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

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

clang: lib/CodeGen/CGStmt.cpp Source File

;

CodeGen;

CodeGenFunction::EmitStopPoint(

*S) {

= S->getBeginLoc();

assert(S &&

);

assert(!isa<DeclStmt>(*S) &&

);

(

*

= dyn_cast<OMPExecutableDirective>(S)) {

(S->getStmtClass()) {

Stmt::CXXCatchStmtClass:

Stmt::SEHExceptStmtClass:

Stmt::SEHFinallyStmtClass:

Stmt::MSDependentExistsStmtClass:

llvm_unreachable(

);

Stmt::NullStmtClass:

Stmt::CompoundStmtClass:

Stmt::DeclStmtClass:

Stmt::LabelStmtClass:

Stmt::AttributedStmtClass:

Stmt::GotoStmtClass:

Stmt::BreakStmtClass:

Stmt::ContinueStmtClass:

Stmt::DefaultStmtClass:

Stmt::CaseStmtClass:

Stmt::SEHLeaveStmtClass:

Stmt::SYCLKernelCallStmtClass:

llvm_unreachable(

);

llvm::BasicBlock *incoming =

.GetInsertBlock();

assert(incoming &&

);

llvm::BasicBlock *outgoing =

.GetInsertBlock();

assert(outgoing &&

);

(incoming != outgoing && outgoing->use_empty()) {

outgoing->eraseFromParent();

.ClearInsertionPoint();

Stmt::IndirectGotoStmtClass:

Stmt::IfStmtClass:

(cast<IfStmt>(*S));

;

Stmt::WhileStmtClass:

(cast<WhileStmt>(*S), Attrs);

;

Stmt::DoStmtClass:

(cast<DoStmt>(*S), Attrs);

;

Stmt::ForStmtClass:

(cast<ForStmt>(*S), Attrs);

;

Stmt::ReturnStmtClass:

(cast<ReturnStmt>(*S));

;

Stmt::SwitchStmtClass:

(cast<SwitchStmt>(*S));

;

Stmt::GCCAsmStmtClass:

Stmt::MSAsmStmtClass:

(cast<AsmStmt>(*S));

;

Stmt::CoroutineBodyStmtClass:

Stmt::CoreturnStmtClass:

Stmt::CapturedStmtClass: {

Stmt::ObjCAtTryStmtClass:

Stmt::ObjCAtCatchStmtClass:

);

Stmt::ObjCAtFinallyStmtClass:

);

Stmt::ObjCAtThrowStmtClass:

Stmt::ObjCAtSynchronizedStmtClass:

Stmt::ObjCForCollectionStmtClass:

Stmt::ObjCAutoreleasePoolStmtClass:

Stmt::CXXTryStmtClass:

Stmt::CXXForRangeStmtClass:

Stmt::SEHTryStmtClass:

Stmt::OMPMetaDirectiveClass:

Stmt::OMPCanonicalLoopClass:

Stmt::OMPParallelDirectiveClass:

Stmt::OMPSimdDirectiveClass:

Stmt::OMPTileDirectiveClass:

Stmt::OMPUnrollDirectiveClass:

Stmt::OMPReverseDirectiveClass:

Stmt::OMPInterchangeDirectiveClass:

Stmt::OMPForDirectiveClass:

Stmt::OMPForSimdDirectiveClass:

Stmt::OMPSectionsDirectiveClass:

Stmt::OMPSectionDirectiveClass:

Stmt::OMPSingleDirectiveClass:

Stmt::OMPMasterDirectiveClass:

Stmt::OMPCriticalDirectiveClass:

Stmt::OMPParallelForDirectiveClass:

Stmt::OMPParallelForSimdDirectiveClass:

Stmt::OMPParallelMasterDirectiveClass:

Stmt::OMPParallelSectionsDirectiveClass:

Stmt::OMPTaskDirectiveClass:

Stmt::OMPTaskyieldDirectiveClass:

Stmt::OMPErrorDirectiveClass:

Stmt::OMPBarrierDirectiveClass:

Stmt::OMPTaskwaitDirectiveClass:

Stmt::OMPTaskgroupDirectiveClass:

Stmt::OMPFlushDirectiveClass:

Stmt::OMPDepobjDirectiveClass:

Stmt::OMPScanDirectiveClass:

Stmt::OMPOrderedDirectiveClass:

Stmt::OMPAtomicDirectiveClass:

Stmt::OMPTargetDirectiveClass:

Stmt::OMPTeamsDirectiveClass:

Stmt::OMPCancellationPointDirectiveClass:

Stmt::OMPCancelDirectiveClass:

Stmt::OMPTargetDataDirectiveClass:

Stmt::OMPTargetEnterDataDirectiveClass:

Stmt::OMPTargetExitDataDirectiveClass:

Stmt::OMPTargetParallelDirectiveClass:

Stmt::OMPTargetParallelForDirectiveClass:

Stmt::OMPTaskLoopDirectiveClass:

Stmt::OMPTaskLoopSimdDirectiveClass:

Stmt::OMPMasterTaskLoopDirectiveClass:

Stmt::OMPMaskedTaskLoopDirectiveClass:

Stmt::OMPMasterTaskLoopSimdDirectiveClass:

cast<OMPMasterTaskLoopSimdDirective>(*S));

Stmt::OMPMaskedTaskLoopSimdDirectiveClass:

cast<OMPMaskedTaskLoopSimdDirective>(*S));

Stmt::OMPParallelMasterTaskLoopDirectiveClass:

cast<OMPParallelMasterTaskLoopDirective>(*S));

Stmt::OMPParallelMaskedTaskLoopDirectiveClass:

cast<OMPParallelMaskedTaskLoopDirective>(*S));

Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:

cast<OMPParallelMasterTaskLoopSimdDirective>(*S));

Stmt::OMPParallelMaskedTaskLoopSimdDirectiveClass:

cast<OMPParallelMaskedTaskLoopSimdDirective>(*S));

Stmt::OMPDistributeDirectiveClass:

Stmt::OMPTargetUpdateDirectiveClass:

Stmt::OMPDistributeParallelForDirectiveClass:

cast<OMPDistributeParallelForDirective>(*S));

Stmt::OMPDistributeParallelForSimdDirectiveClass:

cast<OMPDistributeParallelForSimdDirective>(*S));

Stmt::OMPDistributeSimdDirectiveClass:

Stmt::OMPTargetParallelForSimdDirectiveClass:

cast<OMPTargetParallelForSimdDirective>(*S));

Stmt::OMPTargetSimdDirectiveClass:

Stmt::OMPTeamsDistributeDirectiveClass:

Stmt::OMPTeamsDistributeSimdDirectiveClass:

cast<OMPTeamsDistributeSimdDirective>(*S));

Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:

cast<OMPTeamsDistributeParallelForSimdDirective>(*S));

Stmt::OMPTeamsDistributeParallelForDirectiveClass:

cast<OMPTeamsDistributeParallelForDirective>(*S));

Stmt::OMPTargetTeamsDirectiveClass:

Stmt::OMPTargetTeamsDistributeDirectiveClass:

cast<OMPTargetTeamsDistributeDirective>(*S));

Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:

cast<OMPTargetTeamsDistributeParallelForDirective>(*S));

Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:

cast<OMPTargetTeamsDistributeParallelForSimdDirective>(*S));

Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:

cast<OMPTargetTeamsDistributeSimdDirective>(*S));

Stmt::OMPInteropDirectiveClass:

Stmt::OMPDispatchDirectiveClass:

Stmt::OMPScopeDirectiveClass:

Stmt::OMPMaskedDirectiveClass:

Stmt::OMPGenericLoopDirectiveClass:

Stmt::OMPTeamsGenericLoopDirectiveClass:

Stmt::OMPTargetTeamsGenericLoopDirectiveClass:

cast<OMPTargetTeamsGenericLoopDirective>(*S));

Stmt::OMPParallelGenericLoopDirectiveClass:

cast<OMPParallelGenericLoopDirective>(*S));

Stmt::OMPTargetParallelGenericLoopDirectiveClass:

cast<OMPTargetParallelGenericLoopDirective>(*S));

Stmt::OMPParallelMaskedDirectiveClass:

Stmt::OMPAssumeDirectiveClass:

Stmt::OpenACCComputeConstructClass:

Stmt::OpenACCLoopConstructClass:

Stmt::OpenACCCombinedConstructClass:

Stmt::OpenACCDataConstructClass:

Stmt::OpenACCEnterDataConstructClass:

Stmt::OpenACCExitDataConstructClass:

Stmt::OpenACCHostDataConstructClass:

Stmt::OpenACCWaitConstructClass:

Stmt::OpenACCInitConstructClass:

Stmt::OpenACCShutdownConstructClass:

Stmt::OpenACCSetConstructClass:

Stmt::OpenACCUpdateConstructClass:

(S->getStmtClass()) {

Stmt::NullStmtClass:

Stmt::CompoundStmtClass:

Stmt::DeclStmtClass:

Stmt::LabelStmtClass:

Stmt::AttributedStmtClass:

Stmt::GotoStmtClass:

Stmt::BreakStmtClass:

Stmt::ContinueStmtClass:

Stmt::DefaultStmtClass:

Stmt::CaseStmtClass:

Stmt::SEHLeaveStmtClass:

Stmt::SYCLKernelCallStmtClass:

);

LexicalScope

(*

, S.getSourceRange());

assert((!GetLast || (GetLast &&

)) &&

);

(

*CurStmt : S.body()) {

(

*LS = dyn_cast<LabelStmt>(

)) {

}

(

*AS = dyn_cast<AttributedStmt>(

)) {

llvm_unreachable(

);

llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());

(!BI || !BI->isUnconditional())

(BI->getIterator() != BB->begin())

BB->replaceAllUsesWith(BI->getSuccessor(0));

BI->eraseFromParent();

BB->eraseFromParent();

llvm::BasicBlock *CurBB =

.GetInsertBlock();

(IsFinished && BB->use_empty()) {

(CurBB && CurBB->getParent())

->insert(std::next(CurBB->getIterator()), BB);

llvm::BasicBlock *CurBB =

.GetInsertBlock();

(!CurBB || CurBB->getTerminator()) {

.ClearInsertionPoint();

inserted =

;

(llvm::User *u : block->users()) {

(llvm::Instruction *insn = dyn_cast<llvm::Instruction>(u)) {

->insert(std::next(insn->getParent()->getIterator()), block);

.SetInsertPoint(block);

CodeGenFunction::JumpDest

JumpDest &Dest = LabelMap[

];

(Dest.isValid())

Dest;

JumpDest &Dest = LabelMap[

];

(!Dest.isValid()) {

assert(!Dest.getScopeDepth().isValid() &&

);

assert(!Labels.empty());

i = Labels.begin(), e = Labels.end(); i != e; ++i) {

assert(

.LabelMap.count(*i));

ParentScope->Labels.append(Labels.begin(), Labels.end());

nomerge =

;

noinline =

;

alwaysinline =

;

noconvergent =

;

HLSLControlFlowHintAttr::Spelling flattenOrBranch =

HLSLControlFlowHintAttr::SpellingNotCalculated;

*musttail =

;

(

*A : S.getAttrs()) {

(A->getKind()) {

attr::AlwaysInline:

alwaysinline =

;

attr::NoConvergent:

noconvergent =

;

attr::MustTail: {

*Sub = S.getSubStmt();

attr::CXXAssume: {

*Assumption = cast<CXXAssumeAttr>(A)->getAssumption();

.CreateAssumption(AssumptionVal);

attr::HLSLControlFlowHint: {

flattenOrBranch = cast<HLSLControlFlowHintAttr>(A)->getSemanticSpelling();

(S.getSubStmt(), S.getAttrs());

llvm::BasicBlock *CurBB =

.GetInsertBlock();

cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(

, CurBB);

*Else = S.getElse();

(S.isConsteval()) {

*Executed = S.isNegatedConsteval() ? S.getThen() : Else;

RunCleanupsScope ExecutedScope(*

);

LexicalScope ConditionScope(*

, S.getCond()->getSourceRange());

(S.getConditionVariable())

(*S.getConditionVariable());

*Executed = S.getThen();

*Skipped = Else;

std::swap(Executed, Skipped);

RunCleanupsScope ExecutedScope(*

);

llvm::BasicBlock *ElseBlock = ContBlock;

.CreateCondBr(BoolCondVal, ThenBlock, ElseBlock);

RunCleanupsScope ThenScope(*

);

RunCleanupsScope ElseScope(*

);

CondIsConstInt =

!ControllingExpression ||

CondIsTrue = CondIsConstInt && (!ControllingExpression ||

.Val.getInt().getBoolValue());

(HasEmptyBody && CondIsTrue) {

->removeFnAttr(llvm::Attribute::MustProgress);

(std::is_same_v<LoopStmt, ForStmt>) {

*Body = S.getBody();

(!Body || isa<NullStmt>(Body))

(

*Compound = dyn_cast<CompoundStmt>(Body))

Compound->body_empty();

emitConvergenceLoopToken(LoopHeader.getBlock()));

BreakContinueStack.push_back(BreakContinue(

, LoopHeader));

RunCleanupsScope ConditionScope(*

);

(S.getConditionVariable())

(*S.getConditionVariable());

llvm::ConstantInt *

= dyn_cast<llvm::ConstantInt>(BoolCondVal);

EmitBoolCondBranch = !

|| !

->isOne();

(EmitBoolCondBranch) {

llvm::BasicBlock *ExitBlock =

.getBlock();

(ConditionScope.requiresCleanups())

llvm::MDNode *Weights =

createProfileWeightsForLoop(S.getCond(),

(S.getBody()));

BoolCondVal = emitCondLikelihoodViaExpectIntrinsic(

.CreateCondBr(BoolCondVal, LoopBody, ExitBlock, Weights);

(ExitBlock !=

.getBlock()) {

diag::warn_attribute_has_no_effect_on_infinite_loop)

<< A << A->getRange();

diag::note_attribute_has_no_effect_on_infinite_loop_here)

<<

(S.getWhileLoc(), S.getRParenLoc());

RunCleanupsScope BodyScope(*

);

BreakContinueStack.pop_back();

ConditionScope.ForceCleanup();

(!EmitBoolCondBranch)

BreakContinueStack.push_back(BreakContinue(

, LoopCond));

RunCleanupsScope BodyScope(*

);

BreakContinueStack.pop_back();

llvm::ConstantInt *

= dyn_cast<llvm::ConstantInt>(BoolCondVal);

EmitBoolCondBranch = !

|| !

->isZero();

(EmitBoolCondBranch) {

BoolCondVal, LoopBody,

.getBlock(),

createProfileWeightsForLoop(S.getCond(), BackedgeCount));

(!EmitBoolCondBranch)

LexicalScope ForScope(*

, S.getSourceRange());

llvm::BasicBlock *CondBlock = CondDest.getBlock();

LexicalScope ConditionScope(*

, S.getSourceRange());

Continue = CondDest;

(!S.getConditionVariable())

BreakContinueStack.push_back(BreakContinue(

, Continue));

(S.getConditionVariable()) {

(*S.getConditionVariable());

BreakContinueStack.back().ContinueBlock = Continue;

llvm::BasicBlock *ExitBlock =

.getBlock();

(ForScope.requiresCleanups())

llvm::MDNode *Weights =

createProfileWeightsForLoop(S.getCond(),

(S.getBody()));

BoolCondVal = emitCondLikelihoodViaExpectIntrinsic(

.CreateCondBr(BoolCondVal, ForBody, ExitBlock, Weights);

(ExitBlock !=

.getBlock()) {

RunCleanupsScope BodyScope(*

);

BreakContinueStack.pop_back();

ConditionScope.ForceCleanup();

ForScope.ForceCleanup();

LexicalScope ForScope(*

, S.getSourceRange());

llvm::BasicBlock *ExitBlock =

.getBlock();

(ForScope.requiresCleanups())

llvm::MDNode *Weights =

createProfileWeightsForLoop(S.getCond(),

(S.getBody()));

BoolCondVal = emitCondLikelihoodViaExpectIntrinsic(

.CreateCondBr(BoolCondVal, ForBody, ExitBlock, Weights);

(ExitBlock !=

.getBlock()) {

BreakContinueStack.push_back(BreakContinue(

, Continue));

LexicalScope BodyScope(*

, S.getSourceRange());

BreakContinueStack.pop_back();

ForScope.ForceCleanup();

CodeGenFunction::EmitReturnOfRValue(

RV,

Ty) {

SaveRetExprRAII {

: OldRetExpr(CGF.RetExpr), CGF(CGF) {

~SaveRetExprRAII() { CGF.RetExpr = OldRetExpr; }

*OldRetExpr;

(calleeQualType->isFunctionPointerType() ||

calleeQualType->isFunctionReferenceType() ||

calleeQualType->isBlockPointerType() ||

calleeQualType->isMemberFunctionPointerType()) {

}

(

*ty = dyn_cast<FunctionType>(calleeQualType)) {

}

(

CMCE = dyn_cast<CXXMemberCallExpr>(CE)) {

(

methodDecl = CMCE->getMethodDecl()) {

(requiresReturnValueCheck()) {

llvm::GlobalVariable(

.

(), SLoc->getType(),

,

llvm::GlobalVariable::PrivateLinkage, SLoc);

SLocPtr->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

assert(ReturnLocation.

() &&

);

.ClearInsertionPoint();

*RV = S.getRetValue();

SaveRetExprRAII SaveRetExpr(RV, *

);

RunCleanupsScope cleanupScope(*

);

(

*EWC = dyn_cast_or_null<ExprWithCleanups>(RV))

RV = EWC->getSubExpr();

std::optional<llvm::SaveAndRestore<const CallExpr *>> SaveMustTail;

(

CE = dyn_cast<CallExpr>(RV)) {

(

().ElideConstructors && S.getNRVOCandidate() &&

S.getNRVOCandidate()->isNRVOVariable() &&

(llvm::Value *NRVOFlag =

[S.getNRVOCandidate()])

++NumSimpleReturnExprs;

cleanupScope.ForceCleanup();

(

*I : S.decls())

assert(!BreakContinueStack.empty() &&

);

assert(!BreakContinueStack.empty() &&

);

assert(S.getRHS() &&

);

llvm::APSInt LHS = S.getLHS()->EvaluateKnownConstInt(

());

llvm::APSInt RHS = S.getRHS()->EvaluateKnownConstInt(

());

(LHS.isSigned() ? RHS.slt(LHS) : RHS.ult(LHS))

llvm::APInt

= RHS - LHS;

(

.ult(llvm::APInt(

.getBitWidth(), 64))) {

NCases =

.getZExtValue() + 1;

Weight = Total / NCases,

= Total % NCases;

(

I = 0; I != NCases; ++I) {

SwitchWeights->push_back(Weight + (Rem ? 1 : 0));

(SwitchLikelihood)

SwitchLikelihood->push_back(LH);

SwitchInsn->addCase(

.getInt(LHS), CaseDest);

llvm::BasicBlock *RestoreBB =

.GetInsertBlock();

llvm::BasicBlock *FalseDest = CaseRangeBlock;

->insert(

->end(), CaseRangeBlock);

.SetInsertPoint(CaseRangeBlock);

.CreateSub(SwitchInsn->getCondition(),

.getInt(LHS));

llvm::MDNode *Weights =

;

(SwitchWeights) {

DefaultCount = (*SwitchWeights)[0];

Weights = createProfileWeights(ThisCount, DefaultCount);

(*SwitchWeights)[0] += ThisCount;

}

(SwitchLikelihood)

Cond = emitCondLikelihoodViaExpectIntrinsic(Cond, LH);

.CreateCondBr(Cond, CaseDest, FalseDest, Weights);

.SetInsertPoint(RestoreBB);

.ClearInsertionPoint();

llvm::ConstantInt *CaseVal =

(

ICE = dyn_cast<ImplicitCastExpr>(S.getLHS()))

CE = dyn_cast<ConstantExpr>(ICE->getSubExpr());

CE = dyn_cast<ConstantExpr>(S.getLHS());

(

DE = dyn_cast<DeclRefExpr>(CE->

()))

Dbg->EmitGlobalVariable(DE->getDecl(),

(llvm::APSInt(CaseVal->getValue())));

(SwitchLikelihood)

isa<BreakStmt>(S.getSubStmt())) {

JumpDest

= BreakContinueStack.back().BreakBlock;

SwitchInsn->addCase(CaseVal,

.getBlock());

(

.GetInsertBlock()) {

.ClearInsertionPoint();

SwitchInsn->addCase(CaseVal, CaseDest);

*NextCase = dyn_cast<CaseStmt>(S.getSubStmt());

(NextCase && NextCase->

() ==

) {

llvm::ConstantInt *CaseVal =

(SwitchLikelihood)

SwitchInsn->addCase(CaseVal, CaseDest);

NextCase = dyn_cast<CaseStmt>(CurCase->

());

llvm::BasicBlock *DefaultBlock = SwitchInsn->getDefaultDest();

assert(DefaultBlock->empty() &&

);

(SwitchLikelihood)

(

*SC = dyn_cast<SwitchCase>(S)) {

(!Case && isa<BreakStmt>(S))

(

*CS = dyn_cast<CompoundStmt>(S)) {

StartedInLiveCode = FoundCase;

StartSize = ResultStmts.size();

HadSkippedDecl =

;

(; Case && I !=

; ++I) {

(++I; I !=

; ++I)

assert(FoundCase &&

);

assert(!HadSkippedDecl &&

);

AnyDecls =

;

(; I !=

; ++I) {

(++I; I !=

; ++I)

ResultStmts.resize(StartSize);

ResultStmts.push_back(S);

ResultStmts.push_back(S);

llvm::APSInt &ConstantCondValue,

*Case = S.getSwitchCaseList();

(

*DS = dyn_cast<DefaultStmt>(Case)) {

*CS = cast<CaseStmt>(Case);

(CS->

())

;

FoundCase =

;

std::optional<SmallVector<uint64_t, 16>>

(Likelihoods.size() <= 1)

std::nullopt;

uint64_t NumUnlikely = 0;

uint64_t NumNone = 0;

uint64_t NumLikely = 0;

(

LH : Likelihoods) {

(NumUnlikely == 0 && NumLikely == 0)

std::nullopt;

uint64_t Likely = INT32_MAX / (NumLikely + 2);

uint64_t

= Likely / (NumNone + 1);

uint64_t Unlikely = 0;

.reserve(Likelihoods.size());

(

LH : Likelihoods) {

.push_back(Unlikely);

.push_back(Likely);

llvm::SwitchInst *SavedSwitchInsn = SwitchInsn;

llvm::BasicBlock *SavedCRBlock = CaseRangeBlock;

llvm::APSInt ConstantCondValue;

RunCleanupsScope ExecutedScope(*

);

(S.getConditionVariable())

(*S.getConditionVariable());

SwitchInsn =

;

(

i = 0, e = CaseStmts.size(); i != e; ++i)

SwitchInsn = SavedSwitchInsn;

RunCleanupsScope ConditionScope(*

);

(S.getConditionVariable())

(*S.getConditionVariable());

SwitchInsn =

.CreateSwitch(CondV, DefaultBlock);

NumCases = 0;

(

*Case = S.getSwitchCaseList();

(isa<DefaultStmt>(Case))

SwitchWeights->reserve(NumCases);

SwitchWeights->push_back(DefaultCount);

CaseRangeBlock = DefaultBlock;

.ClearInsertionPoint();

JumpDest OuterContinue;

(!BreakContinueStack.empty())

OuterContinue = BreakContinueStack.back().ContinueBlock;

BreakContinueStack.push_back(BreakContinue(SwitchExit, OuterContinue));

BreakContinueStack.pop_back();

SwitchInsn->setDefaultDest(CaseRangeBlock);

(!DefaultBlock->getParent()) {

(ConditionScope.requiresCleanups()) {

DefaultBlock->replaceAllUsesWith(SwitchExit.getBlock());

DefaultBlock;

ConditionScope.ForceCleanup();

(SwitchExit.getBlock(),

);

*

= dyn_cast<CallExpr>(S.getCond());

*FD = dyn_cast_or_null<FunctionDecl>(

->getCalleeDecl());

(FD && FD->getBuiltinID() == Builtin::BI__builtin_unpredictable) {

SwitchInsn->setMetadata(llvm::LLVMContext::MD_unpredictable,

MDHelper.createUnpredictable());

(SwitchWeights) {

assert(SwitchWeights->size() == 1 + SwitchInsn->getNumCases() &&

);

(SwitchWeights->size() > 1)

SwitchInsn->setMetadata(llvm::LLVMContext::MD_prof,

createProfileWeights(*SwitchWeights));

SwitchWeights;

}

(SwitchLikelihood) {

assert(SwitchLikelihood->size() == 1 + SwitchInsn->getNumCases() &&

);

std::optional<SmallVector<uint64_t, 16>> LHW =

SwitchInsn->setMetadata(llvm::LLVMContext::MD_prof,

createProfileWeights(*LHW));

SwitchLikelihood;

SwitchInsn = SavedSwitchInsn;

SwitchWeights = SavedSwitchWeights;

SwitchLikelihood = SavedSwitchLikelihood;

CaseRangeBlock = SavedCRBlock;

(*Constraint) {

(*Constraint) {

(Constraint[1] && Constraint[1] !=

)

(Constraint[1] && Constraint[1] == *Constraint)

);

result =

.resolveSymbolicName(Constraint, *OutCons, Index);

assert(result &&

); (void)result;

+= llvm::utostr(Index);

std::string *GCCReg =

) {

*AsmDeclRef = dyn_cast<DeclRefExpr>(&AsmExpr);

StringRef Register =

->getLabel();

assert(

.isValidGCCRegisterName(Register));

(

.validateOutputConstraint(Info) &&

Register =

.getNormalizedGCCRegisterName(Register);

(GCCReg !=

)

*GCCReg = Register.str();

(EarlyClobber ?

:

) + Register.str() +

;

std::pair<llvm::Value*, llvm::Type *> CodeGenFunction::EmitAsmInputLValue(

((Size <= 64 && llvm::isPowerOf2_64(Size)) ||

ConstraintStr +=

;

std::pair<llvm::Value *, llvm::Type *>

*InputExpr,

std::string &ConstraintStr) {

llvm::APSInt IntResult;

{llvm::ConstantInt::get(

(), IntResult),

};

(InputExpr->

() == Expr::CXXThisExprClass)

EmitAsmInputLValue(Info, Dest, InputExpr->

(), ConstraintStr,

Locs.push_back(llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(

(!StrVal.empty()) {

StartToken = 0;

ByteOffset = 0;

(

i = 0, e = StrVal.size() - 1; i != e; ++i) {

(StrVal[i] !=

)

;

i + 1,

, LangOpts, CGF.

(), &StartToken, &ByteOffset);

Locs.push_back(llvm::ConstantAsMetadata::get(

HasUnwindClobber,

ReadOnly,

ReadNone,

NoMerge,

NoConvergent,

std::vector<llvm::Type *> &ResultRegTypes,

std::vector<llvm::Type *> &ArgElemTypes,

std::vector<llvm::Value *> &RegResults) {

(!HasUnwindClobber)

.addFnAttr(llvm::Attribute::NoUnwind);

.addFnAttr(llvm::Attribute::NoMerge);

(!HasSideEffect) {

.setDoesNotAccessMemory();

.setOnlyReadsMemory();

(

Pair : llvm::enumerate(ArgElemTypes)) {

= llvm::Attribute::get(

CGF.

(), llvm::Attribute::ElementType, Pair.value());

(

*gccAsmStmt = dyn_cast<GCCAsmStmt>(&S))

.setMetadata(

,

llvm::Constant *

=

llvm::ConstantInt::get(CGF.

, S.getAsmLoc().getRawEncoding());

.setMetadata(

,

llvm::ConstantAsMetadata::get(

)));

.addFnAttr(llvm::Attribute::Convergent);

(ResultRegTypes.size() == 1) {

RegResults.push_back(&

);

(

i = 0, e = ResultRegTypes.size(); i != e; ++i) {

llvm::Value *Tmp = CGF.

.CreateExtractValue(&

, i,

);

RegResults.push_back(Tmp);

llvm::BitVector &ResultTypeRequiresCast,

llvm::BitVector &ResultRegIsFlagReg) {

assert(RegResults.size() == ResultRegTypes.size());

assert(RegResults.size() == ResultTruncRegTypes.size());

assert(RegResults.size() == ResultRegDests.size());

assert(ResultTypeRequiresCast.size() <= ResultRegDests.size());

assert(ResultRegIsFlagReg.size() <= ResultRegDests.size());

(

i = 0, e = RegResults.size(); i != e; ++i) {

llvm::Value *Tmp = RegResults[i];

llvm::Type *TruncTy = ResultTruncRegTypes[i];

((i < ResultRegIsFlagReg.size()) && ResultRegIsFlagReg[i]) {

llvm::Constant *Two = llvm::ConstantInt::get(Tmp->getType(), 2);

llvm::Value *IsBooleanValue =

.CreateCmp(llvm::CmpInst::ICMP_ULT, Tmp, Two);

llvm::Function *FnAssume =

.

(llvm::Intrinsic::assume);

.CreateCall(FnAssume, IsBooleanValue);

(ResultRegTypes[i] != TruncTy) {

(TruncTy->isFloatingPointTy())

Tmp =

.CreateFPTrunc(Tmp, TruncTy);

(TruncTy->isPointerTy() && Tmp->getType()->isIntegerTy()) {

Tmp, llvm::IntegerType::get(CTX, (

)ResSize));

Tmp =

.CreateIntToPtr(Tmp, TruncTy);

}

(Tmp->getType()->isPointerTy() && TruncTy->isIntegerTy()) {

Tmp =

.CreatePtrToInt(

Tmp, llvm::IntegerType::get(CTX, (

)TmpSize));

Tmp =

.CreateTrunc(Tmp, TruncTy);

}

(Tmp->getType()->isIntegerTy() && TruncTy->isIntegerTy()) {

Tmp =

.CreateZExtOrTrunc(Tmp, TruncTy);

}

(Tmp->getType()->isVectorTy() || TruncTy->isVectorTy()) {

Tmp =

.CreateBitCast(Tmp, TruncTy);

Dest = ResultRegDests[i];

((i < ResultTypeRequiresCast.size()) && ResultTypeRequiresCast[i]) {

*OutExpr = S.getOutputExpr(i);

diag::err_store_value_to_reg);

Name =

;

(

GCCAsm = dyn_cast<GCCAsmStmt>(&S))

= GCCAsm->getAsmString()->getString();

StrTy = llvm::ConstantDataArray::getString(Ctx,

);

FnTy = llvm::FunctionType::get(llvm::Type::getVoidTy(Ctx),

{StrTy->getType()},

);

UBF = CGF->

.

().getOrInsertFunction(Name, FnTy);

CGF->

.CreateCall(UBF, {StrTy});

CodeGenFunction::RunCleanupsScope Cleanups(*

);

std::string AsmString = S.generateAsmString(

());

IsValidTargetAsm =

;

(

i = 0, e = S.getNumOutputs(); i != e && IsValidTargetAsm; i++) {

(

*GAS = dyn_cast<GCCAsmStmt>(&S))

Name = GAS->getOutputName(i);

(IsHipStdPar && !IsValid)

IsValidTargetAsm =

;

assert(IsValid &&

);

OutputConstraintInfos.push_back(Info);

(

i = 0, e = S.getNumInputs(); i != e && IsValidTargetAsm; i++) {

(

*GAS = dyn_cast<GCCAsmStmt>(&S))

Name = GAS->getInputName(i);

(IsHipStdPar && !IsValid)

IsValidTargetAsm =

;

assert(IsValid &&

);

InputConstraintInfos.push_back(Info);

(!IsValidTargetAsm)

std::string Constraints;

std::vector<LValue> ResultRegDests;

std::vector<QualType> ResultRegQualTys;

std::vector<llvm::Type *> ResultRegTypes;

std::vector<llvm::Type *> ResultTruncRegTypes;

std::vector<llvm::Type *> ArgTypes;

std::vector<llvm::Type *> ArgElemTypes;

std::vector<llvm::Value*> Args;

llvm::BitVector ResultTypeRequiresCast;

llvm::BitVector ResultRegIsFlagReg;

std::string InOutConstraints;

std::vector<llvm::Value*> InOutArgs;

std::vector<llvm::Type*> InOutArgTypes;

std::vector<llvm::Type*> InOutArgElemTypes;

std::vector<std::string> OutputConstraints;

llvm::SmallSet<std::string, 8> PhysRegOutputs;

ReadOnly =

, ReadNone =

;

(

i = 0, e = S.getNumOutputs(); i != e; i++) {

std::string OutputConstraint(S.getOutputConstraint(i));

*OutExpr = S.getOutputExpr(i);

(!GCCReg.empty() && !PhysRegOutputs.insert(GCCReg).second)

.

(S.getAsmLoc(),

+ GCCReg);

OutputConstraints.push_back(OutputConstraint);

(!Constraints.empty())

Constraints +=

;

Constraints +=

+ OutputConstraint;

ResultRegQualTys.push_back(QTy);

ResultRegDests.push_back(Dest);

IsFlagReg = llvm::StringRef(OutputConstraint).starts_with(

);

ResultRegIsFlagReg.push_back(IsFlagReg);

Ty->isAggregateType());

ResultTruncRegTypes.push_back(Ty);

ResultTypeRequiresCast.push_back(RequiresCast);

ResultRegTypes.push_back(Ty);

(InputNo = 0; InputNo != S.getNumInputs(); ++InputNo) {

assert(InputNo != S.getNumInputs() &&

);

InputTy = S.getInputExpr(InputNo)->getType();

(llvm::Type* AdjTy =

ResultRegTypes.back()))

ResultRegTypes.back() = AdjTy;

diag::err_asm_invalid_type_in_input)

<< OutExpr->

() << OutputConstraint;

(

*VT = dyn_cast<llvm::VectorType>(ResultRegTypes.back()))

LargestVectorWidth =

std::max((uint64_t)LargestVectorWidth,

VT->getPrimitiveSizeInBits().getKnownMinValue());

ArgTypes.push_back(DestAddr.

());

Constraints +=

;

Constraints += OutputConstraint;

ReadOnly = ReadNone =

;

InOutConstraints +=

;

*InputExpr = S.getOutputExpr(i);

llvm::Type *ArgElemType;

std::tie(Arg, ArgElemType) = EmitAsmInputLValue(

Info, Dest, InputExpr->

(), InOutConstraints,

(llvm::Type* AdjTy =

Arg =

.CreateBitCast(Arg, AdjTy);

(

*VT = dyn_cast<llvm::VectorType>(Arg->getType()))

LargestVectorWidth =

std::max((uint64_t)LargestVectorWidth,

VT->getPrimitiveSizeInBits().getKnownMinValue());

InOutConstraints += llvm::utostr(i);

InOutConstraints += OutputConstraint;

InOutArgTypes.push_back(Arg->getType());

InOutArgElemTypes.push_back(ArgElemType);

InOutArgs.push_back(Arg);

(isa<MSAsmStmt>(&S)) {

*

, ReturnSlot, Constraints, ResultRegTypes, ResultTruncRegTypes,

ResultRegDests, AsmString, S.getNumOutputs());

(

i = 0, e = S.getNumInputs(); i != e; i++) {

*InputExpr = S.getInputExpr(i);

(!Constraints.empty())

Constraints +=

;

std::string InputConstraint(S.getInputConstraint(i));

&OutputConstraintInfos);

std::string ReplaceConstraint (InputConstraint);

llvm::Type *ArgElemType;

std::tie(Arg, ArgElemType) = EmitAsmInput(Info, InputExpr, Constraints);

OutputType = S.getOutputExpr(Output)->getType();

(isa<llvm::PointerType>(Arg->getType()))

(isa<llvm::IntegerType>(OutputTy))

Arg =

.CreateZExt(Arg, OutputTy);

(isa<llvm::PointerType>(OutputTy))

(OutputTy->isFloatingPointTy())

Arg =

.CreateFPExt(Arg, OutputTy);

ReplaceConstraint = OutputConstraints[Output];

(llvm::Type* AdjTy =

().adjustInlineAsmType(*

, ReplaceConstraint,

Arg =

.CreateBitCast(Arg, AdjTy);

<< InputExpr->

() << InputConstraint;

(

*VT = dyn_cast<llvm::VectorType>(Arg->getType()))

LargestVectorWidth =

std::max((uint64_t)LargestVectorWidth,

VT->getPrimitiveSizeInBits().getKnownMinValue());

ArgTypes.push_back(Arg->getType());

ArgElemTypes.push_back(ArgElemType);

Args.push_back(Arg);

Constraints += InputConstraint;

(

i = 0, e = InOutArgs.size(); i != e; i++) {

ArgTypes.push_back(InOutArgTypes[i]);

ArgElemTypes.push_back(InOutArgElemTypes[i]);

Args.push_back(InOutArgs[i]);

Constraints += InOutConstraints;

llvm::BasicBlock *Fallthrough =

;

IsGCCAsmGoto =

;

(

*GS = dyn_cast<GCCAsmStmt>(&S)) {

IsGCCAsmGoto = GS->isAsmGoto();

(

*

: GS->labels()) {

Transfer.push_back(Dest.getBlock());

(!Constraints.empty())

Constraints +=

;

Constraints +=

;

HasUnwindClobber =

;

(

i = 0, e = S.getNumClobbers(); i != e; i++) {

StringRef Clobber = S.getClobber(i);

(Clobber ==

)

ReadOnly = ReadNone =

;

(Clobber ==

) {

HasUnwindClobber =

;

}

(Clobber !=

) {

diag::warn_stack_clash_protection_inline_asm);

(isa<MSAsmStmt>(&S)) {

(Clobber ==

|| Clobber ==

) {

(Constraints.find(

) != std::string::npos)

std::string::size_type position1 =

Constraints.find(

+ Clobber.str() +

);

(position1 != std::string::npos) {

Constraints.insert(position1 + 1,

);

std::string::size_type position2 = Constraints.find(

);

(position2 != std::string::npos) {

Constraints.insert(position2 + 1,

);

(!Constraints.empty())

Constraints +=

;

Constraints +=

;

Constraints += Clobber;

Constraints +=

;

assert(!(HasUnwindClobber && IsGCCAsmGoto) &&

);

(!MachineClobbers.empty()) {

(!Constraints.empty())

Constraints +=

;

Constraints += MachineClobbers;

llvm::Type *ResultType;

(ResultRegTypes.empty())

(ResultRegTypes.size() == 1)

ResultType = ResultRegTypes[0];

ResultType = llvm::StructType::get(

(), ResultRegTypes);

llvm::FunctionType *FTy =

llvm::FunctionType::get(ResultType, ArgTypes,

);

HasSideEffect = S.isVolatile() || S.getNumOutputs() == 0;

llvm::InlineAsm::AsmDialect GnuAsmDialect =

? llvm::InlineAsm::AD_ATT

: llvm::InlineAsm::AD_Intel;

llvm::InlineAsm::AsmDialect AsmDialect = isa<MSAsmStmt>(&S) ?

llvm::InlineAsm::AD_Intel : GnuAsmDialect;

llvm::InlineAsm *IA = llvm::InlineAsm::get(

FTy, AsmString, Constraints, HasSideEffect,

, AsmDialect, HasUnwindClobber);

std::vector<llvm::Value*> RegResults;

llvm::CallBrInst *CBR;

llvm::DenseMap<llvm::BasicBlock *, SmallVector<llvm::Value *, 4>>

CBR =

.CreateCallBr(IA, Fallthrough, Transfer, Args);

ArgElemTypes, *

, RegResults);

(!RegResults.empty()) {

(llvm::BasicBlock *Dest : CBR->getIndirectDests()) {

llvm::Twine SynthName = Dest->getName() +

;

llvm::IRBuilderBase::InsertPointGuard IPG(

);

.SetInsertPoint(SynthBB);

(ResultRegTypes.size() == 1) {

CBRRegResults[SynthBB].push_back(CBR);

(

j = 0, e = ResultRegTypes.size(); j != e; ++j) {

llvm::Value *Tmp =

.CreateExtractValue(CBR, j,

);

CBRRegResults[SynthBB].push_back(Tmp);

CBR->setIndirectDest(i++, SynthBB);

}

(HasUnwindClobber) {

ArgElemTypes, *

, RegResults);

llvm::CallInst *

=

ArgElemTypes, *

, RegResults);

(*

, S, RegResults, ResultRegTypes, ResultTruncRegTypes,

ResultRegDests, ResultRegQualTys, ResultTypeRequiresCast,

ResultRegIsFlagReg);

(IsGCCAsmGoto && !CBRRegResults.empty()) {

(llvm::BasicBlock *Succ : CBR->getIndirectDests()) {

llvm::IRBuilderBase::InsertPointGuard IPG(

);

.SetInsertPoint(Succ, --(Succ->end()));

(*

, S, CBRRegResults[Succ], ResultRegTypes,

ResultTruncRegTypes, ResultRegDests, ResultRegQualTys,

ResultTypeRequiresCast, ResultRegIsFlagReg);

*RD = S.getCapturedRecordDecl();

= S.capture_init_end();

I !=

; ++I, ++CurField) {

(CurField->hasCapturedVLAType()) {

CGCapturedStmtRAII CapInfoRAII(CGF,

CGCapturedStmtInfo(S, K));

llvm::Function *F = CGF.GenerateCapturedStmtFunction(S);

CGF.CapturedStmtInfo;

);

*RD = S.getCapturedRecordDecl();

assert(CD->

() &&

);

llvm::Function::Create(FuncLLVMTy, llvm::GlobalValue::InternalLinkage,

F->addFnAttr(llvm::Attribute::NoUnwind);

(

*FD : RD->

()) {

(FD->hasCapturedVLAType()) {

VAT = FD->getCapturedVLAType();

VLASizeMap[VAT->getSizeExpr()] = ExprArg;

(

&I : *BB) {

(

*CI = dyn_cast<llvm::ConvergenceControlInst>(&I))

CodeGenFunction::addConvergenceControlToken(llvm::CallBase *Input) {

assert(ParentToken);

llvm::Value *bundleArgs[] = {ParentToken};

llvm::OperandBundleDef OB(

, bundleArgs);

*Output = llvm::CallBase::addOperandBundle(

Input, llvm::LLVMContext::OB_convergencectrl, OB, Input->getIterator());

Input->replaceAllUsesWith(Output);

Input->eraseFromParent();

llvm::ConvergenceControlInst *

CodeGenFunction::emitConvergenceLoopToken(llvm::BasicBlock *BB) {

CGBuilderTy::InsertPoint IP =

.saveIP();

.SetInsertPoint(BB->getFirstInsertionPt());

llvm::CallBase *CB =

.CreateIntrinsic(

llvm::Intrinsic::experimental_convergence_loop, {}, {});

CB = addConvergenceControlToken(CB);

cast<llvm::ConvergenceControlInst>(CB);

llvm::ConvergenceControlInst *

CodeGenFunction::getOrEmitConvergenceEntryToken(llvm::Function *F) {

llvm::BasicBlock *BB = &F->getEntryBlock();

CGBuilderTy::InsertPoint IP =

.saveIP();

.SetInsertPoint(&BB->front());

llvm::CallBase *I =

.CreateIntrinsic(

llvm::Intrinsic::experimental_convergence_entry, {}, {});

assert(isa<llvm::IntrinsicInst>(I));

cast<llvm::ConvergenceControlInst>(I);

Defines enum values for all the target-independent builtin functions.

static std::string AddVariableConstraints(const std::string &Constraint, const Expr &AsmExpr, const TargetInfo &Target, CodeGenModule &CGM, const AsmStmt &Stmt, const bool EarlyClobber, std::string *GCCReg=nullptr)

AddVariableConstraints - Look at AsmExpr and if it is a variable declared as using a particular regis...

static bool FindCaseStatementsForValue(const SwitchStmt &S, const llvm::APSInt &ConstantCondValue, SmallVectorImpl< const Stmt * > &ResultStmts, ASTContext &C, const SwitchCase *&ResultCase)

FindCaseStatementsForValue - Find the case statement being jumped to and then invoke CollectStatement...

static llvm::ConvergenceControlInst * getConvergenceToken(llvm::BasicBlock *BB)

static void EmitHipStdParUnsupportedAsm(CodeGenFunction *CGF, const AsmStmt &S)

static std::optional< SmallVector< uint64_t, 16 > > getLikelihoodWeights(ArrayRef< Stmt::Likelihood > Likelihoods)

static llvm::MDNode * getAsmSrcLocInfo(const StringLiteral *Str, CodeGenFunction &CGF)

getAsmSrcLocInfo - Return the !srcloc metadata node to attach to an inline asm call instruction.

static std::string SimplifyConstraint(const char *Constraint, const TargetInfo &Target, SmallVectorImpl< TargetInfo::ConstraintInfo > *OutCons=nullptr)

static bool isSwiftAsyncCallee(const CallExpr *CE)

Determine if the given call uses the swiftasync calling convention.

static CSFC_Result CollectStatementsForCase(const Stmt *S, const SwitchCase *Case, bool &FoundCase, SmallVectorImpl< const Stmt * > &ResultStmts)

static void EmitAsmStores(CodeGenFunction &CGF, const AsmStmt &S, const llvm::ArrayRef< llvm::Value * > RegResults, const llvm::ArrayRef< llvm::Type * > ResultRegTypes, const llvm::ArrayRef< llvm::Type * > ResultTruncRegTypes, const llvm::ArrayRef< LValue > ResultRegDests, const llvm::ArrayRef< QualType > ResultRegQualTys, const llvm::BitVector &ResultTypeRequiresCast, const llvm::BitVector &ResultRegIsFlagReg)

static bool hasEmptyLoopBody(const LoopStmt &S)

CSFC_Result

CollectStatementsForCase - Given the body of a 'switch' statement and a constant value that is being ...

static void UpdateAsmCallInst(llvm::CallBase &Result, bool HasSideEffect, bool HasUnwindClobber, bool ReadOnly, bool ReadNone, bool NoMerge, bool NoConvergent, const AsmStmt &S, const std::vector< llvm::Type * > &ResultRegTypes, const std::vector< llvm::Type * > &ArgElemTypes, CodeGenFunction &CGF, std::vector< llvm::Value * > &RegResults)

llvm::MachO::Target Target

Defines the PrettyStackTraceEntry class, which is used to make crashes give more contextual informati...

Defines the SourceManager interface.

APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...

bool toIntegralConstant(APSInt &Result, QualType SrcTy, const ASTContext &Ctx) const

Try to convert this value to an integral constant.

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

SourceManager & getSourceManager()

QualType getTagDeclType(const TagDecl *Decl) const

Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.

QualType getRecordType(const RecordDecl *Decl) const

QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const

getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth,...

uint64_t getTypeSize(QualType T) const

Return the size of the specified (complete) type T, in bits.

AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.

Attr - This represents one attribute.

Represents an attribute applied to a statement.

BreakStmt - This represents a break.

CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

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

ImplicitParamDecl * getContextParam() const

Retrieve the parameter containing captured variables.

param_iterator param_end() const

Retrieve an iterator one past the last parameter decl.

param_iterator param_begin() const

Retrieve an iterator pointing to the first parameter decl.

Stmt * getBody() const override

getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...

This captures a statement into a function.

Expr *const * const_capture_init_iterator

Const iterator that walks over the capture initialization arguments.

CapturedRegionKind getCapturedRegionKind() const

Retrieve the captured region kind.

CaseStmt - Represent a case statement.

bool hasProfileClangInstr() const

Check if Clang profile instrumenation is on.

bool hasReducedDebugInfo() const

Check if type and variable info should be emitted.

ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to ...

@ Indirect

Indirect - Pass the argument indirectly via a hidden pointer with the specified alignment (0 indicate...

Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...

llvm::Value * emitRawPointer(CodeGenFunction &CGF) const

Return the pointer contained in this class after authenticating it and adding offset to it if necessa...

llvm::Type * getElementType() const

Return the type of the values stored in this address.

Address withElementType(llvm::Type *ElemTy) const

Return address with different element type, but same pointer and alignment.

llvm::PointerType * getType() const

Return the type of the pointer value.

static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)

forAddr - Make a slot for an aggregate value.

A scoped helper to set the current debug location to the specified location or preferred location of ...

static ApplyDebugLocation CreateEmpty(CodeGenFunction &CGF)

Set the IRBuilder to not attach debug locations.

llvm::StoreInst * CreateFlagStore(bool Value, llvm::Value *Addr)

Emit a store to an i1 flag variable.

llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)

llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")

This class gathers all debug information during compilation and is responsible for emitting to llvm g...

CGFunctionInfo - Class to encapsulate the information about a function definition.

ABIArgInfo & getReturnInfo()

CallingConv getASTCallingConvention() const

getASTCallingConvention() - Return the AST-specified calling convention.

virtual Address getAddressOfLocalVariable(CodeGenFunction &CGF, const VarDecl *VD)

Gets the OpenMP-specific address of the local variable.

virtual llvm::Value * getContextValue() const

virtual void setContextValue(llvm::Value *V)

bool isCXXThisExprCaptured() const

virtual FieldDecl * getThisFieldDecl() const

virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S)

Emit the captured statement body.

virtual StringRef getHelperName() const

Get the name of the capture helper.

void rescopeLabels()

Change the cleanup scope of the labels in this lexical scope to match the scope of the enclosing cont...

void addLabel(const LabelDecl *label)

CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...

void EmitGotoStmt(const GotoStmt &S)

void EmitOMPTargetTeamsDirective(const OMPTargetTeamsDirective &S)

void FinishFunction(SourceLocation EndLoc=SourceLocation())

FinishFunction - Complete IR generation of the current function.

void EmitOMPParallelGenericLoopDirective(const OMPLoopDirective &S)

void EmitOMPMaskedTaskLoopSimdDirective(const OMPMaskedTaskLoopSimdDirective &S)

bool checkIfLoopMustProgress(const Expr *, bool HasEmptyBody)

Returns true if a loop must make progress, which means the mustprogress attribute can be added.

static TypeEvaluationKind getEvaluationKind(QualType T)

getEvaluationKind - Return the TypeEvaluationKind of QualType T.

static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)

ContainsLabel - Return true if the statement contains a label in it.

void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount, Stmt::Likelihood LH=Stmt::LH_None, const Expr *ConditionalOp=nullptr)

EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.

JumpDest getJumpDestInCurrentScope(llvm::BasicBlock *Target)

The given basic block lies in the current EH scope, but may be a target of a potentially scope-crossi...

void EmitSehCppScopeBegin()

void EmitIfStmt(const IfStmt &S)

void EmitWhileStmt(const WhileStmt &S, ArrayRef< const Attr * > Attrs={})

void EmitOMPOrderedDirective(const OMPOrderedDirective &S)

void EmitOMPTargetDirective(const OMPTargetDirective &S)

llvm::DenseMap< const VarDecl *, llvm::Value * > NRVOFlags

A mapping from NRVO variables to the flags used to indicate when the NRVO has been applied to this va...

bool IsOutlinedSEHHelper

True if the current function is an outlined SEH helper.

void EmitOMPAtomicDirective(const OMPAtomicDirective &S)

void EmitOMPTargetEnterDataDirective(const OMPTargetEnterDataDirective &S)

void EmitOMPParallelMasterTaskLoopDirective(const OMPParallelMasterTaskLoopDirective &S)

Address EmitCompoundStmtWithoutScope(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())

void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)

EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...

void EmitOMPReverseDirective(const OMPReverseDirective &S)

static bool hasScalarEvaluationKind(QualType T)

void EmitOpenACCExitDataConstruct(const OpenACCExitDataConstruct &S)

CGCapturedStmtInfo * CapturedStmtInfo

void EmitIndirectGotoStmt(const IndirectGotoStmt &S)

void EmitDecl(const Decl &D)

EmitDecl - Emit a declaration.

void EmitCXXTryStmt(const CXXTryStmt &S)

bool EmitSimpleStmt(const Stmt *S, ArrayRef< const Attr * > Attrs)

EmitSimpleStmt - Try to emit a "simple" statement which does not necessarily require an insertion poi...

void EmitLabel(const LabelDecl *D)

EmitLabel - Emit the block for the given label.

void EmitOpenACCInitConstruct(const OpenACCInitConstruct &S)

void EmitOMPTeamsDistributeParallelForDirective(const OMPTeamsDistributeParallelForDirective &S)

void EmitOMPTaskDirective(const OMPTaskDirective &S)

void EmitOMPScanDirective(const OMPScanDirective &S)

void EmitOMPTaskLoopDirective(const OMPTaskLoopDirective &S)

void EmitOMPMasterTaskLoopSimdDirective(const OMPMasterTaskLoopSimdDirective &S)

SmallVector< llvm::ConvergenceControlInst *, 4 > ConvergenceTokenStack

Stack to track the controlled convergence tokens.

LValue EmitLValue(const Expr *E, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)

EmitLValue - Emit code to compute a designator that specifies the location of the expression.

void EmitCaseStmt(const CaseStmt &S, ArrayRef< const Attr * > Attrs)

llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)

createBasicBlock - Create an LLVM basic block.

void EmitDefaultStmt(const DefaultStmt &S, ArrayRef< const Attr * > Attrs)

const LangOptions & getLangOpts() const

void EmitOMPDistributeSimdDirective(const OMPDistributeSimdDirective &S)

void EmitOMPDistributeParallelForDirective(const OMPDistributeParallelForDirective &S)

LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)

EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference,...

void EmitOpenACCShutdownConstruct(const OpenACCShutdownConstruct &S)

void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)

EmitBlock - Emit the given block.

bool InNoConvergentAttributedStmt

True if the current statement has noconvergent attribute.

void EmitOMPInterchangeDirective(const OMPInterchangeDirective &S)

void EmitObjCAtThrowStmt(const ObjCAtThrowStmt &S)

void EmitOMPTeamsGenericLoopDirective(const OMPTeamsGenericLoopDirective &S)

void EmitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective &S)

SmallVector< llvm::OperandBundleDef, 1 > getBundlesForFunclet(llvm::Value *Callee)

void EmitOpenACCWaitConstruct(const OpenACCWaitConstruct &S)

llvm::Value * EmitCheckedArgForAssume(const Expr *E)

Emits an argument for a call to a __builtin_assume.

void EmitOMPParallelMaskedTaskLoopDirective(const OMPParallelMaskedTaskLoopDirective &S)

void SimplifyForwardingBlocks(llvm::BasicBlock *BB)

SimplifyForwardingBlocks - If the given basic block is only a branch to another basic block,...

RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)

EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...

void EmitOMPParallelDirective(const OMPParallelDirective &S)

void EmitAnyExprToMem(const Expr *E, Address Location, Qualifiers Quals, bool IsInitializer)

EmitAnyExprToMem - Emits the code necessary to evaluate an arbitrary expression into the given memory...

void EmitBlockAfterUses(llvm::BasicBlock *BB)

EmitBlockAfterUses - Emit the given block somewhere hopefully near its uses, and leave the insertion ...

void EmitContinueStmt(const ContinueStmt &S)

void EmitIgnoredExpr(const Expr *E)

EmitIgnoredExpr - Emit an expression in a context which ignores the result.

bool InNoMergeAttributedStmt

True if the current statement has nomerge attribute.

llvm::Type * ConvertTypeForMem(QualType T)

void EmitOMPDistributeParallelForSimdDirective(const OMPDistributeParallelForSimdDirective &S)

LValue MakeAddrLValueWithoutTBAA(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)

void EmitOMPForSimdDirective(const OMPForSimdDirective &S)

JumpDest ReturnBlock

ReturnBlock - Unified return block.

LValue EmitLValueForField(LValue Base, const FieldDecl *Field)

RawAddress CreateMemTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)

CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...

void EmitOMPFlushDirective(const OMPFlushDirective &S)

void EmitOMPMaskedTaskLoopDirective(const OMPMaskedTaskLoopDirective &S)

void EmitSEHLeaveStmt(const SEHLeaveStmt &S)

void EmitAttributedStmt(const AttributedStmt &S)

void EmitOMPCancelDirective(const OMPCancelDirective &S)

void EmitOMPGenericLoopDirective(const OMPGenericLoopDirective &S)

void EmitOMPTargetTeamsDistributeDirective(const OMPTargetTeamsDistributeDirective &S)

void EmitCaseStmtRange(const CaseStmt &S, ArrayRef< const Attr * > Attrs)

const TargetInfo & getTarget() const

void EmitOMPTaskgroupDirective(const OMPTaskgroupDirective &S)

llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Location)

Converts Location to a DebugLoc, if debug information is enabled.

void EmitCXXForRangeStmt(const CXXForRangeStmt &S, ArrayRef< const Attr * > Attrs={})

llvm::Value * getTypeSize(QualType Ty)

Returns calculated size of the specified type.

void EmitLabelStmt(const LabelStmt &S)

void EmitOMPDepobjDirective(const OMPDepobjDirective &S)

const Expr * RetExpr

If a return statement is being visited, this holds the return statment's result expression.

void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init)

void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)

EmitComplexExprIntoLValue - Emit the given expression of complex type and place its result into the s...

void EmitOMPSingleDirective(const OMPSingleDirective &S)

void EmitOMPTargetTeamsGenericLoopDirective(const OMPTargetTeamsGenericLoopDirective &S)

void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S)

void EmitSimpleOMPExecutableDirective(const OMPExecutableDirective &D)

Emit simple code for OpenMP directives in Simd-only mode.

void EmitForStmt(const ForStmt &S, ArrayRef< const Attr * > Attrs={})

void EmitOMPDistributeDirective(const OMPDistributeDirective &S)

void EmitOpenACCCombinedConstruct(const OpenACCCombinedConstruct &S)

RValue EmitAnyExpr(const Expr *E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)

EmitAnyExpr - Emit code to compute the specified expression which can have any type.

void EmitOMPParallelForDirective(const OMPParallelForDirective &S)

void EmitOMPTeamsDirective(const OMPTeamsDirective &S)

uint64_t getCurrentProfileCount()

Get the profiler's current count.

void StartFunction(GlobalDecl GD, QualType RetTy, llvm::Function *Fn, const CGFunctionInfo &FnInfo, const FunctionArgList &Args, SourceLocation Loc=SourceLocation(), SourceLocation StartLoc=SourceLocation())

Emit code for the start of a function.

void EmitOMPUnrollDirective(const OMPUnrollDirective &S)

void EmitOMPParallelMasterTaskLoopSimdDirective(const OMPParallelMasterTaskLoopSimdDirective &S)

void EmitOMPTargetDataDirective(const OMPTargetDataDirective &S)

bool HaveInsertPoint() const

HaveInsertPoint - True if an insertion point is defined.

llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)

Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...

void EmitSwitchStmt(const SwitchStmt &S)

CGDebugInfo * getDebugInfo()

void EmitOMPTargetTeamsDistributeParallelForSimdDirective(const OMPTargetTeamsDistributeParallelForSimdDirective &S)

void EmitOMPTeamsDistributeParallelForSimdDirective(const OMPTeamsDistributeParallelForSimdDirective &S)

void EmitBranch(llvm::BasicBlock *Block)

EmitBranch - Emit a branch to the specified basic block from the current insert block,...

void EmitOpenACCDataConstruct(const OpenACCDataConstruct &S)

llvm::Function * GenerateCapturedStmtFunction(const CapturedStmt &S)

void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy, AggValueSlot::Overlap_t MayOverlap, bool isVolatile=false)

EmitAggregateCopy - Emit an aggregate copy.

void EmitSEHTryStmt(const SEHTryStmt &S)

void EmitOMPInteropDirective(const OMPInteropDirective &S)

const TargetCodeGenInfo & getTargetHooks() const

LValue MakeNaturalAlignRawAddrLValue(llvm::Value *V, QualType T)

RValue EmitReferenceBindingToExpr(const Expr *E)

Emits a reference binding to the passed in expression.

void EmitAggExpr(const Expr *E, AggValueSlot AS)

EmitAggExpr - Emit the computation of the specified expression of aggregate type.

void EmitDeclStmt(const DeclStmt &S)

void EmitOMPScopeDirective(const OMPScopeDirective &S)

bool InNoInlineAttributedStmt

True if the current statement has noinline attribute.

void EmitOMPTargetParallelDirective(const OMPTargetParallelDirective &S)

void EmitOMPParallelMaskedDirective(const OMPParallelMaskedDirective &S)

void EmitCoroutineBody(const CoroutineBodyStmt &S)

Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())

void EmitOMPParallelForSimdDirective(const OMPParallelForSimdDirective &S)

ASTContext & getContext() const

void EmitOpenACCLoopConstruct(const OpenACCLoopConstruct &S)

void EmitBranchThroughCleanup(JumpDest Dest)

EmitBranchThroughCleanup - Emit a branch from the current insert block through the normal cleanup han...

bool ConstantFoldsToSimpleInteger(const Expr *Cond, bool &Result, bool AllowLabels=false)

ConstantFoldsToSimpleInteger - If the specified expression does not fold to a constant,...

void EmitStmt(const Stmt *S, ArrayRef< const Attr * > Attrs={})

EmitStmt - Emit the code for the statement.

void EmitOMPTileDirective(const OMPTileDirective &S)

JumpDest getJumpDestForLabel(const LabelDecl *S)

getBasicBlockForLabel - Return the LLVM basicblock that the specified label maps to.

void EmitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt &S)

llvm::Function * EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K)

void EmitOMPParallelMaskedTaskLoopSimdDirective(const OMPParallelMaskedTaskLoopSimdDirective &S)

llvm::Type * ConvertType(QualType T)

void EmitOMPSectionsDirective(const OMPSectionsDirective &S)

void EmitOpenACCEnterDataConstruct(const OpenACCEnterDataConstruct &S)

llvm::CallBase * EmitCallOrInvoke(llvm::FunctionCallee Callee, ArrayRef< llvm::Value * > Args, const Twine &Name="")

HLSLControlFlowHintAttr::Spelling HLSLControlFlowAttr

HLSL Branch attribute.

void EmitDoStmt(const DoStmt &S, ArrayRef< const Attr * > Attrs={})

bool InAlwaysInlineAttributedStmt

True if the current statement has always_inline attribute.

void EmitOMPTargetSimdDirective(const OMPTargetSimdDirective &S)

void EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &S)

void EmitOpenACCComputeConstruct(const OpenACCComputeConstruct &S)

void EmitOMPSimdDirective(const OMPSimdDirective &S)

void EmitOMPCriticalDirective(const OMPCriticalDirective &S)

void EmitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt &S)

void EmitOMPForDirective(const OMPForDirective &S)

void EmitOMPMetaDirective(const OMPMetaDirective &S)

llvm::Value * EvaluateExprAsBool(const Expr *E)

EvaluateExprAsBool - Perform the usual unary conversions on the specified expression and compare the ...

void EmitOMPTargetUpdateDirective(const OMPTargetUpdateDirective &S)

LValue InitCapturedStruct(const CapturedStmt &S)

void EmitOMPParallelMasterDirective(const OMPParallelMasterDirective &S)

void EmitReturnStmt(const ReturnStmt &S)

unsigned NextCleanupDestIndex

AggValueSlot::Overlap_t getOverlapForReturnValue()

Determine whether a return value slot may overlap some other object.

void EmitOMPTargetTeamsDistributeSimdDirective(const OMPTargetTeamsDistributeSimdDirective &S)

void EmitOMPMasterDirective(const OMPMasterDirective &S)

void EmitOpenACCHostDataConstruct(const OpenACCHostDataConstruct &S)

void EmitOMPMasterTaskLoopDirective(const OMPMasterTaskLoopDirective &S)

void EmitOpenACCUpdateConstruct(const OpenACCUpdateConstruct &S)

void EmitOMPTargetParallelGenericLoopDirective(const OMPTargetParallelGenericLoopDirective &S)

void EmitOMPAssumeDirective(const OMPAssumeDirective &S)

static bool mightAddDeclToScope(const Stmt *S)

Determine if the given statement might introduce a declaration into the current scope,...

void EmitOMPMaskedDirective(const OMPMaskedDirective &S)

uint64_t getProfileCount(const Stmt *S)

Get the profiler's count for the given statement.

static bool hasAggregateEvaluationKind(QualType T)

void EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S)

void EmitOMPTargetParallelForSimdDirective(const OMPTargetParallelForSimdDirective &S)

LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)

void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)

EmitStoreOfComplex - Store a complex number into the specified l-value.

void EmitBreakStmt(const BreakStmt &S)

Address GenerateCapturedStmtArgument(const CapturedStmt &S)

void EmitLambdaVLACapture(const VariableArrayType *VAT, LValue LV)

const CallExpr * MustTailCall

const CGFunctionInfo * CurFnInfo

bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const

isObviouslyBranchWithoutCleanups - Return true if a branch to the specified destination obviously has...

Address GetAddrOfLocalVar(const VarDecl *VD)

GetAddrOfLocalVar - Return the address of a local variable.

void EmitCoreturnStmt(const CoreturnStmt &S)

void EmitOpenACCSetConstruct(const OpenACCSetConstruct &S)

Address ReturnValue

ReturnValue - The temporary alloca to hold the return value.

void EmitOMPTargetExitDataDirective(const OMPTargetExitDataDirective &S)

void EmitOMPErrorDirective(const OMPErrorDirective &S)

void EmitOMPSectionDirective(const OMPSectionDirective &S)

void EmitOMPBarrierDirective(const OMPBarrierDirective &S)

void EmitStopPoint(const Stmt *S)

EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.

void EmitOMPCancellationPointDirective(const OMPCancellationPointDirective &S)

void EnsureInsertPoint()

EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go.

void EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S)

llvm::LLVMContext & getLLVMContext()

void EmitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective &S)

bool SawAsmBlock

Whether we processed a Microsoft-style asm block during CodeGen.

llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)

EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...

void ResolveBranchFixups(llvm::BasicBlock *Target)

void EmitOMPTargetTeamsDistributeParallelForDirective(const OMPTargetTeamsDistributeParallelForDirective &S)

void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)

Increment the profiler's counter for the given statement by StepV.

void EmitOMPParallelSectionsDirective(const OMPParallelSectionsDirective &S)

void EmitOMPCanonicalLoop(const OMPCanonicalLoop *S)

Emit an OMPCanonicalLoop using the OpenMPIRBuilder.

void EmitOMPTeamsDistributeSimdDirective(const OMPTeamsDistributeSimdDirective &S)

llvm::BasicBlock * GetIndirectGotoBlock()

void EmitAsmStmt(const AsmStmt &S)

void EmitObjCAtTryStmt(const ObjCAtTryStmt &S)

void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource Source=AlignmentSource::Type, bool isInit=false, bool isNontemporal=false)

EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...

void EmitOMPTargetParallelForDirective(const OMPTargetParallelForDirective &S)

static bool containsBreak(const Stmt *S)

containsBreak - Return true if the statement contains a break out of it.

This class organizes the cross-function state that is used while generating LLVM code.

void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI)

Set the attributes on the LLVM function for the given decl and function info.

llvm::Module & getModule() const

DiagnosticsEngine & getDiags() const

void ErrorUnsupported(const Stmt *S, const char *Type)

Print out an error that codegen doesn't support the specified stmt yet.

const LangOptions & getLangOpts() const

CodeGenTypes & getTypes()

const llvm::DataLayout & getDataLayout() const

void Error(SourceLocation loc, StringRef error)

Emit a general error that something can't be done.

bool shouldEmitConvergenceTokens() const

CGOpenMPRuntime & getOpenMPRuntime()

Return a reference to the configured OpenMP runtime.

SanitizerMetadata * getSanitizerMetadata()

ASTContext & getContext() const

const TargetCodeGenInfo & getTargetCodeGenInfo()

const CodeGenOptions & getCodeGenOpts() const

llvm::LLVMContext & getLLVMContext()

llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys={})

void assignRegionCounters(GlobalDecl GD, llvm::Function *Fn)

Assign counters to regions and configure them for PGO of a given function.

void markStmtMaybeUsed(const Stmt *S)

void setCurrentStmt(const Stmt *S)

If the execution count for the current statement is known, record that as the current count.

bool haveRegionCounts() const

Whether or not we have PGO region data for the current function.

llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)

GetFunctionType - Get the LLVM function type for.

const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)

A builtin function is a freestanding function using the default C conventions.

A saved depth on the scope stack.

bool encloses(stable_iterator I) const

Returns true if this scope encloses I.

static stable_iterator invalid()

stable_iterator getInnermostNormalCleanup() const

Returns the innermost normal cleanup on the stack, or stable_end() if there are no normal cleanups.

stable_iterator stable_begin() const

Create a stable reference to the top of the EH stack.

bool empty() const

Determines whether the exception-scopes stack is empty.

bool hasNormalCleanups() const

Determines whether there are any normal cleanups on the stack.

static stable_iterator stable_end()

Create a stable reference to the bottom of the EH stack.

FunctionArgList - Type for representing both the decl and type of parameters to a function.

LValue - This represents an lvalue references.

llvm::Value * getPointer(CodeGenFunction &CGF) const

Address getAddress() const

void pop()

End the current loop.

void push(llvm::BasicBlock *Header, const llvm::DebugLoc &StartLoc, const llvm::DebugLoc &EndLoc)

Begin a new structured loop.

RValue - This trivial value class is used to represent the result of an expression that is evaluated.

static RValue get(llvm::Value *V)

Address getAggregateAddress() const

getAggregateAddr() - Return the Value* of the address of the aggregate.

llvm::Value * getScalarVal() const

getScalarVal() - Return the Value* of this scalar value.

std::pair< llvm::Value *, llvm::Value * > getComplexVal() const

getComplexVal - Return the real/imag components of this complex value.

virtual void addReturnRegisterOutputs(CodeGen::CodeGenFunction &CGF, CodeGen::LValue ReturnValue, std::string &Constraints, std::vector< llvm::Type * > &ResultRegTypes, std::vector< llvm::Type * > &ResultTruncRegTypes, std::vector< CodeGen::LValue > &ResultRegDests, std::string &AsmString, unsigned NumOutputs) const

Adds constraints and types for result registers.

virtual bool isScalarizableAsmOperand(CodeGen::CodeGenFunction &CGF, llvm::Type *Ty) const

Target hook to decide whether an inline asm operand can be passed by value.

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

Stmt *const * const_body_iterator

ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...

ContinueStmt - This represents a continue.

specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...

A reference to a declared variable, function, enum, etc.

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

SourceLocation getBodyRBrace() const

getBodyRBrace - Gets the right brace of the body, if a body exists.

virtual bool hasBody() const

Returns true if this Decl represents a declaration for a body of code, such as a function or method d...

SourceLocation getLocation() const

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

DoStmt - This represents a 'do/while' stmt.

This represents one expression.

bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const

EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...

Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY

Skip past any parentheses and casts which do not change the value (including ptr->int casts of the sa...

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

EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.

Expr * IgnoreParens() LLVM_READONLY

Skip past any parentheses which might surround this expression until reaching a fixed point.

bool isEvaluatable(const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const

isEvaluatable - Call EvaluateAsRValue to see if this expression can be constant folded without side-e...

bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const

EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...

bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const

HasSideEffects - This routine returns true for all those expressions which have any effect other than...

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

Represents a member of a struct/union/class.

ForStmt - This represents a 'for (init;cond;inc)' stmt.

const Expr * getSubExpr() const

FunctionType - C99 6.7.5.3 - Function Declarators.

CallingConv getCallConv() const

This represents a GCC inline-assembly statement extension.

GlobalDecl - represents a global declaration.

GotoStmt - This represents a direct goto.

IfStmt - This represents an if/then/else.

IndirectGotoStmt - This represents an indirect goto.

Represents the declaration of a label.

LabelStmt - Represents a label, which has a substatement.

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

bool assumeFunctionsAreConvergent() const

Represents a point when we exit a loop.

If a crash happens while one of these objects are live, the message is printed out along with the spe...

A (possibly-)qualified type.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

QualType getCanonicalType() const

The collection of all-type qualifiers we support.

Represents a struct/union/class.

field_range fields() const

field_iterator field_begin() const

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

Scope - A scope is a transient data structure that is used while parsing the program.

Encodes a location in the source.

UIntTy getRawEncoding() const

When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it.

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.

StmtClass getStmtClass() const

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 const Attr * getLikelihoodAttr(const Stmt *S)

SourceLocation getBeginLoc() const LLVM_READONLY

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

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

SourceLocation getBeginLoc() const LLVM_READONLY

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

const SwitchCase * getNextSwitchCase() const

SwitchStmt - This represents a 'switch' stmt.

Exposes information about the current target.

bool validateInputConstraint(MutableArrayRef< ConstraintInfo > OutputConstraints, ConstraintInfo &info) const

StringRef getNormalizedGCCRegisterName(StringRef Name, bool ReturnCanonical=false) const

Returns the "normalized" GCC register name.

bool validateOutputConstraint(ConstraintInfo &Info) const

virtual std::string_view getClobbers() const =0

Returns a string of target-specific clobbers, in LLVM format.

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

const T * castAs() const

Member-template castAs<specific type>.

bool isReferenceType() const

QualType getPointeeType() const

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

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.

StorageClass getStorageClass() const

Returns the storage class as written in the source.

WhileStmt - This represents a 'while' stmt.

Defines the clang::TargetInfo interface.

bool Rem(InterpState &S, CodePtr OpPC)

1) Pops the RHS from the stack.

bool Ret(InterpState &S, CodePtr &PC)

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

CapturedRegionKind

The different kinds of captured statement.

@ Asm

Assembly: we accept this only so that we can preprocess it.

@ Result

The result type of a method or function.

Diagnostic wrappers for TextAPI types for error reporting.

cl::opt< bool > EnableSingleByteCoverage

A jump destination is an abstract label, branching to which may require a jump out through normal cle...

void setScopeDepth(EHScopeStack::stable_iterator depth)

EHScopeStack::stable_iterator getScopeDepth() const

llvm::IntegerType * Int64Ty

llvm::IntegerType * IntPtrTy

llvm::PointerType * Int8PtrTy

EvalResult is a struct with detailed info about an evaluated expression.

APValue Val

Val - This is the value the expression can be folded to.

bool hasMatchingInput() const

Return true if this output operand has a matching (tied) input operand.

unsigned getTiedOperand() const

bool allowsMemory() const

bool requiresImmediateConstant() const

bool hasTiedOperand() const

Return true if this input operand is a matching constraint that ties it to an output operand.

bool allowsRegister() const

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