Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/ThreadSafetyCommon_8cpp_source.html below:

clang: lib/Analysis/ThreadSafetyCommon.cpp Source File

;

threadSafety;

Stmt::IntegerLiteralClass:

(cast<IntegerLiteral>(CE)->getValue(), 10,

);

Stmt::StringLiteralClass: {

std::string ret(

);

ret += cast<StringLiteral>(CE)->getString();

Stmt::CharacterLiteralClass:

Stmt::CXXNullPtrLiteralExprClass:

Stmt::GNUNullExprClass:

Stmt::CXXBoolLiteralExprClass:

Stmt::FloatingLiteralClass:

Stmt::ImaginaryLiteralClass:

Stmt::ObjCStringLiteralClass:

(

*Ph = dyn_cast<til::Phi>(

))

Walker.

(*

);

ME ? ME->isArrow() :

;

(

*RD = RT->getDecl())

(

*CA = RD->getAttr<CapabilityAttr>())

(

*TD = TT->getDecl())

(

*CA = TD->getAttr<CapabilityAttr>())

(!DeclExp && !

)

(

*ME = dyn_cast<MemberExpr>(DeclExp)) {

Ctx.SelfArg = ME->getBase();

Ctx.SelfArrow = ME->isArrow();

}

(

*CE = dyn_cast<CXXMemberCallExpr>(DeclExp)) {

Ctx.SelfArg = CE->getImplicitObjectArgument();

Ctx.NumArgs = CE->getNumArgs();

Ctx.FunArgs = CE->getArgs();

}

(

*CE = dyn_cast<CallExpr>(DeclExp)) {

(isa<CXXOperatorCallExpr>(CE) && isa<CXXMethodDecl>(

)) {

Ctx.SelfArg = CE->getArg(0);

Ctx.SelfArrow =

;

Ctx.NumArgs = CE->getNumArgs() - 1;

Ctx.FunArgs = CE->getArgs() + 1;

Ctx.NumArgs = CE->getNumArgs();

Ctx.FunArgs = CE->getArgs();

}

(

*CE = dyn_cast<CXXConstructExpr>(DeclExp)) {

Ctx.SelfArg =

;

Ctx.NumArgs = CE->getNumArgs();

Ctx.FunArgs = CE->getArgs();

(

*CMD = dyn_cast<CXXMethodDecl>(

))

(CMD->getParent()->isLambda())

Ctx.SelfArg =

;

assert(!Ctx.SelfArg &&

);

assert(isa<FunctionDecl>(

) &&

);

(isa<CXXMethodDecl>(

))

cast<CXXMethodDecl>(

)->getFunctionObjectParameterType()),

(

* SLit = dyn_cast<StringLiteral>(AttrExp)) {

(SLit->getString() ==

)

(

*OE = dyn_cast<CXXOperatorCallExpr>(AttrExp)) {

(OE->getOperator() == OO_Exclaim) {

AttrExp = OE->getArg(0);

(

*UO = dyn_cast<UnaryOperator>(AttrExp)) {

(UO->getOpcode() == UO_LNot) {

(!

|| isa<til::Literal>(

))

(

*CE = dyn_cast<til::Cast>(

)) {

std::pair<til::LiteralPtr *, StringRef>

(S->getStmtClass()) {

Stmt::DeclRefExprClass:

translateDeclRefExpr(cast<DeclRefExpr>(S), Ctx);

Stmt::CXXThisExprClass:

translateCXXThisExpr(cast<CXXThisExpr>(S), Ctx);

Stmt::MemberExprClass:

translateMemberExpr(cast<MemberExpr>(S), Ctx);

Stmt::ObjCIvarRefExprClass:

translateObjCIVarRefExpr(cast<ObjCIvarRefExpr>(S), Ctx);

Stmt::CallExprClass:

translateCallExpr(cast<CallExpr>(S), Ctx);

Stmt::CXXMemberCallExprClass:

translateCXXMemberCallExpr(cast<CXXMemberCallExpr>(S), Ctx);

Stmt::CXXOperatorCallExprClass:

translateCXXOperatorCallExpr(cast<CXXOperatorCallExpr>(S), Ctx);

Stmt::UnaryOperatorClass:

translateUnaryOperator(cast<UnaryOperator>(S), Ctx);

Stmt::BinaryOperatorClass:

Stmt::CompoundAssignOperatorClass:

translateBinaryOperator(cast<BinaryOperator>(S), Ctx);

Stmt::ArraySubscriptExprClass:

translateArraySubscriptExpr(cast<ArraySubscriptExpr>(S), Ctx);

Stmt::ConditionalOperatorClass:

translateAbstractConditionalOperator(

cast<ConditionalOperator>(S), Ctx);

Stmt::BinaryConditionalOperatorClass:

translateAbstractConditionalOperator(

cast<BinaryConditionalOperator>(S), Ctx);

Stmt::ConstantExprClass:

(cast<ConstantExpr>(S)->getSubExpr(), Ctx);

Stmt::ParenExprClass:

(cast<ParenExpr>(S)->getSubExpr(), Ctx);

Stmt::ExprWithCleanupsClass:

(cast<ExprWithCleanups>(S)->getSubExpr(), Ctx);

Stmt::CXXBindTemporaryExprClass:

(cast<CXXBindTemporaryExpr>(S)->getSubExpr(), Ctx);

Stmt::MaterializeTemporaryExprClass:

(cast<MaterializeTemporaryExpr>(S)->getSubExpr(), Ctx);

Stmt::CharacterLiteralClass:

Stmt::CXXNullPtrLiteralExprClass:

Stmt::GNUNullExprClass:

Stmt::CXXBoolLiteralExprClass:

Stmt::FloatingLiteralClass:

Stmt::ImaginaryLiteralClass:

Stmt::IntegerLiteralClass:

Stmt::StringLiteralClass:

Stmt::ObjCStringLiteralClass:

Stmt::DeclStmtClass:

translateDeclStmt(cast<DeclStmt>(S), Ctx);

(

*CE = dyn_cast<CastExpr>(S))

translateCastExpr(CE, Ctx);

(

*PV = dyn_cast<ParmVarDecl>(VD)) {

I = PV->getFunctionScopeIndex();

(Ctx && Ctx->FunArgs) {

*Canonical = Ctx->AttrDecl->getCanonicalDecl();

(isa<FunctionDecl>(

)

(

*

*FunArgs =

dyn_cast<const Expr *const *>(Ctx->FunArgs)) {

assert(I < Ctx->NumArgs);

(FunArgs[I], Ctx->Prev);

cast<til::SExpr *>(Ctx->FunArgs);

VD = isa<FunctionDecl>(

)

? cast<FunctionDecl>(

)->getCanonicalDecl()->getParamDecl(I)

: cast<ObjCMethodDecl>(

)->getCanonicalDecl()->getParamDecl(I);

(Ctx && Ctx->SelfArg) {

(

*SelfArg = dyn_cast<const Expr *>(Ctx->SelfArg))

cast<til::SExpr *>(Ctx->SelfArg);

assert(SelfVar &&

);

(

*

= dyn_cast<til::Variable>(

))

->clangDecl();

(

*Ph = dyn_cast<til::Phi>(

))

Ph->clangDecl();

(

*

= dyn_cast<til::Project>(

))

->clangDecl();

(

*L = dyn_cast<til::LiteralPtr>(

))

L->clangDecl();

(VD && VD->getType()->isAnyPointerType())

(

*

= dyn_cast<til::Cast>(

))

OverriddenMethods =

->overridden_methods();

(OverriddenMethods.begin() == OverriddenMethods.end())

= *OverriddenMethods.begin();

(

*VD = dyn_cast<CXXMethodDecl>(

))

->setArrow(

);

->setArrow(

);

(CapabilityExprMode) {

FD = FD->getMostRecentDecl();

(LockReturnedAttr *At = FD->getAttr<LockReturnedAttr>()) {

LRCallCtx.SelfArg = SelfE;

LRCallCtx.FunArgs = CE->

();

(

*Arg : CE->

()) {

*SExprBuilder::translateCXXMemberCallExpr(

(CapabilityExprMode) {

translateCallExpr(cast<CallExpr>(ME), Ctx,

*SExprBuilder::translateCXXOperatorCallExpr(

(CapabilityExprMode) {

(k == OO_Star || k == OO_Arrow) {

translateCallExpr(cast<CallExpr>(OCE), Ctx);

(CapabilityExprMode) {

(

*DRE = dyn_cast<DeclRefExpr>(UO->

())) {

(

*DRE = dyn_cast<DeclRefExpr>(LHS)) {

CV = lookupVarDecl(VD);

E1 = addStatement(E1,

, VD);

updateVarDecl(VD, E1);

BO_Mul:

translateBinOp(

, BO, Ctx);

BO_Div:

translateBinOp(

, BO, Ctx);

BO_Rem:

translateBinOp(

, BO, Ctx);

BO_Add:

translateBinOp(

, BO, Ctx);

BO_Sub:

translateBinOp(

, BO, Ctx);

BO_Shl:

translateBinOp(

, BO, Ctx);

BO_Shr:

translateBinOp(

, BO, Ctx);

BO_LT:

translateBinOp(

, BO, Ctx);

BO_GT:

translateBinOp(

, BO, Ctx,

);

BO_LE:

translateBinOp(

, BO, Ctx);

BO_GE:

translateBinOp(

, BO, Ctx,

);

BO_EQ:

translateBinOp(

, BO, Ctx);

BO_NE:

translateBinOp(

, BO, Ctx);

BO_Cmp:

translateBinOp(

, BO, Ctx);

BO_Assign:

translateBinAssign(

, BO, Ctx,

);

BO_MulAssign:

translateBinAssign(

, BO, Ctx);

BO_DivAssign:

translateBinAssign(

, BO, Ctx);

BO_RemAssign:

translateBinAssign(

, BO, Ctx);

BO_AddAssign:

translateBinAssign(

, BO, Ctx);

BO_SubAssign:

translateBinAssign(

, BO, Ctx);

BO_ShlAssign:

translateBinAssign(

, BO, Ctx);

BO_ShrAssign:

translateBinAssign(

, BO, Ctx);

BO_AndAssign:

translateBinAssign(

, BO, Ctx);

BO_XorAssign:

translateBinAssign(

, BO, Ctx);

BO_OrAssign:

translateBinAssign(

, BO, Ctx);

CK_LValueToRValue: {

(

*DRE = dyn_cast<DeclRefExpr>(CE->

())) {

CK_DerivedToBase:

CK_UncheckedDerivedToBase:

CK_ArrayToPointerDecay:

CK_FunctionToPointerDecay: {

(CapabilityExprMode)

SExprBuilder::translateAbstractConditionalOperator(

(

*I : DGrp) {

(

*VD = dyn_cast_or_null<VarDecl>(I)) {

*

= VD->getInit();

addVarDecl(VD, SE);

CurrentInstructions.push_back(

);

It = LVarIdxMap.find(VD);

(It != LVarIdxMap.end()) {

assert(CurrentLVarMap[It->second].first == VD);

CurrentLVarMap[It->second].second;

(

*

= dyn_cast<til::Variable>(

)) {

(!

->clangDecl())

->setClangDecl(VD);

LVarIdxMap.insert(std::make_pair(VD, CurrentLVarMap.

()));

CurrentLVarMap.

(std::make_pair(VD,

));

It = LVarIdxMap.find(VD);

(It == LVarIdxMap.end()) {

CurrentLVarMap.

(It->second).second =

;

SExprBuilder::makePhiNodeVar(

i,

NPreds,

*

) {

ArgIndex = CurrentBlockInfo->ProcessedPredecessors;

assert(ArgIndex > 0 && ArgIndex < NPreds);

(CurrE->

() == CurrentBB) {

*Ph = dyn_cast<til::Phi>(CurrE);

assert(Ph &&

);

Ph->values()[ArgIndex] =

;

(

PIdx = 0; PIdx < ArgIndex; ++PIdx)

Ph->

()[PIdx] = CurrE;

CurrentArguments.push_back(Ph);

IncompleteArgs.push_back(Ph);

CurrentLVarMap.

(i).second = Ph;

SExprBuilder::mergeEntryMap(LVarDefinitionMap Map) {

assert(CurrentBlockInfo &&

);

(!CurrentLVarMap.

()) {

CurrentLVarMap = std::move(Map);

(CurrentLVarMap.

(Map))

ESz = CurrentLVarMap.

();

MSz = Map.size();

Sz = std::min(ESz, MSz);

(

i = 0; i < Sz; ++i) {

(CurrentLVarMap[i].first != Map[i].first) {

(CurrentLVarMap[i].second != Map[i].second)

makePhiNodeVar(i, NPreds, Map[i].second);

CurrentLVarMap.

(Map.size());

SExprBuilder::mergeEntryMapBackEdge() {

assert(CurrentBlockInfo &&

);

(CurrentBlockInfo->HasBackEdges)

CurrentBlockInfo->HasBackEdges =

;

Sz = CurrentLVarMap.

();

(

i = 0; i < Sz; ++i)

makePhiNodeVar(i, NPreds,

);

SExprBuilder::mergePhiNodesBackEdge(

*Blk) {

ArgIndex = BBInfo[Blk->

()].ProcessedPredecessors;

assert(ArgIndex > 0 && ArgIndex < BB->numPredecessors());

*Ph = dyn_cast_or_null<til::Phi>(PE);

assert(Ph &&

);

assert(Ph->

()[ArgIndex] ==

&&

);

assert(

&&

);

Scfg =

(Arena)

(Arena, NBlocks);

BBInfo.resize(NBlocks);

BlockMap.resize(NBlocks,

);

(

*B : *Cfg) {

BlockMap[B->getBlockID()] = BB;

Parms = isa<ObjCMethodDecl>(

) ? cast<ObjCMethodDecl>(

)->parameters()

: cast<FunctionDecl>(

)->parameters();

(

*Pm : Parms) {

(!

.isTrivialType(Pm->getASTContext()))

SExprBuilder::enterCFGBlock(

*B) {

Scfg->

(CurrentBB);

CurrentBlockInfo = &BBInfo[B->

()];

SExprBuilder::handlePredecessor(

*Pred) {

BlockInfo *PredInfo = &BBInfo[Pred->

()];

assert(PredInfo->UnprocessedSuccessors > 0);

(--PredInfo->UnprocessedSuccessors == 0)

mergeEntryMap(std::move(PredInfo->ExitMap));

mergeEntryMap(PredInfo->ExitMap.clone());

++CurrentBlockInfo->ProcessedPredecessors;

SExprBuilder::handlePredecessorBackEdge(

*Pred) {

mergeEntryMapBackEdge();

SExprBuilder::enterCFGBlockBody(

*B) {

(CurrentArguments.size()), Arena);

(

*A : CurrentArguments)

SExprBuilder::handleStatement(

*S) {

addStatement(

, S);

SExprBuilder::handleDestructorCall(

*VD,

addStatement(

,

);

SExprBuilder::exitCFGBlockBody(

*B) {

(CurrentInstructions.size()), Arena);

(

*

: CurrentInstructions)

*Tm =

(Arena)

(BB, Idx);

SExprBuilder::handleSuccessor(

*Succ) {

++CurrentBlockInfo->UnprocessedSuccessors;

SExprBuilder::handleSuccessorBackEdge(

*Succ) {

mergePhiNodesBackEdge(Succ);

++BBInfo[Succ->

()].ProcessedPredecessors;

SExprBuilder::exitCFGBlock(

*B) {

CurrentArguments.clear();

CurrentInstructions.clear();

CurrentBlockInfo->ExitMap = std::move(CurrentLVarMap);

CurrentBB =

;

CurrentBlockInfo =

;

(

*Ph : IncompleteArgs) {

CurrentArguments.clear();

CurrentInstructions.clear();

IncompleteArgs.clear();

threadSafety {

llvm::BumpPtrAllocator Bpa;

TILPrinter::print(Scfg, llvm::errs());

llvm::DenseMap< const Stmt *, CFGBlock * > SMap

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.

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

DeclContext * getDeclContext()

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...

Expr * IgnoreImplicit() LLVM_READONLY

Skip past any implicit AST nodes 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.

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

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isPointerOrReferenceType() const

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.

void printSCFG(CFGWalker &Walker)

std::string getSourceLiteralString(const Expr *CE)

The JSON file list parser is used to communicate input to InstallAPI.

OverloadedOperatorKind

Enumeration specifying the different kinds of C++ overloaded operators.

@ Self

'self' clause, allowed on Compute and Combined Constructs, plus 'update'.

CastKind

CastKind - The kind of operation required for a conversion.

const FunctionProtoType * T

Encapsulates the lexical context of a function call.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4