From 75b8c3b26b558cae9f63469377684a92f6febf0a Mon Sep 17 00:00:00 2001 From: Aditi Date: Thu, 27 May 2021 21:55:13 +0530 Subject: [PATCH 1/4] Trial Push: LFCPAInstModel.h --- lib/InstModel/LFCPAInstModel/LFCPAInstModel.h | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 lib/InstModel/LFCPAInstModel/LFCPAInstModel.h diff --git a/lib/InstModel/LFCPAInstModel/LFCPAInstModel.h b/lib/InstModel/LFCPAInstModel/LFCPAInstModel.h new file mode 100644 index 0000000..51e3590 --- /dev/null +++ b/lib/InstModel/LFCPAInstModel/LFCPAInstModel.h @@ -0,0 +1,48 @@ +#ifndef LFCPAINSTMODEL_LFCPAINSTMODEL_H +#define LFCPAINSTMODEL_LFCPAINSTMODEL_H + +#include "spatial/InstInfo/InstInfo.h" +#include "spatial/InstModel/InstModel.h" +#include "spatial/Token/Token.h" +#include "vector" +#include "llvm/IR/Argument.h" +#include "llvm/IR/Function.h" +#include "llvm/IR/GlobalVariable.h" +#include "llvm/IR/Instruction.h" +#include "llvm/IR/Instructions.h" +#include "llvm/IR/Operator.h" + +namespace spatial { + +class LFCPAInstModel : public InstModel { + std::map InstInfoMap; +public: + using InstModel::InstModel; + + ~LFCPAInstModel(); + std::vector extractRedirections(llvm::Instruction *); + InstInfo extractInstInfo(llvm::Instruction *); + + std::vector extractToken(llvm::Instruction *); + std::vector extractToken(llvm::StoreInst *); + std::vector extractToken(llvm::LoadInst *); + std::vector extractToken(llvm::AllocaInst *); + std::vector extractToken(llvm::BitCastInst *); + std::vector extractToken(llvm::ReturnInst *); + std::vector extractToken(llvm::GetElementPtrInst *); + std::vector extractToken(llvm::GlobalVariable *); + std::vector extractToken(llvm::CallInst *); + std::vector extractToken(llvm::CmpInst *); + std::vector extractToken(llvm::Argument *, llvm::Function *); + + std::vector extractRedirections(llvm::GlobalVariable *); + template Token *handleGEPUtil(GEP *, Token *); + spatial::InstInfo* getInstInfo(llvm::Instruction *); + bool isInstSkip (llvm::Instruction *); + void printInstInfoMap(); + template bool isStructFieldPointerTy(GOP *); + Token* extractDummy(std::string); +}; +} // namespace spatial + +#endif From 75db131d493d9941ce079897dfcb0179ce57da5a Mon Sep 17 00:00:00 2001 From: Aditi Date: Wed, 2 Jun 2021 08:06:34 +0530 Subject: [PATCH 2/4] commit LFCPAInstModel --- .../InstModel/LFCPAInstModel/LFCPAInstModel.h | 3 +- lib/CMakeLists.txt | 2 +- lib/InstModel/CMakeLists.txt | 1 + lib/InstModel/LFCPAInstModel/CMakeLists.txt | 7 + .../LFCPAInstModel/LFCPAInstModel.cpp | 455 ++++++++++++++++++ 5 files changed, 465 insertions(+), 3 deletions(-) rename {lib => include}/InstModel/LFCPAInstModel/LFCPAInstModel.h (95%) create mode 100644 lib/InstModel/LFCPAInstModel/CMakeLists.txt create mode 100644 lib/InstModel/LFCPAInstModel/LFCPAInstModel.cpp diff --git a/lib/InstModel/LFCPAInstModel/LFCPAInstModel.h b/include/InstModel/LFCPAInstModel/LFCPAInstModel.h similarity index 95% rename from lib/InstModel/LFCPAInstModel/LFCPAInstModel.h rename to include/InstModel/LFCPAInstModel/LFCPAInstModel.h index 51e3590..0c3a522 100644 --- a/lib/InstModel/LFCPAInstModel/LFCPAInstModel.h +++ b/include/InstModel/LFCPAInstModel/LFCPAInstModel.h @@ -37,9 +37,8 @@ class LFCPAInstModel : public InstModel { std::vector extractRedirections(llvm::GlobalVariable *); template Token *handleGEPUtil(GEP *, Token *); - spatial::InstInfo* getInstInfo(llvm::Instruction *); + Token * handleGEPUtil_1(llvm::GEPOperator *, Token *); bool isInstSkip (llvm::Instruction *); - void printInstInfoMap(); template bool isStructFieldPointerTy(GOP *); Token* extractDummy(std::string); }; diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index ad08a8b..0d12ae2 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -6,7 +6,7 @@ add_subdirectory(InstInfo) add_subdirectory(InstModel) # TODO: Write this in multiple lines -add_library (Spatial SHARED $ $ $ $ $ $ $) +add_library (Spatial SHARED $ $ $ $ $ $ $ $) set_target_properties(Spatial PROPERTIES SOVERSION 0 diff --git a/lib/InstModel/CMakeLists.txt b/lib/InstModel/CMakeLists.txt index 43a8bfc..49bc772 100644 --- a/lib/InstModel/CMakeLists.txt +++ b/lib/InstModel/CMakeLists.txt @@ -7,3 +7,4 @@ set_target_properties(InstModel PROPERTIES ) add_subdirectory(GenericInstModel) +add_subdirectory(LFCPAInstModel) diff --git a/lib/InstModel/LFCPAInstModel/CMakeLists.txt b/lib/InstModel/LFCPAInstModel/CMakeLists.txt new file mode 100644 index 0000000..30f7a21 --- /dev/null +++ b/lib/InstModel/LFCPAInstModel/CMakeLists.txt @@ -0,0 +1,7 @@ +add_library (LFCPAInstModel OBJECT + LFCPAInstModel.cpp +) + +set_target_properties(LFCPAInstModel PROPERTIES + COMPILE_FLAGS "-g -std=c++14 -fno-rtti -fPIC" +) diff --git a/lib/InstModel/LFCPAInstModel/LFCPAInstModel.cpp b/lib/InstModel/LFCPAInstModel/LFCPAInstModel.cpp new file mode 100644 index 0000000..5f422cb --- /dev/null +++ b/lib/InstModel/LFCPAInstModel/LFCPAInstModel.cpp @@ -0,0 +1,455 @@ +#include "InstModel/LFCPAInstModel/LFCPAInstModel.h" +#include "InstInfo/InstInfo.h" +#include "vector" +#include "queue" + +namespace spatial { + +/// extractInstInfo - Returns empty InstInfo for every instruction as it is not +/// support right now +InstInfo LFCPAInstModel::extractInstInfo(llvm::Instruction *) { + InstInfo II; + return II; +} + +/// extractToken - Returns a vector of alias objects derived from +/// Instruction \Inst operands +std::vector LFCPAInstModel::extractToken(llvm::Instruction *Inst) { + if (llvm::StoreInst *SI = llvm::dyn_cast(Inst)) { + return extractToken(SI); + } else if (llvm::LoadInst *LI = llvm::dyn_cast(Inst)) { + return extractToken(LI); + } else if (llvm::AllocaInst *AI = llvm::dyn_cast(Inst)) { + return extractToken(AI); + } else if (llvm::BitCastInst *BI = llvm::dyn_cast(Inst)) { + return extractToken(BI); + } else if (llvm::ReturnInst *RI = llvm::dyn_cast(Inst)) { + return extractToken(RI); + } else if (llvm::GetElementPtrInst *GEP = + llvm::dyn_cast(Inst)) { + return extractToken(GEP); + } else if (llvm::CmpInst *CM = llvm::dyn_cast(Inst)) { + return extractToken(CM); + } else if (llvm::CallInst *CI = llvm::dyn_cast(Inst)) { + return extractToken(CI); + } else { + // Direct support to some instructions may not be useful example + // CallInst, as it is more useful to generate alias object for call + // arguments on the fly + llvm::errs() << "[TODO]: Unsupported Instruction " << *Inst << "\n"; + } + return {}; +} + +/// extractToken - Returns a vector of alias objects derived from +/// Global variable \Global operands +std::vector +LFCPAInstModel::extractToken(llvm::GlobalVariable *Global) { + std::vector TokenVec; + if (Global->hasName() && !Global->getName().startswith("_")) { + TokenVec.push_back(this->getTokenWrapper()->getToken(Global)); + TokenVec.push_back(this->getTokenWrapper()->getToken( + Global->getName().str() + "-orig", nullptr)); + } + return TokenVec; +} + + +/// extractToken - Returns a vector of alias objects for StoreInst \Inst +/// operands. +std::vector LFCPAInstModel::extractToken(llvm::StoreInst *Inst) { + // The operands are returned in the same order as they are present in the + // instruction example store op1 op2 + + std::vector TokenVec; + //Check for store to non-pointers + if (llvm::isa(Inst->getOperand(1))) { + llvm::GEPOperator *GOP = llvm::dyn_cast(Inst->getOperand(1)); + + if (isStructFieldPointerTy(GOP)) { + Token* opLhs = handleGEPUtil_1(GOP, this->getTokenWrapper()->getToken(Inst->getPointerOperand())); + TokenVec.push_back(opLhs); + llvm::Value *ValOp = Inst->getValueOperand(); + if (!llvm::isa(ValOp)) + TokenVec.push_back(this->getTokenWrapper()->getToken(ValOp)); + }//end if + else { + InstInfo *II = new InstInfo(); + II->setSkipInst(); + }//end else + }//end outer if + else if (this->getTokenWrapper()->getToken(Inst->getPointerOperand())->isBasePointerType()) { /* Ignore Stores to non-pointers */ + TokenVec.push_back(this->getTokenWrapper()->getToken(Inst->getPointerOperand())); + llvm::Value *ValOp = Inst->getValueOperand(); + if (!llvm::isa(ValOp)) + TokenVec.push_back(this->getTokenWrapper()->getToken(ValOp)); + } + else { + InstInfo *II = new InstInfo(); + II->setSkipInst(); + } + return TokenVec; +} + + + +/// extractToken - Returns a vector of alias objects for LoadInst \Inst +/// operands. +std::vector LFCPAInstModel::extractToken(llvm::LoadInst *Inst) { + // The operands are returned in the same order as they are present in the + // instruction example x = load op1 + +std::vector TokenVec; +//Check for load of non-pointers +if (llvm::isa(Inst->getPointerOperand())) { + llvm::GEPOperator *GOP = llvm::dyn_cast(Inst->getOperand(0)); + if (isStructFieldPointerTy(GOP)) { + TokenVec.push_back(this->getTokenWrapper()->getToken(Inst)); + TokenVec.push_back(this->getTokenWrapper()->getToken(Inst->getPointerOperand())); + }//end if + else { + InstInfo *II = new InstInfo(); + II->setSkipInst(); + }//end else +}//end outer if +else if (this->getTokenWrapper()->getToken(Inst->getPointerOperand())->isBasePointerType()) { /* Ignore load of non-pointers */ + TokenVec.push_back(this->getTokenWrapper()->getToken(Inst)); + TokenVec.push_back(this->getTokenWrapper()->getToken(Inst->getPointerOperand())); +} +else { + InstInfo *II = new InstInfo(); + II->setSkipInst(); +} +return TokenVec; +} + +/// extractToken - Returns a vector of alias objects for AllocaInst \Inst +/// operands. +std::vector LFCPAInstModel::extractToken(llvm::AllocaInst *Inst) { + // The operands are returned in the same order as they are present in the + // instruction example x = alloca op1 + std::vector TokenVec; + Token *Alloca = this->getTokenWrapper()->getToken(Inst); + TokenVec.push_back(Alloca); + TokenVec.push_back(this->getTokenWrapper()->getToken( + Alloca->getName().str() + "-orig", Inst->getParent()->getParent())); + return TokenVec; +} + + +/// extractToken - Returns a vector of Token objects for CmpInst \Inst +/// operands. +/* Compare Instruction is not skipped but the Load instrs for loading the operand value are skipped */ +std::vector LFCPAInstModel::extractToken(llvm::CmpInst *Inst) { + + InstInfo *II = new InstInfo(); + II->setSkipInst(); + + bool skipFlag = false; + std::vector TokenVec; + llvm::Instruction* Ins, *I; + Ins = llvm::dyn_cast(Inst); + std::queue q; + +/* if (Ins->getOperand(0) == NULL) + llvm::errs()<<"\n Op 0 is NULL"; + + if (Ins->getOperand(1) == NULL) + llvm::errs()<<"\n Op 1 is NULL"; + +//Check if operand value is NULL + llvm::Constant *constOp0 = llvm::dyn_cast(Ins->getOperand(0)); + llvm::Constant *constOp1 = llvm::cast(Ins->getOperand(1)); + +// if (constOp0->llvm::Constant::isNullValue()) +// llvm::errs()<<"\n Op 0 is NULL"; + + if (constOp1->llvm::Constant::isNullValue()) + llvm::errs()<<"\n Op 1 is NULL"; + + //if(constVal->llvm::Constant::isNullValue()) + // llvm::errs()<<"\n INSTR operand is NULL"; + +// if (!constVal->llvm::Constant::isNullValue()) { + // } + +*/ + for (llvm::Use &U : Ins->operands()) { + + llvm::Value* v = U.get(); +// llvm::errs()<<"\n VALUE= "<<*v; + + I = llvm::dyn_cast(v); + q.push(I); + + + while(!q.empty()) { + llvm::Instruction *I = q.front(); + q.pop(); + if (llvm::isa(I)) { + if (llvm::isa(I->getOperand(0))) { + if (I->getOperand(0)->getType()->getContainedType(0)->isPointerTy()) { + //Global + Ptr + llvm::LoadInst *loadI = llvm::dyn_cast(I); + llvm::Value *OpVal = loadI->getOperand(0); + TokenVec.push_back(this->getTokenWrapper()->getToken(OpVal)); + InstInfoMap[I]= II; + } + else { + //Global + not a ptr + InstInfoMap[I]= II; + } + }//end if + else { + for (llvm::Use &U : I->operands()) { + llvm::Value* v = U.get(); + // llvm::errs()<<"\n VALUE= "<<*v; + llvm::Instruction *I1 = llvm::dyn_cast(v); + q.push(I1); + } + } + }//end if load + }//end while + } + return TokenVec; +} + +/// extractToken - Returns a vector of Token objects for ReturnInst \Inst +/// operands. + +/* Return Instruction is not skipped but the Load instrs for loading the return value are skipped */ +std::vector LFCPAInstModel::extractToken(llvm::ReturnInst *Inst) { + // The original pointer operand is returned for the + // instruction example return *op1 + InstInfo *II = new InstInfo(); + II->setSkipInst(); + bool skipFlag = false; + llvm::Instruction *I, *Ins; + std::vector TokenVec; + llvm::Value *RetVal = Inst->getReturnValue(); +// auto undef = llvm::UndefValue::get(RetVal->getType()); + + if (RetVal->getName() == "") { + InstInfoMap[Inst] = II; + auto bit = II->isSkipInst(); + } + else if (RetVal && !llvm::isa(RetVal)) { + Ins = llvm::dyn_cast(Inst); + while(!skipFlag) { + for (llvm::Use &U : Ins->operands()) { + llvm::Value* v = U.get(); + I = llvm::dyn_cast(v); + if (llvm::isa(I)) + { + if (llvm::isa(I->getOperand(0))) { + if (I->getOperand(0)->getType()->getContainedType(0)->isPointerTy()) { + llvm::LoadInst *loadI = llvm::dyn_cast(I); + llvm::Value *OpVal = loadI->getOperand(0); + + TokenVec.push_back(this->getTokenWrapper()->getToken(OpVal)); + InstInfoMap[I]= II; //Load global instr is skipped + skipFlag = true; + }//end if + else { + InstInfoMap[I]= II; + skipFlag = true; + auto bit = II->isSkipInst(); + break; + }//end else + }//end if ptr + else { + InstInfoMap[I]= II; + Ins = I; + }//end else + }//end if load + }//end for + }//end while + }//end if + else + InstInfoMap[Inst]= II; + return TokenVec; +} + +/// extractToken - Returns a vector of alias objects for BitCastInst \Inst +/// operands. +std::vector LFCPAInstModel::extractToken(llvm::BitCastInst *Inst) { + // The operands are returned in the same order as they are present in the + // instruction example x = bitcast op1 + std::vector TokenVec; + TokenVec.push_back(this->getTokenWrapper()->getToken(Inst)); + if (llvm::CallInst *CI = + llvm::dyn_cast(Inst->getOperand(0))) { + if (CI->getCalledFunction()->getName().startswith("_Zn") || + CI->getCalledFunction()->getName().startswith("_zn")) + TokenVec.push_back(this->getTokenWrapper()->getToken(Inst->getDestTy())); + } else if (llvm::BitCastInst *BI = + llvm::dyn_cast(Inst->getOperand(0))) { + TokenVec.push_back(this->getTokenWrapper()->getToken(BI->getDestTy())); + } + if (TokenVec.size() == 1) { + TokenVec.push_back(this->getTokenWrapper()->getToken(Inst->getOperand(0))); + } + return TokenVec; +} + +/// extractToken - Returns a vector of alias objects for GetElementPointer +/// \Inst operands. +std::vector +LFCPAInstModel::extractToken(llvm::GetElementPtrInst *Inst) { + // Only provides partial support and returns {op1, op2[idx1]} for op1 = GEP + // op2 0 idx1 + + std::vector TokenVec; + + // Check if the operand is a pointer + if (isStructFieldPointerTy(Inst)) { + llvm::Function *Func = Inst->getParent()->getParent(); + TokenVec.push_back(this->getTokenWrapper()->getToken(Inst)); + Token* opRhs = handleGEPUtil(Inst, this->getTokenWrapper()->getToken(Inst->getPointerOperand())); + TokenVec.push_back(opRhs); + } + return TokenVec; +} + +/// extractToken - Returns a vector of alias objects for Argument \Arg of +/// Function \Func +std::vector LFCPAInstModel::extractToken(llvm::Argument *Arg, + llvm::Function *Func) { + std::vector TokenVec; + Token *ArgToken = this->getTokenWrapper()->getToken(Arg); + TokenVec.push_back(ArgToken); + TokenVec.push_back( + this->getTokenWrapper()->getToken(Arg->getName().str() + "-orig", Func)); + return TokenVec; +} + +/// extractToken - Returns the alias object for variable storing the +/// return value from the function call +std::vector LFCPAInstModel::extractToken(llvm::CallInst *CI) { + std::vector TokenVec; + if (!CI->doesNotReturn()) { + TokenVec.push_back(this->getTokenWrapper()->getToken(CI)); + } + return TokenVec; +} + +/// extractRedirections - Returns the relative level of redirection based of +/// LHS and RHS on the statement +std::vector +LFCPAInstModel::extractRedirections(llvm::Instruction *Inst) { + std::vector load{1, 2}, store{2, 1}, copy{1, 1}, assign{1, 0}, temp{2, 0}, gep{1, 0}; + if (llvm::isa(Inst) || + llvm::isa(Inst)) + return gep; + // return assign; + if (llvm::isa(Inst)) { + llvm::StoreInst *SI = llvm::dyn_cast(Inst); + std::vector vecStoreIns = extractToken(SI); + Token* opLhs = vecStoreIns[0]; + Token* opRhs = vecStoreIns[1]; + if (opLhs->isGlobalVar() and opRhs->isGlobalVar()) + return assign; + else if (!opLhs->isGlobalVar() and opRhs->isGlobalVar()) + return temp; + else if (opLhs->isGlobalVar() and !opRhs->isGlobalVar()) + return copy; + else if (!opLhs->isGlobalVar() and !opRhs->isGlobalVar()) + return store; + } + if (llvm::isa(Inst)) { + llvm::LoadInst *LI = llvm::dyn_cast(Inst); + std::vector vecLoadIns = extractToken(LI); + Token* opLhs = vecLoadIns[0]; + Token* opRhs = vecLoadIns[1]; + if (opRhs->isGlobalVar()) + return copy; + else if (!opRhs->isGlobalVar()) + return load; + } + return copy; +} + +std::vector +LFCPAInstModel::extractRedirections(llvm::GlobalVariable *G) { + std::vector load{1, 2}, store{2, 1}, copy{1, 1}, assign{1, 0}; + if (llvm::isa(G)) + return assign; +} + +/// handleGEPUtil - Returns the extended field value for a GEP +template +Token *LFCPAInstModel::handleGEPUtil(GEP *G, Token *Ptr) { + if (!Ptr) + return Ptr; + Token *FieldVal = new Token(Ptr); + FieldVal->setIndex(G); + FieldVal = this->getTokenWrapper()->getToken(FieldVal); + FieldVal->setIndex(G); + return FieldVal; +} + +Token *LFCPAInstModel::handleGEPUtil_1(llvm::GEPOperator *G, Token *Ptr) { + if (!Ptr) + return Ptr; + Token *FieldVal = new Token(Ptr); + //FieldVal->setIndex(G); + FieldVal = this->getTokenWrapper()->getToken(FieldVal); + return FieldVal; +} + +template Token *LFCPAInstModel::handleGEPUtil( + llvm::GetElementPtrInst *G, Token *Ptr); +/*template Token * +LFCPAInstModel::handleGEPUtil(llvm::GEPOperator *G, + Token *Ptr); +*/ +template +bool LFCPAInstModel::isStructFieldPointerTy(GOP *G) { + long int cntOp = G->getNumOperands(); + llvm::Type* BaseTy = G->getOperand(0)->getType()->getContainedType(0); + llvm::ConstantInt *CI = llvm::dyn_cast(G->getOperand(cntOp-1)); + auto conVal = CI->getSExtValue(); + return (BaseTy->getStructElementType(conVal)->isPointerTy()); +} + +template bool LFCPAInstModel::isStructFieldPointerTy(llvm::GetElementPtrInst *G); +template bool LFCPAInstModel::isStructFieldPointerTy(llvm::GEPOperator *G); + + +Token* LFCPAInstModel::extractDummy(std::string S) { + return (this->getTokenWrapper()->getToken(S, nullptr)); +} + + +//LFCPAInstModel::LFCPAInstModel(){}; +LFCPAInstModel::~LFCPAInstModel(){}; + +bool LFCPAInstModel::isInstSkip(llvm::Instruction *I) { + + for (auto it : InstInfoMap) { + llvm::Instruction* Ins = it.first; + if (Ins == I) + return it.second->isSkipInst(); + } + return false; +} + + + + + + + + + + + + + + + + + + + +} // namespace spatial From 11212bae0fa3e0eb378182a305b9139b4e9c14c8 Mon Sep 17 00:00:00 2001 From: Aditi Date: Wed, 2 Jun 2021 15:12:49 +0530 Subject: [PATCH 3/4] Changes in Token Class --- include/Token/Token.h | 7 +++++++ lib/Token/Token.cpp | 31 ++++++++++++++++++++++++++++--- 2 files changed, 35 insertions(+), 3 deletions(-) diff --git a/include/Token/Token.h b/include/Token/Token.h index 4baf33f..a3b6eed 100644 --- a/include/Token/Token.h +++ b/include/Token/Token.h @@ -39,6 +39,7 @@ class Token { public: void setIndex(llvm::GetElementPtrInst *GEPInst); void setIndex(llvm::GEPOperator *GEPOp); + void setIndex(std::string); //Added on 31.5.21 void resetIndex(); std::string getIndex(llvm::GEPOperator *GEPOp); @@ -54,6 +55,7 @@ class Token { std::string getMemTypeName() const; std::string getFunctionName() const; std::string getFieldIndex() const; + friend std::ostream &operator<<(std::ostream &OS, const Token &A); bool isMem() const; @@ -63,11 +65,16 @@ class Token { bool isAllocaOrArgOrGlobal() const; bool sameFunc(llvm::Function *Func) const; bool isBasePointerType() const; + bool isFieldPointerType() const; std::string getHash() const; + std::string getHashNoFieldIdx() const; + bool isPointerType() const; bool operator<(const Token &TheToken) const; bool operator==(const Token &TheToken) const; void operator=(const Token &TheToken); + + }; } // namespace spatial diff --git a/lib/Token/Token.cpp b/lib/Token/Token.cpp index 862ab27..b3f2ecb 100644 --- a/lib/Token/Token.cpp +++ b/lib/Token/Token.cpp @@ -108,6 +108,12 @@ void Token::setIndex(llvm::GEPOperator *GEPOp) { this->Index = getIndex(GEPOp); } + +/// setIndex - For a GEP Operator find the offset and store it +void Token::setIndex(std::string Indx) { + this->Index = Indx; +} + /// resetIndex - Resets the index back to an empty string void Token::resetIndex() { this->Index = ""; } @@ -223,6 +229,12 @@ bool Token::isBasePointerType() const { return false; } +bool Token::isFieldPointerType() const { + if (this->Ty->isPointerTy()) + return true; + return false; +} + /// getHash - Calculates the hash for alias to avoid multiple enteries of same /// alias std::string Token::getHash() const { @@ -232,16 +244,26 @@ std::string Token::getHash() const { hash += this->getName().str(); hash += this->getFunctionName(); hash += this->getMemTypeName(); - hash += this->getFieldIndex(); +// hash += this->getFieldIndex(); + return hash; +} + +std::string Token::getHashNoFieldIdx() const { + std::string hash = ""; + if (this->isGlobalVar()) + hash += "G"; + hash += this->getName().str(); + hash += this->getFunctionName(); + hash += this->getMemTypeName(); return hash; } bool Token::operator<(const Token &TheToken) const { - return (this->getHash() < TheToken.getHash()); + return (this->getHash() < TheToken.getHash()); } bool Token::operator==(const Token &TheToken) const { - return (this->getHash() == TheToken.getHash()); + return (this->getHash() == TheToken.getHash()); } void Token::operator=(const Token &TheToken) { @@ -257,4 +279,7 @@ void Token::operator=(const Token &TheToken) { } } + + + } // namespace spatial From 41d0fd6a1b959f6787670ae27d8c2d2d7981a32a Mon Sep 17 00:00:00 2001 From: Aditi Date: Thu, 3 Jun 2021 17:05:58 +0530 Subject: [PATCH 4/4] Updated Token Class --- include/Token/Token.h | 3 +-- lib/Token/Token.cpp | 16 +--------------- 2 files changed, 2 insertions(+), 17 deletions(-) diff --git a/include/Token/Token.h b/include/Token/Token.h index a3b6eed..ce77ef9 100644 --- a/include/Token/Token.h +++ b/include/Token/Token.h @@ -65,9 +65,8 @@ class Token { bool isAllocaOrArgOrGlobal() const; bool sameFunc(llvm::Function *Func) const; bool isBasePointerType() const; - bool isFieldPointerType() const; + bool isValPointerType() const; std::string getHash() const; - std::string getHashNoFieldIdx() const; bool isPointerType() const; bool operator<(const Token &TheToken) const; diff --git a/lib/Token/Token.cpp b/lib/Token/Token.cpp index b3f2ecb..114acf0 100644 --- a/lib/Token/Token.cpp +++ b/lib/Token/Token.cpp @@ -229,7 +229,7 @@ bool Token::isBasePointerType() const { return false; } -bool Token::isFieldPointerType() const { +bool Token::isValPointerType() const { if (this->Ty->isPointerTy()) return true; return false; @@ -248,16 +248,6 @@ std::string Token::getHash() const { return hash; } -std::string Token::getHashNoFieldIdx() const { - std::string hash = ""; - if (this->isGlobalVar()) - hash += "G"; - hash += this->getName().str(); - hash += this->getFunctionName(); - hash += this->getMemTypeName(); - return hash; -} - bool Token::operator<(const Token &TheToken) const { return (this->getHash() < TheToken.getHash()); } @@ -278,8 +268,4 @@ void Token::operator=(const Token &TheToken) { set(TheToken.name, TheToken.Kind, TheToken.Index, TheToken.Func); } } - - - - } // namespace spatial