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 on: Sep 9, 2024
//      Author: Xiao Cheng, Jiawei Wang
//
#pragma once
 
#include <functional>
 
#include "AE/Core/AbstractState.h"
#include "AE/Core/IntervalValue.h"
#include "SVFIR/SVFIR.h"
#include "Util/GeneralType.h"
 
namespace SVF
{
 
class AbstractInterpretation;
class AbstractState;
class CallICFGNode;
class ICFGNode;
 
class AbsExtAPI
{
public:
    enum ExtAPIType { UNCLASSIFIED, MEMCPY, MEMSET, STRCPY, STRCAT };
 
    // Only AbstractInterpretation may construct the single owned AbsExtAPI
    // instance (reachable through its private getUtils()). Keeping the
    // constructor private prevents external callers from creating their own
    // AbsExtAPI and invoking handleExtAPI()/handleMemcpy()/... directly.
    friend class AbstractInterpretation;
private:
    AbsExtAPI(AbstractInterpretation* ae);
 
public:
    void initExtFunMap();
 
    std::string strRead(const ValVar* rhs, const ICFGNode* node);
 
    void handleExtAPI(const CallICFGNode *call);
 
    // --- Shared primitives used by string/memory handlers ---
 
    u32_t getElementSize(const ValVar* var);
 
    static bool isValidLength(const IntervalValue& len);
 
    IntervalValue getStrlen(const ValVar *strValue, const ICFGNode* node);
 
    // --- String/memory operation handlers ---
 
    void handleStrcpy(const CallICFGNode *call);
    void handleStrcat(const CallICFGNode *call);
    void handleStrncat(const CallICFGNode *call);
    void handleMemcpy(const ValVar *dst, const ValVar *src, const IntervalValue& len, u32_t start_idx, const ICFGNode* node);
    void handleMemset(const ValVar* dst, const IntervalValue& elem, const IntervalValue& len, const ICFGNode* node);
 
    IntervalValue getRangeLimitFromType(const SVFType* type);
 
    AbstractState& getAbsState(const ICFGNode* node);
 
    void collectCheckPoint();
    void checkPointAllSet();
 
    Set<const CallICFGNode*> checkpoints; // for CI check
 
protected:
    AbstractInterpretation* ae; 
    SVFIR* svfir; 
    ICFG* icfg; 
    Map<std::string, std::function<void(const CallICFGNode*)>> func_map; 
};
 
} // namespace SVF