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

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

clang: lib/CodeGen/CGExprConstant.cpp Source File

;

CodeGen;

ConstExprEmitter;

llvm::Type *Ty = CGM.

;

Ty = llvm::ArrayType::get(Ty, PadSize.

());

llvm::Constant::getNullValue(Ty);

llvm::UndefValue::get(Ty);

ConstantAggregateBuilderUtils {

ConstantAggregateBuilderUtils(

&CGM) : CGM(CGM) {}

getAlignment(

llvm::Constant *

)

{

getSize(

llvm::Constant *

)

{

getSize(

->getType());

llvm::Constant *getPadding(

PadSize)

{

return ::getPadding(CGM, PadSize);

llvm::Constant *getZeroes(

ZeroSize)

{

llvm::ConstantAggregateZero::get(Ty);

ConstantAggregateBuilder :

ConstantAggregateBuilderUtils {

NaturalLayout =

;

split(

Index,

Hint);

std::optional<size_t> splitAt(

Pos);

NaturalLayout, llvm::Type *DesiredTy,

AllowOversized);

: ConstantAggregateBuilderUtils(CGM) {}

add(llvm::Constant *

,

Offset,

AllowOverwrite);

addBits(llvm::APInt Bits, uint64_t OffsetInBits,

AllowOverwrite);

condense(

Offset, llvm::Type *DesiredTy);

llvm::Constant *build(llvm::Type *DesiredTy,

AllowOversized)

{

NaturalLayout, DesiredTy, AllowOversized);

<

Container,

= std::initializer_list<

Container::value_type>>

replace(Container &

,

BeginOff,

EndOff,

Vals) {

assert(BeginOff <= EndOff &&

);

llvm::replace(

,

.begin() + BeginOff,

.begin() + EndOff, Vals);

ConstantAggregateBuilder::add(llvm::Constant *

,

Offset,

AllowOverwrite) {

(Offset >= Size) {

(AlignedSize > Offset || Offset.alignTo(Align) != Offset)

NaturalLayout =

;

(AlignedSize < Offset) {

Elems.push_back(getPadding(Offset - Size));

Offsets.push_back(Size);

Elems.push_back(

);

Offsets.push_back(Offset);

= Offset + getSize(

);

std::optional<size_t> FirstElemToReplace = splitAt(Offset);

(!FirstElemToReplace)

std::optional<size_t> LastElemToReplace = splitAt(Offset + CSize);

(!LastElemToReplace)

assert((FirstElemToReplace == LastElemToReplace || AllowOverwrite) &&

);

replace(Elems, *FirstElemToReplace, *LastElemToReplace, {

});

replace(Offsets, *FirstElemToReplace, *LastElemToReplace, {Offset});

= std::max(Size, Offset + CSize);

NaturalLayout =

;

ConstantAggregateBuilder::addBits(llvm::APInt Bits, uint64_t OffsetInBits,

AllowOverwrite) {

OffsetWithinChar = OffsetInBits % CharWidth;

WantedBits =

std::min((uint64_t)Bits.getBitWidth(), CharWidth - OffsetWithinChar);

llvm::APInt BitsThisChar = Bits;

(BitsThisChar.getBitWidth() < CharWidth)

BitsThisChar = BitsThisChar.zext(CharWidth);

= Bits.getBitWidth() - CharWidth + OffsetWithinChar;

BitsThisChar.lshrInPlace(Shift);

BitsThisChar = BitsThisChar.shl(-Shift);

BitsThisChar = BitsThisChar.shl(OffsetWithinChar);

(BitsThisChar.getBitWidth() > CharWidth)

BitsThisChar = BitsThisChar.trunc(CharWidth);

(WantedBits == CharWidth) {

OffsetInChars, AllowOverwrite);

std::optional<size_t> FirstElemToUpdate = splitAt(OffsetInChars);

(!FirstElemToUpdate)

std::optional<size_t> LastElemToUpdate =

(!LastElemToUpdate)

assert(*LastElemToUpdate - *FirstElemToUpdate < 2 &&

);

llvm::APInt UpdateMask(CharWidth, 0);

UpdateMask.setBits(CharWidth - OffsetWithinChar - WantedBits,

CharWidth - OffsetWithinChar);

UpdateMask.setBits(OffsetWithinChar, OffsetWithinChar + WantedBits);

BitsThisChar &= UpdateMask;

(*FirstElemToUpdate == *LastElemToUpdate ||

Elems[*FirstElemToUpdate]->isNullValue() ||

isa<llvm::UndefValue>(Elems[*FirstElemToUpdate])) {

OffsetInChars,

);

llvm::Constant *&ToUpdate = Elems[*FirstElemToUpdate];

*CI = dyn_cast<llvm::ConstantInt>(ToUpdate);

assert(CI->getBitWidth() == CharWidth &&

);

assert((!(CI->getValue() & UpdateMask) || AllowOverwrite) &&

);

BitsThisChar |= (CI->getValue() & ~UpdateMask);

ToUpdate = llvm::ConstantInt::get(CGM.

(), BitsThisChar);

(WantedBits == Bits.getBitWidth())

Bits.lshrInPlace(WantedBits);

Bits = Bits.trunc(Bits.getBitWidth() - WantedBits);

OffsetWithinChar = 0;

std::optional<size_t> ConstantAggregateBuilder::splitAt(

Pos) {

Offsets.size();

FirstAfterPos = llvm::upper_bound(Offsets, Pos);

(FirstAfterPos == Offsets.begin())

LastAtOrBeforePosIndex = FirstAfterPos - Offsets.begin() - 1;

(Offsets[LastAtOrBeforePosIndex] == Pos)

LastAtOrBeforePosIndex;

(Offsets[LastAtOrBeforePosIndex] +

getSize(Elems[LastAtOrBeforePosIndex]) <= Pos)

LastAtOrBeforePosIndex + 1;

(!split(LastAtOrBeforePosIndex, Pos))

ConstantAggregateBuilder::split(

Index,

Hint) {

NaturalLayout =

;

llvm::Constant *

= Elems[Index];

(

*CA = dyn_cast<llvm::ConstantAggregate>(

)) {

replace(Elems, Index, Index + 1,

llvm::map_range(llvm::seq(0u, CA->getNumOperands()),

[&](

Op) { return CA->getOperand(Op); }));

(isa<llvm::ArrayType>(CA->getType()) ||

isa<llvm::VectorType>(CA->getType())) {

llvm::GetElementPtrInst::getTypeAtIndex(CA->getType(), (uint64_t)0);

Offsets, Index, Index + 1,

llvm::map_range(llvm::seq(0u, CA->getNumOperands()),

[&](

Op) { return Offset + Op * ElemSize; }));

*ST = cast<llvm::StructType>(CA->getType());

llvm::StructLayout *Layout =

replace(Offsets, Index, Index + 1,

llvm::seq(0u, CA->getNumOperands()), [&](

Op) {

return Offset + CharUnits::fromQuantity(

Layout->getElementOffset(Op));

(

*CDS = dyn_cast<llvm::ConstantDataSequential>(

)) {

ElemSize = getSize(CDS->getElementType());

replace(Elems, Index, Index + 1,

llvm::map_range(llvm::seq(0u, CDS->getNumElements()),

[&](

Elem) {

return CDS->getElementAsConstant(Elem);

replace(Offsets, Index, Index + 1,

llvm::seq(0u, CDS->getNumElements()),

[&](

Elem) { return Offset + Elem * ElemSize; }));

(isa<llvm::ConstantAggregateZero>(

)) {

assert(Hint > Offset && Hint < Offset + ElemSize &&

);

replace(Elems, Index, Index + 1,

{getZeroes(Hint - Offset), getZeroes(Offset + ElemSize - Hint)});

replace(Offsets, Index, Index + 1, {Offset, Hint});

(isa<llvm::UndefValue>(

)) {

replace(Elems, Index, Index + 1, {});

replace(Offsets, Index, Index + 1, {});

llvm::Constant *

EmitArrayConstant(

&CGM, llvm::ArrayType *DesiredType,

llvm::Type *CommonElementType, uint64_t ArrayBound,

llvm::Constant *Filler);

llvm::Constant *ConstantAggregateBuilder::buildFrom(

NaturalLayout, llvm::Type *DesiredTy,

AllowOversized) {

ConstantAggregateBuilderUtils Utils(CGM);

llvm::UndefValue::get(DesiredTy);

Offset = [&](

I) {

Offsets[I] - StartOffset; };

(llvm::ArrayType *ATy = dyn_cast<llvm::ArrayType>(DesiredTy)) {

assert(!AllowOversized &&

);

CanEmitArray =

;

llvm::Type *CommonType = Elems[0]->getType();

llvm::Constant *Filler = llvm::Constant::getNullValue(CommonType);

ElemSize = Utils.getSize(ATy->getElementType());

(

I = 0; I != Elems.size(); ++I) {

(Elems[I]->isNullValue())

(Elems[I]->getType() != CommonType ||

Offset(I) % ElemSize != 0) {

CanEmitArray =

;

ArrayElements.resize(Offset(I) / ElemSize + 1, Filler);

ArrayElements.back() = Elems[I];

EmitArrayConstant(CGM, ATy, CommonType, ATy->getNumElements(),

ArrayElements, Filler);

DesiredSize = Utils.getSize(DesiredTy);

(Size > DesiredSize) {

assert(AllowOversized &&

);

(llvm::Constant *

: Elems)

Align = std::max(Align, Utils.getAlignment(

));

Packed =

;

(DesiredSize < AlignedSize || DesiredSize.

(Align) != DesiredSize) {

NaturalLayout =

;

}

(DesiredSize > AlignedSize) {

UnpackedElemStorage.assign(Elems.begin(), Elems.end());

UnpackedElemStorage.push_back(Utils.getPadding(DesiredSize - Size));

UnpackedElems = UnpackedElemStorage;

(!NaturalLayout) {

(

I = 0; I != Elems.size(); ++I) {

Align = Utils.getAlignment(Elems[I]);

assert(DesiredOffset >= SizeSoFar &&

);

(DesiredOffset != NaturalOffset)

(DesiredOffset != SizeSoFar)

PackedElems.push_back(Utils.getPadding(DesiredOffset - SizeSoFar));

PackedElems.push_back(Elems[I]);

SizeSoFar = DesiredOffset + Utils.getSize(Elems[I]);

assert(SizeSoFar <= DesiredSize &&

);

(SizeSoFar < DesiredSize)

PackedElems.push_back(Utils.getPadding(DesiredSize - SizeSoFar));

llvm::StructType *STy = llvm::ConstantStruct::getTypeForElements(

CGM.

(), Packed ? PackedElems : UnpackedElems, Packed);

(llvm::StructType *DesiredSTy = dyn_cast<llvm::StructType>(DesiredTy)) {

(DesiredSTy->isLayoutIdentical(STy))

llvm::ConstantStruct::get(STy, Packed ? PackedElems : UnpackedElems);

ConstantAggregateBuilder::condense(

Offset,

llvm::Type *DesiredTy) {

std::optional<size_t> FirstElemToReplace = splitAt(Offset);

(!FirstElemToReplace)

= *FirstElemToReplace;

std::optional<size_t> LastElemToReplace = splitAt(Offset + Size);

(!LastElemToReplace)

= *LastElemToReplace;

(Length == 1 && Offsets[

] == Offset &&

getSize(Elems[

]) == Size) {

*STy = dyn_cast<llvm::StructType>(DesiredTy);

(STy && STy->getNumElements() == 1 &&

STy->getElementType(0) == Elems[

]->getType())

Elems[

] = llvm::ConstantStruct::get(STy, Elems[

]);

llvm::Constant *Replacement = buildFrom(

(Offsets).slice(

, Length), Offset, getSize(DesiredTy),

, DesiredTy,

);

replace(Elems,

,

, {Replacement});

replace(Offsets,

,

, {Offset});

ConstStructBuilder {

ConstantAggregateBuilder &Builder;

ConstantAggregateBuilder &Const,

Offset,

ConstantAggregateBuilder &Builder,

StartOffset)

StartOffset(StartOffset) {}

AppendField(

*Field, uint64_t FieldOffset,

llvm::Constant *InitExpr,

AllowOverwrite =

);

AppendBytes(

FieldOffsetInChars, llvm::Constant *InitCst,

AllowOverwrite =

);

AppendBitField(

*Field, uint64_t FieldOffset,

llvm::Constant *InitExpr,

AllowOverwrite =

);

Build(

*ILE,

AllowOverwrite);

DoZeroInitPadding(

&Layout,

FieldNo,

&Field,

AllowOverwrite,

&SizeSoFar,

&ZeroFieldSize);

DoZeroInitPadding(

&Layout,

AllowOverwrite,

ConstStructBuilder::AppendField(

*Field, uint64_t FieldOffset, llvm::Constant *InitCst,

AllowOverwrite) {

AppendBytes(FieldOffsetInChars, InitCst, AllowOverwrite);

ConstStructBuilder::AppendBytes(

FieldOffsetInChars,

llvm::Constant *InitCst,

AllowOverwrite) {

Builder.add(InitCst, StartOffset + FieldOffsetInChars, AllowOverwrite);

ConstStructBuilder::AppendBitField(

*Field,

uint64_t FieldOffset, llvm::Constant *

,

AllowOverwrite) {

llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(

);

llvm::Type *LoadType =

llvm::Constant *FoldedConstant = llvm::ConstantFoldLoadFromConst(

CI = dyn_cast_if_present<llvm::ConstantInt>(FoldedConstant);

llvm::APInt FieldValue = CI->getValue();

(Info.

> FieldValue.getBitWidth())

FieldValue = FieldValue.zext(Info.

);

(Info.

< FieldValue.getBitWidth())

FieldValue = FieldValue.trunc(Info.

);

Builder.addBits(FieldValue,

ConstantAggregateBuilder &Const,

ConstStructBuilder::UpdateStruct(

, Const, Offset, Updater);

CAT =

.CGM.getContext().getAsConstantArrayType(

);

ElemType = CAT->getElementType();

ElemSize =

.CGM.getContext().getTypeSizeInChars(ElemType);

llvm::Type *ElemTy =

.CGM.getTypes().ConvertTypeForMem(ElemType);

llvm::Constant *FillC =

;

(!isa<NoInitExpr>(Filler)) {

FillC =

.tryEmitAbstractForMemory(Filler, ElemType);

NumElementsToUpdate =

FillC ? CAT->getZExtSize() : Updater->

();

(

I = 0; I != NumElementsToUpdate; ++I, Offset += ElemSize) {

(I < Updater->getNumInits())

(!

&& FillC) {

(!

.add(FillC, Offset,

))

}

(!

|| isa<NoInitExpr>(

)) {

}

(

*ChildILE = dyn_cast<InitListExpr>(

)) {

(!EmitDesignatedInitUpdater(

, Const, Offset, ElemType,

.condense(Offset, ElemTy);

llvm::Constant *Val =

.tryEmitPrivateForMemory(

, ElemType);

(!

.add(Val, Offset,

))

ConstStructBuilder::Build(

*ILE,

AllowOverwrite) {

FieldNo = -1;

ElementNo = 0;

(

*CXXRD = dyn_cast<CXXRecordDecl>(RD))

(CXXRD->getNumBases())

ZeroFieldSize =

;

(

->isUnnamedBitField())

(ElementNo < ILE->getNumInits())

(isa_and_nonnull<NoInitExpr>(

)) {

(ZeroInitPadding &&

!DoZeroInitPadding(Layout, FieldNo, *Field, AllowOverwrite, SizeSoFar,

(ZeroInitPadding &&

!DoZeroInitPadding(Layout, FieldNo, *Field, AllowOverwrite, SizeSoFar,

(AllowOverwrite &&

(

->getType()->isArrayType() ||

->getType()->isRecordType())) {

(

*SubILE = dyn_cast<InitListExpr>(

)) {

(!EmitDesignatedInitUpdater(

, Builder, StartOffset + Offset,

->getType(), SubILE))

Builder.condense(StartOffset + Offset,

llvm::Constant *EltInit =

(ZeroInitPadding && ZeroFieldSize)

(!

->isBitField()) {

(!AppendField(Field, Layout.

(FieldNo), EltInit,

(

->hasAttr<NoUniqueAddressAttr>())

AllowOverwrite =

;

(!AppendBitField(Field, Layout.

(FieldNo), EltInit,

(ZeroInitPadding && !DoZeroInitPadding(Layout, AllowOverwrite, SizeSoFar))

:

(

), Offset(Offset), Index(Index) {

(

BaseInfo &O)

{

Offset < O.Offset; }

(

*CD = dyn_cast<CXXRecordDecl>(RD)) {

llvm::Constant *VTableAddressPoint =

VTableAddressPoint =

.tryEmitConstantSignedPointer(

VTableAddressPoint, *Authentication);

(!VTableAddressPoint)

(!AppendBytes(Offset, VTableAddressPoint))

Bases.reserve(CD->getNumBases());

BaseEnd = CD->bases_end();

!= BaseEnd; ++

, ++BaseNo) {

assert(!

->isVirtual() &&

);

Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo));

llvm::stable_sort(Bases);

(

I = 0, N = Bases.size(); I != N; ++I) {

BaseInfo &

= Bases[I];

VTableClass, Offset +

.Offset);

FieldNo = 0;

ZeroFieldSize =

;

AllowOverwrite =

;

FieldEnd = RD->

(); Field != FieldEnd; ++Field, ++FieldNo) {

(

->isUnnamedBitField() ||

llvm::Constant *EltInit =

.tryEmitPrivateForMemory(FieldValue,

->getType());

(ZeroInitPadding) {

(!DoZeroInitPadding(Layout, FieldNo, **Field, AllowOverwrite,

SizeSoFar, ZeroFieldSize))

(!

->isBitField()) {

(!AppendField(*Field, Layout.

(FieldNo) + OffsetBits,

EltInit, AllowOverwrite))

(

->hasAttr<NoUniqueAddressAttr>())

AllowOverwrite =

;

(!AppendBitField(*Field, Layout.

(FieldNo) + OffsetBits,

EltInit, AllowOverwrite))

(ZeroInitPadding && !DoZeroInitPadding(Layout, AllowOverwrite, SizeSoFar))

ConstStructBuilder::DoZeroInitPadding(

AllowOverwrite,

&SizeSoFar,

&ZeroFieldSize) {

(SizeSoFar < StartOffset)

(!AppendBytes(SizeSoFar, getPadding(CGM, StartOffset - SizeSoFar),

(!

.isBitField()) {

SizeSoFar = StartOffset + FieldSize;

ZeroFieldSize = FieldSize.

();

ZeroFieldSize = Info.

== 0;

ConstStructBuilder::DoZeroInitPadding(

&Layout,

(SizeSoFar < TotalSize)

(!AppendBytes(SizeSoFar, getPadding(CGM, TotalSize - SizeSoFar),

SizeSoFar = TotalSize;

llvm::Constant *ConstStructBuilder::Finalize(

) {

(!Builder.Build(ILE,

))

Builder.Finalize(ValTy);

Builder.Finalize(ValTy);

ConstantAggregateBuilder &Const,

ConstStructBuilder(

, Const, Offset)

.Build(Updater,

);

(llvm::GlobalVariable *Addr =

assert(!

->isFileScope() &&

);

GV =

llvm::GlobalVariable(

llvm::GlobalValue::InternalLinkage,

,

,

,

llvm::GlobalVariable::NotThreadLocal,

llvm::Constant *

EmitArrayConstant(

&CGM, llvm::ArrayType *DesiredType,

llvm::Type *CommonElementType, uint64_t ArrayBound,

llvm::Constant *Filler) {

NonzeroLength = ArrayBound;

(Elements.size() < NonzeroLength && Filler->isNullValue())

NonzeroLength = Elements.size();

(NonzeroLength == Elements.size()) {

(NonzeroLength > 0 && Elements[NonzeroLength - 1]->isNullValue())

(NonzeroLength == 0)

llvm::ConstantAggregateZero::get(DesiredType);

TrailingZeroes = ArrayBound - NonzeroLength;

(TrailingZeroes >= 8) {

assert(Elements.size() >= NonzeroLength &&

);

(CommonElementType && NonzeroLength >= 8) {

llvm::Constant *Initial = llvm::ConstantArray::get(

llvm::ArrayType::get(CommonElementType, NonzeroLength),

(Elements).take_front(NonzeroLength));

Elements[0] = Initial;

Elements.resize(NonzeroLength + 1);

CommonElementType ? CommonElementType : DesiredType->getElementType();

FillerType = llvm::ArrayType::get(FillerType, TrailingZeroes);

Elements.back() = llvm::ConstantAggregateZero::get(FillerType);

CommonElementType =

;

}

(Elements.size() != ArrayBound) {

Elements.resize(ArrayBound, Filler);

(Filler->getType() != CommonElementType)

CommonElementType =

;

(CommonElementType)

llvm::ConstantArray::get(

llvm::ArrayType::get(CommonElementType, ArrayBound), Elements);

Types.reserve(Elements.size());

(llvm::Constant *Elt : Elements)

Types.push_back(Elt->getType());

llvm::StructType *SType =

llvm::ConstantStruct::get(SType, Elements);

ConstExprEmitter

llvm::LLVMContext &VMContext;

: CGM(emitter.CGM),

(emitter), VMContext(CGM.getLLVMContext()) {

llvm::Constant *VisitStmt(

*S,

) {

; }

(llvm::Constant *Result =

.tryEmitConstantExpr(CE))

(

->getResultExpr(),

);

(

->getInitializer(),

);

llvm::Constant *ProduceIntToIntCast(

*

,

DestType) {

(llvm::Constant *

=

(

, FromType))

(

*CI = dyn_cast<llvm::ConstantInt>(

)) {

(DstWidth == SrcWidth)

? CI->getValue().sextOrTrunc(DstWidth)

: CI->getValue().zextOrTrunc(DstWidth);

(

*ECE = dyn_cast<ExplicitCastExpr>(

))

*subExpr =

->getSubExpr();

(

->getCastKind()) {

);

field =

->getTargetUnionField();

=

.tryEmitPrivateForMemory(subExpr, field->getType());

(!

)

;

destTy = ConvertType(destType);

(

->getType() == destTy)

;

Elts.push_back(

);

Types.push_back(

->getType());

CurSize = CGM.

().getTypeAllocSize(

->getType());

TotalSize = CGM.

().getTypeAllocSize(destTy);

assert(CurSize <= TotalSize &&

);

(

NumPadBytes = TotalSize - CurSize) {

llvm::Constant *Padding =

Elts.push_back(Padding);

Types.push_back(Padding->getType());

llvm::StructType *STy = llvm::StructType::get(VMContext, Types,

);

llvm::ConstantStruct::get(STy, Elts);

CK_AddressSpaceConversion: {

(!

)

;

llvm::Type *destTy = ConvertType(

->

());

CK_LValueToRValue: {

(

*

=

dyn_cast<CompoundLiteralExpr>(subExpr->

()))

(

->getInitializer(), destType);

CK_AtomicToNonAtomic:

CK_NonAtomicToAtomic:

CK_ConstructorConversion:

(subExpr, destType);

CK_ArrayToPointerDecay:

(

*S = dyn_cast<StringLiteral>(subExpr))

CK_NullToPointer:

(

(subExpr, destType))

CK_IntToOCLSampler:

llvm_unreachable(

);

CK_IntegralCast:

ProduceIntToIntCast(subExpr, destType);

CK_Dependent: llvm_unreachable(

);

CK_BuiltinFnToFnPtr:

llvm_unreachable(

);

CK_ReinterpretMemberPointer:

CK_DerivedToBaseMemberPointer:

CK_BaseToDerivedMemberPointer: {

(!

)

;

CK_ObjCObjectLValueCast:

CK_ARCProduceObject:

CK_ARCConsumeObject:

CK_ARCReclaimReturnedObject:

CK_ARCExtendBlockObject:

CK_CopyAndAutoreleaseBlockObject:

CK_LValueBitCast:

CK_LValueToRValueBitCast:

CK_NullToMemberPointer:

CK_UserDefinedConversion:

CK_CPointerToObjCPointerCast:

CK_BlockPointerToObjCPointerCast:

CK_AnyPointerToBlockPointerCast:

CK_FunctionToPointerDecay:

CK_BaseToDerived:

CK_DerivedToBase:

CK_UncheckedDerivedToBase:

CK_MemberPointerToBoolean:

CK_VectorSplat:

CK_FloatingRealToComplex:

CK_FloatingComplexToReal:

CK_FloatingComplexToBoolean:

CK_FloatingComplexCast:

CK_FloatingComplexToIntegralComplex:

CK_IntegralRealToComplex:

CK_IntegralComplexToReal:

CK_IntegralComplexToBoolean:

CK_IntegralComplexCast:

CK_IntegralComplexToFloatingComplex:

CK_PointerToIntegral:

CK_PointerToBoolean:

CK_BooleanToSignedIntegral:

CK_IntegralToPointer:

CK_IntegralToBoolean:

CK_IntegralToFloating:

CK_FloatingToIntegral:

CK_FloatingToBoolean:

CK_FloatingCast:

CK_FloatingToFixedPoint:

CK_FixedPointToFloating:

CK_FixedPointCast:

CK_FixedPointToBoolean:

CK_FixedPointToIntegral:

CK_IntegralToFixedPoint:

CK_ZeroToOCLOpaqueType:

CK_HLSLVectorTruncation:

CK_HLSLArrayRValue:

llvm_unreachable(

);

(

->getSubExpr(),

);

llvm::APFloat Result =

llvm::RoundingMode RM =

(RM == llvm::RoundingMode::Dynamic)

RM = llvm::RoundingMode::NearestTiesToEven;

Result.convertFromAPInt(

,

.isSigned(), RM);

assert(CAT &&

);

NumElements = CAT->getZExtSize();

(

*

: ILE->

()) {

(

*Embed =

dyn_cast<EmbedExpr>(

->IgnoreParenImpCasts())) {

NumInitElements += Embed->getDataElementCount() - 1;

(NumInitElements > NumElements) {

NumInitElements = NumElements;

NumInitableElts = std::min<uint64_t>(NumInitElements, NumElements);

EltType = CAT->getElementType();

llvm::Constant *fillC =

;

fillC =

.tryEmitAbstractForMemory(filler, EltType);

(fillC && fillC->isNullValue())

Elts.reserve(NumInitableElts + 1);

Elts.reserve(NumElements);

llvm::Type *CommonElementType =

;

Emit = [&](

*

,

ArrayIndex) {

llvm::Constant *

=

;

(ArrayIndex == 0)

CommonElementType =

->getType();

(

->getType() != CommonElementType)

CommonElementType =

;

Elts.push_back(

);

ArrayIndex = 0;

DestTy = CAT->getElementType();

(

i = 0; i < ILE->

(); ++i) {

(

*EmbedS = dyn_cast<EmbedExpr>(

->IgnoreParenImpCasts())) {

llvm::Constant *

;

(

I = EmbedS->getStartingElementPos(),

N = EmbedS->getDataElementCount();

I != EmbedS->getStartingElementPos() + N; ++I) {

=

.tryEmitPrivateForMemory(

withDestType(CGM.

(),

, EmbedS->getType(), DestTy,

Elts.push_back(

);

((ArrayIndex - EmbedS->getDataElementCount()) == 0)

CommonElementType =

->getType();

(

->getType() != CommonElementType)

CommonElementType =

;

(!Emit(

, ArrayIndex))

llvm::ArrayType *Desired =

EmitArrayConstant(CGM, Desired, CommonElementType, NumElements, Elts,

llvm::Constant *EmitRecordInitialization(

*ILE,

ConstStructBuilder::BuildStruct(

, ILE,

);

EmitArrayInitialization(ILE,

);

EmitRecordInitialization(ILE,

);

=

(

->getBase(), destType);

ConstantAggregateBuilder

(CGM);

HasFlexibleArray =

;

HasFlexibleArray = RT->getDecl()->hasFlexibleArrayMember();

.build(ValTy, HasFlexibleArray);

(!

->getConstructor()->isTrivial())

(

->getNumArgs()) {

assert(

->getNumArgs() == 1 &&

);

assert(

->getConstructor()->isCopyOrMoveConstructor() &&

);

*Arg =

->getArg(0);

);

(

*MTE = dyn_cast<MaterializeTemporaryExpr>(Arg))

(MTE->getSubExpr(), Ty);

assert(CAT &&

);

llvm::ConstantDataArray::getString(VMContext, Str,

);

(

->getSubExpr(),

);

(llvm::Constant *

=

(

->getSubExpr(),

))

(

*CI = dyn_cast<llvm::ConstantInt>(

))

llvm::ConstantInt::get(CGM.

(), -CI->getValue());

(

->getSelectedExpr(),

);

llvm::Constant *ConstantEmitter::validateAndPopAbstract(llvm::Constant *

,

AbstractState saved) {

Abstract = saved.OldValue;

assert(saved.OldPlaceholdersSize == PlaceholderAddresses.size() &&

);

state = pushAbstract();

validateAndPopAbstract(

, state);

state = pushAbstract();

validateAndPopAbstract(

, state);

state = pushAbstract();

validateAndPopAbstract(

, state);

state = pushAbstract();

= validateAndPopAbstract(

, state);

);

EnablePtrAuthFunctionTypeDiscrimination) {

state = pushAbstract();

(value, destType, EnablePtrAuthFunctionTypeDiscrimination);

= validateAndPopAbstract(

, state);

);

initializeNonAbstract(

.getType().getAddressSpace());

initializeNonAbstract(destAddrSpace);

initializeNonAbstract(destAddrSpace);

assert(

&&

);

assert(!Abstract &&

);

llvm::GlobalValue::PrivateLinkage,

llvm::GlobalVariable::NotThreadLocal,

PlaceholderAddresses.push_back(std::make_pair(

, global));

llvm::GlobalValue *placeholder) {

assert(!PlaceholderAddresses.empty());

assert(PlaceholderAddresses.back().first ==

);

assert(PlaceholderAddresses.back().second == placeholder);

PlaceholderAddresses.back().first = signal;

ReplacePlaceholders {

llvm::Constant *

;

llvm::Type *BaseValueTy =

;

llvm::DenseMap<llvm::Constant*, llvm::GlobalVariable*> PlaceholderAddresses;

llvm::DenseMap<llvm::GlobalVariable*, llvm::Constant*> Locations;

ReplacePlaceholders(

&CGM, llvm::Constant *base,

<std::pair<llvm::Constant*,

llvm::GlobalVariable*>> addresses)

: CGM(CGM),

(base),

PlaceholderAddresses(addresses.begin(), addresses.end()) {

replaceInInitializer(llvm::Constant *init) {

BaseValueTy = init->getType();

Indices.push_back(0);

IndexValues.push_back(

);

findLocations(init);

assert(IndexValues.size() == Indices.size() &&

);

assert(Indices.size() == 1 &&

);

assert(Locations.size() == PlaceholderAddresses.size() &&

);

(

&entry : Locations) {

assert(entry.first->getName() ==

&&

);

entry.first->replaceAllUsesWith(entry.second);

entry.first->eraseFromParent();

findLocations(llvm::Constant *init) {

(

agg = dyn_cast<llvm::ConstantAggregate>(init)) {

(

i = 0, e = agg->getNumOperands(); i != e; ++i) {

Indices.push_back(i);

IndexValues.push_back(

);

findLocations(agg->getOperand(i));

IndexValues.pop_back();

it = PlaceholderAddresses.find(init);

(it != PlaceholderAddresses.end()) {

setLocation(it->second);

(

= dyn_cast<llvm::ConstantExpr>(init)) {

init =

->getOperand(0);

setLocation(llvm::GlobalVariable *placeholder) {

assert(!Locations.contains(placeholder) &&

);

assert(Indices.size() == IndexValues.size());

(

i = Indices.size() - 1; i !=

(-1); --i) {

(IndexValues[i]) {

(

j = 0; j != i + 1; ++j) {

assert(IndexValues[j] &&

isa<llvm::ConstantInt>(IndexValues[j]) &&

cast<llvm::ConstantInt>(IndexValues[j])->getZExtValue()

IndexValues[i] = llvm::ConstantInt::get(CGM.

, Indices[i]);

llvm::Constant *location = llvm::ConstantExpr::getInBoundsGetElementPtr(

BaseValueTy,

, IndexValues);

Locations.insert({placeholder, location});

assert(InitializedNonAbstract &&

);

assert(!Finalized &&

);

assert(global->getInitializer());

(!PlaceholderAddresses.empty()) {

ReplacePlaceholders(

, global, PlaceholderAddresses)

.replaceInInitializer(global->getInitializer());

PlaceholderAddresses.clear();

assert((!InitializedNonAbstract || Finalized || Failed) &&

);

assert(PlaceholderAddresses.empty() &&

);

.getQualifiers());

(!

.hasLocalStorage()) {

dyn_cast_or_null<CXXConstructExpr>(

.getInit())) {

InConstantContext =

.hasConstantInitialization();

*

=

.getInit();

assert(

&&

);

(llvm::Constant *

= ConstExprEmitter(*this).Visit(

, nonMemoryDestType))

(

*value =

.evaluateValue())

assert(Schema &&

);

UnsignedPointer;

Key = Schema.

();

llvm::GlobalValue *StorageAddress =

;

llvm::ConstantInt *Discriminator =

UnsignedPointer, Key, StorageAddress, Discriminator);

SignedPointer;

llvm::Constant *

,

destValueType = AT->getValueType();

(innerSize == outerSize)

assert(innerSize < outerSize &&

);

llvm::Constant *elts[] = {

llvm::ConstantAggregateZero::get(

llvm::ArrayType::get(

.

, (outerSize - innerSize) / 8))

llvm::ConstantStruct::getAnon(elts);

(

->getType()->isIntegerTy(1) && !destType->

()) {

llvm::Constant *Res = llvm::ConstantFoldCastOperand(

assert(Res &&

);

ConstantAggregateBuilder Builder(

);

*CI = cast<llvm::ConstantInt>(

);

llvm::Constant *Res = llvm::ConstantFoldCastOperand(

: llvm::Instruction::ZExt,

llvm::APInt

= cast<llvm::ConstantInt>(Res)->getValue();

Builder.addBits(

,

0,

);

Builder.build(DesiredTy,

);

assert(!destType->

() &&

);

(llvm::Constant *

= ConstExprEmitter(*this).Visit(

, destType))

ConstantLValue {

llvm::Constant *

;

HasOffsetApplied;

ConstantLValue(llvm::Constant *value,

hasOffsetApplied =

)

:

(value), HasOffsetApplied(hasOffsetApplied) {}

: ConstantLValue(address.getPointer()) {}

ConstantLValueEmitter :

<ConstantLValueEmitter,

EnablePtrAuthFunctionTypeDiscrimination;

EnablePtrAuthFunctionTypeDiscrimination =

)

: CGM(emitter.CGM),

(emitter),

(value), DestType(destType),

EnablePtrAuthFunctionTypeDiscrimination(

EnablePtrAuthFunctionTypeDiscrimination) {}

llvm::Constant *tryEmit();

llvm::Constant *tryEmitAbsolute(llvm::Type *destTy);

ConstantLValue VisitStmt(

*S) {

; }

ConstantLValue VisitCallExpr(

*

);

ConstantLValue VisitBlockExpr(

*

);

ConstantLValue VisitMaterializeTemporaryExpr(

ConstantLValue emitPointerAuthSignConstant(

*

);

llvm::Constant *emitPointerAuthPointer(

*

);

emitPointerAuthKey(

*

);

std::pair<llvm::Constant *, llvm::ConstantInt *>

emitPointerAuthDiscriminator(

*

);

hasNonZeroOffset()

{

!

.getLValueOffset().isZero();

llvm::Constant *getOffset() {

llvm::ConstantInt::get(CGM.

,

.getLValueOffset().getQuantity());

llvm::Constant *applyOffset(llvm::Constant *

) {

(!hasNonZeroOffset())

llvm::ConstantExpr::getGetElementPtr(CGM.

,

, getOffset());

llvm::Constant *ConstantLValueEmitter::tryEmit() {

assert(isa<llvm::IntegerType>(destTy) || isa<llvm::PointerType>(destTy));

tryEmitAbsolute(destTy);

ConstantLValue result = tryEmitBase(base);

llvm::Constant *value = result.Value;

(!value)

;

(!result.HasOffsetApplied) {

value = applyOffset(value);

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

llvm::ConstantExpr::getPointerCast(value, destTy);

llvm::ConstantExpr::getPtrToInt(value, destTy);

ConstantLValueEmitter::tryEmitAbsolute(llvm::Type *destTy) {

destPtrTy = cast<llvm::PointerType>(destTy);

(

.isNullPointer()) {

intptrTy = CGM.

().getIntPtrType(destPtrTy);

llvm::Constant *

;

= llvm::ConstantFoldIntegerCast(getOffset(), intptrTy,

,

assert(

&&

);

= llvm::ConstantExpr::getIntToPtr(

, destPtrTy);

PtrAuthSign = [&](llvm::Constant *

) {

(EnablePtrAuthFunctionTypeDiscrimination)

(hasNonZeroOffset())

ConstantLValue(

);

= applyOffset(

);

, AuthInfo.

(),

,

ConstantLValue(

,

);

ConstantLValue(

);

(

*FD = dyn_cast<FunctionDecl>(

))

(

*VD = dyn_cast<VarDecl>(

)) {

(!VD->hasLocalStorage()) {

(VD->isFileVarDecl() || VD->hasExternalStorage())

(VD->isLocalVarDecl()) {

(

*GD = dyn_cast<MSGuidDecl>(

))

(

*GCD = dyn_cast<UnnamedGlobalConstantDecl>(

))

(

*TPO = dyn_cast<TemplateParamObjectDecl>(

))

Visit(base.

<

*>());

ConstantLValueEmitter::VisitConstantExpr(

*

) {

Visit(

->getSubExpr());

CompoundLiteralEmitter.setInConstantContext(

.isInConstantContext());

tryEmitGlobalCompoundLiteral(CompoundLiteralEmitter,

);

ConstantLValueEmitter::VisitStringLiteral(

*

) {

ConstantLValueEmitter::VisitObjCEncodeExpr(

*

) {

ConstantLValueEmitter::VisitObjCBoxedExpr(

*

) {

assert(

->isExpressibleAsConstantInitializer() &&

);

ConstantLValueEmitter::VisitPredefinedExpr(

*

) {

ConstantLValueEmitter::VisitAddrLabelExpr(

*

) {

assert(

.CGF &&

);

llvm::Constant *Ptr =

.CGF->GetAddrOfLabel(

->getLabel());

ConstantLValueEmitter::VisitCallExpr(

*

) {

builtin =

->getBuiltinCallee();

(builtin == Builtin::BI__builtin_function_start)

(builtin == Builtin::BI__builtin_ptrauth_sign_constant)

emitPointerAuthSignConstant(

);

(builtin != Builtin::BI__builtin___CFStringMakeConstantString &&

builtin != Builtin::BI__builtin___NSStringMakeConstantString)

(builtin == Builtin::BI__builtin___NSStringMakeConstantString) {

ConstantLValueEmitter::emitPointerAuthSignConstant(

*

) {

llvm::Constant *UnsignedPointer = emitPointerAuthPointer(

->getArg(0));

Key = emitPointerAuthKey(

->getArg(1));

[StorageAddress, OtherDiscriminator] =

emitPointerAuthDiscriminator(

->getArg(2));

UnsignedPointer, Key, StorageAddress, OtherDiscriminator);

SignedPointer;

llvm::Constant *ConstantLValueEmitter::emitPointerAuthPointer(

*

) {

assert(

.Val.isLValue());

(isa<FunctionDecl>(

.Val.getLValueBase().get<

*>()))

assert(

.Val.getLValueOffset().isZero());

ConstantLValueEmitter::emitPointerAuthKey(

*

) {

std::pair<llvm::Constant *, llvm::ConstantInt *>

ConstantLValueEmitter::emitPointerAuthDiscriminator(

*

) {

(

*

= dyn_cast<CallExpr>(

)) {

(

->getBuiltinCallee() ==

Builtin::BI__builtin_ptrauth_blend_discriminator) {

->getArg(0),

->getArg(0)->getType());

*Extra = cast<llvm::ConstantInt>(

(CGM).emitAbstract(

->getArg(1),

->getArg(1)->getType()));

(

->getType()->isPointerTy())

{

,

};

{

, cast<llvm::ConstantInt>(

)};

ConstantLValueEmitter::VisitBlockExpr(

*

) {

StringRef functionName;

functionName = CGF->CurFn->getName();

functionName =

;

ConstantLValueEmitter::VisitCXXTypeidExpr(

*

) {

(

->isTypeOperand())

ConstantLValueEmitter::VisitMaterializeTemporaryExpr(

assert(

->getStorageDuration() ==

);

EnablePtrAuthFunctionTypeDiscrimination) {

ConstantLValueEmitter(*

,

, DestType,

EnablePtrAuthFunctionTypeDiscrimination)

.getFixedPoint().getValue());

.getComplexIntReal());

.getComplexIntImag());

llvm::StructType *STy =

llvm::StructType::get(

[0]->getType(),

[1]->getType());

llvm::ConstantStruct::get(STy,

);

llvm::APFloat &

=

.getFloat();

(&

.getSemantics() == &llvm::APFloat::IEEEhalf() &&

.bitcastToAPInt());

.getComplexFloatReal());

.getComplexFloatImag());

llvm::StructType *STy =

llvm::StructType::get(

[0]->getType(),

[1]->getType());

llvm::ConstantStruct::get(STy,

);

NumElts =

.getVectorLength();

(

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

llvm_unreachable(

);

llvm::ConstantVector::get(Inits);

(!LHS || !RHS)

;

LHS = llvm::ConstantExpr::getPtrToInt(LHS,

.

);

RHS = llvm::ConstantExpr::getPtrToInt(RHS,

.

);

llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS);

llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType);

ConstStructBuilder::BuildStruct(*

,

, DestType);

NumElements =

.getArraySize();

NumInitElts =

.getArrayInitializedElts();

llvm::Constant *Filler =

;

(

.hasArrayFiller()) {

(Filler && Filler->isNullValue())

Elts.reserve(NumInitElts + 1);

Elts.reserve(NumElements);

llvm::Type *CommonElementType =

;

(

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

(!

)

;

CommonElementType =

->getType();

(

->getType() != CommonElementType)

CommonElementType =

;

Elts.push_back(

);

llvm::ArrayType *Desired =

Desired = llvm::ArrayType::get(Desired->getElementType(), Elts.size());

EmitArrayConstant(

, Desired, CommonElementType, NumElements, Elts,

llvm_unreachable(

);

EmittedCompoundLiterals.lookup(

);

= EmittedCompoundLiterals.insert(std::make_pair(CLE, GV)).second;

assert(

&&

);

assert(

->isFileScope() &&

);

tryEmitGlobalCompoundLiteral(emitter,

);

llvm::Type *baseType,

asCompleteObject) {

llvm::StructType *structure =

numElements = structure->getNumElements();

std::vector<llvm::Constant *> elements(numElements);

CXXR = dyn_cast<CXXRecordDecl>(record);

(

&I : CXXR->bases()) {

(I.isVirtual()) {

llvm::Type *baseType = structure->getElementType(fieldIndex);

(

*Field : record->

()) {

(!Field->isBitField() &&

(Field->getIdentifier())

(

*FieldRD = Field->getType()->getAsRecordDecl())

(FieldRD->findFirstNamedDataMember())

(CXXR && asCompleteObject) {

(

&I : CXXR->vbases()) {

(elements[fieldIndex])

;

llvm::Type *baseType = structure->getElementType(fieldIndex);

(

i = 0; i != numElements; ++i) {

elements[i] = llvm::Constant::getNullValue(structure->getElementType(i));

llvm::ConstantStruct::get(structure, elements);

llvm::Type *baseType,

llvm::Constant::getNullValue(baseType);

cast<llvm::PointerType>(

().ConvertTypeForMem(

)),

);

(

().isZeroInitializable(

))

llvm::Constant::getNullValue(

().ConvertTypeForMem(

));

llvm::ArrayType *ATy =

cast<llvm::ArrayType>(

().ConvertTypeForMem(

));

llvm::Constant *Element =

llvm::ConstantArray::get(ATy, Array);

return ::EmitNullConstant(*

, RT->getDecl(),

);

);

return ::EmitNullConstant(*

,

,

);

Defines the clang::ASTContext interface.

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

static QualType getNonMemoryType(CodeGenModule &CGM, QualType type)

static llvm::Constant * EmitNullConstant(CodeGenModule &CGM, const RecordDecl *record, bool asCompleteObject)

static ConstantLValue emitConstantObjCStringLiteral(const StringLiteral *S, QualType T, CodeGenModule &CGM)

static llvm::Constant * EmitNullConstantForBase(CodeGenModule &CGM, llvm::Type *baseType, const CXXRecordDecl *base)

Emit the null constant for a base subobject.

llvm::MachO::Record Record

llvm::APInt getValue() const

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

APValue & getStructField(unsigned i)

const FieldDecl * getUnionField() const

APValue & getUnionValue()

bool isIndeterminate() const

@ Indeterminate

This object has an indeterminate value (C++ [basic.indet]).

@ None

There is no such object (it's outside its lifetime).

APValue & getStructBase(unsigned i)

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

const ConstantArrayType * getAsConstantArrayType(QualType T) const

CharUnits getTypeAlignInChars(QualType T) const

Return the ABI-specified alignment of a (complete) type T, in characters.

unsigned getIntWidth(QualType T) const

const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const

Return the APFloat 'semantics' for the specified scalar floating point type.

uint64_t getFieldOffset(const ValueDecl *FD) const

Get the offset of a FieldDecl or IndirectFieldDecl, in bits.

void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const

Emit the Objective-CC type encoding for the given type T into S.

const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const

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

bool hasSameType(QualType T1, QualType T2) const

Determine whether the given types T1 and T2 are equivalent.

QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const

Return the uniqued reference to the type for an lvalue reference to the specified type.

const LangOptions & getLangOpts() const

QualType getBaseElementType(const ArrayType *VAT) const

Return the innermost element type of an array type.

QualType getQualifiedType(SplitQualType split) const

Un-split a SplitQualType.

int64_t toBits(CharUnits CharSize) const

Convert a size in characters to a size in bits.

bool hasSameUnqualifiedType(QualType T1, QualType T2) const

Determine whether the given types are equivalent after cvr-qualifiers have been removed.

const ArrayType * getAsArrayType(QualType T) const

Type Query functions.

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.

const TargetInfo & getTargetInfo() const

CharUnits toCharUnitsFromBits(int64_t BitSize) const

Convert a size in bits to a size in characters.

unsigned getTargetAddressSpace(LangAS AS) const

uint64_t getCharWidth() const

Return the size of the character type, in bits.

ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...

bool hasOwnVFPtr() const

hasOwnVFPtr - Does this class provide its own virtual-function table pointer, rather than inheriting ...

CharUnits getSize() const

getSize - Get the record size in characters.

uint64_t getFieldOffset(unsigned FieldNo) const

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

CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const

getBaseClassOffset - Get the offset, in chars, for the given base class.

const CXXRecordDecl * getPrimaryBase() const

getPrimaryBase - Get the primary base for this record.

CharUnits getNonVirtualSize() const

getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...

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

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

QualType getElementType() const

BlockExpr - Adaptor class for mixing a BlockDecl with expressions.

Represents a base class of a C++ class.

Represents a call to a C++ constructor.

Represents a C++ constructor within a class.

bool isDefaultConstructor() const

Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...

A use of a default initializer in a constructor or in aggregate initialization.

Expr * getExpr()

Get the initialization expression that will be used.

Represents a static or instance method of a struct/union/class.

Represents a C++ struct/union/class.

A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...

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

CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...

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

bool isZero() const

isZero - Test whether the quantity equals zero.

llvm::Align getAsAlign() const

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

QuantityType getQuantity() const

getQuantity - Get the raw integer representation of this quantity.

static CharUnits One()

One - Construct a CharUnits quantity of one.

static CharUnits fromQuantity(QuantityType Quantity)

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

CharUnits alignTo(const CharUnits &Align) const

alignTo - Returns the next integer (mod 2**64) that is greater than or equal to this quantity and is ...

static CharUnits Zero()

Zero - Construct a CharUnits quantity of zero.

ChooseExpr - GNU builtin-in function __builtin_choose_expr.

Expr * getChosenSubExpr() const

getChosenSubExpr - Return the subexpression chosen according to the condition.

virtual llvm::Constant * EmitNullMemberPointer(const MemberPointerType *MPT)

Create a null member pointer of the given type.

virtual llvm::Constant * EmitMemberPointer(const APValue &MP, QualType MPT)

Create a member pointer for the given member pointer constant.

virtual llvm::Constant * getVTableAddressPoint(BaseSubobject Base, const CXXRecordDecl *VTableClass)=0

Get the address point of the vtable for the given base subobject.

virtual llvm::Constant * EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset)

Create a member pointer for the given field.

virtual llvm::Value * EmitMemberPointerConversion(CodeGenFunction &CGF, const CastExpr *E, llvm::Value *Src)

Perform a derived-to-base, base-to-derived, or bitcast member pointer conversion.

virtual llvm::Constant * EmitMemberFunctionPointer(const CXXMethodDecl *MD)

Create a member pointer for the given method.

virtual ConstantAddress GenerateConstantString(const StringLiteral *)=0

Generate a constant string object.

llvm::Value * getDiscriminator() const

CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM typ...

unsigned getNonVirtualBaseLLVMFieldNo(const CXXRecordDecl *RD) const

llvm::StructType * getLLVMType() const

Return the "complete object" LLVM type associated with this record.

const CGBitFieldInfo & getBitFieldInfo(const FieldDecl *FD) const

Return the BitFieldInfo that corresponds to the field FD.

bool isZeroInitializableAsBase() const

Check whether this struct can be C++ zero-initialized with a zeroinitializer when considered as a bas...

llvm::StructType * getBaseSubobjectLLVMType() const

Return the "base subobject" LLVM type associated with this record.

unsigned getLLVMFieldNo(const FieldDecl *FD) const

Return llvm::StructType element number that corresponds to the field FD.

unsigned getVirtualBaseIndex(const CXXRecordDecl *base) const

Return the LLVM field index corresponding to the given virtual base.

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

ConstantAddress GetAddrOfMSGuidDecl(const MSGuidDecl *GD)

Get the address of a GUID.

void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)

Emit type info if type of an expression is a variably modified type.

llvm::Module & getModule() const

ConstantAddress GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E)

Returns a pointer to a constant global variable for the given file-scope compound literal expression.

llvm::Constant * EmitNullConstantForBase(const CXXRecordDecl *Record)

Return a null constant appropriate for zero-initializing a base class with the given type.

llvm::Constant * getRawFunctionPointer(GlobalDecl GD, llvm::Type *Ty=nullptr)

Return a function pointer for a reference to the given function.

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

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

llvm::Constant * getNullPointer(llvm::PointerType *T, QualType QT)

Get target specific null pointer.

llvm::Constant * GetAddrOfGlobalBlock(const BlockExpr *BE, StringRef Name)

Gets the address of a block which requires no captures.

CodeGenTypes & getTypes()

llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD)

Returns LLVM linkage for a declarator.

llvm::Constant * getMemberPointerConstant(const UnaryOperator *e)

const llvm::DataLayout & getDataLayout() const

void Error(SourceLocation loc, StringRef error)

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

CGCXXABI & getCXXABI() const

ConstantAddress GetWeakRefReference(const ValueDecl *VD)

Get a reference to the target of VD.

CGPointerAuthInfo getFunctionPointerAuthInfo(QualType T)

Return the abstract pointer authentication schema for a pointer to the given function type.

llvm::Constant * GetFunctionStart(const ValueDecl *Decl)

llvm::GlobalVariable * getAddrOfConstantCompoundLiteralIfEmitted(const CompoundLiteralExpr *E)

If it's been emitted already, returns the GlobalVariable corresponding to a compound literal.

std::optional< PointerAuthQualifier > getVTablePointerAuthentication(const CXXRecordDecl *thisClass)

llvm::Constant * getOrCreateStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)

ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal)

Return a pointer to a constant CFString object for the given string.

ConstantAddress GetAddrOfConstantStringFromLiteral(const StringLiteral *S, StringRef Name=".str")

Return a pointer to a constant array for the given string literal.

ASTContext & getContext() const

ConstantAddress GetAddrOfTemplateParamObject(const TemplateParamObjectDecl *TPO)

Get the address of a template parameter object.

ConstantAddress GetAddrOfUnnamedGlobalConstantDecl(const UnnamedGlobalConstantDecl *GCD)

Get the address of a UnnamedGlobalConstant.

llvm::Constant * GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty=nullptr, ForDefinition_t IsForDefinition=NotForDefinition)

Return the llvm::Constant for the address of the given global variable.

void setAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *CLE, llvm::GlobalVariable *GV)

Notes that CLE's GlobalVariable is GV.

const TargetCodeGenInfo & getTargetCodeGenInfo()

llvm::Constant * GetConstantArrayFromStringLiteral(const StringLiteral *E)

Return a constant array for the given string.

llvm::LLVMContext & getLLVMContext()

bool shouldZeroInitPadding() const

CGObjCRuntime & getObjCRuntime()

Return a reference to the configured Objective-C runtime.

ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner)

Returns a pointer to a global variable representing a temporary with static or thread storage duratio...

llvm::Constant * EmitNullConstant(QualType T)

Return the result of value-initializing the given type, i.e.

llvm::Constant * getConstantSignedPointer(llvm::Constant *Pointer, const PointerAuthSchema &Schema, llvm::Constant *StorageAddress, GlobalDecl SchemaDecl, QualType SchemaType)

Sign a constant pointer using the given scheme, producing a constant with the same IR type.

ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)

Return a pointer to a constant array for the given ObjCEncodeExpr node.

llvm::Type * ConvertType(QualType T)

ConvertType - Convert type T into a llvm::Type.

llvm::Type * convertTypeForLoadStore(QualType T, llvm::Type *LLVMTy=nullptr)

Given that T is a scalar type, return the IR type that should be used for load and store operations.

const CGRecordLayout & getCGRecordLayout(const RecordDecl *)

getCGRecordLayout - Return record layout info for the given record decl.

llvm::Type * ConvertTypeForMem(QualType T)

ConvertTypeForMem - Convert type T into a llvm::Type.

bool typeRequiresSplitIntoByteArray(QualType ASTTy, llvm::Type *LLVMTy=nullptr)

Check whether the given type needs to be laid out in memory using an opaque byte-array type because i...

A specialization of Address that requires the address to be an LLVM Constant.

static ConstantAddress invalid()

llvm::Constant * getPointer() const

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

llvm::Constant * tryEmitForInitializer(const VarDecl &D)

Try to emit the initiaizer of the given declaration as an abstract constant.

llvm::Constant * tryEmitPrivateForVarInit(const VarDecl &D)

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

void finalize(llvm::GlobalVariable *global)

llvm::Constant * tryEmitAbstractForInitializer(const VarDecl &D)

Try to emit the initializer of the given declaration as an abstract constant.

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

Emit the result of the given expression as an abstract constant, asserting that it succeeded.

llvm::GlobalValue * getCurrentAddrPrivate()

Get the address of the current location.

llvm::Constant * tryEmitConstantExpr(const ConstantExpr *CE)

llvm::Constant * emitForMemory(llvm::Constant *C, QualType T)

llvm::Constant * emitNullForMemory(QualType T)

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

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

void registerCurrentAddrPrivate(llvm::Constant *signal, llvm::GlobalValue *placeholder)

Register a 'signal' value with the emitter to inform it where to resolve a placeholder.

llvm::Constant * emitForInitializer(const APValue &value, LangAS destAddrSpace, QualType destType)

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

bool isAbstract() const

Is the current emission context abstract?

llvm::Constant * tryEmitConstantSignedPointer(llvm::Constant *Ptr, PointerAuthQualifier Auth)

Try to emit a constant signed pointer, given a raw pointer and the destination ptrauth qualifier.

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

virtual llvm::Constant * getNullPointer(const CodeGen::CodeGenModule &CGM, llvm::PointerType *T, QualType QT) const

Get target specific null pointer.

CompoundLiteralExpr - [C99 6.5.2.5].

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

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

uint64_t getZExtSize() const

Return the size zero-extended as a uint64_t.

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

APValue getAPValueResult() const

SourceLocation getBeginLoc() const LLVM_READONLY

bool hasAPValueResult() const

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

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

Decl * getMostRecentDecl()

Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...

Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...

This represents one expression.

const Expr * skipRValueSubobjectAdjustments(SmallVectorImpl< const Expr * > &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const

Walk outwards from an expression we want to bind a reference to and find the expression whose lifetim...

Expr * IgnoreParenCasts() LLVM_READONLY

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

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

EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.

FPOptions getFPFeaturesInEffect(const LangOptions &LO) const

Returns the set of floating point options that apply to this expression.

Expr * IgnoreParens() LLVM_READONLY

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

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

EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known ...

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

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

SourceLocation getExprLoc() const LLVM_READONLY

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

const ValueDecl * getAsBuiltinConstantDeclRef(const ASTContext &Context) const

If this expression is an unambiguous reference to a single declaration, in the style of __builtin_fun...

RoundingMode getRoundingMode() const

Represents a member of a struct/union/class.

const Expr * getSubExpr() const

bool isTrivial() const

Whether this function is "trivial" in some specialized C++ senses.

Represents a C11 generic selection.

Represents an implicitly-generated value initialization of an object of a given type.

Describes an C or C++ initializer list.

bool isTransparent() const

Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic,...

FieldDecl * getInitializedFieldInUnion()

If this initializes a union, specifies which field in the union to initialize.

unsigned getNumInits() const

Expr * getArrayFiller()

If this initializer list initializes an array with more elements than there are initializers in the l...

const Expr * getInit(unsigned Init) const

ArrayRef< Expr * > inits()

Represents a prvalue temporary that is written into memory so that a reference can bind to it.

A pointer to member type per C++ 8.3.3 - Pointers to members.

ObjCBoxedExpr - used for generalized expression boxing.

ObjCEncodeExpr, used for @encode in Objective-C.

ObjCStringLiteral, used for Objective-C string literals i.e.

ParenExpr - This represents a parenthesized expression, e.g.

const Expr * getSubExpr() const

Pointer-authentication qualifiers.

bool isAddressDiscriminated() const

unsigned getExtraDiscriminator() const

PointerType - C99 6.7.5.1 - Pointer Declarators.

[C99 6.4.2.2] - A predefined identifier such as func.

A (possibly-)qualified type.

LangAS getAddressSpace() const

Return the address space of this type.

bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)

Represents a struct/union/class.

bool hasFlexibleArrayMember() const

field_iterator field_end() const

field_range fields() const

field_iterator field_begin() const

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

RecordDecl * getDecl() const

Encodes a location in the source.

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

RetTy Visit(PTR(Stmt) S, ParamTys... P)

Stmt - This represents one statement.

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

uint32_t getCodeUnit(size_t i) const

Represents a reference to a non-type template parameter that has been substituted with a template arg...

Expr * getReplacement() const

virtual bool useFP16ConversionIntrinsics() const

Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...

Symbolic representation of typeid(T) for some type T.

The base class of the type hierarchy.

bool isSignedIntegerOrEnumerationType() const

Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...

bool isIncompleteArrayType() const

bool isSignedIntegerType() const

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

bool isIntegerType() const

isIntegerType() does not include complex integers (a GCC extension).

const T * castAs() const

Member-template castAs<specific type>.

bool isReferenceType() const

QualType getPointeeType() const

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

bool isMemberDataPointerType() const

bool isBitIntType() const

bool isFloatingType() const

bool isUnsignedIntegerType() const

Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...

const T * getAs() const

Member-template getAs<specific type>'.

bool isRecordType() const

UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...

Expr * getSubExpr() const

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

Represents a variable declaration or definition.

Represents a GCC generic vector type.

QualType getElementType() const

bool isEmptyRecordForLayout(const ASTContext &Context, QualType T)

isEmptyRecordForLayout - Return true iff a structure contains only empty base classes (per isEmptyRec...

bool isEmptyFieldForLayout(const ASTContext &Context, const FieldDecl *FD)

isEmptyFieldForLayout - Return true iff the field is "empty", that is, either a zero-width bit-field ...

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

const internal::VariadicAllOfMatcher< Decl > decl

Matches declarations.

const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr

Matches expressions.

uint32_t Literal

Literals are represented as positive integers.

bool Const(InterpState &S, CodePtr OpPC, const T &Arg)

bool GE(InterpState &S, CodePtr OpPC)

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

@ Finalize

'finalize' clause, allowed on 'exit data' directive.

bool operator<(DeclarationName LHS, DeclarationName RHS)

Ordering on two declaration names.

@ SD_Static

Static storage duration.

@ Result

The result type of a method or function.

LangAS

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

const FunctionProtoType * T

bool declaresSameEntity(const Decl *D1, const Decl *D2)

Determine whether two declarations declare the same entity.

@ Success

Template argument deduction was successful.

Structure with information about how a bitfield should be accessed.

unsigned Size

The total size of the bit-field, in bits.

llvm::IntegerType * Int64Ty

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

llvm::IntegerType * CharTy

char

llvm::IntegerType * Int32Ty

llvm::IntegerType * IntPtrTy

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

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