29#include "llvm/ADT/StringExtras.h"
30#include "llvm/ADT/StringRef.h"
31#include "llvm/Support/Casting.h"
38using namespace threadSafety;
43 case Stmt::IntegerLiteralClass:
44 return toString(cast<IntegerLiteral>(CE)->getValue(), 10,
true);
45 case Stmt::StringLiteralClass: {
46 std::string ret(
"\"");
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>())
124 if (!DeclExp && !Self)
133 else if (
const auto *ME = dyn_cast<MemberExpr>(DeclExp)) {
136 }
else if (
const auto *CE = dyn_cast<CXXMemberCallExpr>(DeclExp)) {
137 Ctx.
SelfArg = CE->getImplicitObjectArgument();
139 Ctx.
NumArgs = CE->getNumArgs();
141 }
else if (
const auto *CE = dyn_cast<CallExpr>(DeclExp)) {
142 Ctx.
NumArgs = CE->getNumArgs();
144 }
else if (
const auto *CE = dyn_cast<CXXConstructExpr>(DeclExp)) {
146 Ctx.
NumArgs = CE->getNumArgs();
151 assert(!Ctx.
SelfArg &&
"Ambiguous self argument");
177 if (
const auto* SLit = dyn_cast<StringLiteral>(AttrExp)) {
178 if (SLit->getString() == StringRef(
"*"))
189 if (
const auto *OE = dyn_cast<CXXOperatorCallExpr>(AttrExp)) {
190 if (OE->getOperator() == OO_Exclaim) {
192 AttrExp = OE->getArg(0);
195 else if (
const auto *UO = dyn_cast<UnaryOperator>(AttrExp)) {
196 if (UO->getOpcode() == UO_LNot) {
198 AttrExp = UO->getSubExpr();
206 if (!E || isa<til::Literal>(E))
212 if (
const auto *CE = dyn_cast<til::Cast>(E)) {
223std::pair<til::LiteralPtr *, StringRef>
241 switch (S->getStmtClass()) {
242 case Stmt::DeclRefExprClass:
243 return translateDeclRefExpr(cast<DeclRefExpr>(S), Ctx);
244 case Stmt::CXXThisExprClass:
245 return translateCXXThisExpr(cast<CXXThisExpr>(S), Ctx);
246 case Stmt::MemberExprClass:
247 return translateMemberExpr(cast<MemberExpr>(S), Ctx);
248 case Stmt::ObjCIvarRefExprClass:
249 return translateObjCIVarRefExpr(cast<ObjCIvarRefExpr>(S), Ctx);
250 case Stmt::CallExprClass:
251 return translateCallExpr(cast<CallExpr>(S), Ctx);
252 case Stmt::CXXMemberCallExprClass:
253 return translateCXXMemberCallExpr(cast<CXXMemberCallExpr>(S), Ctx);
254 case Stmt::CXXOperatorCallExprClass:
255 return translateCXXOperatorCallExpr(cast<CXXOperatorCallExpr>(S), Ctx);
256 case Stmt::UnaryOperatorClass:
257 return translateUnaryOperator(cast<UnaryOperator>(S), Ctx);
258 case Stmt::BinaryOperatorClass:
259 case Stmt::CompoundAssignOperatorClass:
260 return translateBinaryOperator(cast<BinaryOperator>(S), Ctx);
262 case Stmt::ArraySubscriptExprClass:
263 return translateArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Ctx);
264 case Stmt::ConditionalOperatorClass:
265 return translateAbstractConditionalOperator(
266 cast<ConditionalOperator>(S), Ctx);
267 case Stmt::BinaryConditionalOperatorClass:
268 return translateAbstractConditionalOperator(
269 cast<BinaryConditionalOperator>(S), Ctx);
272 case Stmt::ConstantExprClass:
273 return translate(cast<ConstantExpr>(S)->getSubExpr(), Ctx);
274 case Stmt::ParenExprClass:
275 return translate(cast<ParenExpr>(S)->getSubExpr(), Ctx);
276 case Stmt::ExprWithCleanupsClass:
277 return translate(cast<ExprWithCleanups>(S)->getSubExpr(), Ctx);
278 case Stmt::CXXBindTemporaryExprClass:
279 return translate(cast<CXXBindTemporaryExpr>(S)->getSubExpr(), Ctx);
280 case Stmt::MaterializeTemporaryExprClass:
281 return translate(cast<MaterializeTemporaryExpr>(S)->getSubExpr(), Ctx);
284 case Stmt::CharacterLiteralClass:
285 case Stmt::CXXNullPtrLiteralExprClass:
286 case Stmt::GNUNullExprClass:
287 case Stmt::CXXBoolLiteralExprClass:
288 case Stmt::FloatingLiteralClass:
289 case Stmt::ImaginaryLiteralClass:
290 case Stmt::IntegerLiteralClass:
291 case Stmt::StringLiteralClass:
292 case Stmt::ObjCStringLiteralClass:
295 case Stmt::DeclStmtClass:
296 return translateDeclStmt(cast<DeclStmt>(S), Ctx);
300 if (
const auto *CE = dyn_cast<CastExpr>(S))
301 return translateCastExpr(CE, Ctx);
311 if (
const auto *PV = dyn_cast<ParmVarDecl>(VD)) {
312 unsigned I = PV->getFunctionScopeIndex();
316 if (isa<FunctionDecl>(D)
320 assert(I < Ctx->NumArgs);
326 VD = isa<FunctionDecl>(D)
327 ? cast<FunctionDecl>(D)->getCanonicalDecl()->getParamDecl(I)
328 : cast<ObjCMethodDecl>(D)->getCanonicalDecl()->getParamDecl(I);
339 if (
const auto *SelfArg = dyn_cast<const Expr *>(Ctx->
SelfArg))
342 return cast<til::SExpr *>(Ctx->
SelfArg);
344 assert(SelfVar &&
"We have no variable for 'this'!");
349 if (
const auto *
V = dyn_cast<til::Variable>(E))
350 return V->clangDecl();
351 if (
const auto *Ph = dyn_cast<til::Phi>(E))
352 return Ph->clangDecl();
353 if (
const auto *
P = dyn_cast<til::Project>(E))
354 return P->clangDecl();
355 if (
const auto *L = dyn_cast<til::LiteralPtr>(E))
356 return L->clangDecl();
362 if (VD && VD->getType()->isAnyPointerType())
364 if (
const auto *
C = dyn_cast<til::Cast>(E))
375 if (OverriddenMethods.begin() == OverriddenMethods.end())
378 D = *OverriddenMethods.begin();
389 if (
const auto *VD = dyn_cast<CXXMethodDecl>(D))
414 if (CapabilityExprMode) {
417 FD = FD->getMostRecentDecl();
418 if (LockReturnedAttr *At = FD->getAttr<LockReturnedAttr>()) {
421 LRCallCtx.SelfArg = SelfE;
423 LRCallCtx.FunArgs = CE->
getArgs();
431 for (
const auto *Arg : CE->
arguments()) {
438til::SExpr *SExprBuilder::translateCXXMemberCallExpr(
440 if (CapabilityExprMode) {
449 return translateCallExpr(cast<CallExpr>(ME), Ctx,
453til::SExpr *SExprBuilder::translateCXXOperatorCallExpr(
455 if (CapabilityExprMode) {
458 if (k == OO_Star || k == OO_Arrow) {
464 return translateCallExpr(cast<CallExpr>(OCE), Ctx);
477 if (CapabilityExprMode) {
479 if (
const auto *DRE = dyn_cast<DeclRefExpr>(UO->
getSubExpr())) {
538 if (
const auto *DRE = dyn_cast<DeclRefExpr>(LHS)) {
540 CV = lookupVarDecl(VD);
546 E1 = addStatement(E1,
nullptr, VD);
549 return updateVarDecl(VD, E1);
560 case BO_Mul:
return translateBinOp(
til::BOP_Mul, BO, Ctx);
561 case BO_Div:
return translateBinOp(
til::BOP_Div, BO, Ctx);
562 case BO_Rem:
return translateBinOp(
til::BOP_Rem, BO, Ctx);
563 case BO_Add:
return translateBinOp(
til::BOP_Add, BO, Ctx);
564 case BO_Sub:
return translateBinOp(
til::BOP_Sub, BO, Ctx);
565 case BO_Shl:
return translateBinOp(
til::BOP_Shl, BO, Ctx);
566 case BO_Shr:
return translateBinOp(
til::BOP_Shr, BO, Ctx);
567 case BO_LT:
return translateBinOp(
til::BOP_Lt, BO, Ctx);
568 case BO_GT:
return translateBinOp(
til::BOP_Lt, BO, Ctx,
true);
569 case BO_LE:
return translateBinOp(
til::BOP_Leq, BO, Ctx);
570 case BO_GE:
return translateBinOp(
til::BOP_Leq, BO, Ctx,
true);
571 case BO_EQ:
return translateBinOp(
til::BOP_Eq, BO, Ctx);
572 case BO_NE:
return translateBinOp(
til::BOP_Neq, BO, Ctx);
573 case BO_Cmp:
return translateBinOp(
til::BOP_Cmp, BO, Ctx);
580 case BO_Assign:
return translateBinAssign(
til::BOP_Eq, BO, Ctx,
true);
581 case BO_MulAssign:
return translateBinAssign(
til::BOP_Mul, BO, Ctx);
582 case BO_DivAssign:
return translateBinAssign(
til::BOP_Div, BO, Ctx);
583 case BO_RemAssign:
return translateBinAssign(
til::BOP_Rem, BO, Ctx);
584 case BO_AddAssign:
return translateBinAssign(
til::BOP_Add, BO, Ctx);
585 case BO_SubAssign:
return translateBinAssign(
til::BOP_Sub, BO, Ctx);
586 case BO_ShlAssign:
return translateBinAssign(
til::BOP_Shl, BO, Ctx);
587 case BO_ShrAssign:
return translateBinAssign(
til::BOP_Shr, BO, Ctx);
588 case BO_AndAssign:
return translateBinAssign(
til::BOP_BitAnd, BO, Ctx);
589 case BO_XorAssign:
return translateBinAssign(
til::BOP_BitXor, BO, Ctx);
590 case BO_OrAssign:
return translateBinAssign(
til::BOP_BitOr, BO, Ctx);
603 case CK_LValueToRValue: {
604 if (
const auto *DRE = dyn_cast<DeclRefExpr>(CE->
getSubExpr())) {
615 case CK_DerivedToBase:
616 case CK_UncheckedDerivedToBase:
617 case CK_ArrayToPointerDecay:
618 case CK_FunctionToPointerDecay: {
625 if (CapabilityExprMode)
641SExprBuilder::translateAbstractConditionalOperator(
652 for (
auto *I : DGrp) {
653 if (
auto *VD = dyn_cast_or_null<VarDecl>(I)) {
654 Expr *E = VD->getInit();
660 return addVarDecl(VD, SE);
679 CurrentInstructions.push_back(E);
687 auto It = LVarIdxMap.find(VD);
688 if (It != LVarIdxMap.end()) {
689 assert(CurrentLVarMap[It->second].first == VD);
690 return CurrentLVarMap[It->second].second;
699 if (
auto *
V = dyn_cast<til::Variable>(E)) {
708 LVarIdxMap.insert(std::make_pair(VD, CurrentLVarMap.
size()));
710 CurrentLVarMap.
push_back(std::make_pair(VD, E));
717 auto It = LVarIdxMap.find(VD);
718 if (It == LVarIdxMap.end()) {
724 CurrentLVarMap.
elem(It->second).second = E;
731void SExprBuilder::makePhiNodeVar(
unsigned i,
unsigned NPreds,
til::SExpr *E) {
732 unsigned ArgIndex = CurrentBlockInfo->ProcessedPredecessors;
733 assert(ArgIndex > 0 && ArgIndex < NPreds);
736 if (CurrE->
block() == CurrentBB) {
739 auto *Ph = dyn_cast<til::Phi>(CurrE);
740 assert(Ph &&
"Expecting Phi node.");
742 Ph->values()[ArgIndex] = E;
750 for (
unsigned PIdx = 0; PIdx < ArgIndex; ++PIdx)
751 Ph->
values()[PIdx] = CurrE;
753 Ph->
values()[ArgIndex] = E;
761 CurrentArguments.push_back(Ph);
763 IncompleteArgs.push_back(Ph);
766 CurrentLVarMap.
elem(i).second = Ph;
771void SExprBuilder::mergeEntryMap(LVarDefinitionMap Map) {
772 assert(CurrentBlockInfo &&
"Not processing a block!");
774 if (!CurrentLVarMap.
valid()) {
776 CurrentLVarMap = std::move(Map);
779 if (CurrentLVarMap.
sameAs(Map))
783 unsigned ESz = CurrentLVarMap.
size();
784 unsigned MSz = Map.size();
785 unsigned Sz = std::min(ESz, MSz);
787 for (
unsigned i = 0; i < Sz; ++i) {
788 if (CurrentLVarMap[i].first != Map[i].first) {
794 if (CurrentLVarMap[i].second != Map[i].second)
795 makePhiNodeVar(i, NPreds, Map[i].second);
799 CurrentLVarMap.
downsize(Map.size());
805void SExprBuilder::mergeEntryMapBackEdge() {
814 assert(CurrentBlockInfo &&
"Not processing a block!");
816 if (CurrentBlockInfo->HasBackEdges)
818 CurrentBlockInfo->HasBackEdges =
true;
821 unsigned Sz = CurrentLVarMap.
size();
824 for (
unsigned i = 0; i < Sz; ++i)
825 makePhiNodeVar(i, NPreds,
nullptr);
831void SExprBuilder::mergePhiNodesBackEdge(
const CFGBlock *Blk) {
833 unsigned ArgIndex = BBInfo[Blk->
getBlockID()].ProcessedPredecessors;
834 assert(ArgIndex > 0 && ArgIndex < BB->numPredecessors());
837 auto *Ph = dyn_cast_or_null<til::Phi>(PE);
838 assert(Ph &&
"Expecting Phi Node.");
839 assert(Ph->
values()[ArgIndex] ==
nullptr &&
"Wrong index for back edge.");
842 assert(E &&
"Couldn't find local variable for Phi node.");
843 Ph->
values()[ArgIndex] = E;
847void SExprBuilder::enterCFG(
CFG *Cfg,
const NamedDecl *D,
851 Scfg =
new (Arena)
til::SCFG(Arena, NBlocks);
854 BBInfo.resize(NBlocks);
855 BlockMap.resize(NBlocks,
nullptr);
857 for (
auto *B : *Cfg) {
860 BlockMap[B->getBlockID()] = BB;
864 auto Parms = isa<ObjCMethodDecl>(D) ? cast<ObjCMethodDecl>(D)->parameters()
865 : cast<FunctionDecl>(D)->parameters();
866 for (
auto *Pm : Parms) {
880void SExprBuilder::enterCFGBlock(
const CFGBlock *B) {
884 Scfg->
add(CurrentBB);
893void SExprBuilder::handlePredecessor(
const CFGBlock *Pred) {
897 BlockInfo *PredInfo = &BBInfo[Pred->
getBlockID()];
898 assert(PredInfo->UnprocessedSuccessors > 0);
900 if (--PredInfo->UnprocessedSuccessors == 0)
901 mergeEntryMap(std::move(PredInfo->ExitMap));
903 mergeEntryMap(PredInfo->ExitMap.clone());
905 ++CurrentBlockInfo->ProcessedPredecessors;
908void SExprBuilder::handlePredecessorBackEdge(
const CFGBlock *Pred) {
909 mergeEntryMapBackEdge();
912void SExprBuilder::enterCFGBlockBody(
const CFGBlock *B) {
916 static_cast<unsigned>(CurrentArguments.size()), Arena);
917 for (
auto *A : CurrentArguments)
921void SExprBuilder::handleStatement(
const Stmt *S) {
926void SExprBuilder::handleDestructorCall(
const VarDecl *VD,
932 addStatement(E,
nullptr);
935void SExprBuilder::exitCFGBlockBody(
const CFGBlock *B) {
937 static_cast<unsigned>(CurrentInstructions.size()), Arena);
938 for (
auto *
V : CurrentInstructions)
948 auto *Tm =
new (Arena)
til::Goto(BB, Idx);
962void SExprBuilder::handleSuccessor(
const CFGBlock *Succ) {
963 ++CurrentBlockInfo->UnprocessedSuccessors;
966void SExprBuilder::handleSuccessorBackEdge(
const CFGBlock *Succ) {
967 mergePhiNodesBackEdge(Succ);
968 ++BBInfo[Succ->
getBlockID()].ProcessedPredecessors;
971void SExprBuilder::exitCFGBlock(
const CFGBlock *B) {
972 CurrentArguments.clear();
973 CurrentInstructions.clear();
974 CurrentBlockInfo->ExitMap = std::move(CurrentLVarMap);
976 CurrentBlockInfo =
nullptr;
980 for (
auto *Ph : IncompleteArgs) {
985 CurrentArguments.clear();
986 CurrentInstructions.clear();
987 IncompleteArgs.clear();
llvm::DenseMap< const Stmt *, CFGBlock * > SMap
static QualType getThisObjectType(ASTContext &C, const FunctionProtoType *FPT, const CXXRecordDecl *Decl)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the clang::Expr interface and subclasses for C++ expressions.
static const Decl * getCanonicalDecl(const Decl *D)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines an enumeration for C++ overloaded operators.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Defines various enumerations that describe declaration and type specifiers.
static bool isIncompletePhi(const til::SExpr *E)
static const ValueDecl * getValueDeclFromSExpr(const til::SExpr *E)
static void maybeUpdateVD(til::SExpr *E, const ValueDecl *VD)
static bool hasAnyPointerType(const til::SExpr *E)
static const CXXMethodDecl * getFirstVirtualDecl(const CXXMethodDecl *D)
static StringRef ClassifyDiagnostic(const CapabilityAttr *A)
static bool isCalleeArrow(const Expr *E)
C Language Family Type Representation.
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Expr * getCond() const
getCond - Return the expression representing the condition for the ?: operator.
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression representing the value of the expression if the condition eval...
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression representing the value of the expression if the condition eva...
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
A builtin binary operation expression such as "x + y" or "x <= y".
Represents a single basic block in a source-level CFG.
succ_iterator succ_begin()
unsigned pred_size() const
unsigned getBlockID() const
Stmt * getTerminatorCondition(bool StripParens=true)
unsigned succ_size() const
Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt.
unsigned getNumBlockIDs() const
Returns the total number of BlockIDs allocated (which start at 0).
Represents a C++ destructor within a class.
Represents a call to a member function that may be written either with member call syntax (e....
CXXMethodDecl * getMethodDecl() const
Retrieve the declaration of the called method.
Expr * getImplicitObjectArgument() const
Retrieve the implicit object argument for the member call.
Represents a static or instance method of a struct/union/class.
overridden_method_range overridden_methods() const
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
A call to an overloaded operator written using operator syntax.
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Represents the this expression in C++.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Expr ** getArgs()
Retrieve the call arguments.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
CastKind getCastKind() const
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
A reference to a declared variable, function, enum, etc.
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Decl - This represents one declaration (or definition), e.g.
ASTContext & getASTContext() const LLVM_READONLY
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
This represents one expression.
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
Represents a function declaration or definition.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
This represents a decl that may have a name.
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
ObjCIvarDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
ObjCIvarRefExpr - A reference to an ObjC instance variable.
const Expr * getBase() const
A (possibly-)qualified type.
bool isTrivialType(const ASTContext &Context) const
Return true if this is a trivial type per (C++0x [basic.types]p9)
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Stmt - This represents one statement.
StmtClass getStmtClass() const
bool isPointerType() const
bool isReferenceType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
const T * getAs() const
Member-template getAs<specific type>'.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Expr * getSubExpr() const
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
const til::SExpr * sexpr() const
void push_back(const T &Elem)
bool sameAs(const CopyOnWriteVector &V) const
void downsize(unsigned i)
CapabilityExpr translateAttrExpr(const Expr *AttrExp, const NamedDecl *D, const Expr *DeclExp, til::SExpr *Self=nullptr)
Translate a clang expression in an attribute to a til::SExpr.
til::SExpr * translate(const Stmt *S, CallingContext *Ctx)
std::pair< til::LiteralPtr *, StringRef > createThisPlaceholder(const Expr *Exp)
til::SExpr * lookupStmt(const Stmt *S)
til::SCFG * buildCFG(CFGWalker &Walker)
til::LiteralPtr * createVariable(const VarDecl *VD)
til::BasicBlock * lookupBlock(const CFGBlock *B)
Apply an argument to a function.
If p is a reference to an array, then p[i] is a reference to the i'th element of the array.
A basic block is part of an SCFG.
unsigned addPredecessor(BasicBlock *Pred)
const InstrArray & arguments() const
void reserveInstructions(unsigned Nins)
void addArgument(Phi *V)
Add a new argument.
size_t numPredecessors() const
Returns the number of predecessors.
InstrArray & instructions()
void reservePredecessors(unsigned NumPreds)
unsigned findPredecessorIndex(const BasicBlock *BB) const
Return the index of BB, or Predecessors.size if BB is not a predecessor.
void setTerminator(Terminator *E)
void addInstruction(SExpr *V)
Add a new instruction.
Simple arithmetic binary operations, e.g.
A conditional branch to two other blocks.
Call a function (after all arguments have been applied).
Jump to another basic block.
An if-then-else expression.
A Literal pointer to an object allocated in memory.
Load a value from memory.
Phi Node, for code in SSA form.
const ValueDecl * clangDecl() const
Return the clang declaration of the variable for this Phi node, if any.
void setClangDecl(const ValueDecl *Cvd)
Set the clang variable associated with this Phi node.
const ValArray & values() const
Project a named slot from a C++ struct or class.
Apply a self-argument to a self-applicable function.
An SCFG is a control-flow graph.
Base class for AST nodes in the typed intermediate language.
BasicBlock * block() const
Returns the block, if this is an instruction in a basic block, otherwise returns null.
void setValues(unsigned Sz, const T &C)
void reserve(size_t Ncp, MemRegionRef A)
Simple arithmetic unary operations, e.g.
Placeholder for expressions that cannot be represented in the TIL.
Placeholder for a wildcard that matches any other expression.
bool isTrivial(const SExpr *E)
void simplifyIncompleteArg(til::Phi *Ph)
TIL_BinaryOpcode
Opcode for binary arithmetic operations.
std::string getSourceLiteralString(const Expr *CE)
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ C
Languages that the frontend can parse and compile.
CastKind
CastKind - The kind of operation required for a conversion.
Encapsulates the lexical context of a function call.
const NamedDecl * AttrDecl
llvm::PointerUnion< const Expr *, til::SExpr * > SelfArg
const Expr *const * FunArgs