AbstractStateManager.h

Go to the documentation of this file.

//===- AbstractStateManager.h -- State management for abstract execution --//
//
//                     SVF: Static Value-Flow Analysis
//
// Copyright (C) <2013->  <Yulei Sui>
//
 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
 
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
//===----------------------------------------------------------------------===//
//
//  Created on: Mar 2026
//      Author: Jiawei Wang
//
#pragma once
#include "AE/Core/AbstractState.h"
#include "SVFIR/SVFIR.h"
 
namespace SVF
{
 
class GepStmt;
class AddrStmt;
class SVFG;
class AndersenWaveDiff;
 
class AbstractStateManager
{
public:
    AbstractStateManager(SVFIR* svfir, AndersenWaveDiff* pta);
    ~AbstractStateManager();
 
    // ===----------------------------------------------------------------------===//
    //  Abstract Value Access API
    // ===----------------------------------------------------------------------===//
 
    const AbstractValue& getAbstractValue(const ValVar* var, const ICFGNode* node);
 
    const AbstractValue& getAbstractValue(const ObjVar* var, const ICFGNode* node);
 
    const AbstractValue& getAbstractValue(const SVFVar* var, const ICFGNode* node);
 
    bool hasAbstractValue(const ValVar* var, const ICFGNode* node) const;
 
    bool hasAbstractValue(const ObjVar* var, const ICFGNode* node) const;
 
    bool hasAbstractValue(const SVFVar* var, const ICFGNode* node) const;
 
    void updateAbstractValue(const ValVar* var, const AbstractValue& val, const ICFGNode* node);
 
    void updateAbstractValue(const ObjVar* var, const AbstractValue& val, const ICFGNode* node);
 
    void updateAbstractValue(const SVFVar* var, const AbstractValue& val, const ICFGNode* node);
 
    // ===----------------------------------------------------------------------===//
    //  State Access
    // ===----------------------------------------------------------------------===//
 
    AbstractState& getAbstractState(const ICFGNode* node);
    void updateAbstractState(const ICFGNode* node, const AbstractState& state);
 
    bool hasAbstractState(const ICFGNode* node);
 
    void getAbstractState(const Set<const ValVar*>& vars, AbstractState& result, const ICFGNode* node);
    void getAbstractState(const Set<const ObjVar*>& vars, AbstractState& result, const ICFGNode* node);
    void getAbstractState(const Set<const SVFVar*>& vars, AbstractState& result, const ICFGNode* node);
 
    // ===----------------------------------------------------------------------===//
    //  GEP Helpers
    //
    //  Lifted from AbstractState to use getAbstractValue for index variable lookup.
    // ===----------------------------------------------------------------------===//
 
    IntervalValue getGepElementIndex(const GepStmt* gep);
 
    IntervalValue getGepByteOffset(const GepStmt* gep);
 
    AddressValue getGepObjAddrs(const ValVar* pointer, IntervalValue offset);
 
    // ===----------------------------------------------------------------------===//
    //  Load / Store through pointer (combines ValVar lookup + ObjVar access)
    // ===----------------------------------------------------------------------===//
 
    AbstractValue loadValue(const ValVar* pointer, const ICFGNode* node);
 
    void storeValue(const ValVar* pointer, const AbstractValue& val, const ICFGNode* node);
 
    // ===----------------------------------------------------------------------===//
    //  Type / Size Helpers
    // ===----------------------------------------------------------------------===//
 
    const SVFType* getPointeeElement(const ObjVar* var, const ICFGNode* node);
 
    u32_t getAllocaInstByteSize(const AddrStmt* addr);
 
    // ===----------------------------------------------------------------------===//
    //  Direct Trace Access (for merge, fixpoint, etc.)
    // ===----------------------------------------------------------------------===//
 
    Map<const ICFGNode*, AbstractState>& getTrace()
    {
        return abstractTrace;
    }
    AbstractState& operator[](const ICFGNode* node)
    {
        return abstractTrace[node];
    }
 
    // ===----------------------------------------------------------------------===//
    //  Def/Use site queries (sparsity-aware)
    // ===----------------------------------------------------------------------===//
 
    Set<const ICFGNode*> getUseSitesOfObjVar(const ObjVar* obj, const ICFGNode* node) const;
 
    Set<const ICFGNode*> getUseSitesOfValVar(const ValVar* var) const;
 
    const ICFGNode* getDefSiteOfValVar(const ValVar* var) const;
 
    const ICFGNode* getDefSiteOfObjVar(const ObjVar* obj, const ICFGNode* node) const;
 
private:
    SVFIR* svfir;
    SVFG* svfg;
    Map<const ICFGNode*, AbstractState> abstractTrace;
};
 
} // namespace SVF