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

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

clang: lib/CodeGen/CGCleanup.cpp Source File

;

CodeGen;

AggregateLiteral:

AggregateAddress:

ComplexAddress: {

llvm_unreachable(

);

*EHScopeStack::allocate(

Size) {

Capacity = 1024;

(Capacity < Size) Capacity *= 2;

StartOfBuffer =

[Capacity];

StartOfData = EndOfBuffer = StartOfBuffer + Capacity;

}

(

(StartOfData - StartOfBuffer) < Size) {

CurrentCapacity = EndOfBuffer - StartOfBuffer;

UsedCapacity = CurrentCapacity - (StartOfData - StartOfBuffer);

NewCapacity = CurrentCapacity;

}

(NewCapacity < UsedCapacity + Size);

*NewStartOfBuffer =

[NewCapacity];

*NewEndOfBuffer = NewStartOfBuffer + NewCapacity;

*NewStartOfData = NewEndOfBuffer - UsedCapacity;

(NewStartOfData, StartOfData, UsedCapacity);

[] StartOfBuffer;

StartOfBuffer = NewStartOfBuffer;

EndOfBuffer = NewEndOfBuffer;

StartOfData = NewStartOfData;

assert(StartOfBuffer + Size <= StartOfData);

StartOfData -=

;

EHScopeStack::deallocate(

Size) {

(!cleanup->isLifetimeMarker() && !cleanup->isFakeUse())

(

*cleanup = dyn_cast<EHCleanupScope>(&*

(si)))

(cleanup->isLifetimeMarker()) {

si = cleanup->getEnclosingEHScope();

(cleanup.isActive())

si;

si = cleanup.getEnclosingNormalCleanup();

*EHScopeStack::pushCleanup(

Kind,

Size) {

IsFakeUse = Kind &

;

IsEHCleanup =

;

InnermostNormalCleanup,

(IsLifetimeMarker)

->setLifetimeMarker();

->setFakeUse();

(CGF->

().EHAsynch && IsEHCleanup && !IsLifetimeMarker &&

->getCleanupBuffer();

assert(!

() &&

);

assert(isa<EHCleanupScope>(*

()));

InnermostNormalCleanup =

.getEnclosingNormalCleanup();

InnermostEHScope =

.getEnclosingEHScope();

deallocate(

.getAllocatedSize());

(!BranchFixups.empty()) {

BranchFixups.clear();

assert(!

() &&

);

(buffer)

(numHandlers, InnermostEHScope);

MinSize = cast<EHCleanupScope>(*it).getFixupDepth();

assert(BranchFixups.size() >= MinSize &&

);

(BranchFixups.size() > MinSize &&

BranchFixups.back().Destination ==

)

BranchFixups.pop_back();

assert(!cleanup.hasActiveFlag() &&

);

cleanup.setActiveFlag(ActiveFlag);

(cleanup.isNormalCleanup()) cleanup.setTestFlagInNormalCleanup();

(cleanup.isEHCleanup()) cleanup.setTestFlagInEHCleanup();

EHScopeStack::Cleanup::anchor() {}

llvm::BasicBlock::iterator beforeInst,

store =

llvm::StoreInst(value, addr.

(CGF), beforeInst);

llvm::LoadInst *

llvm::BasicBlock::iterator beforeInst,

llvm::SwitchInst *

,

llvm::BasicBlock *CleanupEntry) {

(!CasesAdded.insert(Fixup.

).second)

llvm::BasicBlock *

) {

llvm::Instruction *Term =

->getTerminator();

assert(Term &&

);

(llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Term)) {

assert(Br->isUnconditional());

, Term->getIterator(), CGF);

llvm::SwitchInst *

=

llvm::SwitchInst::Create(Load, Br->getSuccessor(0), 4,

);

Br->eraseFromParent();

cast<llvm::SwitchInst>(Term);

assert(

&&

);

(!EHStack.getNumBranchFixups())

;

assert(EHStack.hasNormalCleanups() &&

);

ResolvedAny =

;

(

I = 0,

= EHStack.getNumBranchFixups(); I !=

; ++I) {

(!ModifiedOptimisticBlocks.insert(BranchBB).second)

EHStack.popNullFixups();

std::initializer_list<llvm::Value **> ValuesToReload) {

HadBranches =

;

(EHStack.stable_begin() != Old) {

HadBranches |=

.hasBranches();

FallThroughIsBranchThrough =

PopCleanupBlock(FallThroughIsBranchThrough);

(llvm::Value **ReloadedValue : ValuesToReload) {

*Inst = dyn_cast_or_null<llvm::Instruction>(*ReloadedValue);

*AI = dyn_cast<llvm::AllocaInst>(Inst);

(AI && AI->isStaticAlloca())

CreateDefaultAlignTempAlloca(Inst->getType(),

);

llvm::BasicBlock::iterator InsertBefore;

(

*Invoke = dyn_cast<llvm::InvokeInst>(Inst))

InsertBefore = Invoke->getNormalDest()->getFirstInsertionPt();

InsertBefore = std::next(Inst->getIterator());

*ReloadedValue = Builder.CreateLoad(Tmp);

std::initializer_list<llvm::Value **> ValuesToReload) {

PopCleanupBlocks(Old, ValuesToReload);

(

I = OldLifetimeExtendedSize,

= LifetimeExtendedCleanupStack.size(); I !=

;

) {

assert((I %

(LifetimeExtendedCleanupHeader) == 0) &&

);

LifetimeExtendedCleanupHeader &Header =

LifetimeExtendedCleanupHeader&

(

LifetimeExtendedCleanupStack[I]);

I +=

(Header);

EHStack.pushCopyOfCleanup(Header.getKind(),

&LifetimeExtendedCleanupStack[I],

I += Header.getSize();

(Header.isConditional()) {

&

(LifetimeExtendedCleanupStack[I]);

initFullExprCleanupWithFlag(ActiveFlag);

I +=

(ActiveFlag);

LifetimeExtendedCleanupStack.resize(OldLifetimeExtendedSize);

assert(

.isNormalCleanup());

llvm::BasicBlock *Entry =

.getNormalBlock();

.setNormalBlock(Entry);

llvm::BasicBlock *Entry) {

llvm::BasicBlock *Pred = Entry->getSinglePredecessor();

(!Pred)

Entry;

llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Pred->getTerminator());

(!Br || Br->isConditional())

Entry;

assert(Br->getSuccessor(0) == Entry);

WasInsertBlock = CGF.

.GetInsertBlock() == Entry;

assert(!WasInsertBlock || CGF.

.GetInsertPoint() == Entry->end());

Br->eraseFromParent();

Entry->replaceAllUsesWith(Pred);

Pred->splice(Pred->end(), Entry);

Entry->eraseFromParent();

CGF.

.SetInsertPoint(Pred);

llvm::BasicBlock *ContBB =

;

llvm::Value *IsActive

CGF.

.CreateCondBr(IsActive, CleanupBB, ContBB);

Fn->Emit(CGF, flags);

assert(CGF.

() &&

);

llvm::BasicBlock *From,

llvm::BasicBlock *To) {

llvm::Instruction *Term = Exit->getTerminator();

(llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Term)) {

assert(Br->isUnconditional() && Br->getSuccessor(0) == From);

Br->setSuccessor(0, To);

llvm::SwitchInst *

= cast<llvm::SwitchInst>(Term);

(

I = 0,

=

->getNumSuccessors(); I !=

; ++I)

(

->getSuccessor(I) == From)

->setSuccessor(I, To);

(llvm::BasicBlock::use_iterator

i = entry->use_begin(), e = entry->use_end(); i != e; ) {

use.set(unreachableBB);

llvm::SwitchInst *si = cast<llvm::SwitchInst>(use.getUser());

(si->getNumCases() == 1 && si->getDefaultDest() == unreachableBB) {

llvm::BranchInst::Create(si->case_begin()->getCaseSuccessor(),

llvm::LoadInst *condition = cast<llvm::LoadInst>(si->getCondition());

si->eraseFromParent();

assert(condition->use_empty());

condition->eraseFromParent();

assert(entry->use_empty());

assert(!EHStack.empty() &&

);

assert(isa<EHCleanupScope>(*EHStack.begin()) &&

);

assert(

.getFixupDepth() <= EHStack.getNumBranchFixups());

CGBuilderTy::InsertPoint NormalDeactivateOrigIP;

NormalDeactivateOrigIP = Builder.saveAndClearIP();

IsActive =

.isActive();

.shouldTestFlagInNormalCleanup() ?

.getActiveFlag()

.shouldTestFlagInEHCleanup() ?

.getActiveFlag()

llvm::BasicBlock *EHEntry =

.getCachedEHDispatchBlock();

assert(

.hasEHBranches() == (EHEntry !=

));

RequiresEHCleanup = (EHEntry !=

);

FixupDepth =

.getFixupDepth();

HasFixups = EHStack.getNumBranchFixups() != FixupDepth;

HasExistingBranches =

.hasBranches();

llvm::BasicBlock *FallthroughSource = Builder.GetInsertBlock();

HasFallthrough =

FallthroughSource !=

&& (IsActive || HasExistingBranches);

HasPrebranchedFallthrough =

(FallthroughSource && FallthroughSource->getTerminator());

assert(!

.isNormalCleanup() || !HasPrebranchedFallthrough ||

(

.getNormalBlock() &&

FallthroughSource->getTerminator()->getSuccessor(0)

==

.getNormalBlock()));

RequiresNormalCleanup =

;

(

.isNormalCleanup() &&

(HasFixups || HasExistingBranches || HasFallthrough)) {

RequiresNormalCleanup =

;

(

.isNormalCleanup() && HasPrebranchedFallthrough &&

!RequiresNormalCleanup) {

llvm::BasicBlock *prebranchDest;

(FallthroughIsBranchThrough) {

&enclosing = *EHStack.find(

.getEnclosingNormalCleanup());

prebranchDest = createBasicBlock(

);

EmitBlock(prebranchDest);

llvm::BasicBlock *normalEntry =

.getNormalBlock();

assert(normalEntry && !normalEntry->use_empty());

normalEntry, prebranchDest);

(!RequiresNormalCleanup && !RequiresEHCleanup) {

EHStack.popCleanup();

assert(EHStack.getNumBranchFixups() == 0 ||

EHStack.hasNormalCleanups());

(NormalDeactivateOrigIP.isSet())

Builder.restoreIP(NormalDeactivateOrigIP);

*CleanupSource =

*

(

.getCleanupBuffer());

CleanupBufferStack[8 *

(

*)];

std::unique_ptr<char[]> CleanupBufferHeap;

CleanupSize =

.getCleanupSize();

(CleanupSize <=

(CleanupBufferStack)) {

(CleanupBufferStack, CleanupSource, CleanupSize);

CleanupBufferHeap.reset(

[CleanupSize]);

(CleanupBufferHeap.get(), CleanupSource, CleanupSize);

(

.isNormalCleanup())

(

.isEHCleanup())

IsEHa = getLangOpts().EHAsynch && !

.isLifetimeMarker();

(!RequiresNormalCleanup) {

(IsEHa && getInvokeDest()) {

(NormalDeactivateOrigIP.isSet())

Builder.restoreIP(NormalDeactivateOrigIP);

EmitSehCppScopeEnd();

(NormalDeactivateOrigIP.isSet())

NormalDeactivateOrigIP = Builder.saveAndClearIP();

.MarkEmitted();

EHStack.popCleanup();

(HasFallthrough && !HasPrebranchedFallthrough && !HasFixups &&

!HasExistingBranches) {

(IsEHa && getInvokeDest()) {

EmitSehCppScopeEnd();

EmitSehTryScopeEnd();

.MarkEmitted();

EHStack.popCleanup();

(*

, Fn, cleanupFlags, NormalActiveFlag);

CGBuilderTy::InsertPoint savedInactiveFallthroughIP;

(HasFallthrough) {

(!HasPrebranchedFallthrough)

Builder.CreateStore(Builder.getInt32(0), getNormalCleanupDestSlot());

}

(FallthroughSource) {

assert(!IsActive &&

);

savedInactiveFallthroughIP = Builder.saveAndClearIP();

EmitBlock(NormalEntry);

(IsEHa && getInvokeDest()) {

EmitSehCppScopeEnd();

EmitSehTryScopeEnd();

HasEnclosingCleanups =

(

.getEnclosingNormalCleanup() != EHStack.stable_end());

llvm::BasicBlock *BranchThroughDest =

;

(

.hasBranchThroughs() ||

(FallthroughSource && FallthroughIsBranchThrough) ||

(HasFixups && HasEnclosingCleanups)) {

assert(HasEnclosingCleanups);

&S = *EHStack.find(

.getEnclosingNormalCleanup());

llvm::BasicBlock *FallthroughDest =

;

(!

.hasBranchThroughs() && !HasFixups && !HasFallthrough &&

!currentFunctionUsesSEHTry() &&

.getNumBranchAfters() == 1) {

assert(!BranchThroughDest || !IsActive);

llvm::Instruction *NormalCleanupDestSlot =

cast<llvm::Instruction>(getNormalCleanupDestSlot().getPointer());

(NormalCleanupDestSlot->hasOneUse()) {

NormalCleanupDestSlot->user_back()->eraseFromParent();

NormalCleanupDestSlot->eraseFromParent();

llvm::BasicBlock *BranchAfter =

.getBranchAfterBlock(0);

InstsToAppend.push_back(llvm::BranchInst::Create(BranchAfter));

}

(

.getNumBranchAfters() ||

(HasFallthrough && !FallthroughIsBranchThrough) ||

(HasFixups && !HasEnclosingCleanups)) {

(BranchThroughDest ? BranchThroughDest : getUnreachableBlock());

SwitchCapacity = 10;

, *

);

llvm::SwitchInst *

=

llvm::SwitchInst::Create(Load,

, SwitchCapacity);

InstsToAppend.push_back(Load);

InstsToAppend.push_back(

);

(FallthroughSource && !FallthroughIsBranchThrough) {

FallthroughDest = createBasicBlock(

);

->addCase(Builder.getInt32(0), FallthroughDest);

(

I = 0,

=

.getNumBranchAfters(); I !=

; ++I) {

.getBranchAfterBlock(I));

(HasFixups && !HasEnclosingCleanups)

assert(BranchThroughDest);

InstsToAppend.push_back(llvm::BranchInst::Create(BranchThroughDest));

.MarkEmitted();

EHStack.popCleanup();

assert(EHStack.hasNormalCleanups() == HasEnclosingCleanups);

(*

, Fn, cleanupFlags, NormalActiveFlag);

llvm::BasicBlock *NormalExit = Builder.GetInsertBlock();

(

I = 0,

= InstsToAppend.size(); I !=

; ++I)

InstsToAppend[I]->insertInto(NormalExit, NormalExit->end());

(

I = FixupDepth,

= EHStack.getNumBranchFixups();

getNormalCleanupDestSlot(),

(!HasFallthrough && FallthroughSource) {

Builder.restoreIP(savedInactiveFallthroughIP);

}

(HasFallthrough && FallthroughDest) {

assert(!FallthroughIsBranchThrough);

EmitBlock(FallthroughDest);

}

(HasFallthrough) {

Builder.ClearInsertionPoint();

llvm::BasicBlock *NewNormalEntry =

(NewNormalEntry != NormalEntry && NormalEntry == NormalExit)

(

I = FixupDepth,

= EHStack.getNumBranchFixups();

EHStack.getBranchFixup(I).OptimisticBranchBlock = NewNormalEntry;

(NormalDeactivateOrigIP.isSet())

Builder.restoreIP(NormalDeactivateOrigIP);

assert(EHStack.hasNormalCleanups() || EHStack.getNumBranchFixups() == 0);

(RequiresEHCleanup) {

CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();

llvm::BasicBlock *NextAction = getEHDispatchBlock(EHParent);

PushedTerminate =

;

llvm::CleanupPadInst *CPI =

;

llvm::Value *ParentPad = CurrentFuncletPad;

ParentPad = llvm::ConstantTokenNone::get(CGM.getLLVMContext());

CurrentFuncletPad = CPI = Builder.CreateCleanupPad(ParentPad);

EHStack.pushTerminate();

PushedTerminate =

;

}

(IsEHa && getInvokeDest()) {

EmitSehCppScopeEnd();

(EHActiveFlag.

() || IsActive) {

(*

, Fn, cleanupFlags, EHActiveFlag);

Builder.CreateCleanupRet(CPI, NextAction);

Builder.CreateBr(NextAction);

(PushedTerminate)

EHStack.popTerminate();

Builder.restoreIP(SavedIP);

assert(Dest.getScopeDepth().encloses(EHStack.stable_begin())

&&

);

EHStack.getInnermostActiveNormalCleanup();

(TopCleanup == EHStack.stable_end() ||

TopCleanup.

(Dest.getScopeDepth()))

assert(Dest.getScopeDepth().encloses(EHStack.stable_begin())

&&

);

(!HaveInsertPoint())

llvm::BranchInst *BI = Builder.CreateBr(Dest.getBlock());

TopCleanup = EHStack.getInnermostActiveNormalCleanup();

(TopCleanup == EHStack.stable_end() ||

TopCleanup.

(Dest.getScopeDepth())) {

Builder.ClearInsertionPoint();

(!Dest.getScopeDepth().isValid()) {

Builder.ClearInsertionPoint();

llvm::ConstantInt *Index = Builder.getInt32(Dest.getDestIndex());

cast<EHCleanupScope>(*EHStack.find(TopCleanup));

(

.strictlyEncloses(I)) {

assert(

.isNormalCleanup());

I =

.getEnclosingNormalCleanup();

(!

.strictlyEncloses(I)) {

.addBranchAfter(Index, Dest.getBlock());

(!

.addBranchThrough(Dest.getBlock()))

Builder.ClearInsertionPoint();

assert(cleanup.strictlyEncloses(i));

llvm::Instruction *dominatingIP) {

isActivatedInConditional =

needFlag =

;

(

.isNormalCleanup()) {

.setTestFlagInNormalCleanup();

(

.isEHCleanup() &&

.setTestFlagInEHCleanup();

(!var.isValid()) {

CodeGenFunction::AllocaTrackerRAII AllocaTracker(CGF);

);

.setActiveFlag(var);

.AddAuxAllocas(AllocaTracker.Take());

assert(dominatingIP &&

);

llvm::Instruction *dominatingIP) {

assert(

!= EHStack.stable_end() &&

);

assert(!

.isActive() &&

);

.setActive(

);

llvm::Instruction *dominatingIP) {

assert(

!= EHStack.stable_end() &&

);

assert(

.isActive() &&

);

(

== EHStack.stable_begin() &&

CurrentCleanupScopeDepth.strictlyEncloses(

)) {

PopCleanupBlock(

,

.setActive(

);

(!NormalCleanupDest.isValid())

CreateDefaultAlignTempAlloca(Builder.getInt32Ty(),

);

NormalCleanupDest;

llvm::FunctionCallee &SehCppScope) {

assert(CGF.

.GetInsertBlock() && InvokeDest);

CGF.

.CreateInvoke(SehCppScope, Cont, InvokeDest, {}, BundleList);

assert(getLangOpts().EHAsynch);

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.VoidTy,

);

llvm::FunctionCallee SehCppScope =

CGM.CreateRuntimeFunction(FTy,

);

assert(getLangOpts().EHAsynch);

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.VoidTy,

);

llvm::FunctionCallee SehCppScope =

CGM.CreateRuntimeFunction(FTy,

);

assert(getLangOpts().EHAsynch);

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.VoidTy,

);

llvm::FunctionCallee SehCppScope =

CGM.CreateRuntimeFunction(FTy,

);

assert(getLangOpts().EHAsynch);

llvm::FunctionType *FTy =

llvm::FunctionType::get(CGM.VoidTy,

);

llvm::FunctionCallee SehCppScope =

CGM.CreateRuntimeFunction(FTy,

);

static llvm::LoadInst * createLoadInstBefore(Address addr, const Twine &name, llvm::BasicBlock::iterator beforeInst, CodeGenFunction &CGF)

static void EmitSehScope(CodeGenFunction &CGF, llvm::FunctionCallee &SehCppScope)

static llvm::BasicBlock * CreateNormalEntry(CodeGenFunction &CGF, EHCleanupScope &Scope)

static void EmitCleanup(CodeGenFunction &CGF, EHScopeStack::Cleanup *Fn, EHScopeStack::Cleanup::Flags flags, Address ActiveFlag)

static void destroyOptimisticNormalEntry(CodeGenFunction &CGF, EHCleanupScope &scope)

We don't need a normal entry block for the given cleanup.

static void SetupCleanupBlockActivation(CodeGenFunction &CGF, EHScopeStack::stable_iterator C, ForActivation_t kind, llvm::Instruction *dominatingIP)

The given cleanup block is changing activation state.

static void ForwardPrebranchedFallthrough(llvm::BasicBlock *Exit, llvm::BasicBlock *From, llvm::BasicBlock *To)

static void createStoreInstBefore(llvm::Value *value, Address addr, llvm::BasicBlock::iterator beforeInst, CodeGenFunction &CGF)

static void ResolveAllBranchFixups(CodeGenFunction &CGF, llvm::SwitchInst *Switch, llvm::BasicBlock *CleanupEntry)

All the branch fixups on the EH stack have propagated out past the outermost normal cleanup; resolve ...

static bool IsUsedAsEHCleanup(EHScopeStack &EHStack, EHScopeStack::stable_iterator cleanup)

static llvm::BasicBlock * SimplifyCleanupEntry(CodeGenFunction &CGF, llvm::BasicBlock *Entry)

Attempts to reduce a cleanup's entry block to a fallthrough.

static llvm::SwitchInst * TransitionToCleanupSwitch(CodeGenFunction &CGF, llvm::BasicBlock *Block)

Transitions the terminator of the given exit-block of a cleanup to be a cleanup switch.

static Decl::Kind getKind(const Decl *D)

__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)

Represents a C++ temporary.

llvm::Align getAsAlign() const

getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...

static CharUnits One()

One - Construct a CharUnits quantity of one.

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

CharUnits getAlignment() const

llvm::Type * getElementType() const

Return the type of the values stored in this address.

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

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

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

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

DeactivateCleanupBlock - Deactivates the given cleanup block.

void EmitSehCppScopeBegin()

RawAddress createCleanupActiveFlag()

RawAddress CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)

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

createBasicBlock - Create an LLVM basic block.

const LangOptions & getLangOpts() const

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

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

RawAddress getNormalCleanupDestSlot()

void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize, std::initializer_list< llvm::Value ** > ValuesToReload={})

Takes the old cleanup stack size and emits the cleanup blocks that have been added.

llvm::BasicBlock * getUnreachableBlock()

const TargetInfo & getTarget() const

bool isInConditionalBranch() const

isInConditionalBranch - Return true if we're currently emitting one branch or the other of a conditio...

void EmitSehCppScopeEnd()

void initFullExprCleanupWithFlag(RawAddress ActiveFlag)

llvm::BasicBlock * getInvokeDest()

void EmitSehTryScopeBegin()

void EmitSehTryScopeEnd()

bool HaveInsertPoint() const

HaveInsertPoint - True if an insertion point is defined.

void setBeforeOutermostConditional(llvm::Value *value, Address addr, CodeGenFunction &CGF)

void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType, Address Ptr)

void EmitBranchThroughCleanup(JumpDest Dest)

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

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

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

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

ActivateCleanupBlock - Activates an initially-inactive cleanup.

RawAddress NormalCleanupDest

i32s containing the indexes of the cleanup destinations.

bool isObviouslyBranchWithoutCleanups(JumpDest Dest) const

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

llvm::Instruction * CurrentFuncletPad

void ResolveBranchFixups(llvm::BasicBlock *Target)

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

static size_t getSizeForNumHandlers(unsigned N)

A cleanup scope which generates the cleanup blocks lazily.

static size_t getSizeForCleanupSize(size_t Size)

Gets the size required for a lazy cleanup scope with the given cleanup-data requirements.

llvm::BasicBlock * getNormalBlock() const

An exceptions scope which filters exceptions thrown through it.

static size_t getSizeForNumFilters(unsigned numFilters)

unsigned getNumFilters() const

void setIsNormalCleanupKind()

void setIsEHCleanupKind()

Information for lazily generating a cleanup.

A non-stable pointer into the scope stack.

A saved depth on the scope stack.

bool encloses(stable_iterator I) const

Returns true if this scope encloses I.

bool strictlyEncloses(stable_iterator I) const

Returns true if this scope strictly encloses I: that is, if it encloses I and is not I.

A stack of scopes which respond to exceptions, including cleanups and catch blocks.

class EHFilterScope * pushFilter(unsigned NumFilters)

Push an exceptions filter on the stack.

BranchFixup & getBranchFixup(unsigned I)

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.

unsigned getNumBranchFixups() const

void popCleanup()

Pops a cleanup scope off the stack. This is private to CGCleanup.cpp.

stable_iterator getInnermostEHScope() const

bool requiresLandingPad() const

bool empty() const

Determines whether the exception-scopes stack is empty.

void popFilter()

Pops an exceptions filter off the stack.

iterator begin() const

Returns an iterator pointing to the innermost EH scope.

bool containsOnlyNoopCleanups(stable_iterator Old) const

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.

void popNullFixups()

Pops lazily-removed fixups from the end of the list.

bool hasNormalCleanups() const

Determines whether there are any normal cleanups on the stack.

stable_iterator getInnermostActiveNormalCleanup() const

stable_iterator stabilize(iterator it) const

Translates an iterator into a stable_iterator.

static stable_iterator stable_end()

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

void clearFixups()

Clears the branch-fixups list.

void pushTerminate()

Push a terminate handler on the stack.

A protected scope for zero-cost EH handling.

EHScopeStack::stable_iterator getEnclosingEHScope() const

bool hasEHBranches() const

An exceptions scope which calls std::terminate if any exception reaches it.

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

static RValue get(llvm::Value *V)

static RValue getAggregate(Address addr, bool isVolatile=false)

Convert an Address to an RValue.

static RValue getComplex(llvm::Value *V1, llvm::Value *V2)

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.

An abstract representation of an aligned address.

llvm::Value * getPointer() const

static RawAddress invalid()

A (possibly-)qualified type.

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

bool isMicrosoft() const

Is this ABI an MSVC-compatible ABI?

TargetCXXABI getCXXABI() const

Get the C++ ABI currently in use.

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

bool Load(InterpState &S, CodePtr OpPC)

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

unsigned DestinationIndex

The destination index value.

llvm::BasicBlock * Destination

The ultimate destination of the branch.

llvm::BasicBlock * OptimisticBranchBlock

The block containing the terminator which needs to be modified into a switch if this fixup is resolve...

llvm::BranchInst * InitialBranch

The initial branch of the fixup.

static llvm::Value * restore(CodeGenFunction &CGF, saved_type value)

static saved_type save(CodeGenFunction &CGF, llvm::Value *value)

static bool needsSaving(llvm::Value *value)

Answer whether the given value needs extra work to be saved.

A metaprogramming class for ensuring that a value will dominate an arbitrary position in a function.

The exceptions personality for a function.

bool isMSVCXXPersonality() const

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

bool usesFuncletPads() const

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

bool isMSVCPersonality() 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