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

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

clang: lib/CodeGen/CGExprAgg.cpp Source File

;

CodeGen;

AggExprEmitter :

<AggExprEmitter> {

withReturnValueSlot(

*

,

DoZeroInitPadding(uint64_t &PaddingStart, uint64_t PaddingEnd,

: CGF(cgf), Builder(CGF.Builder), Dest(Dest),

IsResultUnused(IsResultUnused) { }

EmitAggLoadOfLValue(

*

);

CodeGenFunction::ExprValueKind SrcValueKind =

CodeGenFunction::EVK_NonRValue);

EmitArrayInit(

DestPtr, llvm::ArrayType *AType,

ArrayQTy,

(CGF.

().getGC() && TypeRequiresGCollection(

))

TypeRequiresGCollection(

);

VisitStmt(

*S) {

(

->getReplacement());

llvm::TypeSize::getFixed(

(

->getSubExpr());

VisitDeclRefExpr(

*

) { EmitAggLoadOfLValue(

); }

VisitMemberExpr(

*ME) { EmitAggLoadOfLValue(ME); }

VisitUnaryDeref(

*

) { EmitAggLoadOfLValue(

); }

VisitStringLiteral(

*

) { EmitAggLoadOfLValue(

); }

EmitAggLoadOfLValue(

);

EmitAggLoadOfLValue(

);

VisitCallExpr(

*

);

VisitStmtExpr(

*

);

VisitPointerToDataMemberBinaryOperator(

*BO);

(

->getSemanticForm());

EmitAggLoadOfLValue(

);

llvm::Value *outerBegin =

);

CodeGenFunction::CXXDefaultArgExprScope

(CGF, DAE);

CodeGenFunction::CXXDefaultInitExprScope

(CGF, DIE);

VisitCXXTypeidExpr(

*

) { EmitAggLoadOfLValue(

); }

EmitFinalDestCopy(

->

(), LV);

NeedsDestruction =

(NeedsDestruction)

(NeedsDestruction)

EmitFinalDestCopy(

->

(), Res);

(

->getSelectedExpr());

AggExprEmitter::EmitAggLoadOfLValue(

*

) {

EmitFinalDestCopy(

->

(), LV);

AggExprEmitter::TypeRequiresGCollection(

) {

(!RecordTy)

;

(isa<CXXRecordDecl>(

) &&

(cast<CXXRecordDecl>(

)->hasNonTrivialCopyConstructor() ||

!cast<CXXRecordDecl>(

)->hasTrivialDestructor()))

AggExprEmitter::withReturnValueSlot(

RequiresDestruction =

(RequiresDestruction && Dest.

());

llvm::Value *LifetimeSizePtr =

;

llvm::IntrinsicInst *LifetimeStartInst =

;

RetAddr = CGF.

(RetTy,

, &RetAllocaAddr);

llvm::TypeSize

=

(LifetimeSizePtr) {

cast<llvm::IntrinsicInst>(std::prev(Builder.GetInsertPoint()));

assert(LifetimeStartInst->getIntrinsicID() ==

llvm::Intrinsic::lifetime_start &&

);

EmitFinalDestCopy(

->

(), Src);

(!RequiresDestruction && LifetimeStartInst) {

assert(src.

() &&

);

EmitFinalDestCopy(

, srcLV, CodeGenFunction::EVK_RValue);

AggExprEmitter::EmitFinalDestCopy(

CodeGenFunction::ExprValueKind SrcValueKind) {

(SrcValueKind == CodeGenFunction::EVK_RValue) {

EmitCopy(

, Dest, srcAgg);

assert(Array.isSimple() &&

);

ArrayPtr = Array.getAddress();

assert(

&&

);

assert(Field !=

->field_end() &&

);

assert(Field !=

->field_end() &&

);

assert(

->getType()->isPointerType() &&

);

llvm::Value *

= llvm::ConstantInt::get(CGF.

, 0);

llvm::Value *IdxEnd[] = {

,

};

llvm::Value *ArrayEnd = Builder.CreateInBoundsGEP(

assert(++Field ==

->field_end() &&

);

(isa<ImplicitValueInitExpr>(

))

(

*ILE = dyn_cast<InitListExpr>(

)) {

(ILE->getNumInits())

(

*Cons = dyn_cast_or_null<CXXConstructExpr>(

))

Cons->getConstructor()->isDefaultConstructor() &&

Cons->getConstructor()->isTrivial();

AggExprEmitter::EmitArrayInit(

DestPtr, llvm::ArrayType *AType,

NumInitElements = Args.size();

NumArrayElements = AType->getNumElements();

(

*

: Args) {

(

*Embed = dyn_cast<EmbedExpr>(

->IgnoreParenImpCasts())) {

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

(NumInitElements > NumArrayElements) {

NumInitElements = NumArrayElements;

assert(NumInitElements <= NumArrayElements);

(NumInitElements * elementSize.

() > 16 &&

(llvm::Constant *

=

.tryEmitForInitializer(ExprToVisit, AS, GVArrayQTy)) {

GV =

llvm::GlobalVariable(

, llvm::GlobalValue::PrivateLinkage,

,

, llvm::GlobalVariable::NotThreadLocal,

GVAddr(GV, GV->getValueType(), Align);

EmitFinalDestCopy(ArrayQTy, CGF.

(GVAddr, GVArrayQTy));

CodeGenFunction::CleanupDeactivationScope deactivation(CGF);

CodeGenFunction::AllocaTrackerRAII allocaTracker(CGF);

llvm::Instruction *dominatingIP =

Builder.CreateFlagLoad(llvm::ConstantInt::getNullValue(CGF.

));

);

Builder.CreateStore(begin, endOfInit);

.AddAuxAllocas(allocaTracker.Take());

llvm::Value *one = llvm::ConstantInt::get(CGF.

, 1);

llvm::Value *element = begin;

(ArrayIndex > 0) {

element = Builder.CreateInBoundsGEP(

llvmElementType, begin,

llvm::ConstantInt::get(CGF.

, ArrayIndex),

);

Builder.CreateStore(element, endOfInit);

(element, llvmElementType, elementAlign), elementType);

EmitInitializationToLValue(

, elementLV);

ArrayIndex = 0;

(uint64_t i = 0; i != NumInitElements; ++i) {

(ArrayIndex >= NumInitElements)

(

*EmbedS = dyn_cast<EmbedExpr>(Args[i]->IgnoreParenImpCasts())) {

EmbedS->doForEachDataElement(Emit, ArrayIndex);

Emit(Args[i], ArrayIndex);

(NumInitElements != NumArrayElements &&

!(Dest.

() && hasTrivialFiller &&

llvm::Value *element = begin;

(NumInitElements) {

element = Builder.CreateInBoundsGEP(

llvmElementType, element,

llvm::ConstantInt::get(CGF.

, NumInitElements),

(endOfInit.

()) Builder.CreateStore(element, endOfInit);

llvm::Value *end = Builder.CreateInBoundsGEP(

llvmElementType, begin,

llvm::ConstantInt::get(CGF.

, NumArrayElements),

);

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

llvm::PHINode *currentElement =

Builder.CreatePHI(element->getType(), 2,

);

currentElement->addIncoming(element, entryBB);

CodeGenFunction::RunCleanupsScope CleanupsScope(CGF);

(currentElement, llvmElementType, elementAlign), elementType);

EmitInitializationToLValue(ArrayFiller, elementLV);

EmitNullInitializationToLValue(elementLV);

llvm::Value *nextElement = Builder.CreateInBoundsGEP(

llvmElementType, currentElement, one,

);

(endOfInit.

()) Builder.CreateStore(nextElement, endOfInit);

llvm::Value *done = Builder.CreateICmpEQ(nextElement, end,

Builder.CreateCondBr(done, endBB, bodyBB);

currentElement->addIncoming(nextElement, Builder.GetInsertBlock());

Visit(

->getSubExpr());

EmitAggLoadOfLValue(

);

(

castE = dyn_cast<CastExpr>(op)) {

(castE->getCastKind() == kind)

castE->getSubExpr();

AggExprEmitter::VisitCastExpr(

*

) {

(

*ECE = dyn_cast<ExplicitCastExpr>(

))

(

->getCastKind()) {

assert(isa<CXXDynamicCastExpr>(

) &&

);

CodeGenFunction::TCK_Load);

EmitInitializationToLValue(

->getSubExpr(),

CK_LValueToRValueBitCast: {

llvm::Value *SizeVal = llvm::ConstantInt::get(

Builder.CreateMemCpy(DestAddress, SourceAddress, SizeVal);

CK_DerivedToBase:

CK_BaseToDerived:

CK_UncheckedDerivedToBase: {

llvm_unreachable(

);

CK_NonAtomicToAtomic:

CK_AtomicToNonAtomic: {

isToAtomic = (

->getCastKind() == CK_NonAtomicToAtomic);

(isToAtomic) std::swap(

, valueType);

Visit(

->getSubExpr());

(isToAtomic ? CK_AtomicToNonAtomic : CK_NonAtomicToAtomic);

);

EmitFinalDestCopy(valueType, rvalue);

CK_AddressSpaceConversion:

Visit(

->getSubExpr());

CK_LValueToRValue:

Visit(

->getSubExpr());

CK_HLSLArrayRValue:

Visit(

->getSubExpr());

CK_UserDefinedConversion:

CK_ConstructorConversion:

);

Visit(

->getSubExpr());

CK_LValueBitCast:

llvm_unreachable(

);

CK_ArrayToPointerDecay:

CK_FunctionToPointerDecay:

CK_NullToPointer:

CK_NullToMemberPointer:

CK_BaseToDerivedMemberPointer:

CK_DerivedToBaseMemberPointer:

CK_MemberPointerToBoolean:

CK_ReinterpretMemberPointer:

CK_IntegralToPointer:

CK_PointerToIntegral:

CK_PointerToBoolean:

CK_IntegralCast:

CK_BooleanToSignedIntegral:

CK_IntegralToBoolean:

CK_IntegralToFloating:

CK_FloatingToIntegral:

CK_FloatingToBoolean:

CK_FloatingCast:

CK_CPointerToObjCPointerCast:

CK_BlockPointerToObjCPointerCast:

CK_AnyPointerToBlockPointerCast:

CK_ObjCObjectLValueCast:

CK_FloatingRealToComplex:

CK_FloatingComplexToReal:

CK_FloatingComplexToBoolean:

CK_FloatingComplexCast:

CK_FloatingComplexToIntegralComplex:

CK_IntegralRealToComplex:

CK_IntegralComplexToReal:

CK_IntegralComplexToBoolean:

CK_IntegralComplexCast:

CK_IntegralComplexToFloatingComplex:

CK_ARCProduceObject:

CK_ARCConsumeObject:

CK_ARCReclaimReturnedObject:

CK_ARCExtendBlockObject:

CK_CopyAndAutoreleaseBlockObject:

CK_BuiltinFnToFnPtr:

CK_ZeroToOCLOpaqueType:

CK_HLSLVectorTruncation:

CK_IntToOCLSampler:

CK_FloatingToFixedPoint:

CK_FixedPointToFloating:

CK_FixedPointCast:

CK_FixedPointToBoolean:

CK_FixedPointToIntegral:

CK_IntegralToFixedPoint:

llvm_unreachable(

);

AggExprEmitter::VisitCallExpr(

*

) {

(

->getCallReturnType(CGF.

())->isReferenceType()) {

EmitAggLoadOfLValue(

);

Visit(

->getRHS());

AggExprEmitter::VisitStmtExpr(

*

) {

CodeGenFunction::StmtExprEvaluation eval(CGF);

*NameSuffix =

) {

ArgTy = CT->getElementType();

);

CGF, LHS, RHS, MPT,

);

CmpInstInfo {

llvm::CmpInst::Predicate FCmp;

llvm::CmpInst::Predicate SCmp;

llvm::CmpInst::Predicate UCmp;

CmpInstInfo InstInfo = [&]() -> CmpInstInfo {

FI = llvm::FCmpInst;

II = llvm::ICmpInst;

{

, FI::FCMP_OLT, II::ICMP_SLT, II::ICMP_ULT};

{

, FI::FCMP_OGT, II::ICMP_SGT, II::ICMP_UGT};

{

, FI::FCMP_OEQ, II::ICMP_EQ, II::ICMP_EQ};

llvm_unreachable(

);

Builder.CreateFCmp(InstInfo.FCmp, LHS, RHS,

llvm::Twine(InstInfo.Name) + NameSuffix);

Builder.CreateICmp(Inst, LHS, RHS,

llvm::Twine(InstInfo.Name) + NameSuffix);

llvm_unreachable(

);

llvm::BasicBlock;

llvm::PHINode;

);

EmitOperand = [&](

*

) -> std::pair<Value *, Value *> {

LHSValues = EmitOperand(

->getLHS()),

RHSValues = EmitOperand(

->getRHS());

K, IsComplex ?

:

);

RHSValues.second, K,

);

Builder.CreateAnd(Cmp, CmpImag,

);

Builder.getInt(VInfo->getIntValue());

Builder.CreateSelect(EmitCmp(

), EmitCmpRes(CmpInfo.

()),

EmitCmpRes(CmpInfo.

()),

);

Select = Builder.CreateSelect(EmitCmp(

),

SelectOne,

);

*SelectEq = Builder.CreateSelect(

SelectEq,

);

Select = Builder.CreateSelect(

EmitCmp(

), EmitCmpRes(CmpInfo.

()), SelectGT,

);

(

->getOpcode() == BO_PtrMemD ||

->getOpcode() == BO_PtrMemI)

VisitPointerToDataMemberBinaryOperator(

);

AggExprEmitter::VisitPointerToDataMemberBinaryOperator(

EmitFinalDestCopy(

->

(), LV);

(

*DRE = dyn_cast<DeclRefExpr>(

)) {

*var = dyn_cast<VarDecl>(DRE->getDecl());

(var && var->hasAttr<BlocksAttr>());

(op->isAssignmentOp() || op->isPtrMemOp())

(op->getOpcode() == BO_Comma)

= dyn_cast<AbstractConditionalOperator>(

)) {

= dyn_cast<OpaqueValueExpr>(

)) {

(

*src = op->getSourceExpr())

}

(

*

= dyn_cast<CastExpr>(

)) {

(

->getCastKind() == CK_LValueToRValue)

}

(

*uop = dyn_cast<UnaryOperator>(

)) {

}

(

*mem = dyn_cast<MemberExpr>(

)) {

&&

);

EnsureDest(

->getRHS()->

());

Visit(

->getRHS());

EmitCopy(

->getLHS()->

(),

needsGC(

->getLHS()->

()),

EnsureDest(

->getRHS()->

());

Visit(

->getRHS());

EmitFinalDestCopy(

->

(), LHS);

AggExprEmitter::

CodeGenFunction::OpaqueValueMapping binding(CGF,

);

CodeGenFunction::ConditionalEvaluation eval(CGF);

destructNonTrivialCStruct =

!isExternallyDestructed &&

isExternallyDestructed |= destructNonTrivialCStruct;

Visit(

->getTrueExpr());

assert(CGF.

() &&

);

CGF.

.CreateBr(ContBlock);

Visit(

->getFalseExpr());

(destructNonTrivialCStruct)

AggExprEmitter::VisitChooseExpr(

*CE) {

AggExprEmitter::VisitVAArgExpr(

*VE) {

Visit(

->getSubExpr());

(!wasExternallyDestructed)

AggExprEmitter::VisitCXXInheritedCtorInitExpr(

->getConstructor(),

->constructsVBase(), Slot.

(),

->inheritedFromVBase(),

);

AggExprEmitter::VisitLambdaExpr(

*

) {

CodeGenFunction::CleanupDeactivationScope scope(CGF);

e =

->capture_init_end();

i != e; ++i, ++CurField) {

(CurField->hasCapturedVLAType()) {

EmitInitializationToLValue(*i, LV);

CurField->getType().isDestructedType()) {

CurField->getType(),

CodeGenFunction::RunCleanupsScope cleanups(CGF);

Visit(

->getSubExpr());

CK_UserDefinedConversion:

CK_ConstructorConversion:

CK_BooleanToSignedIntegral:

CK_FloatingCast:

CK_FloatingComplexCast:

CK_FloatingComplexToBoolean:

CK_FloatingComplexToIntegralComplex:

CK_FloatingComplexToReal:

CK_FloatingRealToComplex:

CK_FloatingToBoolean:

CK_FloatingToIntegral:

CK_IntegralCast:

CK_IntegralComplexCast:

CK_IntegralComplexToBoolean:

CK_IntegralComplexToFloatingComplex:

CK_IntegralComplexToReal:

CK_IntegralRealToComplex:

CK_IntegralToBoolean:

CK_IntegralToFloating:

CK_IntegralToPointer:

CK_PointerToIntegral:

CK_VectorSplat:

CK_NonAtomicToAtomic:

CK_AtomicToNonAtomic:

CK_HLSLVectorTruncation:

CK_BaseToDerivedMemberPointer:

CK_DerivedToBaseMemberPointer:

CK_MemberPointerToBoolean:

CK_NullToMemberPointer:

CK_ReinterpretMemberPointer:

CK_AnyPointerToBlockPointerCast:

CK_BlockPointerToObjCPointerCast:

CK_CPointerToObjCPointerCast:

CK_ObjCObjectLValueCast:

CK_IntToOCLSampler:

CK_ZeroToOCLOpaqueType:

CK_FixedPointCast:

CK_FixedPointToBoolean:

CK_FixedPointToFloating:

CK_FixedPointToIntegral:

CK_FloatingToFixedPoint:

CK_IntegralToFixedPoint:

CK_AddressSpaceConversion:

CK_BaseToDerived:

CK_DerivedToBase:

CK_NullToPointer:

CK_PointerToBoolean:

CK_ARCConsumeObject:

CK_ARCExtendBlockObject:

CK_ARCProduceObject:

CK_ARCReclaimReturnedObject:

CK_CopyAndAutoreleaseBlockObject:

CK_ArrayToPointerDecay:

CK_FunctionToPointerDecay:

CK_BuiltinFnToFnPtr:

CK_LValueBitCast:

CK_LValueToRValue:

CK_LValueToRValueBitCast:

CK_UncheckedDerivedToBase:

CK_HLSLArrayRValue:

llvm_unreachable(

);

(

*CE = dyn_cast<CastExpr>(

)) {

IL->getValue() == 0;

FL->getValue().isPosZero();

((isa<ImplicitValueInitExpr>(

) || isa<CXXScalarValueInitExpr>(

)) &&

(

*ICE = dyn_cast<CastExpr>(

))

ICE->getCastKind() == CK_NullToPointer &&

CL->getValue() == 0;

AggExprEmitter::EmitInitializationToLValue(

*

,

LV) {

}

(isa<ImplicitValueInitExpr>(

) || isa<CXXScalarValueInitExpr>(

)) {

EmitNullInitializationToLValue(LV);

}

(isa<NoInitExpr>(

)) {

}

(

->isReferenceType()) {

AggExprEmitter::EmitNullInitializationToLValue(

lv) {

VisitCXXParenListOrInitListExpr(

,

->getInitExprs(),

->getInitializedFieldInUnion(),

->getArrayFiller());

(

->hadArrayRangeDesignator())

(

->isTransparent())

Visit(

->getInit(0));

VisitCXXParenListOrInitListExpr(

,

->inits(),

->getInitializedFieldInUnion(),

->getArrayFiller());

AggExprEmitter::VisitCXXParenListOrInitListExpr(

(llvm::Constant *

=

CGF.

.EmitConstantExpr(ExprToVisit, ExprToVisit->

(), &CGF)) {

llvm::GlobalVariable* GV =

llvm::GlobalVariable(CGF.

.

(),

->getType(),

,

llvm::GlobalValue::InternalLinkage,

,

);

EmitFinalDestCopy(ExprToVisit->

(),

EmitArrayInit(Dest.

(), AType, ExprToVisit->

(), ExprToVisit,

InitExprs, ArrayFiller);

assert(InitExprs.size() == 0 &&

);

);

NumInitElements = InitExprs.size();

CodeGenFunction::CleanupDeactivationScope DeactivateCleanups(CGF);

curInitIndex = 0;

(

*CXXRD = dyn_cast<CXXRecordDecl>(record)) {

assert(NumInitElements >= CXXRD->getNumBases() &&

);

(

&

: CXXRD->bases()) {

assert(!

.isVirtual() &&

);

*BaseRD =

.getType()->getAsCXXRecordDecl();

CGF.

(InitExprs[curInitIndex++], AggSlot);

.getType().isDestructedType())

CodeGenFunction::FieldConstructionScope FCS(CGF, Dest.

());

ZeroInitPadding =

(!InitializedFieldInUnion) {

(

*Field : record->

())

(

->isUnnamedBitField() ||

->isAnonymousStructOrUnion()) &&

);

(NumInitElements) {

EmitInitializationToLValue(InitExprs[0], FieldLoc);

(ZeroInitPadding) {

DoZeroInitPadding(FieldSize, TotalSize,

);

(ZeroInitPadding)

EmitNullInitializationToLValue(DestLV);

EmitNullInitializationToLValue(FieldLoc);

(

*field : record->

()) {

(field->getType()->isIncompleteArrayType())

(field->isUnnamedBitField())

(curInitIndex == NumInitElements && Dest.

() &&

(ZeroInitPadding)

DoZeroInitPadding(PaddingStart,

(curInitIndex < NumInitElements) {

EmitInitializationToLValue(InitExprs[curInitIndex++], LV);

EmitNullInitializationToLValue(LV);

= field->getType().isDestructedType()) {

(ZeroInitPadding) {

DoZeroInitPadding(PaddingStart, TotalSize,

);

AggExprEmitter::DoZeroInitPadding(uint64_t &PaddingStart,

uint64_t PaddingEnd,

Addr = Builder.CreateConstGEP(Addr, Start.

());

llvm::Constant *SizeVal = Builder.getInt64((End - Start).getQuantity());

(NextField !=

&& NextField->

()) {

(StorageStart + Info.

> PaddingStart) {

(StorageStart > PaddingStart)

InitBytes(PaddingStart, StorageStart);

Builder.CreateStore(Builder.getIntN(Info.

, 0), Addr);

(PaddingStart < PaddingEnd)

InitBytes(PaddingStart, PaddingEnd);

(NextField !=

)

llvm::Value *outerBegin) {

CodeGenFunction::OpaqueValueMapping binding(CGF,

->getCommonExpr());

numElements =

->getArraySize().getZExtValue();

llvm::Value *zero = llvm::ConstantInt::get(CGF.

, 0);

llvm::Value *indices[] = {zero, zero};

llvm::Value *begin = Builder.CreateInBoundsGEP(destPtr.

(),

indices,

);

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

llvm::PHINode *index =

Builder.CreatePHI(zero->getType(), 2,

);

index->addIncoming(zero, entryBB);

llvm::Value *element =

Builder.CreateInBoundsGEP(llvmElementType, begin, index);

(outerBegin->getType() != element->getType())

outerBegin = Builder.CreateBitCast(outerBegin, element->getType());

CodeGenFunction::RunCleanupsScope CleanupsScope(CGF);

CodeGenFunction::ArrayInitLoopExprScope

(CGF, index);

(element, llvmElementType, elementAlign), elementType);

AggExprEmitter(CGF, elementSlot,

)

.VisitArrayInitLoopExpr(InnerLoop, outerBegin);

EmitInitializationToLValue(

->getSubExpr(), elementLV);

llvm::Value *nextIndex = Builder.CreateNUWAdd(

index, llvm::ConstantInt::get(CGF.

, 1),

);

index->addIncoming(nextIndex, Builder.GetInsertBlock());

llvm::Value *done = Builder.CreateICmpEQ(

nextIndex, llvm::ConstantInt::get(CGF.

, numElements),

Builder.CreateCondBr(done, endBB, bodyBB);

EmitInitializationToLValue(

->getBase(), DestLV);

VisitInitListExpr(

->getUpdater());

(

*MTE = dyn_cast<MaterializeTemporaryExpr>(

))

= MTE->getSubExpr();

ILE = dyn_cast<InitListExpr>(ILE->

(0));

(!RT->isUnionType()) {

ILEElement = 0;

(

*CXXRD = dyn_cast<CXXRecordDecl>(SD))

(ILEElement != CXXRD->getNumBases())

(

*Field : SD->

()) {

(Field->getType()->isIncompleteArrayType() ||

(Field->isUnnamedBitField())

(Field->getType()->isReferenceType())

NumNonZeroBytes;

(

i = 0, e = ILE->

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

NumNonZeroBytes;

*RD = cast<CXXRecordDecl>(RT->getDecl());

(NumNonZeroBytes*4 > Size)

llvm::Constant *SizeVal = CGF.

.getInt64(Size.getQuantity());

);

);

AggExprEmitter(*

, Slot, Slot.

()).Visit(

*

(

));

AggExprEmitter(*

, Dest, Dest.

())

.EmitFinalDestCopy(

, Src, SrcKind);

().getASTRecordLayout(BaseRD).getSize() <=

assert((

->hasTrivialCopyConstructor() ||

->hasTrivialCopyAssignment() ||

->hasTrivialMoveConstructor() ||

->hasTrivialMoveAssignment() ||

->hasAttr<TrivialABIAttr>() ||

->isUnion()) &&

);

(

().emitCUDADeviceBuiltinSurfaceDeviceCopy(*

, Dest,

(

().emitCUDADeviceBuiltinTextureDeviceCopy(*

, Dest,

llvm::Value *SizeVal =

;

(

*VAT = dyn_cast_or_null<VariableArrayType>(

SizeVal =

.CreateNUWMul(

(

->hasObjectMember()) {

Inst->setMetadata(llvm::LLVMContext::MD_tbaa_struct, TBAAStructTag);

Defines the clang::ASTContext interface.

static CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF)

GetNumNonZeroBytesInInit - Get an approximate count of the number of non-zero bytes that will be stor...

static Expr * findPeephole(Expr *op, CastKind kind, const ASTContext &ctx)

Attempt to look through various unimportant expressions to find a cast of the given kind.

static bool isBlockVarRef(const Expr *E)

Is the value of the given expression possibly a reference to or into a __block variable?

static bool isTrivialFiller(Expr *E)

Determine if E is a trivial array filler, that is, one that is equivalent to zero-initialization.

static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF)

isSimpleZero - If emitting this value will obviously just cause a store of zero to memory,...

static llvm::Value * EmitCompare(CGBuilderTy &Builder, CodeGenFunction &CGF, const BinaryOperator *E, llvm::Value *LHS, llvm::Value *RHS, CompareKind Kind, const char *NameSuffix="")

static bool castPreservesZero(const CastExpr *CE)

Determine whether the given cast kind is known to always convert values with all zero bits in their v...

static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E, CodeGenFunction &CGF)

CheckAggExprForMemSetUse - If the initializer is large and has a lot of zeros in it,...

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

Defines the C++ template declaration subclasses.

llvm::MachO::Record Record

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.

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 getBaseElementType(const ArrayType *VAT) const

Return the innermost element type of an array type.

ComparisonCategories CompCategories

Types and expressions required to build C++2a three-way comparisons using operator<=>,...

CanQualType getSizeType() const

Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.

QualType removeAddrSpaceQualType(QualType T) const

Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...

TypeInfoChars getTypeInfoDataSizeInChars(QualType T) const

TypeInfoChars getTypeInfoInChars(const Type *T) const

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.

CharUnits toCharUnitsFromBits(int64_t BitSize) const

Convert a size in bits to a size in characters.

QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const

Return the uniqued reference to the type for an address space qualified type with the specified type ...

unsigned getTargetAddressSpace(LangAS AS) const

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

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.

CharUnits getNonVirtualSize() const

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

AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...

Represents a loop initializing the elements of an array.

ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.

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

QualType getElementType() const

AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...

QualType getValueType() const

Gets the type contained by this atomic type, i.e.

A builtin binary operation expression such as "x + y" or "x <= y".

Represents binding an expression to a temporary.

Represents a call to a C++ constructor.

A default argument (C++ [dcl.fct.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 call to an inherited base class constructor from an inheriting constructor.

Represents a list-initialization with parenthesis.

Represents a C++ struct/union/class.

bool isTriviallyCopyable() const

Determine whether this class is considered trivially copyable per (C++11 [class]p6).

bool hasUserDeclaredConstructor() const

Determine whether this class has any user-declared constructors.

bool isEmpty() const

Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).

A rewritten comparison expression that was originally written using operator syntax.

An expression "T()" which creates an rvalue of a non-class type T.

Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...

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

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

CastKind getCastKind() const

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.

CharUnits alignmentOfArrayElement(CharUnits elementSize) const

Given that this is the alignment of the first element of an array, return the minimum alignment of an...

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.

ChooseExpr - GNU builtin-in function __builtin_choose_expr.

Expr * getChosenSubExpr() const

getChosenSubExpr - Return the subexpression chosen according to the condition.

Represents a 'co_await' expression.

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.

llvm::PointerType * getType() const

Return the type of the pointer value.

void setVolatile(bool flag)

static AggValueSlot ignored()

ignored - Returns an aggregate value slot indicating that the aggregate value is being ignored.

Address getAddress() const

CharUnits getPreferredSize(ASTContext &Ctx, QualType Type) const

Get the preferred size to use when storing a value to this slot.

NeedsGCBarriers_t requiresGCollection() const

void setExternallyDestructed(bool destructed=true)

void setZeroed(bool V=true)

IsZeroed_t isZeroed() const

Qualifiers getQualifiers() const

static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)

IsAliased_t isPotentiallyAliased() const

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

forAddr - Make a slot for an aggregate value.

IsDestructed_t isExternallyDestructed() const

Overlap_t mayOverlap() const

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

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

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

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

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

virtual llvm::Value * EmitMemberPointerComparison(CodeGenFunction &CGF, llvm::Value *L, llvm::Value *R, const MemberPointerType *MPT, bool Inequality)

Emit a comparison between two member pointers. Returns an i1.

virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, Address DestPtr, Address SrcPtr, llvm::Value *Size)=0

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

const CGBitFieldInfo & getBitFieldInfo(const FieldDecl *FD) const

Return the BitFieldInfo that corresponds to the field FD.

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

void EmitNullInitialization(Address DestPtr, QualType Ty)

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

void CreateCoercedStore(llvm::Value *Src, Address Dst, llvm::TypeSize DstSize, bool DstIsVolatile)

Create a store to.

llvm::Value * EmitLifetimeStart(llvm::TypeSize Size, llvm::Value *Addr)

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

DeactivateCleanupBlock - Deactivates the given cleanup block.

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

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

LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e)

Given an opaque value expression, return its LValue mapping if it exists, otherwise create one.

LValue EmitAggExprToLValue(const Expr *E)

EmitAggExprToLValue - Emit the computation of the specified expression of aggregate type into a tempo...

void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr)

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

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

void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)

static bool hasScalarEvaluationKind(QualType T)

void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin, Address arrayEndPointer, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)

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

AggValueSlot::Overlap_t getOverlapForBaseInit(const CXXRecordDecl *RD, const CXXRecordDecl *BaseRD, bool IsVirtual)

Determine whether a base class initialization may overlap some other object.

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

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

RValue EmitAtomicLoad(LValue LV, SourceLocation SL, AggValueSlot Slot=AggValueSlot::ignored())

bool hasVolatileMember(QualType T)

hasVolatileMember - returns true if aggregate type has a volatile member.

void callCStructCopyAssignmentOperator(LValue Dst, LValue Src)

void callCStructMoveConstructor(LValue Dst, LValue Src)

llvm::SmallVector< DeferredDeactivateCleanup > DeferredDeactivationCleanupStack

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.

const LangOptions & getLangOpts() const

LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)

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

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

EmitBlock - Emit the given block.

void pushDestroyAndDeferDeactivation(QualType::DestructionKind dtorKind, Address addr, QualType type)

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

void EmitInheritedCXXConstructorCall(const CXXConstructorDecl *D, bool ForVirtualBase, Address This, bool InheritedFromVBase, const CXXInheritedCtorInitExpr *E)

Emit a call to a constructor inherited from a base class, passing the current constructor's arguments...

RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())

void EmitIgnoredExpr(const Expr *E)

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

llvm::Type * ConvertTypeForMem(QualType T)

LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK)

Same as EmitLValue but additionally we generate checking code to guard against undefined behavior.

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

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

Destroyer * getDestroyer(QualType::DestructionKind destructionKind)

void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, llvm::Value **Result=nullptr)

EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints as EmitStoreThroughLValue.

const TargetInfo & getTarget() const

llvm::Value * getTypeSize(QualType Ty)

Returns calculated size of the specified type.

void pushFullExprCleanup(CleanupKind kind, As... A)

pushFullExprCleanup - Push a cleanup to be run at the end of the current full-expression.

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

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

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

CreateAggTemp - Create a temporary memory object for the given aggregate type.

RValue EmitCoyieldExpr(const CoyieldExpr &E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)

bool HaveInsertPoint() const

HaveInsertPoint - True if an insertion point is defined.

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

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

AggValueSlot::Overlap_t getOverlapForFieldInit(const FieldDecl *FD)

Determine whether a field initialization may overlap some other object.

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

EmitAggregateCopy - Emit an aggregate copy.

const TargetCodeGenInfo & getTargetHooks() const

RValue EmitReferenceBindingToExpr(const Expr *E)

Emits a reference binding to the passed in expression.

void EmitAggExpr(const Expr *E, AggValueSlot AS)

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

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

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

RValue EmitVAArg(VAArgExpr *VE, Address &VAListAddr, AggValueSlot Slot=AggValueSlot::ignored())

Generate code to get an argument from the passed in pointer and update it accordingly.

RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e, AggValueSlot slot=AggValueSlot::ignored())

ASTContext & getContext() const

void EmitAggFinalDestCopy(QualType Type, AggValueSlot Dest, const LValue &Src, ExprValueKind SrcKind)

EmitAggFinalDestCopy - Emit copy of the specified aggregate into destination address.

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

void pushDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)

Address GetAddressOfDirectBaseInCompleteClass(Address Value, const CXXRecordDecl *Derived, const CXXRecordDecl *Base, bool BaseIsVirtual)

GetAddressOfBaseOfCompleteClass - Convert the given pointer to a complete class to the given direct b...

void callCStructMoveAssignmentOperator(LValue Dst, LValue Src)

bool needsEHCleanup(QualType::DestructionKind kind)

Determines whether an EH cleanup is required to destroy a type with the given destruction kind.

CleanupKind getCleanupKind(QualType::DestructionKind kind)

void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest)

llvm::Type * ConvertType(QualType T)

CodeGenTypes & getTypes() const

RValue EmitCoawaitExpr(const CoawaitExpr &E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)

llvm::Value * EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE)

uint64_t getProfileCount(const Stmt *S)

Get the profiler's count for the given statement.

LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e)

static bool hasAggregateEvaluationKind(QualType T)

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

void EmitLambdaVLACapture(const VariableArrayType *VAT, LValue LV)

void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit)

void EmitInitializationToLValue(const Expr *E, LValue LV, AggValueSlot::IsZeroed_t IsZeroed=AggValueSlot::IsNotZeroed)

EmitInitializationToLValue - Emit an initializer to an LValue.

RValue EmitCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue=ReturnValueSlot(), llvm::CallBase **CallOrInvoke=nullptr)

llvm::LLVMContext & getLLVMContext()

bool LValueIsSuitableForInlineAtomic(LValue Src)

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

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

void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin, llvm::Value *arrayEnd, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)

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

RValue EmitAtomicExpr(AtomicExpr *E)

LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E)

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

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

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

llvm::MDNode * getTBAAStructInfo(QualType QTy)

llvm::Module & getModule() const

bool isPaddedAtomicType(QualType type)

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

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

TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo, TBAAAccessInfo SrcInfo)

mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the purposes of memory transfer call...

const LangOptions & getLangOpts() const

const llvm::DataLayout & getDataLayout() const

CGCXXABI & getCXXABI() const

void DecorateInstructionWithTBAA(llvm::Instruction *Inst, TBAAAccessInfo TBAAInfo)

DecorateInstructionWithTBAA - Decorate the instruction with a TBAA tag.

ASTContext & getContext() const

const CodeGenOptions & getCodeGenOpts() const

bool shouldZeroInitPadding() const

CGObjCRuntime & getObjCRuntime()

Return a reference to the configured Objective-C runtime.

llvm::Constant * EmitNullConstant(QualType T)

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

LangAS GetGlobalConstantAddressSpace() const

Return the AST address space of constant literal, which is used to emit the constant literal as globa...

bool isPointerZeroInitializable(QualType T)

Check if the pointer type can be zero-initialized (in the C++ sense) with an LLVM zeroinitializer.

const CGRecordLayout & getCGRecordLayout(const RecordDecl *)

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

bool isZeroInitializable(QualType T)

IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...

A saved depth on the scope stack.

stable_iterator stable_begin() const

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

iterator find(stable_iterator save) const

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

LValue - This represents an lvalue references.

Address getAddress() const

TBAAAccessInfo getTBAAInfo() const

void setNonGC(bool Value)

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

llvm::Value * getAggregatePointer(QualType PointeeType, CodeGenFunction &CGF) const

static RValue get(llvm::Value *V)

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

Convert an Address to an RValue.

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

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

const ComparisonCategoryInfo & getInfoForType(QualType Ty) const

Return the comparison category information as specified by getCategoryForType(Ty).

bool isPartial() const

True iff the comparison is not totally ordered.

const ValueInfo * getLess() const

const ValueInfo * getUnordered() const

const CXXRecordDecl * Record

The declaration for the comparison category type from the standard library.

const ValueInfo * getGreater() const

const ValueInfo * getEqualOrEquiv() const

Complex values, per C99 6.2.5p11.

CompoundLiteralExpr - [C99 6.5.2.5].

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

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

Represents a 'co_yield' expression.

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

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

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

This represents one expression.

Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY

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

Expr * IgnoreParens() LLVM_READONLY

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

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

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

SourceLocation getExprLoc() const LLVM_READONLY

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

Represents a member of a struct/union/class.

bool isBitField() const

Determines whether this field is a bitfield.

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.

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

unsigned getNumInits() const

const Expr * getInit(unsigned Init) const

A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...

Expr *const * const_capture_init_iterator

Const iterator that walks over the capture initialization arguments.

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

MemberExpr - [C99 6.5.2.3] Structure and Union Members.

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

Represents a place-holder for an object not to be initialized by anything.

ObjCIvarRefExpr - A reference to an ObjC instance variable.

An expression that sends a message to the given Objective-C object or class.

OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.

Expr * getSourceExpr() const

The source expression of an opaque value expression is the expression which originally generated the ...

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

const Expr * getSubExpr() const

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

PseudoObjectExpr - An expression which accesses a pseudo-object l-value.

A (possibly-)qualified type.

bool isVolatileQualified() const

Determine whether this type is volatile-qualified.

bool isTriviallyCopyableType(const ASTContext &Context) const

Return true if this is a trivially copyable type (C++0x [basic.types]p9)

LangAS getAddressSpace() const

Return the address space of this type.

DestructionKind isDestructedType() const

Returns a nonzero value if objects of this type require non-trivial work to clean up after.

bool isPODType(const ASTContext &Context) const

Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).

@ PCK_Struct

The type is a struct containing a field whose type is neither PCK_Trivial nor PCK_VolatileTrivial.

The collection of all-type qualifiers we support.

Represents a struct/union/class.

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

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

StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).

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

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

Stmt - This represents one statement.

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

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

uint64_t getPointerWidth(LangAS AddrSpace) const

Return the width of pointers on this target, for the specified address space.

The base class of the type hierarchy.

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

bool isConstantArrayType() const

bool isPointerType() const

const T * castAs() const

Member-template castAs<specific type>.

bool isVariableArrayType() const

bool isCUDADeviceBuiltinSurfaceType() const

Check if the type is the CUDA device builtin surface type.

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

bool isAnyComplexType() const

bool hasSignedIntegerRepresentation() const

Determine whether this type has an signed integer representation of some sort, e.g....

bool isMemberPointerType() const

bool isAtomicType() const

bool isCUDADeviceBuiltinTextureType() const

Check if the type is the CUDA device builtin texture type.

bool hasFloatingRepresentation() const

Determine whether this type has a floating-point representation of some sort, e.g....

bool isRealFloatingType() const

Floating point categories.

const T * getAs() const

Member-template getAs<specific type>'.

bool isNullPtrType() const

bool isRecordType() const

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

Represents a call to the builtin function __builtin_va_arg.

Represents a variable declaration or definition.

@ EHCleanup

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

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

const AstTypeMatcher< AtomicType > atomicType

Matches atomic types.

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

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

bool Zero(InterpState &S, CodePtr OpPC)

bool GE(InterpState &S, CodePtr OpPC)

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

LangAS

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

CastKind

CastKind - The kind of operation required for a conversion.

ExprValueKind

The categorization of expression values, currently following the C++11 scheme.

const FunctionProtoType * T

U cast(CodeGen::Address addr)

Diagnostic wrappers for TextAPI types for error reporting.

cl::opt< bool > EnableSingleByteCoverage

Structure with information about how a bitfield should be accessed.

CharUnits StorageOffset

The offset of the bitfield storage from the start of the struct.

unsigned StorageSize

The storage size in bits which should be used when accessing this bitfield.

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

llvm::IntegerType * CharTy

char

llvm::IntegerType * SizeTy

llvm::PointerType * Int8PtrTy

llvm::IntegerType * PtrDiffTy

CharUnits getPointerAlign() 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