svf-lib 1.0.2319 → 1.0.2321

package/SVF-osx/Release-build/include/SVF/SVF-LLVM/BasicTypes.h

@@ -0,0 +1,280 @@
+//===- BasicTypes.h --Basic Types of SVF-LLVM---------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2022>  <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/>.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SVF_FE_BASIC_TYPES_H
+#define SVF_FE_BASIC_TYPES_H
+
+#include "SVF-LLVM/GEPTypeBridgeIterator.h"
+
+#include <llvm/Pass.h>
+
+#include <llvm/IR/Instructions.h>
+#include <llvm/IR/GetElementPtrTypeIterator.h>	//for gep iterator
+#include <llvm/IR/GlobalVariable.h>	// for GlobalVariable
+#include <llvm/IR/BasicBlock.h>
+#include <llvm/IR/IntrinsicInst.h>
+#include <llvm/IR/LLVMContext.h>
+#include <llvm/IR/Metadata.h>
+#include <llvm/IR/DataLayout.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/DebugInfo.h>
+#include <llvm/IR/InstIterator.h>
+#include <llvm/IR/GetElementPtrTypeIterator.h>
+#include <llvm/IR/DerivedTypes.h>
+#include <llvm/IR/Statepoint.h>
+#include <llvm/IR/Intrinsics.h>
+
+#include <llvm/Analysis/MemoryLocation.h>
+#include <llvm/Analysis/DominanceFrontier.h>
+#include <llvm/Analysis/PostDominators.h>
+#include <llvm/Analysis/ScalarEvolution.h>
+#include <llvm/Analysis/ScalarEvolutionExpressions.h>
+
+#include <llvm/Transforms/Utils/UnifyFunctionExitNodes.h>
+
+#include <llvm/Support/SourceMgr.h>
+
+#include <llvm/Bitcode/BitcodeWriter.h>		// for WriteBitcodeToFile
+#include <llvm/Bitcode/BitcodeReader.h>     /// for isBitcode
+#include <llvm/IRReader/IRReader.h>	// IR reader for bit file
+#include <llvm/IR/InstVisitor.h>	// for instruction visitor
+#include <llvm/IR/InstIterator.h>	// for inst iteration
+
+#include <llvm/BinaryFormat/Dwarf.h> // for dwarf tags
+
+#include <llvm/Analysis/LoopInfo.h>
+#include <llvm/Demangle/Demangle.h>
+
+namespace SVF
+{
+
+typedef llvm::LLVMContext LLVMContext;
+typedef llvm::GlobalObject GlobalObject;
+typedef llvm::Use Use;
+typedef llvm::ModulePass ModulePass;
+typedef llvm::IRBuilder<> IRBuilder;
+#if LLVM_VERSION_MAJOR >= 12
+typedef llvm::UnifyFunctionExitNodesLegacyPass UnifyFunctionExitNodes;
+#else
+typedef llvm::UnifyFunctionExitNodes UnifyFunctionExitNodes;
+#endif
+
+/// LLVM Basic classes
+typedef llvm::Value Value;
+typedef llvm::Type Type;
+typedef llvm::Module Module;
+typedef llvm::Function Function;
+typedef llvm::BasicBlock BasicBlock;
+typedef llvm::Instruction Instruction;
+typedef llvm::GlobalValue GlobalValue;
+
+typedef llvm::SMDiagnostic SMDiagnostic;
+typedef llvm::BlockAddress BlockAddress;
+
+/// LLVM types
+typedef llvm::StructType StructType;
+typedef llvm::ArrayType ArrayType;
+typedef llvm::PointerType PointerType;
+typedef llvm::IntegerType IntegerType;
+typedef llvm::FunctionType FunctionType;
+
+// LLVM Metadata
+typedef llvm::MDString MDString;
+typedef llvm::MetadataAsValue MetadataAsValue;
+
+// LLVM data layout
+typedef llvm::StructLayout StructLayout;
+typedef llvm::ConstantStruct ConstantStruct;
+typedef llvm::MemoryLocation MemoryLocation;
+typedef llvm::DataLayout DataLayout;
+
+/// LLVM metadata and debug information
+typedef llvm::NamedMDNode NamedMDNode;
+typedef llvm::MDNode MDNode;
+typedef llvm::DISubprogram DISubprogram;
+
+// LLVM Aliases and constants
+typedef llvm::ConstantData ConstantData;
+typedef llvm::ConstantAggregate ConstantAggregate;
+typedef llvm::ConstantAggregateZero ConstantAggregateZero;
+typedef llvm::ConstantDataSequential ConstantDataSequential;
+typedef llvm::ConstantExpr ConstantExpr;
+typedef llvm::ConstantDataArray ConstantDataArray;
+typedef llvm::ConstantData ConstantData;
+typedef llvm::ConstantArray ConstantArray;
+typedef llvm::Constant Constant;
+typedef llvm::ConstantInt ConstantInt;
+typedef llvm::ConstantFP ConstantFP;
+typedef llvm::ConstantPointerNull ConstantPointerNull;
+typedef llvm::GlobalAlias GlobalAlias;
+typedef llvm::GlobalIFunc GlobalIFunc;
+typedef llvm::GlobalVariable GlobalVariable;
+
+/// LLVM Dominators
+typedef llvm::DominatorTree DominatorTree;
+typedef llvm::DomTreeNode DomTreeNode;
+typedef llvm::DominanceFrontier DominanceFrontier;
+typedef llvm::PostDominatorTree PostDominatorTree;
+typedef llvm::DominanceFrontierBase<llvm::BasicBlock, false> DominanceFrontierBase;
+
+/// LLVM Loop
+typedef llvm::Loop Loop;
+typedef llvm::LoopInfo LoopInfo;
+typedef llvm::User User;
+
+// LLVM Instructions
+typedef llvm::Argument Argument;
+typedef llvm::CallBase CallBase;
+typedef llvm::CallInst CallInst;
+typedef llvm::StoreInst StoreInst;
+typedef llvm::LoadInst LoadInst;
+typedef llvm::AllocaInst AllocaInst;
+typedef llvm::AtomicCmpXchgInst AtomicCmpXchgInst;
+typedef llvm::AtomicRMWInst AtomicRMWInst;
+typedef llvm::BitCastInst BitCastInst;
+typedef llvm::BranchInst BranchInst;
+typedef llvm::SwitchInst SwitchInst;
+typedef llvm::CallBrInst CallBrInst;
+typedef llvm::ReturnInst ReturnInst;
+typedef llvm::CastInst CastInst;
+typedef llvm::CmpInst CmpInst;
+typedef llvm::ExtractValueInst  ExtractValueInst;
+typedef llvm::ExtractElementInst ExtractElementInst;
+typedef llvm::GetElementPtrInst GetElementPtrInst;
+typedef llvm::InvokeInst InvokeInst;
+typedef llvm::ShuffleVectorInst ShuffleVectorInst;
+typedef llvm::PHINode PHINode;
+typedef llvm::IntToPtrInst IntToPtrInst;
+typedef llvm::InsertValueInst InsertValueInst;
+typedef llvm::FenceInst FenceInst;
+typedef llvm::FreezeInst FreezeInst;
+typedef llvm::UnreachableInst UnreachableInst;
+typedef llvm::InsertElementInst InsertElementInst;
+typedef llvm::LandingPadInst LandingPadInst;
+typedef llvm::ResumeInst ResumeInst;
+typedef llvm::SelectInst SelectInst;
+typedef llvm::VAArgInst VAArgInst;
+typedef llvm::VACopyInst VACopyInst;
+typedef llvm::VAEndInst VAEndInst;
+typedef llvm::VAStartInst VAStartInst;
+typedef llvm::BinaryOperator BinaryOperator;
+typedef llvm::UnaryOperator UnaryOperator;
+typedef llvm::UndefValue UndefValue;
+typedef llvm::GEPOperator GEPOperator;
+
+// Related to Switch Case
+typedef std::pair<const BasicBlock*, const ConstantInt*> SuccBBAndCondValPair;
+typedef std::vector<SuccBBAndCondValPair> SuccBBAndCondValPairVec;
+
+// LLVM Intrinsic Instructions
+#if LLVM_VERSION_MAJOR >= 13
+typedef llvm::IntrinsicInst IntrinsicInst;
+typedef llvm::DbgInfoIntrinsic DbgInfoIntrinsic;
+typedef llvm::DbgVariableIntrinsic DbgVariableIntrinsic;
+typedef llvm::DbgDeclareInst DbgDeclareInst;
+typedef llvm::DbgInfoIntrinsic DbgInfoIntrinsic;
+typedef llvm::DbgValueInst DbgValueInst;
+typedef llvm::DbgLabelInst DbgLabelInst;
+typedef llvm::VPIntrinsic VPIntrinsic;
+typedef llvm::ConstrainedFPIntrinsic ConstrainedFPIntrinsic;
+typedef llvm::ConstrainedFPCmpIntrinsic ConstrainedFPCmpIntrinsic;
+typedef llvm::MinMaxIntrinsic MinMaxIntrinsic;
+typedef llvm::BinaryOpIntrinsic BinaryOpIntrinsic;
+typedef llvm::WithOverflowInst WithOverflowInst;
+typedef llvm::SaturatingInst SaturatingInst;
+typedef llvm::AtomicMemIntrinsic AtomicMemIntrinsic;
+typedef llvm::AtomicMemSetInst AtomicMemSetInst;
+typedef llvm::AtomicMemTransferInst AtomicMemTransferInst;
+typedef llvm::AtomicMemCpyInst AtomicMemCpyInst;
+typedef llvm::AtomicMemMoveInst AtomicMemMoveInst;
+typedef llvm::MemIntrinsic MemIntrinsic;
+typedef llvm::MemSetInst MemSetInst;
+typedef llvm::MemTransferInst MemTransferInst;
+typedef llvm::MemCpyInst MemCpyInst;
+typedef llvm::MemMoveInst MemMoveInst;
+typedef llvm::MemCpyInlineInst MemCpyInlineInst;
+typedef llvm::AnyMemIntrinsic AnyMemIntrinsic;
+typedef llvm::AnyMemSetInst AnyMemSetInst;
+typedef llvm::AnyMemTransferInst AnyMemTransferInst;
+typedef llvm::AnyMemCpyInst AnyMemCpyInst;
+typedef llvm::AnyMemMoveInst AnyMemMoveInst;
+typedef llvm::VAStartInst VAStartInst;
+typedef llvm::VAEndInst VAEndInst;
+typedef llvm::VACopyInst VACopyInst;
+typedef llvm::InstrProfIncrementInst InstrProfIncrementInst;
+typedef llvm::InstrProfIncrementInstStep InstrProfIncrementInstStep;
+typedef llvm::InstrProfValueProfileInst InstrProfValueProfileInst;
+typedef llvm::PseudoProbeInst PseudoProbeInst;
+typedef llvm::NoAliasScopeDeclInst NoAliasScopeDeclInst;
+typedef llvm::GCStatepointInst GCStatepointInst;
+typedef llvm::GCProjectionInst GCProjectionInst;
+typedef llvm::GCRelocateInst GCRelocateInst;
+typedef llvm::GCResultInst GCResultInst;
+typedef llvm::AssumeInst AssumeInst;
+#endif
+
+// LLVM Debug Information
+typedef llvm::DIType DIType;
+typedef llvm::DICompositeType DICompositeType;
+typedef llvm::DIDerivedType DIDerivedType;
+typedef llvm::DebugInfoFinder DebugInfoFinder;
+typedef llvm::DISubroutineType DISubroutineType;
+typedef llvm::DIBasicType DIBasicType;
+typedef llvm::DISubrange DISubrange;
+typedef llvm::DINode DINode;
+typedef llvm::DINodeArray DINodeArray;
+typedef llvm::DITypeRefArray DITypeRefArray;
+namespace dwarf = llvm::dwarf;
+
+// Iterators.
+typedef llvm::inst_iterator inst_iterator;
+typedef llvm::const_inst_iterator const_inst_iterator;
+typedef llvm::gep_type_iterator gep_type_iterator;
+typedef llvm::bridge_gep_iterator bridge_gep_iterator;
+typedef llvm::const_inst_iterator const_inst_iterator;
+typedef llvm::const_pred_iterator const_pred_iterator;
+
+// LLVM Scalar Evolution.
+typedef llvm::ScalarEvolutionWrapperPass ScalarEvolutionWrapperPass;
+typedef llvm::SCEVAddRecExpr SCEVAddRecExpr;
+typedef llvm::SCEVConstant SCEVConstant;
+typedef llvm::ScalarEvolution ScalarEvolution;
+typedef llvm::SCEV SCEV;
+
+/// LLVM outputs
+typedef llvm::raw_fd_ostream raw_fd_ostream;
+
+// LLVM Types.
+typedef llvm::VectorType VectorType;
+#if (LLVM_VERSION_MAJOR >= 9)
+typedef llvm::FunctionCallee FunctionCallee;
+#endif
+
+/// LLVM Iterators
+#if LLVM_VERSION_MAJOR >= 11
+typedef llvm::const_succ_iterator succ_const_iterator;
+#else
+typedef llvm::succ_const_iterator succ_const_iterator;
+#endif
+} // End namespace SVF
+
+#endif  // SVF_FE_BASIC_TYPES_H

package/SVF-osx/Release-build/include/SVF/SVF-LLVM/BreakConstantExpr.h

@@ -0,0 +1,93 @@
+//===- BreakConstantGEPs.h - Change constant GEPs into GEP instructions --- --//
+//
+//                          The SAFECode Compiler
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass changes all GEP constant expressions into GEP instructions.  This
+// permits the rest of SAFECode to put run-time checks on them if necessary.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef BREAKCONSTANTGEPS_H
+#define BREAKCONSTANTGEPS_H
+
+
+namespace SVF
+{
+
+//
+// Pass: BreakConstantGEPs
+//
+// Description:
+//  This pass modifies a function so that it uses GEP instructions instead of
+//  GEP constant expressions.
+//
+class BreakConstantGEPs : public ModulePass
+{
+private:
+    // Private methods
+
+    // Private variables
+
+public:
+    static char ID;
+    BreakConstantGEPs() : ModulePass(ID) {}
+    llvm::StringRef getPassName() const
+    {
+        return "Remove Constant GEP Expressions";
+    }
+    virtual bool runOnModule (Module & M);
+};
+
+
+//
+// Pass: MergeFunctionRets
+//
+// Description:
+//  This pass modifies a function so that each function only have one unified exit basic block
+//
+class MergeFunctionRets : public ModulePass
+{
+private:
+    // Private methods
+
+    // Private variables
+
+public:
+    static char ID;
+    MergeFunctionRets() : ModulePass(ID) {}
+    llvm::StringRef getPassName() const
+    {
+        return "unify function exit into one dummy exit basic block";
+    }
+    virtual bool runOnModule (Module & M)
+    {
+        UnifyFunctionExit(M);
+        return true;
+    }
+    inline void UnifyFunctionExit(Module& module)
+    {
+        for (Module::const_iterator iter = module.begin(), eiter = module.end();
+                iter != eiter; ++iter)
+        {
+            const Function& fun = *iter;
+            if(fun.isDeclaration())
+                continue;
+            getUnifyExit(fun)->runOnFunction(const_cast<Function&>(fun));
+        }
+    }
+    /// Get Unified Exit basic block node
+    inline UnifyFunctionExitNodes* getUnifyExit(const Function& fn)
+    {
+        assert(!fn.isDeclaration() && "external function does not have DF");
+        return &getAnalysis<UnifyFunctionExitNodes>(const_cast<Function&>(fn));
+    }
+};
+
+} // End namespace SVF
+
+#endif

package/SVF-osx/Release-build/include/SVF/SVF-LLVM/CHGBuilder.h

@@ -0,0 +1,78 @@
+//===----- CHGBuiler.h -- Class hierarchy graph builder ---------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CHGBuiler.h
+ *
+ *  Created on: Jun 4, 2021
+ *      Author: Yulei Sui
+ */
+
+#include "Graphs/CHG.h"
+#include "SVF-LLVM/BasicTypes.h"
+
+namespace SVF
+{
+
+class LLVMModuleSet;
+
+class CHGBuilder
+{
+
+private:
+    CHGraph* chg;
+
+public:
+    typedef CHGraph::CHNodeSetTy CHNodeSetTy;
+    typedef CHGraph::WorkList WorkList;
+
+    CHGBuilder(CHGraph* c): chg(c)
+    {
+
+    }
+    void buildCHG();
+    void buildCHGNodes(const GlobalValue *V);
+    void buildCHGNodes(const Function* F);
+    void buildCHGEdges(const Function* F);
+    void buildInternalMaps();
+    void readInheritanceMetadataFromModule(const Module &M);
+
+    CHNode *createNode(const std::string& name);
+
+    void connectInheritEdgeViaCall(const Function* caller, const CallBase* cs);
+    void connectInheritEdgeViaStore(const Function* caller, const StoreInst* store);
+
+    void buildClassNameToAncestorsDescendantsMap();
+    const CHGraph::CHNodeSetTy& getInstancesAndDescendants(const std::string& className);
+
+    void analyzeVTables(const Module &M);
+    void buildVirtualFunctionToIDMap();
+    void buildCSToCHAVtblsAndVfnsMap();
+    const CHNodeSetTy& getCSClasses(const CallBase* cs);
+    void addFuncToFuncVector(CHNode::FuncVector &v, const Function *f);
+
+private:
+    LLVMModuleSet* llvmModuleSet();
+};
+
+} // End namespace SVF
+

package/SVF-osx/Release-build/include/SVF/SVF-LLVM/CppUtil.h

@@ -0,0 +1,184 @@
+//===- CPPUtil.h -- Base class of pointer analyses ---------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2017>  <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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * CPPUtil.h
+ *
+ *  Created on: Apr 13, 2016
+ *      Author: Xiaokang Fan
+ */
+
+#ifndef CPPUtil_H_
+#define CPPUtil_H_
+
+#include "SVF-LLVM/BasicTypes.h"
+#include "Util/GeneralType.h"
+
+namespace SVF
+{
+
+class CHGraph;
+/*
+ * Util class to assist pointer analysis for cpp programs
+ */
+
+namespace cppUtil
+{
+
+struct DemangledName
+{
+    std::string className;
+    std::string funcName;
+    bool isThunkFunc;
+};
+
+struct DemangledName demangle(const std::string& name);
+
+
+Set<std::string> getClsNamesInBrackets(const std::string& name);
+
+std::string getBeforeBrackets(const std::string& name);
+std::string getClassNameFromVtblObj(const std::string& vtblName);
+
+/*
+ * Get the vtable struct of a class.
+ *
+ * Given the class:
+ *
+ *   class A {
+ *     virtual ~A();
+ *   };
+ *   A::~A() = default;
+ *
+ *  The corresponding vtable @_ZTV1A is of type:
+ *
+ *    { [4 x i8*] }
+ *
+ *  If the program has been compiled with AddressSanitizer,
+ *  the vtable will have redzones and appear as:
+ *
+ *    { { [4 x i8*] }, [32 x i8] }
+ *
+ *  See https://github.com/SVF-tools/SVF/issues/1114 for more.
+ */
+const ConstantStruct *getVtblStruct(const GlobalValue *vtbl);
+
+bool isValVtbl(const Value* val);
+bool isVirtualCallSite(const CallBase* cs);
+bool isConstructor(const Function* F);
+bool isDestructor(const Function* F);
+bool isCPPThunkFunction(const Function* F);
+const Function* getThunkTarget(const Function* F);
+
+/*
+ * VtableA = {&A::foo}
+ * A::A(this){
+ *   *this = &VtableA;
+ * }
+ *
+ *
+ * A* p = new A;
+ * cs: p->foo(...)
+ * ==>
+ *  vtptr = *p;
+ *  vfn = &vtptr[i]
+ *  %funp = *vfn
+ *  call %funp(p,...)
+ * getConstructorThisPtr(A) return "this" pointer
+ * getVCallThisPtr(cs) return p (this pointer)
+ * getVCallVtblPtr(cs) return vtptr
+ * getVCallIdx(cs) return i
+ * getClassNameFromVtblObj(VtableA) return
+ * getClassNameFromType(type of p) return type A
+ */
+const Argument* getConstructorThisPtr(const Function* fun);
+const Value* getVCallThisPtr(const CallBase* cs);
+const Value* getVCallVtblPtr(const CallBase* cs);
+s32_t getVCallIdx(const CallBase* cs);
+bool classTyHasVTable(const StructType* ty);
+std::string getClassNameFromType(const StructType* ty);
+Set<std::string> getClassNameOfThisPtr(const CallBase* cs);
+std::string getFunNameOfVCallSite(const CallBase* cs);
+bool VCallInCtorOrDtor(const CallBase* cs);
+
+/*
+ *  A(A* this){
+ *      store this this.addr;
+ *      tmp = load this.addr;
+ *      this1 = bitcast(tmp);
+ *      B(this1);
+ *  }
+ *  this and this1 are the same thisPtr in the constructor
+ */
+bool isSameThisPtrInConstructor(const Argument* thisPtr1,
+                                const Value* thisPtr2);
+
+/// extract class name from the c++ function name, e.g., constructor/destructors
+Set<std::string> extractClsNamesFromFunc(const Function *foo);
+
+/// extract class names from template functions
+Set<std::string> extractClsNamesFromTemplate(const std::string &oname);
+
+/// class sources can be heap allocation
+/// or functions where we can extract the class name (constructors/destructors or template functions)
+bool isClsNameSource(const Value *val);
+
+/// whether foo matches the mangler label
+bool matchesLabel(const std::string &foo, const std::string &label);
+
+/// whether foo is a cpp template function
+bool isTemplateFunc(const Function *foo);
+
+/// whether foo is a cpp dyncast function
+bool isDynCast(const Function *foo);
+
+/// extract class name from cpp dyncast function
+std::string extractClsNameFromDynCast(const CallBase* callBase);
+
+const Type *cppClsNameToType(const std::string &className);
+
+
+
+/// Constants pertaining to CTir, for C and C++.
+/// TODO: move helper functions here too?
+namespace ctir
+{
+/// On loads, stores, GEPs representing dereferences, and calls
+/// representing virtual calls.
+/// (The static type.)
+const std::string derefMDName = "ctir";
+/// On the (global) virtual table itself.
+/// (The class it corresponds to.)
+const std::string vtMDName = "ctir.vt";
+/// On the bitcast of `this` to i8*.
+/// (The class the constructor it corresponds to.)
+const std::string vtInitMDName = "ctir.vt.init";
+
+/// Value we expect a ctir-annotated module to have.
+const uint32_t moduleFlagValue = 1;
+} // namespace ctir
+
+} // End namespace cppUtil
+
+} // End namespace SVF
+
+#endif /* CPPUtil_H_ */