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

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

clang: lib/CodeGen/Targets/X86.cpp Source File

;

IsX86_MMXType(llvm::Type *IRType) {

IRType->isVectorTy() && IRType->getPrimitiveSizeInBits() == 64 &&

cast<llvm::VectorType>(IRType)->getElementType()->isIntegerTy() &&

IRType->getScalarSizeInBits() != 64;

(Constraint ==

) {

llvm::Type *Int1Ty = llvm::Type::getInt1Ty(CGF.

());

llvm::FixedVectorType::get(Int1Ty, Ty->getScalarSizeInBits());

(BT->isFloatingPoint() && BT->getKind() != BuiltinType::Half) {

(BT->getKind() == BuiltinType::LongDouble) {

&llvm::APFloat::x87DoubleExtended())

(VecSize == 128 || VecSize == 256 || VecSize == 512)

isX86VectorCallAggregateSmallEnough(uint64_t NumMembers) {

NumMembers <= 4;

getDirectX86Hva(llvm::Type*

=

) {

AI.setCanBeFlattened(

);

: IsPreassigned(FI.arg_size()), CC(FI.getCallingConvention()),

llvm::SmallBitVector IsPreassigned;

CC = CallingConv::CC_C;

FreeRegs = 0;

FreeSSERegs = 0;

X86_32ABIInfo :

{

MinABIStackAlignInBytes = 4;

IsDarwinVectorABI;

IsRetSmallStructInRegABI;

IsWin32StructABI;

DefaultNumRegisterParameters;

isRegisterSize(

Size) {

(Size == 8 || Size == 16 || Size == 32 || Size == 64);

isX86VectorTypeForVectorCall(

(), Ty);

uint64_t NumMembers)

{

isX86VectorCallAggregateSmallEnough(NumMembers);

getTypeStackAlignInBytes(

Ty,

Align)

;

ArgIndex)

;

updateFreeRegs(

Ty, CCState &State)

;

shouldAggregateUseDirect(

Ty, CCState &State,

&InReg,

&NeedsPadding)

;

shouldPrimitiveUseInReg(

Ty, CCState &State)

;

canExpandIndirectArgument(

Ty)

;

runVectorCallFirstPass(

&FI, CCState &State)

;

RetSmallStructInRegABI,

Win32StructABI,

NumRegisterParameters,

SoftFloatABI)

:

(CGT), IsDarwinVectorABI(DarwinVectorABI),

IsRetSmallStructInRegABI(RetSmallStructInRegABI),

IsWin32StructABI(Win32StructABI), IsSoftFloatABI(SoftFloatABI),

IsMCUABI(CGT.getTarget().getTriple().isOSIAMCU()),

IsLinuxABI(CGT.getTarget().getTriple().isOSLinux() ||

CGT.getTarget().getTriple().isOSCygMing()),

DefaultNumRegisterParameters(NumRegisterParameters) {}

AsReturnValue)

{

RetSmallStructInRegABI,

Win32StructABI,

NumRegisterParameters,

SoftFloatABI)

CGT, DarwinVectorABI, RetSmallStructInRegABI, Win32StructABI,

NumRegisterParameters, SoftFloatABI)) {

SwiftInfo = std::make_unique<X86_32SwiftABIInfo>(CGT);

isStructReturnInRegABI(

llvm::Value *

)

;

StringRef Constraint,

llvm::Type* Ty)

{

X86AdjustInlineAsmType(CGF, Constraint, Ty);

std::string &Constraints,

std::vector<llvm::Type *> &ResultRegTypes,

std::vector<llvm::Type *> &ResultTruncRegTypes,

std::vector<LValue> &ResultRegDests,

std::string &AsmString,

NumOutputs)

;

;

std::string &AsmString) {

llvm::raw_string_ostream OS(Buf);

(Pos < AsmString.size()) {

DollarStart = AsmString.find(

, Pos);

(DollarStart == std::string::npos)

DollarStart = AsmString.size();

DollarEnd = AsmString.find_first_not_of(

, DollarStart);

(DollarEnd == std::string::npos)

DollarEnd = AsmString.size();

OS << StringRef(&AsmString[Pos], DollarEnd - Pos);

NumDollars = DollarEnd - DollarStart;

(NumDollars % 2 != 0 && Pos < AsmString.size()) {

DigitStart = Pos;

(AsmString[DigitStart] ==

) {

DigitEnd = AsmString.find_first_not_of(

, DigitStart);

(DigitEnd == std::string::npos)

DigitEnd = AsmString.size();

StringRef OperandStr(&AsmString[DigitStart], DigitEnd - DigitStart);

OperandIndex;

(!OperandStr.getAsInteger(10, OperandIndex)) {

(OperandIndex >= FirstIn)

OperandIndex += NumNewOuts;

AsmString = std::move(Buf);

X86_32TargetCodeGenInfo::addReturnRegisterOutputs(

std::vector<llvm::Type *> &ResultRegTypes,

std::vector<llvm::Type *> &ResultTruncRegTypes,

std::vector<LValue> &ResultRegDests, std::string &AsmString,

NumOutputs)

{

(!Constraints.empty())

(RetWidth <= 32) {

Constraints +=

;

ResultRegTypes.push_back(CGF.

);

Constraints +=

;

ResultRegTypes.push_back(CGF.

);

llvm::Type *CoerceTy = llvm::IntegerType::get(CGF.

(), RetWidth);

ResultTruncRegTypes.push_back(CoerceTy);

ResultRegDests.push_back(ReturnSlot);

X86_32ABIInfo::shouldReturnTypeInRegister(

Ty,

((IsMCUABI && Size > 64) || (!IsMCUABI && !isRegisterSize(Size)))

(Size == 64 || Size == 128)

shouldReturnTypeInRegister(AT->getElementType(), Context);

(!RT)

;

(!shouldReturnTypeInRegister(FD->getType(), Context))

Ty = CTy->getElementType();

Size == 32 || Size == 64;

(

*FD : RD->

()) {

(FD->isBitField())

X86_32ABIInfo::canExpandIndirectArgument(

Ty)

{

(

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

(!IsWin32StructABI) {

(!CXXRD->isCLike())

(CXXRD->isDynamicClass())

== getContext().getTypeSize(Ty);

X86_32ABIInfo::getIndirectReturnResult(

RetTy, CCState &State)

{

(State.CC != llvm::CallingConv::X86_FastCall &&

State.CC != llvm::CallingConv::X86_VectorCall && State.FreeRegs) {

getNaturalAlignIndirectInReg(RetTy);

getNaturalAlignIndirect(RetTy,

);

CCState &State)

{

((State.CC == llvm::CallingConv::X86_VectorCall ||

State.CC == llvm::CallingConv::X86_RegCall) &&

isHomogeneousAggregate(RetTy,

, NumElts)) {

(IsDarwinVectorABI) {

llvm::Type::getInt64Ty(getVMContext()), 2));

((Size == 8 || Size == 16 || Size == 32) ||

(Size == 64 && VT->getNumElements() == 1))

getIndirectReturnResult(RetTy, State);

getIndirectReturnResult(RetTy, State);

getIndirectReturnResult(RetTy, State);

llvm::Type::getHalfTy(getVMContext()), 2));

(shouldReturnTypeInRegister(RetTy, getContext())) {

((!IsWin32StructABI && SeltTy->isRealFloatingType())

|| SeltTy->hasPointerRepresentation())

getIndirectReturnResult(RetTy, State);

RetTy = EnumTy->getDecl()->getIntegerType();

(EIT->getNumBits() > 64)

getIndirectReturnResult(RetTy, State);

X86_32ABIInfo::getTypeStackAlignInBytes(

Ty,

Align)

{

(Align <= MinABIStackAlignInBytes)

(Ty->

() && (Align == 16 || Align == 32 || Align == 64))

(!IsDarwinVectorABI) {

MinABIStackAlignInBytes;

MinABIStackAlignInBytes;

CCState &State)

{

(State.FreeRegs) {

getNaturalAlignIndirectInReg(Ty);

getNaturalAlignIndirect(Ty,

);

TypeAlign = getContext().getTypeAlign(Ty) / 8;

StackAlign = getTypeStackAlignInBytes(Ty, TypeAlign);

Realign = TypeAlign > StackAlign;

X86_32ABIInfo::Class X86_32ABIInfo::classify(

Ty)

{

(K == BuiltinType::Float || K == BuiltinType::Double)

X86_32ABIInfo::updateFreeRegs(

Ty, CCState &State)

{

(!IsSoftFloatABI) {

= getContext().getTypeSize(Ty);

SizeInRegs = (

+ 31) / 32;

(SizeInRegs > State.FreeRegs) {

(SizeInRegs > State.FreeRegs || SizeInRegs > 2)

State.FreeRegs -= SizeInRegs;

X86_32ABIInfo::shouldAggregateUseDirect(

Ty, CCState &State,

&NeedsPadding)

{

NeedsPadding =

;

(!updateFreeRegs(Ty, State))

(State.CC == llvm::CallingConv::X86_FastCall ||

State.CC == llvm::CallingConv::X86_VectorCall ||

State.CC == llvm::CallingConv::X86_RegCall) {

(getContext().getTypeSize(Ty) <= 32 && State.FreeRegs)

NeedsPadding =

;

X86_32ABIInfo::shouldPrimitiveUseInReg(

Ty, CCState &State)

{

IsPtrOrInt = (getContext().getTypeSize(Ty) <= 32) &&

(!IsPtrOrInt && (State.CC == llvm::CallingConv::X86_FastCall ||

State.CC == llvm::CallingConv::X86_VectorCall))

(!updateFreeRegs(Ty, State))

(!IsPtrOrInt && State.CC == llvm::CallingConv::X86_RegCall)

X86_32ABIInfo::runVectorCallFirstPass(

&FI, CCState &State)

{

(

I = 0,

= Args.size(); I <

; ++I) {

isHomogeneousAggregate(Ty,

, NumElts)) {

(State.FreeSSERegs >= NumElts) {

State.FreeSSERegs -= NumElts;

State.IsPreassigned.set(I);

ArgIndex)

{

IsFastCall = State.CC == llvm::CallingConv::X86_FastCall;

IsRegCall = State.CC == llvm::CallingConv::X86_RegCall;

IsVectorCall = State.CC == llvm::CallingConv::X86_VectorCall;

TI = getContext().getTypeInfo(Ty);

getIndirectResult(Ty,

, State);

}

(State.IsDelegateCall) {

Res = getIndirectResult(Ty,

, State);

((IsRegCall || IsVectorCall) &&

isHomogeneousAggregate(Ty,

, NumElts)) {

(State.FreeSSERegs >= NumElts) {

State.FreeSSERegs -= NumElts;

getDirectX86Hva();

getIndirectResult(Ty,

, State);

getIndirectResult(Ty,

, State);

(!IsWin32StructABI &&

(getContext(), Ty,

))

llvm::LLVMContext &LLVMContext = getVMContext();

llvm::IntegerType *

= llvm::Type::getInt32Ty(LLVMContext);

NeedsPadding =

;

(shouldAggregateUseDirect(Ty, State, InReg, NeedsPadding)) {

SizeInRegs = (TI.

+ 31) / 32;

llvm::Type *Result = llvm::StructType::get(LLVMContext, Elements);

llvm::IntegerType *PaddingType = NeedsPadding ?

:

;

(IsWin32StructABI && State.Required.isRequiredArg(ArgIndex)) {

AlignInBits = 0;

getContext().getASTRecordLayout(RT->

());

AlignInBits = TI.

;

(AlignInBits > 32)

getIndirectResult(Ty,

, State);

(TI.

<= 4 * 32 && (!IsMCUABI || State.FreeRegs == 0) &&

canExpandIndirectArgument(Ty))

IsFastCall || IsVectorCall || IsRegCall, PaddingType);

getIndirectResult(Ty,

, State);

(IsWin32StructABI) {

(TI.

<= 512 && State.FreeSSERegs > 0) {

getIndirectResult(Ty,

, State);

(IsDarwinVectorABI) {

(TI.

== 64 && VT->getNumElements() == 1))

llvm::IntegerType::get(getVMContext(), TI.

));

(IsX86_MMXType(CGT.ConvertType(Ty)))

Ty = EnumTy->getDecl()->getIntegerType();

InReg = shouldPrimitiveUseInReg(Ty, State);

(isPromotableIntegerTypeForABI(Ty)) {

(EIT->getNumBits() <= 64) {

getIndirectResult(Ty,

, State);

(State.CC == llvm::CallingConv::X86_FastCall) {

State.FreeSSERegs = 3;

}

(State.CC == llvm::CallingConv::X86_VectorCall) {

State.FreeSSERegs = 6;

(State.CC == llvm::CallingConv::X86_RegCall) {

State.FreeSSERegs = 8;

}

(IsWin32StructABI) {

State.FreeRegs = DefaultNumRegisterParameters;

State.FreeSSERegs = 3;

State.FreeRegs = DefaultNumRegisterParameters;

(State.FreeRegs) {

(State.CC == llvm::CallingConv::X86_VectorCall)

runVectorCallFirstPass(FI, State);

UsedInAlloca =

;

(

I = 0,

= Args.size(); I <

; ++I) {

(State.IsPreassigned.test(I))

rewriteWithInAlloca(FI);

assert(StackOffset.

(WordSize) &&

);

IsIndirect =

;

llvm::Type *LLTy = CGT.ConvertTypeForMem(

);

LLTy = llvm::PointerType::getUnqual(getVMContext());

FrameFields.push_back(LLTy);

StackOffset += IsIndirect ? WordSize : getContext().getTypeSizeInChars(

);

StackOffset = FieldEnd.

(WordSize);

(StackOffset != FieldEnd) {

NumBytes = StackOffset - FieldEnd;

llvm::Type *Ty = llvm::Type::getInt8Ty(getVMContext());

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

());

FrameFields.push_back(Ty);

llvm_unreachable(

);

X86_32ABIInfo::rewriteWithInAlloca(

&FI)

{

assert(IsWin32StructABI &&

);

(

.isIndirect() &&

.isSRetAfterThis() && !IsThisCall &&

addFieldToArgStruct(FrameFields, StackOffset, I->

, I->

);

(

.isIndirect() && !

.getInReg()) {

addFieldToArgStruct(FrameFields, StackOffset, Ret, FI.

());

.setInAllocaSRet(IsWin32StructABI);

(; I !=

; ++I) {

addFieldToArgStruct(FrameFields, StackOffset, I->

, I->

);

FI.

(llvm::StructType::get(getVMContext(), FrameFields,

= getContext().getTypeInfoInChars(Ty);

getTypeStackAlignInBytes(Ty,

.

.getQuantity()));

X86_32TargetCodeGenInfo::isStructReturnInRegABI(

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

(Opts.getStructReturnConvention()) {

(Triple.isOSDarwin() || Triple.isOSIAMCU())

(Triple.getOS()) {

llvm::Triple::DragonFly:

llvm::Triple::FreeBSD:

llvm::Triple::OpenBSD:

llvm::Triple::Win32:

(!FD->

<AnyX86InterruptAttr>())

llvm::Function *Fn = cast<llvm::Function>(GV);

Fn->setCallingConv(llvm::CallingConv::X86_INTR);

llvm::Attribute NewAttr = llvm::Attribute::getWithByValType(

Fn->getContext(), ByValTy);

Fn->addParamAttr(0, NewAttr);

X86_32TargetCodeGenInfo::setTargetAttributes(

(GV->isDeclaration())

(

*FD = dyn_cast_or_null<FunctionDecl>(

)) {

(FD->hasAttr<X86ForceAlignArgPointerAttr>()) {

llvm::Function *

= cast<llvm::Function>(GV);

->addFnAttr(

);

X86_32TargetCodeGenInfo::initDwarfEHRegSizeTable(

llvm::Value *

)

{

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

, 4);

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

, 16);

Builder.CreateAlignedStore(

Four8, Builder.CreateConstInBoundsGEP1_32(CGF.

,

, 9),

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

, 12);

getNativeVectorSizeForAVXABI(

AVXLevel) {

X86AVXABILevel::AVX512:

X86AVXABILevel::AVX:

X86AVXABILevel::None:

llvm_unreachable(

);

X86_64ABIInfo :

{

merge(Class Accum, Class Field);

postMerge(

AggregateSize, Class &Lo, Class &Hi)

;

classify(

, uint64_t OffsetBase, Class &Lo, Class &Hi,

isNamedArg,

IsRegCall =

)

;

llvm::Type *GetByteVectorType(

Ty)

;

llvm::Type *GetSSETypeAtOffset(llvm::Type *IRType,

IROffset,

SourceTy,

SourceOffset)

;

llvm::Type *GetINTEGERTypeAtOffset(llvm::Type *IRType,

IROffset,

SourceTy,

SourceOffset)

;

&neededInt,

&neededSSE,

IsRegCall =

)

;

&NeededSSE,

&MaxVectorWidth)

;

&NeededSSE,

&MaxVectorWidth)

;

IsIllegalVectorType(

Ty)

;

honorsRevision0_98()

{

classifyIntegerMMXAsSSE()

{

(

().getLangOpts().getClangABICompat() <=

LangOptions::ClangABI::Ver3_8)

(Triple.isOSDarwin() || Triple.isPS() || Triple.isOSFreeBSD())

passInt128VectorsInMem()

{

(

().getLangOpts().getClangABICompat() <=

LangOptions::ClangABI::Ver9)

.isOSLinux() ||

.isOSNetBSD();

Has64BitPointers;

:

(CGT), AVXLevel(AVXLevel),

Has64BitPointers(CGT.getDataLayout().getPointerSize(0) == 8) {}

neededInt, neededSSE;

(llvm::VectorType *vectorTy = dyn_cast_or_null<llvm::VectorType>(ty))

vectorTy->getPrimitiveSizeInBits().getFixedValue() > 128;

has64BitPointers()

{

Has64BitPointers;

WinX86_64ABIInfo :

{

:

(CGT), AVXLevel(AVXLevel),

IsMingw64(getTarget().getTriple().isWindowsGNUEnvironment()) {}

isX86VectorTypeForVectorCall(

(), Ty);

uint64_t NumMembers)

{

isX86VectorCallAggregateSmallEnough(NumMembers);

IsVectorCall,

IsRegCall)

;

std::make_unique<SwiftABIInfo>(CGT,

);

llvm::Value *

)

{

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

, 8);

StringRef Constraint,

llvm::Type* Ty)

{

X86AdjustInlineAsmType(CGF, Constraint, Ty);

HasAVXType =

;

(CallArgList::const_iterator

it = args.begin(), ie = args.end(); it != ie; ++it) {

(getABIInfo<X86_64ABIInfo>().isPassedUsingAVXType(it->Ty)) {

(GV->isDeclaration())

(

*FD = dyn_cast_or_null<FunctionDecl>(

)) {

(FD->hasAttr<X86ForceAlignArgPointerAttr>()) {

llvm::Function *

= cast<llvm::Function>(GV);

->addFnAttr(

);

ReturnType)

;

llvm::StringMap<bool> &CallerMap,

llvm::StringMap<bool> &CalleeMap,

(CalleeMap.empty() && CallerMap.empty()) {

llvm::StringMap<bool> &CallerMap,

llvm::StringMap<bool> &CalleeMap,

CallerHasFeat = CallerMap.lookup(Feature);

CalleeHasFeat = CalleeMap.lookup(Feature);

(!CallerHasFeat && !CalleeHasFeat)

.Report(CallLoc, diag::warn_avx_calling_convention)

<< IsArgument << Ty << Feature;

(!CallerHasFeat || !CalleeHasFeat)

.Report(CallLoc, diag::err_avx_calling_convention)

<< IsArgument << Ty << Feature;

llvm::StringMap<bool> &CallerMap,

llvm::StringMap<bool> &CalleeMap,

Caller256 = CallerMap.lookup(

) && !CallerMap.lookup(

);

Callee256 = CalleeMap.lookup(

) && !CalleeMap.lookup(

);

(Caller256 || Callee256)

.Report(CallLoc, diag::err_avx_calling_convention)

<< IsArgument << Ty <<

;

, IsArgument);

llvm::StringMap<bool> &CallerMap,

llvm::StringMap<bool> &CalleeMap,

Ty,

X86_64TargetCodeGenInfo::checkFunctionCallABI(

&CGM,

llvm::StringMap<bool> CallerMap;

llvm::StringMap<bool> CalleeMap;

ArgIndex = 0;

(

&Arg : Args) {

(Arg.getType()->isVectorType() &&

(ArgIndex < Callee->getNumParams())

Ty =

->getParamDecl(ArgIndex)->getType();

CalleeMap, Ty,

))

(

->getReturnType()->isVectorType() &&

CalleeMap,

->getReturnType(),

Quote = Lib.contains(

);

std::string ArgStr = Quote ?

:

;

(!Lib.ends_with_insensitive(

) && !Lib.ends_with_insensitive(

))

ArgStr += Quote ?

:

;

WinX86_32TargetCodeGenInfo :

X86_32TargetCodeGenInfo {

DarwinVectorABI,

RetSmallStructInRegABI,

Win32StructABI,

NumRegisterParameters)

: X86_32TargetCodeGenInfo(CGT, DarwinVectorABI, RetSmallStructInRegABI,

Win32StructABI, NumRegisterParameters,

) {}

setTargetAttributes(

*

, llvm::GlobalValue *GV,

getDependentLibraryOption(llvm::StringRef Lib,

Opt =

;

Opt += qualifyWindowsLibrary(Lib);

getDetectMismatchOption(llvm::StringRef Name,

llvm::StringRef

,

Opt =

+ Name.str() +

+

.str() +

;

WinX86_32TargetCodeGenInfo::setTargetAttributes(

X86_32TargetCodeGenInfo::setTargetAttributes(

, GV, CGM);

(GV->isDeclaration())

addStackProbeTargetAttributes(

, GV, CGM);

std::make_unique<SwiftABIInfo>(CGT,

);

setTargetAttributes(

*

, llvm::GlobalValue *GV,

llvm::Value *

)

{

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

, 8);

getDependentLibraryOption(llvm::StringRef Lib,

Opt =

;

Opt += qualifyWindowsLibrary(Lib);

getDetectMismatchOption(llvm::StringRef Name,

llvm::StringRef

,

Opt =

+ Name.str() +

+

.str() +

;

WinX86_64TargetCodeGenInfo::setTargetAttributes(

(GV->isDeclaration())

(

*FD = dyn_cast_or_null<FunctionDecl>(

)) {

(FD->hasAttr<X86ForceAlignArgPointerAttr>()) {

llvm::Function *

= cast<llvm::Function>(GV);

->addFnAttr(

);

addStackProbeTargetAttributes(

, GV, CGM);

X86_64ABIInfo::postMerge(

AggregateSize,

&Lo,

(Hi == X87Up && Lo != X87 && honorsRevision0_98())

(AggregateSize > 128 && (Lo != SSE || Hi != SSEUp))

(Hi == SSEUp && Lo != SSE)

X86_64ABIInfo::Class X86_64ABIInfo::merge(

Accum,

Field) {

assert((Accum != Memory && Accum != ComplexX87) &&

);

(Accum == Field || Field == NoClass)

(Field == Memory)

(Accum == NoClass)

(Field == X87 || Field == X87Up || Field == ComplexX87 ||

Accum == X87 || Accum == X87Up)

X86_64ABIInfo::classify(

Ty, uint64_t OffsetBase,

&Lo,

&Hi,

isNamedArg,

IsRegCall)

{

&Current = OffsetBase < 64 ? Lo : Hi;

(k == BuiltinType::Void) {

}

(k == BuiltinType::Int128 || k == BuiltinType::UInt128) {

}

(k >= BuiltinType::Bool && k <= BuiltinType::LongLong) {

}

(k == BuiltinType::Float || k == BuiltinType::Double ||

k == BuiltinType::Float16 || k == BuiltinType::BFloat16) {

}

(k == BuiltinType::Float128) {

}

(k == BuiltinType::LongDouble) {

llvm::fltSemantics *LDF = &getTarget().getLongDoubleFormat();

(LDF == &llvm::APFloat::IEEEquad()) {

}

(LDF == &llvm::APFloat::x87DoubleExtended()) {

}

(LDF == &llvm::APFloat::IEEEdouble()) {

llvm_unreachable(

);

classify(ET->getDecl()->getIntegerType(), OffsetBase, Lo, Hi, isNamedArg);

(Has64BitPointers) {

EB_FuncPtr = (OffsetBase) / 64;

EB_ThisAdj = (OffsetBase + 64 - 1) / 64;

(EB_FuncPtr != EB_ThisAdj) {

(Size == 1 || Size == 8 || Size == 16 || Size == 32) {

EB_Lo = (OffsetBase) / 64;

}

(Size == 64) {

ElementType = VT->getElementType();

(!classifyIntegerMMXAsSSE() &&

(OffsetBase && OffsetBase != 64)

}

(Size == 128 ||

(isNamedArg && Size <= getNativeVectorSizeForAVXABI(AVXLevel))) {

ElementType = VT->getElementType();

(passInt128VectorsInMem() &&

!= 128 &&

(Size <= 128)

}

(ET->

() || ET == getContext().FloatTy ||

}

(ET == getContext().DoubleTy) {

}

(ET == getContext().LongDoubleTy) {

llvm::fltSemantics *LDF = &getTarget().getLongDoubleFormat();

(LDF == &llvm::APFloat::IEEEquad())

(LDF == &llvm::APFloat::x87DoubleExtended())

Current = ComplexX87;

(LDF == &llvm::APFloat::IEEEdouble())

llvm_unreachable(

);

EB_Real = (OffsetBase) / 64;

EB_Imag = (OffsetBase + getContext().getTypeSize(ET)) / 64;

(Hi == NoClass && EB_Real != EB_Imag)

(EITy->getNumBits() <= 64)

(EITy->getNumBits() <= 128)

(!IsRegCall && Size > 512)

(OffsetBase % getContext().getTypeAlign(AT->getElementType()))

EltSize = getContext().getTypeSize(AT->getElementType());

ArraySize = AT->getZExtSize();

(Size != EltSize || Size > getNativeVectorSizeForAVXABI(AVXLevel)))

(uint64_t i=0, Offset=OffsetBase; i<ArraySize; ++i, Offset += EltSize) {

FieldLo, FieldHi;

classify(AT->getElementType(), Offset, FieldLo, FieldHi, isNamedArg);

Lo = merge(Lo, FieldLo);

Hi = merge(Hi, FieldHi);

(Lo == Memory || Hi == Memory)

postMerge(Size, Lo, Hi);

assert((Hi != SSEUp || Lo == SSE) &&

);

(

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

(

&I : CXXRD->bases()) {

assert(!I.isVirtual() && !I.getType()->isDependentType() &&

);

FieldLo, FieldHi;

classify(I.getType(), Offset, FieldLo, FieldHi, isNamedArg);

Lo = merge(Lo, FieldLo);

Hi = merge(Hi, FieldHi);

(Lo == Memory || Hi == Memory) {

postMerge(Size, Lo, Hi);

UseClang11Compat = getContext().getLangOpts().getClangABICompat() <=

getContext().getTargetInfo().getTriple().isPS();

IsUnion = RT->

() && !UseClang11Compat;

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

BitField = i->isBitField();

(BitField && i->isUnnamedBitField())

((!IsUnion && Size != getContext().getTypeSize(i->getType())) ||

Size > getNativeVectorSizeForAVXABI(AVXLevel))) {

postMerge(Size, Lo, Hi);

Offset % getContext().getTypeAlign(i->getType().getCanonicalType());

(!BitField && IsInMemory) {

postMerge(Size, Lo, Hi);

FieldLo, FieldHi;

assert(!i->isUnnamedBitField());

assert(EB_Hi == EB_Lo &&

);

FieldHi = EB_Hi ?

: NoClass;

classify(i->getType(), Offset, FieldLo, FieldHi, isNamedArg);

Lo = merge(Lo, FieldLo);

Hi = merge(Hi, FieldHi);

(Lo == Memory || Hi == Memory)

postMerge(Size, Lo, Hi);

Ty = EnumTy->getDecl()->getIntegerType();

getNaturalAlignIndirect(Ty);

getNaturalAlignIndirect(Ty);

X86_64ABIInfo::IsIllegalVectorType(

Ty)

{

LargestVector = getNativeVectorSizeForAVXABI(AVXLevel);

(Size <= 64 || Size > LargestVector)

EltTy = VecTy->getElementType();

(passInt128VectorsInMem() &&

freeIntRegs)

{

Ty = EnumTy->getDecl()->getIntegerType();

Align = std::max(getContext().getTypeAlign(Ty) / 8, 8U);

(freeIntRegs == 0) {

(Align == 8 && Size <= 64)

llvm::Type *X86_64ABIInfo::GetByteVectorType(

Ty)

{

llvm::Type *IRType = CGT.ConvertType(Ty);

(isa<llvm::VectorType>(IRType)) {

(passInt128VectorsInMem() &&

cast<llvm::VectorType>(IRType)->getElementType()->isIntegerTy(128)) {

llvm::FixedVectorType::get(llvm::Type::getInt64Ty(getVMContext()),

(IRType->getTypeID() == llvm::Type::FP128TyID)

assert((Size == 128 || Size == 256 || Size == 512) &&

);

llvm::FixedVectorType::get(llvm::Type::getDoubleTy(getVMContext()),

(TySize <= StartBit)

NumElts = (

)AT->getZExtSize();

(

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

EltOffset = i*EltSize;

(EltOffset >= EndBit)

;

EltStart = EltOffset < StartBit ? StartBit-EltOffset :0;

EndBit-EltOffset, Context))

(

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

(

&I : CXXRD->bases()) {

assert(!I.isVirtual() && !I.getType()->isDependentType() &&

);

(BaseOffset >= EndBit)

;

BaseStart = BaseOffset < StartBit ? StartBit-BaseOffset :0;

EndBit-BaseOffset, Context))

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

(FieldOffset >= EndBit)

;

FieldStart = FieldOffset < StartBit ? StartBit-FieldOffset :0;

llvm::DataLayout &TD) {

(IROffset == 0 && IRType->isFloatingPointTy())

(llvm::StructType *STy = dyn_cast<llvm::StructType>(IRType)) {

(!STy->getNumContainedTypes())

llvm::StructLayout *SL = TD.getStructLayout(STy);

Elt = SL->getElementContainingOffset(IROffset);

IROffset -= SL->getElementOffset(Elt);

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

llvm::Type *EltTy = ATy->getElementType();

EltSize = TD.getTypeAllocSize(EltTy);

IROffset -= IROffset / EltSize * EltSize;

llvm::Type *X86_64ABIInfo::

GetSSETypeAtOffset(llvm::Type *IRType,

IROffset,

SourceTy,

SourceOffset)

{

llvm::DataLayout &TD = getDataLayout();

SourceSize =

(

)getContext().getTypeSize(SourceTy) / 8 - SourceOffset;

(!T0 || T0->isDoubleTy())

llvm::Type::getDoubleTy(getVMContext());

llvm::Type *T1 =

;

T0Size = TD.getTypeAllocSize(T0);

(SourceSize > T0Size)

(T1 ==

) {

(T0->is16bitFPTy() && SourceSize > 4)

(T0->isFloatTy() && T1->isFloatTy())

llvm::FixedVectorType::get(T0, 2);

(T0->is16bitFPTy() && T1->is16bitFPTy()) {

llvm::Type *T2 =

;

llvm::FixedVectorType::get(T0, 2);

llvm::FixedVectorType::get(T0, 4);

(T0->is16bitFPTy() || T1->is16bitFPTy())

llvm::FixedVectorType::get(llvm::Type::getHalfTy(getVMContext()), 4);

llvm::Type::getDoubleTy(getVMContext());

llvm::Type *X86_64ABIInfo::

GetINTEGERTypeAtOffset(llvm::Type *IRType,

IROffset,

SourceTy,

SourceOffset)

{

(IROffset == 0) {

((isa<llvm::PointerType>(IRType) && Has64BitPointers) ||

IRType->isIntegerTy(64))

(IRType->isIntegerTy(8) || IRType->isIntegerTy(16) ||

IRType->isIntegerTy(32) ||

(isa<llvm::PointerType>(IRType) && !Has64BitPointers)) {

BitWidth = isa<llvm::PointerType>(IRType) ? 32 :

cast<llvm::IntegerType>(IRType)->getBitWidth();

SourceOffset*8+64, getContext()))

(llvm::StructType *STy = dyn_cast<llvm::StructType>(IRType)) {

llvm::StructLayout *SL = getDataLayout().getStructLayout(STy);

(IROffset < SL->getSizeInBytes()) {

FieldIdx = SL->getElementContainingOffset(IROffset);

IROffset -= SL->getElementOffset(FieldIdx);

GetINTEGERTypeAtOffset(STy->getElementType(FieldIdx), IROffset,

SourceTy, SourceOffset);

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

llvm::Type *EltTy = ATy->getElementType();

EltSize = getDataLayout().getTypeAllocSize(EltTy);

EltOffset = IROffset/EltSize*EltSize;

GetINTEGERTypeAtOffset(EltTy, IROffset-EltOffset, SourceTy,

TySizeInBytes =

(

)getContext().getTypeSizeInChars(SourceTy).getQuantity();

assert(TySizeInBytes != SourceOffset &&

);

llvm::IntegerType::get(getVMContext(),

std::min(TySizeInBytes-SourceOffset, 8U)*8);

llvm::DataLayout &TD) {

LoSize = (

)TD.getTypeAllocSize(Lo);

llvm::Align HiAlign = TD.getABITypeAlign(Hi);

HiStart = llvm::alignTo(LoSize, HiAlign);

assert(HiStart != 0 && HiStart <= 8 &&

);

(Lo->isHalfTy() || Lo->isFloatTy())

Lo = llvm::Type::getDoubleTy(Lo->getContext());

assert((Lo->isIntegerTy() || Lo->isPointerTy())

&&

);

Lo = llvm::Type::getInt64Ty(Lo->getContext());

llvm::StructType *

= llvm::StructType::get(Lo, Hi);

assert(TD.getStructLayout(

)->getElementOffset(1) == 8 &&

);

classifyReturnType(

RetTy)

{

X86_64ABIInfo::Class Lo, Hi;

classify(RetTy, 0, Lo, Hi,

);

assert((Hi != Memory || Lo == Memory) &&

);

assert((Hi != SSEUp || Lo == SSE) &&

);

llvm::Type *ResType =

;

assert((Hi == SSE || Hi ==

|| Hi == X87Up) &&

);

llvm_unreachable(

);

getIndirectReturnResult(RetTy);

ResType = GetINTEGERTypeAtOffset(CGT.ConvertType(RetTy), 0, RetTy, 0);

(Hi == NoClass && isa<llvm::IntegerType>(ResType)) {

RetTy = EnumTy->getDecl()->getIntegerType();

isPromotableIntegerTypeForABI(RetTy))

ResType = GetSSETypeAtOffset(CGT.ConvertType(RetTy), 0, RetTy, 0);

ResType = llvm::Type::getX86_FP80Ty(getVMContext());

assert(Hi == ComplexX87 &&

);

ResType = llvm::StructType::get(llvm::Type::getX86_FP80Ty(getVMContext()),

llvm::Type::getX86_FP80Ty(getVMContext()));

llvm::Type *HighPart =

;

llvm_unreachable(

);

HighPart = GetINTEGERTypeAtOffset(CGT.ConvertType(RetTy), 8, RetTy, 8);

HighPart = GetSSETypeAtOffset(CGT.ConvertType(RetTy), 8, RetTy, 8);

assert(Lo == SSE &&

);

ResType = GetByteVectorType(RetTy);

HighPart = GetSSETypeAtOffset(CGT.ConvertType(RetTy), 8, RetTy, 8);

X86_64ABIInfo::classifyArgumentType(

Ty,

freeIntRegs,

&neededInt,

&neededSSE,

isNamedArg,

IsRegCall)

{

X86_64ABIInfo::Class Lo, Hi;

classify(Ty, 0, Lo, Hi, isNamedArg, IsRegCall);

assert((Hi != Memory || Lo == Memory) &&

);

assert((Hi != SSEUp || Lo == SSE) &&

);

llvm::Type *ResType =

;

assert((Hi == SSE || Hi ==

|| Hi == X87Up) &&

);

getIndirectResult(Ty, freeIntRegs);

llvm_unreachable(

);

ResType = GetINTEGERTypeAtOffset(CGT.ConvertType(Ty), 0, Ty, 0);

(Hi == NoClass && isa<llvm::IntegerType>(ResType)) {

Ty = EnumTy->getDecl()->getIntegerType();

isPromotableIntegerTypeForABI(Ty))

llvm::Type *IRType = CGT.ConvertType(Ty);

ResType = GetSSETypeAtOffset(IRType, 0, Ty, 0);

llvm::Type *HighPart =

;

llvm_unreachable(

);

NoClass:

;

HighPart = GetINTEGERTypeAtOffset(CGT.ConvertType(Ty), 8, Ty, 8);

HighPart = GetSSETypeAtOffset(CGT.ConvertType(Ty), 8, Ty, 8);

assert(Lo == SSE &&

);

ResType = GetByteVectorType(Ty);

X86_64ABIInfo::classifyRegCallStructTypeImpl(

Ty,

&NeededInt,

&NeededSSE,

&MaxVectorWidth)

{

assert(RT &&

);

getIndirectReturnResult(Ty);

(

CXXRD = dyn_cast<CXXRecordDecl>(RT->

())) {

(CXXRD->isDynamicClass()) {

NeededInt = NeededSSE = 0;

getIndirectReturnResult(Ty);

(

&I : CXXRD->bases())

(classifyRegCallStructTypeImpl(I.getType(), NeededInt, NeededSSE,

NeededInt = NeededSSE = 0;

getIndirectReturnResult(Ty);

(classifyRegCallStructTypeImpl(MTy, NeededInt, NeededSSE,

NeededInt = NeededSSE = 0;

getIndirectReturnResult(Ty);

LocalNeededInt, LocalNeededSSE;

NeededInt = NeededSSE = 0;

getIndirectReturnResult(Ty);

(

*AT = getContext().getAsConstantArrayType(MTy))

MTy = AT->getElementType();

(getContext().getTypeSize(VT) > MaxVectorWidth)

MaxVectorWidth = getContext().getTypeSize(VT);

NeededInt += LocalNeededInt;

NeededSSE += LocalNeededSSE;

X86_64ABIInfo::classifyRegCallStructType(

Ty,

&NeededInt,

&NeededSSE,

&MaxVectorWidth)

{

classifyRegCallStructTypeImpl(Ty, NeededInt, NeededSSE,

WinX86_64ABIInfo Win64ABIInfo(CGT, AVXLevel);

Win64ABIInfo.computeInfo(FI);

IsRegCall =

== llvm::CallingConv::X86_RegCall;

FreeIntRegs = IsRegCall ? 11 : 6;

FreeSSERegs = IsRegCall ? 16 : 8;

NeededInt = 0, NeededSSE = 0, MaxVectorWidth = 0;

FI.

(), NeededInt, NeededSSE, MaxVectorWidth);

(FreeIntRegs >= NeededInt && FreeSSERegs >= NeededSSE) {

FreeIntRegs -= NeededInt;

FreeSSERegs -= NeededSSE;

getContext().LongDoubleTy)

(NeededSSE && MaxVectorWidth > 0)

it != ie; ++it, ++ArgNo) {

IsNamedArg = ArgNo < NumRequiredArgs;

(IsRegCall && it->type->isStructureOrClassType())

it->info = classifyRegCallStructType(it->type, NeededInt, NeededSSE,

NeededSSE, IsNamedArg);

(FreeIntRegs >= NeededInt && FreeSSERegs >= NeededSSE) {

FreeIntRegs -= NeededInt;

FreeSSERegs -= NeededSSE;

it->info = getIndirectResult(it->type, FreeIntRegs);

llvm::Value *overflow_arg_area =

llvm::Value *Res = overflow_arg_area;

llvm::Value *Offset =

llvm::ConstantInt::get(CGF.

, (SizeInBytes + 7) & ~7);

Offset,

);

(Res, LTy, Align);

neededInt, neededSSE;

(!neededInt && !neededSSE)

llvm::Value *InRegs =

;

llvm::Value *gp_offset =

, *fp_offset =

;

InRegs = llvm::ConstantInt::get(CGF.

, 48 - neededInt * 8);

InRegs = CGF.

.CreateICmpULE(gp_offset, InRegs,

);

llvm::Value *FitsInFP =

llvm::ConstantInt::get(CGF.

, 176 - neededSSE * 16);

FitsInFP = CGF.

.CreateICmpULE(fp_offset, FitsInFP,

);

InRegs = InRegs ? CGF.

.CreateAnd(InRegs, FitsInFP) : FitsInFP;

CGF.

.CreateCondBr(InRegs, InRegBlock, InMemBlock);

(neededInt && neededSSE) {

assert(AI.

() &&

);

llvm::StructType *ST = cast<llvm::StructType>(AI.

());

assert(ST->getNumElements() == 2 &&

);

llvm::Type *TyLo = ST->getElementType(0);

llvm::Type *TyHi = ST->getElementType(1);

assert((TyLo->isFPOrFPVectorTy() ^ TyHi->isFPOrFPVectorTy()) &&

);

llvm::Value *GPAddr =

llvm::Value *FPAddr =

llvm::Value *RegLoAddr = TyLo->isFPOrFPVectorTy() ? FPAddr : GPAddr;

llvm::Value *RegHiAddr = TyLo->isFPOrFPVectorTy() ? GPAddr : FPAddr;

}

(neededInt || neededSSE == 1) {

TInfo = getContext().getTypeInfoInChars(Ty);

TySize = TInfo.Width.getQuantity();

llvm::Type *CoTy =

;

llvm::Value *GpOrFpOffset = neededInt ? gp_offset : fp_offset;

Alignment = neededInt ? 8 : 16;

RegSize = neededInt ? neededInt * 8 : 16;

llvm::Value *PtrOffset =

assert(neededSSE == 2 &&

);

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

, neededInt * 8);

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

, neededSSE * 16);

Width = getContext().getTypeSize(Ty);

IsIndirect = Width > 64 || !llvm::isPowerOf2_64(Width);

WinX86_64ABIInfo::reclassifyHvaArgForVectorCall(

isHomogeneousAggregate(Ty,

, NumElts) && FreeSSERegs >= NumElts) {

FreeSSERegs -= NumElts;

getDirectX86Hva();

IsReturnType,

IsVectorCall,

IsRegCall)

{

Ty = EnumTy->getDecl()->getIntegerType();

Info = getContext().getTypeInfo(Ty);

Align = getContext().toCharUnitsFromBits(Info.

);

(!IsReturnType) {

getNaturalAlignIndirect(Ty,

);

((IsVectorCall || IsRegCall) &&

isHomogeneousAggregate(Ty,

, NumElts)) {

(FreeSSERegs >= NumElts) {

FreeSSERegs -= NumElts;

}

(IsVectorCall) {

(FreeSSERegs >= NumElts &&

FreeSSERegs -= NumElts;

}

(IsReturnType) {

llvm::Type *LLTy = CGT.ConvertType(Ty);

(LLTy->isPointerTy() || LLTy->isIntegerTy())

(Width > 64 || !llvm::isPowerOf2_64(Width))

getNaturalAlignIndirect(Ty,

);

(BT->getKind()) {

BuiltinType::Bool:

BuiltinType::LongDouble:

llvm::fltSemantics *LDF = &getTarget().getLongDoubleFormat();

(LDF == &llvm::APFloat::x87DoubleExtended())

BuiltinType::Int128:

BuiltinType::UInt128:

llvm::Type::getInt64Ty(getVMContext()), 2));

IsVectorCall = CC == llvm::CallingConv::X86_VectorCall;

IsRegCall = CC == llvm::CallingConv::X86_RegCall;

(CC == llvm::CallingConv::X86_64_SysV) {

X86_64ABIInfo SysVABIInfo(CGT, AVXLevel);

SysVABIInfo.computeInfo(FI);

FreeSSERegs = 0;

}

(IsRegCall) {

IsVectorCall, IsRegCall);

}

(IsRegCall) {

ArgNum = 0;

ZeroSSERegs = 0;

*MaybeFreeSSERegs =

(IsVectorCall && ArgNum >= 6) ? &ZeroSSERegs : &FreeSSERegs;

classify(I.

, *MaybeFreeSSERegs,

, IsVectorCall, IsRegCall);

I.

= reclassifyHvaArgForVectorCall(I.

, FreeSSERegs, I.

);

Width = getContext().getTypeSize(Ty);

IsIndirect = Width > 64 || !llvm::isPowerOf2_64(Width);

&CGM,

DarwinVectorABI,

Win32StructABI,

NumRegisterParameters,

SoftFloatABI) {

RetSmallStructInRegABI = X86_32TargetCodeGenInfo::isStructReturnInRegABI(

std::make_unique<X86_32TargetCodeGenInfo>(

CGM.

(), DarwinVectorABI, RetSmallStructInRegABI, Win32StructABI,

NumRegisterParameters, SoftFloatABI);

&CGM,

DarwinVectorABI,

Win32StructABI,

NumRegisterParameters) {

RetSmallStructInRegABI = X86_32TargetCodeGenInfo::isStructReturnInRegABI(

std::make_unique<WinX86_32TargetCodeGenInfo>(

CGM.

(), DarwinVectorABI, RetSmallStructInRegABI, Win32StructABI,

NumRegisterParameters);

std::unique_ptr<TargetCodeGenInfo>

std::make_unique<X86_64TargetCodeGenInfo>(CGM.

(), AVXLevel);

std::unique_ptr<TargetCodeGenInfo>

std::make_unique<WinX86_64TargetCodeGenInfo>(CGM.

(), AVXLevel);

static bool checkAVX512ParamFeature(DiagnosticsEngine &Diag, SourceLocation CallLoc, const llvm::StringMap< bool > &CallerMap, const llvm::StringMap< bool > &CalleeMap, QualType Ty, bool IsArgument)

static bool is32Or64BitBasicType(QualType Ty, ASTContext &Context)

static void rewriteInputConstraintReferences(unsigned FirstIn, unsigned NumNewOuts, std::string &AsmString)

Rewrite input constraint references after adding some output constraints.

static void initFeatureMaps(const ASTContext &Ctx, llvm::StringMap< bool > &CallerMap, const FunctionDecl *Caller, llvm::StringMap< bool > &CalleeMap, const FunctionDecl *Callee)

static llvm::Type * GetX86_64ByValArgumentPair(llvm::Type *Lo, llvm::Type *Hi, const llvm::DataLayout &TD)

GetX86_64ByValArgumentPair - Given a high and low type that can ideally be used as elements of a two ...

static bool checkAVXParam(DiagnosticsEngine &Diag, ASTContext &Ctx, SourceLocation CallLoc, const llvm::StringMap< bool > &CallerMap, const llvm::StringMap< bool > &CalleeMap, QualType Ty, bool IsArgument)

static bool checkAVXParamFeature(DiagnosticsEngine &Diag, SourceLocation CallLoc, const llvm::StringMap< bool > &CallerMap, const llvm::StringMap< bool > &CalleeMap, QualType Ty, StringRef Feature, bool IsArgument)

static bool addBaseAndFieldSizes(ASTContext &Context, const CXXRecordDecl *RD, uint64_t &Size)

static llvm::Type * getFPTypeAtOffset(llvm::Type *IRType, unsigned IROffset, const llvm::DataLayout &TD)

getFPTypeAtOffset - Return a floating point type at the specified offset.

static bool addFieldSizes(ASTContext &Context, const RecordDecl *RD, uint64_t &Size)

static bool BitsContainNoUserData(QualType Ty, unsigned StartBit, unsigned EndBit, ASTContext &Context)

BitsContainNoUserData - Return true if the specified [start,end) bit range is known to either be off ...

static Address EmitX86_64VAArgFromMemory(CodeGenFunction &CGF, Address VAListAddr, QualType Ty)

static void addX86InterruptAttrs(const FunctionDecl *FD, llvm::GlobalValue *GV, CodeGen::CodeGenModule &CGM)

static bool isArgInAlloca(const ABIArgInfo &Info)

static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)

Produce a diagnostic highlighting some portion of a literal.

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

TypeInfoChars getTypeInfoInChars(const Type *T) const

int64_t toBits(CharUnits CharSize) const

Convert a size in characters to a size in bits.

uint64_t getTypeSize(QualType T) const

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

const TargetInfo & getTargetInfo() const

void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) 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 getRequiredAlignment() const

CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const

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

A fixed int type of a specified bitwidth.

This class is used for builtin types like 'int'.

Represents a base class of a C++ class.

Represents a C++ struct/union/class.

CanProxy< U > getAs() const

Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed.

const T * getTypePtr() const

Retrieve the underlying type pointer, which refers to a canonical type.

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

QuantityType getQuantity() const

getQuantity - Get the raw integer representation of this quantity.

static CharUnits One()

One - Construct a CharUnits quantity of one.

bool isMultipleOf(CharUnits N) const

Test whether this is a multiple of the other value.

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

CodeGenOptions - Track various options which control how the code is optimized and passed to the back...

ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to ...

bool getIndirectByVal() const

static ABIArgInfo getInAlloca(unsigned FieldIndex, bool Indirect=false)

static ABIArgInfo getIgnore()

static ABIArgInfo getExpand()

unsigned getDirectOffset() const

void setIndirectAlign(CharUnits IA)

static ABIArgInfo getExtendInReg(QualType Ty, llvm::Type *T=nullptr)

static ABIArgInfo getExpandWithPadding(bool PaddingInReg, llvm::Type *Padding)

static ABIArgInfo getIndirect(CharUnits Alignment, bool ByVal=true, bool Realign=false, llvm::Type *Padding=nullptr)

static ABIArgInfo getDirect(llvm::Type *T=nullptr, unsigned Offset=0, llvm::Type *Padding=nullptr, bool CanBeFlattened=true, unsigned Align=0)

@ Extend

Extend - Valid only for integer argument types.

@ Ignore

Ignore - Ignore the argument (treat as void).

@ IndirectAliased

IndirectAliased - Similar to Indirect, but the pointer may be to an object that is otherwise referenc...

@ Expand

Expand - Only valid for aggregate argument types.

@ InAlloca

InAlloca - Pass the argument directly using the LLVM inalloca attribute.

@ Indirect

Indirect - Pass the argument indirectly via a hidden pointer with the specified alignment (0 indicate...

@ CoerceAndExpand

CoerceAndExpand - Only valid for aggregate argument types.

@ Direct

Direct - Pass the argument directly using the normal converted LLVM type, or by coercing to another s...

static ABIArgInfo getExtend(QualType Ty, llvm::Type *T=nullptr)

llvm::Type * getCoerceToType() const

bool canHaveCoerceToType() const

static ABIArgInfo getDirectInReg(llvm::Type *T=nullptr)

ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions.

ASTContext & getContext() const

virtual bool isHomogeneousAggregateBaseType(QualType Ty) const

virtual RValue EmitMSVAArg(CodeGen::CodeGenFunction &CGF, CodeGen::Address VAListAddr, QualType Ty, AggValueSlot Slot) const

Emit the target dependent code to load a value of.

virtual bool isHomogeneousAggregateSmallEnough(const Type *Base, uint64_t Members) const

const TargetInfo & getTarget() const

virtual RValue EmitVAArg(CodeGen::CodeGenFunction &CGF, CodeGen::Address VAListAddr, QualType Ty, AggValueSlot Slot) const =0

EmitVAArg - Emit the target dependent code to load a value of.

virtual void computeInfo(CodeGen::CGFunctionInfo &FI) const =0

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

llvm::Value * getBasePointer() const

Address withElementType(llvm::Type *ElemTy) const

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

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

Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")

Given a pointer to i8, adjust it by a given constant offset.

Address CreateGEP(CodeGenFunction &CGF, Address Addr, llvm::Value *Index, const llvm::Twine &Name="")

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

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

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

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

RecordArgABI

Specify how one should pass an argument of a record type.

@ RAA_Indirect

Pass it as a pointer to temporary memory.

@ RAA_DirectInMemory

Pass it on the stack using its defined layout.

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

ABIArgInfo & getReturnInfo()

unsigned getCallingConvention() const

getCallingConvention - Return the user specified calling convention, which has been translated into a...

const_arg_iterator arg_begin() const

unsigned getRegParm() const

CanQualType getReturnType() const

bool getHasRegParm() const

MutableArrayRef< ArgInfo > arguments()

const_arg_iterator arg_end() const

void setArgStruct(llvm::StructType *Ty, CharUnits Align)

unsigned getMaxVectorWidth() const

Return the maximum vector width in the arguments.

unsigned getNumRequiredArgs() const

void setMaxVectorWidth(unsigned Width)

Set the maximum vector width in the arguments.

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

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

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

createBasicBlock - Create an LLVM basic block.

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

EmitBlock - Emit the given block.

llvm::Type * ConvertTypeForMem(QualType T)

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

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

void EmitBranch(llvm::BasicBlock *Block)

EmitBranch - Emit a branch to the specified basic block from the current insert block,...

ASTContext & getContext() const

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

const CGFunctionInfo * CurFnInfo

llvm::LLVMContext & getLLVMContext()

RValue EmitLoadOfAnyValue(LValue V, AggValueSlot Slot=AggValueSlot::ignored(), SourceLocation Loc={})

Like EmitLoadOfLValue but also handles complex and aggregate types.

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

DiagnosticsEngine & getDiags() const

CodeGenTypes & getTypes()

const TargetInfo & getTarget() const

const llvm::Triple & getTriple() const

ASTContext & getContext() const

const CodeGenOptions & getCodeGenOpts() const

This class organizes the cross-module state that is used while lowering AST types to LLVM types.

llvm::Type * ConvertType(QualType T)

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

LValue - This represents an lvalue references.

Address getAddress() const

void setAddress(Address address)

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

A class for recording the number of arguments that a function signature requires.

Target specific hooks for defining how a type should be passed or returned from functions with one of...

bool occupiesMoreThan(ArrayRef< llvm::Type * > scalarTypes, unsigned maxAllRegisters) const

Does the given lowering require more than the given number of registers when expanded?

virtual bool shouldPassIndirectly(ArrayRef< llvm::Type * > ComponentTys, bool AsReturnValue) const

Returns true if an aggregate which expands to the given type sequence should be passed / returned ind...

TargetCodeGenInfo - This class organizes various target-specific codegeneration issues,...

virtual void addReturnRegisterOutputs(CodeGen::CodeGenFunction &CGF, CodeGen::LValue ReturnValue, std::string &Constraints, std::vector< llvm::Type * > &ResultRegTypes, std::vector< llvm::Type * > &ResultTruncRegTypes, std::vector< CodeGen::LValue > &ResultRegDests, std::string &AsmString, unsigned NumOutputs) const

Adds constraints and types for result registers.

virtual llvm::Type * adjustInlineAsmType(CodeGen::CodeGenFunction &CGF, StringRef Constraint, llvm::Type *Ty) const

Corrects the low-level LLVM type for a given constraint and "usual" type.

virtual StringRef getARCRetainAutoreleasedReturnValueMarker() const

Retrieve the address of a function to call immediately before calling objc_retainAutoreleasedReturnVa...

virtual void checkFunctionCallABI(CodeGenModule &CGM, SourceLocation CallLoc, const FunctionDecl *Caller, const FunctionDecl *Callee, const CallArgList &Args, QualType ReturnType) const

Any further codegen related checks that need to be done on a function call in a target specific manne...

virtual bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, llvm::Value *Address) const

Initializes the given DWARF EH register-size table, a char*.

virtual void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M) const

setTargetAttributes - Provides a convenient hook to handle extra target-specific attributes for the g...

static std::string qualifyWindowsLibrary(StringRef Lib)

virtual int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const

Determines the DWARF register number for the stack pointer, for exception-handling purposes.

virtual bool markARCOptimizedReturnCallsAsNoTail() const

Determine whether a call to objc_retainAutoreleasedReturnValue or objc_unsafeClaimAutoreleasedReturnV...

virtual bool isNoProtoCallVariadic(const CodeGen::CallArgList &args, const FunctionNoProtoType *fnType) const

Determine whether a call to an unprototyped functions under the given calling convention should use t...

Complex values, per C99 6.2.5p11.

QualType getElementType() const

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

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

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

Concrete class used by the front-end to report problems and issues.

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

Represents a function declaration or definition.

const ParmVarDecl * getParamDecl(unsigned i) const

unsigned getNumParams() const

Return the number of parameters this function must have based on its FunctionType.

Represents a K&R-style 'int foo()' function, which has no information available about its arguments.

CallingConv getCallConv() const

@ Ver11

Attempt to be ABI-compatible with code generated by Clang 11.0.x (git 2e10b7a39b93).

A (possibly-)qualified type.

const Type * getTypePtr() const

Retrieves a pointer to the underlying (unqualified) type.

QualType getCanonicalType() const

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.

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

const llvm::fltSemantics & getLongDoubleFormat() const

The base class of the type hierarchy.

bool isBlockPointerType() const

bool isFloat16Type() const

bool isPointerType() const

bool isReferenceType() const

bool isEnumeralType() const

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

bool isBitIntType() const

bool isSpecificBuiltinType(unsigned K) const

Test for a particular builtin type.

bool isBuiltinType() const

Helper methods to distinguish type categories.

bool isAnyComplexType() const

bool isMemberPointerType() const

bool isBFloat16Type() const

bool isMemberFunctionPointerType() const

bool isVectorType() const

const T * getAs() const

Member-template getAs<specific type>'.

bool isRecordType() const

bool hasPointerRepresentation() const

Whether this type is represented natively as a pointer.

Represents a GCC generic vector type.

ABIArgInfo classifyArgumentType(CodeGenModule &CGM, CanQualType type)

Classify the rules for how to pass a particular type.

CGCXXABI::RecordArgABI getRecordArgABI(const RecordType *RT, CGCXXABI &CXXABI)

std::unique_ptr< TargetCodeGenInfo > createX86_64TargetCodeGenInfo(CodeGenModule &CGM, X86AVXABILevel AVXLevel)

bool classifyReturnType(const CGCXXABI &CXXABI, CGFunctionInfo &FI, const ABIInfo &Info)

std::unique_ptr< TargetCodeGenInfo > createWinX86_32TargetCodeGenInfo(CodeGenModule &CGM, bool DarwinVectorABI, bool Win32StructABI, unsigned NumRegisterParameters)

bool isRecordWithSIMDVectorType(ASTContext &Context, QualType Ty)

RValue emitVoidPtrVAArg(CodeGenFunction &CGF, Address VAListAddr, QualType ValueTy, bool IsIndirect, TypeInfoChars ValueInfo, CharUnits SlotSizeAndAlign, bool AllowHigherAlign, AggValueSlot Slot, bool ForceRightAdjust=false)

Emit va_arg for a platform using the common void* representation, where arguments are simply emitted ...

Address emitMergePHI(CodeGenFunction &CGF, Address Addr1, llvm::BasicBlock *Block1, Address Addr2, llvm::BasicBlock *Block2, const llvm::Twine &Name="")

X86AVXABILevel

The AVX ABI level for X86 targets.

bool isEmptyField(ASTContext &Context, const FieldDecl *FD, bool AllowArrays, bool AsIfNoUniqueAddr=false)

isEmptyField - Return true iff a the field is "empty", that is it is an unnamed bit-field or an (arra...

llvm::Value * emitRoundPointerUpToAlignment(CodeGenFunction &CGF, llvm::Value *Ptr, CharUnits Align)

bool isAggregateTypeForABI(QualType T)

const Type * isSingleElementStruct(QualType T, ASTContext &Context)

isSingleElementStruct - Determine if a structure is a "single element struct", i.e.

void AssignToArrayRange(CodeGen::CGBuilderTy &Builder, llvm::Value *Array, llvm::Value *Value, unsigned FirstIndex, unsigned LastIndex)

QualType useFirstFieldIfTransparentUnion(QualType Ty)

Pass transparent unions as if they were the type of the first element.

std::unique_ptr< TargetCodeGenInfo > createX86_32TargetCodeGenInfo(CodeGenModule &CGM, bool DarwinVectorABI, bool Win32StructABI, unsigned NumRegisterParameters, bool SoftFloatABI)

bool isEmptyRecord(ASTContext &Context, QualType T, bool AllowArrays, bool AsIfNoUniqueAddr=false)

isEmptyRecord - Return true iff a structure contains only empty fields.

std::unique_ptr< TargetCodeGenInfo > createWinX86_64TargetCodeGenInfo(CodeGenModule &CGM, X86AVXABILevel AVXLevel)

bool isSIMDVectorType(ASTContext &Context, QualType Ty)

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

bool Ret(InterpState &S, CodePtr &PC)

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

@ Result

The result type of a method or function.

const FunctionProtoType * T

CallingConv

CallingConv - Specifies the calling convention that a function uses.

@ Class

The "class" keyword introduces the elaborated-type-specifier.

llvm::IntegerType * Int64Ty

llvm::IntegerType * Int8Ty

i8, i16, i32, and i64

llvm::IntegerType * Int32Ty

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