29 #include "llvm/ADT/StringExtras.h"
30 #include "llvm/ADT/StringRef.h"
31 #include "llvm/Support/Casting.h"
37 using namespace clang;
38 using namespace threadSafety;
43 case Stmt::IntegerLiteralClass:
45 case Stmt::StringLiteralClass: {
47 ret += cast<StringLiteral>(CE)->getString();
51 case Stmt::CharacterLiteralClass:
52 case Stmt::CXXNullPtrLiteralExprClass:
53 case Stmt::GNUNullExprClass:
54 case Stmt::CXXBoolLiteralExprClass:
55 case Stmt::FloatingLiteralClass:
56 case Stmt::ImaginaryLiteralClass:
57 case Stmt::ObjCStringLiteralClass:
65 if (
const auto *Ph = dyn_cast<til::Phi>(E))
73 auto It =
SMap.find(S);
86 return ME ? ME->isArrow() :
false;
98 if (
const auto *RD = RT->getDecl())
99 if (
const auto *CA = RD->getAttr<CapabilityAttr>())
102 if (
const auto *TD = TT->getDecl())
103 if (
const auto *CA = TD->getAttr<CapabilityAttr>())
130 if (
const auto *ME = dyn_cast<MemberExpr>(DeclExp)) {
133 }
else if (
const auto *CE = dyn_cast<CXXMemberCallExpr>(DeclExp)) {
134 Ctx.
SelfArg = CE->getImplicitObjectArgument();
136 Ctx.
NumArgs = CE->getNumArgs();
138 }
else if (
const auto *CE = dyn_cast<CallExpr>(DeclExp)) {
139 Ctx.
NumArgs = CE->getNumArgs();
141 }
else if (
const auto *CE = dyn_cast<CXXConstructExpr>(DeclExp)) {
143 Ctx.
NumArgs = CE->getNumArgs();
145 }
else if (D && isa<CXXDestructorDecl>(D)) {
152 if (SelfDecl && !Ctx.
SelfArg) {
179 if (
const auto* SLit = dyn_cast<StringLiteral>(AttrExp)) {
180 if (SLit->getString() == StringRef(
"*"))
191 if (
const auto *OE = dyn_cast<CXXOperatorCallExpr>(AttrExp)) {
192 if (OE->getOperator() == OO_Exclaim) {
194 AttrExp = OE->getArg(0);
197 else if (
const auto *UO = dyn_cast<UnaryOperator>(AttrExp)) {
198 if (UO->getOpcode() == UO_LNot) {
200 AttrExp = UO->getSubExpr();
208 if (!E || isa<til::Literal>(E))
214 if (
const auto *CE = dyn_cast<til::Cast>(E)) {
233 switch (S->getStmtClass()) {
234 case Stmt::DeclRefExprClass:
235 return translateDeclRefExpr(cast<DeclRefExpr>(S), Ctx);
236 case Stmt::CXXThisExprClass:
237 return translateCXXThisExpr(cast<CXXThisExpr>(S), Ctx);
238 case Stmt::MemberExprClass:
239 return translateMemberExpr(cast<MemberExpr>(S), Ctx);
240 case Stmt::ObjCIvarRefExprClass:
241 return translateObjCIVarRefExpr(cast<ObjCIvarRefExpr>(S), Ctx);
242 case Stmt::CallExprClass:
243 return translateCallExpr(cast<CallExpr>(S), Ctx);
244 case Stmt::CXXMemberCallExprClass:
245 return translateCXXMemberCallExpr(cast<CXXMemberCallExpr>(S), Ctx);
246 case Stmt::CXXOperatorCallExprClass:
247 return translateCXXOperatorCallExpr(cast<CXXOperatorCallExpr>(S), Ctx);
248 case Stmt::UnaryOperatorClass:
249 return translateUnaryOperator(cast<UnaryOperator>(S), Ctx);
250 case Stmt::BinaryOperatorClass:
251 case Stmt::CompoundAssignOperatorClass:
252 return translateBinaryOperator(cast<BinaryOperator>(S), Ctx);
254 case Stmt::ArraySubscriptExprClass:
255 return translateArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Ctx);
256 case Stmt::ConditionalOperatorClass:
257 return translateAbstractConditionalOperator(
258 cast<ConditionalOperator>(S), Ctx);
259 case Stmt::BinaryConditionalOperatorClass:
260 return translateAbstractConditionalOperator(
261 cast<BinaryConditionalOperator>(S), Ctx);
264 case Stmt::ConstantExprClass:
265 return translate(cast<ConstantExpr>(S)->getSubExpr(), Ctx);
266 case Stmt::ParenExprClass:
267 return translate(cast<ParenExpr>(S)->getSubExpr(), Ctx);
268 case Stmt::ExprWithCleanupsClass:
269 return translate(cast<ExprWithCleanups>(S)->getSubExpr(), Ctx);
270 case Stmt::CXXBindTemporaryExprClass:
271 return translate(cast<CXXBindTemporaryExpr>(S)->getSubExpr(), Ctx);
272 case Stmt::MaterializeTemporaryExprClass:
273 return translate(cast<MaterializeTemporaryExpr>(S)->getSubExpr(), Ctx);
276 case Stmt::CharacterLiteralClass:
277 case Stmt::CXXNullPtrLiteralExprClass:
278 case Stmt::GNUNullExprClass:
279 case Stmt::CXXBoolLiteralExprClass:
280 case Stmt::FloatingLiteralClass:
281 case Stmt::ImaginaryLiteralClass:
282 case Stmt::IntegerLiteralClass:
283 case Stmt::StringLiteralClass:
284 case Stmt::ObjCStringLiteralClass:
287 case Stmt::DeclStmtClass:
288 return translateDeclStmt(cast<DeclStmt>(S), Ctx);
292 if (
const auto *CE = dyn_cast<CastExpr>(S))
293 return translateCastExpr(CE, Ctx);
303 if (
const auto *PV = dyn_cast<ParmVarDecl>(VD)) {
304 unsigned I = PV->getFunctionScopeIndex();
308 if (isa<FunctionDecl>(D)
312 assert(I < Ctx->NumArgs);
318 VD = isa<FunctionDecl>(D)
319 ? cast<FunctionDecl>(D)->getCanonicalDecl()->getParamDecl(I)
320 : cast<ObjCMethodDecl>(D)->getCanonicalDecl()->getParamDecl(I);
332 assert(SelfVar &&
"We have no variable for 'this'!");
337 if (
const auto *
V = dyn_cast<til::Variable>(E))
338 return V->clangDecl();
339 if (
const auto *Ph = dyn_cast<til::Phi>(E))
340 return Ph->clangDecl();
341 if (
const auto *
P = dyn_cast<til::Project>(E))
342 return P->clangDecl();
343 if (
const auto *L = dyn_cast<til::LiteralPtr>(E))
344 return L->clangDecl();
350 if (VD && VD->getType()->isAnyPointerType())
352 if (
const auto *
C = dyn_cast<til::Cast>(E))
363 if (OverriddenMethods.begin() == OverriddenMethods.end())
366 D = *OverriddenMethods.begin();
377 if (
const auto *VD = dyn_cast<CXXMethodDecl>(D))
402 if (CapabilityExprMode) {
405 FD = FD->getMostRecentDecl();
406 if (LockReturnedAttr *At = FD->getAttr<LockReturnedAttr>()) {
409 LRCallCtx.SelfArg = SelfE;
411 LRCallCtx.FunArgs = CE->
getArgs();
419 for (
const auto *Arg : CE->
arguments()) {
426 til::SExpr *SExprBuilder::translateCXXMemberCallExpr(
428 if (CapabilityExprMode) {
437 return translateCallExpr(cast<CallExpr>(ME), Ctx,
441 til::SExpr *SExprBuilder::translateCXXOperatorCallExpr(
443 if (CapabilityExprMode) {
446 if (k == OO_Star || k == OO_Arrow) {
452 return translateCallExpr(cast<CallExpr>(OCE), Ctx);
465 if (CapabilityExprMode) {
467 if (
const auto *DRE = dyn_cast<DeclRefExpr>(UO->
getSubExpr())) {
526 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
528 CV = lookupVarDecl(VD);
534 E1 = addStatement(E1,
nullptr, VD);
537 return updateVarDecl(VD, E1);
548 case BO_Mul:
return translateBinOp(
til::BOP_Mul, BO, Ctx);
549 case BO_Div:
return translateBinOp(
til::BOP_Div, BO, Ctx);
550 case BO_Rem:
return translateBinOp(
til::BOP_Rem, BO, Ctx);
551 case BO_Add:
return translateBinOp(
til::BOP_Add, BO, Ctx);
552 case BO_Sub:
return translateBinOp(
til::BOP_Sub, BO, Ctx);
553 case BO_Shl:
return translateBinOp(
til::BOP_Shl, BO, Ctx);
554 case BO_Shr:
return translateBinOp(
til::BOP_Shr, BO, Ctx);
555 case BO_LT:
return translateBinOp(
til::BOP_Lt, BO, Ctx);
556 case BO_GT:
return translateBinOp(
til::BOP_Lt, BO, Ctx,
true);
557 case BO_LE:
return translateBinOp(
til::BOP_Leq, BO, Ctx);
558 case BO_GE:
return translateBinOp(
til::BOP_Leq, BO, Ctx,
true);
559 case BO_EQ:
return translateBinOp(
til::BOP_Eq, BO, Ctx);
560 case BO_NE:
return translateBinOp(
til::BOP_Neq, BO, Ctx);
561 case BO_Cmp:
return translateBinOp(
til::BOP_Cmp, BO, Ctx);
568 case BO_Assign:
return translateBinAssign(
til::BOP_Eq, BO, Ctx,
true);
569 case BO_MulAssign:
return translateBinAssign(
til::BOP_Mul, BO, Ctx);
570 case BO_DivAssign:
return translateBinAssign(
til::BOP_Div, BO, Ctx);
571 case BO_RemAssign:
return translateBinAssign(
til::BOP_Rem, BO, Ctx);
572 case BO_AddAssign:
return translateBinAssign(
til::BOP_Add, BO, Ctx);
573 case BO_SubAssign:
return translateBinAssign(
til::BOP_Sub, BO, Ctx);
574 case BO_ShlAssign:
return translateBinAssign(
til::BOP_Shl, BO, Ctx);
575 case BO_ShrAssign:
return translateBinAssign(
til::BOP_Shr, BO, Ctx);
576 case BO_AndAssign:
return translateBinAssign(
til::BOP_BitAnd, BO, Ctx);
577 case BO_XorAssign:
return translateBinAssign(
til::BOP_BitXor, BO, Ctx);
578 case BO_OrAssign:
return translateBinAssign(
til::BOP_BitOr, BO, Ctx);
591 case CK_LValueToRValue: {
592 if (
const auto *DRE = dyn_cast<DeclRefExpr>(CE->
getSubExpr())) {
603 case CK_DerivedToBase:
604 case CK_UncheckedDerivedToBase:
605 case CK_ArrayToPointerDecay:
606 case CK_FunctionToPointerDecay: {
613 if (CapabilityExprMode)
629 SExprBuilder::translateAbstractConditionalOperator(
640 for (
auto I : DGrp) {
641 if (
auto *VD = dyn_cast_or_null<VarDecl>(I)) {
642 Expr *E = VD->getInit();
648 return addVarDecl(VD, SE);
667 CurrentInstructions.push_back(E);
675 auto It = LVarIdxMap.find(VD);
676 if (It != LVarIdxMap.end()) {
677 assert(CurrentLVarMap[It->second].first == VD);
678 return CurrentLVarMap[It->second].second;
687 if (
auto *
V = dyn_cast<til::Variable>(E)) {
696 LVarIdxMap.insert(std::make_pair(VD, CurrentLVarMap.
size()));
698 CurrentLVarMap.
push_back(std::make_pair(VD, E));
705 auto It = LVarIdxMap.find(VD);
706 if (It == LVarIdxMap.end()) {
712 CurrentLVarMap.
elem(It->second).second = E;
719 void SExprBuilder::makePhiNodeVar(
unsigned i,
unsigned NPreds,
til::SExpr *E) {
720 unsigned ArgIndex = CurrentBlockInfo->ProcessedPredecessors;
721 assert(ArgIndex > 0 && ArgIndex < NPreds);
724 if (CurrE->
block() == CurrentBB) {
727 auto *Ph = dyn_cast<til::Phi>(CurrE);
728 assert(Ph &&
"Expecting Phi node.");
730 Ph->values()[ArgIndex] = E;
738 for (
unsigned PIdx = 0; PIdx < ArgIndex; ++PIdx)
739 Ph->
values()[PIdx] = CurrE;
741 Ph->
values()[ArgIndex] = E;
749 CurrentArguments.push_back(Ph);
751 IncompleteArgs.push_back(Ph);
754 CurrentLVarMap.
elem(i).second = Ph;
759 void SExprBuilder::mergeEntryMap(LVarDefinitionMap Map) {
760 assert(CurrentBlockInfo &&
"Not processing a block!");
762 if (!CurrentLVarMap.
valid()) {
764 CurrentLVarMap = std::move(Map);
767 if (CurrentLVarMap.
sameAs(Map))
771 unsigned ESz = CurrentLVarMap.
size();
772 unsigned MSz = Map.size();
775 for (
unsigned i = 0; i < Sz; ++i) {
776 if (CurrentLVarMap[i].first != Map[i].first) {
782 if (CurrentLVarMap[i].second != Map[i].second)
783 makePhiNodeVar(i, NPreds, Map[i].second);
787 CurrentLVarMap.
downsize(Map.size());
793 void SExprBuilder::mergeEntryMapBackEdge() {
802 assert(CurrentBlockInfo &&
"Not processing a block!");
804 if (CurrentBlockInfo->HasBackEdges)
806 CurrentBlockInfo->HasBackEdges =
true;
809 unsigned Sz = CurrentLVarMap.
size();
812 for (
unsigned i = 0; i < Sz; ++i)
813 makePhiNodeVar(i, NPreds,
nullptr);
819 void SExprBuilder::mergePhiNodesBackEdge(
const CFGBlock *Blk) {
821 unsigned ArgIndex = BBInfo[Blk->
getBlockID()].ProcessedPredecessors;
822 assert(ArgIndex > 0 && ArgIndex < BB->numPredecessors());
825 auto *Ph = dyn_cast_or_null<til::Phi>(PE);
826 assert(Ph &&
"Expecting Phi Node.");
827 assert(Ph->
values()[ArgIndex] ==
nullptr &&
"Wrong index for back edge.");
830 assert(E &&
"Couldn't find local variable for Phi node.");
831 Ph->
values()[ArgIndex] = E;
835 void SExprBuilder::enterCFG(
CFG *Cfg,
const NamedDecl *D,
839 Scfg =
new (Arena)
til::SCFG(Arena, NBlocks);
842 BBInfo.resize(NBlocks);
843 BlockMap.resize(NBlocks,
nullptr);
845 for (
auto *B : *Cfg) {
848 BlockMap[B->getBlockID()] = BB;
852 auto Parms = isa<ObjCMethodDecl>(D) ? cast<ObjCMethodDecl>(D)->parameters()
853 : cast<FunctionDecl>(D)->parameters();
854 for (
auto *Pm : Parms) {
868 void SExprBuilder::enterCFGBlock(
const CFGBlock *B) {
872 Scfg->
add(CurrentBB);
881 void SExprBuilder::handlePredecessor(
const CFGBlock *Pred) {
885 BlockInfo *PredInfo = &BBInfo[Pred->
getBlockID()];
886 assert(PredInfo->UnprocessedSuccessors > 0);
888 if (--PredInfo->UnprocessedSuccessors == 0)
889 mergeEntryMap(std::move(PredInfo->ExitMap));
891 mergeEntryMap(PredInfo->ExitMap.clone());
893 ++CurrentBlockInfo->ProcessedPredecessors;
896 void SExprBuilder::handlePredecessorBackEdge(
const CFGBlock *Pred) {
897 mergeEntryMapBackEdge();
900 void SExprBuilder::enterCFGBlockBody(
const CFGBlock *B) {
904 static_cast<unsigned>(CurrentArguments.size()), Arena);
905 for (
auto *A : CurrentArguments)
909 void SExprBuilder::handleStatement(
const Stmt *S) {
914 void SExprBuilder::handleDestructorCall(
const VarDecl *VD,
920 addStatement(E,
nullptr);
923 void SExprBuilder::exitCFGBlockBody(
const CFGBlock *B) {
925 static_cast<unsigned>(CurrentInstructions.size()), Arena);
926 for (
auto *
V : CurrentInstructions)
936 auto *Tm =
new (Arena)
til::Goto(BB, Idx);
950 void SExprBuilder::handleSuccessor(
const CFGBlock *Succ) {
951 ++CurrentBlockInfo->UnprocessedSuccessors;
954 void SExprBuilder::handleSuccessorBackEdge(
const CFGBlock *Succ) {
955 mergePhiNodesBackEdge(Succ);
956 ++BBInfo[Succ->
getBlockID()].ProcessedPredecessors;
959 void SExprBuilder::exitCFGBlock(
const CFGBlock *B) {
960 CurrentArguments.clear();
961 CurrentInstructions.clear();
962 CurrentBlockInfo->ExitMap = std::move(CurrentLVarMap);
964 CurrentBlockInfo =
nullptr;
967 void SExprBuilder::exitCFG(
const CFGBlock *Last) {
968 for (
auto *Ph : IncompleteArgs) {
973 CurrentArguments.clear();
974 CurrentInstructions.clear();
975 IncompleteArgs.clear();