AbsExtAPI.h

Go to the documentation of this file.

//===- AbsExtAPI.h -- Abstract Interpretation External API handler-----//
//
//                     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 by Jiawei Wang on 2024/9/9.
//
#pragma once
#include "AE/Core/AbstractState.h"
#include "AE/Core/ICFGWTO.h"
#include "AE/Svfexe/AEDetector.h"
#include "AE/Svfexe/AbsExtAPI.h"
#include "Util/SVFBugReport.h"
#include "WPA/Andersen.h"
 
namespace SVF
{
 
// Forward declaration of AbstractInterpretation class
class AbstractInterpretation;
 
class AbsExtAPI
{
public:
    enum ExtAPIType { UNCLASSIFIED, MEMCPY, MEMSET, STRCPY, STRCAT };
 
    AbsExtAPI(Map<const ICFGNode*, AbstractState>& traces);
 
    void initExtFunMap();
 
    std::string strRead(AbstractState& as, const SVFVar* rhs);
 
    void handleExtAPI(const CallICFGNode *call);
 
    void handleStrcpy(const CallICFGNode *call);
 
    IntervalValue getStrlen(AbstractState& as, const SVF::SVFVar *strValue);
 
    void handleStrcat(const SVF::CallICFGNode *call);
 
    void handleMemcpy(AbstractState& as, const SVF::SVFVar *dst, const SVF::SVFVar *src, IntervalValue len, u32_t start_idx);
 
    void handleMemset(AbstractState& as, const SVFVar* dst, IntervalValue elem, IntervalValue len);
 
    IntervalValue getRangeLimitFromType(const SVFType* type);
 
    AbstractState& getAbsStateFromTrace(const ICFGNode* node);
 
    const SVFVar* getSVFVar(const SVFValue* val);
 
protected:
    SVFIR* svfir; 
    ICFG* icfg; 
    Map<const ICFGNode*, AbstractState>& abstractTrace; 
    Map<std::string, std::function<void(const CallICFGNode*)>> func_map; 
};
 
} // namespace SVF