|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h 355 class Variable : public SExpr {
435 class Future : public SExpr {
487 class Undefined : public SExpr {
509 class Wildcard : public SExpr {
529 class Literal : public SExpr {
635 class LiteralPtr : public SExpr {
662 class Function : public SExpr {
713 class SFunction : public SExpr {
763 class Code : public SExpr {
798 class Field : public SExpr {
837 class Apply : public SExpr {
872 class SApply : public SExpr {
910 class Project : public SExpr {
963 class Call : public SExpr {
993 class Alloc : public SExpr {
1029 class Load : public SExpr {
1056 class Store : public SExpr {
1091 class ArrayIndex : public SExpr {
1128 class ArrayAdd : public SExpr {
1164 class UnaryOp : public SExpr {
1202 class BinaryOp : public SExpr {
1253 class Cast : public SExpr {
1291 class Phi : public SExpr {
1344 class Terminator : public SExpr {
1499 class BasicBlock : public SExpr {
1686 class SCFG : public SExpr {
1785 class Identifier : public SExpr {
1810 class IfThenElse : public SExpr {
1855 class Let : public SExpr {
References
include/llvm/Support/Casting.h 57 static inline bool doit(const From &Val) {
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
367 dyn_cast_or_null(Y *Val) {
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h 63 inline bool equals(const til::SExpr *E1, const til::SExpr *E2) {
63 inline bool equals(const til::SExpr *E1, const til::SExpr *E2) {
67 inline bool matches(const til::SExpr *E1, const til::SExpr *E2) {
67 inline bool matches(const til::SExpr *E1, const til::SExpr *E2) {
79 inline bool partiallyMatches(const til::SExpr *E1, const til::SExpr *E2) {
79 inline bool partiallyMatches(const til::SExpr *E1, const til::SExpr *E2) {
89 inline std::string toString(const til::SExpr *E) {
273 const til::SExpr* CapExpr;
279 CapabilityExpr(const til::SExpr *E, bool Neg) : CapExpr(E), Negated(Neg) {}
281 const til::SExpr* sexpr() const { return CapExpr; }
379 til::SExpr *translate(const Stmt *S, CallingContext *Ctx);
382 til::SExpr *lookupStmt(const Stmt *S);
395 til::SExpr *translateDeclRefExpr(const DeclRefExpr *DRE,
397 til::SExpr *translateCXXThisExpr(const CXXThisExpr *TE, CallingContext *Ctx);
398 til::SExpr *translateMemberExpr(const MemberExpr *ME, CallingContext *Ctx);
399 til::SExpr *translateObjCIVarRefExpr(const ObjCIvarRefExpr *IVRE,
401 til::SExpr *translateCallExpr(const CallExpr *CE, CallingContext *Ctx,
403 til::SExpr *translateCXXMemberCallExpr(const CXXMemberCallExpr *ME,
405 til::SExpr *translateCXXOperatorCallExpr(const CXXOperatorCallExpr *OCE,
407 til::SExpr *translateUnaryOperator(const UnaryOperator *UO,
409 til::SExpr *translateBinOp(til::TIL_BinaryOpcode Op,
412 til::SExpr *translateBinAssign(til::TIL_BinaryOpcode Op,
415 til::SExpr *translateBinaryOperator(const BinaryOperator *BO,
417 til::SExpr *translateCastExpr(const CastExpr *CE, CallingContext *Ctx);
418 til::SExpr *translateArraySubscriptExpr(const ArraySubscriptExpr *E,
420 til::SExpr *translateAbstractConditionalOperator(
423 til::SExpr *translateDeclStmt(const DeclStmt *S, CallingContext *Ctx);
426 using StatementMap = llvm::DenseMap<const Stmt *, til::SExpr *>;
432 using NameVarPair = std::pair<const ValueDecl *, til::SExpr *>;
465 void insertStmt(const Stmt *S, til::SExpr *E) {
469 til::SExpr *getCurrentLVarDefinition(const ValueDecl *VD);
471 til::SExpr *addStatement(til::SExpr *E, const Stmt *S,
471 til::SExpr *addStatement(til::SExpr *E, const Stmt *S,
473 til::SExpr *lookupVarDecl(const ValueDecl *VD);
474 til::SExpr *addVarDecl(const ValueDecl *VD, til::SExpr *E);
474 til::SExpr *addVarDecl(const ValueDecl *VD, til::SExpr *E);
475 til::SExpr *updateVarDecl(const ValueDecl *VD, til::SExpr *E);
475 til::SExpr *updateVarDecl(const ValueDecl *VD, til::SExpr *E);
477 void makePhiNodeVar(unsigned i, unsigned NPreds, til::SExpr *E);
508 std::vector<til::SExpr *> CurrentInstructions;
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyLogical.h 43 til::SExpr *Expr;
46 Terminal(til::SExpr *Expr) : LExpr(LExpr::Terminal), Expr(Expr) {}
48 const til::SExpr *expr() const { return Expr; }
49 til::SExpr *expr() { return Expr; }
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h 322 SExpr(const SExpr &E) : Opcode(E.Opcode), Flags(E.Flags) {}
334 inline bool isTrivial(const SExpr *E) {
355 class Variable : public SExpr {
368 Variable(StringRef s, SExpr *D = nullptr)
373 Variable(SExpr *D, const ValueDecl *Cvd = nullptr)
379 Variable(const Variable &Vd, SExpr *D) // rewrite constructor
384 static bool classof(const SExpr *E) { return E->opcode() == COP_Variable; }
398 SExpr *definition() { return Definition; }
399 const SExpr *definition() const { return Definition; }
403 void setDefinition(SExpr *E) { Definition = E; }
427 SExpr *Definition;
435 class Future : public SExpr {
446 static bool classof(const SExpr *E) { return E->opcode() == COP_Future; }
449 virtual SExpr *compute() { return nullptr; }
452 SExpr *maybeGetResult() const { return Result; }
455 SExpr *result() {
480 SExpr* force();
483 SExpr *Result = nullptr;
487 class Undefined : public SExpr {
492 static bool classof(const SExpr *E) { return E->opcode() == COP_Undefined; }
509 class Wildcard : public SExpr {
514 static bool classof(const SExpr *E) { return E->opcode() == COP_Wildcard; }
529 class Literal : public SExpr {
536 static bool classof(const SExpr *E) { return E->opcode() == COP_Literal; }
635 class LiteralPtr : public SExpr {
640 static bool classof(const SExpr *E) { return E->opcode() == COP_LiteralPtr; }
662 class Function : public SExpr {
664 Function(Variable *Vd, SExpr *Bd)
669 Function(const Function &F, Variable *Vd, SExpr *Bd) // rewrite constructor
674 static bool classof(const SExpr *E) { return E->opcode() == COP_Function; }
679 SExpr *body() { return Body; }
680 const SExpr *body() const { return Body; }
707 SExpr* Body;
713 class SFunction : public SExpr {
715 SFunction(Variable *Vd, SExpr *B)
722 SFunction(const SFunction &F, Variable *Vd, SExpr *B) // rewrite constructor
729 static bool classof(const SExpr *E) { return E->opcode() == COP_SFunction; }
734 SExpr *body() { return Body; }
735 const SExpr *body() const { return Body; }
759 SExpr* Body;
763 class Code : public SExpr {
765 Code(SExpr *T, SExpr *B) : SExpr(COP_Code), ReturnType(T), Body(B) {}
765 Code(SExpr *T, SExpr *B) : SExpr(COP_Code), ReturnType(T), Body(B) {}
766 Code(const Code &C, SExpr *T, SExpr *B) // rewrite constructor
766 Code(const Code &C, SExpr *T, SExpr *B) // rewrite constructor
769 static bool classof(const SExpr *E) { return E->opcode() == COP_Code; }
771 SExpr *returnType() { return ReturnType; }
772 const SExpr *returnType() const { return ReturnType; }
774 SExpr *body() { return Body; }
775 const SExpr *body() const { return Body; }
793 SExpr* ReturnType;
794 SExpr* Body;
798 class Field : public SExpr {
800 Field(SExpr *R, SExpr *B) : SExpr(COP_Field), Range(R), Body(B) {}
800 Field(SExpr *R, SExpr *B) : SExpr(COP_Field), Range(R), Body(B) {}
801 Field(const Field &C, SExpr *R, SExpr *B) // rewrite constructor
801 Field(const Field &C, SExpr *R, SExpr *B) // rewrite constructor
804 static bool classof(const SExpr *E) { return E->opcode() == COP_Field; }
806 SExpr *range() { return Range; }
807 const SExpr *range() const { return Range; }
809 SExpr *body() { return Body; }
810 const SExpr *body() const { return Body; }
828 SExpr* Range;
829 SExpr* Body;
837 class Apply : public SExpr {
839 Apply(SExpr *F, SExpr *A) : SExpr(COP_Apply), Fun(F), Arg(A) {}
839 Apply(SExpr *F, SExpr *A) : SExpr(COP_Apply), Fun(F), Arg(A) {}
840 Apply(const Apply &A, SExpr *F, SExpr *Ar) // rewrite constructor
840 Apply(const Apply &A, SExpr *F, SExpr *Ar) // rewrite constructor
843 static bool classof(const SExpr *E) { return E->opcode() == COP_Apply; }
845 SExpr *fun() { return Fun; }
846 const SExpr *fun() const { return Fun; }
848 SExpr *arg() { return Arg; }
849 const SExpr *arg() const { return Arg; }
867 SExpr* Fun;
868 SExpr* Arg;
872 class SApply : public SExpr {
874 SApply(SExpr *Sf, SExpr *A = nullptr) : SExpr(COP_SApply), Sfun(Sf), Arg(A) {}
874 SApply(SExpr *Sf, SExpr *A = nullptr) : SExpr(COP_SApply), Sfun(Sf), Arg(A) {}
875 SApply(SApply &A, SExpr *Sf, SExpr *Ar = nullptr) // rewrite constructor
875 SApply(SApply &A, SExpr *Sf, SExpr *Ar = nullptr) // rewrite constructor
878 static bool classof(const SExpr *E) { return E->opcode() == COP_SApply; }
880 SExpr *sfun() { return Sfun; }
881 const SExpr *sfun() const { return Sfun; }
883 SExpr *arg() { return Arg ? Arg : Sfun; }
884 const SExpr *arg() const { return Arg ? Arg : Sfun; }
905 SExpr* Sfun;
906 SExpr* Arg;
910 class Project : public SExpr {
912 Project(SExpr *R, const ValueDecl *Cvd)
917 static bool classof(const SExpr *E) { return E->opcode() == COP_Project; }
919 SExpr *record() { return Rec; }
920 const SExpr *record() const { return Rec; }
957 SExpr* Rec;
963 class Call : public SExpr {
965 Call(SExpr *T, const CallExpr *Ce = nullptr)
967 Call(const Call &C, SExpr *T) : SExpr(C), Target(T), Cexpr(C.Cexpr) {}
969 static bool classof(const SExpr *E) { return E->opcode() == COP_Call; }
971 SExpr *target() { return Target; }
972 const SExpr *target() const { return Target; }
988 SExpr* Target;
993 class Alloc : public SExpr {
1000 Alloc(SExpr *D, AllocKind K) : SExpr(COP_Alloc), Dtype(D) { Flags = K; }
1001 Alloc(const Alloc &A, SExpr *Dt) : SExpr(A), Dtype(Dt) { Flags = A.kind(); }
1003 static bool classof(const SExpr *E) { return E->opcode() == COP_Call; }
1007 SExpr *dataType() { return Dtype; }
1008 const SExpr *dataType() const { return Dtype; }
1025 SExpr* Dtype;
1029 class Load : public SExpr {
1031 Load(SExpr *P) : SExpr(COP_Load), Ptr(P) {}
1032 Load(const Load &L, SExpr *P) : SExpr(L), Ptr(P) {}
1034 static bool classof(const SExpr *E) { return E->opcode() == COP_Load; }
1036 SExpr *pointer() { return Ptr; }
1037 const SExpr *pointer() const { return Ptr; }
1051 SExpr* Ptr;
1056 class Store : public SExpr {
1058 Store(SExpr *P, SExpr *V) : SExpr(COP_Store), Dest(P), Source(V) {}
1058 Store(SExpr *P, SExpr *V) : SExpr(COP_Store), Dest(P), Source(V) {}
1059 Store(const Store &S, SExpr *P, SExpr *V) : SExpr(S), Dest(P), Source(V) {}
1059 Store(const Store &S, SExpr *P, SExpr *V) : SExpr(S), Dest(P), Source(V) {}
1061 static bool classof(const SExpr *E) { return E->opcode() == COP_Store; }
1063 SExpr *destination() { return Dest; } // Address to store to
1064 const SExpr *destination() const { return Dest; }
1066 SExpr *source() { return Source; } // Value to store
1067 const SExpr *source() const { return Source; }
1085 SExpr* Dest;
1086 SExpr* Source;
1091 class ArrayIndex : public SExpr {
1093 ArrayIndex(SExpr *A, SExpr *N) : SExpr(COP_ArrayIndex), Array(A), Index(N) {}
1093 ArrayIndex(SExpr *A, SExpr *N) : SExpr(COP_ArrayIndex), Array(A), Index(N) {}
1094 ArrayIndex(const ArrayIndex &E, SExpr *A, SExpr *N)
1094 ArrayIndex(const ArrayIndex &E, SExpr *A, SExpr *N)
1097 static bool classof(const SExpr *E) { return E->opcode() == COP_ArrayIndex; }
1099 SExpr *array() { return Array; }
1100 const SExpr *array() const { return Array; }
1102 SExpr *index() { return Index; }
1103 const SExpr *index() const { return Index; }
1121 SExpr* Array;
1122 SExpr* Index;
1128 class ArrayAdd : public SExpr {
1130 ArrayAdd(SExpr *A, SExpr *N) : SExpr(COP_ArrayAdd), Array(A), Index(N) {}
1130 ArrayAdd(SExpr *A, SExpr *N) : SExpr(COP_ArrayAdd), Array(A), Index(N) {}
1131 ArrayAdd(const ArrayAdd &E, SExpr *A, SExpr *N)
1131 ArrayAdd(const ArrayAdd &E, SExpr *A, SExpr *N)
1134 static bool classof(const SExpr *E) { return E->opcode() == COP_ArrayAdd; }
1136 SExpr *array() { return Array; }
1137 const SExpr *array() const { return Array; }
1139 SExpr *index() { return Index; }
1140 const SExpr *index() const { return Index; }
1158 SExpr* Array;
1159 SExpr* Index;
1164 class UnaryOp : public SExpr {
1166 UnaryOp(TIL_UnaryOpcode Op, SExpr *E) : SExpr(COP_UnaryOp), Expr0(E) {
1170 UnaryOp(const UnaryOp &U, SExpr *E) : SExpr(U), Expr0(E) { Flags = U.Flags; }
1172 static bool classof(const SExpr *E) { return E->opcode() == COP_UnaryOp; }
1178 SExpr *expr() { return Expr0; }
1179 const SExpr *expr() const { return Expr0; }
1197 SExpr* Expr0;
1202 class BinaryOp : public SExpr {
1204 BinaryOp(TIL_BinaryOpcode Op, SExpr *E0, SExpr *E1)
1204 BinaryOp(TIL_BinaryOpcode Op, SExpr *E0, SExpr *E1)
1209 BinaryOp(const BinaryOp &B, SExpr *E0, SExpr *E1)
1209 BinaryOp(const BinaryOp &B, SExpr *E0, SExpr *E1)
1214 static bool classof(const SExpr *E) { return E->opcode() == COP_BinaryOp; }
1220 SExpr *expr0() { return Expr0; }
1221 const SExpr *expr0() const { return Expr0; }
1223 SExpr *expr1() { return Expr1; }
1224 const SExpr *expr1() const { return Expr1; }
1246 SExpr* Expr0;
1247 SExpr* Expr1;
1253 class Cast : public SExpr {
1255 Cast(TIL_CastOpcode Op, SExpr *E) : SExpr(COP_Cast), Expr0(E) { Flags = Op; }
1256 Cast(const Cast &C, SExpr *E) : SExpr(C), Expr0(E) { Flags = C.Flags; }
1258 static bool classof(const SExpr *E) { return E->opcode() == COP_Cast; }
1264 SExpr *expr() { return Expr0; }
1265 const SExpr *expr() const { return Expr0; }
1283 SExpr* Expr0;
1291 class Phi : public SExpr {
1293 using ValArray = SimpleArray<SExpr *>;
1308 static bool classof(const SExpr *E) { return E->opcode() == COP_Phi; }
1327 for (const auto *Val : Values)
1344 class Terminator : public SExpr {
1347 Terminator(const SExpr &E) : SExpr(E) {}
1350 static bool classof(const SExpr *E) {
1374 static bool classof(const SExpr *E) { return E->opcode() == COP_Goto; }
1407 Branch(SExpr *C, BasicBlock *T, BasicBlock *E)
1413 Branch(const Branch &Br, SExpr *C, BasicBlock *T, BasicBlock *E)
1419 static bool classof(const SExpr *E) { return E->opcode() == COP_Branch; }
1421 const SExpr *condition() const { return Condition; }
1422 SExpr *condition() { return Condition; }
1450 SExpr *Condition;
1458 Return(SExpr* Rval) : Terminator(COP_Return), Retval(Rval) {}
1459 Return(const Return &R, SExpr* Rval) : Terminator(R), Retval(Rval) {}
1461 static bool classof(const SExpr *E) { return E->opcode() == COP_Return; }
1466 SExpr *returnValue() { return Retval; }
1467 const SExpr *returnValue() const { return Retval; }
1481 SExpr* Retval;
1499 class BasicBlock : public SExpr {
1501 using InstrArray = SimpleArray<SExpr *>;
1537 static bool classof(const SExpr *E) { return E->opcode() == COP_BasicBlock; }
1587 void addInstruction(SExpr *V) {
1619 for (const auto *E : Args) {
1623 for (const auto *E : Instrs) {
1686 class SCFG : public SExpr {
1708 static bool classof(const SExpr *E) { return E->opcode() == COP_SCFG; }
1785 class Identifier : public SExpr {
1790 static bool classof(const SExpr *E) { return E->opcode() == COP_Identifier; }
1810 class IfThenElse : public SExpr {
1812 IfThenElse(SExpr *C, SExpr *T, SExpr *E)
1812 IfThenElse(SExpr *C, SExpr *T, SExpr *E)
1812 IfThenElse(SExpr *C, SExpr *T, SExpr *E)
1814 IfThenElse(const IfThenElse &I, SExpr *C, SExpr *T, SExpr *E)
1814 IfThenElse(const IfThenElse &I, SExpr *C, SExpr *T, SExpr *E)
1814 IfThenElse(const IfThenElse &I, SExpr *C, SExpr *T, SExpr *E)
1817 static bool classof(const SExpr *E) { return E->opcode() == COP_IfThenElse; }
1819 SExpr *condition() { return Condition; } // Address to store to
1820 const SExpr *condition() const { return Condition; }
1822 SExpr *thenExpr() { return ThenExpr; } // Value to store
1823 const SExpr *thenExpr() const { return ThenExpr; }
1825 SExpr *elseExpr() { return ElseExpr; } // Value to store
1826 const SExpr *elseExpr() const { return ElseExpr; }
1848 SExpr* Condition;
1849 SExpr* ThenExpr;
1850 SExpr* ElseExpr;
1855 class Let : public SExpr {
1857 Let(Variable *Vd, SExpr *Bd) : SExpr(COP_Let), VarDecl(Vd), Body(Bd) {
1861 Let(const Let &L, Variable *Vd, SExpr *Bd) : SExpr(L), VarDecl(Vd), Body(Bd) {
1865 static bool classof(const SExpr *E) { return E->opcode() == COP_Let; }
1870 SExpr *body() { return Body; }
1871 const SExpr *body() const { return Body; }
1898 SExpr* Body;
1901 const SExpr *getCanonicalVal(const SExpr *E);
1901 const SExpr *getCanonicalVal(const SExpr *E);
1902 SExpr* simplifyToCanonicalVal(SExpr *E);
1902 SExpr* simplifyToCanonicalVal(SExpr *E);
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h 74 typename R::R_SExpr traverseSExpr(SExpr *E, typename R::R_Ctx Ctx) {
79 typename R::R_SExpr traverseByCase(SExpr *E, typename R::R_Ctx Ctx) {
142 using R_SExpr = SExpr *;
294 bool traverse(SExpr *E, TraversalKind K = TRV_Normal) {
299 static bool visit(SExpr *E) {
315 bool compareByCase(const SExpr *E1, const SExpr* E2) {
315 bool compareByCase(const SExpr *E1, const SExpr* E2) {
341 bool compare(const SExpr *E1, const SExpr* E2) {
341 bool compare(const SExpr *E1, const SExpr* E2) {
355 static bool compareExprs(const SExpr *E1, const SExpr* E2) {
355 static bool compareExprs(const SExpr *E1, const SExpr* E2) {
375 bool compare(const SExpr *E1, const SExpr *E2) {
375 bool compare(const SExpr *E1, const SExpr *E2) {
393 static bool compareExprs(const SExpr *E1, const SExpr* E2) {
393 static bool compareExprs(const SExpr *E1, const SExpr* E2) {
420 static void print(const SExpr *E, StreamType &SS) {
442 unsigned precedence(const SExpr *E) {
498 void printSExpr(const SExpr *E, StreamType &SS, unsigned P, bool Sub=true) {
652 const SExpr *B = E->body();
683 const SExpr *F = E->fun();
732 const SExpr *T = E->target();
823 void printBBInstr(const SExpr *E, StreamType &SS) {
845 for (const auto *A : E->arguments())
848 for (const auto *I : E->instructions())
851 const SExpr *T = E->terminator();
866 for (const auto *V : E->values()) {
tools/clang/lib/Analysis/ThreadSafety.cpp 900 llvm::PointerIntPair<const til::SExpr *, 2, UnderlyingCapabilityKind>;
tools/clang/lib/Analysis/ThreadSafetyCommon.cpp 63 static bool isIncompletePhi(const til::SExpr *E) {
71 til::SExpr *SExprBuilder::lookupStmt(const Stmt *S) {
180 til::SExpr *E = translate(AttrExp, Ctx);
198 til::SExpr *SExprBuilder::translate(const Stmt *S, CallingContext *Ctx) {
204 if (til::SExpr *E = lookupStmt(S))
273 til::SExpr *SExprBuilder::translateDeclRefExpr(const DeclRefExpr *DRE,
302 til::SExpr *SExprBuilder::translateCXXThisExpr(const CXXThisExpr *TE,
311 static const ValueDecl *getValueDeclFromSExpr(const til::SExpr *E) {
323 static bool hasAnyPointerType(const til::SExpr *E) {
346 til::SExpr *SExprBuilder::translateMemberExpr(const MemberExpr *ME,
348 til::SExpr *BE = translate(ME->getBase(), Ctx);
349 til::SExpr *E = new (Arena) til::SApply(BE);
361 til::SExpr *SExprBuilder::translateObjCIVarRefExpr(const ObjCIvarRefExpr *IVRE,
363 til::SExpr *BE = translate(IVRE->getBase(), Ctx);
364 til::SExpr *E = new (Arena) til::SApply(BE);
374 til::SExpr *SExprBuilder::translateCallExpr(const CallExpr *CE,
393 til::SExpr *E = translate(CE->getCallee(), Ctx);
395 til::SExpr *A = translate(Arg, Ctx);
401 til::SExpr *SExprBuilder::translateCXXMemberCallExpr(
407 auto *E = translate(ME->getImplicitObjectArgument(), Ctx);
416 til::SExpr *SExprBuilder::translateCXXOperatorCallExpr(
422 auto *E = translate(OCE->getArg(0), Ctx);
430 til::SExpr *SExprBuilder::translateUnaryOperator(const UnaryOperator *UO,
479 til::SExpr *SExprBuilder::translateBinOp(til::TIL_BinaryOpcode Op,
482 til::SExpr *E0 = translate(BO->getLHS(), Ctx);
483 til::SExpr *E1 = translate(BO->getRHS(), Ctx);
490 til::SExpr *SExprBuilder::translateBinAssign(til::TIL_BinaryOpcode Op,
496 til::SExpr *E0 = translate(LHS, Ctx);
497 til::SExpr *E1 = translate(RHS, Ctx);
500 til::SExpr *CV = nullptr;
507 til::SExpr *Arg = CV ? CV : new (Arena) til::Load(E0);
516 til::SExpr *SExprBuilder::translateBinaryOperator(const BinaryOperator *BO,
562 til::SExpr *SExprBuilder::translateCastExpr(const CastExpr *CE,
568 til::SExpr *E0 = lookupVarDecl(DRE->getDecl());
572 til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
582 til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
587 til::SExpr *E0 = translate(CE->getSubExpr(), Ctx);
595 til::SExpr *
598 til::SExpr *E0 = translate(E->getBase(), Ctx);
599 til::SExpr *E1 = translate(E->getIdx(), Ctx);
603 til::SExpr *
606 auto *C = translate(CO->getCond(), Ctx);
607 auto *T = translate(CO->getTrueExpr(), Ctx);
608 auto *E = translate(CO->getFalseExpr(), Ctx);
612 til::SExpr *
618 til::SExpr* SE = translate(E, Ctx);
636 til::SExpr *SExprBuilder::addStatement(til::SExpr* E, const Stmt *S,
636 til::SExpr *SExprBuilder::addStatement(til::SExpr* E, const Stmt *S,
649 til::SExpr *SExprBuilder::lookupVarDecl(const ValueDecl *VD) {
659 static void maybeUpdateVD(til::SExpr *E, const ValueDecl *VD) {
669 til::SExpr *SExprBuilder::addVarDecl(const ValueDecl *VD, til::SExpr *E) {
669 til::SExpr *SExprBuilder::addVarDecl(const ValueDecl *VD, til::SExpr *E) {
678 til::SExpr *SExprBuilder::updateVarDecl(const ValueDecl *VD, til::SExpr *E) {
678 til::SExpr *SExprBuilder::updateVarDecl(const ValueDecl *VD, til::SExpr *E) {
682 til::SExpr *Ptr = new (Arena) til::LiteralPtr(VD);
683 til::SExpr *St = new (Arena) til::Store(Ptr, E);
694 void SExprBuilder::makePhiNodeVar(unsigned i, unsigned NPreds, til::SExpr *E) {
698 til::SExpr *CurrE = CurrentLVarMap[i].second;
799 for (til::SExpr *PE : BB->arguments()) {
804 til::SExpr *E = lookupVarDecl(Ph->clangDecl());
836 til::SExpr *Lp = new (Arena) til::LiteralPtr(Pm);
837 til::SExpr *Ld = new (Arena) til::Load(Lp);
838 til::SExpr *V = addStatement(Ld, nullptr, Pm);
885 til::SExpr *E = translate(S, nullptr);
891 til::SExpr *Sf = new (Arena) til::LiteralPtr(VD);
892 til::SExpr *Dr = new (Arena) til::LiteralPtr(DD);
893 til::SExpr *Ap = new (Arena) til::Apply(Dr, Sf);
894 til::SExpr *E = new (Arena) til::Call(Ap);
901 for (auto *V : CurrentInstructions)
915 til::SExpr *C = translate(B->getTerminatorCondition(true), nullptr);
tools/clang/lib/Analysis/ThreadSafetyTIL.cpp 51 SExpr* Future::force() {
62 for (auto *E : Args) {
73 for (auto *E : Args) {
82 const SExpr *til::getCanonicalVal(const SExpr *E) {
82 const SExpr *til::getCanonicalVal(const SExpr *E) {
104 SExpr *til::simplifyToCanonicalVal(SExpr *E) {
104 SExpr *til::simplifyToCanonicalVal(SExpr *E) {
139 SExpr *E0 = simplifyToCanonicalVal(Ph->values()[0]);
141 SExpr *Ei = simplifyToCanonicalVal(Ph->values()[i]);
153 for (auto *Arg : Args)
155 for (auto *Instr : Instrs)
usr/include/c++/7.4.0/type_traits 1983 { typedef _Up type; };