diff options
Diffstat (limited to 'contrib/llvm/tools/clang/lib/Analysis')
11 files changed, 1948 insertions, 256 deletions
diff --git a/contrib/llvm/tools/clang/lib/Analysis/AnalysisDeclContext.cpp b/contrib/llvm/tools/clang/lib/Analysis/AnalysisDeclContext.cpp index 5ff7842..465f0c3 100644 --- a/contrib/llvm/tools/clang/lib/Analysis/AnalysisDeclContext.cpp +++ b/contrib/llvm/tools/clang/lib/Analysis/AnalysisDeclContext.cpp @@ -157,6 +157,19 @@ AnalysisDeclContext::getBlockForRegisteredExpression(const Stmt *stmt) { return itr->second; } +/// Add each synthetic statement in the CFG to the parent map, using the +/// source statement's parent. +static void addParentsForSyntheticStmts(const CFG *TheCFG, ParentMap &PM) { + if (!TheCFG) + return; + + for (CFG::synthetic_stmt_iterator I = TheCFG->synthetic_stmt_begin(), + E = TheCFG->synthetic_stmt_end(); + I != E; ++I) { + PM.setParent(I->first, PM.getParent(I->second)); + } +} + CFG *AnalysisDeclContext::getCFG() { if (!cfgBuildOptions.PruneTriviallyFalseEdges) return getUnoptimizedCFG(); @@ -167,6 +180,9 @@ CFG *AnalysisDeclContext::getCFG() { // Even when the cfg is not successfully built, we don't // want to try building it again. builtCFG = true; + + if (PM) + addParentsForSyntheticStmts(cfg.get(), *PM); } return cfg.get(); } @@ -180,6 +196,9 @@ CFG *AnalysisDeclContext::getUnoptimizedCFG() { // Even when the cfg is not successfully built, we don't // want to try building it again. builtCompleteCFG = true; + + if (PM) + addParentsForSyntheticStmts(completeCFG.get(), *PM); } return completeCFG.get(); } @@ -222,6 +241,10 @@ ParentMap &AnalysisDeclContext::getParentMap() { PM->addStmt((*I)->getInit()); } } + if (builtCFG) + addParentsForSyntheticStmts(getCFG(), *PM); + if (builtCompleteCFG) + addParentsForSyntheticStmts(getUnoptimizedCFG(), *PM); } return *PM; } @@ -387,7 +410,7 @@ bool LocationContext::isParentOf(const LocationContext *LC) const { return false; } -void LocationContext::dumpStack() const { +void LocationContext::dumpStack(raw_ostream &OS, StringRef Indent) const { ASTContext &Ctx = getAnalysisDeclContext()->getASTContext(); PrintingPolicy PP(Ctx.getLangOpts()); PP.TerseOutput = 1; @@ -396,15 +419,15 @@ void LocationContext::dumpStack() const { for (const LocationContext *LCtx = this; LCtx; LCtx = LCtx->getParent()) { switch (LCtx->getKind()) { case StackFrame: - llvm::errs() << '#' << Frame++ << ' '; - cast<StackFrameContext>(LCtx)->getDecl()->print(llvm::errs(), PP); - llvm::errs() << '\n'; + OS << Indent << '#' << Frame++ << ' '; + cast<StackFrameContext>(LCtx)->getDecl()->print(OS, PP); + OS << '\n'; break; case Scope: - llvm::errs() << " (scope)\n"; + OS << Indent << " (scope)\n"; break; case Block: - llvm::errs() << " (block context: " + OS << Indent << " (block context: " << cast<BlockInvocationContext>(LCtx)->getContextData() << ")\n"; break; @@ -412,6 +435,10 @@ void LocationContext::dumpStack() const { } } +void LocationContext::dumpStack() const { + dumpStack(llvm::errs()); +} + //===----------------------------------------------------------------------===// // Lazily generated map to query the external variables referenced by a Block. //===----------------------------------------------------------------------===// diff --git a/contrib/llvm/tools/clang/lib/Analysis/CFG.cpp b/contrib/llvm/tools/clang/lib/Analysis/CFG.cpp index 096c7a0..8b8c573 100644 --- a/contrib/llvm/tools/clang/lib/Analysis/CFG.cpp +++ b/contrib/llvm/tools/clang/lib/Analysis/CFG.cpp @@ -19,6 +19,7 @@ #include "clang/AST/DeclCXX.h" #include "clang/AST/PrettyPrinter.h" #include "clang/AST/StmtVisitor.h" +#include "clang/Basic/Builtins.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/OwningPtr.h" #include "llvm/ADT/SmallPtrSet.h" @@ -155,7 +156,7 @@ public: return !(*this == rhs); } - operator bool() const { + LLVM_EXPLICIT operator bool() const { return *this != const_iterator(); } @@ -362,6 +363,7 @@ private: AddStmtChoice asc); CFGBlock *VisitCXXCatchStmt(CXXCatchStmt *S); CFGBlock *VisitCXXConstructExpr(CXXConstructExpr *C, AddStmtChoice asc); + CFGBlock *VisitCXXDeleteExpr(CXXDeleteExpr *DE, AddStmtChoice asc); CFGBlock *VisitCXXForRangeStmt(CXXForRangeStmt *S); CFGBlock *VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E, AddStmtChoice asc); @@ -470,6 +472,10 @@ private: B->appendAutomaticObjDtor(VD, S, cfg->getBumpVectorContext()); } + void appendDeleteDtor(CFGBlock *B, CXXRecordDecl *RD, CXXDeleteExpr *DE) { + B->appendDeleteDtor(RD, DE, cfg->getBumpVectorContext()); + } + void prependAutomaticObjDtorsWithTerminator(CFGBlock *Blk, LocalScope::const_iterator B, LocalScope::const_iterator E); @@ -974,10 +980,23 @@ LocalScope* CFGBuilder::addLocalScopeForVarDecl(VarDecl *VD, // Check for const references bound to temporary. Set type to pointee. QualType QT = VD->getType(); if (QT.getTypePtr()->isReferenceType()) { - if (!VD->extendsLifetimeOfTemporary()) + // Attempt to determine whether this declaration lifetime-extends a + // temporary. + // + // FIXME: This is incorrect. Non-reference declarations can lifetime-extend + // temporaries, and a single declaration can extend multiple temporaries. + // We should look at the storage duration on each nested + // MaterializeTemporaryExpr instead. + const Expr *Init = VD->getInit(); + if (!Init) + return Scope; + if (const ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(Init)) + Init = EWC->getSubExpr(); + if (!isa<MaterializeTemporaryExpr>(Init)) return Scope; - QT = getReferenceInitTemporaryType(*Context, VD->getInit()); + // Lifetime-extending a temporary. + QT = getReferenceInitTemporaryType(*Context, Init); } // Check for constant size array. Set type to array element type. @@ -1103,6 +1122,9 @@ CFGBlock *CFGBuilder::Visit(Stmt * S, AddStmtChoice asc) { case Stmt::CXXConstructExprClass: return VisitCXXConstructExpr(cast<CXXConstructExpr>(S), asc); + case Stmt::CXXDeleteExprClass: + return VisitCXXDeleteExpr(cast<CXXDeleteExpr>(S), asc); + case Stmt::CXXFunctionalCastExprClass: return VisitCXXFunctionalCastExpr(cast<CXXFunctionalCastExpr>(S), asc); @@ -1449,18 +1471,33 @@ CFGBlock *CFGBuilder::VisitCallExpr(CallExpr *C, AddStmtChoice asc) { AddEHEdge = true; } + // If this is a call to a builtin function, it might not actually evaluate + // its arguments. Don't add them to the CFG if this is the case. + bool OmitArguments = false; + if (FunctionDecl *FD = C->getDirectCallee()) { if (FD->isNoReturn()) NoReturn = true; if (FD->hasAttr<NoThrowAttr>()) AddEHEdge = false; + if (FD->getBuiltinID() == Builtin::BI__builtin_object_size) + OmitArguments = true; } if (!CanThrow(C->getCallee(), *Context)) AddEHEdge = false; - if (!NoReturn && !AddEHEdge) + if (OmitArguments) { + assert(!NoReturn && "noreturn calls with unevaluated args not implemented"); + assert(!AddEHEdge && "EH calls with unevaluated args not implemented"); + autoCreateBlock(); + appendStmt(Block, C); + return Visit(C->getCallee()); + } + + if (!NoReturn && !AddEHEdge) { return VisitStmt(C, asc.withAlwaysAdd(true)); + } if (Block) { Succ = Block; @@ -1627,6 +1664,7 @@ CFGBlock *CFGBuilder::VisitDeclStmt(DeclStmt *DS) { Decl *D = *I; void *Mem = cfg->getAllocator().Allocate(sizeof(DeclStmt), A); DeclStmt *DSNew = new (Mem) DeclStmt(DG, D->getLocation(), GetEndLoc(D)); + cfg->addSyntheticDeclStmt(DSNew, DS); // Append the fake DeclStmt to block. B = VisitDeclSubExpr(DSNew); @@ -1639,19 +1677,11 @@ CFGBlock *CFGBuilder::VisitDeclStmt(DeclStmt *DS) { /// DeclStmts and initializers in them. CFGBlock *CFGBuilder::VisitDeclSubExpr(DeclStmt *DS) { assert(DS->isSingleDecl() && "Can handle single declarations only."); - Decl *D = DS->getSingleDecl(); - - if (isa<StaticAssertDecl>(D)) { - // static_asserts aren't added to the CFG because they do not impact - // runtime semantics. - return Block; - } - VarDecl *VD = dyn_cast<VarDecl>(DS->getSingleDecl()); if (!VD) { - autoCreateBlock(); - appendStmt(Block, DS); + // Of everything that can be declared in a DeclStmt, only VarDecls impact + // runtime semantics. return Block; } @@ -1869,9 +1899,12 @@ CFGBlock *CFGBuilder::VisitReturnStmt(ReturnStmt *R) { // Create the new block. Block = createBlock(false); - // The Exit block is the only successor. addAutomaticObjDtors(ScopePos, LocalScope::const_iterator(), R); - addSuccessor(Block, &cfg->getExit()); + + // If the one of the destructors does not return, we already have the Exit + // block as a successor. + if (!Block->hasNoReturnElement()) + addSuccessor(Block, &cfg->getExit()); // Add the return statement to the block. This may create new blocks if R // contains control-flow (short-circuit operations). @@ -2190,17 +2223,24 @@ CFGBlock *CFGBuilder::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { // Now create the true branch. { // Save the current values for Succ, continue and break targets. - SaveAndRestore<CFGBlock*> save_Succ(Succ); + SaveAndRestore<CFGBlock*> save_Block(Block), save_Succ(Succ); SaveAndRestore<JumpTarget> save_continue(ContinueJumpTarget), - save_break(BreakJumpTarget); + save_break(BreakJumpTarget); + // Add an intermediate block between the BodyBlock and the + // EntryConditionBlock to represent the "loop back" transition, for looping + // back to the head of the loop. + CFGBlock *LoopBackBlock = 0; + Succ = LoopBackBlock = createBlock(); + LoopBackBlock->setLoopTarget(S); + BreakJumpTarget = JumpTarget(LoopSuccessor, ScopePos); - ContinueJumpTarget = JumpTarget(EntryConditionBlock, ScopePos); + ContinueJumpTarget = JumpTarget(Succ, ScopePos); CFGBlock *BodyBlock = addStmt(S->getBody()); if (!BodyBlock) - BodyBlock = EntryConditionBlock; // can happen for "for (X in Y) ;" + BodyBlock = ContinueJumpTarget.block; // can happen for "for (X in Y) ;" else if (Block) { if (badCFG) return 0; @@ -2679,9 +2719,15 @@ CFGBlock *CFGBuilder::VisitSwitchStmt(SwitchStmt *Terminator) { // If we have no "default:" case, the default transition is to the code // following the switch body. Moreover, take into account if all the // cases of a switch are covered (e.g., switching on an enum value). + // + // Note: We add a successor to a switch that is considered covered yet has no + // case statements if the enumeration has no enumerators. + bool SwitchAlwaysHasSuccessor = false; + SwitchAlwaysHasSuccessor |= switchExclusivelyCovered; + SwitchAlwaysHasSuccessor |= Terminator->isAllEnumCasesCovered() && + Terminator->getSwitchCaseList(); addSuccessor(SwitchTerminatedBlock, - switchExclusivelyCovered || Terminator->isAllEnumCasesCovered() - ? 0 : DefaultCaseBlock); + SwitchAlwaysHasSuccessor ? 0 : DefaultCaseBlock); // Add the terminator and condition in the switch block. SwitchTerminatedBlock->setTerminator(Terminator); @@ -3078,6 +3124,22 @@ CFGBlock *CFGBuilder::VisitCXXConstructExpr(CXXConstructExpr *C, return VisitChildren(C); } + +CFGBlock *CFGBuilder::VisitCXXDeleteExpr(CXXDeleteExpr *DE, + AddStmtChoice asc) { + autoCreateBlock(); + appendStmt(Block, DE); + QualType DTy = DE->getDestroyedType(); + DTy = DTy.getNonReferenceType(); + CXXRecordDecl *RD = Context->getBaseElementType(DTy)->getAsCXXRecordDecl(); + if (RD) { + if (RD->isCompleteDefinition() && !RD->hasTrivialDestructor()) + appendDeleteDtor(Block, RD, DE); + } + + return VisitChildren(DE); +} + CFGBlock *CFGBuilder::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E, AddStmtChoice asc) { if (asc.alwaysAdd(*this, E)) { @@ -3378,6 +3440,14 @@ CFGImplicitDtor::getDestructorDecl(ASTContext &astContext) const { cast<CXXRecordDecl>(recordType->getDecl()); return classDecl->getDestructor(); } + case CFGElement::DeleteDtor: { + const CXXDeleteExpr *DE = castAs<CFGDeleteDtor>().getDeleteExpr(); + QualType DTy = DE->getDestroyedType(); + DTy = DTy.getNonReferenceType(); + const CXXRecordDecl *classDecl = + astContext.getBaseElementType(DTy)->getAsCXXRecordDecl(); + return classDecl->getDestructor(); + } case CFGElement::TemporaryDtor: { const CXXBindTemporaryExpr *bindExpr = castAs<CFGTemporaryDtor>().getBindTemporaryExpr(); @@ -3400,113 +3470,6 @@ bool CFGImplicitDtor::isNoReturn(ASTContext &astContext) const { } //===----------------------------------------------------------------------===// -// CFG: Queries for BlkExprs. -//===----------------------------------------------------------------------===// - -namespace { - typedef llvm::DenseMap<const Stmt*,unsigned> BlkExprMapTy; -} - -static void FindSubExprAssignments(const Stmt *S, - llvm::SmallPtrSet<const Expr*,50>& Set) { - if (!S) - return; - - for (Stmt::const_child_range I = S->children(); I; ++I) { - const Stmt *child = *I; - if (!child) - continue; - - if (const BinaryOperator* B = dyn_cast<BinaryOperator>(child)) - if (B->isAssignmentOp()) Set.insert(B); - - FindSubExprAssignments(child, Set); - } -} - -static BlkExprMapTy* PopulateBlkExprMap(CFG& cfg) { - BlkExprMapTy* M = new BlkExprMapTy(); - - // Look for assignments that are used as subexpressions. These are the only - // assignments that we want to *possibly* register as a block-level - // expression. Basically, if an assignment occurs both in a subexpression and - // at the block-level, it is a block-level expression. - llvm::SmallPtrSet<const Expr*,50> SubExprAssignments; - - for (CFG::iterator I=cfg.begin(), E=cfg.end(); I != E; ++I) - for (CFGBlock::iterator BI=(*I)->begin(), EI=(*I)->end(); BI != EI; ++BI) - if (Optional<CFGStmt> S = BI->getAs<CFGStmt>()) - FindSubExprAssignments(S->getStmt(), SubExprAssignments); - - for (CFG::iterator I=cfg.begin(), E=cfg.end(); I != E; ++I) { - - // Iterate over the statements again on identify the Expr* and Stmt* at the - // block-level that are block-level expressions. - - for (CFGBlock::iterator BI=(*I)->begin(), EI=(*I)->end(); BI != EI; ++BI) { - Optional<CFGStmt> CS = BI->getAs<CFGStmt>(); - if (!CS) - continue; - if (const Expr *Exp = dyn_cast<Expr>(CS->getStmt())) { - assert((Exp->IgnoreParens() == Exp) && "No parens on block-level exps"); - - if (const BinaryOperator* B = dyn_cast<BinaryOperator>(Exp)) { - // Assignment expressions that are not nested within another - // expression are really "statements" whose value is never used by - // another expression. - if (B->isAssignmentOp() && !SubExprAssignments.count(Exp)) - continue; - } else if (const StmtExpr *SE = dyn_cast<StmtExpr>(Exp)) { - // Special handling for statement expressions. The last statement in - // the statement expression is also a block-level expr. - const CompoundStmt *C = SE->getSubStmt(); - if (!C->body_empty()) { - const Stmt *Last = C->body_back(); - if (const Expr *LastEx = dyn_cast<Expr>(Last)) - Last = LastEx->IgnoreParens(); - unsigned x = M->size(); - (*M)[Last] = x; - } - } - - unsigned x = M->size(); - (*M)[Exp] = x; - } - } - - // Look at terminators. The condition is a block-level expression. - - Stmt *S = (*I)->getTerminatorCondition(); - - if (S && M->find(S) == M->end()) { - unsigned x = M->size(); - (*M)[S] = x; - } - } - - return M; -} - -CFG::BlkExprNumTy CFG::getBlkExprNum(const Stmt *S) { - assert(S != NULL); - if (!BlkExprMap) { BlkExprMap = (void*) PopulateBlkExprMap(*this); } - - BlkExprMapTy* M = reinterpret_cast<BlkExprMapTy*>(BlkExprMap); - BlkExprMapTy::iterator I = M->find(S); - return (I == M->end()) ? CFG::BlkExprNumTy() : CFG::BlkExprNumTy(I->second); -} - -unsigned CFG::getNumBlkExprs() { - if (const BlkExprMapTy* M = reinterpret_cast<const BlkExprMapTy*>(BlkExprMap)) - return M->size(); - - // We assume callers interested in the number of BlkExprs will want - // the map constructed if it doesn't already exist. - BlkExprMap = (void*) PopulateBlkExprMap(*this); - return reinterpret_cast<BlkExprMapTy*>(BlkExprMap)->size(); -} - -//===----------------------------------------------------------------------===// // Filtered walking of the CFG. //===----------------------------------------------------------------------===// @@ -3530,14 +3493,6 @@ bool CFGBlock::FilterEdge(const CFGBlock::FilterOptions &F, } //===----------------------------------------------------------------------===// -// Cleanup: CFG dstor. -//===----------------------------------------------------------------------===// - -CFG::~CFG() { - delete reinterpret_cast<const BlkExprMapTy*>(BlkExprMap); -} - -//===----------------------------------------------------------------------===// // CFG pretty printing //===----------------------------------------------------------------------===// @@ -3753,35 +3708,32 @@ public: }; } // end anonymous namespace -static void print_elem(raw_ostream &OS, StmtPrinterHelper* Helper, +static void print_elem(raw_ostream &OS, StmtPrinterHelper &Helper, const CFGElement &E) { if (Optional<CFGStmt> CS = E.getAs<CFGStmt>()) { const Stmt *S = CS->getStmt(); - if (Helper) { - - // special printing for statement-expressions. - if (const StmtExpr *SE = dyn_cast<StmtExpr>(S)) { - const CompoundStmt *Sub = SE->getSubStmt(); - - if (Sub->children()) { - OS << "({ ... ; "; - Helper->handledStmt(*SE->getSubStmt()->body_rbegin(),OS); - OS << " })\n"; - return; - } + // special printing for statement-expressions. + if (const StmtExpr *SE = dyn_cast<StmtExpr>(S)) { + const CompoundStmt *Sub = SE->getSubStmt(); + + if (Sub->children()) { + OS << "({ ... ; "; + Helper.handledStmt(*SE->getSubStmt()->body_rbegin(),OS); + OS << " })\n"; + return; } - // special printing for comma expressions. - if (const BinaryOperator* B = dyn_cast<BinaryOperator>(S)) { - if (B->getOpcode() == BO_Comma) { - OS << "... , "; - Helper->handledStmt(B->getRHS(),OS); - OS << '\n'; - return; - } + } + // special printing for comma expressions. + if (const BinaryOperator* B = dyn_cast<BinaryOperator>(S)) { + if (B->getOpcode() == BO_Comma) { + OS << "... , "; + Helper.handledStmt(B->getRHS(),OS); + OS << '\n'; + return; } } - S->printPretty(OS, Helper, PrintingPolicy(Helper->getLangOpts())); + S->printPretty(OS, &Helper, PrintingPolicy(Helper.getLangOpts())); if (isa<CXXOperatorCallExpr>(S)) { OS << " (OperatorCall)"; @@ -3807,21 +3759,25 @@ static void print_elem(raw_ostream &OS, StmtPrinterHelper* Helper, const CXXCtorInitializer *I = IE->getInitializer(); if (I->isBaseInitializer()) OS << I->getBaseClass()->getAsCXXRecordDecl()->getName(); + else if (I->isDelegatingInitializer()) + OS << I->getTypeSourceInfo()->getType()->getAsCXXRecordDecl()->getName(); else OS << I->getAnyMember()->getName(); OS << "("; if (Expr *IE = I->getInit()) - IE->printPretty(OS, Helper, PrintingPolicy(Helper->getLangOpts())); + IE->printPretty(OS, &Helper, PrintingPolicy(Helper.getLangOpts())); OS << ")"; if (I->isBaseInitializer()) OS << " (Base initializer)\n"; + else if (I->isDelegatingInitializer()) + OS << " (Delegating initializer)\n"; else OS << " (Member initializer)\n"; } else if (Optional<CFGAutomaticObjDtor> DE = E.getAs<CFGAutomaticObjDtor>()) { const VarDecl *VD = DE->getVarDecl(); - Helper->handleDecl(VD, OS); + Helper.handleDecl(VD, OS); const Type* T = VD->getType().getTypePtr(); if (const ReferenceType* RT = T->getAs<ReferenceType>()) @@ -3831,6 +3787,15 @@ static void print_elem(raw_ostream &OS, StmtPrinterHelper* Helper, OS << ".~" << T->getAsCXXRecordDecl()->getName().str() << "()"; OS << " (Implicit destructor)\n"; + } else if (Optional<CFGDeleteDtor> DE = E.getAs<CFGDeleteDtor>()) { + const CXXRecordDecl *RD = DE->getCXXRecordDecl(); + if (!RD) + return; + CXXDeleteExpr *DelExpr = + const_cast<CXXDeleteExpr*>(DE->getDeleteExpr()); + Helper.handledStmt(cast<Stmt>(DelExpr->getArgument()), OS); + OS << "->~" << RD->getName().str() << "()"; + OS << " (Implicit destructor)\n"; } else if (Optional<CFGBaseDtor> BE = E.getAs<CFGBaseDtor>()) { const CXXBaseSpecifier *BS = BE->getBaseSpecifier(); OS << "~" << BS->getType()->getAsCXXRecordDecl()->getName() << "()"; @@ -3845,18 +3810,18 @@ static void print_elem(raw_ostream &OS, StmtPrinterHelper* Helper, } else if (Optional<CFGTemporaryDtor> TE = E.getAs<CFGTemporaryDtor>()) { const CXXBindTemporaryExpr *BT = TE->getBindTemporaryExpr(); - OS << "~" << BT->getType()->getAsCXXRecordDecl()->getName() << "()"; - OS << " (Temporary object destructor)\n"; + OS << "~"; + BT->getType().print(OS, PrintingPolicy(Helper.getLangOpts())); + OS << "() (Temporary object destructor)\n"; } } static void print_block(raw_ostream &OS, const CFG* cfg, const CFGBlock &B, - StmtPrinterHelper* Helper, bool print_edges, + StmtPrinterHelper &Helper, bool print_edges, bool ShowColors) { - if (Helper) - Helper->setBlockID(B.getBlockID()); + Helper.setBlockID(B.getBlockID()); // Print the header. if (ShowColors) @@ -3886,19 +3851,19 @@ static void print_block(raw_ostream &OS, const CFG* cfg, OS << L->getName(); else if (CaseStmt *C = dyn_cast<CaseStmt>(Label)) { OS << "case "; - C->getLHS()->printPretty(OS, Helper, - PrintingPolicy(Helper->getLangOpts())); + C->getLHS()->printPretty(OS, &Helper, + PrintingPolicy(Helper.getLangOpts())); if (C->getRHS()) { OS << " ... "; - C->getRHS()->printPretty(OS, Helper, - PrintingPolicy(Helper->getLangOpts())); + C->getRHS()->printPretty(OS, &Helper, + PrintingPolicy(Helper.getLangOpts())); } } else if (isa<DefaultStmt>(Label)) OS << "default"; else if (CXXCatchStmt *CS = dyn_cast<CXXCatchStmt>(Label)) { OS << "catch ("; if (CS->getExceptionDecl()) - CS->getExceptionDecl()->print(OS, PrintingPolicy(Helper->getLangOpts()), + CS->getExceptionDecl()->print(OS, PrintingPolicy(Helper.getLangOpts()), 0); else OS << "..."; @@ -3922,8 +3887,7 @@ static void print_block(raw_ostream &OS, const CFG* cfg, OS << llvm::format("%3d", j) << ": "; - if (Helper) - Helper->setStmtID(j); + Helper.setStmtID(j); print_elem(OS, Helper, *I); } @@ -3935,10 +3899,10 @@ static void print_block(raw_ostream &OS, const CFG* cfg, OS << " T: "; - if (Helper) Helper->setBlockID(-1); + Helper.setBlockID(-1); - PrintingPolicy PP(Helper ? Helper->getLangOpts() : LangOptions()); - CFGBlockTerminatorPrint TPrinter(OS, Helper, PP); + PrintingPolicy PP(Helper.getLangOpts()); + CFGBlockTerminatorPrint TPrinter(OS, &Helper, PP); TPrinter.Visit(const_cast<Stmt*>(B.getTerminator().getStmt())); OS << '\n'; @@ -4020,7 +3984,7 @@ void CFG::print(raw_ostream &OS, const LangOptions &LO, bool ShowColors) const { StmtPrinterHelper Helper(this, LO); // Print the entry block. - print_block(OS, this, getEntry(), &Helper, true, ShowColors); + print_block(OS, this, getEntry(), Helper, true, ShowColors); // Iterate through the CFGBlocks and print them one by one. for (const_iterator I = Blocks.begin(), E = Blocks.end() ; I != E ; ++I) { @@ -4028,11 +3992,11 @@ void CFG::print(raw_ostream &OS, const LangOptions &LO, bool ShowColors) const { if (&(**I) == &getEntry() || &(**I) == &getExit()) continue; - print_block(OS, this, **I, &Helper, true, ShowColors); + print_block(OS, this, **I, Helper, true, ShowColors); } // Print the exit block. - print_block(OS, this, getExit(), &Helper, true, ShowColors); + print_block(OS, this, getExit(), Helper, true, ShowColors); OS << '\n'; OS.flush(); } @@ -4048,7 +4012,7 @@ void CFGBlock::dump(const CFG* cfg, const LangOptions &LO, void CFGBlock::print(raw_ostream &OS, const CFG* cfg, const LangOptions &LO, bool ShowColors) const { StmtPrinterHelper Helper(cfg, LO); - print_block(OS, cfg, *this, &Helper, true, ShowColors); + print_block(OS, cfg, *this, Helper, true, ShowColors); OS << '\n'; } @@ -4070,6 +4034,10 @@ Stmt *CFGBlock::getTerminatorCondition() { default: break; + case Stmt::CXXForRangeStmtClass: + E = cast<CXXForRangeStmt>(Terminator)->getCond(); + break; + case Stmt::ForStmtClass: E = cast<ForStmt>(Terminator)->getCond(); break; @@ -4146,7 +4114,7 @@ struct DOTGraphTraits<const CFG*> : public DefaultDOTGraphTraits { #ifndef NDEBUG std::string OutSStr; llvm::raw_string_ostream Out(OutSStr); - print_block(Out,Graph, *Node, GraphHelper, false, false); + print_block(Out,Graph, *Node, *GraphHelper, false, false); std::string& OutStr = Out.str(); if (OutStr[0] == '\n') OutStr.erase(OutStr.begin()); diff --git a/contrib/llvm/tools/clang/lib/Analysis/CFGReachabilityAnalysis.cpp b/contrib/llvm/tools/clang/lib/Analysis/CFGReachabilityAnalysis.cpp index e77e72f..492e66f 100644 --- a/contrib/llvm/tools/clang/lib/Analysis/CFGReachabilityAnalysis.cpp +++ b/contrib/llvm/tools/clang/lib/Analysis/CFGReachabilityAnalysis.cpp @@ -50,11 +50,10 @@ void CFGReverseBlockReachabilityAnalysis::mapReachability(const CFGBlock *Dst) { // multiple queries relating to a destination node. worklist.push_back(Dst); bool firstRun = true; - - while (!worklist.empty()) { - const CFGBlock *block = worklist.back(); - worklist.pop_back(); - + + while (!worklist.empty()) { + const CFGBlock *block = worklist.pop_back_val(); + if (visited[block->getBlockID()]) continue; visited[block->getBlockID()] = true; diff --git a/contrib/llvm/tools/clang/lib/Analysis/Consumed.cpp b/contrib/llvm/tools/clang/lib/Analysis/Consumed.cpp new file mode 100644 index 0000000..b33c8d8 --- /dev/null +++ b/contrib/llvm/tools/clang/lib/Analysis/Consumed.cpp @@ -0,0 +1,1521 @@ +//===- Consumed.cpp --------------------------------------------*- C++ --*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// A intra-procedural analysis for checking consumed properties. This is based, +// in part, on research on linear types. +// +//===----------------------------------------------------------------------===// + +#include "clang/AST/ASTContext.h" +#include "clang/AST/Attr.h" +#include "clang/AST/DeclCXX.h" +#include "clang/AST/ExprCXX.h" +#include "clang/AST/RecursiveASTVisitor.h" +#include "clang/AST/StmtVisitor.h" +#include "clang/AST/StmtCXX.h" +#include "clang/AST/Type.h" +#include "clang/Analysis/Analyses/PostOrderCFGView.h" +#include "clang/Analysis/AnalysisContext.h" +#include "clang/Analysis/CFG.h" +#include "clang/Analysis/Analyses/Consumed.h" +#include "clang/Basic/OperatorKinds.h" +#include "clang/Basic/SourceLocation.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/OwningPtr.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/Support/Compiler.h" +#include "llvm/Support/raw_ostream.h" + +// TODO: Adjust states of args to constructors in the same way that arguments to +// function calls are handled. +// TODO: Use information from tests in for- and while-loop conditional. +// TODO: Add notes about the actual and expected state for +// TODO: Correctly identify unreachable blocks when chaining boolean operators. +// TODO: Adjust the parser and AttributesList class to support lists of +// identifiers. +// TODO: Warn about unreachable code. +// TODO: Switch to using a bitmap to track unreachable blocks. +// TODO: Handle variable definitions, e.g. bool valid = x.isValid(); +// if (valid) ...; (Deferred) +// TODO: Take notes on state transitions to provide better warning messages. +// (Deferred) +// TODO: Test nested conditionals: A) Checking the same value multiple times, +// and 2) Checking different values. (Deferred) + +using namespace clang; +using namespace consumed; + +// Key method definition +ConsumedWarningsHandlerBase::~ConsumedWarningsHandlerBase() {} + +static SourceLocation getFirstStmtLoc(const CFGBlock *Block) { + // Find the source location of the first statement in the block, if the block + // is not empty. + for (CFGBlock::const_iterator BI = Block->begin(), BE = Block->end(); + BI != BE; ++BI) { + if (Optional<CFGStmt> CS = BI->getAs<CFGStmt>()) + return CS->getStmt()->getLocStart(); + } + + // Block is empty. + // If we have one successor, return the first statement in that block + if (Block->succ_size() == 1 && *Block->succ_begin()) + return getFirstStmtLoc(*Block->succ_begin()); + + return SourceLocation(); +} + +static SourceLocation getLastStmtLoc(const CFGBlock *Block) { + // Find the source location of the last statement in the block, if the block + // is not empty. + if (const Stmt *StmtNode = Block->getTerminator()) { + return StmtNode->getLocStart(); + } else { + for (CFGBlock::const_reverse_iterator BI = Block->rbegin(), + BE = Block->rend(); BI != BE; ++BI) { + if (Optional<CFGStmt> CS = BI->getAs<CFGStmt>()) + return CS->getStmt()->getLocStart(); + } + } + + // If we have one successor, return the first statement in that block + SourceLocation Loc; + if (Block->succ_size() == 1 && *Block->succ_begin()) + Loc = getFirstStmtLoc(*Block->succ_begin()); + if (Loc.isValid()) + return Loc; + + // If we have one predecessor, return the last statement in that block + if (Block->pred_size() == 1 && *Block->pred_begin()) + return getLastStmtLoc(*Block->pred_begin()); + + return Loc; +} + +static ConsumedState invertConsumedUnconsumed(ConsumedState State) { + switch (State) { + case CS_Unconsumed: + return CS_Consumed; + case CS_Consumed: + return CS_Unconsumed; + case CS_None: + return CS_None; + case CS_Unknown: + return CS_Unknown; + } + llvm_unreachable("invalid enum"); +} + +static bool isCallableInState(const CallableWhenAttr *CWAttr, + ConsumedState State) { + + CallableWhenAttr::callableState_iterator I = CWAttr->callableState_begin(), + E = CWAttr->callableState_end(); + + for (; I != E; ++I) { + + ConsumedState MappedAttrState = CS_None; + + switch (*I) { + case CallableWhenAttr::Unknown: + MappedAttrState = CS_Unknown; + break; + + case CallableWhenAttr::Unconsumed: + MappedAttrState = CS_Unconsumed; + break; + + case CallableWhenAttr::Consumed: + MappedAttrState = CS_Consumed; + break; + } + + if (MappedAttrState == State) + return true; + } + + return false; +} + +static bool isConsumableType(const QualType &QT) { + if (QT->isPointerType() || QT->isReferenceType()) + return false; + + if (const CXXRecordDecl *RD = QT->getAsCXXRecordDecl()) + return RD->hasAttr<ConsumableAttr>(); + + return false; +} + +static bool isKnownState(ConsumedState State) { + switch (State) { + case CS_Unconsumed: + case CS_Consumed: + return true; + case CS_None: + case CS_Unknown: + return false; + } + llvm_unreachable("invalid enum"); +} + +static bool isRValueRefish(QualType ParamType) { + return ParamType->isRValueReferenceType() || + (ParamType->isLValueReferenceType() && + !cast<LValueReferenceType>( + ParamType.getCanonicalType())->isSpelledAsLValue()); +} + +static bool isTestingFunction(const FunctionDecl *FunDecl) { + return FunDecl->hasAttr<TestTypestateAttr>(); +} + +static bool isValueType(QualType ParamType) { + return !(ParamType->isPointerType() || ParamType->isReferenceType()); +} + +static ConsumedState mapConsumableAttrState(const QualType QT) { + assert(isConsumableType(QT)); + + const ConsumableAttr *CAttr = + QT->getAsCXXRecordDecl()->getAttr<ConsumableAttr>(); + + switch (CAttr->getDefaultState()) { + case ConsumableAttr::Unknown: + return CS_Unknown; + case ConsumableAttr::Unconsumed: + return CS_Unconsumed; + case ConsumableAttr::Consumed: + return CS_Consumed; + } + llvm_unreachable("invalid enum"); +} + +static ConsumedState +mapParamTypestateAttrState(const ParamTypestateAttr *PTAttr) { + switch (PTAttr->getParamState()) { + case ParamTypestateAttr::Unknown: + return CS_Unknown; + case ParamTypestateAttr::Unconsumed: + return CS_Unconsumed; + case ParamTypestateAttr::Consumed: + return CS_Consumed; + } + llvm_unreachable("invalid_enum"); +} + +static ConsumedState +mapReturnTypestateAttrState(const ReturnTypestateAttr *RTSAttr) { + switch (RTSAttr->getState()) { + case ReturnTypestateAttr::Unknown: + return CS_Unknown; + case ReturnTypestateAttr::Unconsumed: + return CS_Unconsumed; + case ReturnTypestateAttr::Consumed: + return CS_Consumed; + } + llvm_unreachable("invalid enum"); +} + +static ConsumedState mapSetTypestateAttrState(const SetTypestateAttr *STAttr) { + switch (STAttr->getNewState()) { + case SetTypestateAttr::Unknown: + return CS_Unknown; + case SetTypestateAttr::Unconsumed: + return CS_Unconsumed; + case SetTypestateAttr::Consumed: + return CS_Consumed; + } + llvm_unreachable("invalid_enum"); +} + +static StringRef stateToString(ConsumedState State) { + switch (State) { + case consumed::CS_None: + return "none"; + + case consumed::CS_Unknown: + return "unknown"; + + case consumed::CS_Unconsumed: + return "unconsumed"; + + case consumed::CS_Consumed: + return "consumed"; + } + llvm_unreachable("invalid enum"); +} + +static ConsumedState testsFor(const FunctionDecl *FunDecl) { + assert(isTestingFunction(FunDecl)); + switch (FunDecl->getAttr<TestTypestateAttr>()->getTestState()) { + case TestTypestateAttr::Unconsumed: + return CS_Unconsumed; + case TestTypestateAttr::Consumed: + return CS_Consumed; + } + llvm_unreachable("invalid enum"); +} + +namespace { +struct VarTestResult { + const VarDecl *Var; + ConsumedState TestsFor; +}; +} // end anonymous::VarTestResult + +namespace clang { +namespace consumed { + +enum EffectiveOp { + EO_And, + EO_Or +}; + +class PropagationInfo { + enum { + IT_None, + IT_State, + IT_VarTest, + IT_BinTest, + IT_Var, + IT_Tmp + } InfoType; + + struct BinTestTy { + const BinaryOperator *Source; + EffectiveOp EOp; + VarTestResult LTest; + VarTestResult RTest; + }; + + union { + ConsumedState State; + VarTestResult VarTest; + const VarDecl *Var; + const CXXBindTemporaryExpr *Tmp; + BinTestTy BinTest; + }; + +public: + PropagationInfo() : InfoType(IT_None) {} + + PropagationInfo(const VarTestResult &VarTest) + : InfoType(IT_VarTest), VarTest(VarTest) {} + + PropagationInfo(const VarDecl *Var, ConsumedState TestsFor) + : InfoType(IT_VarTest) { + + VarTest.Var = Var; + VarTest.TestsFor = TestsFor; + } + + PropagationInfo(const BinaryOperator *Source, EffectiveOp EOp, + const VarTestResult <est, const VarTestResult &RTest) + : InfoType(IT_BinTest) { + + BinTest.Source = Source; + BinTest.EOp = EOp; + BinTest.LTest = LTest; + BinTest.RTest = RTest; + } + + PropagationInfo(const BinaryOperator *Source, EffectiveOp EOp, + const VarDecl *LVar, ConsumedState LTestsFor, + const VarDecl *RVar, ConsumedState RTestsFor) + : InfoType(IT_BinTest) { + + BinTest.Source = Source; + BinTest.EOp = EOp; + BinTest.LTest.Var = LVar; + BinTest.LTest.TestsFor = LTestsFor; + BinTest.RTest.Var = RVar; + BinTest.RTest.TestsFor = RTestsFor; + } + + PropagationInfo(ConsumedState State) + : InfoType(IT_State), State(State) {} + + PropagationInfo(const VarDecl *Var) : InfoType(IT_Var), Var(Var) {} + PropagationInfo(const CXXBindTemporaryExpr *Tmp) + : InfoType(IT_Tmp), Tmp(Tmp) {} + + const ConsumedState & getState() const { + assert(InfoType == IT_State); + return State; + } + + const VarTestResult & getVarTest() const { + assert(InfoType == IT_VarTest); + return VarTest; + } + + const VarTestResult & getLTest() const { + assert(InfoType == IT_BinTest); + return BinTest.LTest; + } + + const VarTestResult & getRTest() const { + assert(InfoType == IT_BinTest); + return BinTest.RTest; + } + + const VarDecl * getVar() const { + assert(InfoType == IT_Var); + return Var; + } + + const CXXBindTemporaryExpr * getTmp() const { + assert(InfoType == IT_Tmp); + return Tmp; + } + + ConsumedState getAsState(const ConsumedStateMap *StateMap) const { + assert(isVar() || isTmp() || isState()); + + if (isVar()) + return StateMap->getState(Var); + else if (isTmp()) + return StateMap->getState(Tmp); + else if (isState()) + return State; + else + return CS_None; + } + + EffectiveOp testEffectiveOp() const { + assert(InfoType == IT_BinTest); + return BinTest.EOp; + } + + const BinaryOperator * testSourceNode() const { + assert(InfoType == IT_BinTest); + return BinTest.Source; + } + + inline bool isValid() const { return InfoType != IT_None; } + inline bool isState() const { return InfoType == IT_State; } + inline bool isVarTest() const { return InfoType == IT_VarTest; } + inline bool isBinTest() const { return InfoType == IT_BinTest; } + inline bool isVar() const { return InfoType == IT_Var; } + inline bool isTmp() const { return InfoType == IT_Tmp; } + + bool isTest() const { + return InfoType == IT_VarTest || InfoType == IT_BinTest; + } + + bool isPointerToValue() const { + return InfoType == IT_Var || InfoType == IT_Tmp; + } + + PropagationInfo invertTest() const { + assert(InfoType == IT_VarTest || InfoType == IT_BinTest); + + if (InfoType == IT_VarTest) { + return PropagationInfo(VarTest.Var, + invertConsumedUnconsumed(VarTest.TestsFor)); + + } else if (InfoType == IT_BinTest) { + return PropagationInfo(BinTest.Source, + BinTest.EOp == EO_And ? EO_Or : EO_And, + BinTest.LTest.Var, invertConsumedUnconsumed(BinTest.LTest.TestsFor), + BinTest.RTest.Var, invertConsumedUnconsumed(BinTest.RTest.TestsFor)); + } else { + return PropagationInfo(); + } + } +}; + +static inline void +setStateForVarOrTmp(ConsumedStateMap *StateMap, const PropagationInfo &PInfo, + ConsumedState State) { + + assert(PInfo.isVar() || PInfo.isTmp()); + + if (PInfo.isVar()) + StateMap->setState(PInfo.getVar(), State); + else + StateMap->setState(PInfo.getTmp(), State); +} + +class ConsumedStmtVisitor : public ConstStmtVisitor<ConsumedStmtVisitor> { + + typedef llvm::DenseMap<const Stmt *, PropagationInfo> MapType; + typedef std::pair<const Stmt *, PropagationInfo> PairType; + typedef MapType::iterator InfoEntry; + typedef MapType::const_iterator ConstInfoEntry; + + AnalysisDeclContext &AC; + ConsumedAnalyzer &Analyzer; + ConsumedStateMap *StateMap; + MapType PropagationMap; + void forwardInfo(const Stmt *From, const Stmt *To); + bool isLikeMoveAssignment(const CXXMethodDecl *MethodDecl); + void propagateReturnType(const Stmt *Call, const FunctionDecl *Fun, + QualType ReturnType); + +public: + void checkCallability(const PropagationInfo &PInfo, + const FunctionDecl *FunDecl, + SourceLocation BlameLoc); + + void VisitBinaryOperator(const BinaryOperator *BinOp); + void VisitCallExpr(const CallExpr *Call); + void VisitCastExpr(const CastExpr *Cast); + void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Temp); + void VisitCXXConstructExpr(const CXXConstructExpr *Call); + void VisitCXXMemberCallExpr(const CXXMemberCallExpr *Call); + void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *Call); + void VisitDeclRefExpr(const DeclRefExpr *DeclRef); + void VisitDeclStmt(const DeclStmt *DelcS); + void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Temp); + void VisitMemberExpr(const MemberExpr *MExpr); + void VisitParmVarDecl(const ParmVarDecl *Param); + void VisitReturnStmt(const ReturnStmt *Ret); + void VisitUnaryOperator(const UnaryOperator *UOp); + void VisitVarDecl(const VarDecl *Var); + + ConsumedStmtVisitor(AnalysisDeclContext &AC, ConsumedAnalyzer &Analyzer, + ConsumedStateMap *StateMap) + : AC(AC), Analyzer(Analyzer), StateMap(StateMap) {} + + PropagationInfo getInfo(const Stmt *StmtNode) const { + ConstInfoEntry Entry = PropagationMap.find(StmtNode); + + if (Entry != PropagationMap.end()) + return Entry->second; + else + return PropagationInfo(); + } + + void reset(ConsumedStateMap *NewStateMap) { + StateMap = NewStateMap; + } +}; + +void ConsumedStmtVisitor::checkCallability(const PropagationInfo &PInfo, + const FunctionDecl *FunDecl, + SourceLocation BlameLoc) { + assert(!PInfo.isTest()); + + if (!FunDecl->hasAttr<CallableWhenAttr>()) + return; + + const CallableWhenAttr *CWAttr = FunDecl->getAttr<CallableWhenAttr>(); + + if (PInfo.isVar()) { + ConsumedState VarState = StateMap->getState(PInfo.getVar()); + + if (VarState == CS_None || isCallableInState(CWAttr, VarState)) + return; + + Analyzer.WarningsHandler.warnUseInInvalidState( + FunDecl->getNameAsString(), PInfo.getVar()->getNameAsString(), + stateToString(VarState), BlameLoc); + + } else { + ConsumedState TmpState = PInfo.getAsState(StateMap); + + if (TmpState == CS_None || isCallableInState(CWAttr, TmpState)) + return; + + Analyzer.WarningsHandler.warnUseOfTempInInvalidState( + FunDecl->getNameAsString(), stateToString(TmpState), BlameLoc); + } +} + +void ConsumedStmtVisitor::forwardInfo(const Stmt *From, const Stmt *To) { + InfoEntry Entry = PropagationMap.find(From); + + if (Entry != PropagationMap.end()) + PropagationMap.insert(PairType(To, Entry->second)); +} + +bool ConsumedStmtVisitor::isLikeMoveAssignment( + const CXXMethodDecl *MethodDecl) { + + return MethodDecl->isMoveAssignmentOperator() || + (MethodDecl->getOverloadedOperator() == OO_Equal && + MethodDecl->getNumParams() == 1 && + MethodDecl->getParamDecl(0)->getType()->isRValueReferenceType()); +} + +void ConsumedStmtVisitor::propagateReturnType(const Stmt *Call, + const FunctionDecl *Fun, + QualType ReturnType) { + if (isConsumableType(ReturnType)) { + + ConsumedState ReturnState; + + if (Fun->hasAttr<ReturnTypestateAttr>()) + ReturnState = mapReturnTypestateAttrState( + Fun->getAttr<ReturnTypestateAttr>()); + else + ReturnState = mapConsumableAttrState(ReturnType); + + PropagationMap.insert(PairType(Call, PropagationInfo(ReturnState))); + } +} + +void ConsumedStmtVisitor::VisitBinaryOperator(const BinaryOperator *BinOp) { + switch (BinOp->getOpcode()) { + case BO_LAnd: + case BO_LOr : { + InfoEntry LEntry = PropagationMap.find(BinOp->getLHS()), + REntry = PropagationMap.find(BinOp->getRHS()); + + VarTestResult LTest, RTest; + + if (LEntry != PropagationMap.end() && LEntry->second.isVarTest()) { + LTest = LEntry->second.getVarTest(); + + } else { + LTest.Var = NULL; + LTest.TestsFor = CS_None; + } + + if (REntry != PropagationMap.end() && REntry->second.isVarTest()) { + RTest = REntry->second.getVarTest(); + + } else { + RTest.Var = NULL; + RTest.TestsFor = CS_None; + } + + if (!(LTest.Var == NULL && RTest.Var == NULL)) + PropagationMap.insert(PairType(BinOp, PropagationInfo(BinOp, + static_cast<EffectiveOp>(BinOp->getOpcode() == BO_LOr), LTest, RTest))); + + break; + } + + case BO_PtrMemD: + case BO_PtrMemI: + forwardInfo(BinOp->getLHS(), BinOp); + break; + + default: + break; + } +} + +void ConsumedStmtVisitor::VisitCallExpr(const CallExpr *Call) { + if (const FunctionDecl *FunDecl = + dyn_cast_or_null<FunctionDecl>(Call->getDirectCallee())) { + + // Special case for the std::move function. + // TODO: Make this more specific. (Deferred) + if (FunDecl->getNameAsString() == "move") { + forwardInfo(Call->getArg(0), Call); + return; + } + + unsigned Offset = Call->getNumArgs() - FunDecl->getNumParams(); + + for (unsigned Index = Offset; Index < Call->getNumArgs(); ++Index) { + const ParmVarDecl *Param = FunDecl->getParamDecl(Index - Offset); + QualType ParamType = Param->getType(); + + InfoEntry Entry = PropagationMap.find(Call->getArg(Index)); + + if (Entry == PropagationMap.end() || Entry->second.isTest()) + continue; + + PropagationInfo PInfo = Entry->second; + + // Check that the parameter is in the correct state. + + if (Param->hasAttr<ParamTypestateAttr>()) { + ConsumedState ParamState = PInfo.getAsState(StateMap); + + ConsumedState ExpectedState = + mapParamTypestateAttrState(Param->getAttr<ParamTypestateAttr>()); + + if (ParamState != ExpectedState) + Analyzer.WarningsHandler.warnParamTypestateMismatch( + Call->getArg(Index - Offset)->getExprLoc(), + stateToString(ExpectedState), stateToString(ParamState)); + } + + if (!(Entry->second.isVar() || Entry->second.isTmp())) + continue; + + // Adjust state on the caller side. + + if (isRValueRefish(ParamType)) { + setStateForVarOrTmp(StateMap, PInfo, consumed::CS_Consumed); + + } else if (Param->hasAttr<ReturnTypestateAttr>()) { + setStateForVarOrTmp(StateMap, PInfo, + mapReturnTypestateAttrState(Param->getAttr<ReturnTypestateAttr>())); + + } else if (!isValueType(ParamType) && + !ParamType->getPointeeType().isConstQualified()) { + + setStateForVarOrTmp(StateMap, PInfo, consumed::CS_Unknown); + } + } + + QualType RetType = FunDecl->getCallResultType(); + if (RetType->isReferenceType()) + RetType = RetType->getPointeeType(); + + propagateReturnType(Call, FunDecl, RetType); + } +} + +void ConsumedStmtVisitor::VisitCastExpr(const CastExpr *Cast) { + forwardInfo(Cast->getSubExpr(), Cast); +} + +void ConsumedStmtVisitor::VisitCXXBindTemporaryExpr( + const CXXBindTemporaryExpr *Temp) { + + InfoEntry Entry = PropagationMap.find(Temp->getSubExpr()); + + if (Entry != PropagationMap.end() && !Entry->second.isTest()) { + StateMap->setState(Temp, Entry->second.getAsState(StateMap)); + PropagationMap.insert(PairType(Temp, PropagationInfo(Temp))); + } +} + +void ConsumedStmtVisitor::VisitCXXConstructExpr(const CXXConstructExpr *Call) { + CXXConstructorDecl *Constructor = Call->getConstructor(); + + ASTContext &CurrContext = AC.getASTContext(); + QualType ThisType = Constructor->getThisType(CurrContext)->getPointeeType(); + + if (!isConsumableType(ThisType)) + return; + + // FIXME: What should happen if someone annotates the move constructor? + if (Constructor->hasAttr<ReturnTypestateAttr>()) { + // TODO: Adjust state of args appropriately. + + ReturnTypestateAttr *RTAttr = Constructor->getAttr<ReturnTypestateAttr>(); + ConsumedState RetState = mapReturnTypestateAttrState(RTAttr); + PropagationMap.insert(PairType(Call, PropagationInfo(RetState))); + + } else if (Constructor->isDefaultConstructor()) { + + PropagationMap.insert(PairType(Call, + PropagationInfo(consumed::CS_Consumed))); + + } else if (Constructor->isMoveConstructor()) { + + InfoEntry Entry = PropagationMap.find(Call->getArg(0)); + + if (Entry != PropagationMap.end()) { + PropagationInfo PInfo = Entry->second; + + if (PInfo.isVar()) { + const VarDecl* Var = PInfo.getVar(); + + PropagationMap.insert(PairType(Call, + PropagationInfo(StateMap->getState(Var)))); + + StateMap->setState(Var, consumed::CS_Consumed); + + } else if (PInfo.isTmp()) { + const CXXBindTemporaryExpr *Tmp = PInfo.getTmp(); + + PropagationMap.insert(PairType(Call, + PropagationInfo(StateMap->getState(Tmp)))); + + StateMap->setState(Tmp, consumed::CS_Consumed); + + } else { + PropagationMap.insert(PairType(Call, PInfo)); + } + } + } else if (Constructor->isCopyConstructor()) { + forwardInfo(Call->getArg(0), Call); + + } else { + // TODO: Adjust state of args appropriately. + + ConsumedState RetState = mapConsumableAttrState(ThisType); + PropagationMap.insert(PairType(Call, PropagationInfo(RetState))); + } +} + +void ConsumedStmtVisitor::VisitCXXMemberCallExpr( + const CXXMemberCallExpr *Call) { + + VisitCallExpr(Call); + + InfoEntry Entry = PropagationMap.find(Call->getCallee()->IgnoreParens()); + + if (Entry != PropagationMap.end()) { + PropagationInfo PInfo = Entry->second; + const CXXMethodDecl *MethodDecl = Call->getMethodDecl(); + + checkCallability(PInfo, MethodDecl, Call->getExprLoc()); + + if (PInfo.isVar()) { + if (isTestingFunction(MethodDecl)) + PropagationMap.insert(PairType(Call, + PropagationInfo(PInfo.getVar(), testsFor(MethodDecl)))); + else if (MethodDecl->hasAttr<SetTypestateAttr>()) + StateMap->setState(PInfo.getVar(), + mapSetTypestateAttrState(MethodDecl->getAttr<SetTypestateAttr>())); + } else if (PInfo.isTmp() && MethodDecl->hasAttr<SetTypestateAttr>()) { + StateMap->setState(PInfo.getTmp(), + mapSetTypestateAttrState(MethodDecl->getAttr<SetTypestateAttr>())); + } + } +} + +void ConsumedStmtVisitor::VisitCXXOperatorCallExpr( + const CXXOperatorCallExpr *Call) { + + const FunctionDecl *FunDecl = + dyn_cast_or_null<FunctionDecl>(Call->getDirectCallee()); + + if (!FunDecl) return; + + if (isa<CXXMethodDecl>(FunDecl) && + isLikeMoveAssignment(cast<CXXMethodDecl>(FunDecl))) { + + InfoEntry LEntry = PropagationMap.find(Call->getArg(0)); + InfoEntry REntry = PropagationMap.find(Call->getArg(1)); + + PropagationInfo LPInfo, RPInfo; + + if (LEntry != PropagationMap.end() && + REntry != PropagationMap.end()) { + + LPInfo = LEntry->second; + RPInfo = REntry->second; + + if (LPInfo.isPointerToValue() && RPInfo.isPointerToValue()) { + setStateForVarOrTmp(StateMap, LPInfo, RPInfo.getAsState(StateMap)); + PropagationMap.insert(PairType(Call, LPInfo)); + setStateForVarOrTmp(StateMap, RPInfo, consumed::CS_Consumed); + + } else if (RPInfo.isState()) { + setStateForVarOrTmp(StateMap, LPInfo, RPInfo.getState()); + PropagationMap.insert(PairType(Call, LPInfo)); + + } else { + setStateForVarOrTmp(StateMap, RPInfo, consumed::CS_Consumed); + } + + } else if (LEntry != PropagationMap.end() && + REntry == PropagationMap.end()) { + + LPInfo = LEntry->second; + + assert(!LPInfo.isTest()); + + if (LPInfo.isPointerToValue()) { + setStateForVarOrTmp(StateMap, LPInfo, consumed::CS_Unknown); + PropagationMap.insert(PairType(Call, LPInfo)); + + } else { + PropagationMap.insert(PairType(Call, + PropagationInfo(consumed::CS_Unknown))); + } + + } else if (LEntry == PropagationMap.end() && + REntry != PropagationMap.end()) { + + RPInfo = REntry->second; + + if (RPInfo.isPointerToValue()) + setStateForVarOrTmp(StateMap, RPInfo, consumed::CS_Consumed); + } + + } else { + + VisitCallExpr(Call); + + InfoEntry Entry = PropagationMap.find(Call->getArg(0)); + + if (Entry != PropagationMap.end()) { + PropagationInfo PInfo = Entry->second; + + checkCallability(PInfo, FunDecl, Call->getExprLoc()); + + if (PInfo.isVar()) { + if (isTestingFunction(FunDecl)) + PropagationMap.insert(PairType(Call, + PropagationInfo(PInfo.getVar(), testsFor(FunDecl)))); + else if (FunDecl->hasAttr<SetTypestateAttr>()) + StateMap->setState(PInfo.getVar(), + mapSetTypestateAttrState(FunDecl->getAttr<SetTypestateAttr>())); + + } else if (PInfo.isTmp() && FunDecl->hasAttr<SetTypestateAttr>()) { + StateMap->setState(PInfo.getTmp(), + mapSetTypestateAttrState(FunDecl->getAttr<SetTypestateAttr>())); + } + } + } +} + +void ConsumedStmtVisitor::VisitDeclRefExpr(const DeclRefExpr *DeclRef) { + if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(DeclRef->getDecl())) + if (StateMap->getState(Var) != consumed::CS_None) + PropagationMap.insert(PairType(DeclRef, PropagationInfo(Var))); +} + +void ConsumedStmtVisitor::VisitDeclStmt(const DeclStmt *DeclS) { + for (DeclStmt::const_decl_iterator DI = DeclS->decl_begin(), + DE = DeclS->decl_end(); DI != DE; ++DI) { + + if (isa<VarDecl>(*DI)) VisitVarDecl(cast<VarDecl>(*DI)); + } + + if (DeclS->isSingleDecl()) + if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(DeclS->getSingleDecl())) + PropagationMap.insert(PairType(DeclS, PropagationInfo(Var))); +} + +void ConsumedStmtVisitor::VisitMaterializeTemporaryExpr( + const MaterializeTemporaryExpr *Temp) { + + forwardInfo(Temp->GetTemporaryExpr(), Temp); +} + +void ConsumedStmtVisitor::VisitMemberExpr(const MemberExpr *MExpr) { + forwardInfo(MExpr->getBase(), MExpr); +} + + +void ConsumedStmtVisitor::VisitParmVarDecl(const ParmVarDecl *Param) { + QualType ParamType = Param->getType(); + ConsumedState ParamState = consumed::CS_None; + + if (Param->hasAttr<ParamTypestateAttr>()) { + const ParamTypestateAttr *PTAttr = Param->getAttr<ParamTypestateAttr>(); + ParamState = mapParamTypestateAttrState(PTAttr); + + } else if (isConsumableType(ParamType)) { + ParamState = mapConsumableAttrState(ParamType); + + } else if (isRValueRefish(ParamType) && + isConsumableType(ParamType->getPointeeType())) { + + ParamState = mapConsumableAttrState(ParamType->getPointeeType()); + + } else if (ParamType->isReferenceType() && + isConsumableType(ParamType->getPointeeType())) { + ParamState = consumed::CS_Unknown; + } + + if (ParamState != CS_None) + StateMap->setState(Param, ParamState); +} + +void ConsumedStmtVisitor::VisitReturnStmt(const ReturnStmt *Ret) { + ConsumedState ExpectedState = Analyzer.getExpectedReturnState(); + + if (ExpectedState != CS_None) { + InfoEntry Entry = PropagationMap.find(Ret->getRetValue()); + + if (Entry != PropagationMap.end()) { + ConsumedState RetState = Entry->second.getAsState(StateMap); + + if (RetState != ExpectedState) + Analyzer.WarningsHandler.warnReturnTypestateMismatch( + Ret->getReturnLoc(), stateToString(ExpectedState), + stateToString(RetState)); + } + } + + StateMap->checkParamsForReturnTypestate(Ret->getLocStart(), + Analyzer.WarningsHandler); +} + +void ConsumedStmtVisitor::VisitUnaryOperator(const UnaryOperator *UOp) { + InfoEntry Entry = PropagationMap.find(UOp->getSubExpr()->IgnoreParens()); + if (Entry == PropagationMap.end()) return; + + switch (UOp->getOpcode()) { + case UO_AddrOf: + PropagationMap.insert(PairType(UOp, Entry->second)); + break; + + case UO_LNot: + if (Entry->second.isTest()) + PropagationMap.insert(PairType(UOp, Entry->second.invertTest())); + break; + + default: + break; + } +} + +// TODO: See if I need to check for reference types here. +void ConsumedStmtVisitor::VisitVarDecl(const VarDecl *Var) { + if (isConsumableType(Var->getType())) { + if (Var->hasInit()) { + MapType::iterator VIT = PropagationMap.find( + Var->getInit()->IgnoreImplicit()); + if (VIT != PropagationMap.end()) { + PropagationInfo PInfo = VIT->second; + ConsumedState St = PInfo.getAsState(StateMap); + + if (St != consumed::CS_None) { + StateMap->setState(Var, St); + return; + } + } + } + // Otherwise + StateMap->setState(Var, consumed::CS_Unknown); + } +} +}} // end clang::consumed::ConsumedStmtVisitor + +namespace clang { +namespace consumed { + +void splitVarStateForIf(const IfStmt * IfNode, const VarTestResult &Test, + ConsumedStateMap *ThenStates, + ConsumedStateMap *ElseStates) { + + ConsumedState VarState = ThenStates->getState(Test.Var); + + if (VarState == CS_Unknown) { + ThenStates->setState(Test.Var, Test.TestsFor); + ElseStates->setState(Test.Var, invertConsumedUnconsumed(Test.TestsFor)); + + } else if (VarState == invertConsumedUnconsumed(Test.TestsFor)) { + ThenStates->markUnreachable(); + + } else if (VarState == Test.TestsFor) { + ElseStates->markUnreachable(); + } +} + +void splitVarStateForIfBinOp(const PropagationInfo &PInfo, + ConsumedStateMap *ThenStates, ConsumedStateMap *ElseStates) { + + const VarTestResult <est = PInfo.getLTest(), + &RTest = PInfo.getRTest(); + + ConsumedState LState = LTest.Var ? ThenStates->getState(LTest.Var) : CS_None, + RState = RTest.Var ? ThenStates->getState(RTest.Var) : CS_None; + + if (LTest.Var) { + if (PInfo.testEffectiveOp() == EO_And) { + if (LState == CS_Unknown) { + ThenStates->setState(LTest.Var, LTest.TestsFor); + + } else if (LState == invertConsumedUnconsumed(LTest.TestsFor)) { + ThenStates->markUnreachable(); + + } else if (LState == LTest.TestsFor && isKnownState(RState)) { + if (RState == RTest.TestsFor) + ElseStates->markUnreachable(); + else + ThenStates->markUnreachable(); + } + + } else { + if (LState == CS_Unknown) { + ElseStates->setState(LTest.Var, + invertConsumedUnconsumed(LTest.TestsFor)); + + } else if (LState == LTest.TestsFor) { + ElseStates->markUnreachable(); + + } else if (LState == invertConsumedUnconsumed(LTest.TestsFor) && + isKnownState(RState)) { + + if (RState == RTest.TestsFor) + ElseStates->markUnreachable(); + else + ThenStates->markUnreachable(); + } + } + } + + if (RTest.Var) { + if (PInfo.testEffectiveOp() == EO_And) { + if (RState == CS_Unknown) + ThenStates->setState(RTest.Var, RTest.TestsFor); + else if (RState == invertConsumedUnconsumed(RTest.TestsFor)) + ThenStates->markUnreachable(); + + } else { + if (RState == CS_Unknown) + ElseStates->setState(RTest.Var, + invertConsumedUnconsumed(RTest.TestsFor)); + else if (RState == RTest.TestsFor) + ElseStates->markUnreachable(); + } + } +} + +bool ConsumedBlockInfo::allBackEdgesVisited(const CFGBlock *CurrBlock, + const CFGBlock *TargetBlock) { + + assert(CurrBlock && "Block pointer must not be NULL"); + assert(TargetBlock && "TargetBlock pointer must not be NULL"); + + unsigned int CurrBlockOrder = VisitOrder[CurrBlock->getBlockID()]; + for (CFGBlock::const_pred_iterator PI = TargetBlock->pred_begin(), + PE = TargetBlock->pred_end(); PI != PE; ++PI) { + if (*PI && CurrBlockOrder < VisitOrder[(*PI)->getBlockID()] ) + return false; + } + return true; +} + +void ConsumedBlockInfo::addInfo(const CFGBlock *Block, + ConsumedStateMap *StateMap, + bool &AlreadyOwned) { + + assert(Block && "Block pointer must not be NULL"); + + ConsumedStateMap *Entry = StateMapsArray[Block->getBlockID()]; + + if (Entry) { + Entry->intersect(StateMap); + + } else if (AlreadyOwned) { + StateMapsArray[Block->getBlockID()] = new ConsumedStateMap(*StateMap); + + } else { + StateMapsArray[Block->getBlockID()] = StateMap; + AlreadyOwned = true; + } +} + +void ConsumedBlockInfo::addInfo(const CFGBlock *Block, + ConsumedStateMap *StateMap) { + + assert(Block != NULL && "Block pointer must not be NULL"); + + ConsumedStateMap *Entry = StateMapsArray[Block->getBlockID()]; + + if (Entry) { + Entry->intersect(StateMap); + delete StateMap; + + } else { + StateMapsArray[Block->getBlockID()] = StateMap; + } +} + +ConsumedStateMap* ConsumedBlockInfo::borrowInfo(const CFGBlock *Block) { + assert(Block && "Block pointer must not be NULL"); + assert(StateMapsArray[Block->getBlockID()] && "Block has no block info"); + + return StateMapsArray[Block->getBlockID()]; +} + +void ConsumedBlockInfo::discardInfo(const CFGBlock *Block) { + unsigned int BlockID = Block->getBlockID(); + delete StateMapsArray[BlockID]; + StateMapsArray[BlockID] = NULL; +} + +ConsumedStateMap* ConsumedBlockInfo::getInfo(const CFGBlock *Block) { + assert(Block && "Block pointer must not be NULL"); + + ConsumedStateMap *StateMap = StateMapsArray[Block->getBlockID()]; + if (isBackEdgeTarget(Block)) { + return new ConsumedStateMap(*StateMap); + } else { + StateMapsArray[Block->getBlockID()] = NULL; + return StateMap; + } +} + +bool ConsumedBlockInfo::isBackEdge(const CFGBlock *From, const CFGBlock *To) { + assert(From && "From block must not be NULL"); + assert(To && "From block must not be NULL"); + + return VisitOrder[From->getBlockID()] > VisitOrder[To->getBlockID()]; +} + +bool ConsumedBlockInfo::isBackEdgeTarget(const CFGBlock *Block) { + assert(Block != NULL && "Block pointer must not be NULL"); + + // Anything with less than two predecessors can't be the target of a back + // edge. + if (Block->pred_size() < 2) + return false; + + unsigned int BlockVisitOrder = VisitOrder[Block->getBlockID()]; + for (CFGBlock::const_pred_iterator PI = Block->pred_begin(), + PE = Block->pred_end(); PI != PE; ++PI) { + if (*PI && BlockVisitOrder < VisitOrder[(*PI)->getBlockID()]) + return true; + } + return false; +} + +void ConsumedStateMap::checkParamsForReturnTypestate(SourceLocation BlameLoc, + ConsumedWarningsHandlerBase &WarningsHandler) const { + + ConsumedState ExpectedState; + + for (VarMapType::const_iterator DMI = VarMap.begin(), DME = VarMap.end(); + DMI != DME; ++DMI) { + + if (isa<ParmVarDecl>(DMI->first)) { + const ParmVarDecl *Param = cast<ParmVarDecl>(DMI->first); + + if (!Param->hasAttr<ReturnTypestateAttr>()) continue; + + ExpectedState = + mapReturnTypestateAttrState(Param->getAttr<ReturnTypestateAttr>()); + + if (DMI->second != ExpectedState) { + WarningsHandler.warnParamReturnTypestateMismatch(BlameLoc, + Param->getNameAsString(), stateToString(ExpectedState), + stateToString(DMI->second)); + } + } + } +} + +void ConsumedStateMap::clearTemporaries() { + TmpMap.clear(); +} + +ConsumedState ConsumedStateMap::getState(const VarDecl *Var) const { + VarMapType::const_iterator Entry = VarMap.find(Var); + + if (Entry != VarMap.end()) + return Entry->second; + + return CS_None; +} + +ConsumedState +ConsumedStateMap::getState(const CXXBindTemporaryExpr *Tmp) const { + TmpMapType::const_iterator Entry = TmpMap.find(Tmp); + + if (Entry != TmpMap.end()) + return Entry->second; + + return CS_None; +} + +void ConsumedStateMap::intersect(const ConsumedStateMap *Other) { + ConsumedState LocalState; + + if (this->From && this->From == Other->From && !Other->Reachable) { + this->markUnreachable(); + return; + } + + for (VarMapType::const_iterator DMI = Other->VarMap.begin(), + DME = Other->VarMap.end(); DMI != DME; ++DMI) { + + LocalState = this->getState(DMI->first); + + if (LocalState == CS_None) + continue; + + if (LocalState != DMI->second) + VarMap[DMI->first] = CS_Unknown; + } +} + +void ConsumedStateMap::intersectAtLoopHead(const CFGBlock *LoopHead, + const CFGBlock *LoopBack, const ConsumedStateMap *LoopBackStates, + ConsumedWarningsHandlerBase &WarningsHandler) { + + ConsumedState LocalState; + SourceLocation BlameLoc = getLastStmtLoc(LoopBack); + + for (VarMapType::const_iterator DMI = LoopBackStates->VarMap.begin(), + DME = LoopBackStates->VarMap.end(); DMI != DME; ++DMI) { + + LocalState = this->getState(DMI->first); + + if (LocalState == CS_None) + continue; + + if (LocalState != DMI->second) { + VarMap[DMI->first] = CS_Unknown; + WarningsHandler.warnLoopStateMismatch( + BlameLoc, DMI->first->getNameAsString()); + } + } +} + +void ConsumedStateMap::markUnreachable() { + this->Reachable = false; + VarMap.clear(); + TmpMap.clear(); +} + +void ConsumedStateMap::setState(const VarDecl *Var, ConsumedState State) { + VarMap[Var] = State; +} + +void ConsumedStateMap::setState(const CXXBindTemporaryExpr *Tmp, + ConsumedState State) { + TmpMap[Tmp] = State; +} + +void ConsumedStateMap::remove(const VarDecl *Var) { + VarMap.erase(Var); +} + +bool ConsumedStateMap::operator!=(const ConsumedStateMap *Other) const { + for (VarMapType::const_iterator DMI = Other->VarMap.begin(), + DME = Other->VarMap.end(); DMI != DME; ++DMI) { + + if (this->getState(DMI->first) != DMI->second) + return true; + } + + return false; +} + +void ConsumedAnalyzer::determineExpectedReturnState(AnalysisDeclContext &AC, + const FunctionDecl *D) { + QualType ReturnType; + if (const CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) { + ASTContext &CurrContext = AC.getASTContext(); + ReturnType = Constructor->getThisType(CurrContext)->getPointeeType(); + } else + ReturnType = D->getCallResultType(); + + if (D->hasAttr<ReturnTypestateAttr>()) { + const ReturnTypestateAttr *RTSAttr = D->getAttr<ReturnTypestateAttr>(); + + const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl(); + if (!RD || !RD->hasAttr<ConsumableAttr>()) { + // FIXME: This should be removed when template instantiation propagates + // attributes at template specialization definition, not + // declaration. When it is removed the test needs to be enabled + // in SemaDeclAttr.cpp. + WarningsHandler.warnReturnTypestateForUnconsumableType( + RTSAttr->getLocation(), ReturnType.getAsString()); + ExpectedReturnState = CS_None; + } else + ExpectedReturnState = mapReturnTypestateAttrState(RTSAttr); + } else if (isConsumableType(ReturnType)) + ExpectedReturnState = mapConsumableAttrState(ReturnType); + else + ExpectedReturnState = CS_None; +} + +bool ConsumedAnalyzer::splitState(const CFGBlock *CurrBlock, + const ConsumedStmtVisitor &Visitor) { + + OwningPtr<ConsumedStateMap> FalseStates(new ConsumedStateMap(*CurrStates)); + PropagationInfo PInfo; + + if (const IfStmt *IfNode = + dyn_cast_or_null<IfStmt>(CurrBlock->getTerminator().getStmt())) { + + const Stmt *Cond = IfNode->getCond(); + + PInfo = Visitor.getInfo(Cond); + if (!PInfo.isValid() && isa<BinaryOperator>(Cond)) + PInfo = Visitor.getInfo(cast<BinaryOperator>(Cond)->getRHS()); + + if (PInfo.isVarTest()) { + CurrStates->setSource(Cond); + FalseStates->setSource(Cond); + splitVarStateForIf(IfNode, PInfo.getVarTest(), CurrStates, + FalseStates.get()); + + } else if (PInfo.isBinTest()) { + CurrStates->setSource(PInfo.testSourceNode()); + FalseStates->setSource(PInfo.testSourceNode()); + splitVarStateForIfBinOp(PInfo, CurrStates, FalseStates.get()); + + } else { + return false; + } + + } else if (const BinaryOperator *BinOp = + dyn_cast_or_null<BinaryOperator>(CurrBlock->getTerminator().getStmt())) { + + PInfo = Visitor.getInfo(BinOp->getLHS()); + if (!PInfo.isVarTest()) { + if ((BinOp = dyn_cast_or_null<BinaryOperator>(BinOp->getLHS()))) { + PInfo = Visitor.getInfo(BinOp->getRHS()); + + if (!PInfo.isVarTest()) + return false; + + } else { + return false; + } + } + + CurrStates->setSource(BinOp); + FalseStates->setSource(BinOp); + + const VarTestResult &Test = PInfo.getVarTest(); + ConsumedState VarState = CurrStates->getState(Test.Var); + + if (BinOp->getOpcode() == BO_LAnd) { + if (VarState == CS_Unknown) + CurrStates->setState(Test.Var, Test.TestsFor); + else if (VarState == invertConsumedUnconsumed(Test.TestsFor)) + CurrStates->markUnreachable(); + + } else if (BinOp->getOpcode() == BO_LOr) { + if (VarState == CS_Unknown) + FalseStates->setState(Test.Var, + invertConsumedUnconsumed(Test.TestsFor)); + else if (VarState == Test.TestsFor) + FalseStates->markUnreachable(); + } + + } else { + return false; + } + + CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(); + + if (*SI) + BlockInfo.addInfo(*SI, CurrStates); + else + delete CurrStates; + + if (*++SI) + BlockInfo.addInfo(*SI, FalseStates.take()); + + CurrStates = NULL; + return true; +} + +void ConsumedAnalyzer::run(AnalysisDeclContext &AC) { + const FunctionDecl *D = dyn_cast_or_null<FunctionDecl>(AC.getDecl()); + if (!D) + return; + + CFG *CFGraph = AC.getCFG(); + if (!CFGraph) + return; + + determineExpectedReturnState(AC, D); + + PostOrderCFGView *SortedGraph = AC.getAnalysis<PostOrderCFGView>(); + // AC.getCFG()->viewCFG(LangOptions()); + + BlockInfo = ConsumedBlockInfo(CFGraph->getNumBlockIDs(), SortedGraph); + + CurrStates = new ConsumedStateMap(); + ConsumedStmtVisitor Visitor(AC, *this, CurrStates); + + // Add all trackable parameters to the state map. + for (FunctionDecl::param_const_iterator PI = D->param_begin(), + PE = D->param_end(); PI != PE; ++PI) { + Visitor.VisitParmVarDecl(*PI); + } + + // Visit all of the function's basic blocks. + for (PostOrderCFGView::iterator I = SortedGraph->begin(), + E = SortedGraph->end(); I != E; ++I) { + + const CFGBlock *CurrBlock = *I; + + if (CurrStates == NULL) + CurrStates = BlockInfo.getInfo(CurrBlock); + + if (!CurrStates) { + continue; + + } else if (!CurrStates->isReachable()) { + delete CurrStates; + CurrStates = NULL; + continue; + } + + Visitor.reset(CurrStates); + + // Visit all of the basic block's statements. + for (CFGBlock::const_iterator BI = CurrBlock->begin(), + BE = CurrBlock->end(); BI != BE; ++BI) { + + switch (BI->getKind()) { + case CFGElement::Statement: + Visitor.Visit(BI->castAs<CFGStmt>().getStmt()); + break; + + case CFGElement::TemporaryDtor: { + const CFGTemporaryDtor DTor = BI->castAs<CFGTemporaryDtor>(); + const CXXBindTemporaryExpr *BTE = DTor.getBindTemporaryExpr(); + + Visitor.checkCallability(PropagationInfo(BTE), + DTor.getDestructorDecl(AC.getASTContext()), + BTE->getExprLoc()); + break; + } + + case CFGElement::AutomaticObjectDtor: { + const CFGAutomaticObjDtor DTor = BI->castAs<CFGAutomaticObjDtor>(); + SourceLocation Loc = DTor.getTriggerStmt()->getLocEnd(); + const VarDecl *Var = DTor.getVarDecl(); + + Visitor.checkCallability(PropagationInfo(Var), + DTor.getDestructorDecl(AC.getASTContext()), + Loc); + break; + } + + default: + break; + } + } + + CurrStates->clearTemporaries(); + + // TODO: Handle other forms of branching with precision, including while- + // and for-loops. (Deferred) + if (!splitState(CurrBlock, Visitor)) { + CurrStates->setSource(NULL); + + if (CurrBlock->succ_size() > 1 || + (CurrBlock->succ_size() == 1 && + (*CurrBlock->succ_begin())->pred_size() > 1)) { + + bool OwnershipTaken = false; + + for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(), + SE = CurrBlock->succ_end(); SI != SE; ++SI) { + + if (*SI == NULL) continue; + + if (BlockInfo.isBackEdge(CurrBlock, *SI)) { + BlockInfo.borrowInfo(*SI)->intersectAtLoopHead(*SI, CurrBlock, + CurrStates, + WarningsHandler); + + if (BlockInfo.allBackEdgesVisited(*SI, CurrBlock)) + BlockInfo.discardInfo(*SI); + } else { + BlockInfo.addInfo(*SI, CurrStates, OwnershipTaken); + } + } + + if (!OwnershipTaken) + delete CurrStates; + + CurrStates = NULL; + } + } + + if (CurrBlock == &AC.getCFG()->getExit() && + D->getCallResultType()->isVoidType()) + CurrStates->checkParamsForReturnTypestate(D->getLocation(), + WarningsHandler); + } // End of block iterator. + + // Delete the last existing state map. + delete CurrStates; + + WarningsHandler.emitDiagnostics(); +} +}} // end namespace clang::consumed diff --git a/contrib/llvm/tools/clang/lib/Analysis/FormatString.cpp b/contrib/llvm/tools/clang/lib/Analysis/FormatString.cpp index 9dcd422..07431ac 100644 --- a/contrib/llvm/tools/clang/lib/Analysis/FormatString.cpp +++ b/contrib/llvm/tools/clang/lib/Analysis/FormatString.cpp @@ -223,6 +223,27 @@ clang::analyze_format_string::ParseLengthModifier(FormatSpecifier &FS, break; } return false; + // printf: AsInt64, AsInt32, AsInt3264 + // scanf: AsInt64 + case 'I': + if (I + 1 != E && I + 2 != E) { + if (I[1] == '6' && I[2] == '4') { + I += 3; + lmKind = LengthModifier::AsInt64; + break; + } + if (IsScanf) + return false; + + if (I[1] == '3' && I[2] == '2') { + I += 3; + lmKind = LengthModifier::AsInt32; + break; + } + } + ++I; + lmKind = LengthModifier::AsInt3264; + break; } LengthModifier lm(lmPosition, lmKind); FS.setLengthModifier(lm); @@ -334,7 +355,7 @@ bool ArgType::matchesType(ASTContext &C, QualType argTy) const { return false; QualType pointeeTy = C.getCanonicalType(PT->getPointeeType()).getUnqualifiedType(); - return pointeeTy == C.getWCharType(); + return pointeeTy == C.getWideCharType(); } case WIntTy: { @@ -398,7 +419,7 @@ QualType ArgType::getRepresentativeType(ASTContext &C) const { Res = C.getPointerType(C.CharTy); break; case WCStrTy: - Res = C.getPointerType(C.getWCharType()); + Res = C.getPointerType(C.getWideCharType()); break; case ObjCPointerTy: Res = C.ObjCBuiltinIdTy; @@ -471,6 +492,12 @@ analyze_format_string::LengthModifier::toString() const { return "z"; case AsPtrDiff: return "t"; + case AsInt32: + return "I32"; + case AsInt3264: + return "I"; + case AsInt64: + return "I64"; case AsLongDouble: return "L"; case AsAllocate: @@ -514,7 +541,7 @@ const char *ConversionSpecifier::toString() const { case ScanListArg: return "["; case InvalidSpecifier: return NULL; - // MacOS X unicode extensions. + // POSIX unicode extensions. case CArg: return "C"; case SArg: return "S"; @@ -685,6 +712,20 @@ bool FormatSpecifier::hasValidLengthModifier(const TargetInfo &Target) const { default: return false; } + case LengthModifier::AsInt32: + case LengthModifier::AsInt3264: + case LengthModifier::AsInt64: + switch (CS.getKind()) { + case ConversionSpecifier::dArg: + case ConversionSpecifier::iArg: + case ConversionSpecifier::oArg: + case ConversionSpecifier::uArg: + case ConversionSpecifier::xArg: + case ConversionSpecifier::XArg: + return Target.getTriple().isOSMSVCRT(); + default: + return false; + } } llvm_unreachable("Invalid LengthModifier Kind!"); } @@ -704,6 +745,9 @@ bool FormatSpecifier::hasStandardLengthModifier() const { case LengthModifier::AsAllocate: case LengthModifier::AsMAllocate: case LengthModifier::AsQuad: + case LengthModifier::AsInt32: + case LengthModifier::AsInt3264: + case LengthModifier::AsInt64: return false; } llvm_unreachable("Invalid LengthModifier Kind!"); diff --git a/contrib/llvm/tools/clang/lib/Analysis/LiveVariables.cpp b/contrib/llvm/tools/clang/lib/Analysis/LiveVariables.cpp index b43892a..9e5ec55 100644 --- a/contrib/llvm/tools/clang/lib/Analysis/LiveVariables.cpp +++ b/contrib/llvm/tools/clang/lib/Analysis/LiveVariables.cpp @@ -87,8 +87,7 @@ void DataflowWorklist::sortWorklist() { const CFGBlock *DataflowWorklist::dequeue() { if (worklist.empty()) return 0; - const CFGBlock *b = worklist.back(); - worklist.pop_back(); + const CFGBlock *b = worklist.pop_back_val(); enqueuedBlocks[b->getBlockID()] = false; return b; } diff --git a/contrib/llvm/tools/clang/lib/Analysis/PrintfFormatString.cpp b/contrib/llvm/tools/clang/lib/Analysis/PrintfFormatString.cpp index b9bde0a..400bbf8 100644 --- a/contrib/llvm/tools/clang/lib/Analysis/PrintfFormatString.cpp +++ b/contrib/llvm/tools/clang/lib/Analysis/PrintfFormatString.cpp @@ -187,8 +187,8 @@ static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H, case 'i': k = ConversionSpecifier::iArg; break; case 'n': k = ConversionSpecifier::nArg; break; case 'o': k = ConversionSpecifier::oArg; break; - case 'p': k = ConversionSpecifier::pArg; break; - case 's': k = ConversionSpecifier::sArg; break; + case 'p': k = ConversionSpecifier::pArg; break; + case 's': k = ConversionSpecifier::sArg; break; case 'u': k = ConversionSpecifier::uArg; break; case 'x': k = ConversionSpecifier::xArg; break; // POSIX specific. @@ -297,18 +297,27 @@ ArgType PrintfSpecifier::getArgType(ASTContext &Ctx, case LengthModifier::AsLongDouble: // GNU extension. return Ctx.LongLongTy; - case LengthModifier::None: return Ctx.IntTy; + case LengthModifier::None: + return Ctx.IntTy; + case LengthModifier::AsInt32: + return ArgType(Ctx.IntTy, "__int32"); case LengthModifier::AsChar: return ArgType::AnyCharTy; case LengthModifier::AsShort: return Ctx.ShortTy; case LengthModifier::AsLong: return Ctx.LongTy; case LengthModifier::AsLongLong: case LengthModifier::AsQuad: return Ctx.LongLongTy; + case LengthModifier::AsInt64: + return ArgType(Ctx.LongLongTy, "__int64"); case LengthModifier::AsIntMax: return ArgType(Ctx.getIntMaxType(), "intmax_t"); case LengthModifier::AsSizeT: // FIXME: How to get the corresponding signed version of size_t? return ArgType(); + case LengthModifier::AsInt3264: + return Ctx.getTargetInfo().getTriple().isArch64Bit() + ? ArgType(Ctx.LongLongTy, "__int64") + : ArgType(Ctx.IntTy, "__int32"); case LengthModifier::AsPtrDiff: return ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"); case LengthModifier::AsAllocate: @@ -321,17 +330,26 @@ ArgType PrintfSpecifier::getArgType(ASTContext &Ctx, case LengthModifier::AsLongDouble: // GNU extension. return Ctx.UnsignedLongLongTy; - case LengthModifier::None: return Ctx.UnsignedIntTy; + case LengthModifier::None: + return Ctx.UnsignedIntTy; + case LengthModifier::AsInt32: + return ArgType(Ctx.UnsignedIntTy, "unsigned __int32"); case LengthModifier::AsChar: return Ctx.UnsignedCharTy; case LengthModifier::AsShort: return Ctx.UnsignedShortTy; case LengthModifier::AsLong: return Ctx.UnsignedLongTy; case LengthModifier::AsLongLong: case LengthModifier::AsQuad: return Ctx.UnsignedLongLongTy; + case LengthModifier::AsInt64: + return ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64"); case LengthModifier::AsIntMax: return ArgType(Ctx.getUIntMaxType(), "uintmax_t"); case LengthModifier::AsSizeT: return ArgType(Ctx.getSizeType(), "size_t"); + case LengthModifier::AsInt3264: + return Ctx.getTargetInfo().getTriple().isArch64Bit() + ? ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64") + : ArgType(Ctx.UnsignedIntTy, "unsigned __int32"); case LengthModifier::AsPtrDiff: // FIXME: How to get the corresponding unsigned // version of ptrdiff_t? @@ -370,6 +388,9 @@ ArgType PrintfSpecifier::getArgType(ASTContext &Ctx, return ArgType(); // FIXME: Is this a known extension? case LengthModifier::AsAllocate: case LengthModifier::AsMAllocate: + case LengthModifier::AsInt32: + case LengthModifier::AsInt3264: + case LengthModifier::AsInt64: return ArgType::Invalid(); } } @@ -391,7 +412,7 @@ ArgType PrintfSpecifier::getArgType(ASTContext &Ctx, case ConversionSpecifier::CArg: if (IsObjCLiteral) return ArgType(Ctx.UnsignedShortTy, "unichar"); - return ArgType(Ctx.WCharTy, "wchar_t"); + return ArgType(Ctx.WideCharTy, "wchar_t"); case ConversionSpecifier::pArg: return ArgType::CPointerTy; case ConversionSpecifier::ObjCObjArg: diff --git a/contrib/llvm/tools/clang/lib/Analysis/ReachableCode.cpp b/contrib/llvm/tools/clang/lib/Analysis/ReachableCode.cpp index a90aebb..a2d19c0 100644 --- a/contrib/llvm/tools/clang/lib/Analysis/ReachableCode.cpp +++ b/contrib/llvm/tools/clang/lib/Analysis/ReachableCode.cpp @@ -110,10 +110,13 @@ const Stmt *DeadCodeScan::findDeadCode(const clang::CFGBlock *Block) { return 0; } -static int SrcCmp(const void *p1, const void *p2) { - return - ((const std::pair<const CFGBlock *, const Stmt *>*) p2)->second->getLocStart() < - ((const std::pair<const CFGBlock *, const Stmt *>*) p1)->second->getLocStart(); +static int SrcCmp(const std::pair<const CFGBlock *, const Stmt *> *p1, + const std::pair<const CFGBlock *, const Stmt *> *p2) { + if (p1->second->getLocStart() < p2->second->getLocStart()) + return -1; + if (p2->second->getLocStart() < p1->second->getLocStart()) + return 1; + return 0; } unsigned DeadCodeScan::scanBackwards(const clang::CFGBlock *Start, @@ -227,7 +230,7 @@ static SourceLocation GetUnreachableLoc(const Stmt *S, case Expr::CXXFunctionalCastExprClass: { const CXXFunctionalCastExpr *CE = cast <CXXFunctionalCastExpr>(S); R1 = CE->getSubExpr()->getSourceRange(); - return CE->getTypeBeginLoc(); + return CE->getLocStart(); } case Stmt::CXXTryStmtClass: { return cast<CXXTryStmt>(S)->getHandler(0)->getCatchLoc(); diff --git a/contrib/llvm/tools/clang/lib/Analysis/ScanfFormatString.cpp b/contrib/llvm/tools/clang/lib/Analysis/ScanfFormatString.cpp index 2dbc9e4..f5ce84f 100644 --- a/contrib/llvm/tools/clang/lib/Analysis/ScanfFormatString.cpp +++ b/contrib/llvm/tools/clang/lib/Analysis/ScanfFormatString.cpp @@ -232,6 +232,8 @@ ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const { case LengthModifier::AsLongLong: case LengthModifier::AsQuad: return ArgType::PtrTo(Ctx.LongLongTy); + case LengthModifier::AsInt64: + return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64")); case LengthModifier::AsIntMax: return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t")); case LengthModifier::AsSizeT: @@ -243,8 +245,9 @@ ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const { // GNU extension. return ArgType::PtrTo(Ctx.LongLongTy); case LengthModifier::AsAllocate: - return ArgType::Invalid(); case LengthModifier::AsMAllocate: + case LengthModifier::AsInt32: + case LengthModifier::AsInt3264: return ArgType::Invalid(); } @@ -267,6 +270,8 @@ ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const { case LengthModifier::AsLongLong: case LengthModifier::AsQuad: return ArgType::PtrTo(Ctx.UnsignedLongLongTy); + case LengthModifier::AsInt64: + return ArgType::PtrTo(ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64")); case LengthModifier::AsIntMax: return ArgType::PtrTo(ArgType(Ctx.getUIntMaxType(), "uintmax_t")); case LengthModifier::AsSizeT: @@ -278,8 +283,9 @@ ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const { // GNU extension. return ArgType::PtrTo(Ctx.UnsignedLongLongTy); case LengthModifier::AsAllocate: - return ArgType::Invalid(); case LengthModifier::AsMAllocate: + case LengthModifier::AsInt32: + case LengthModifier::AsInt3264: return ArgType::Invalid(); } @@ -311,7 +317,7 @@ ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const { case LengthModifier::None: return ArgType::PtrTo(ArgType::AnyCharTy); case LengthModifier::AsLong: - return ArgType::PtrTo(ArgType(Ctx.getWCharType(), "wchar_t")); + return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t")); case LengthModifier::AsAllocate: case LengthModifier::AsMAllocate: return ArgType::PtrTo(ArgType::CStrTy); @@ -323,7 +329,7 @@ ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const { // FIXME: Mac OS X specific? switch (LM.getKind()) { case LengthModifier::None: - return ArgType::PtrTo(ArgType(Ctx.getWCharType(), "wchar_t")); + return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t")); case LengthModifier::AsAllocate: case LengthModifier::AsMAllocate: return ArgType::PtrTo(ArgType(ArgType::WCStrTy, "wchar_t *")); @@ -349,6 +355,8 @@ ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const { case LengthModifier::AsLongLong: case LengthModifier::AsQuad: return ArgType::PtrTo(Ctx.LongLongTy); + case LengthModifier::AsInt64: + return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64")); case LengthModifier::AsIntMax: return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t")); case LengthModifier::AsSizeT: @@ -359,6 +367,8 @@ ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const { return ArgType(); // FIXME: Is this a known extension? case LengthModifier::AsAllocate: case LengthModifier::AsMAllocate: + case LengthModifier::AsInt32: + case LengthModifier::AsInt3264: return ArgType::Invalid(); } diff --git a/contrib/llvm/tools/clang/lib/Analysis/ThreadSafety.cpp b/contrib/llvm/tools/clang/lib/Analysis/ThreadSafety.cpp index 479d9a3..6e0e173 100644 --- a/contrib/llvm/tools/clang/lib/Analysis/ThreadSafety.cpp +++ b/contrib/llvm/tools/clang/lib/Analysis/ThreadSafety.cpp @@ -10,8 +10,8 @@ // A intra-procedural analysis for thread safety (e.g. deadlocks and race // conditions), based off of an annotation system. // -// See http://clang.llvm.org/docs/LanguageExtensions.html#threadsafety for more -// information. +// See http://clang.llvm.org/docs/LanguageExtensions.html#thread-safety-annotation-checking +// for more information. // //===----------------------------------------------------------------------===// @@ -266,6 +266,11 @@ private: return NodeVec.size()-1; } + inline bool isCalleeArrow(const Expr *E) { + const MemberExpr *ME = dyn_cast<MemberExpr>(E->IgnoreParenCasts()); + return ME ? ME->isArrow() : false; + } + /// Build an SExpr from the given C++ expression. /// Recursive function that terminates on DeclRefExpr. /// Note: this function merely creates a SExpr; it does not check to @@ -323,13 +328,11 @@ private: } else if (const CXXMemberCallExpr *CMCE = dyn_cast<CXXMemberCallExpr>(Exp)) { // When calling a function with a lock_returned attribute, replace // the function call with the expression in lock_returned. - const CXXMethodDecl* MD = - cast<CXXMethodDecl>(CMCE->getMethodDecl()->getMostRecentDecl()); + const CXXMethodDecl *MD = CMCE->getMethodDecl()->getMostRecentDecl(); if (LockReturnedAttr* At = MD->getAttr<LockReturnedAttr>()) { CallingContext LRCallCtx(CMCE->getMethodDecl()); LRCallCtx.SelfArg = CMCE->getImplicitObjectArgument(); - LRCallCtx.SelfArrow = - dyn_cast<MemberExpr>(CMCE->getCallee())->isArrow(); + LRCallCtx.SelfArrow = isCalleeArrow(CMCE->getCallee()); LRCallCtx.NumArgs = CMCE->getNumArgs(); LRCallCtx.FunArgs = CMCE->getArgs(); LRCallCtx.PrevCtx = CallCtx; @@ -339,7 +342,7 @@ private: // ignore any method named get(). if (CMCE->getMethodDecl()->getNameAsString() == "get" && CMCE->getNumArgs() == 0) { - if (NDeref && dyn_cast<MemberExpr>(CMCE->getCallee())->isArrow()) + if (NDeref && isCalleeArrow(CMCE->getCallee())) ++(*NDeref); return buildSExpr(CMCE->getImplicitObjectArgument(), CallCtx, NDeref); } @@ -353,8 +356,7 @@ private: NodeVec[Root].setSize(Sz + 1); return Sz + 1; } else if (const CallExpr *CE = dyn_cast<CallExpr>(Exp)) { - const FunctionDecl* FD = - cast<FunctionDecl>(CE->getDirectCallee()->getMostRecentDecl()); + const FunctionDecl *FD = CE->getDirectCallee()->getMostRecentDecl(); if (LockReturnedAttr* At = FD->getAttr<LockReturnedAttr>()) { CallingContext LRCallCtx(CE->getDirectCallee()); LRCallCtx.NumArgs = CE->getNumArgs(); @@ -498,11 +500,10 @@ private: } else if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(DeclExp)) { CallCtx.SelfArg = CE->getImplicitObjectArgument(); - CallCtx.SelfArrow = dyn_cast<MemberExpr>(CE->getCallee())->isArrow(); + CallCtx.SelfArrow = isCalleeArrow(CE->getCallee()); CallCtx.NumArgs = CE->getNumArgs(); CallCtx.FunArgs = CE->getArgs(); - } else if (const CallExpr *CE = - dyn_cast<CallExpr>(DeclExp)) { + } else if (const CallExpr *CE = dyn_cast<CallExpr>(DeclExp)) { CallCtx.NumArgs = CE->getNumArgs(); CallCtx.FunArgs = CE->getArgs(); } else if (const CXXConstructExpr *CE = @@ -750,16 +751,18 @@ struct LockData { /// /// FIXME: add support for re-entrant locking and lock up/downgrading LockKind LKind; + bool Asserted; // for asserted locks bool Managed; // for ScopedLockable objects SExpr UnderlyingMutex; // for ScopedLockable objects - LockData(SourceLocation AcquireLoc, LockKind LKind, bool M = false) - : AcquireLoc(AcquireLoc), LKind(LKind), Managed(M), + LockData(SourceLocation AcquireLoc, LockKind LKind, bool M=false, + bool Asrt=false) + : AcquireLoc(AcquireLoc), LKind(LKind), Asserted(Asrt), Managed(M), UnderlyingMutex(Decl::EmptyShell()) {} LockData(SourceLocation AcquireLoc, LockKind LKind, const SExpr &Mu) - : AcquireLoc(AcquireLoc), LKind(LKind), Managed(false), + : AcquireLoc(AcquireLoc), LKind(LKind), Asserted(false), Managed(false), UnderlyingMutex(Mu) {} @@ -864,6 +867,16 @@ public: return false; } + // Returns an iterator + iterator findLockIter(FactManager &FM, const SExpr &M) { + for (iterator I = begin(), E = end(); I != E; ++I) { + const SExpr &Exp = FM[*I].MutID; + if (Exp.matches(M)) + return I; + } + return end(); + } + LockData* findLock(FactManager &FM, const SExpr &M) const { for (const_iterator I = begin(), E = end(); I != E; ++I) { const SExpr &Exp = FM[*I].MutID; @@ -1484,7 +1497,8 @@ void ThreadSafetyAnalyzer::addLock(FactSet &FSet, const SExpr &Mutex, return; if (FSet.findLock(FactMan, Mutex)) { - Handler.handleDoubleLock(Mutex.toString(), LDat.AcquireLoc); + if (!LDat.Asserted) + Handler.handleDoubleLock(Mutex.toString(), LDat.AcquireLoc); } else { FSet.addLock(FactMan, Mutex, LDat); } @@ -1647,15 +1661,22 @@ const CallExpr* ThreadSafetyAnalyzer::getTrylockCallExpr(const Stmt *Cond, if (!TCond) Negate = !Negate; return getTrylockCallExpr(BOP->getLHS(), C, Negate); } - else if (getStaticBooleanValue(BOP->getLHS(), TCond)) { + TCond = false; + if (getStaticBooleanValue(BOP->getLHS(), TCond)) { if (!TCond) Negate = !Negate; return getTrylockCallExpr(BOP->getRHS(), C, Negate); } return 0; } + if (BOP->getOpcode() == BO_LAnd) { + // LHS must have been evaluated in a different block. + return getTrylockCallExpr(BOP->getRHS(), C, Negate); + } + if (BOP->getOpcode() == BO_LOr) { + return getTrylockCallExpr(BOP->getRHS(), C, Negate); + } return 0; } - // FIXME -- handle && and || as well. return 0; } @@ -1669,11 +1690,11 @@ void ThreadSafetyAnalyzer::getEdgeLockset(FactSet& Result, const CFGBlock *CurrBlock) { Result = ExitSet; - if (!PredBlock->getTerminatorCondition()) + const Stmt *Cond = PredBlock->getTerminatorCondition(); + if (!Cond) return; bool Negate = false; - const Stmt *Cond = PredBlock->getTerminatorCondition(); const CFGBlockInfo *PredBlockInfo = &BlockInfo[PredBlock->getBlockID()]; const LocalVarContext &LVarCtx = PredBlockInfo->ExitContext; @@ -1686,7 +1707,6 @@ void ThreadSafetyAnalyzer::getEdgeLockset(FactSet& Result, if(!FunDecl || !FunDecl->hasAttrs()) return; - MutexIDList ExclusiveLocksToAdd; MutexIDList SharedLocksToAdd; @@ -1858,6 +1878,13 @@ void BuildLockset::checkAccess(const Expr *Exp, AccessKind AK) { return; } + if (const ArraySubscriptExpr *AE = dyn_cast<ArraySubscriptExpr>(Exp)) { + if (Analyzer->Handler.issueBetaWarnings()) { + checkPtAccess(AE->getLHS(), AK); + return; + } + } + if (const MemberExpr *ME = dyn_cast<MemberExpr>(Exp)) { if (ME->isArrow()) checkPtAccess(ME->getBase(), AK); @@ -1881,7 +1908,27 @@ void BuildLockset::checkAccess(const Expr *Exp, AccessKind AK) { /// \brief Checks pt_guarded_by and pt_guarded_var attributes. void BuildLockset::checkPtAccess(const Expr *Exp, AccessKind AK) { - Exp = Exp->IgnoreParenCasts(); + if (Analyzer->Handler.issueBetaWarnings()) { + while (true) { + if (const ParenExpr *PE = dyn_cast<ParenExpr>(Exp)) { + Exp = PE->getSubExpr(); + continue; + } + if (const CastExpr *CE = dyn_cast<CastExpr>(Exp)) { + if (CE->getCastKind() == CK_ArrayToPointerDecay) { + // If it's an actual array, and not a pointer, then it's elements + // are protected by GUARDED_BY, not PT_GUARDED_BY; + checkAccess(CE->getSubExpr(), AK); + return; + } + Exp = CE->getSubExpr(); + continue; + } + break; + } + } + else + Exp = Exp->IgnoreParenCasts(); const ValueDecl *D = getValueDecl(Exp); if (!D || !D->hasAttrs()) @@ -1909,6 +1956,7 @@ void BuildLockset::checkPtAccess(const Expr *Exp, AccessKind AK) { /// the same signature as const method calls can be also treated as reads. /// void BuildLockset::handleCall(Expr *Exp, const NamedDecl *D, VarDecl *VD) { + SourceLocation Loc = Exp->getExprLoc(); const AttrVec &ArgAttrs = D->getAttrs(); MutexIDList ExclusiveLocksToAdd; MutexIDList SharedLocksToAdd; @@ -1933,6 +1981,32 @@ void BuildLockset::handleCall(Expr *Exp, const NamedDecl *D, VarDecl *VD) { break; } + // An assert will add a lock to the lockset, but will not generate + // a warning if it is already there, and will not generate a warning + // if it is not removed. + case attr::AssertExclusiveLock: { + AssertExclusiveLockAttr *A = cast<AssertExclusiveLockAttr>(At); + + MutexIDList AssertLocks; + Analyzer->getMutexIDs(AssertLocks, A, Exp, D, VD); + for (unsigned i=0,n=AssertLocks.size(); i<n; ++i) { + Analyzer->addLock(FSet, AssertLocks[i], + LockData(Loc, LK_Exclusive, false, true)); + } + break; + } + case attr::AssertSharedLock: { + AssertSharedLockAttr *A = cast<AssertSharedLockAttr>(At); + + MutexIDList AssertLocks; + Analyzer->getMutexIDs(AssertLocks, A, Exp, D, VD); + for (unsigned i=0,n=AssertLocks.size(); i<n; ++i) { + Analyzer->addLock(FSet, AssertLocks[i], + LockData(Loc, LK_Shared, false, true)); + } + break; + } + // When we encounter an unlock function, we need to remove unlocked // mutexes from the lockset, and flag a warning if they are not there. case attr::UnlockFunction: { @@ -1986,7 +2060,6 @@ void BuildLockset::handleCall(Expr *Exp, const NamedDecl *D, VarDecl *VD) { } // Add locks. - SourceLocation Loc = Exp->getExprLoc(); for (unsigned i=0,n=ExclusiveLocksToAdd.size(); i<n; ++i) { Analyzer->addLock(FSet, ExclusiveLocksToAdd[i], LockData(Loc, LK_Exclusive, isScopedVar)); @@ -2052,6 +2125,7 @@ void BuildLockset::VisitBinaryOperator(BinaryOperator *BO) { checkAccess(BO->getLHS(), AK_Written); } + /// Whenever we do an LValue to Rvalue cast, we are reading a variable and /// need to ensure we hold any required mutexes. /// FIXME: Deal with non-primitive types. @@ -2091,9 +2165,19 @@ void BuildLockset::VisitCallExpr(CallExpr *Exp) { checkAccess(Source, AK_Read); break; } + case OO_Star: + case OO_Arrow: + case OO_Subscript: { + if (Analyzer->Handler.issueBetaWarnings()) { + const Expr *Obj = OE->getArg(0); + checkAccess(Obj, AK_Read); + checkPtAccess(Obj, AK_Read); + } + break; + } default: { - const Expr *Source = OE->getArg(0); - checkAccess(Source, AK_Read); + const Expr *Obj = OE->getArg(0); + checkAccess(Obj, AK_Read); break; } } @@ -2160,21 +2244,28 @@ void ThreadSafetyAnalyzer::intersectAndWarn(FactSet &FSet1, bool Modify) { FactSet FSet1Orig = FSet1; + // Find locks in FSet2 that conflict or are not in FSet1, and warn. for (FactSet::const_iterator I = FSet2.begin(), E = FSet2.end(); I != E; ++I) { const SExpr &FSet2Mutex = FactMan[*I].MutID; const LockData &LDat2 = FactMan[*I].LDat; + FactSet::iterator I1 = FSet1.findLockIter(FactMan, FSet2Mutex); - if (const LockData *LDat1 = FSet1.findLock(FactMan, FSet2Mutex)) { + if (I1 != FSet1.end()) { + const LockData* LDat1 = &FactMan[*I1].LDat; if (LDat1->LKind != LDat2.LKind) { Handler.handleExclusiveAndShared(FSet2Mutex.toString(), LDat2.AcquireLoc, LDat1->AcquireLoc); if (Modify && LDat1->LKind != LK_Exclusive) { - FSet1.removeLock(FactMan, FSet2Mutex); - FSet1.addLock(FactMan, FSet2Mutex, LDat2); + // Take the exclusive lock, which is the one in FSet2. + *I1 = *I; } } + else if (LDat1->Asserted && !LDat2.Asserted) { + // The non-asserted lock in FSet2 is the one we want to track. + *I1 = *I; + } } else { if (LDat2.UnderlyingMutex.isValid()) { if (FSet2.findLock(FactMan, LDat2.UnderlyingMutex)) { @@ -2186,14 +2277,15 @@ void ThreadSafetyAnalyzer::intersectAndWarn(FactSet &FSet1, JoinLoc, LEK1); } } - else if (!LDat2.Managed && !FSet2Mutex.isUniversal()) + else if (!LDat2.Managed && !FSet2Mutex.isUniversal() && !LDat2.Asserted) Handler.handleMutexHeldEndOfScope(FSet2Mutex.toString(), LDat2.AcquireLoc, JoinLoc, LEK1); } } - for (FactSet::const_iterator I = FSet1.begin(), E = FSet1.end(); + // Find locks in FSet1 that are not in FSet2, and remove them. + for (FactSet::const_iterator I = FSet1Orig.begin(), E = FSet1Orig.end(); I != E; ++I) { const SExpr &FSet1Mutex = FactMan[*I].MutID; const LockData &LDat1 = FactMan[*I].LDat; @@ -2209,7 +2301,7 @@ void ThreadSafetyAnalyzer::intersectAndWarn(FactSet &FSet1, JoinLoc, LEK1); } } - else if (!LDat1.Managed && !FSet1Mutex.isUniversal()) + else if (!LDat1.Managed && !FSet1Mutex.isUniversal() && !LDat1.Asserted) Handler.handleMutexHeldEndOfScope(FSet1Mutex.toString(), LDat1.AcquireLoc, JoinLoc, LEK2); @@ -2305,8 +2397,6 @@ void ThreadSafetyAnalyzer::runAnalysis(AnalysisDeclContext &AC) { = dyn_cast<SharedLocksRequiredAttr>(Attr)) { getMutexIDs(SharedLocksToAdd, A, (Expr*) 0, D); } else if (UnlockFunctionAttr *A = dyn_cast<UnlockFunctionAttr>(Attr)) { - if (!Handler.issueBetaWarnings()) - return; // UNLOCK_FUNCTION() is used to hide the underlying lock implementation. // We must ignore such methods. if (A->args_size() == 0) @@ -2316,15 +2406,11 @@ void ThreadSafetyAnalyzer::runAnalysis(AnalysisDeclContext &AC) { getMutexIDs(LocksReleased, A, (Expr*) 0, D); } else if (ExclusiveLockFunctionAttr *A = dyn_cast<ExclusiveLockFunctionAttr>(Attr)) { - if (!Handler.issueBetaWarnings()) - return; if (A->args_size() == 0) return; getMutexIDs(ExclusiveLocksAcquired, A, (Expr*) 0, D); } else if (SharedLockFunctionAttr *A = dyn_cast<SharedLockFunctionAttr>(Attr)) { - if (!Handler.issueBetaWarnings()) - return; if (A->args_size() == 0) return; getMutexIDs(SharedLocksAcquired, A, (Expr*) 0, D); diff --git a/contrib/llvm/tools/clang/lib/Analysis/UninitializedValues.cpp b/contrib/llvm/tools/clang/lib/Analysis/UninitializedValues.cpp index 730aa6b..332c02c 100644 --- a/contrib/llvm/tools/clang/lib/Analysis/UninitializedValues.cpp +++ b/contrib/llvm/tools/clang/lib/Analysis/UninitializedValues.cpp @@ -14,12 +14,12 @@ #include "clang/AST/ASTContext.h" #include "clang/AST/Attr.h" #include "clang/AST/Decl.h" +#include "clang/AST/StmtVisitor.h" #include "clang/Analysis/Analyses/PostOrderCFGView.h" #include "clang/Analysis/Analyses/UninitializedValues.h" #include "clang/Analysis/AnalysisContext.h" #include "clang/Analysis/CFG.h" #include "clang/Analysis/DomainSpecific/ObjCNoReturn.h" -#include "clang/Analysis/Visitors/CFGRecStmtDeclVisitor.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/PackedVector.h" @@ -240,10 +240,9 @@ const CFGBlock *DataflowWorklist::dequeue() { // First dequeue from the worklist. This can represent // updates along backedges that we want propagated as quickly as possible. - if (!worklist.empty()) { - B = worklist.back(); - worklist.pop_back(); - } + if (!worklist.empty()) + B = worklist.pop_back_val(); + // Next dequeue from the initial reverse post order. This is the // theoretical ideal in the presence of no back edges. else if (PO_I != PO_E) { @@ -527,14 +526,29 @@ public: // of marking it as not being a candidate element of the frontier. SuccsVisited[block->getBlockID()] = block->succ_size(); while (!Queue.empty()) { - const CFGBlock *B = Queue.back(); - Queue.pop_back(); + const CFGBlock *B = Queue.pop_back_val(); + + // If the use is always reached from the entry block, make a note of that. + if (B == &cfg.getEntry()) + Use.setUninitAfterCall(); + for (CFGBlock::const_pred_iterator I = B->pred_begin(), E = B->pred_end(); I != E; ++I) { const CFGBlock *Pred = *I; - if (vals.getValue(Pred, B, vd) == Initialized) + Value AtPredExit = vals.getValue(Pred, B, vd); + if (AtPredExit == Initialized) // This block initializes the variable. continue; + if (AtPredExit == MayUninitialized && + vals.getValue(B, 0, vd) == Uninitialized) { + // This block declares the variable (uninitialized), and is reachable + // from a block that initializes the variable. We can't guarantee to + // give an earlier location for the diagnostic (and it appears that + // this code is intended to be reachable) so give a diagnostic here + // and go no further down this path. + Use.setUninitAfterDecl(); + continue; + } unsigned &SV = SuccsVisited[Pred->getBlockID()]; if (!SV) { |
