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

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

clang: lib/CodeGen/CGException.cpp Source File

;

CodeGen;

llvm::FunctionType *FTy =

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.

,

);

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.

,

);

llvm::FunctionType *FTy =

llvm::FunctionType *FTy =

llvm::FunctionType::get(

,

);

name =

;

name =

;

name =

;

name =

;

llvm::FunctionType *FTy =

llvm::Triple &

=

.getTriple();

(

.isWindowsMSVCEnvironment())

llvm::Triple &

=

.getTriple();

(

.isWindowsMSVCEnvironment())

(

.isOSCygMing())

llvm_unreachable(

);

llvm::Triple &

=

.getTriple();

(

.isWindowsMSVCEnvironment())

(

.getTriple().isWindowsMSVCEnvironment())

llvm_unreachable(

);

(

.getArch() == llvm::Triple::x86)

(CGF.

, dyn_cast_or_null<FunctionDecl>(FD));

llvm::AttributeList(),

);

cast<llvm::Constant>(Fn.getCallee());

(

I = 0,

= LPI->getNumClauses(); I !=

; ++I) {

llvm::Value *Val = LPI->getClause(I)->stripPointerCasts();

(LPI->isCatch(I)) {

(llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Val))

(GV->getName().starts_with(

))

llvm::Constant *CVal = cast<llvm::Constant>(Val);

(llvm::User::op_iterator

II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II) {

(llvm::GlobalVariable *GV =

cast<llvm::GlobalVariable>((*II)->stripPointerCasts()))

(GV->getName().starts_with(

))

(llvm::User *

: Fn->users()) {

(llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(

)) {

(CE->getOpcode() != llvm::Instruction::BitCast)

;

llvm::Function *F = dyn_cast<llvm::Function>(

);

(!F)

;

(

BB = F->begin(),

= F->end(); BB !=

; ++BB) {

(BB->isLandingPad())

CodeGenModule::SimplifyPersonality() {

(!LangOpts.CPlusPlus || !LangOpts.ObjC || !LangOpts.Exceptions)

assert(std::strcmp(

.PersonalityFn,

.PersonalityFn) != 0 &&

);

(!Fn ||

->use_empty())

;

(

->getType() != CXXFn.getCallee()->getType())

->replaceAllUsesWith(CXXFn.getCallee());

->eraseFromParent();

llvm::ConstantPointerNull::get(CGF.

);

FreeException(llvm::Value *exn) : exn(exn) {}

cleanup, cast<llvm::Instruction>(typedAddr.

(*

)));

KeepInsertionPoint) {

llvm::Triple &

=

.getTriple();

(

.

().OpenMPIsTargetDevice && (

.isNVPTX() ||

.isAMDGCN())) {

(

*SubExpr =

->getSubExpr()) {

ThrowType = SubExpr->getType();

*ThrowStmt =

->getSubExpr();

(KeepInsertionPoint)

* FD = dyn_cast_or_null<FunctionDecl>(

);

(

* CD = dyn_cast_or_null<CapturedDecl>(

)) {

diag::warn_wasm_dynamic_exception_spec_ignored)

diag::warn_wasm_dynamic_exception_spec_ignored)

(

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

->setFilter(I, EHType);

(!dispatchBlock)

;

(dispatchBlock->use_empty()) {

dispatchBlock;

llvm::BasicBlock *unexpectedBB = CGF.

(

);

llvm::Value *zero = CGF.

.getInt32(0);

llvm::Value *failsFilter =

CGF.

.CreateICmpSLT(selector, zero,

);

CGF.

.CreateCondBr(failsFilter, unexpectedBB,

->setDoesNotReturn();

CGF.

.CreateUnreachable();

* FD = dyn_cast_or_null<FunctionDecl>(

);

(

* CD = dyn_cast_or_null<CapturedDecl>(

)) {

llvm::Triple &

=

.getTriple();

IsTargetDevice =

(

.

().OpenMPIsTargetDevice && (

.isNVPTX() ||

.isAMDGCN()));

NumHandlers = S.getNumHandlers();

(

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

(

->getExceptionDecl()) {

->getCaughtType().getNonReferenceType(), CaughtTypeQuals);

CaughtType,

->getCaughtType());

(!dispatchBlock) {

dispatchBlock;

DispatchBlock;

DispatchBlock->setName(

);

DispatchBlock->setName(

);

llvm_unreachable(

);

DispatchBlock->setName(

);

DispatchBlock;

(S.getKind()) {

!cast<EHCleanupScope>(S).isEHCleanup();

llvm_unreachable(

);

(!LO.Exceptions || LO.IgnoreExceptions) {

(!LO.Borland && !LO.MicrosoftExt)

(LO.CUDA && LO.CUDAIsDevice)

(!

->hasPersonalityFn())

ir->setCachedLandingPad(LP);

(innermostEHScope.

()) {

CGBuilderTy::InsertPoint savedIP =

.saveAndClearIP();

llvm::LandingPadInst *LPadInst =

llvm::Value *LPadExn =

.CreateExtractValue(LPadInst, 0);

llvm::Value *LPadSel =

.CreateExtractValue(LPadInst, 1);

hasCatchAll =

;

hasCleanup =

;

hasFilter =

;

(I->getKind()) {

hasCleanup = (hasCleanup || cast<EHCleanupScope>(*I).isEHCleanup());

assert(I.next() ==

.

() &&

);

assert(!hasCatchAll &&

);

(

i = 0, e = filter.

(); i != e; ++i)

filterTypes.push_back(filter.

(i));

assert(!hasCatchAll);

(

hi = 0, he = catchScope.

(); hi != he; ++hi) {

);

assert(!hasCatchAll);

(catchTypes.insert(handler.

.

).second)

LPadInst->addClause(handler.

.

);

assert(!(hasCatchAll && hasFilter));

}

(hasFilter) {

llvm::ArrayType *AType =

llvm::ArrayType::get(!filterTypes.empty() ?

(

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

Filters.push_back(cast<llvm::Constant>(filterTypes[i]));

llvm::Constant *FilterArray = llvm::ConstantArray::get(AType, Filters);

LPadInst->addClause(FilterArray);

LPadInst->setCleanup(

);

}

(hasCleanup) {

LPadInst->setCleanup(

);

assert((LPadInst->getNumClauses() > 0 || LPadInst->isCleanup()) &&

);

assert(DispatchBlock);

CGBuilderTy::InsertPoint SavedIP = CGF.

.saveIP();

llvm::BasicBlock *UnwindBB =

llvm::CatchSwitchInst *CatchSwitch =

CGF.

.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers);

(

I = 0; I < NumHandlers; ++I) {

llvm::Constant::getNullValue(CGF.

)});

CatchSwitch->addHandler(Handler.

);

CGF.

.restoreIP(SavedIP);

assert(DispatchBlock);

CGBuilderTy::InsertPoint SavedIP = CGF.

.saveIP();

ParentPad = llvm::ConstantTokenNone::get(CGF.

());

llvm::BasicBlock *UnwindBB =

llvm::CatchSwitchInst *CatchSwitch =

CGF.

.CreateCatchSwitch(ParentPad, UnwindBB, NumHandlers);

llvm::BasicBlock *WasmCatchStartBlock = CGF.

(

);

CatchSwitch->addHandler(WasmCatchStartBlock);

(

I = 0,

= NumHandlers; I <

; ++I) {

CatchTypes.push_back(

.RTTI);

*CPI = CGF.

.CreateCatchPad(CatchSwitch, CatchTypes);

llvm::Function *GetExnFn =

llvm::Function *GetSelectorFn =

llvm::CallInst *Exn = CGF.

.CreateCall(GetExnFn, CPI);

llvm::CallInst *

= CGF.

.CreateCall(GetSelectorFn, CPI);

llvm::Function *TypeIDFn =

CGF.

.restoreIP(SavedIP);

(

I = 0,

= NumHandlers;; ++I) {

assert(I <

&&

);

llvm::BasicBlock *NextBlock;

EmitNextBlock =

, NextIsEnd =

;

EmitNextBlock =

;

EmitNextBlock =

;

llvm::CallInst *TypeIndex = CGF.

.CreateCall(TypeIDFn,

.RTTI);

TypeIndex->setDoesNotThrow();

llvm::Value *MatchesTypeIndex =

CGF.

.CreateCondBr(MatchesTypeIndex, Handler.

, NextBlock);

CGF.

.restoreIP(SavedIP);

assert(dispatchBlock);

CGBuilderTy::InsertPoint savedIP = CGF.

.saveIP();

llvm::Function *llvm_eh_typeid_for =

llvm::Type *argTy = llvm_eh_typeid_for->getArg(0)->getType();

(

i = 0, e = catchScope.

(); ; ++i) {

assert(i < e &&

);

llvm::Value *typeValue = handler.

.

;

);

assert(typeValue &&

);

(typeValue->getType() != argTy)

llvm::BasicBlock *nextBlock;

llvm::CallInst *typeIndex =

CGF.

.CreateCall(llvm_eh_typeid_for, typeValue);

typeIndex->setDoesNotThrow();

llvm::Value *matchesTypeIndex =

CGF.

.CreateICmpEQ(selector, typeIndex,

);

CGF.

.CreateCondBr(matchesTypeIndex, handler.

, nextBlock);

CGF.

.restoreIP(savedIP);

NumHandlers = S.getNumHandlers();

CatchScope.

(), CatchScope.

() + NumHandlers);

doImplicitRethrow =

;

doImplicitRethrow = isa<CXXDestructorDecl>(

) ||

llvm::BasicBlock *WasmCatchStartBlock =

;

cast<llvm::CatchSwitchInst>(DispatchBlock->getFirstNonPHIIt());

WasmCatchStartBlock = CatchSwitch->hasUnwindDest()

? CatchSwitch->getSuccessor(1)

: CatchSwitch->getSuccessor(0);

cast<llvm::CatchPadInst>(WasmCatchStartBlock->getFirstNonPHIIt());

HasCatchAll =

;

(

I = NumHandlers; I != 0; --I) {

HasCatchAll |= Handlers[I - 1].isCatchAll();

llvm::BasicBlock *CatchBlock = Handlers[I-1].Block;

RunCleanupsScope CatchScope(*

);

.ClearInsertionPoint();

CatchScope.ForceCleanup();

assert(WasmCatchStartBlock);

llvm::BasicBlock *RethrowBlock = WasmCatchStartBlock;

(llvm::Instruction *TI = RethrowBlock->getTerminator()) {

*BI = cast<llvm::BranchInst>(TI);

assert(BI->isConditional());

RethrowBlock = BI->getSuccessor(1);

assert(RethrowBlock != WasmCatchStartBlock && RethrowBlock->empty());

.SetInsertPoint(RethrowBlock);

llvm::Function *RethrowInCatchFn =

llvm::Value *ForEHVar;

llvm::FunctionCallee EndCatchFn;

CallEndCatchForFinally(llvm::Value *ForEHVar,

llvm::FunctionCallee EndCatchFn)

: ForEHVar(ForEHVar), EndCatchFn(EndCatchFn) {}

llvm::BasicBlock *EndCatchBB = CGF.

(

);

llvm::BasicBlock *CleanupContBB =

llvm::Value *ShouldEndCatch =

CGF.

.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB);

llvm::Value *ForEHVar;

llvm::FunctionCallee EndCatchFn;

llvm::FunctionCallee RethrowFn;

llvm::Value *SavedExnVar;

PerformFinally(

*Body, llvm::Value *ForEHVar,

llvm::FunctionCallee EndCatchFn,

llvm::FunctionCallee RethrowFn, llvm::Value *SavedExnVar)

: Body(Body), ForEHVar(ForEHVar), EndCatchFn(EndCatchFn),

RethrowFn(RethrowFn), SavedExnVar(SavedExnVar) {}

ForEHVar, EndCatchFn);

llvm::Value *SavedCleanupDest =

);

llvm::Value *ShouldRethrow =

CGF.

.CreateCondBr(ShouldRethrow, RethrowBB, ContBB);

CGF.

.CreateUnreachable();

CGBuilderTy::InsertPoint SavedIP = CGF.

.saveAndClearIP();

CGF.

.restoreIP(SavedIP);

llvm::FunctionCallee beginCatchFn,

llvm::FunctionCallee endCatchFn,

llvm::FunctionCallee rethrowFn) {

assert((!!beginCatchFn) == (!!endCatchFn) &&

);

assert(rethrowFn &&

);

BeginCatchFn = beginCatchFn;

llvm::FunctionType *rethrowFnTy = rethrowFn.getFunctionType();

SavedExnVar =

;

(rethrowFnTy->getNumParams())

ForEHVar, endCatchFn,

rethrowFn, SavedExnVar);

(catchBB->use_empty()) {

CGBuilderTy::InsertPoint savedIP = CGF.

.saveAndClearIP();

llvm::Value *exn =

;

CGF.

.restoreIP(savedIP);

(TerminateLandingPad)

TerminateLandingPad;

CGBuilderTy::InsertPoint SavedIP =

.saveAndClearIP();

.SetInsertPoint(TerminateLandingPad);

(!

->hasPersonalityFn())

llvm::LandingPadInst *LPadInst =

llvm::Value *Exn =

;

Exn =

.CreateExtractValue(LPadInst, 0);

llvm::CallInst *terminateCall =

terminateCall->setDoesNotReturn();

TerminateLandingPad;

(TerminateHandler)

TerminateHandler;

CGBuilderTy::InsertPoint SavedIP =

.saveAndClearIP();

.SetInsertPoint(TerminateHandler);

llvm::Value *Exn =

;

llvm::CallInst *terminateCall =

terminateCall->setDoesNotReturn();

TerminateHandler;

);

(TerminateFunclet)

TerminateFunclet;

CGBuilderTy::InsertPoint SavedIP =

.saveAndClearIP();

.SetInsertPoint(TerminateFunclet);

llvm::CallInst *terminateCall =

terminateCall->setDoesNotReturn();

TerminateFunclet;

CGBuilderTy::InsertPoint SavedIP =

.saveIP();

(RethrowName !=

&& !isCleanup) {

llvm::Type *LPadType = llvm::StructType::get(Exn->getType(), Sel->getType());

llvm::Value *LPadVal = llvm::PoisonValue::get(LPadType);

LPadVal =

.CreateInsertValue(LPadVal, Exn, 0,

);

LPadVal =

.CreateInsertValue(LPadVal, Sel, 1,

);

.CreateResume(LPadVal);

llvm::BasicBlock *TryBB =

;

TryBB =

.GetInsertBlock();

(!TryExit.getBlock()->use_empty())

TryExit.getBlock();

!

.insert(BB).second

||

!BB->getParent()

|| BB->empty())

(!BB->isEHPad()) {

(llvm::BasicBlock::iterator J = BB->begin(), JE = BB->end(); J != JE;

(

LI = dyn_cast<llvm::LoadInst>(J)) {

LI->setVolatile(

);

}

(

SI = dyn_cast<llvm::StoreInst>(J)) {

SI->setVolatile(

);

}

(

* MCI = dyn_cast<llvm::MemIntrinsic>(J)) {

MCI->setVolatile(llvm::ConstantInt::get(

.getInt1Ty(), 1));

llvm::Instruction *TI = BB->getTerminator();

N = TI->getNumSuccessors();

(

I = 0; I < N; I++)

llvm::Function *OutlinedFinally;

PerformSEHFinally(llvm::Function *OutlinedFinally)

: OutlinedFinally(OutlinedFinally) {}

llvm::Value *FP =

;

FP = &CGF.

->arg_begin()[1];

llvm::Function *LocalAddrFn =

FP = CGF.

.CreateCall(LocalAddrFn);

llvm::Value *IsForEH =

llvm::ConstantInt::get(CGF.

(ArgTys[0]), F.isForEHCleanup());

(!F.isForEHCleanup() && F.hasExitSwitch()) {

llvm::Value *

= llvm::Constant::getNullValue(CGM.

);

IsForEH = CGF.

.CreateICmpNE(Load, Zero);

: ParentCGF(ParentCGF), ParentThis(ParentThis) {}

foundCaptures() {

!Captures.empty() || SEHCodeSlot.

();

Visit(

*S) {

(

*Child : S->children())

(

->refersToEnclosingVariableOrCapture())

Captures.insert(ParentThis);

*

= dyn_cast<VarDecl>(

->getDecl());

(

&&

->isLocalVarDeclOrParm() &&

->hasLocalStorage())

Captures.insert(

);

Captures.insert(ParentThis);

VisitCallExpr(

*

) {

=

->getBuiltinCallee();

Builtin::BI__exception_code:

Builtin::BI_exception_code:

llvm::Value *ParentFP) {

llvm::CallInst *RecoverCall =

;

(

*ParentAlloca =

dyn_cast_or_null<llvm::AllocaInst>(ParentVar.

())) {

InsertPair =

.EscapedLocals.insert(

std::make_pair(ParentAlloca,

.EscapedLocals.size()));

FrameEscapeIdx = InsertPair.first->second;

llvm::Function *FrameRecoverFn = llvm::Intrinsic::getOrInsertDeclaration(

RecoverCall =

.CreateCall(

llvm::ConstantInt::get(

, FrameEscapeIdx)});

*ParentRecover = cast<llvm::IntrinsicInst>(

assert(ParentRecover->getIntrinsicID() == llvm::Intrinsic::localrecover &&

);

RecoverCall = cast<llvm::CallInst>(ParentRecover->clone());

RecoverCall->setArgOperand(1, ParentFP);

llvm::Value *ChildVar =

ChildVar->setName(ParentVar.

());

*OutlinedStmt,

Finder.Visit(OutlinedStmt);

(!Finder.foundCaptures() &&

llvm::Value *EntryFP =

;

EntryFP =

.CreateCall(

{Builder.getInt32(1)});

AI =

->arg_begin();

llvm::Value *ParentFP = EntryFP;

llvm::Function *RecoverFPIntrin =

llvm::AllocaInst *FramePtrAddrAlloca =

;

(

&I :

.LocalDeclMap) {

*

= cast<VarDecl>(I.first);

(isa<ImplicitParamDecl>(

) &&

assert(

->getName().starts_with(

));

FramePtrAddrAlloca =

cast<llvm::AllocaInst>(I.second.getBasePointer());

assert(FramePtrAddrAlloca);

InsertPair =

.EscapedLocals.insert(

std::make_pair(FramePtrAddrAlloca,

.EscapedLocals.size()));

FrameEscapeIdx = InsertPair.first->second;

llvm::Function *FrameRecoverFn = llvm::Intrinsic::getOrInsertDeclaration(

ParentFP =

.CreateCall(

llvm::ConstantInt::get(

, FrameEscapeIdx)});

(

*VD : Finder.Captures) {

);

I =

.LocalDeclMap.find(VD);

ParentVar = I->second;

setAddrOfLocalVar(VD, Recovered);

(isa<ImplicitParamDecl>(VD)) {

CXXABIThisAlignment =

.CXXABIThisAlignment;

CXXThisAlignment =

.CXXThisAlignment;

CXXThisValue = CXXABIThisValue;

(Finder.SEHCodeSlot.isValid()) {

*OutlinedStmt) {

llvm::raw_svector_ostream OS(Name);

assert(ParentSEHFn &&

);

&

().Idents.get(

),

&

().Idents.get(

),

llvm::Function *

= llvm::Function::Create(

FnTy, llvm::GlobalValue::InternalLinkage, Name.str(), &

.

());

llvm::Value *ParentFP,

llvm::Value *EntryFP) {

llvm::Type *RecordTy = llvm::PointerType::getUnqual(

());

llvm::Type *PtrsTy = llvm::StructType::get(RecordTy,

.

);

assert(!

.empty() &&

);

llvm::UndefValue::get(

);

assert(!

.empty() &&

);

AI =

->arg_begin();

llvm::Function *FinallyFunc) {

.pushCleanup<PerformSEHFinally>(

, FinallyFunc);

HelperCGF.ParentCGF =

;

llvm::Function *FinallyFunc =

HelperCGF.GenerateSEHFinallyFunction(*

, *Finally);

llvm::Constant *

=

llvm::Function *FilterFunc =

HelperCGF.GenerateSEHFilterFunction(*

, *Except);

(S.getFinallyHandler()) {

assert(Except &&

);

llvm::CatchPadInst *CPI =

cast<llvm::CatchPadInst>(CatchPadBB->getFirstNonPHIIt());

.CreateCatchRet(CPI, ExceptBB);

llvm::Function *SEHCodeIntrin =

llvm::Value *Code =

.CreateCall(SEHCodeIntrin, {CPI});

.ClearInsertionPoint();

static llvm::FunctionCallee getUnexpectedFn(CodeGenModule &CGM)

static const EHPersonality & getObjCPersonality(const TargetInfo &Target, const LangOptions &L)

static const EHPersonality & getSEHPersonalityMSVC(const llvm::Triple &T)

static const EHPersonality & getCXXPersonality(const TargetInfo &Target, const LangOptions &L)

static llvm::FunctionCallee getPersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality)

static void emitFilterDispatchBlock(CodeGenFunction &CGF, EHFilterScope &filterScope)

Emit the dispatch block for a filter scope if necessary.

static void emitCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope)

static llvm::FunctionCallee getFreeExceptionFn(CodeGenModule &CGM)

static llvm::FunctionCallee getSehTryEndFn(CodeGenModule &CGM)

static bool LandingPadHasOnlyCXXUses(llvm::LandingPadInst *LPI)

Check whether a landingpad instruction only uses C++ features.

static bool PersonalityHasOnlyCXXUses(llvm::Constant *Fn)

Check whether a personality function could reasonably be swapped for a C++ personality function.

static void emitCatchDispatchBlock(CodeGenFunction &CGF, EHCatchScope &catchScope)

Emit the structure of the dispatch block for the given catch scope.

static llvm::Constant * getOpaquePersonalityFn(CodeGenModule &CGM, const EHPersonality &Personality)

static bool isNonEHScope(const EHScope &S)

Check whether this is a non-EH scope, i.e.

static llvm::FunctionCallee getCatchallRethrowFn(CodeGenModule &CGM, StringRef Name)

static llvm::FunctionCallee getSehTryBeginFn(CodeGenModule &CGM)

static llvm::Constant * getCatchAllValue(CodeGenFunction &CGF)

Returns the value to inject into a selector to indicate the presence of a catch-all.

static const EHPersonality & getObjCXXPersonality(const TargetInfo &Target, const LangOptions &L)

Determines the personality function to use when both C++ and Objective-C exceptions are being caught.

static void emitWasmCatchPadBlock(CodeGenFunction &CGF, EHCatchScope &CatchScope)

static const EHPersonality & getCPersonality(const TargetInfo &Target, const LangOptions &L)

llvm::DenseSet< const void * > Visited

llvm::MachO::Target Target

Defines the Objective-C statement AST node classes.

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

CanQualType UnsignedCharTy

QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const

Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.

CXXCatchStmt - This represents a C++ catch block.

Represents the this expression in C++.

A C++ throw-expression (C++ [except.throw]).

CXXTryStmt - A C++ try block, including all handlers.

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

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

static CharUnits fromQuantity(QuantityType Quantity)

fromQuantity - Construct a CharUnits quantity from a raw integer type.

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

llvm::Value * getBasePointer() const

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

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

Address withPointer(llvm::Value *NewPointer, KnownNonNull_t IsKnownNonNull) const

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

Address withElementType(llvm::Type *ElemTy) const

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

llvm::StringRef getName() const

Return the IR name of the pointer value.

llvm::PointerType * getType() const

Return the type of the pointer value.

static ApplyDebugLocation CreateDefaultArtificial(CodeGenFunction &CGF, SourceLocation TemporaryLocation)

Apply TemporaryLocation if it is valid.

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::StoreInst * CreateAlignedStore(llvm::Value *Val, llvm::Value *Addr, CharUnits Align, bool IsVolatile=false)

Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")

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

llvm::LoadInst * CreateFlagLoad(llvm::Value *Addr, const llvm::Twine &Name="")

Emit a load from an i1 flag variable.

llvm::LoadInst * CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")

virtual void emitBeginCatch(CodeGenFunction &CGF, const CXXCatchStmt *C)=0

virtual void emitRethrow(CodeGenFunction &CGF, bool isNoReturn)=0

virtual llvm::CallInst * emitTerminateForUnexpectedException(CodeGenFunction &CGF, llvm::Value *Exn)

virtual CatchTypeInfo getCatchAllTypeInfo()

virtual void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E)=0

virtual CatchTypeInfo getAddrOfCXXCatchHandlerType(QualType Ty, QualType CatchHandlerType)=0

MangleContext & getMangleContext()

Gets the mangle context.

static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())

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

virtual llvm::Constant * GetEHType(QualType T)=0

Get the type constant to catch for the given ObjC pointer type.

virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, bool ClearInsertionPoint=true)=0

CallArgList - Type for representing both the value and type of arguments in a call.

void add(RValue rvalue, QualType type)

void exit(CodeGenFunction &CGF)

void enter(CodeGenFunction &CGF, const Stmt *Finally, llvm::FunctionCallee beginCatchFn, llvm::FunctionCallee endCatchFn, llvm::FunctionCallee rethrowFn)

Enters a finally block for an implementation using zero-cost exceptions.

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

llvm::BasicBlock * getEHDispatchBlock(EHScopeStack::stable_iterator scope)

void FinishFunction(SourceLocation EndLoc=SourceLocation())

FinishFunction - Complete IR generation of the current function.

void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)

DeactivateCleanupBlock - Deactivates the given cleanup block.

void EnterSEHTryStmt(const SEHTryStmt &S)

Address getExceptionSlot()

Returns a pointer to the function's exception object and selector slot, which is assigned in every la...

void VolatilizeTryBlocks(llvm::BasicBlock *BB, llvm::SmallPtrSet< llvm::BasicBlock *, 10 > &V)

llvm::Function * GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF, const SEHFinallyStmt &Finally)

llvm::CallInst * EmitTrapCall(llvm::Intrinsic::ID IntrID)

Emit a call to trap or debugtrap and attach function attribute "trap-func-name" if specified.

llvm::Function * GenerateSEHFilterFunction(CodeGenFunction &ParentCGF, const SEHExceptStmt &Except)

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

llvm::BasicBlock * getInvokeDestImpl()

bool IsOutlinedSEHHelper

True if the current function is an outlined SEH helper.

void startOutlinedSEHHelper(CodeGenFunction &ParentCGF, bool IsFilter, const Stmt *OutlinedStmt)

SmallVector< Address, 1 > SEHCodeSlotStack

A stack of exception code slots.

FieldDecl * LambdaThisCaptureField

void EmitCXXTryStmt(const CXXTryStmt &S)

void popCatchScope()

popCatchScope - Pops the catch scope at the top of the EHScope stack, emitting any required code (oth...

void EmitEndEHSpec(const Decl *D)

EmitEndEHSpec - Emit the end of the exception spec.

void EmitAnyExprToExn(const Expr *E, Address Addr)

bool isSEHTryScope() const

Returns true inside SEH __try blocks.

void EmitSEHExceptionCodeSave(CodeGenFunction &ParentCGF, llvm::Value *ParentFP, llvm::Value *EntryEBP)

llvm::BasicBlock * getEHResumeBlock(bool isCleanup)

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

createBasicBlock - Create an LLVM basic block.

llvm::Value * EmitSEHExceptionInfo()

const LangOptions & getLangOpts() const

llvm::BasicBlock * EHResumeBlock

EHResumeBlock - Unified block containing a call to llvm.eh.resume.

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

EmitBlock - Emit the given block.

llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)

CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...

llvm::AllocaInst * EHSelectorSlot

The selector slot.

RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)

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

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

RawAddress getNormalCleanupDestSlot()

llvm::BasicBlock * getTerminateFunclet()

getTerminateLandingPad - Return a cleanup funclet that just calls terminate.

llvm::Type * ConvertTypeForMem(QualType T)

const Decl * CurCodeDecl

CurCodeDecl - This is the inner-most code context, which includes blocks.

llvm::BasicBlock * getUnreachableBlock()

llvm::AssertingVH< llvm::Instruction > AllocaInsertPt

AllocaInsertPoint - This is an instruction in the entry block before which we prefer to insert alloca...

bool currentFunctionUsesSEHTry() const

llvm::SmallVector< const JumpDest *, 2 > SEHTryEpilogueStack

CodeGenFunction * ParentCGF

llvm::Value * ExceptionSlot

The exception slot.

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 EmitSEHLeaveStmt(const SEHLeaveStmt &S)

const TargetInfo & getTarget() const

llvm::Value * EmitSEHExceptionCode()

void pushSEHCleanup(CleanupKind kind, llvm::Function *FinallyFunc)

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 EmitSehTryScopeBegin()

bool HaveInsertPoint() const

HaveInsertPoint - True if an insertion point is defined.

Address recoverAddrOfEscapedLocal(CodeGenFunction &ParentCGF, Address ParentVar, llvm::Value *ParentFP)

Recovers the address of a local in a parent function.

void EmitSEHTryStmt(const SEHTryStmt &S)

void ExitSEHTryStmt(const SEHTryStmt &S)

llvm::BasicBlock * getTerminateLandingPad()

getTerminateLandingPad - Return a landing pad that just calls terminate.

llvm::BasicBlock * getTerminateHandler()

getTerminateHandler - Return a handler (not a landing pad, just a catch handler) that just calls term...

const TargetCodeGenInfo & getTargetHooks() const

void EnterCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock=false)

void EmitStartEHSpec(const Decl *D)

EmitStartEHSpec - Emit the start of the exception spec.

RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **CallOrInvoke, bool IsMustTail, SourceLocation Loc, bool IsVirtualFunctionPointerThunk=false)

EmitCall - Generate a call of the given function, expecting the given result type,...

llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")

ASTContext & getContext() const

void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)

void EmitBranchThroughCleanup(JumpDest Dest)

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

llvm::Value * SEHInfo

Value returned by __exception_info intrinsic.

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

EmitStmt - Emit the code for the statement.

void PopCleanupBlock(bool FallThroughIsBranchThrough=false, bool ForDeactivation=false)

PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.

llvm::BasicBlock * EmitLandingPad()

Emits a landing pad for the current EH stack.

llvm::DenseMap< const ValueDecl *, FieldDecl * > LambdaCaptureFields

llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")

llvm::Type * ConvertType(QualType T)

void EmitNoreturnRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args)

llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")

void EmitCapturedLocals(CodeGenFunction &ParentCGF, const Stmt *OutlinedStmt, bool IsFilter)

Scan the outlined statement for captures from the parent function.

llvm::BasicBlock * getFuncletEHDispatchBlock(EHScopeStack::stable_iterator scope)

llvm::Value * EmitSEHAbnormalTermination()

Address ReturnValue

ReturnValue - The temporary alloca to hold the return value.

void EmitStopPoint(const Stmt *S)

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

void ExitCXXTryStmt(const CXXTryStmt &S, bool IsFnTryBlock=false)

llvm::Instruction * CurrentFuncletPad

void EnsureInsertPoint()

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

llvm::LLVMContext & getLLVMContext()

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

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

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

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

llvm::Value * getSelectorFromSlot()

llvm::Value * getExceptionFromSlot()

Returns the contents of the function's exception object and selector slots.

Address getEHSelectorSlot()

LValue EmitLValueForLambdaField(const FieldDecl *Field)

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

llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)

Create or return a runtime function declaration with the specified type and name.

llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)

Get the address of the RTTI descriptor for the given type.

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 TargetInfo & getTarget() const

CGCXXABI & getCXXABI() const

ASTContext & getContext() const

llvm::FunctionCallee getTerminateFn()

Get the declaration of std::terminate for the platform.

llvm::LLVMContext & getLLVMContext()

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

CGObjCRuntime & getObjCRuntime()

Return a reference to the configured Objective-C runtime.

LangAS GetGlobalVarAddressSpace(const VarDecl *D)

Return the AST address space of the underlying global variable for D, as determined by its declaratio...

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.

const CGFunctionInfo & arrangeBuiltinFunctionCall(QualType resultType, const CallArgList &args)

llvm::Constant * tryEmitAbstract(const Expr *E, QualType T)

Try to emit the result of the given expression as an abstract constant.

A scope which attempts to handle some, possibly all, types of exceptions.

const Handler & getHandler(unsigned I) const

void setHandler(unsigned I, llvm::Constant *Type, llvm::BasicBlock *Block)

void setCatchAllHandler(unsigned I, llvm::BasicBlock *Block)

void clearHandlerBlocks()

unsigned getNumHandlers() const

An exceptions scope which filters exceptions thrown through it.

llvm::Value * getFilter(unsigned i) const

unsigned getNumFilters() const

Information for lazily generating a cleanup.

A non-stable pointer into the scope stack.

A saved depth on the scope stack.

class EHFilterScope * pushFilter(unsigned NumFilters)

Push an exceptions filter on the stack.

stable_iterator stable_begin() const

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

stable_iterator getInnermostEHScope() const

bool requiresLandingPad() const

bool empty() const

Determines whether the exception-scopes stack is empty.

iterator end() const

Returns an iterator pointing to the outermost EH scope.

void popFilter()

Pops an exceptions filter off the stack.

iterator begin() const

Returns an iterator pointing to the innermost EH scope.

void popCatch()

Pops a catch scope off the stack. This is private to CGException.cpp.

class EHCatchScope * pushCatch(unsigned NumHandlers)

Push a set of catch handlers on the stack.

iterator find(stable_iterator save) const

Turn a stable reference to a scope depth into a unstable pointer to the EH stack.

static stable_iterator stable_end()

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

void popTerminate()

Pops a terminate handler off the stack.

void pushTerminate()

Push a terminate handler on the stack.

A protected scope for zero-cost EH handling.

llvm::BasicBlock * getCachedLandingPad() const

EHScopeStack::stable_iterator getEnclosingEHScope() const

llvm::BasicBlock * getCachedEHDispatchBlock() const

void setCachedEHDispatchBlock(llvm::BasicBlock *block)

bool hasEHBranches() const

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

LValue - This represents an lvalue references.

Address getAddress() const

static RValue get(llvm::Value *V)

llvm::Value * getScalarVal() const

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

ReturnValueSlot - Contains the address where the return value of a function can be stored,...

Address performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, Address Addr, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const

ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.

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

Decl - This represents one declaration (or definition), e.g.

SourceLocation getLocation() const

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

This represents one expression.

SourceLocation getExprLoc() const LLVM_READONLY

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

Represents a function declaration or definition.

bool usesSEHTry() const

Indicates the function uses __try.

SourceRange getExceptionSpecSourceRange() const

Attempt to compute an informative source range covering the function exception specification,...

Represents a prototype with parameter type info, e.g.

ExceptionSpecificationType getExceptionSpecType() const

Get the kind of exception specification on this function.

QualType getExceptionType(unsigned i) const

Return the ith exception type, where 0 <= i < getNumExceptions().

unsigned getNumExceptions() const

Return the number of types in the exception specification.

CanThrowResult canThrow() const

Determine whether this function type has a non-throwing exception specification.

GlobalDecl - represents a global declaration.

const Decl * getDecl() const

static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)

Create implicit parameter.

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

bool hasWasmExceptions() const

clang::ObjCRuntime ObjCRuntime

bool hasSjLjExceptions() const

bool hasDWARFExceptions() const

bool hasSEHExceptions() const

MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...

virtual void mangleSEHFilterExpression(GlobalDecl EnclosingDecl, raw_ostream &Out)=0

virtual void mangleSEHFinallyBlock(GlobalDecl EnclosingDecl, raw_ostream &Out)=0

Represents Objective-C's @throw statement.

The basic abstraction for the target Objective-C runtime.

bool hasTerminate() const

Does this runtime provide an objc_terminate function?

bool isNeXTFamily() const

Is this runtime basically of the NeXT family of runtimes?

const VersionTuple & getVersion() const

@ MacOSX

'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...

@ FragileMacOSX

'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...

@ GNUstep

'gnustep' is the modern non-fragile GNUstep runtime.

@ ObjFW

'objfw' is the Objective-C runtime included in ObjFW

@ iOS

'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...

@ GCC

'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI

@ WatchOS

'watchos' is a variant of iOS for Apple's watchOS.

A (possibly-)qualified type.

Qualifiers getQualifiers() const

Retrieve the set of qualifiers applied to this type.

QualType getNonReferenceType() const

If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...

QualType getUnqualifiedType() const

Retrieve the unqualified variant of the given type, removing as little sugar as possible.

The collection of all-type qualifiers we support.

CompoundStmt * getBlock() const

Expr * getFilterExpr() const

CompoundStmt * getBlock() const

Represents a __leave statement.

Smart pointer class that efficiently represents Objective-C method names.

Encodes a location in the source.

Stmt - This represents one statement.

SourceLocation getEndLoc() const LLVM_READONLY

SourceLocation getBeginLoc() const LLVM_READONLY

bool isMicrosoft() const

Is this ABI an MSVC-compatible ABI?

Exposes information about the current target.

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

TargetCXXABI getCXXABI() const

Get the C++ ABI currently in use.

bool isSignedIntegerType() const

Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...

bool isPointerType() const

bool isVariablyModifiedType() const

Whether this type is a variably-modified type (C99 6.7.5).

bool isObjCObjectPointerType() const

const T * getAs() const

Member-template getAs<specific type>'.

Represents a variable declaration or definition.

bool isLocalVarDeclOrParm() const

Similar to isLocalVarDecl but also includes parameters.

@ NormalCleanup

Denotes a cleanup that should run when a scope is exited using normal control flow (falling off the e...

@ EHCleanup

Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...

tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName="<stdin>")

Clean up any erroneous/redundant code in the given Ranges in Code.

bool Zero(InterpState &S, CodePtr OpPC)

bool Load(InterpState &S, CodePtr OpPC)

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

LangAS

Defines the address space values used by the address space qualifier of QualType.

const FunctionProtoType * T

@ Other

Other implicit parameter.

ExceptionSpecificationType

The various types of exception specifications that exist in C++11.

@ EST_DynamicNone

throw()

@ EST_Dynamic

throw(T1, T2)

The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler,...

llvm::PointerType * VoidPtrTy

CharUnits getIntAlign() const

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

llvm::IntegerType * Int32Ty

llvm::IntegerType * IntTy

int

llvm::PointerType * Int8PtrTy

CharUnits getPointerAlign() const

llvm::PointerType * AllocaInt8PtrTy

CatchTypeInfo Type

A type info value, or null (C++ null, not an LLVM null pointer) for a catch-all.

llvm::BasicBlock * Block

The catch handler for this type.

The exceptions personality for a function.

static const EHPersonality & get(CodeGenModule &CGM, const FunctionDecl *FD)

static const EHPersonality XL_CPlusPlus

static const EHPersonality GNU_ObjC_SJLJ

bool isWasmPersonality() const

static const EHPersonality ZOS_CPlusPlus

static const EHPersonality GNUstep_ObjC

static const EHPersonality MSVC_CxxFrameHandler3

bool usesFuncletPads() const

Does this personality use landingpads or the family of pad instructions designed to form funclets?

static const EHPersonality MSVC_C_specific_handler

static const EHPersonality GNU_CPlusPlus_SEH

static const EHPersonality GNU_ObjC

static const EHPersonality GNU_CPlusPlus_SJLJ

static const EHPersonality GNU_C_SJLJ

static const EHPersonality GNU_C

static const EHPersonality NeXT_ObjC

const char * CatchallRethrowFn

static const EHPersonality GNU_CPlusPlus

static const EHPersonality GNU_ObjCXX

static const EHPersonality GNU_C_SEH

static const EHPersonality MSVC_except_handler

static const EHPersonality GNU_ObjC_SEH

const char * PersonalityFn

static const EHPersonality GNU_Wasm_CPlusPlus

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