Lines Matching +full:se +full:- +full:neg
1 //===- ThreadSafetyCommon.cpp ---------------------------------------------===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
11 //===----------------------------------------------------------------------===//
42 switch (CE->getStmtClass()) {
44 return toString(cast<IntegerLiteral>(CE)->getValue(), 10, true);
47 ret += cast<StringLiteral>(CE)->getString();
66 return Ph->status() == til::Phi::PH_Incomplete;
80 const auto *ME = dyn_cast<MemberExpr>(E->IgnoreParenCasts());
81 return ME ? ME->isArrow() : false;
85 return A->getName();
92 if (const auto *RT = VDT->getAs<RecordType>()) {
93 if (const auto *RD = RT->getDecl())
94 if (const auto *CA = RD->getAttr<CapabilityAttr>())
96 } else if (const auto *TT = VDT->getAs<TypedefType>()) {
97 if (const auto *TD = TT->getDecl())
98 if (const auto *CA = TD->getAttr<CapabilityAttr>())
100 } else if (VDT->isPointerType() || VDT->isReferenceType())
101 return ClassifyDiagnostic(VDT->getPointeeType());
113 /// \param Self S-expression to substitute for a \ref CXXThisExpr in a call,
130 Ctx.SelfArg = ME->getBase();
131 Ctx.SelfArrow = ME->isArrow();
133 Ctx.SelfArg = CE->getImplicitObjectArgument();
134 Ctx.SelfArrow = isCalleeArrow(CE->getCallee());
135 Ctx.NumArgs = CE->getNumArgs();
136 Ctx.FunArgs = CE->getArgs();
138 Ctx.NumArgs = CE->getNumArgs();
139 Ctx.FunArgs = CE->getArgs();
142 Ctx.NumArgs = CE->getNumArgs();
143 Ctx.FunArgs = CE->getArgs();
159 cast<CXXMethodDecl>(D)->getFunctionObjectParameterType()),
180 if (SLit->getString() == "*")
190 bool Neg = false;
192 if (OE->getOperator() == OO_Exclaim) {
193 Neg = true;
194 AttrExp = OE->getArg(0);
198 if (UO->getOpcode() == UO_LNot) {
199 Neg = true;
200 AttrExp = UO->getSubExpr()->IgnoreImplicit();
211 StringRef Kind = ClassifyDiagnostic(AttrExp->getType());
213 // Hack to deal with smart pointers -- strip off top-level pointer casts.
215 if (CE->castOpcode() == til::CAST_objToPtr)
216 return CapabilityExpr(CE->expr(), Kind, Neg);
218 return CapabilityExpr(E, Kind, Neg);
228 ClassifyDiagnostic(Exp->getType())};
243 switch (S->getStmtClass()) {
273 // We treat these as no-ops
275 return translate(cast<ConstantExpr>(S)->getSubExpr(), Ctx);
277 return translate(cast<ParenExpr>(S)->getSubExpr(), Ctx);
279 return translate(cast<ExprWithCleanups>(S)->getSubExpr(), Ctx);
281 return translate(cast<CXXBindTemporaryExpr>(S)->getSubExpr(), Ctx);
283 return translate(cast<MaterializeTemporaryExpr>(S)->getSubExpr(), Ctx);
310 const auto *VD = cast<ValueDecl>(DRE->getDecl()->getCanonicalDecl());
314 unsigned I = PV->getFunctionScopeIndex();
315 const DeclContext *D = PV->getDeclContext();
316 if (Ctx && Ctx->FunArgs) {
317 const Decl *Canonical = Ctx->AttrDecl->getCanonicalDecl();
319 ? (cast<FunctionDecl>(D)->getCanonicalDecl() == Canonical)
320 : (cast<ObjCMethodDecl>(D)->getCanonicalDecl() == Canonical)) {
323 Ctx->FunArgs.dyn_cast<const Expr *const *>()) {
324 assert(I < Ctx->NumArgs);
325 return translate(FunArgs[I], Ctx->Prev);
329 return Ctx->FunArgs.get<til::SExpr *>();
335 ? cast<FunctionDecl>(D)->getCanonicalDecl()->getParamDecl(I)
336 : cast<ObjCMethodDecl>(D)->getCanonicalDecl()->getParamDecl(I);
339 // For non-local variables, treat it as a reference to a named object.
346 if (Ctx && Ctx->SelfArg) {
347 if (const auto *SelfArg = dyn_cast<const Expr *>(Ctx->SelfArg))
348 return translate(SelfArg, Ctx->Prev);
350 return cast<til::SExpr *>(Ctx->SelfArg);
358 return V->clangDecl();
360 return Ph->clangDecl();
362 return P->clangDecl();
364 return L->clangDecl();
370 if (VD && VD->getType()->isAnyPointerType())
373 return C->castOpcode() == til::CAST_objToPtr;
381 D = D->getCanonicalDecl();
382 auto OverriddenMethods = D->overridden_methods();
393 til::SExpr *BE = translate(ME->getBase(), Ctx);
396 const auto *D = cast<ValueDecl>(ME->getMemberDecl()->getCanonicalDecl());
402 P->setArrow(true);
408 til::SExpr *BE = translate(IVRE->getBase(), Ctx);
411 const auto *D = cast<ObjCIvarDecl>(IVRE->getDecl()->getCanonicalDecl());
415 P->setArrow(true);
424 if (const FunctionDecl *FD = CE->getDirectCallee()) {
425 FD = FD->getMostRecentDecl();
426 if (LockReturnedAttr *At = FD->getAttr<LockReturnedAttr>()) {
428 LRCallCtx.AttrDecl = CE->getDirectCallee();
430 LRCallCtx.NumArgs = CE->getNumArgs();
431 LRCallCtx.FunArgs = CE->getArgs();
433 translateAttrExpr(At->getArg(), &LRCallCtx).sexpr());
438 til::SExpr *E = translate(CE->getCallee(), Ctx);
439 for (const auto *Arg : CE->arguments()) {
450 if (ME->getMethodDecl()->getNameAsString() == "get" &&
451 ME->getNumArgs() == 0) {
452 auto *E = translate(ME->getImplicitObjectArgument(), Ctx);
458 ME->getImplicitObjectArgument());
464 // Ignore operator * and operator -> on smart pointers.
465 OverloadedOperatorKind k = OCE->getOperator();
467 auto *E = translate(OCE->getArg(0), Ctx);
477 switch (UO->getOpcode()) {
487 if (const auto *DRE = dyn_cast<DeclRefExpr>(UO->getSubExpr())) {
488 if (DRE->getDecl()->isCXXInstanceMember()) {
489 // This is a pointer-to-member expression, e.g. &MyClass::mu_.
492 return new (Arena) til::Project(W, DRE->getDecl());
496 // otherwise, & is a no-op
497 return translate(UO->getSubExpr(), Ctx);
499 // We treat these as no-ops
502 return translate(UO->getSubExpr(), Ctx);
506 til::UnaryOp(til::UOP_Minus, translate(UO->getSubExpr(), Ctx));
509 til::UnaryOp(til::UOP_BitNot, translate(UO->getSubExpr(), Ctx));
512 til::UnaryOp(til::UOP_LogicNot, translate(UO->getSubExpr(), Ctx));
527 til::SExpr *E0 = translate(BO->getLHS(), Ctx);
528 til::SExpr *E1 = translate(BO->getRHS(), Ctx);
539 const Expr *LHS = BO->getLHS();
540 const Expr *RHS = BO->getRHS();
547 VD = DRE->getDecl();
563 switch (BO->getOpcode()) {
602 return translate(BO->getRHS(), Ctx);
609 CastKind K = CE->getCastKind();
612 if (const auto *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) {
613 til::SExpr *E0 = lookupVarDecl(DRE->getDecl());
617 til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
619 // FIXME!! -- get Load working properly
627 til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
632 til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
643 til::SExpr *E0 = translate(E->getBase(), Ctx);
644 til::SExpr *E1 = translate(E->getIdx(), Ctx);
651 auto *C = translate(CO->getCond(), Ctx);
652 auto *T = translate(CO->getTrueExpr(), Ctx);
653 auto *E = translate(CO->getFalseExpr(), Ctx);
659 DeclGroupRef DGrp = S->getDeclGroup();
662 Expr *E = VD->getInit();
663 til::SExpr* SE = translate(E, Ctx);
666 QualType T = VD->getType();
667 if (T.isTrivialType(VD->getASTContext()))
668 return addVarDecl(VD, SE);
677 // If (E) is non-trivial, then add it to the current basic block, and
683 if (!E || !CurrentBB || E->block() || til::ThreadSafetyTIL::isTrivial(E))
697 assert(CurrentLVarMap[It->second].first == VD);
698 return CurrentLVarMap[It->second].second;
708 if (!V->clangDecl())
709 V->setClangDecl(VD);
732 CurrentLVarMap.elem(It->second).second = E;
737 // If E != null, sets Phi[CurrentBlockInfo->ArgIndex] = E.
740 unsigned ArgIndex = CurrentBlockInfo->ProcessedPredecessors;
744 if (CurrE->block() == CurrentBB) {
750 Ph->values()[ArgIndex] = E;
757 Ph->values().setValues(NPreds, nullptr);
759 Ph->values()[PIdx] = CurrE;
761 Ph->values()[ArgIndex] = E;
762 Ph->setClangDecl(CurrentLVarMap[i].first);
763 // If E is from a back-edge, or either E or CurrE are incomplete, then
766 Ph->setStatus(til::Phi::PH_Incomplete);
770 if (Ph->status() == til::Phi::PH_Incomplete)
783 // Steal Map, using copy-on-write.
790 unsigned NPreds = CurrentBB->numPredecessors();
824 if (CurrentBlockInfo->HasBackEdges)
826 CurrentBlockInfo->HasBackEdges = true;
830 unsigned NPreds = CurrentBB->numPredecessors();
841 unsigned ArgIndex = BBInfo[Blk->getBlockID()].ProcessedPredecessors;
842 assert(ArgIndex > 0 && ArgIndex < BB->numPredecessors());
844 for (til::SExpr *PE : BB->arguments()) {
847 assert(Ph->values()[ArgIndex] == nullptr && "Wrong index for back edge.");
849 til::SExpr *E = lookupVarDecl(Ph->clangDecl());
851 Ph->values()[ArgIndex] = E;
858 unsigned NBlocks = Cfg->getNumBlockIDs();
867 BB->reserveInstructions(B->size());
868 BlockMap[B->getBlockID()] = BB;
871 CurrentBB = lookupBlock(&Cfg->getEntry());
872 auto Parms = isa<ObjCMethodDecl>(D) ? cast<ObjCMethodDecl>(D)->parameters()
873 : cast<FunctionDecl>(D)->parameters();
875 QualType T = Pm->getType();
876 if (!T.isTrivialType(Pm->getASTContext()))
891 CurrentBB->reservePredecessors(B->pred_size());
892 Scfg->add(CurrentBB);
894 CurrentBlockInfo = &BBInfo[B->getBlockID()];
904 CurrentBB->addPredecessor(BlockMap[Pred->getBlockID()]);
905 BlockInfo *PredInfo = &BBInfo[Pred->getBlockID()];
906 assert(PredInfo->UnprocessedSuccessors > 0);
908 if (--PredInfo->UnprocessedSuccessors == 0)
909 mergeEntryMap(std::move(PredInfo->ExitMap));
911 mergeEntryMap(PredInfo->ExitMap.clone());
913 ++CurrentBlockInfo->ProcessedPredecessors;
923 CurrentBB->arguments().reserve(
926 CurrentBB->addArgument(A);
944 CurrentBB->instructions().reserve(
947 CurrentBB->addInstruction(V);
950 unsigned N = B->succ_size();
951 auto It = B->succ_begin();
955 unsigned Idx = BB ? BB->findPredecessorIndex(CurrentBB) : 0;
957 CurrentBB->setTerminator(Tm);
960 til::SExpr *C = translate(B->getTerminatorCondition(true), nullptr);
966 CurrentBB->setTerminator(Tm);
971 ++CurrentBlockInfo->UnprocessedSuccessors;
976 ++BBInfo[Succ->getBlockID()].ProcessedPredecessors;
982 CurrentBlockInfo->ExitMap = std::move(CurrentLVarMap);
989 if (Ph->status() == til::Phi::PH_Incomplete)