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

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

clang: lib/CodeGen/CGNonTrivialStruct.cpp Source File

;

CodeGen;

{ DstIdx = 0, SrcIdx = 1 };

*ValNameStr[2] = {

,

};

<

Derived>

StructVisitor {

<

... Ts>

asDerived().visit(FT, FD, CurStructOffset, Args...);

asDerived().flushTrivialFields(Args...);

<

... Ts>

visitTrivial(Ts... Args) {}

<

... Ts>

visitCXXDestructor(Ts... Args) {

llvm_unreachable(

);

<

... Ts>

flushTrivialFields(Ts... Args) {}

Derived &asDerived() {

Derived &

(*this); }

<

Derived,

IsMove>

CopyStructVisitor : StructVisitor<Derived>,

CopyStructVisitor(

&Ctx) : StructVisitor<Derived>(Ctx) {}

<

... Ts>

().flushTrivialFields(std::forward<Ts>(Args)...);

<

... Ts>

(

*AT =

().getContext().getAsArrayType(FT)) {

CurStructOffset, std::forward<Ts>(Args)...);

std::forward<Ts>(Args)...);

<

... Ts>

FEndInBits = FStartInBits + FieldSize;

<

Derived>

GenFuncNameBase {

std::string getVolatileOffsetStr(

IsVolatile,

Offset) {

S += llvm::to_string(Offset.getQuantity());

FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);

FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);

FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);

asDerived().visitStructFields(QT, FieldOffset);

<

FieldKind>

visitArray(FieldKind FK,

*AT,

IsVolatile,

asDerived().visitTrivial(

(AT, 0), FD, CurStructOffset);

asDerived().flushTrivialFields();

FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);

appendStr(

+ llvm::to_string(FieldOffset.

()) +

+

llvm::to_string(NumElts));

asDerived().visitWithKind(FK, EltTy,

, FieldOffset);

appendStr(StringRef Str) { Name += Str; }

Derived &asDerived() {

Derived &

(*this); }

<

Derived>

GenUnaryFuncName : StructVisitor<Derived>, GenFuncNameBase<Derived> {

: StructVisitor<Derived>(Ctx) {

this->appendStr(Prefix);

this->appendStr(llvm::to_string(DstAlignment.

()));

llvm::ConstantPointerNull::get(cast<llvm::PointerType>(Ty));

<

IsMove>

GenBinaryFuncName : CopyStructVisitor<GenBinaryFuncName<IsMove>, IsMove>,

GenFuncNameBase<GenBinaryFuncName<IsMove>> {

GenBinaryFuncName(StringRef Prefix,

DstAlignment,

: CopyStructVisitor<GenBinaryFuncName<IsMove>, IsMove>(Ctx) {

this->appendStr(Prefix);

this->appendStr(llvm::to_string(DstAlignment.

()));

this->appendStr(

+ llvm::to_string(SrcAlignment.

()));

flushTrivialFields() {

(this->Start == this->End)

this->appendStr(

+ llvm::to_string(this->Start.getQuantity()) +

+

llvm::to_string((this->End - this->Start).getQuantity()));

this->appendStr(

+ llvm::to_string(OffsetInBits) +

+

GenDefaultInitializeFuncName

: GenUnaryFuncName<GenDefaultInitializeFuncName>,

: GenUnaryFuncName<GenDefaultInitializeFuncName>(

,

DstAlignment, Ctx) {}

(

*AT = getContext().getAsArrayType(FT)) {

GenDestructorFuncName : GenUnaryFuncName<GenDestructorFuncName>,

GenDestructorFuncName(

*Prefix,

DstAlignment,

: GenUnaryFuncName<GenDestructorFuncName>(Prefix, DstAlignment, Ctx) {}

(

*AT = getContext().getAsArrayType(FT)) {

(

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

ImplicitParamKind::Other));

llvm::append_range(Args, Params);

<

N,

... Ints>

std::array<Address, N> getParamAddrs(std::index_sequence<Ints...> IntSeq,

std::array<CharUnits, N> Alignments,

std::array<Address, N>{

<

Derived>

GenFuncBase {

std::array<Address, N> Addrs) {

this->asDerived().callSpecialFunction(

<

FieldKind,

N>

visitArray(FieldKind FK,

*AT,

IsVolatile,

std::array<Address, N> Addrs) {

asDerived().visitTrivial(

(AT, 0), FD, CurStructOffset,

asDerived().flushTrivialFields(Addrs);

std::array<Address, N> StartAddrs = Addrs;

(

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

StartAddrs[I] = getAddrWithOffset(Addrs[I], CurStructOffset, FD);

DstAddr = StartAddrs[DstIdx];

llvm::Value *BaseEltSizeVal =

llvm::ConstantInt::get(NumElts->getType(), BaseEltSize);

llvm::Value *SizeInBytes =

CGF.

.CreateNUWMul(BaseEltSizeVal, NumElts);

llvm::BasicBlock *PreheaderBB = CGF.

.GetInsertBlock();

llvm::PHINode *PHIs[N];

(

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

PHIs[I]->addIncoming(StartAddrs[I].emitRawPointer(CGF), PreheaderBB);

CGF.

.CreateICmpEQ(PHIs[DstIdx], DstArrayEnd,

);

CGF.

.CreateCondBr(Done, ExitBB, LoopBB);

std::array<Address, N> NewAddrs = Addrs;

(

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

StartAddrs[I].getAlignment().alignmentAtOffset(EltSize));

this->asDerived().visitWithKind(FK, EltQT,

,

(),

LoopBB = CGF.

.GetInsertBlock();

(

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

NewAddrs[I] = getAddrWithOffset(NewAddrs[I], EltSize);

PHIs[I]->addIncoming(NewAddrs[I].emitRawPointer(CGF), LoopBB);

CGF.

.CreateBr(HeaderBB);

assert(Addr.

() &&

);

(Offset.getQuantity() == 0)

getAddrWithOffset(Addr, StructFieldOffset +

llvm::Function *getFunction(StringRef FuncName,

QT,

std::array<CharUnits, N> Alignments,

(llvm::Function *F = CGM.

().getFunction(FuncName)) {

WrongType =

;

(!F->getReturnType()->isVoidTy())

(

llvm::Argument &Arg : F->args())

std::string FuncName = std::string(F->getName());

CGM.

(

,

+ FuncName +

);

llvm::Function::Create(FuncTy, llvm::GlobalValue::LinkOnceODRLinkage,

F->setVisibility(llvm::GlobalValue::HiddenVisibility);

std::array<Address, N> Addrs =

getParamAddrs<N>(std::make_index_sequence<N>{}, Alignments, Args, CGF);

callFunc(StringRef FuncName,

QT, std::array<Address, N> Addrs,

std::array<CharUnits, N> Alignments;

llvm::Value *Ptrs[N];

(

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

Alignments[I] = Addrs[I].getAlignment();

Ptrs[I] = Addrs[I].emitRawPointer(CallerCGF);

(llvm::Function *F =

getFunction(FuncName, QT, Alignments, CallerCGF.

))

Derived &asDerived() {

Derived &

(*this); }

<

Derived,

IsMove>

GenBinaryFunc : CopyStructVisitor<Derived, IsMove>,

GenFuncBase<Derived> {

GenBinaryFunc(

&Ctx) : CopyStructVisitor<Derived, IsMove>(Ctx) {}

flushTrivialFields(std::array<Address, 2> Addrs) {

(

.getQuantity() == 0)

DstAddr = this->getAddrWithOffset(Addrs[DstIdx], this->Start);

SrcAddr = this->getAddrWithOffset(Addrs[SrcIdx], this->Start);

(

.getQuantity() >= 16 ||

!llvm::has_single_bit<uint32_t>(

.getQuantity())) {

llvm::Value *SizeVal =

llvm::ConstantInt::get(this->CGF->

,

.getQuantity());

llvm::Type *Ty = llvm::Type::getIntNTy(

.getQuantity() * this->CGF->getContext().getCharWidth());

<

... Ts>

std::array<Address, 2> Addrs) {

DstAddr = this->getAddrWithOffset(Addrs[DstIdx], Offset);

SrcAddr = this->getAddrWithOffset(Addrs[SrcIdx], Offset);

GenDestructor : StructVisitor<GenDestructor>,

GenFuncBase<GenDestructor>,

GenDestructor(

&Ctx) : StructVisitor<GenDestructor>(Ctx) {}

std::array<Address, 1> Addrs) {

(

*AT = getContext().getAsArrayType(FT)) {

CurStructOffset, std::array<Address, 1> Addrs) {

*CGF, getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);

std::array<Address, 1> Addrs) {

*CGF, getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);

std::array<Address, 1> Addrs) {

CGF->

(getAddrWithOffset(Addrs[DstIdx], Offset), FT));

GenDefaultInitialize

: StructVisitor<GenDefaultInitialize>,

GenFuncBase<GenDefaultInitialize>,

GenFuncBase<GenDefaultInitialize> GenFuncBaseTy;

: StructVisitor<GenDefaultInitialize>(Ctx) {}

std::array<Address, 1> Addrs) {

(

*AT = getContext().getAsArrayType(FT)) {

CurStructOffset, std::array<Address, 1> Addrs) {

getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);

std::array<Address, 1> Addrs) {

getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD), QT);

<

FieldKind,

... Is>

visitArray(FieldKind FK,

*AT,

IsVolatile,

std::array<Address, 1> Addrs) {

visitTrivial(

(AT, 0), FD, CurStructOffset, Addrs);

GenFuncBaseTy::visitArray(FK, AT, IsVolatile, FD, CurStructOffset, Addrs);

llvm::Constant *SizeVal = CGF->

.getInt64(

.getQuantity());

DstAddr = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);

std::array<Address, 1> Addrs) {

CGF->

(getAddrWithOffset(Addrs[DstIdx], Offset), FT));

GenCopyConstructor : GenBinaryFunc<GenCopyConstructor, false> {

: GenBinaryFunc<GenCopyConstructor,

>(Ctx) {}

CurStructOffset, std::array<Address, 2> Addrs) {

Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);

Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);

std::array<Address, 2> Addrs) {

Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);

Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);

std::array<Address, 2> Addrs) {

Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);

Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);

GenMoveConstructor : GenBinaryFunc<GenMoveConstructor, true> {

: GenBinaryFunc<GenMoveConstructor,

>(Ctx) {}

CurStructOffset, std::array<Address, 2> Addrs) {

Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);

Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);

llvm::Value *SrcVal =

std::array<Address, 2> Addrs) {

Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);

Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);

std::array<Address, 2> Addrs) {

Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);

Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);

GenCopyAssignment : GenBinaryFunc<GenCopyAssignment, false> {

: GenBinaryFunc<GenCopyAssignment,

>(Ctx) {}

CurStructOffset, std::array<Address, 2> Addrs) {

Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);

Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);

std::array<Address, 2> Addrs) {

Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);

Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);

std::array<Address, 2> Addrs) {

Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);

Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);

GenMoveAssignment : GenBinaryFunc<GenMoveAssignment, true> {

: GenBinaryFunc<GenMoveAssignment,

>(Ctx) {}

CurStructOffset, std::array<Address, 2> Addrs) {

Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);

Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);

llvm::Value *SrcVal =

llvm::Value *DstVal =

std::array<Address, 2> Addrs) {

Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], CurStructOffset, FD);

Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], CurStructOffset, FD);

std::array<Address, 2> Addrs) {

Addrs[DstIdx] = getAddrWithOffset(Addrs[DstIdx], Offset);

Addrs[SrcIdx] = getAddrWithOffset(Addrs[SrcIdx], Offset);

Gen.visit(QT,

,

(), std::array<Address, 1>({{DstPtr}}));

<

G,

N>

std::array<Address, N> Addrs) {

(

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

Addrs[I] = Addrs[I].withElementType(CGF.

.

);

Gen.callFunc(FuncName, QT, Addrs, CGF);

<

G,

N>

llvm::Function *

Gen.getFunction(FuncName, QT, Alignments, CGM);

std::string FuncName = GenName.getName(QT, IsVolatile);

IsVolatile, *

, std::array<Address, 1>({{DstPtr}}));

GenBinaryFuncName<false> GenName(

, Alignment, Alignment, Ctx);

GenName.getName(QT, IsVolatile);

GenDestructorFuncName GenName(

, Alignment, Ctx);

GenName.getName(QT, IsVolatile);

GenDestructorFuncName GenName(

, DstPtr.

(),

std::string FuncName = GenName.getName(QT, IsVolatile);

*

, std::array<Address, 1>({{DstPtr}}));

GenBinaryFuncName<false> GenName(

, DstPtr.

(),

std::string FuncName = GenName.getName(QT, IsVolatile);

std::array<Address, 2>({{DstPtr, SrcPtr}}));

GenBinaryFuncName<false> GenName(

, DstPtr.

(),

std::string FuncName = GenName.getName(QT, IsVolatile);

*

, std::array<Address, 2>({{DstPtr, SrcPtr}}));

GenBinaryFuncName<true> GenName(

, DstPtr.

(),

std::string FuncName = GenName.getName(QT, IsVolatile);

std::array<Address, 2>({{DstPtr, SrcPtr}}));

GenBinaryFuncName<true> GenName(

, DstPtr.

(),

std::string FuncName = GenName.getName(QT, IsVolatile);

*

, std::array<Address, 2>({{DstPtr, SrcPtr}}));

GenDefaultInitializeFuncName GenName(DstAlignment, Ctx);

std::string FuncName = GenName.getName(QT, IsVolatile);

std::array<CharUnits, 1>({{DstAlignment}}), CGM);

GenBinaryFuncName<false> GenName(

, DstAlignment,

std::string FuncName = GenName.getName(QT, IsVolatile);

GenCopyConstructor(Ctx), FuncName, QT, IsVolatile,

std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);

GenBinaryFuncName<true> GenName(

, DstAlignment,

std::string FuncName = GenName.getName(QT, IsVolatile);

GenMoveConstructor(Ctx), FuncName, QT, IsVolatile,

std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);

GenBinaryFuncName<false> GenName(

, DstAlignment,

std::string FuncName = GenName.getName(QT, IsVolatile);

GenCopyAssignment(Ctx), FuncName, QT, IsVolatile,

std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);

GenBinaryFuncName<true> GenName(

, DstAlignment,

std::string FuncName = GenName.getName(QT, IsVolatile);

GenMoveAssignment(Ctx), FuncName, QT, IsVolatile,

std::array<CharUnits, 2>({{DstAlignment, SrcAlignment}}), CGM);

GenDestructorFuncName GenName(

, DstAlignment, Ctx);

std::string FuncName = GenName.getName(QT, IsVolatile);

std::array<CharUnits, 1>({{DstAlignment}}), CGM);

static bool getFieldOffsetInBits(CodeGenFunction &CGF, const RecordDecl *RD, const FieldDecl *Field, int64_t &Offset)

The offset of a field from the beginning of the record.

static uint64_t getFieldSize(const FieldDecl *FD, QualType FT, ASTContext &Ctx)

static void callSpecialFunction(G &&Gen, StringRef FuncName, QualType QT, bool IsVolatile, CodeGenFunction &CGF, std::array< Address, N > Addrs)

static llvm::Function * getSpecialFunction(G &&Gen, StringRef FuncName, QualType QT, bool IsVolatile, std::array< CharUnits, N > Alignments, CodeGenModule &CGM)

static llvm::Constant * getNullForVariable(Address addr)

Given the address of a variable of pointer type, find the correct null to store into it.

static uint64_t getFieldOffset(const ASTContext &C, const FieldDecl *FD)

static std::string getName(const CallEvent &Call)

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

const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const

Get or compute information about the layout of the specified record (struct/union/class) D,...

QualType getPointerType(QualType T) const

Return the uniqued reference to the type for a pointer to the specified type.

QualType getBaseElementType(const ArrayType *VAT) const

Return the innermost element type of an array type.

int64_t toBits(CharUnits CharSize) const

Convert a size in characters to a size in bits.

uint64_t getTypeSize(QualType T) const

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

CharUnits getTypeSizeInChars(QualType T) const

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

CharUnits toCharUnitsFromBits(int64_t BitSize) const

Convert a size in bits to a size in characters.

uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const

Return number of constant array elements.

uint64_t getCharWidth() const

Return the size of the character type, in bits.

uint64_t getFieldOffset(unsigned FieldNo) const

getFieldOffset - Get the offset of the given field index, in bits.

Represents an array type, per C99 6.7.5.2 - Array Declarators.

QualType getElementType() const

CharUnits - This is an opaque type for sizes expressed in character units.

QuantityType getQuantity() const

getQuantity - Get the raw integer representation of this quantity.

static CharUnits fromQuantity(QuantityType Quantity)

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

static CharUnits Zero()

Zero - Construct a CharUnits quantity of zero.

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.

Address withElementType(llvm::Type *ElemTy) const

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

static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF)

Apply TemporaryLocation if it is valid.

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

llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)

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

llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)

Address CreateConstInBoundsGEP(Address Addr, uint64_t Index, const llvm::Twine &Name="")

Given addr = T* ... produce name = getelementptr inbounds addr, i64 index where i64 is actually the t...

Address CreateInBoundsGEP(Address Addr, ArrayRef< llvm::Value * > IdxList, llvm::Type *ElementType, CharUnits Align, const Twine &Name="")

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

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

void FinishFunction(SourceLocation EndLoc=SourceLocation())

FinishFunction - Complete IR generation of the current function.

void EmitNullInitialization(Address DestPtr, QualType Ty)

EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...

void EmitARCMoveWeak(Address dst, Address src)

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

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

void callCStructDefaultConstructor(LValue Dst)

llvm::Value * emitArrayLength(const ArrayType *arrayType, QualType &baseType, Address &addr)

emitArrayLength - Compute the length of an array, even if it's a VLA, and drill down to the base elem...

void callCStructCopyAssignmentOperator(LValue Dst, LValue Src)

void callCStructMoveConstructor(LValue Dst, LValue Src)

void callCStructCopyConstructor(LValue Dst, LValue Src)

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

createBasicBlock - Create an LLVM basic block.

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

EmitBlock - Emit the given block.

void callCStructDestructor(LValue Dst)

RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)

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

llvm::Type * ConvertTypeForMem(QualType T)

LValue EmitLValueForField(LValue Base, const FieldDecl *Field)

static std::string getNonTrivialDestructorStr(QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx)

void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)

void EmitARCCopyWeak(Address dst, Address src)

void defaultInitNonTrivialCStructVar(LValue Dst)

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.

llvm::Value * EmitARCRetain(QualType type, llvm::Value *value)

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

ASTContext & getContext() const

llvm::Value * EmitARCStoreStrong(LValue lvalue, llvm::Value *value, bool resultIgnored)

llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, AlignmentSource Source=AlignmentSource::Type, bool isNontemporal=false)

EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...

void emitARCMoveAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr)

void callCStructMoveAssignmentOperator(LValue Dst, LValue Src)

static Destroyer destroyARCWeak

llvm::Type * ConvertType(QualType T)

void emitARCCopyAssignWeak(QualType Ty, Address DstAddr, Address SrcAddr)

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

Address GetAddrOfLocalVar(const VarDecl *VD)

GetAddrOfLocalVar - Return the address of a local variable.

static Destroyer destroyARCStrongImprecise

llvm::LLVMContext & getLLVMContext()

static std::string getNonTrivialCopyConstructorStr(QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx)

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

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

llvm::Module & getModule() const

CodeGenTypes & getTypes()

void Error(SourceLocation loc, StringRef error)

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

ASTContext & getContext() const

void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F, bool IsThunk)

Set the LLVM function attributes (sext, zext, etc).

void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F)

Set the LLVM function attributes which only apply to a function definition.

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.

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

LValue - This represents an lvalue references.

Address getAddress() const

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

llvm::Value * getScalarVal() const

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

Represents the canonical version of C arrays with a specified constant size.

Represents a member of a struct/union/class.

bool isBitField() const

Determines whether this field is a bitfield.

unsigned getBitWidthValue() const

Computes the bit width of this field, if this is a bit field.

unsigned getFieldIndex() const

Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...

const RecordDecl * getParent() const

Returns the parent of this field declaration, which is the struct in which this field is defined.

bool isZeroLengthBitField() const

Is this a zero-length bit-field? Such bit-fields aren't really bit-fields at all and instead act as a...

GlobalDecl - represents a global declaration.

IdentifierInfo & get(StringRef Name)

Return the identifier token info for the specified named identifier.

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

Create implicit parameter.

A (possibly-)qualified type.

bool isVolatileQualified() const

Determine whether this type is volatile-qualified.

PrimitiveDefaultInitializeKind

QualType withVolatile() const

Represents a struct/union/class.

field_range fields() const

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

Encodes a location in the source.

const Type * getTypeForDecl() const

The base class of the type hierarchy.

bool isBlockPointerType() const

const T * castAs() const

Member-template castAs<specific type>.

const T * getAs() const

Member-template getAs<specific type>'.

llvm::Function * getNonTrivialCStructCopyConstructor(CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, bool IsVolatile, QualType QT)

Returns the copy constructor for a C struct with non-trivially copyable fields, generating it if nece...

llvm::Function * getNonTrivialCStructMoveConstructor(CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, bool IsVolatile, QualType QT)

Returns the move constructor for a C struct with non-trivially copyable fields, generating it if nece...

llvm::Function * getNonTrivialCStructCopyAssignmentOperator(CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, bool IsVolatile, QualType QT)

Returns the copy assignment operator for a C struct with non-trivially copyable fields,...

llvm::Function * getNonTrivialCStructMoveAssignmentOperator(CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment, bool IsVolatile, QualType QT)

Return the move assignment operator for a C struct with non-trivially copyable fields,...

llvm::Function * getNonTrivialCStructDestructor(CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT)

Returns the destructor for a C struct with non-trivially copyable fields, generating it if necessary.

llvm::Function * getNonTrivialCStructDefaultConstructor(CodeGenModule &GCM, CharUnits DstAlignment, bool IsVolatile, QualType QT)

Returns the default constructor for a C struct with non-trivially copyable fields,...

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

llvm::PointerType * VoidPtrTy

llvm::PointerType * Int8PtrPtrTy

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

llvm::IntegerType * SizeTy

llvm::PointerType * Int8PtrTy

RetTy visitWithKind(QualType::PrimitiveCopyKind PCK, QualType FT, Ts &&... Args)

RetTy visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType FT, Ts &&... Args)

RetTy visitWithKind(QualType::DestructionKind DK, QualType FT, Ts &&... Args)

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