r206338 - Thread Safety Analysis: rewrite SSA pass to use the new SExpr and CFG
Timur Iskhodzhanov
timurrrr at google.com
Wed Apr 16 01:16:41 PDT 2014
Request timeout -- I'm going to revert the change.
2014-04-16 7:24 GMT+04:00 Renato Golin <renato.golin at linaro.org>:
> Hi DeLesley,
>
> Have you seen this error?
>
> http://lab.llvm.org:8011/builders/clang-native-arm-lnt/builds/5991/steps/compile/logs/stdio
>
> /external/buildbot/clang-native-arm-lnt/llvm.src/tools/clang/lib/Analysis/../../include/clang/Analysis/Analyses/ThreadSafetyUtil.h:105:16:
> error: ‘Sz’ was not declared in this scope
> assert(i < Sz && "Array index out of bounds.");
>
> cheers,
> --renato
>
> On 15 April 2014 20:23, DeLesley Hutchins <delesley at google.com> wrote:
>> Author: delesley
>> Date: Tue Apr 15 18:23:19 2014
>> New Revision: 206338
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=206338&view=rev
>> Log:
>> Thread Safety Analysis: rewrite SSA pass to use the new SExpr and CFG
>> traversal system. The new pass is still undergoing testing; no change in
>> functionality.
>>
>> Modified:
>> cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyCommon.h
>> cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyTIL.h
>> cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h
>> cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyUtil.h
>> cfe/trunk/lib/Analysis/ThreadSafetyCommon.cpp
>>
>> Modified: cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyCommon.h
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyCommon.h?rev=206338&r1=206337&r2=206338&view=diff
>> ==============================================================================
>> --- cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyCommon.h (original)
>> +++ cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyCommon.h Tue Apr 15 18:23:19 2014
>> @@ -33,32 +33,53 @@
>> namespace clang {
>> namespace threadSafety {
>>
>> -// CFG traversal uses templates instead of virtual function dispatch. Visitors
>> -// must implement the following functions:
>> -//
>> -// Enter the CFG for Decl D, and perform any initial setup operations.
>> -// void enterCFG(CFG *Cfg, const NamedDecl *D, const CFGBlock *First) {}
>> -//
>> -// Enter a CFGBlock.
>> -// void enterCFGBlock(const CFGBlock *B) {}
>> -//
>> -// Process an ordinary statement.
>> -// void handleStatement(const Stmt *S) {}
>> -//
>> -// Process a destructor call
>> -// void handleDestructorCall(const VarDecl *VD, const CXXDestructorDecl *DD) {}
>> -//
>> -// Process a successor edge.
>> -// void handleSuccessor(const CFGBlock *Succ) {}
>> -//
>> -// Process a successor back edge to a previously visited block.
>> -// void handleSuccessorBackEdge(const CFGBlock *Succ) {}
>> -//
>> -// Leave a CFGBlock.
>> -// void exitCFGBlock(const CFGBlock *B) {}
>> -//
>> -// Leave the CFG, and perform any final cleanup operations.
>> -// void exitCFG(const CFGBlock *Last) {}
>> +// This class defines the interface of a clang CFG Visitor.
>> +// CFGWalker will invoke the following methods.
>> +// Note that methods are not virtual; the visitor is templatized.
>> +class CFGVisitor {
>> + // Enter the CFG for Decl D, and perform any initial setup operations.
>> + void enterCFG(CFG *Cfg, const NamedDecl *D, const CFGBlock *First) {}
>> +
>> + // Enter a CFGBlock.
>> + void enterCFGBlock(const CFGBlock *B) {}
>> +
>> + // Returns true if this visitor implements handlePredecessor
>> + bool visitPredecessors() { return true; }
>> +
>> + // Process a predecessor edge.
>> + void handlePredecessor(const CFGBlock *Pred) {}
>> +
>> + // Process a successor back edge to a previously visited block.
>> + void handlePredecessorBackEdge(const CFGBlock *Pred) {}
>> +
>> + // Called just before processing statements.
>> + void enterCFGBlockBody(const CFGBlock *B) {}
>> +
>> + // Process an ordinary statement.
>> + void handleStatement(const Stmt *S) {}
>> +
>> + // Process a destructor call
>> + void handleDestructorCall(const VarDecl *VD, const CXXDestructorDecl *DD) {}
>> +
>> + // Called after all statements have been handled.
>> + void exitCFGBlockBody(const CFGBlock *B) {}
>> +
>> + // Return true
>> + bool visitSuccessors() { return true; }
>> +
>> + // Process a successor edge.
>> + void handleSuccessor(const CFGBlock *Succ) {}
>> +
>> + // Process a successor back edge to a previously visited block.
>> + void handleSuccessorBackEdge(const CFGBlock *Succ) {}
>> +
>> + // Leave a CFGBlock.
>> + void exitCFGBlock(const CFGBlock *B) {}
>> +
>> + // Leave the CFG, and perform any final cleanup operations.
>> + void exitCFG(const CFGBlock *Last) {}
>> +};
>> +
>>
>> // Walks the clang CFG, and invokes methods on a given CFGVisitor.
>> class CFGWalker {
>> @@ -97,6 +118,25 @@ public:
>>
>> V.enterCFGBlock(CurrBlock);
>>
>> + // Process predecessors
>> + if (V.visitPredecessors()) {
>> + // Process successors
>> + for (CFGBlock::const_pred_iterator SI = CurrBlock->pred_begin(),
>> + SE = CurrBlock->pred_end();
>> + SI != SE; ++SI) {
>> + if (*SI == nullptr)
>> + continue;
>> +
>> + if (!VisitedBlocks.alreadySet(*SI)) {
>> + V.handlePredecessorBackEdge(*SI);
>> + continue;
>> + }
>> + V.handlePredecessor(*SI);
>> + }
>> + }
>> +
>> + V.enterCFGBlockBody(CurrBlock);
>> +
>> // Process statements
>> for (const auto &BI : *CurrBlock) {
>> switch (BI.getKind()) {
>> @@ -117,18 +157,23 @@ public:
>> }
>> }
>>
>> + V.exitCFGBlockBody(CurrBlock);
>> +
>> // Process successors
>> - for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(),
>> - SE = CurrBlock->succ_end();
>> - SI != SE; ++SI) {
>> - if (*SI == nullptr)
>> - continue;
>> -
>> - if (VisitedBlocks.alreadySet(*SI)) {
>> - V.handleSuccessorBackEdge(*SI);
>> - continue;
>> + if (V.visitSuccessors()) {
>> + // Process successors
>> + for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(),
>> + SE = CurrBlock->succ_end();
>> + SI != SE; ++SI) {
>> + if (*SI == nullptr)
>> + continue;
>> +
>> + if (VisitedBlocks.alreadySet(*SI)) {
>> + V.handleSuccessorBackEdge(*SI);
>> + continue;
>> + }
>> + V.handleSuccessor(*SI);
>> }
>> - V.handleSuccessor(*SI);
>> }
>>
>> V.exitCFGBlock(CurrBlock);
>> @@ -174,15 +219,16 @@ public:
>> {}
>> };
>>
>> - til::SExpr *lookupStmt(const Stmt *S);
>> - void insertStmt(const Stmt *S, til::Variable *V);
>> -
>> // Translate a clang statement or expression to a TIL expression.
>> // Also performs substitution of variables; Ctx provides the context.
>> // Dispatches on the type of S.
>> til::SExpr *translate(const Stmt *S, CallingContext *Ctx);
>> + til::SCFG *buildCFG(CFGWalker &Walker);
>>
>> -protected:
>> + til::SExpr *lookupStmt(const Stmt *S);
>> + til::SCFG *getCFG() const { return Scfg; }
>> +
>> +private:
>> til::SExpr *translateDeclRefExpr(const DeclRefExpr *DRE,
>> CallingContext *Ctx) ;
>> til::SExpr *translateCXXThisExpr(const CXXThisExpr *TE, CallingContext *Ctx);
>> @@ -204,24 +250,86 @@ protected:
>> til::SExpr *translateBinaryConditionalOperator(
>> const BinaryConditionalOperator *C, CallingContext *Ctx);
>>
>> + til::SExpr *translateDeclStmt(const DeclStmt *S, CallingContext *Ctx);
>> +
>> +private:
>> + // Used for looking the index of a name.
>> + typedef llvm::DenseMap<const ValueDecl*, unsigned> NameIndexMap;
>> +
>> + // Used for looking up the current SSA variable for a name, by index.
>> + typedef CopyOnWriteVector<std::pair<const ValueDecl*, til::SExpr*> >
>> + NameVarMap;
>> +
>> + struct BlockInfo {
>> + NameVarMap ExitMap;
>> + bool HasBackEdges = false;
>> + unsigned SuccessorsToProcess = 0;
>> + };
>> +
>> + // We implement the CFGVisitor API
>> + friend class CFGWalker;
>> +
>> + void enterCFG(CFG *Cfg, const NamedDecl *D, const CFGBlock *First);
>> + void enterCFGBlock(const CFGBlock *B);
>> + bool visitPredecessors() { return true; }
>> + void handlePredecessor(const CFGBlock *Pred);
>> + void handlePredecessorBackEdge(const CFGBlock *Pred);
>> + void enterCFGBlockBody(const CFGBlock *B);
>> + void handleStatement(const Stmt *S);
>> + void handleDestructorCall(const VarDecl *VD, const CXXDestructorDecl *DD);
>> + void exitCFGBlockBody(const CFGBlock *B);
>> + bool visitSuccessors() { return true; }
>> + void handleSuccessor(const CFGBlock *Succ);
>> + void handleSuccessorBackEdge(const CFGBlock *Succ);
>> + void exitCFGBlock(const CFGBlock *B);
>> + void exitCFG(const CFGBlock *Last);
>> +
>> + void insertStmt(const Stmt *S, til::Variable *V);
>> + til::SExpr *addStatement(til::SExpr *E, const Stmt *S, const ValueDecl *VD=0);
>> + til::SExpr *lookupVarDecl(const ValueDecl *VD);
>> + til::SExpr *addVarDecl(const ValueDecl *VD, til::SExpr *E);
>> + til::SExpr *updateVarDecl(const ValueDecl *VD, til::SExpr *E);
>> +
>> + void mergeEntryMap(NameVarMap Map);
>>
>> public:
>> - SExprBuilder(til::MemRegionRef A, StatementMap *SM = nullptr)
>> - : Arena(A), SMap(SM), SelfVar(nullptr), CurrentBlock(nullptr) {
>> + SExprBuilder(til::MemRegionRef A)
>> + : Arena(A), SelfVar(nullptr), Scfg(nullptr), CallCtx(nullptr),
>> + CurrentBB(nullptr), CurrentBlockID(0), CurrentVarID(0),
>> + CurrentArgIndex(0)
>> + {
>> // FIXME: we don't always have a self-variable.
>> SelfVar = new (Arena) til::Variable(til::Variable::VK_SFun);
>> }
>>
>> -protected:
>> + ~SExprBuilder() {
>> + if (CallCtx)
>> + delete CallCtx;
>> + }
>> +
>> +private:
>> til::MemRegionRef Arena;
>> - StatementMap *SMap; // Map from Stmt to TIL Variables
>> - til::Variable *SelfVar; // Variable to use for 'this'. May be null.
>> - til::BasicBlock* CurrentBlock; // Current basic block. May be null.
>> + til::Variable *SelfVar; // Variable to use for 'this'. May be null.
>> + til::SCFG *Scfg;
>> +
>> + StatementMap SMap; // Map from Stmt to TIL Variables
>> + NameIndexMap IdxMap; // Indices of clang local vars.
>> + std::vector<til::BasicBlock*> BlockMap; // Map from clang to til BBs.
>> + std::vector<BlockInfo> BBInfo; // Extra information per BB.
>> + // Indexed by clang BlockID.
>> + SExprBuilder::CallingContext *CallCtx; // Root calling context
>> +
>> + NameVarMap CurrentNameMap;
>> + til::BasicBlock *CurrentBB;
>> + BlockInfo *CurrentBlockInfo;
>> + unsigned CurrentBlockID;
>> + unsigned CurrentVarID;
>> + unsigned CurrentArgIndex;
>> };
>>
>>
>> // Dump an SCFG to llvm::errs().
>> -void printSCFG(CFGWalker &walker);
>> +void printSCFG(CFGWalker &Walker);
>>
>>
>> } // end namespace threadSafety
>>
>> Modified: cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyTIL.h
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyTIL.h?rev=206338&r1=206337&r2=206338&view=diff
>> ==============================================================================
>> --- cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyTIL.h (original)
>> +++ cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyTIL.h Tue Apr 15 18:23:19 2014
>> @@ -199,7 +199,7 @@ public:
>> // These are defined after SExprRef contructor, below
>> inline Variable(VariableKind K, SExpr *D = nullptr,
>> const clang::ValueDecl *Cvd = nullptr);
>> - inline Variable(const clang::ValueDecl *Cvd, SExpr *D = nullptr);
>> + inline Variable(SExpr *D = nullptr, const clang::ValueDecl *Cvd = nullptr);
>> inline Variable(const Variable &Vd, SExpr *D);
>>
>> VariableKind kind() const { return static_cast<VariableKind>(Flags); }
>> @@ -220,6 +220,7 @@ public:
>> BlockID = static_cast<unsigned short>(Bid);
>> Id = static_cast<unsigned short>(I);
>> }
>> + void setClangDecl(const clang::ValueDecl *VD) { Cvdecl = VD; }
>>
>> template <class V> typename V::R_SExpr traverse(V &Visitor) {
>> // This routine is only called for variable references.
>> @@ -353,7 +354,7 @@ Variable::Variable(VariableKind K, SExpr
>> Flags = K;
>> }
>>
>> -Variable::Variable(const clang::ValueDecl *Cvd, SExpr *D)
>> +Variable::Variable(SExpr *D, const clang::ValueDecl *Cvd)
>> : SExpr(COP_Variable), Definition(D), Cvdecl(Cvd),
>> BlockID(0), Id(0), NumUses(0) {
>> Flags = VK_Let;
>> @@ -935,6 +936,8 @@ private:
>> SExprRef Expr0;
>> };
>>
>> +
>> +
>> class BasicBlock;
>>
>> // An SCFG is a control-flow graph. It consists of a set of basic blocks, each
>> @@ -998,13 +1001,16 @@ public:
>>
>> BasicBlock(MemRegionRef A, unsigned Nargs, unsigned Nins,
>> SExpr *Term = nullptr)
>> - : BlockID(0), Parent(nullptr), Args(A, Nargs), Instrs(A, Nins),
>> - Terminator(Term) {}
>> + : BlockID(0), Parent(nullptr), NumPredecessors(0),
>> + Args(A, Nargs), Instrs(A, Nins), Terminator(Term) {}
>> BasicBlock(const BasicBlock &B, VarArray &&As, VarArray &&Is, SExpr *T)
>> - : BlockID(0), Parent(nullptr), Args(std::move(As)), Instrs(std::move(Is)),
>> - Terminator(T) {}
>> + : BlockID(0), Parent(nullptr), NumPredecessors(B.NumPredecessors),
>> + Args(std::move(As)), Instrs(std::move(Is)), Terminator(T)
>> + {}
>>
>> unsigned blockID() const { return BlockID; }
>> + unsigned numPredecessors() const { return NumPredecessors; }
>> +
>> const BasicBlock *parent() const { return Parent; }
>> BasicBlock *parent() { return Parent; }
>>
>> @@ -1017,8 +1023,9 @@ public:
>> const SExpr *terminator() const { return Terminator.get(); }
>> SExpr *terminator() { return Terminator.get(); }
>>
>> - void setParent(BasicBlock *P) { Parent = P; }
>> void setBlockID(unsigned i) { BlockID = i; }
>> + void setParent(BasicBlock *P) { Parent = P; }
>> + void setNumPredecessors(unsigned NP) { NumPredecessors = NP; }
>> void setTerminator(SExpr *E) { Terminator.reset(E); }
>> void addArgument(Variable *V) { Args.push_back(V); }
>> void addInstr(Variable *V) { Args.push_back(V); }
>> @@ -1057,9 +1064,10 @@ private:
>> friend class SCFG;
>>
>> unsigned BlockID;
>> - BasicBlock *Parent; // The parent block is the enclosing lexical scope.
>> - // The parent dominates this block.
>> - VarArray Args; // Phi nodes
>> + BasicBlock *Parent; // The parent block is the enclosing lexical scope.
>> + // The parent dominates this block.
>> + unsigned NumPredecessors; // Number of blocks which jump to this one.
>> + VarArray Args; // Phi nodes. One argument per predecessor.
>> VarArray Instrs;
>> SExprRef Terminator;
>> };
>> @@ -1100,8 +1108,8 @@ public:
>> return Visitor.reducePhi(*this, Nvs);
>> }
>>
>> - template <class C> typename C::CType compare(Phi *E, C &Cmp) {
>> - // TODO -- implement CFG comparisons
>> + template <class C> typename C::CType compare(Phi* E, C &Cmp) {
>> + // TODO: implement CFG comparisons
>> return Cmp.comparePointers(this, E);
>> }
>>
>> @@ -1146,17 +1154,26 @@ public:
>> static bool classof(const SExpr *E) { return E->opcode() == COP_Branch; }
>>
>> Branch(SExpr *C, BasicBlock *T, BasicBlock *E)
>> - : SExpr(COP_Branch), Condition(C), ThenBlock(T), ElseBlock(E) {}
>> + : SExpr(COP_Branch), Condition(C), ThenBlock(T), ElseBlock(E),
>> + ThenIndex(0), ElseIndex(0)
>> + {}
>> Branch(const Branch &Br, SExpr *C, BasicBlock *T, BasicBlock *E)
>> - : SExpr(COP_Branch), Condition(C), ThenBlock(T), ElseBlock(E) {}
>> + : SExpr(COP_Branch), Condition(C), ThenBlock(T), ElseBlock(E),
>> + ThenIndex(0), ElseIndex(0)
>> + {}
>>
>> const SExpr *condition() const { return Condition; }
>> SExpr *condition() { return Condition; }
>> +
>> const BasicBlock *thenBlock() const { return ThenBlock; }
>> BasicBlock *thenBlock() { return ThenBlock; }
>> +
>> const BasicBlock *elseBlock() const { return ElseBlock; }
>> BasicBlock *elseBlock() { return ElseBlock; }
>>
>> + unsigned thenIndex() const { return ThenIndex; }
>> + unsigned elseIndex() const { return ElseIndex; }
>> +
>> template <class V> typename V::R_SExpr traverse(V &Visitor) {
>> typename V::R_SExpr Nc = Visitor.traverse(Condition);
>> BasicBlock *Ntb = Visitor.reduceBasicBlockRef(ThenBlock);
>> @@ -1173,6 +1190,8 @@ private:
>> SExpr *Condition;
>> BasicBlock *ThenBlock;
>> BasicBlock *ElseBlock;
>> + unsigned ThenIndex;
>> + unsigned ElseIndex;
>> };
>>
>>
>>
>> Modified: cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h?rev=206338&r1=206337&r2=206338&view=diff
>> ==============================================================================
>> --- cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h (original)
>> +++ cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h Tue Apr 15 18:23:19 2014
>> @@ -409,6 +409,15 @@ protected:
>> SS << "\n";
>> }
>>
>> + void printBlockLabel(StreamType & SS, BasicBlock *BB, unsigned index) {
>> + if (!BB) {
>> + SS << "BB_null";
>> + return;
>> + }
>> + SS << "BB_";
>> + SS << BB->blockID();
>> + }
>> +
>> // TODO: further distinguish between binary operations.
>> static const unsigned Prec_Atom = 0;
>> static const unsigned Prec_Postfix = 1;
>> @@ -560,9 +569,11 @@ protected:
>>
>> void printSApply(SApply *E, StreamType &SS) {
>> self()->printSExpr(E->sfun(), SS, Prec_Postfix);
>> - SS << "@(";
>> - self()->printSExpr(E->arg(), SS, Prec_MAX);
>> - SS << ")";
>> + if (E->isDelegation()) {
>> + SS << "@(";
>> + self()->printSExpr(E->arg(), SS, Prec_MAX);
>> + SS << ")";
>> + }
>> }
>>
>> void printProject(Project *E, StreamType &SS) {
>> @@ -584,7 +595,7 @@ protected:
>> }
>>
>> void printAlloc(Alloc *E, StreamType &SS) {
>> - SS << "#alloc ";
>> + SS << "new ";
>> self()->printSExpr(E->dataType(), SS, Prec_Other-1);
>> }
>>
>> @@ -595,7 +606,7 @@ protected:
>>
>> void printStore(Store *E, StreamType &SS) {
>> self()->printSExpr(E->destination(), SS, Prec_Other-1);
>> - SS << " = ";
>> + SS << " := ";
>> self()->printSExpr(E->source(), SS, Prec_Other-1);
>> }
>>
>> @@ -628,9 +639,11 @@ protected:
>> newline(SS);
>> }
>> for (auto I : BBI->instructions()) {
>> - SS << "let ";
>> - self()->printVariable(I, SS);
>> - SS << " = ";
>> + if (I->definition()->opcode() != COP_Store) {
>> + SS << "let ";
>> + self()->printVariable(I, SS);
>> + SS << " = ";
>> + }
>> self()->printSExpr(I->definition(), SS, Prec_MAX);
>> SS << ";";
>> newline(SS);
>> @@ -648,31 +661,29 @@ protected:
>> }
>>
>> void printPhi(Phi *E, StreamType &SS) {
>> - SS << "#phi(";
>> + SS << "phi(";
>> unsigned i = 0;
>> for (auto V : E->values()) {
>> - ++i;
>> if (i > 0)
>> SS << ", ";
>> self()->printSExpr(V, SS, Prec_MAX);
>> + ++i;
>> }
>> SS << ")";
>> }
>>
>> void printGoto(Goto *E, StreamType &SS) {
>> - SS << "#goto BB_";
>> - SS << E->targetBlock()->blockID();
>> - SS << ":";
>> - SS << E->index();
>> + SS << "goto ";
>> + printBlockLabel(SS, E->targetBlock(), E->index());
>> }
>>
>> void printBranch(Branch *E, StreamType &SS) {
>> - SS << "#branch (";
>> + SS << "branch (";
>> self()->printSExpr(E->condition(), SS, Prec_MAX);
>> - SS << ") BB_";
>> - SS << E->thenBlock()->blockID();
>> - SS << " BB_";
>> - SS << E->elseBlock()->blockID();
>> + SS << ") ";
>> + printBlockLabel(SS, E->thenBlock(), E->thenIndex());
>> + SS << " ";
>> + printBlockLabel(SS, E->elseBlock(), E->elseIndex());
>> }
>> };
>>
>>
>> Modified: cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyUtil.h
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyUtil.h?rev=206338&r1=206337&r2=206338&view=diff
>> ==============================================================================
>> --- cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyUtil.h (original)
>> +++ cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyUtil.h Tue Apr 15 18:23:19 2014
>> @@ -78,7 +78,7 @@ template <class T> class SimpleArray {
>> public:
>> SimpleArray() : Data(nullptr), Size(0), Capacity(0) {}
>> SimpleArray(T *Dat, size_t Cp, size_t Sz = 0)
>> - : Data(Dat), Size(0), Capacity(Cp) {}
>> + : Data(Dat), Size(Sz), Capacity(Cp) {}
>> SimpleArray(MemRegionRef A, size_t Cp)
>> : Data(A.allocateT<T>(Cp)), Size(0), Capacity(Cp) {}
>> SimpleArray(SimpleArray<T> &&A)
>> @@ -101,8 +101,14 @@ public:
>> size_t size() const { return Size; }
>> size_t capacity() const { return Capacity; }
>>
>> - T &operator[](unsigned I) { return Data[I]; }
>> - const T &operator[](unsigned I) const { return Data[I]; }
>> + T &operator[](unsigned i) {
>> + assert(i < Sz && "Array index out of bounds.");
>> + return Data[i];
>> + }
>> + const T &operator[](unsigned i) const {
>> + assert(i < Size && "Array index out of bounds.");
>> + return Data[i];
>> + }
>>
>> iterator begin() { return Data; }
>> iterator end() { return Data + Size; }
>> @@ -115,6 +121,14 @@ public:
>> Data[Size++] = Elem;
>> }
>>
>> + void setValues(unsigned Sz, const T& C) {
>> + assert(Sz < Capacity);
>> + Size = Sz;
>> + for (unsigned i = 0; i < Sz; ++i) {
>> + Data[i] = C;
>> + }
>> + }
>> +
>> template <class Iter> unsigned append(Iter I, Iter E) {
>> size_t Osz = Size;
>> size_t J = Osz;
>> @@ -132,8 +146,135 @@ private:
>> size_t Capacity;
>> };
>>
>> -
>> } // end namespace til
>> +
>> +
>> +// A copy on write vector.
>> +// The vector can be in one of three states:
>> +// * invalid -- no operations are permitted.
>> +// * read-only -- read operations are permitted.
>> +// * writable -- read and write operations are permitted.
>> +// The init(), destroy(), and makeWritable() methods will change state.
>> +template<typename T>
>> +class CopyOnWriteVector {
>> +private:
>> + class VectorData {
>> + public:
>> + VectorData() : NumRefs(1) { }
>> + VectorData(const VectorData &VD) : NumRefs(1), Vect(VD.Vect) { }
>> +
>> + unsigned NumRefs;
>> + std::vector<T> Vect;
>> + };
>> +
>> +public:
>> + CopyOnWriteVector() : Data(0) { }
>> + CopyOnWriteVector(const CopyOnWriteVector &V) = delete;
>> + CopyOnWriteVector(CopyOnWriteVector &&V) : Data(V.Data) {
>> + V.Data = 0;
>> + }
>> + ~CopyOnWriteVector() {
>> + destroy();
>> + }
>> +
>> + // Returns true if this holds a valid vector.
>> + bool valid() { return Data; }
>> +
>> + // Returns true if this vector is writable.
>> + bool writable() { return Data && Data->NumRefs == 1; }
>> +
>> + // If this vector is not valid, initialize it to a valid vector.
>> + void init() {
>> + if (!Data) {
>> + Data = new VectorData();
>> + }
>> + }
>> +
>> + // Destroy this vector; thus making it invalid.
>> + void destroy() {
>> + if (!Data)
>> + return;
>> + if (Data->NumRefs <= 1)
>> + delete Data;
>> + else
>> + --Data->NumRefs;
>> + Data = 0;
>> + }
>> +
>> + // Make this vector writable, creating a copy if needed.
>> + void makeWritable() {
>> + if (!Data) {
>> + Data = new VectorData();
>> + return;
>> + }
>> + if (Data->NumRefs == 1)
>> + return; // already writeable.
>> + --Data->NumRefs;
>> + Data = new VectorData(*Data);
>> + }
>> +
>> + // Create a lazy copy of this vector.
>> + CopyOnWriteVector clone() { return CopyOnWriteVector(Data); }
>> +
>> + // No copy constructor or copy assignment. Use clone() with move assignment.
>> + void operator=(const CopyOnWriteVector &V) = delete;
>> +
>> + void operator=(CopyOnWriteVector &&V) {
>> + destroy();
>> + Data = V.Data;
>> + V.Data = 0;
>> + }
>> +
>> + typedef typename std::vector<T>::const_iterator iterator;
>> +
>> + const std::vector<T> &elements() const { return Data->Vect; }
>> +
>> + iterator begin() const { return elements().cbegin(); }
>> + iterator end() const { return elements().cend(); }
>> +
>> + const T& operator[](unsigned i) const { return elements()[i]; }
>> +
>> + unsigned size() const { return Data ? elements().size() : 0; }
>> +
>> + // Return true if V and this vector refer to the same data.
>> + bool sameAs(const CopyOnWriteVector& V) { return Data == V.Data; }
>> +
>> + // Clear vector. The vector must be writable.
>> + void clear() {
>> + assert(writable() && "Vector is not writable!");
>> + Data->Vect.clear();
>> + }
>> +
>> + // Push a new element onto the end. The vector must be writable.
>> + void push_back(const T& Elem) {
>> + assert(writable() && "Vector is not writable!");
>> + Data->Vect.push_back(Elem);
>> + }
>> +
>> + // Gets a mutable reference to the element at index(i).
>> + // The vector must be writable.
>> + T& elem(unsigned i) {
>> + assert(writable() && "Vector is not writable!");
>> + return Data->Vect[i];
>> + }
>> +
>> + // Drops elements from the back until the vector has size i.
>> + void downsize(unsigned i) {
>> + assert(writable() && "Vector is not writable!");
>> + Data->Vect.erase(Data->Vect.begin() + i, Data->Vect.end());
>> + }
>> +
>> +private:
>> + CopyOnWriteVector(VectorData *D) : Data(D) {
>> + if (!Data)
>> + return;
>> + ++Data->NumRefs;
>> + }
>> +
>> + VectorData *Data;
>> +};
>> +
>> +
>> } // end namespace threadSafety
>> } // end namespace clang
>>
>>
>> Modified: cfe/trunk/lib/Analysis/ThreadSafetyCommon.cpp
>> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/ThreadSafetyCommon.cpp?rev=206338&r1=206337&r2=206338&view=diff
>> ==============================================================================
>> --- cfe/trunk/lib/Analysis/ThreadSafetyCommon.cpp (original)
>> +++ cfe/trunk/lib/Analysis/ThreadSafetyCommon.cpp Tue Apr 15 18:23:19 2014
>> @@ -28,6 +28,8 @@
>> #include "llvm/ADT/SmallVector.h"
>> #include "llvm/ADT/StringRef.h"
>>
>> +#include <algorithm>
>> +#include <climits>
>> #include <vector>
>>
>>
>> @@ -38,16 +40,20 @@ typedef SExprBuilder::CallingContext Cal
>>
>>
>> til::SExpr *SExprBuilder::lookupStmt(const Stmt *S) {
>> - if (!SMap)
>> - return nullptr;
>> - auto It = SMap->find(S);
>> - if (It != SMap->end())
>> + auto It = SMap.find(S);
>> + if (It != SMap.end())
>> return It->second;
>> return nullptr;
>> }
>>
>> void SExprBuilder::insertStmt(const Stmt *S, til::Variable *V) {
>> - SMap->insert(std::make_pair(S, V));
>> + SMap.insert(std::make_pair(S, V));
>> +}
>> +
>> +
>> +til::SCFG *SExprBuilder::buildCFG(CFGWalker &Walker) {
>> + Walker.walk(*this);
>> + return Scfg;
>> }
>>
>>
>> @@ -55,6 +61,9 @@ void SExprBuilder::insertStmt(const Stmt
>> // Also performs substitution of variables; Ctx provides the context.
>> // Dispatches on the type of S.
>> til::SExpr *SExprBuilder::translate(const Stmt *S, CallingContext *Ctx) {
>> + if (!S)
>> + return nullptr;
>> +
>> // Check if S has already been translated and cached.
>> // This handles the lookup of SSA names for DeclRefExprs here.
>> if (til::SExpr *E = lookupStmt(S))
>> @@ -105,6 +114,9 @@ til::SExpr *SExprBuilder::translate(cons
>> case Stmt::StringLiteralClass:
>> case Stmt::ObjCStringLiteralClass:
>> return new (Arena) til::Literal(cast<Expr>(S));
>> +
>> + case Stmt::DeclStmtClass:
>> + return translateDeclStmt(cast<DeclStmt>(S), Ctx);
>> default:
>> break;
>> }
>> @@ -209,6 +221,7 @@ til::SExpr *SExprBuilder::translateUnary
>> return new (Arena) til::Undefined(UO);
>> }
>>
>> +
>> til::SExpr *SExprBuilder::translateBinaryOperator(const BinaryOperator *BO,
>> CallingContext *Ctx) {
>> switch (BO->getOpcode()) {
>> @@ -238,10 +251,17 @@ til::SExpr *SExprBuilder::translateBinar
>> til::BinaryOp(BO->getOpcode(), translate(BO->getLHS(), Ctx),
>> translate(BO->getRHS(), Ctx));
>>
>> - case BO_Assign:
>> - return new (Arena)
>> - til::Store(translate(BO->getLHS(), Ctx), translate(BO->getRHS(), Ctx));
>> -
>> + case BO_Assign: {
>> + const Expr *LHS = BO->getLHS();
>> + if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(LHS)) {
>> + const Expr *RHS = BO->getRHS();
>> + til::SExpr *E1 = translate(RHS, Ctx);
>> + return updateVarDecl(DRE->getDecl(), E1);
>> + }
>> + til::SExpr *E0 = translate(LHS, Ctx);
>> + til::SExpr *E1 = translate(BO->getRHS(), Ctx);
>> + return new (Arena) til::Store(E0, E1);
>> + }
>> case BO_MulAssign:
>> case BO_DivAssign:
>> case BO_RemAssign:
>> @@ -265,145 +285,332 @@ til::SExpr *SExprBuilder::translateBinar
>>
>> til::SExpr *SExprBuilder::translateCastExpr(const CastExpr *CE,
>> CallingContext *Ctx) {
>> - til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
>> -
>> clang::CastKind K = CE->getCastKind();
>> switch (K) {
>> - case CK_LValueToRValue:
>> + case CK_LValueToRValue: {
>> + if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) {
>> + til::SExpr *E0 = lookupVarDecl(DRE->getDecl());
>> + if (E0)
>> + return E0;
>> + }
>> + til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
>> return new (Arena) til::Load(E0);
>> -
>> + }
>> case CK_NoOp:
>> case CK_DerivedToBase:
>> case CK_UncheckedDerivedToBase:
>> case CK_ArrayToPointerDecay:
>> - case CK_FunctionToPointerDecay:
>> + case CK_FunctionToPointerDecay: {
>> + til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
>> return E0;
>> -
>> - default:
>> + }
>> + default: {
>> + til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
>> return new (Arena) til::Cast(K, E0);
>> }
>> + }
>> }
>>
>> +
>> til::SExpr *
>> SExprBuilder::translateArraySubscriptExpr(const ArraySubscriptExpr *E,
>> CallingContext *Ctx) {
>> return new (Arena) til::Undefined(E);
>> }
>>
>> +
>> til::SExpr *
>> SExprBuilder::translateConditionalOperator(const ConditionalOperator *C,
>> CallingContext *Ctx) {
>> return new (Arena) til::Undefined(C);
>> }
>>
>> +
>> til::SExpr *SExprBuilder::translateBinaryConditionalOperator(
>> const BinaryConditionalOperator *C, CallingContext *Ctx) {
>> return new (Arena) til::Undefined(C);
>> }
>>
>>
>> +til::SExpr *
>> +SExprBuilder::translateDeclStmt(const DeclStmt *S, CallingContext *Ctx) {
>> + DeclGroupRef DGrp = S->getDeclGroup();
>> + for (DeclGroupRef::iterator I = DGrp.begin(), E = DGrp.end(); I != E; ++I) {
>> + if (VarDecl *VD = dyn_cast_or_null<VarDecl>(*I)) {
>> + Expr *E = VD->getInit();
>> + til::SExpr* SE = translate(E, Ctx);
>> +
>> + // Add local variables with trivial type to the variable map
>> + QualType T = VD->getType();
>> + if (T.isTrivialType(VD->getASTContext())) {
>> + return addVarDecl(VD, SE);
>> + }
>> + else {
>> + // TODO: add alloca
>> + }
>> + }
>> + }
>> + return nullptr;
>> +}
>>
>> -// Build a complete SCFG from a clang CFG.
>> -class SCFGBuilder {
>> - class BBInfo {
>>
>> - };
>> +// If (E) is non-trivial, then add it to the current basic block, and
>> +// update the statement map so that S refers to E. Returns a new variable
>> +// that refers to E.
>> +// If E is trivial returns E.
>> +til::SExpr *SExprBuilder::addStatement(til::SExpr* E, const Stmt *S,
>> + const ValueDecl *VD) {
>> + if (!E)
>> + return nullptr;
>> + if (til::ThreadSafetyTIL::isTrivial(E))
>> + return E;
>>
>> - void addStatement(til::SExpr* E, const Stmt *S) {
>> - if (!E)
>> - return;
>> - if (til::ThreadSafetyTIL::isTrivial(E))
>> - return;
>> + til::Variable *V = new (Arena) til::Variable(E, VD);
>> + V->setID(CurrentBlockID, CurrentVarID++);
>> + CurrentBB->addInstr(V);
>> + if (S)
>> + insertStmt(S, V);
>> + return V;
>> +}
>>
>> - til::Variable *V = new (Arena) til::Variable(til::Variable::VK_Let, E);
>> - V->setID(CurrentBlockID, CurrentVarID++);
>> - CurrentBB->addInstr(V);
>> - if (S)
>> - BuildEx.insertStmt(S, V);
>> - }
>>
>> -public:
>> - // Enter the CFG for Decl D, and perform any initial setup operations.
>> - void enterCFG(CFG *Cfg, const NamedDecl *D, const CFGBlock *First) {
>> - Scfg = new (Arena) til::SCFG(Arena, Cfg->getNumBlockIDs());
>> - CallCtx = new SExprBuilder::CallingContext(D);
>> - }
>> +// Returns the current value of VD, if known, and nullptr otherwise.
>> +til::SExpr *SExprBuilder::lookupVarDecl(const ValueDecl *VD) {
>> + auto It = IdxMap.find(VD);
>> + if (It != IdxMap.end())
>> + return CurrentNameMap[It->second].second;
>> + return nullptr;
>> +}
>>
>> - // Enter a CFGBlock.
>> - void enterCFGBlock(const CFGBlock *B) {
>> - CurrentBB = new (Arena) til::BasicBlock(Arena, 0, B->size());
>> - CurrentBB->setBlockID(CurrentBlockID);
>> - CurrentVarID = 0;
>> - Scfg->add(CurrentBB);
>> - }
>>
>> - // Process an ordinary statement.
>> - void handleStatement(const Stmt *S) {
>> - til::SExpr *E = BuildEx.translate(S, CallCtx);
>> - addStatement(E, S);
>> +// if E is a til::Variable, update its clangDecl.
>> +inline void maybeUpdateVD(til::SExpr *E, const ValueDecl *VD) {
>> + if (!E)
>> + return;
>> + if (til::Variable *V = dyn_cast<til::Variable>(E)) {
>> + if (!V->clangDecl())
>> + V->setClangDecl(VD);
>> }
>> +}
>> +
>> +// Adds a new variable declaration.
>> +til::SExpr *SExprBuilder::addVarDecl(const ValueDecl *VD, til::SExpr *E) {
>> + maybeUpdateVD(E, VD);
>> + IdxMap.insert(std::make_pair(VD, CurrentNameMap.size()));
>> + CurrentNameMap.makeWritable();
>> + CurrentNameMap.push_back(std::make_pair(VD, E));
>> + return E;
>> +}
>> +
>> +
>> +// Updates a current variable declaration. (E.g. by assignment)
>> +til::SExpr *SExprBuilder::updateVarDecl(const ValueDecl *VD, til::SExpr *E) {
>> + maybeUpdateVD(E, VD);
>> + auto It = IdxMap.find(VD);
>> + if (It == IdxMap.end()) {
>> + til::SExpr *Ptr = new (Arena) til::LiteralPtr(VD);
>> + til::SExpr *St = new (Arena) til::Store(Ptr, E);
>> + return St;
>> + }
>> + CurrentNameMap.makeWritable();
>> + CurrentNameMap.elem(It->second).second = E;
>> + return E;
>> +}
>> +
>>
>> - // Process a destructor call
>> - void handleDestructorCall(const VarDecl *VD, const CXXDestructorDecl *DD) {
>> - til::SExpr *Sf = new (Arena) til::LiteralPtr(VD);
>> - til::SExpr *Dr = new (Arena) til::LiteralPtr(DD);
>> - til::SExpr *Ap = new (Arena) til::Apply(Dr, Sf);
>> - til::SExpr *E = new (Arena) til::Call(Ap);
>> - addStatement(E, nullptr);
>> +// Merge values from Map into the current entry map.
>> +void SExprBuilder::mergeEntryMap(NameVarMap Map) {
>> + assert(CurrentBlockInfo && "Not processing a block!");
>> +
>> + if (!CurrentNameMap.valid()) {
>> + // Steal Map, using copy-on-write.
>> + CurrentNameMap = std::move(Map);
>> + return;
>> + }
>> + if (CurrentNameMap.sameAs(Map))
>> + return; // Easy merge: maps from different predecessors are unchanged.
>> +
>> + unsigned ESz = CurrentNameMap.size();
>> + unsigned MSz = Map.size();
>> + unsigned Sz = std::max(ESz, MSz);
>> + bool W = CurrentNameMap.writable();
>> + for (unsigned i=0; i<Sz; ++i) {
>> + if (CurrentNameMap[i].first != Map[i].first) {
>> + if (!W)
>> + CurrentNameMap.makeWritable();
>> + CurrentNameMap.downsize(i);
>> + break;
>> + }
>> + if (CurrentNameMap[i].second != Map[i].second) {
>> + til::Variable *V =
>> + dyn_cast<til::Variable>(CurrentNameMap[i].second);
>> + if (V && V->getBlockID() == CurrentBB->blockID()) {
>> + // We already have a Phi node, so add the new variable.
>> + til::Phi *Ph = dyn_cast<til::Phi>(V->definition());
>> + assert(Ph && "Expecting Phi node.");
>> + Ph->values()[CurrentArgIndex] = Map[i].second;
>> + }
>> + else {
>> + if (!W)
>> + CurrentNameMap.makeWritable();
>> + unsigned NPreds = CurrentBB->numPredecessors();
>> + assert(CurrentArgIndex > 0 && CurrentArgIndex < NPreds);
>> +
>> + // Make a new phi node. All phi args up to the current index must
>> + // be the same, and equal to the current NameMap value.
>> + auto *Ph = new (Arena) til::Phi(Arena, NPreds);
>> + Ph->values().setValues(NPreds, nullptr);
>> + for (unsigned PIdx = 0; PIdx < CurrentArgIndex; ++PIdx)
>> + Ph->values()[PIdx] = CurrentNameMap[i].second;
>> + Ph->values()[CurrentArgIndex] = Map[i].second;
>> +
>> + // Add phi node to current basic block.
>> + auto *Var = new (Arena) til::Variable(Ph, CurrentNameMap[i].first);
>> + Var->setID(CurrentBlockID, CurrentVarID++);
>> + CurrentBB->addArgument(Var);
>> + CurrentNameMap.elem(i).second = Var;
>> + }
>> + }
>> + }
>> + if (ESz > MSz) {
>> + if (!W)
>> + CurrentNameMap.makeWritable();
>> + CurrentNameMap.downsize(Map.size());
>> }
>> +}
>> +
>>
>> - // Process a successor edge.
>> - void handleSuccessor(const CFGBlock *Succ) {}
>>
>> - // Process a successor back edge to a previously visited block.
>> - void handleSuccessorBackEdge(const CFGBlock *Succ) {}
>> +void SExprBuilder::enterCFG(CFG *Cfg, const NamedDecl *D,
>> + const CFGBlock *First) {
>> + // Perform initial setup operations.
>> + unsigned NBlocks = Cfg->getNumBlockIDs();
>> + Scfg = new (Arena) til::SCFG(Arena, NBlocks);
>>
>> - // Leave a CFGBlock.
>> - void exitCFGBlock(const CFGBlock *B) {
>> - CurrentBlockID++;
>> - CurrentBB = 0;
>> + // allocate all basic blocks immediately, to handle forward references.
>> + BlockMap.reserve(NBlocks);
>> + BBInfo.resize(NBlocks);
>> + for (auto *B : *Cfg) {
>> + auto *BB = new (Arena) til::BasicBlock(Arena, 0, B->size());
>> + BlockMap.push_back(BB);
>> }
>> + CallCtx = new SExprBuilder::CallingContext(D);
>> +}
>> +
>> +
>> +
>> +void SExprBuilder::enterCFGBlock(const CFGBlock *B) {
>> + // Intialize TIL basic block and add it to the CFG.
>> + CurrentBB = BlockMap[B->getBlockID()];
>> + CurrentBB->setBlockID(CurrentBlockID);
>> + CurrentBB->setNumPredecessors(B->pred_size());
>> + Scfg->add(CurrentBB);
>> +
>> + CurrentBlockInfo = &BBInfo[B->getBlockID()];
>> + CurrentVarID = 0;
>> + CurrentArgIndex = 0;
>> +
>> + assert(!CurrentNameMap.valid() && "CurrentNameMap already initialized.");
>> +}
>> +
>> +
>> +void SExprBuilder::handlePredecessor(const CFGBlock *Pred) {
>> + // Compute CurrentNameMap on entry from ExitMaps of predecessors
>> +
>> + BlockInfo *PredInfo = &BBInfo[Pred->getBlockID()];
>> + assert(PredInfo->SuccessorsToProcess > 0);
>> +
>> + if (--PredInfo->SuccessorsToProcess == 0)
>> + mergeEntryMap(std::move(PredInfo->ExitMap));
>> + else
>> + mergeEntryMap(PredInfo->ExitMap.clone());
>> +
>> + ++CurrentArgIndex;
>> +}
>> +
>> +
>> +void SExprBuilder::handlePredecessorBackEdge(const CFGBlock *Pred) {
>> + CurrentBlockInfo->HasBackEdges = true;
>> +}
>> +
>>
>> - // Leave the CFG, and perform any final cleanup operations.
>> - void exitCFG(const CFGBlock *Last) {
>> - delete CallCtx;
>> - CallCtx = nullptr;
>> +void SExprBuilder::enterCFGBlockBody(const CFGBlock *B) { }
>> +
>> +
>> +void SExprBuilder::handleStatement(const Stmt *S) {
>> + til::SExpr *E = translate(S, CallCtx);
>> + addStatement(E, S);
>> +}
>> +
>> +
>> +void SExprBuilder::handleDestructorCall(const VarDecl *VD,
>> + const CXXDestructorDecl *DD) {
>> + til::SExpr *Sf = new (Arena) til::LiteralPtr(VD);
>> + til::SExpr *Dr = new (Arena) til::LiteralPtr(DD);
>> + til::SExpr *Ap = new (Arena) til::Apply(Dr, Sf);
>> + til::SExpr *E = new (Arena) til::Call(Ap);
>> + addStatement(E, nullptr);
>> +}
>> +
>> +
>> +
>> +void SExprBuilder::exitCFGBlockBody(const CFGBlock *B) {
>> + unsigned N = B->succ_size();
>> + auto It = B->succ_begin();
>> + if (N == 1) {
>> + til::BasicBlock *BB = *It ? BlockMap[(*It)->getBlockID()] : nullptr;
>> + // TODO: set index
>> + til::SExpr *Tm = new (Arena) til::Goto(BB, 0);
>> + CurrentBB->setTerminator(Tm);
>> }
>> + else if (N == 2) {
>> + til::SExpr *C = translate(B->getTerminatorCondition(true), CallCtx);
>> + til::BasicBlock *BB1 = *It ? BlockMap[(*It)->getBlockID()] : nullptr;
>> + ++It;
>> + til::BasicBlock *BB2 = *It ? BlockMap[(*It)->getBlockID()] : nullptr;
>> + // TODO: set conditional, set index
>> + til::SExpr *Tm = new (Arena) til::Branch(C, BB1, BB2);
>> + CurrentBB->setTerminator(Tm);
>> + }
>> +}
>>
>> - SCFGBuilder(til::MemRegionRef A)
>> - : Arena(A), Scfg(nullptr), CurrentBB(nullptr), CurrentBlockID(0),
>> - CurrentVarID(0), CallCtx(nullptr),
>> - SMap(new SExprBuilder::StatementMap()), BuildEx(A, SMap) {}
>> - ~SCFGBuilder() { delete SMap; }
>>
>> - til::SCFG *getCFG() const { return Scfg; }
>> +void SExprBuilder::handleSuccessor(const CFGBlock *Succ) {
>> + ++CurrentBlockInfo->SuccessorsToProcess;
>> +}
>>
>> -private:
>> - til::MemRegionRef Arena;
>> - til::SCFG *Scfg;
>> - til::BasicBlock *CurrentBB;
>> - unsigned CurrentBlockID;
>> - unsigned CurrentVarID;
>>
>> - SExprBuilder::CallingContext *CallCtx;
>> - SExprBuilder::StatementMap *SMap;
>> - SExprBuilder BuildEx;
>> -};
>> +void SExprBuilder::handleSuccessorBackEdge(const CFGBlock *Succ) {
>> +
>> +}
>> +
>> +
>> +void SExprBuilder::exitCFGBlock(const CFGBlock *B) {
>> + CurrentBlockInfo->ExitMap = std::move(CurrentNameMap);
>> + CurrentBlockID++;
>> + CurrentBB = nullptr;
>> + CurrentBlockInfo = nullptr;
>> +}
>> +
>> +
>> +void SExprBuilder::exitCFG(const CFGBlock *Last) {
>> + CurrentBlockID = 0;
>> + CurrentVarID = 0;
>> + CurrentArgIndex = 0;
>> +}
>>
>>
>>
>> -class LLVMPrinter :
>> - public til::PrettyPrinter<LLVMPrinter, llvm::raw_ostream> {
>> +class LLVMPrinter : public til::PrettyPrinter<LLVMPrinter, llvm::raw_ostream> {
>> };
>>
>>
>> -void printSCFG(CFGWalker &walker) {
>> +void printSCFG(CFGWalker &Walker) {
>> llvm::BumpPtrAllocator Bpa;
>> til::MemRegionRef Arena(&Bpa);
>> - SCFGBuilder builder(Arena);
>> - // CFGVisitor visitor;
>> - walker.walk(builder);
>> - LLVMPrinter::print(builder.getCFG(), llvm::errs());
>> + SExprBuilder builder(Arena);
>> + til::SCFG *Cfg = builder.buildCFG(Walker);
>> + LLVMPrinter::print(Cfg, llvm::errs());
>> }
>>
>>
>>
>>
>> _______________________________________________
>> cfe-commits mailing list
>> cfe-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
More information about the cfe-commits
mailing list