10#include "TargetInfo.h"
21 SlotSize, SlotSize,
true);
29 2 * SlotSize - EltSize);
44 llvm::Value *
Address,
bool Is64Bit,
51 llvm::IntegerType *i8 = CGF.
Int8Ty;
52 llvm::Value *Four8 = llvm::ConstantInt::get(i8, 4);
53 llvm::Value *Eight8 = llvm::ConstantInt::get(i8, 8);
54 llvm::Value *Sixteen8 = llvm::ConstantInt::get(i8, 16);
107class AIXABIInfo :
public ABIInfo {
109 const unsigned PtrByteSize;
114 :
ABIInfo(CGT), Is64Bit(Is64Bit), PtrByteSize(Is64Bit ? 8 : 4) {}
116 bool isPromotableTypeForABI(
QualType Ty)
const;
145 llvm::Value *
Address)
const override;
154bool AIXABIInfo::isPromotableTypeForABI(
QualType Ty)
const {
157 Ty = EnumTy->getDecl()->getIntegerType();
160 if (getContext().isPromotableIntegerType(Ty))
170 switch (BT->getKind()) {
171 case BuiltinType::Int:
172 case BuiltinType::UInt:
192 return getNaturalAlignIndirect(RetTy);
213 CharUnits CCAlign = getParamTypeAlignment(Ty);
214 CharUnits TyAlign = getContext().getTypeAlignInChars(Ty);
227 Ty = CTy->getElementType();
242 auto TypeInfo = getContext().getTypeInfoInChars(Ty);
256 if (EltSize < SlotSize)
261 SlotSize,
true, Slot);
264bool AIXTargetCodeGenInfo::initDwarfEHRegSizeTable(
269void AIXTargetCodeGenInfo::setTargetAttributes(
271 if (!isa<llvm::GlobalVariable>(GV))
274 auto *GVar = cast<llvm::GlobalVariable>(GV);
275 auto GVId = GV->getName();
278 bool UserSpecifiedTOC =
282 if (UserSpecifiedTOC ||
285 const unsigned long PointerSize =
286 GV->getParent()->getDataLayout().getPointerSizeInBits() / 8;
287 auto *VarD = dyn_cast<VarDecl>(
D);
288 assert(VarD &&
"Invalid declaration of global variable.");
292 const auto *Ty = VarD->getType().getTypePtr();
296 bool EmitDiagnostic = UserSpecifiedTOC && GV->hasExternalLinkage();
297 auto reportUnsupportedWarning = [&](
bool ShouldEmitWarning, StringRef Msg) {
298 if (ShouldEmitWarning)
303 reportUnsupportedWarning(EmitDiagnostic,
"of incomplete type");
305 reportUnsupportedWarning(EmitDiagnostic,
306 "it contains a flexible array member");
308 reportUnsupportedWarning(EmitDiagnostic,
"of thread local storage");
310 reportUnsupportedWarning(EmitDiagnostic,
311 "variable is larger than a pointer");
312 else if (PointerSize < Alignment)
313 reportUnsupportedWarning(EmitDiagnostic,
314 "variable is aligned wider than a pointer");
316 reportUnsupportedWarning(EmitDiagnostic,
317 "variable has a section attribute");
318 else if (GV->hasExternalLinkage() ||
320 GVar->addAttribute(
"toc-data");
329 bool IsRetSmallStructInRegABI;
335 bool RetSmallStructInRegABI)
337 IsRetSmallStructInRegABI(RetSmallStructInRegABI) {}
354 PPC32TargetCodeGenInfo(
CodeGenTypes &CGT,
bool SoftFloatABI,
355 bool RetSmallStructInRegABI)
357 CGT, SoftFloatABI, RetSmallStructInRegABI)) {}
359 static bool isStructReturnInRegABI(
const llvm::Triple &Triple,
368 llvm::Value *
Address)
const override;
375 Ty = CTy->getElementType();
383 const Type *AlignTy =
nullptr;
386 if ((EltType->isVectorType() && getContext().getTypeSize(EltType) == 128) ||
401 (Size = getContext().getTypeSize(RetTy)) <= 64) {
416 llvm::Type *CoerceTy = llvm::Type::getIntNTy(getVMContext(), Size);
428 if (getTarget().getTriple().isOSDarwin()) {
429 auto TI = getContext().getTypeInfoInChars(Ty);
430 TI.Align = getParamTypeAlignment(Ty);
438 const unsigned OverflowLimit = 8;
453 bool isI64 = Ty->
isIntegerType() && getContext().getTypeSize(Ty) == 64;
455 bool isF64 = Ty->
isFloatingType() && getContext().getTypeSize(Ty) == 64;
465 if (isInt || IsSoftFloatABI) {
466 NumRegsAddr = Builder.CreateStructGEP(VAList, 0,
"gpr");
468 NumRegsAddr = Builder.CreateStructGEP(VAList, 1,
"fpr");
471 llvm::Value *NumRegs = Builder.CreateLoad(NumRegsAddr,
"numUsedRegs");
474 if (isI64 || (isF64 && IsSoftFloatABI)) {
475 NumRegs = Builder.CreateAdd(NumRegs, Builder.getInt8(1));
476 NumRegs = Builder.CreateAnd(NumRegs, Builder.getInt8((uint8_t) ~1U));
480 Builder.CreateICmpULT(NumRegs, Builder.getInt8(OverflowLimit),
"cond");
486 Builder.CreateCondBr(CC, UsingRegs, UsingOverflow);
488 llvm::Type *DirectTy = CGF.
ConvertType(Ty), *ElementTy = DirectTy;
497 Address RegSaveAreaPtr = Builder.CreateStructGEP(VAList, 4);
498 RegAddr =
Address(Builder.CreateLoad(RegSaveAreaPtr), CGF.
Int8Ty,
503 if (!(isInt || IsSoftFloatABI)) {
504 RegAddr = Builder.CreateConstInBoundsByteGEP(RegAddr,
511 llvm::Value *RegOffset =
512 Builder.CreateMul(NumRegs, Builder.getInt8(RegSize.
getQuantity()));
513 RegAddr =
Address(Builder.CreateInBoundsGEP(
520 Builder.CreateAdd(NumRegs,
521 Builder.getInt8((isI64 || (isF64 && IsSoftFloatABI)) ? 2 : 1));
522 Builder.CreateStore(NumRegs, NumRegsAddr);
532 Builder.CreateStore(Builder.getInt8(OverflowLimit), NumRegsAddr);
545 Address OverflowAreaAddr = Builder.CreateStructGEP(VAList, 3);
547 Address(Builder.CreateLoad(OverflowAreaAddr,
"argp.cur"), CGF.
Int8Ty,
551 if (Align > OverflowAreaAlign) {
560 OverflowArea = Builder.CreateConstInBoundsByteGEP(OverflowArea, Size);
561 Builder.CreateStore(OverflowArea.
emitRawPointer(CGF), OverflowAreaAddr);
573 Result =
Address(Builder.CreateLoad(Result,
"aggr"), ElementTy,
574 getContext().getTypeAlignInChars(Ty));
580bool PPC32TargetCodeGenInfo::isStructReturnInRegABI(
582 assert(Triple.isPPC32());
584 switch (Opts.getStructReturnConvention()) {
593 if (Triple.isOSBinFormatELF() && !Triple.isOSLinux())
611class PPC64_SVR4_ABIInfo :
public ABIInfo {
612 static const unsigned GPRBits = 64;
621 bool isPromotableTypeForABI(
QualType Ty)
const;
629 uint64_t Members)
const override;
668 std::make_unique<PPC64_SVR4_ABIInfo>(CGT,
Kind, SoftFloatABI)) {
670 std::make_unique<SwiftABIInfo>(CGT,
false);
679 llvm::Value *
Address)
const override;
681 const llvm::MapVector<GlobalDecl, StringRef>
682 &MangledDeclNames)
const override;
696 llvm::Value *
Address)
const override;
703PPC64_SVR4_ABIInfo::isPromotableTypeForABI(
QualType Ty)
const {
706 Ty = EnumTy->getDecl()->getIntegerType();
709 if (isPromotableIntegerTypeForABI(Ty))
716 case BuiltinType::Int:
717 case BuiltinType::UInt:
724 if (EIT->getNumBits() < 64)
735 Ty = CTy->getElementType();
737 auto FloatUsesVector = [
this](
QualType Ty){
739 Ty) == &llvm::APFloat::IEEEquad();
746 }
else if (FloatUsesVector(Ty)) {
755 const Type *AlignAsType =
nullptr;
759 if ((EltType->
isVectorType() && getContext().getTypeSize(EltType) == 128) ||
761 AlignAsType = EltType;
767 if (!AlignAsType && Kind == PPC64_SVR4_ABIKind::ELFv2 &&
774 FloatUsesVector(
QualType(AlignAsType, 0));
787bool PPC64_SVR4_ABIInfo::isHomogeneousAggregateBaseType(
QualType Ty)
const {
791 if (BT->
getKind() == BuiltinType::Float ||
792 BT->
getKind() == BuiltinType::Double ||
793 BT->
getKind() == BuiltinType::LongDouble ||
794 BT->
getKind() == BuiltinType::Ibm128 ||
795 (getContext().getTargetInfo().hasFloat128Type() &&
796 (BT->
getKind() == BuiltinType::Float128))) {
803 if (getContext().getTypeSize(VT) == 128)
809bool PPC64_SVR4_ABIInfo::isHomogeneousAggregateSmallEnough(
810 const Type *
Base, uint64_t Members)
const {
814 ((getContext().getTargetInfo().hasFloat128Type() &&
815 Base->isFloat128Type()) ||
816 Base->isVectorType()) ? 1
817 : (getContext().getTypeSize(
Base) + 63) / 64;
820 return Members * NumRegs <= 8;
824PPC64_SVR4_ABIInfo::classifyArgumentType(
QualType Ty)
const {
835 return getNaturalAlignIndirect(Ty,
false);
836 else if (Size < 128) {
837 llvm::Type *CoerceTy = llvm::IntegerType::get(getVMContext(), Size);
843 if (EIT->getNumBits() > 128)
844 return getNaturalAlignIndirect(Ty,
true);
850 uint64_t ABIAlign = getParamTypeAlignment(Ty).getQuantity();
856 if (Kind == PPC64_SVR4_ABIKind::ELFv2 &&
857 isHomogeneousAggregate(Ty,
Base, Members)) {
858 llvm::Type *BaseTy = CGT.ConvertType(
QualType(
Base, 0));
859 llvm::Type *CoerceTy = llvm::ArrayType::get(BaseTy, Members);
867 uint64_t Bits = getContext().getTypeSize(Ty);
868 if (Bits > 0 && Bits <= 8 * GPRBits) {
869 llvm::Type *CoerceTy;
875 llvm::IntegerType::get(getVMContext(), llvm::alignTo(Bits, 8));
880 uint64_t NumRegs = llvm::alignTo(Bits, RegBits) / RegBits;
881 llvm::Type *RegTy = llvm::IntegerType::get(getVMContext(), RegBits);
882 CoerceTy = llvm::ArrayType::get(RegTy, NumRegs);
899PPC64_SVR4_ABIInfo::classifyReturnType(
QualType RetTy)
const {
911 return getNaturalAlignIndirect(RetTy);
912 else if (Size < 128) {
913 llvm::Type *CoerceTy = llvm::IntegerType::get(getVMContext(), Size);
919 if (EIT->getNumBits() > 128)
920 return getNaturalAlignIndirect(RetTy,
false);
926 if (Kind == PPC64_SVR4_ABIKind::ELFv2 &&
927 isHomogeneousAggregate(RetTy,
Base, Members)) {
928 llvm::Type *BaseTy = CGT.ConvertType(
QualType(
Base, 0));
929 llvm::Type *CoerceTy = llvm::ArrayType::get(BaseTy, Members);
934 uint64_t Bits = getContext().getTypeSize(RetTy);
935 if (Kind == PPC64_SVR4_ABIKind::ELFv2 && Bits <= 2 * GPRBits) {
939 llvm::Type *CoerceTy;
940 if (Bits > GPRBits) {
941 CoerceTy = llvm::IntegerType::get(getVMContext(), GPRBits);
942 CoerceTy = llvm::StructType::get(CoerceTy, CoerceTy);
945 llvm::IntegerType::get(getVMContext(), llvm::alignTo(Bits, 8));
950 return getNaturalAlignIndirect(RetTy);
960 auto TypeInfo = getContext().getTypeInfoInChars(Ty);
973 if (EltSize < SlotSize)
991 SlotSize,
true, Slot,
996PPC64_SVR4_TargetCodeGenInfo::initDwarfEHRegSizeTable(
1003void PPC64_SVR4_TargetCodeGenInfo::emitTargetMetadata(
1005 const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames)
const {
1009 if (flt == &llvm::APFloat::PPCDoubleDouble())
1010 CGM.
getModule().addModuleFlag(llvm::Module::Error,
"float-abi",
1011 llvm::MDString::get(Ctx,
"doubledouble"));
1012 else if (flt == &llvm::APFloat::IEEEquad())
1013 CGM.
getModule().addModuleFlag(llvm::Module::Error,
"float-abi",
1014 llvm::MDString::get(Ctx,
"ieeequad"));
1015 else if (flt == &llvm::APFloat::IEEEdouble())
1016 CGM.
getModule().addModuleFlag(llvm::Module::Error,
"float-abi",
1017 llvm::MDString::get(Ctx,
"ieeedouble"));
1028std::unique_ptr<TargetCodeGenInfo>
1030 return std::make_unique<AIXTargetCodeGenInfo>(CGM.
getTypes(), Is64Bit);
1033std::unique_ptr<TargetCodeGenInfo>
1035 bool RetSmallStructInRegABI = PPC32TargetCodeGenInfo::isStructReturnInRegABI(
1037 return std::make_unique<PPC32TargetCodeGenInfo>(CGM.
getTypes(), SoftFloatABI,
1038 RetSmallStructInRegABI);
1041std::unique_ptr<TargetCodeGenInfo>
1043 return std::make_unique<PPC64TargetCodeGenInfo>(CGM.
getTypes());
1048 return std::make_unique<PPC64_SVR4_TargetCodeGenInfo>(CGM.
getTypes(), Kind,
static RValue complexTempStructure(CodeGenFunction &CGF, Address VAListAddr, QualType Ty, CharUnits SlotSize, CharUnits EltSize, const ComplexType *CTy)
static bool PPC_initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF, llvm::Value *Address, bool Is64Bit, bool IsAIX)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
TypeInfoChars getTypeInfoInChars(const Type *T) const
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
A fixed int type of a specified bitwidth.
This class is used for builtin types like 'int'.
bool isFloatingPoint() const
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
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.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
std::vector< std::string > TocDataVarsUserSpecified
List of global variables explicitly specified by the user as toc-data.
std::vector< std::string > NoTocDataVars
List of global variables that over-ride the toc-data default.
ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to ...
static ABIArgInfo getIgnore()
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)
static ABIArgInfo getExtend(QualType Ty, llvm::Type *T=nullptr)
static ABIArgInfo getDirectInReg(llvm::Type *T=nullptr)
ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions.
CodeGen::CGCXXABI & getCXXABI() const
virtual bool isHomogeneousAggregateBaseType(QualType Ty) const
virtual bool isHomogeneousAggregateSmallEnough(const Type *Base, uint64_t Members) 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 * 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.
Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset, const llvm::Twine &Name="")
Given a pointer to i8, adjust it by a given constant offset.
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
RecordArgABI
Specify how one should pass an argument of a record type.
@ RAA_DirectInMemory
Pass it on the stack using its defined layout.
CGFunctionInfo - Class to encapsulate the information about a function definition.
ABIArgInfo & getReturnInfo()
CanQualType getReturnType() const
MutableArrayRef< ArgInfo > arguments()
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)
void EmitBranch(llvm::BasicBlock *Block)
EmitBranch - Emit a branch to the specified basic block from the current insert block,...
ASTContext & getContext() const
llvm::Type * ConvertType(QualType T)
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
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.
llvm::Module & getModule() const
DiagnosticsEngine & getDiags() const
CodeGenTypes & getTypes()
const TargetInfo & getTarget() const
const llvm::DataLayout & getDataLayout() const
const llvm::Triple & getTriple() const
const CodeGenOptions & getCodeGenOpts() const
llvm::LLVMContext & getLLVMContext()
This class organizes the cross-module state that is used while lowering AST types to LLVM types.
bool isLongDoubleReferenced() const
DefaultABIInfo - The default implementation for ABI specific details.
ABIArgInfo classifyArgumentType(QualType RetTy) const
RValue EmitVAArg(CodeGenFunction &CGF, Address VAListAddr, QualType Ty, AggValueSlot Slot) const override
EmitVAArg - Emit the target dependent code to load a value of.
ABIArgInfo classifyReturnType(QualType RetTy) const
void computeInfo(CGFunctionInfo &FI) const override
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
static RValue getAggregate(Address addr, bool isVolatile=false)
Convert an Address to an RValue.
static RValue getComplex(llvm::Value *V1, llvm::Value *V2)
TargetCodeGenInfo - This class organizes various target-specific codegeneration issues,...
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...
virtual int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const
Determines the DWARF register number for the stack pointer, for exception-handling purposes.
virtual void emitTargetMetadata(CodeGen::CodeGenModule &CGM, const llvm::MapVector< GlobalDecl, StringRef > &MangledDeclNames) const
emitTargetMetadata - Provides a convenient hook to handle extra target-specific metadata for the give...
Complex values, per C99 6.2.5p11.
QualType getElementType() const
Decl - This represents one declaration (or definition), e.g.
ASTContext & getASTContext() const LLVM_READONLY
SourceLocation getLocation() const
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
A (possibly-)qualified type.
Represents a struct/union/class.
bool hasFlexibleArrayMember() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
const llvm::fltSemantics & getLongDoubleFormat() const
The base class of the type hierarchy.
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
bool isAnyComplexType() const
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isVectorType() const
bool isRealFloatingType() const
Floating point categories.
bool isFloatingType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
@ TLS_None
Not a TLS variable.
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)
bool classifyReturnType(const CGCXXABI &CXXABI, CGFunctionInfo &FI, const ABIInfo &Info)
std::unique_ptr< TargetCodeGenInfo > createPPC64_SVR4_TargetCodeGenInfo(CodeGenModule &CGM, PPC64_SVR4_ABIKind Kind, bool SoftFloatABI)
Address emitVoidPtrDirectVAArg(CodeGenFunction &CGF, Address VAListAddr, llvm::Type *DirectTy, CharUnits DirectSize, CharUnits DirectAlign, CharUnits SlotSize, bool AllowHigherAlign, bool ForceRightAdjust=false)
Emit va_arg for a platform using the common void* representation, where arguments are simply emitted ...
std::unique_ptr< TargetCodeGenInfo > createAIXTargetCodeGenInfo(CodeGenModule &CGM, bool Is64Bit)
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="")
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 > createPPC32TargetCodeGenInfo(CodeGenModule &CGM, bool SoftFloatABI)
std::unique_ptr< TargetCodeGenInfo > createPPC64TargetCodeGenInfo(CodeGenModule &CGM)
The JSON file list parser is used to communicate input to InstallAPI.
const FunctionProtoType * T
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
CharUnits getPointerSize() const
llvm::PointerType * UnqualPtrTy