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

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

clang: lib/AST/Stmt.cpp Source File

;

\

"by a bitfield of width NumStmtBits");

return ::operator

(

,

, alignment);

);

);

llvm::errs() <<

;

(

i = 0; i != Stmt::lastStmtConstant+1; i++) {

llvm::errs() <<

<< sum <<

;

(

i = 0; i != Stmt::lastStmtConstant+1; i++) {

llvm::errs() <<

<< sum <<

;

Stmt::StatisticsEnabled =

;

StatisticsEnabled =

;

std::pair<Stmt::Likelihood, const Attr *>

(

*A : Attrs) {

(isa<LikelyAttr>(A))

(isa<UnlikelyAttr>(A))

(

*AS = dyn_cast_or_null<AttributedStmt>(S))

return ::getLikelihood(Attrs).first;

return ::getLikelihood(S).first;

return ::getLikelihood(S).second;

std::tuple<bool, const Attr *, const Attr *>

(LHT.first !=

&& LHT.first == LHE.first)

std::make_tuple(

, LHT.second, LHE.second);

std::make_tuple(

,

,

);

(

CapS = dyn_cast_or_null<CapturedStmt>(S))

S = CapS->getCapturedStmt();

(

AS = dyn_cast_or_null<AttributedStmt>(S))

S = AS->getSubStmt();

(

CS = dyn_cast_or_null<CompoundStmt>(S)) {

*S =

;

(

*LS = dyn_cast<LabelStmt>(S))

S = LS->getSubStmt();

(

*SC = dyn_cast<SwitchCase>(S))

S = SC->getSubStmt();

(

*AS = dyn_cast<AttributedStmt>(S))

S = AS->getSubStmt();

good is_good(good) {

good(); }

<

T> good implements_children(children_t

::*) {

LLVM_ATTRIBUTE_UNUSED

bad implements_children(children_t

::*) {

<

T> good implements_getBeginLoc(getBeginLoc_t

::*) {

LLVM_ATTRIBUTE_UNUSED

bad implements_getBeginLoc(getBeginLoc_t

::*) {

bad(); }

<

T> good implements_getEndLoc(getLocEnd_t

::*) {

LLVM_ATTRIBUTE_UNUSED

bad implements_getEndLoc(getLocEnd_t

::*) {

bad(); }

LLVM_ATTRIBUTE_UNUSED

llvm_unreachable(

);

<

S,

T>

S*

(

)->getSourceRange();

S *

(

)->getEndLoc());

llvm_unreachable(

);

llvm_unreachable(

);

llvm_unreachable(

);

:

(CompoundStmtClass), LBraceLoc(LB), RBraceLoc(RB) {

(hasStoredFPFeatures())

setStoredFPFeatures(FPFeatures);

);

std::copy(Stmts.begin(), Stmts.end(),

());

.Allocate(totalSizeToAlloc<Stmt *, FPOptionsOverride>(

(Mem)

(Stmts, FPFeatures, LB, RB);

HasFPFeatures) {

*Mem =

.Allocate(

totalSizeToAlloc<Stmt *, FPOptionsOverride>(NumStmts, HasFPFeatures),

*S =

;

(

*

= dyn_cast<Expr>(S))

(

*LS = dyn_cast<LabelStmt>(S))

S = LS->getSubStmt();

(

*AS = dyn_cast<AttributedStmt>(S))

S = AS->getSubStmt();

llvm_unreachable(

);

}

(isa<ValueStmt>(S));

assert(!Attrs.empty() &&

);

*Mem =

.Allocate(totalSizeToAlloc<const Attr *>(Attrs.size()),

assert(NumAttrs > 0 &&

);

*Mem =

.Allocate(totalSizeToAlloc<const Attr *>(NumAttrs),

(

*gccAsmStmt = dyn_cast<GCCAsmStmt>(

))

gccAsmStmt->generateAsmString(

);

(

*msAsmStmt = dyn_cast<MSAsmStmt>(

))

msAsmStmt->generateAsmString(

);

llvm_unreachable(

);

(

*gccAsmStmt = dyn_cast<GCCAsmStmt>(

))

gccAsmStmt->getOutputConstraint(i);

(

*msAsmStmt = dyn_cast<MSAsmStmt>(

))

msAsmStmt->getOutputConstraint(i);

llvm_unreachable(

);

(

*gccAsmStmt = dyn_cast<GCCAsmStmt>(

))

gccAsmStmt->getOutputExpr(i);

(

*msAsmStmt = dyn_cast<MSAsmStmt>(

))

msAsmStmt->getOutputExpr(i);

llvm_unreachable(

);

(

*gccAsmStmt = dyn_cast<GCCAsmStmt>(

))

gccAsmStmt->getInputConstraint(i);

(

*msAsmStmt = dyn_cast<MSAsmStmt>(

))

msAsmStmt->getInputConstraint(i);

llvm_unreachable(

);

(

*gccAsmStmt = dyn_cast<GCCAsmStmt>(

))

gccAsmStmt->getInputExpr(i);

(

*msAsmStmt = dyn_cast<MSAsmStmt>(

))

msAsmStmt->getInputExpr(i);

llvm_unreachable(

);

(

*gccAsmStmt = dyn_cast<GCCAsmStmt>(

))

gccAsmStmt->getClobber(i);

(

*msAsmStmt = dyn_cast<MSAsmStmt>(

))

msAsmStmt->getClobber(i);

llvm_unreachable(

);

assert(

() &&

);

(Str[0]) ? Str[0] :

;

cast<Expr>(

[i]);

GCCAsmStmt::setOutputsAndInputsAndClobbers(

&

,

this->NumLabels = NumLabels;

.Deallocate(this->Names);

std::copy(Names, Names + NumExprs, this->Names);

.Deallocate(this->Exprs);

this->Exprs =

(

)

*[NumExprs];

std::copy(

,

+ NumExprs, this->Exprs);

.Deallocate(this->Constraints);

std::copy(Constraints, Constraints +

, this->Constraints);

.Deallocate(this->Clobbers);

std::copy(Clobbers, Clobbers +

, this->Clobbers);

(

i = 0; i !=

; ++i)

*StrStart = Str.begin();

*StrEnd = Str.end();

*CurPtr = StrStart;

(; CurPtr != StrEnd; ++CurPtr) {

std::string CurStringPiece;

HasVariants = !

.getTargetInfo().hasNoAsmVariants();

LastAsmStringToken = 0;

LastAsmStringOffset = 0;

(CurPtr == StrEnd) {

(!CurStringPiece.empty())

CurChar = *CurPtr++;

: CurStringPiece +=

;

;

: CurStringPiece += (HasVariants ?

:

);

;

: CurStringPiece += (HasVariants ?

:

);

;

: CurStringPiece += (HasVariants ?

:

);

;

CurStringPiece += CurChar;

(CurPtr == StrEnd) {

DiagOffs = CurPtr-StrStart-1;

diag::err_asm_invalid_escape;

EscapedChar = *CurPtr++;

(EscapedChar) {

CurStringPiece += *MaybeReplaceStr;

CurStringPiece += EscapedChar;

CurStringPiece +=

;

(!CurStringPiece.empty()) {

CurStringPiece.clear();

*

= CurPtr - 1;

*Percent =

- 1;

(CurPtr == StrEnd) {

DiagOffs = CurPtr-StrStart-1;

diag::err_asm_invalid_escape;

EscapedChar = *CurPtr++;

(CurPtr != StrEnd &&

(*CurPtr))

N = N*10 + ((*CurPtr++)-

);

(N >= NumOperands) {

DiagOffs = CurPtr-StrStart-1;

diag::err_asm_invalid_operand_number;

Percent - StrStart,

, LO, TI, &LastAsmStringToken,

&LastAsmStringOffset);

CurPtr - StrStart,

, LO, TI, &LastAsmStringToken,

&LastAsmStringOffset);

Pieces.emplace_back(N, std::move(Str), BeginLoc, EndLoc);

(EscapedChar ==

) {

DiagOffs = CurPtr-StrStart-1;

*NameEnd = (

*)memchr(CurPtr,

, StrEnd-CurPtr);

(NameEnd ==

)

diag::err_asm_unterminated_symbolic_operand_name;

(NameEnd == CurPtr)

diag::err_asm_empty_symbolic_operand_name;

StringRef SymbolicName(CurPtr, NameEnd - CurPtr);

DiagOffs = CurPtr-StrStart;

diag::err_asm_unknown_symbolic_operand_name;

std::string Str(

, NameEnd + 1 -

);

Percent - StrStart,

, LO, TI, &LastAsmStringToken,

&LastAsmStringOffset);

NameEnd + 1 - StrStart,

, LO, TI, &LastAsmStringToken,

&LastAsmStringOffset);

Pieces.emplace_back(N, std::move(Str), BeginLoc, EndLoc);

DiagOffs = CurPtr-StrStart-1;

diag::err_asm_invalid_escape;

std::string AsmString;

(

&Piece : Pieces) {

(Piece.isString())

AsmString += Piece.getString();

(Piece.getModifier() ==

)

AsmString +=

+ llvm::utostr(Piece.getOperandNo());

AsmString +=

+ llvm::utostr(Piece.getOperandNo()) +

+

Piece.getModifier() +

;

AsmStr.split(Pieces,

);

std::string MSAsmString;

(

I = 0,

= Pieces.size(); I <

; ++I) {

StringRef Instruction = Pieces[I];

(Instruction.starts_with(

))

MSAsmString +=

+ Instruction.substr(0, 3).str() +

+

Instruction.substr(3).str();

(Instruction.starts_with(

) ||

Instruction.starts_with(

) ||

Instruction.starts_with(

))

MSAsmString +=

+ Instruction.substr(0, 4).str() +

+

Instruction.substr(4).str();

MSAsmString += Instruction.str();

MSAsmString +=

;

cast<Expr>(

[i]);

issimple,

isvolatile,

numoutputs,

:

(GCCAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,

numinputs, numclobbers),

RParenLoc(rparenloc), AsmStr(asmstr), NumLabels(numlabels) {

std::copy(names, names + NumExprs, Names);

std::copy(exprs, exprs + NumExprs,

);

std::copy(constraints, constraints +

, Constraints);

std::copy(clobbers, clobbers +

, Clobbers);

:

(MSAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,

numinputs, clobbers.size()), LBraceLoc(lbraceloc),

EndLoc(endloc), NumAsmToks(asmtoks.size()) {

initialize(

, asmstr, asmtoks, constraints, exprs, clobbers);

str.copy(

);

MSAsmStmt::initialize(

&

, StringRef asmstr,

assert(NumAsmToks == asmtoks.size());

assert(exprs.size() == constraints.size());

std::copy(exprs.begin(), exprs.end(),

);

AsmToks =

(

)

[asmtoks.size()];

std::copy(asmtoks.begin(), asmtoks.end(), AsmToks);

Constraints =

(

) StringRef[exprs.size()];

std::transform(constraints.begin(), constraints.end(), Constraints,

[&](StringRef Constraint) {

return copyIntoContext(C, Constraint);

std::transform(clobbers.begin(), clobbers.end(), Clobbers,

[&](StringRef Clobber) {

return copyIntoContext(C, Clobber);

:

(IfStmtClass), LParenLoc(LPL), RParenLoc(RPL) {

HasElse = Else !=

;

HasVar = Var !=

;

HasInit =

!=

;

IfStmtBits.HasElse = HasElse;

IfStmtBits.HasVar = HasVar;

IfStmtBits.HasInit = HasInit;

setStatementKind(Kind);

setConditionVariable(Ctx, Var);

IfStmt::IfStmt(EmptyShell

,

HasElse,

HasVar,

HasInit)

IfStmtBits.HasElse = HasElse;

IfStmtBits.HasVar = HasVar;

IfStmtBits.HasInit = HasInit;

HasElse = Else !=

;

HasVar = Var !=

;

HasInit =

!=

;

totalSizeToAlloc<Stmt *, SourceLocation>(

NumMandatoryStmtPtr + HasElse + HasVar + HasInit, HasElse),

(Ctx, IL, Kind,

, Var, Cond, LPL, RPL, Then, EL, Else);

totalSizeToAlloc<Stmt *, SourceLocation>(

NumMandatoryStmtPtr + HasElse + HasVar + HasInit, HasElse),

cast<VarDecl>(DS->getSingleDecl());

);

getTrailingObjects<Stmt *>()[varOffset()] =

;

getTrailingObjects<Stmt *>()[varOffset()] =

(Ctx)

isa<ObjCAvailabilityCheckExpr>(

());

std::nullopt;

std::optional<const Stmt *>

(std::optional<Stmt *>

=

std::nullopt;

:

(ForStmtClass), LParenLoc(LP), RParenLoc(RP)

SubExprs[INIT] =

;

SubExprs[COND] = Cond;

SubExprs[INC] = Inc;

SubExprs[BODY] = Body;

(!SubExprs[CONDVAR])

*DS = cast<DeclStmt>(SubExprs[CONDVAR]);

cast<VarDecl>(DS->getSingleDecl());

SubExprs[CONDVAR] =

;

:

(SwitchStmtClass), FirstCase(nullptr), LParenLoc(LParenLoc),

RParenLoc(RParenLoc) {

HasInit =

!=

;

HasVar = Var !=

;

SwitchStmt::SwitchStmt(EmptyShell

,

HasInit,

HasVar)

HasInit =

!=

;

HasVar = Var !=

;

totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasInit + HasVar),

(Mem)

(Ctx,

, Var, Cond, LParenLoc, RParenLoc);

totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasInit + HasVar),

cast<VarDecl>(DS->getSingleDecl());

);

getTrailingObjects<Stmt *>()[varOffset()] =

;

getTrailingObjects<Stmt *>()[varOffset()] =

(Ctx)

:

(WhileStmtClass) {

HasVar = Var !=

;

WhileStmt::WhileStmt(EmptyShell

,

HasVar)

HasVar = Var !=

;

Ctx.

(totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasVar),

(Mem)

(Ctx, Var, Cond, Body, WL, LParenLoc, RParenLoc);

Ctx.

(totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasVar),

cast<VarDecl>(DS->getSingleDecl());

);

getTrailingObjects<Stmt *>()[varOffset()] =

;

getTrailingObjects<Stmt *>()[varOffset()] =

(Ctx)

(

*

= dyn_cast<AddrLabelExpr>(

()->IgnoreParenImpCasts()))

->getLabel();

:

(ReturnStmtClass), RetExpr(

) {

HasNRVOCandidate = NRVOCandidate !=

;

(HasNRVOCandidate)

setNRVOCandidate(NRVOCandidate);

ReturnStmt::ReturnStmt(EmptyShell

,

HasNRVOCandidate)

HasNRVOCandidate = NRVOCandidate !=

;

*Mem = Ctx.

(totalSizeToAlloc<const VarDecl *>(HasNRVOCandidate),

(Mem)

(RL,

, NRVOCandidate);

HasNRVOCandidate) {

*Mem = Ctx.

(totalSizeToAlloc<const VarDecl *>(HasNRVOCandidate),

CaseStmtIsGNURange = rhs !=

;

totalSizeToAlloc<Stmt *, SourceLocation>(

NumMandatoryStmtPtr + CaseStmtIsGNURange, CaseStmtIsGNURange),

(Mem)

(lhs, rhs, caseLoc, ellipsisLoc, colonLoc);

CaseStmtIsGNURange) {

totalSizeToAlloc<Stmt *, SourceLocation>(

NumMandatoryStmtPtr + CaseStmtIsGNURange, CaseStmtIsGNURange),

:

(SEHTryStmtClass), IsCXXTry(IsCXXTry), TryLoc(TryLoc) {

Children[TRY] = TryBlock;

Children[HANDLER] = Handler;

(

)

(IsCXXTry,TryLoc,TryBlock,Handler);

dyn_cast<SEHExceptStmt>(

());

dyn_cast<SEHFinallyStmt>(

());

Children[FILTER_EXPR] = FilterExpr;

: VarAndKind(Var, Kind),

(

) {

assert(!Var &&

);

assert(Var &&

);

assert(Var &&

);

);

VarAndKind.getInt();

);

VarAndKind.getPointer();

Size =

(

) +

(

*) * (NumCaptures + 1);

FirstCaptureOffset = llvm::alignTo(Size,

(

));

*

(

*

(

*

(

))

+ FirstCaptureOffset);

:

(CapturedStmtClass), NumCaptures(Captures.size()),

CapDeclAndKind(CD, Kind), TheRecordDecl(RD) {

assert( S &&

);

assert(CD &&

);

assert(RD &&

);

**Stored = getStoredStmts();

(

I = 0, N = NumCaptures; I != N; ++I)

*Stored++ = CaptureInits[I];

*Buffer = getStoredCaptures();

std::copy(Captures.begin(), Captures.end(), Buffer);

CapturedStmt::CapturedStmt(EmptyShell

,

NumCaptures)

:

(CapturedStmtClass,

), NumCaptures(NumCaptures),

getStoredStmts()[NumCaptures] =

;

*Buffer = getStoredCaptures();

(

I = 0, N = NumCaptures; I != N; ++I)

assert(CaptureInits.size() == Captures.size() &&

);

Size =

(

) +

(

*) * (Captures.size() + 1);

(!Captures.empty()) {

Size = llvm::alignTo(Size,

(

));

Size +=

(

) * Captures.size();

*Mem = Context.

(Size);

(Mem)

(S, Kind, Captures, CaptureInits, CD, RD);

NumCaptures) {

Size =

(

) +

(

*) * (NumCaptures + 1);

(NumCaptures > 0) {

Size = llvm::alignTo(Size,

(

));

Size +=

(

) * NumCaptures;

*Mem = Context.

(Size);

(getStoredStmts(), getStoredStmts() + NumCaptures);

CapDeclAndKind.getPointer();

CapDeclAndKind.getPointer();

assert(

&&

);

CapDeclAndKind.setPointer(

);

CapDeclAndKind.getInt();

CapDeclAndKind.setInt(Kind);

(

&I :

()) {

(!I.capturesVariable() && !I.capturesVariableByCopy())

Defines the clang::ASTContext interface.

static StringRef bytes(const std::vector< T, Allocator > &v)

Defines the clang::Expr interface and subclasses for C++ expressions.

Defines Expressions and AST nodes for C++2a concepts.

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines the clang::SourceLocation class and associated facilities.

Defines the Objective-C statement AST node classes.

This file defines OpenACC AST classes for statement-level contructs.

This file defines OpenMP AST classes for executable directives and clauses.

This file defines SYCL AST classes used to represent calls to SYCL kernels.

static StmtClassNameTable & getStmtInfoTableEntry(Stmt::StmtClass E)

static LLVM_ATTRIBUTE_UNUSED void check_implementations()

Check whether the various Stmt classes implement their member functions.

static StringRef copyIntoContext(const ASTContext &C, StringRef str)

static std::pair< Stmt::Likelihood, const Attr * > getLikelihood(ArrayRef< const Attr * > Attrs)

static struct StmtClassNameTable StmtClassInfo[Stmt::lastStmtConstant+1]

#define BLOCK(DERIVED, BASE)

C Language Family Type Representation.

__device__ __2f16 float __ockl_bool s

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

llvm::BumpPtrAllocator & getAllocator() const

void * Allocate(size_t Size, unsigned Align=8) const

AddrLabelExpr - The GNU address of label extension, representing &&label.

LabelDecl * getLabel() const

AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.

unsigned getNumPlusOperands() const

getNumPlusOperands - Return the number of output operands that have a "+" constraint.

StringRef getOutputConstraint(unsigned i) const

getOutputConstraint - Return the constraint string for the specified output operand.

const Expr * getInputExpr(unsigned i) const

bool isOutputPlusConstraint(unsigned i) const

isOutputPlusConstraint - Return true if the specified output constraint is a "+" constraint (which is...

const Expr * getOutputExpr(unsigned i) const

StringRef getInputConstraint(unsigned i) const

getInputConstraint - Return the specified input constraint.

unsigned getNumOutputs() const

std::string generateAsmString(const ASTContext &C) const

Assemble final IR asm string.

unsigned getNumInputs() const

StringRef getClobber(unsigned i) const

Attr - This represents one attribute.

Represents an attribute applied to a statement.

static AttributedStmt * CreateEmpty(const ASTContext &C, unsigned NumAttrs)

static AttributedStmt * Create(const ASTContext &C, SourceLocation Loc, ArrayRef< const Attr * > Attrs, Stmt *SubStmt)

Represents the body of a CapturedStmt, and serves as its DeclContext.

Describes the capture of either a variable, or 'this', or variable-length array type.

VariableCaptureKind getCaptureKind() const

Determine the kind of capture.

VarDecl * getCapturedVar() const

Retrieve the declaration of the variable being captured.

This captures a statement into a function.

static CapturedStmt * CreateDeserialized(const ASTContext &Context, unsigned NumCaptures)

void setCapturedRegionKind(CapturedRegionKind Kind)

Set the captured region kind.

CapturedDecl * getCapturedDecl()

Retrieve the outlined function declaration.

bool capturesVariable(const VarDecl *Var) const

True if this variable has been captured.

void setCapturedDecl(CapturedDecl *D)

Set the outlined function declaration.

static CapturedStmt * Create(const ASTContext &Context, Stmt *S, CapturedRegionKind Kind, ArrayRef< Capture > Captures, ArrayRef< Expr * > CaptureInits, CapturedDecl *CD, RecordDecl *RD)

CapturedRegionKind getCapturedRegionKind() const

Retrieve the captured region kind.

VariableCaptureKind

The different capture forms: by 'this', by reference, capture for variable-length array type etc.

CaseStmt - Represent a case statement.

static CaseStmt * Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs, SourceLocation caseLoc, SourceLocation ellipsisLoc, SourceLocation colonLoc)

Build a case statement.

static CaseStmt * CreateEmpty(const ASTContext &Ctx, bool CaseStmtIsGNURange)

Build an empty case statement.

CompoundStmt - This represents a group of statements like { stmt stmt }.

static CompoundStmt * CreateEmpty(const ASTContext &C, unsigned NumStmts, bool HasFPFeatures)

body_iterator body_begin()

static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt * > Stmts, FPOptionsOverride FPFeatures, SourceLocation LB, SourceLocation RB)

DeclStmt - Adaptor class for mixing declarations with statements and expressions.

This represents one expression.

llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const

EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.

Represents difference between two FPOptions values.

bool requiresTrailingStorage() const

ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar, Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP, SourceLocation RP)

VarDecl * getConditionVariable() const

Retrieve the variable declared in this "for" statement, if any.

void setConditionVariable(const ASTContext &C, VarDecl *V)

AsmStringPiece - this is part of a decomposed asm string specification (for use with the AnalyzeAsmSt...

char getModifier() const

getModifier - Get the modifier for this operand, if present.

unsigned getNumLabels() const

const StringLiteral * getInputConstraintLiteral(unsigned i) const

std::string generateAsmString(const ASTContext &C) const

Assemble final IR asm string.

StringRef getClobber(unsigned i) const

StringRef getLabelName(unsigned i) const

unsigned AnalyzeAsmString(SmallVectorImpl< AsmStringPiece > &Pieces, const ASTContext &C, unsigned &DiagOffs) const

AnalyzeAsmString - Analyze the asm string of the current asm, decomposing it into pieces.

const StringLiteral * getOutputConstraintLiteral(unsigned i) const

StringRef getOutputConstraint(unsigned i) const

getOutputConstraint - Return the constraint string for the specified output operand.

void setInputExpr(unsigned i, Expr *E)

const StringLiteral * getAsmString() const

StringLiteral * getClobberStringLiteral(unsigned i)

StringRef getInputName(unsigned i) const

GCCAsmStmt(const ASTContext &C, SourceLocation asmloc, bool issimple, bool isvolatile, unsigned numoutputs, unsigned numinputs, IdentifierInfo **names, StringLiteral **constraints, Expr **exprs, StringLiteral *asmstr, unsigned numclobbers, StringLiteral **clobbers, unsigned numlabels, SourceLocation rparenloc)

StringRef getOutputName(unsigned i) const

Expr * getOutputExpr(unsigned i)

int getNamedOperand(StringRef SymbolicName) const

getNamedOperand - Given a symbolic operand reference like %[foo], translate this into a numeric value...

Expr * getInputExpr(unsigned i)

AddrLabelExpr * getLabelExpr(unsigned i) const

StringRef getInputConstraint(unsigned i) const

getInputConstraint - Return the specified input constraint.

One of these records is kept for each identifier that is lexed.

const char * getNameStart() const

Return the beginning of the actual null-terminated string for this identifier.

IfStmt - This represents an if/then/else.

static IfStmt * Create(const ASTContext &Ctx, SourceLocation IL, IfStatementKind Kind, Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LPL, SourceLocation RPL, Stmt *Then, SourceLocation EL=SourceLocation(), Stmt *Else=nullptr)

Create an IfStmt.

void setConditionVariable(const ASTContext &Ctx, VarDecl *V)

Set the condition variable for this if statement.

bool hasVarStorage() const

True if this IfStmt has storage for a variable declaration.

static IfStmt * CreateEmpty(const ASTContext &Ctx, bool HasElse, bool HasVar, bool HasInit)

Create an empty IfStmt optionally with storage for an else statement, condition variable and init exp...

std::optional< const Stmt * > getNondiscardedCase(const ASTContext &Ctx) const

If this is an 'if constexpr', determine which substatement will be taken.

bool isObjCAvailabilityCheck() const

DeclStmt * getConditionVariableDeclStmt()

If this IfStmt has a condition variable, return the faux DeclStmt associated with the creation of tha...

VarDecl * getConditionVariable()

Retrieve the variable declared in this "if" statement, if any.

LabelDecl * getConstantTarget()

getConstantTarget - Returns the fixed target of this indirect goto, if one exists.

Represents the declaration of a label.

LabelDecl * getDecl() const

const char * getName() const

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

Expr * getOutputExpr(unsigned i)

void setInputExpr(unsigned i, Expr *E)

MSAsmStmt(const ASTContext &C, SourceLocation asmloc, SourceLocation lbraceloc, bool issimple, bool isvolatile, ArrayRef< Token > asmtoks, unsigned numoutputs, unsigned numinputs, ArrayRef< StringRef > constraints, ArrayRef< Expr * > exprs, StringRef asmstr, ArrayRef< StringRef > clobbers, SourceLocation endloc)

std::string generateAsmString(const ASTContext &C) const

Assemble final IR asm string.

Expr * getInputExpr(unsigned i)

IdentifierInfo * getIdentifier() const

Get the identifier that names this declaration, if there is one.

StringRef getName() const

Get the name of identifier for this declaration as a StringRef.

Represents a struct/union/class.

ReturnStmt - This represents a return, optionally of an expression: return; return 4;.

static ReturnStmt * Create(const ASTContext &Ctx, SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate)

Create a return statement.

static ReturnStmt * CreateEmpty(const ASTContext &Ctx, bool HasNRVOCandidate)

Create an empty return statement, optionally with storage for an NRVO candidate.

static SEHExceptStmt * Create(const ASTContext &C, SourceLocation ExceptLoc, Expr *FilterExpr, Stmt *Block)

static SEHFinallyStmt * Create(const ASTContext &C, SourceLocation FinallyLoc, Stmt *Block)

SEHFinallyStmt * getFinallyHandler() const

static SEHTryStmt * Create(const ASTContext &C, bool isCXXTry, SourceLocation TryLoc, Stmt *TryBlock, Stmt *Handler)

SEHExceptStmt * getExceptHandler() const

Returns 0 if not defined.

Stmt * getHandler() const

Encodes a location in the source.

This class handles loading and caching of source files into memory.

A trivial tuple used to represent a source range.

SourceLocation getEnd() const

SourceLocation getBegin() const

Stmt - This represents one statement.

SourceLocation getEndLoc() const LLVM_READONLY

WhileStmtBitfields WhileStmtBits

static void EnableStatistics()

SwitchStmtBitfields SwitchStmtBits

const Stmt * stripLabelLikeStatements() const

Strip off all label-like statements.

StmtClass getStmtClass() const

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

static std::tuple< bool, const Attr *, const Attr * > determineLikelihoodConflict(const Stmt *Then, const Stmt *Else)

llvm::iterator_range< child_iterator > child_range

CompoundStmtBitfields CompoundStmtBits

Likelihood

The likelihood of a branch being taken.

@ LH_Unlikely

Branch has the [[unlikely]] attribute.

@ LH_None

No attribute set or branches of the IfStmt have the same attribute.

@ LH_Likely

Branch has the [[likely]] attribute.

static void addStmtClass(const StmtClass s)

ForStmtBitfields ForStmtBits

const char * getStmtClassName() const

static const Attr * getLikelihoodAttr(const Stmt *S)

Stmt * IgnoreContainers(bool IgnoreCaptured=false)

Skip no-op (attributed, compound) container stmts and skip captured stmt at the top,...

int64_t getID(const ASTContext &Context) const

ReturnStmtBitfields ReturnStmtBits

SourceLocation getBeginLoc() const LLVM_READONLY

llvm::iterator_range< const_child_iterator > const_child_range

static Likelihood getLikelihood(ArrayRef< const Attr * > Attrs)

StringLiteral - This represents a string literal expression, e.g.

SourceLocation getLocationOfByte(unsigned ByteNo, const SourceManager &SM, const LangOptions &Features, const TargetInfo &Target, unsigned *StartToken=nullptr, unsigned *StartTokenByteOffset=nullptr) const

getLocationOfByte - Return a source location that points to the specified byte of this string literal...

StringRef getString() const

SwitchStmt - This represents a 'switch' stmt.

void setRParenLoc(SourceLocation Loc)

void setConditionVariable(const ASTContext &Ctx, VarDecl *VD)

Set the condition variable in this switch statement.

static SwitchStmt * Create(const ASTContext &Ctx, Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LParenLoc, SourceLocation RParenLoc)

Create a switch statement.

void setLParenLoc(SourceLocation Loc)

static SwitchStmt * CreateEmpty(const ASTContext &Ctx, bool HasInit, bool HasVar)

Create an empty switch statement optionally with storage for an init expression and a condition varia...

bool hasVarStorage() const

True if this SwitchStmt has storage for a condition variable.

VarDecl * getConditionVariable()

Retrieve the variable declared in this "switch" statement, if any.

DeclStmt * getConditionVariableDeclStmt()

If this SwitchStmt has a condition variable, return the faux DeclStmt associated with the creation of...

Exposes information about the current target.

virtual std::optional< std::string > handleAsmEscapedChar(char C) const

Replace some escaped characters with another string based on target-specific rules.

Token - This structure provides full information about a lexed token.

const Expr * getExprStmt() const

Represents a variable declaration or definition.

VarDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

WhileStmt - This represents a 'while' stmt.

DeclStmt * getConditionVariableDeclStmt()

If this WhileStmt has a condition variable, return the faux DeclStmt associated with the creation of ...

VarDecl * getConditionVariable()

Retrieve the variable declared in this "while" statement, if any.

void setConditionVariable(const ASTContext &Ctx, VarDecl *V)

Set the condition variable of this while statement.

bool hasVarStorage() const

True if this WhileStmt has storage for a condition variable.

static WhileStmt * Create(const ASTContext &Ctx, VarDecl *Var, Expr *Cond, Stmt *Body, SourceLocation WL, SourceLocation LParenLoc, SourceLocation RParenLoc)

Create a while statement.

static WhileStmt * CreateEmpty(const ASTContext &Ctx, bool HasVar)

Create an empty while statement optionally with storage for a condition variable.

Defines the clang::TargetInfo interface.

const internal::VariadicAllOfMatcher< Stmt > stmt

Matches statements.

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

IfStatementKind

In an if statement, this denotes whether the statement is a constexpr or consteval if statement.

CapturedRegionKind

The different kinds of captured statement.

LLVM_READONLY bool isLetter(unsigned char c)

Return true if this character is an ASCII letter: [a-zA-Z].

@ Result

The result type of a method or function.

LLVM_READONLY bool isDigit(unsigned char c)

Return true if this character is an ASCII digit: [0-9].

const FunctionProtoType * T

A placeholder type used to construct an empty shell of a type, that will be filled in later (e....

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