This is an archive of the discontinued LLVM Phabricator instance.

Differential D59246

SVE opaque type for C intrinsics demo (LLVM side)
AbandonedPublic

Authored by huntergr on Mar 12 2019, 4:26 AM.

Details

Reviewers
deadalnix
Summary

This code is just to aid discussion on the mailing list, it isn't suitable for inclusion at present.

Diff Detail

Revision Contents

PathSize
docs/
7 lines
include/
llvm-c/
2 lines
llvm/
Bitcode/
5 lines
CodeGen/
10 lines
IR/
3 lines
4 lines
6 lines
17 lines
25 lines
Support/
16 lines
lib/
AsmParser/
2 lines
Bitcode/
Reader/
6 lines
Writer/
2 lines
CodeGen/
SelectionDAG/
1 line
61 lines
IR/
2 lines
4 lines
4 lines
16 lines
2 lines
2 lines
4 lines
Target/
AArch64/
14 lines
9 lines
28 lines
8 lines
11 lines
Hexagon/
2 lines
test/
Instrumentation/
EfficiencySanitizer/
70 lines
12 lines
70 lines
TableGen/
2 lines
tools/
llvm-stress/
2 lines
utils/
TableGen/
2 lines
6 lines

Diff 190236

docs/BitCodeFormat.rst

Show First 20 Lines • Show All 1,288 Lines • ▼ Show 20 Lines
* *vararg*: Non-zero if the type represents a varargs function * *vararg*: Non-zero if the type represents a varargs function
* *retty*: The type index of the function's return type * *retty*: The type index of the function's return type
* *paramty*: Zero or more type indices representing the parameter types of the * *paramty*: Zero or more type indices representing the parameter types of the
function function
TYPE_CODE_ARM_SVE Record
^^^^^^^^^^^^^^^^^^^^^^^^
``[ARM_SVE]``
The ``ARM_SVE`` record (code 23) adds an ``arm_sve`` type to the type table
.. _CONSTANTS_BLOCK: .. _CONSTANTS_BLOCK:
CONSTANTS_BLOCK Contents CONSTANTS_BLOCK Contents
------------------------ ------------------------
The ``CONSTANTS_BLOCK`` block (id 11) ... The ``CONSTANTS_BLOCK`` block (id 11) ...
.. _FUNCTION_BLOCK: .. _FUNCTION_BLOCK:
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

include/llvm-c/Core.h

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Linestypedef enum {
LLVMIntegerTypeKind, /**< Arbitrary bit width integers */ LLVMIntegerTypeKind, /**< Arbitrary bit width integers */
LLVMFunctionTypeKind, /**< Functions */ LLVMFunctionTypeKind, /**< Functions */
LLVMStructTypeKind, /**< Structures */ LLVMStructTypeKind, /**< Structures */
LLVMArrayTypeKind, /**< Arrays */ LLVMArrayTypeKind, /**< Arrays */
LLVMPointerTypeKind, /**< Pointers */ LLVMPointerTypeKind, /**< Pointers */
LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */ LLVMVectorTypeKind, /**< SIMD 'packed' format, or other vector type */
LLVMMetadataTypeKind, /**< Metadata */ LLVMMetadataTypeKind, /**< Metadata */
LLVMX86_MMXTypeKind, /**< X86 MMX */ LLVMX86_MMXTypeKind, /**< X86 MMX */
LLVMARM_SVETypeKind, /**< ARM SVE Data */
LLVMARM_SVEPredTypeKind, /**< ARM SVE Predicate */
LLVMTokenTypeKind /**< Tokens */ LLVMTokenTypeKind /**< Tokens */
} LLVMTypeKind; } LLVMTypeKind;
typedef enum { typedef enum {
LLVMExternalLinkage, /**< Externally visible function */ LLVMExternalLinkage, /**< Externally visible function */
LLVMAvailableExternallyLinkage, LLVMAvailableExternallyLinkage,
LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/ LLVMLinkOnceAnyLinkage, /**< Keep one copy of function when linking (inline)*/
LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something LLVMLinkOnceODRLinkage, /**< Same, but only replaced by something
▲ Show 20 Lines • Show All 3,834 Lines • Show Last 20 Lines

include/llvm/Bitcode/LLVMBitCodes.h

Show First 20 Lines • Show All 160 Lines • ▼ Show 20 Linesenum TypeCodes {
TYPE_CODE_X86_MMX = 17, // X86 MMX TYPE_CODE_X86_MMX = 17, // X86 MMX
TYPE_CODE_STRUCT_ANON = 18, // STRUCT_ANON: [ispacked, eltty x N] TYPE_CODE_STRUCT_ANON = 18, // STRUCT_ANON: [ispacked, eltty x N]
TYPE_CODE_STRUCT_NAME = 19, // STRUCT_NAME: [strchr x N] TYPE_CODE_STRUCT_NAME = 19, // STRUCT_NAME: [strchr x N]
TYPE_CODE_STRUCT_NAMED = 20, // STRUCT_NAMED: [ispacked, eltty x N] TYPE_CODE_STRUCT_NAMED = 20, // STRUCT_NAMED: [ispacked, eltty x N]
TYPE_CODE_FUNCTION = 21, // FUNCTION: [vararg, retty, paramty x N] TYPE_CODE_FUNCTION = 21, // FUNCTION: [vararg, retty, paramty x N]
TYPE_CODE_TOKEN = 22 // TOKEN TYPE_CODE_TOKEN = 22, // TOKEN
TYPE_CODE_ARM_SVE = 23, // ARM SVE
TYPE_CODE_ARM_SVE_PRED = 24
}; };
enum OperandBundleTagCode { enum OperandBundleTagCode {
OPERAND_BUNDLE_TAG = 1, // TAG: [strchr x N] OPERAND_BUNDLE_TAG = 1, // TAG: [strchr x N]
}; };
enum SyncScopeNameCode { enum SyncScopeNameCode {
SYNC_SCOPE_NAME = 1, SYNC_SCOPE_NAME = 1,
▲ Show 20 Lines • Show All 452 Lines • Show Last 20 Lines

include/llvm/CodeGen/ValueTypes.td

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Lines
def nxv8f32 : ValueType<256, 103>; // n x 8 x f32 vector value def nxv8f32 : ValueType<256, 103>; // n x 8 x f32 vector value
def nxv16f32 : ValueType<512, 104>; // n x 16 x f32 vector value def nxv16f32 : ValueType<512, 104>; // n x 16 x f32 vector value
def nxv1f64 : ValueType<64, 105>; // n x 1 x f64 vector value def nxv1f64 : ValueType<64, 105>; // n x 1 x f64 vector value
def nxv2f64 : ValueType<128, 106>; // n x 2 x f64 vector value def nxv2f64 : ValueType<128, 106>; // n x 2 x f64 vector value
def nxv4f64 : ValueType<256, 107>; // n x 4 x f64 vector value def nxv4f64 : ValueType<256, 107>; // n x 4 x f64 vector value
def nxv8f64 : ValueType<512, 108>; // n x 8 x f64 vector value def nxv8f64 : ValueType<512, 108>; // n x 8 x f64 vector value
def x86mmx : ValueType<64 , 109>; // X86 MMX value def x86mmx : ValueType<64 , 109>; // X86 MMX value
def FlagVT : ValueType<0 , 110>; // Pre-RA sched glue def armsve : ValueType<0 , 110>; // ARM SVE data value
def isVoid : ValueType<0 , 111>; // Produces no value def armsvepred : ValueType<0, 111>; // ARM SVE predicate value
def untyped: ValueType<8 , 112>; // Produces an untyped value def FlagVT : ValueType<0 , 112>; // Pre-RA sched glue
def ExceptRef: ValueType<0, 113>; // WebAssembly's except_ref type def isVoid : ValueType<0 , 113>; // Produces no value
def untyped: ValueType<8 , 114>; // Produces an untyped value
def ExceptRef: ValueType<0, 115>; // WebAssembly's except_ref type
def token : ValueType<0 , 248>; // TokenTy def token : ValueType<0 , 248>; // TokenTy
def MetadataVT: ValueType<0, 249>; // Metadata def MetadataVT: ValueType<0, 249>; // Metadata
// Pseudo valuetype mapped to the current pointer size to any address space. // Pseudo valuetype mapped to the current pointer size to any address space.
// Should only be used in TableGen. // Should only be used in TableGen.
def iPTRAny : ValueType<0, 250>; def iPTRAny : ValueType<0, 250>;
// Pseudo valuetype to represent "vector of any size" // Pseudo valuetype to represent "vector of any size"
Show All 24 Lines

include/llvm/IR/DataLayout.h

Show First 20 Lines • Show All 592 Lines • ▼ Show 20 Lines case Type::X86_MMXTyID:
return 64; return 64;
case Type::PPC_FP128TyID: case Type::PPC_FP128TyID:
case Type::FP128TyID: case Type::FP128TyID:
return 128; return 128;
// In memory objects this is always aligned to a higher boundary, but // In memory objects this is always aligned to a higher boundary, but
// only 80 bits contain information. // only 80 bits contain information.
case Type::X86_FP80TyID: case Type::X86_FP80TyID:
return 80; return 80;
case Type::Arm_SVETyID:
case Type::Arm_SVEPredTyID:
return 0;
case Type::VectorTyID: { case Type::VectorTyID: {
VectorType *VTy = cast<VectorType>(Ty); VectorType *VTy = cast<VectorType>(Ty);
return VTy->getNumElements() * getTypeSizeInBits(VTy->getElementType()); return VTy->getNumElements() * getTypeSizeInBits(VTy->getElementType());
} }
default: default:
llvm_unreachable("DataLayout::getTypeSizeInBits(): Unsupported type"); llvm_unreachable("DataLayout::getTypeSizeInBits(): Unsupported type");
} }
} }
} // end namespace llvm } // end namespace llvm
#endif // LLVM_IR_DATALAYOUT_H #endif // LLVM_IR_DATALAYOUT_H

include/llvm/IR/Intrinsics.h

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines#undef GET_INTRINSIC_ENUM_VALUES
/// Map a MS builtin name to an intrinsic ID. /// Map a MS builtin name to an intrinsic ID.
ID getIntrinsicForMSBuiltin(const char *Prefix, StringRef BuiltinName); ID getIntrinsicForMSBuiltin(const char *Prefix, StringRef BuiltinName);
/// This is a type descriptor which explains the type requirements of an /// This is a type descriptor which explains the type requirements of an
/// intrinsic. This is returned by getIntrinsicInfoTableEntries. /// intrinsic. This is returned by getIntrinsicInfoTableEntries.
struct IITDescriptor { struct IITDescriptor {
enum IITDescriptorKind { enum IITDescriptorKind {
Void, VarArg, MMX, Token, Metadata, Half, Float, Double, Quad, Void, VarArg, MMX, SVE, SVEPred, Token, Metadata, Half, Float, Double,
Integer, Vector, Pointer, Struct, Quad, Integer, Vector, Pointer, Struct,
Argument, ExtendArgument, TruncArgument, HalfVecArgument, Argument, ExtendArgument, TruncArgument, HalfVecArgument,
SameVecWidthArgument, PtrToArgument, PtrToElt, VecOfAnyPtrsToElt SameVecWidthArgument, PtrToArgument, PtrToElt, VecOfAnyPtrsToElt
} Kind; } Kind;
union { union {
unsigned Integer_Width; unsigned Integer_Width;
unsigned Float_Width; unsigned Float_Width;
unsigned Vector_Width; unsigned Vector_Width;
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

include/llvm/IR/Intrinsics.td

Show First 20 Lines • Show All 196 Lines • ▼ Show 20 Lines
def llvm_empty_ty : LLVMType<OtherVT>; // { } def llvm_empty_ty : LLVMType<OtherVT>; // { }
def llvm_descriptor_ty : LLVMPointerType<llvm_empty_ty>; // { }* def llvm_descriptor_ty : LLVMPointerType<llvm_empty_ty>; // { }*
def llvm_metadata_ty : LLVMType<MetadataVT>; // !{...} def llvm_metadata_ty : LLVMType<MetadataVT>; // !{...}
def llvm_token_ty : LLVMType<token>; // token def llvm_token_ty : LLVMType<token>; // token
def llvm_x86mmx_ty : LLVMType<x86mmx>; def llvm_x86mmx_ty : LLVMType<x86mmx>;
def llvm_ptrx86mmx_ty : LLVMPointerType<llvm_x86mmx_ty>; // <1 x i64>* def llvm_ptrx86mmx_ty : LLVMPointerType<llvm_x86mmx_ty>; // <1 x i64>*
def llvm_armsve_ty : LLVMType<armsve>;
def llvm_ptrarmsve_ty : LLVMPointerType<llvm_armsve_ty>;
def llvm_armsvepred_ty : LLVMType<armsvepred>;
def llvmptrarmsvepred_ty : LLVMPointerType<llvm_armsvepred_ty>;
def llvm_v2i1_ty : LLVMType<v2i1>; // 2 x i1 def llvm_v2i1_ty : LLVMType<v2i1>; // 2 x i1
def llvm_v4i1_ty : LLVMType<v4i1>; // 4 x i1 def llvm_v4i1_ty : LLVMType<v4i1>; // 4 x i1
def llvm_v8i1_ty : LLVMType<v8i1>; // 8 x i1 def llvm_v8i1_ty : LLVMType<v8i1>; // 8 x i1
def llvm_v16i1_ty : LLVMType<v16i1>; // 16 x i1 def llvm_v16i1_ty : LLVMType<v16i1>; // 16 x i1
def llvm_v32i1_ty : LLVMType<v32i1>; // 32 x i1 def llvm_v32i1_ty : LLVMType<v32i1>; // 32 x i1
def llvm_v64i1_ty : LLVMType<v64i1>; // 64 x i1 def llvm_v64i1_ty : LLVMType<v64i1>; // 64 x i1
def llvm_v512i1_ty : LLVMType<v512i1>; // 512 x i1 def llvm_v512i1_ty : LLVMType<v512i1>; // 512 x i1
def llvm_v1024i1_ty : LLVMType<v1024i1>; //1024 x i1 def llvm_v1024i1_ty : LLVMType<v1024i1>; //1024 x i1
▲ Show 20 Lines • Show All 964 Lines • Show Last 20 Lines

include/llvm/IR/IntrinsicsAArch64.td

Show First 20 Lines • Show All 677 Lines • ▼ Show 20 Linesdef int_aarch64_crc32w : Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty],
[IntrNoMem]>; [IntrNoMem]>;
def int_aarch64_crc32cw : Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty], def int_aarch64_crc32cw : Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty],
[IntrNoMem]>; [IntrNoMem]>;
def int_aarch64_crc32x : Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i64_ty], def int_aarch64_crc32x : Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i64_ty],
[IntrNoMem]>; [IntrNoMem]>;
def int_aarch64_crc32cx : Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i64_ty], def int_aarch64_crc32cx : Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i64_ty],
[IntrNoMem]>; [IntrNoMem]>;
} }
//===----------------------------------------------------------------------===//
// SVE ACLE
let TargetPrefix = "aarch64" in {
def int_aarch64_sve_ptrue_P2_i : Intrinsic<[llvm_armsvepred_ty], [llvm_i32_ty],
[IntrNoMem]>;
def int_aarch64_sve_reinterpret_bool_b : Intrinsic<[llvm_armsvepred_ty],
[llvm_armsvepred_ty], [IntrNoMem]>;
def int_aarch64_sve_reinterpret_bool_d : Intrinsic<[llvm_armsve_ty],
[llvm_armsve_ty], [IntrNoMem]>;
def int_aarch64_sve_fdup_D2_d : Intrinsic<[llvm_armsve_ty], [llvm_anyfloat_ty],
[IntrNoMem]>;
def int_aarch64_sve_fmul_D2_P2D2D2 : Intrinsic<[llvm_armsve_ty],
[llvm_armsvepred_ty, llvm_armsve_ty, llvm_armsve_ty], [IntrNoMem]>;
}
No newline at end of file

include/llvm/IR/Type.h

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines enum TypeID {
FloatTyID, ///< 2: 32-bit floating point type FloatTyID, ///< 2: 32-bit floating point type
DoubleTyID, ///< 3: 64-bit floating point type DoubleTyID, ///< 3: 64-bit floating point type
X86_FP80TyID, ///< 4: 80-bit floating point type (X87) X86_FP80TyID, ///< 4: 80-bit floating point type (X87)
FP128TyID, ///< 5: 128-bit floating point type (112-bit mantissa) FP128TyID, ///< 5: 128-bit floating point type (112-bit mantissa)
PPC_FP128TyID, ///< 6: 128-bit floating point type (two 64-bits, PowerPC) PPC_FP128TyID, ///< 6: 128-bit floating point type (two 64-bits, PowerPC)
LabelTyID, ///< 7: Labels LabelTyID, ///< 7: Labels
MetadataTyID, ///< 8: Metadata MetadataTyID, ///< 8: Metadata
X86_MMXTyID, ///< 9: MMX vectors (64 bits, X86 specific) X86_MMXTyID, ///< 9: MMX vectors (64 bits, X86 specific)
TokenTyID, ///< 10: Tokens Arm_SVETyID, ///< 10: SVE data vectors (unsized, AArch64 specific)
Arm_SVEPredTyID, ///< 11: SVE predicate vectors (unsized, AArch64 specific)
TokenTyID, ///< 12: Tokens
// Derived types... see DerivedTypes.h file. // Derived types... see DerivedTypes.h file.
// Make sure FirstDerivedTyID stays up to date! // Make sure FirstDerivedTyID stays up to date!
IntegerTyID, ///< 11: Arbitrary bit width integers IntegerTyID, ///< 13: Arbitrary bit width integers
FunctionTyID, ///< 12: Functions FunctionTyID, ///< 14: Functions
StructTyID, ///< 13: Structures StructTyID, ///< 15: Structures
ArrayTyID, ///< 14: Arrays ArrayTyID, ///< 16: Arrays
PointerTyID, ///< 15: Pointers PointerTyID, ///< 17: Pointers
VectorTyID ///< 16: SIMD 'packed' format, or other vector type VectorTyID ///< 18: SIMD 'packed' format, or other vector type
}; };
private: private:
/// This refers to the LLVMContext in which this type was uniqued. /// This refers to the LLVMContext in which this type was uniqued.
LLVMContext &Context; LLVMContext &Context;
TypeID ID : 8; // The current base type of this type. TypeID ID : 8; // The current base type of this type.
unsigned SubclassData : 24; // Space for subclasses to store data. unsigned SubclassData : 24; // Space for subclasses to store data.
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines const fltSemantics &getFltSemantics() const {
case PPC_FP128TyID: return APFloat::PPCDoubleDouble(); case PPC_FP128TyID: return APFloat::PPCDoubleDouble();
default: llvm_unreachable("Invalid floating type"); default: llvm_unreachable("Invalid floating type");
} }
} }
/// Return true if this is X86 MMX. /// Return true if this is X86 MMX.
bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID; } bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID; }
/// Return true if this is Arm data SVE.
bool isArm_SVETy() const { return getTypeID() == Arm_SVETyID; }
/// Return true if this is Arm predicate SVE
bool isArm_SVEPredTy() const { return getTypeID() == Arm_SVEPredTyID; }
/// Return true if this is a FP type or a vector of FP. /// Return true if this is a FP type or a vector of FP.
bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); } bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); }
/// Return true if this is 'label'. /// Return true if this is 'label'.
bool isLabelTy() const { return getTypeID() == LabelTyID; } bool isLabelTy() const { return getTypeID() == LabelTyID; }
/// Return true if this is 'metadata'. /// Return true if this is 'metadata'.
bool isMetadataTy() const { return getTypeID() == MetadataTyID; } bool isMetadataTy() const { return getTypeID() == MetadataTyID; }
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Linespublic:
/// Return true if it makes sense to take the size of this type. To get the /// Return true if it makes sense to take the size of this type. To get the
/// actual size for a particular target, it is reasonable to use the /// actual size for a particular target, it is reasonable to use the
/// DataLayout subsystem to do this. /// DataLayout subsystem to do this.
bool isSized(SmallPtrSetImpl<Type*> *Visited = nullptr) const { bool isSized(SmallPtrSetImpl<Type*> *Visited = nullptr) const {
// If it's a primitive, it is always sized. // If it's a primitive, it is always sized.
if (getTypeID() == IntegerTyID || isFloatingPointTy() || if (getTypeID() == IntegerTyID || isFloatingPointTy() ||
getTypeID() == PointerTyID || getTypeID() == PointerTyID ||
getTypeID() == Arm_SVETyID || getTypeID() == Arm_SVEPredTyID ||
getTypeID() == X86_MMXTyID) getTypeID() == X86_MMXTyID)
return true; return true;
// If it is not something that can have a size (e.g. a function or label), // If it is not something that can have a size (e.g. a function or label),
// it doesn't have a size. // it doesn't have a size.
if (getTypeID() != StructTyID && getTypeID() != ArrayTyID && if (getTypeID() != StructTyID && getTypeID() != ArrayTyID &&
getTypeID() != VectorTyID) getTypeID() != VectorTyID)
return false; return false;
// Otherwise we have to try harder to decide. // Otherwise we have to try harder to decide.
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 Linespublic:
static Type *getHalfTy(LLVMContext &C); static Type *getHalfTy(LLVMContext &C);
static Type *getFloatTy(LLVMContext &C); static Type *getFloatTy(LLVMContext &C);
static Type *getDoubleTy(LLVMContext &C); static Type *getDoubleTy(LLVMContext &C);
static Type *getMetadataTy(LLVMContext &C); static Type *getMetadataTy(LLVMContext &C);
static Type *getX86_FP80Ty(LLVMContext &C); static Type *getX86_FP80Ty(LLVMContext &C);
static Type *getFP128Ty(LLVMContext &C); static Type *getFP128Ty(LLVMContext &C);
static Type *getPPC_FP128Ty(LLVMContext &C); static Type *getPPC_FP128Ty(LLVMContext &C);
static Type *getX86_MMXTy(LLVMContext &C); static Type *getX86_MMXTy(LLVMContext &C);
static Type *getArm_SVETy(LLVMContext &C);
static Type *getArm_SVEPredTy(LLVMContext &C);
static Type *getTokenTy(LLVMContext &C); static Type *getTokenTy(LLVMContext &C);
static IntegerType *getIntNTy(LLVMContext &C, unsigned N); static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
static IntegerType *getInt1Ty(LLVMContext &C); static IntegerType *getInt1Ty(LLVMContext &C);
static IntegerType *getInt8Ty(LLVMContext &C); static IntegerType *getInt8Ty(LLVMContext &C);
static IntegerType *getInt16Ty(LLVMContext &C); static IntegerType *getInt16Ty(LLVMContext &C);
static IntegerType *getInt32Ty(LLVMContext &C); static IntegerType *getInt32Ty(LLVMContext &C);
static IntegerType *getInt64Ty(LLVMContext &C); static IntegerType *getInt64Ty(LLVMContext &C);
static IntegerType *getInt128Ty(LLVMContext &C); static IntegerType *getInt128Ty(LLVMContext &C);
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

include/llvm/Support/MachineValueType.h

Show First 20 Lines • Show All 176 Lines • ▼ Show 20 Lines enum SimpleValueType : uint8_t {
FIRST_FP_SCALABLE_VALUETYPE = nxv2f16, FIRST_FP_SCALABLE_VALUETYPE = nxv2f16,
LAST_FP_SCALABLE_VALUETYPE = nxv8f64, LAST_FP_SCALABLE_VALUETYPE = nxv8f64,
FIRST_VECTOR_VALUETYPE = v1i1, FIRST_VECTOR_VALUETYPE = v1i1,
LAST_VECTOR_VALUETYPE = nxv8f64, LAST_VECTOR_VALUETYPE = nxv8f64,
x86mmx = 109, // This is an X86 MMX value x86mmx = 109, // This is an X86 MMX value
Glue = 110, // This glues nodes together during pre-RA sched armsve = 110, // This is an ARM SVE data value
isVoid = 111, // This has no value armsvepred = 111, // This is an ARM SVE predicate value
Untyped = 112, // This value takes a register, but has Glue = 112, // This glues nodes together during pre-RA sched
isVoid = 113, // This has no value
Untyped = 114, // This value takes a register, but has
// unspecified type. The register class // unspecified type. The register class
// will be determined by the opcode. // will be determined by the opcode.
ExceptRef = 113, // WebAssembly's except_ref type ExceptRef = 115, // WebAssembly's except_ref type
FIRST_VALUETYPE = 1, // This is always the beginning of the list. FIRST_VALUETYPE = 1, // This is always the beginning of the list.
LAST_VALUETYPE = 114, // This always remains at the end of the list. LAST_VALUETYPE = 116, // This always remains at the end of the list.
// This is the current maximum for LAST_VALUETYPE. // This is the current maximum for LAST_VALUETYPE.
// MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
// This value must be a multiple of 32. // This value must be a multiple of 32.
MAX_ALLOWED_VALUETYPE = 128, MAX_ALLOWED_VALUETYPE = 128,
// A value of type llvm::TokenTy // A value of type llvm::TokenTy
token = 248, token = 248,
▲ Show 20 Lines • Show All 429 Lines • ▼ Show 20 Lines unsigned getSizeInBits() const {
case vAny: case vAny:
case Any: case Any:
llvm_unreachable("Value type is overloaded."); llvm_unreachable("Value type is overloaded.");
case token: case token:
llvm_unreachable("Token type is a sentinel that cannot be used " llvm_unreachable("Token type is a sentinel that cannot be used "
"in codegen and has no size"); "in codegen and has no size");
case Metadata: case Metadata:
llvm_unreachable("Value type is metadata."); llvm_unreachable("Value type is metadata.");
case armsve:
case armsvepred: return 0;
case i1: case i1:
case v1i1: case v1i1:
case nxv1i1: return 1; case nxv1i1: return 1;
case v2i1: case v2i1:
case nxv2i1: return 2; case nxv2i1: return 2;
case v4i1: case v4i1:
case nxv4i1: return 4; case nxv4i1: return 4;
case i8 : case i8 :
▲ Show 20 Lines • Show All 408 Lines • Show Last 20 Lines

lib/AsmParser/LLLexer.cpp

Show First 20 Lines • Show All 804 Lines • ▼ Show 20 Lines#define TYPEKEYWORD(STR, LLVMTY) \
TYPEKEYWORD("float", Type::getFloatTy(Context)); TYPEKEYWORD("float", Type::getFloatTy(Context));
TYPEKEYWORD("double", Type::getDoubleTy(Context)); TYPEKEYWORD("double", Type::getDoubleTy(Context));
TYPEKEYWORD("x86_fp80", Type::getX86_FP80Ty(Context)); TYPEKEYWORD("x86_fp80", Type::getX86_FP80Ty(Context));
TYPEKEYWORD("fp128", Type::getFP128Ty(Context)); TYPEKEYWORD("fp128", Type::getFP128Ty(Context));
TYPEKEYWORD("ppc_fp128", Type::getPPC_FP128Ty(Context)); TYPEKEYWORD("ppc_fp128", Type::getPPC_FP128Ty(Context));
TYPEKEYWORD("label", Type::getLabelTy(Context)); TYPEKEYWORD("label", Type::getLabelTy(Context));
TYPEKEYWORD("metadata", Type::getMetadataTy(Context)); TYPEKEYWORD("metadata", Type::getMetadataTy(Context));
TYPEKEYWORD("x86_mmx", Type::getX86_MMXTy(Context)); TYPEKEYWORD("x86_mmx", Type::getX86_MMXTy(Context));
TYPEKEYWORD("arm_sve", Type::getArm_SVETy(Context));
TYPEKEYWORD("arm_sve_pred", Type::getArm_SVEPredTy(Context));
TYPEKEYWORD("token", Type::getTokenTy(Context)); TYPEKEYWORD("token", Type::getTokenTy(Context));
#undef TYPEKEYWORD #undef TYPEKEYWORD
// Keywords for instructions. // Keywords for instructions.
#define INSTKEYWORD(STR, Enum) \ #define INSTKEYWORD(STR, Enum) \
do { \ do { \
if (Keyword == #STR) { \ if (Keyword == #STR) { \
▲ Show 20 Lines • Show All 302 Lines • Show Last 20 Lines

lib/Bitcode/Reader/BitcodeReader.cpp

Show First 20 Lines • Show All 1,602 Lines • ▼ Show 20 Lines case bitc::TYPE_CODE_LABEL: // LABEL
ResultTy = Type::getLabelTy(Context); ResultTy = Type::getLabelTy(Context);
break; break;
case bitc::TYPE_CODE_METADATA: // METADATA case bitc::TYPE_CODE_METADATA: // METADATA
ResultTy = Type::getMetadataTy(Context); ResultTy = Type::getMetadataTy(Context);
break; break;
case bitc::TYPE_CODE_X86_MMX: // X86_MMX case bitc::TYPE_CODE_X86_MMX: // X86_MMX
ResultTy = Type::getX86_MMXTy(Context); ResultTy = Type::getX86_MMXTy(Context);
break; break;
case bitc::TYPE_CODE_ARM_SVE: // ARM_SVE
ResultTy = Type::getArm_SVETy(Context);
break;
case bitc::TYPE_CODE_ARM_SVE_PRED: // ARM_SVE_PRED
ResultTy = Type::getArm_SVEPredTy(Context);
break;
case bitc::TYPE_CODE_TOKEN: // TOKEN case bitc::TYPE_CODE_TOKEN: // TOKEN
ResultTy = Type::getTokenTy(Context); ResultTy = Type::getTokenTy(Context);
break; break;
case bitc::TYPE_CODE_INTEGER: { // INTEGER: [width] case bitc::TYPE_CODE_INTEGER: { // INTEGER: [width]
if (Record.size() < 1) if (Record.size() < 1)
return error("Invalid record"); return error("Invalid record");
uint64_t NumBits = Record[0]; uint64_t NumBits = Record[0];
▲ Show 20 Lines • Show All 4,583 Lines • Show Last 20 Lines

lib/Bitcode/Writer/BitcodeWriter.cpp

Show First 20 Lines • Show All 856 Lines • ▼ Show 20 Lines for (unsigned i = 0, e = TypeList.size(); i != e; ++i) {
case Type::FloatTyID: Code = bitc::TYPE_CODE_FLOAT; break; case Type::FloatTyID: Code = bitc::TYPE_CODE_FLOAT; break;
case Type::DoubleTyID: Code = bitc::TYPE_CODE_DOUBLE; break; case Type::DoubleTyID: Code = bitc::TYPE_CODE_DOUBLE; break;
case Type::X86_FP80TyID: Code = bitc::TYPE_CODE_X86_FP80; break; case Type::X86_FP80TyID: Code = bitc::TYPE_CODE_X86_FP80; break;
case Type::FP128TyID: Code = bitc::TYPE_CODE_FP128; break; case Type::FP128TyID: Code = bitc::TYPE_CODE_FP128; break;
case Type::PPC_FP128TyID: Code = bitc::TYPE_CODE_PPC_FP128; break; case Type::PPC_FP128TyID: Code = bitc::TYPE_CODE_PPC_FP128; break;
case Type::LabelTyID: Code = bitc::TYPE_CODE_LABEL; break; case Type::LabelTyID: Code = bitc::TYPE_CODE_LABEL; break;
case Type::MetadataTyID: Code = bitc::TYPE_CODE_METADATA; break; case Type::MetadataTyID: Code = bitc::TYPE_CODE_METADATA; break;
case Type::X86_MMXTyID: Code = bitc::TYPE_CODE_X86_MMX; break; case Type::X86_MMXTyID: Code = bitc::TYPE_CODE_X86_MMX; break;
case Type::Arm_SVETyID: Code = bitc::TYPE_CODE_ARM_SVE; break;
case Type::Arm_SVEPredTyID: Code = bitc::TYPE_CODE_ARM_SVE_PRED; break;
case Type::TokenTyID: Code = bitc::TYPE_CODE_TOKEN; break; case Type::TokenTyID: Code = bitc::TYPE_CODE_TOKEN; break;
case Type::IntegerTyID: case Type::IntegerTyID:
// INTEGER: [width] // INTEGER: [width]
Code = bitc::TYPE_CODE_INTEGER; Code = bitc::TYPE_CODE_INTEGER;
TypeVals.push_back(cast<IntegerType>(T)->getBitWidth()); TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());
break; break;
case Type::PointerTyID: { case Type::PointerTyID: {
PointerType *PTy = cast<PointerType>(T); PointerType *PTy = cast<PointerType>(T);
▲ Show 20 Lines • Show All 3,662 Lines • Show Last 20 Lines

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 160 Lines • ▼ Show 20 Lines public:
DAGCombiner(SelectionDAG &D, AliasAnalysis *AA, CodeGenOpt::Level OL) DAGCombiner(SelectionDAG &D, AliasAnalysis *AA, CodeGenOpt::Level OL)
: DAG(D), TLI(D.getTargetLoweringInfo()), Level(BeforeLegalizeTypes), : DAG(D), TLI(D.getTargetLoweringInfo()), Level(BeforeLegalizeTypes),
OptLevel(OL), AA(AA) { OptLevel(OL), AA(AA) {
ForCodeSize = DAG.getMachineFunction().getFunction().optForSize(); ForCodeSize = DAG.getMachineFunction().getFunction().optForSize();
MaximumLegalStoreInBits = 0; MaximumLegalStoreInBits = 0;
for (MVT VT : MVT::all_valuetypes()) for (MVT VT : MVT::all_valuetypes())
if (EVT(VT).isSimple() && VT != MVT::Other && if (EVT(VT).isSimple() && VT != MVT::Other &&
VT != MVT::armsve && VT != MVT::armsvepred &&
TLI.isTypeLegal(EVT(VT)) && TLI.isTypeLegal(EVT(VT)) &&
VT.getSizeInBits() >= MaximumLegalStoreInBits) VT.getSizeInBits() >= MaximumLegalStoreInBits)
MaximumLegalStoreInBits = VT.getSizeInBits(); MaximumLegalStoreInBits = VT.getSizeInBits();
} }
/// Add to the worklist making sure its instance is at the back (next to be /// Add to the worklist making sure its instance is at the back (next to be
/// processed.) /// processed.)
void AddToWorklist(SDNode *N) { void AddToWorklist(SDNode *N) {
▲ Show 20 Lines • Show All 19,421 Lines • Show Last 20 Lines

lib/CodeGen/ValueTypes.cpp

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines if (VectorType *VTy = dyn_cast<VectorType>(LLVMTy))
return VTy->getBitWidth(); return VTy->getBitWidth();
llvm_unreachable("Unrecognized extended type!"); llvm_unreachable("Unrecognized extended type!");
} }
/// getEVTString - This function returns value type as a string, e.g. "i32". /// getEVTString - This function returns value type as a string, e.g. "i32".
std::string EVT::getEVTString() const { std::string EVT::getEVTString() const {
switch (V.SimpleTy) { switch (V.SimpleTy) {
default: default:
if (isVector()) if (isVector()) {
return "v" + utostr(getVectorNumElements()) + std::string Prefix = "v";
if (isScalableVector())
Prefix = "nxv";
return Prefix + utostr(getVectorNumElements()) +
getVectorElementType().getEVTString(); getVectorElementType().getEVTString();
}
if (isInteger()) if (isInteger())
return "i" + utostr(getSizeInBits()); return "i" + utostr(getSizeInBits());
llvm_unreachable("Invalid EVT!"); llvm_unreachable("Invalid EVT!");
case MVT::i1: return "i1"; case MVT::i1: return "i1";
case MVT::i8: return "i8"; case MVT::i8: return "i8";
case MVT::i16: return "i16"; case MVT::i16: return "i16";
case MVT::i32: return "i32"; case MVT::i32: return "i32";
case MVT::i64: return "i64"; case MVT::i64: return "i64";
case MVT::i128: return "i128"; case MVT::i128: return "i128";
case MVT::f16: return "f16"; case MVT::f16: return "f16";
case MVT::f32: return "f32"; case MVT::f32: return "f32";
case MVT::f64: return "f64"; case MVT::f64: return "f64";
case MVT::f80: return "f80"; case MVT::f80: return "f80";
case MVT::f128: return "f128"; case MVT::f128: return "f128";
case MVT::ppcf128: return "ppcf128"; case MVT::ppcf128: return "ppcf128";
case MVT::isVoid: return "isVoid"; case MVT::isVoid: return "isVoid";
case MVT::Other: return "ch"; case MVT::Other: return "ch";
case MVT::Glue: return "glue"; case MVT::Glue: return "glue";
case MVT::x86mmx: return "x86mmx"; case MVT::x86mmx: return "x86mmx";
case MVT::armsve: return "armsve";
case MVT::armsvepred: return "armsvepred";
case MVT::v1i1: return "v1i1"; case MVT::v1i1: return "v1i1";
case MVT::v2i1: return "v2i1"; case MVT::v2i1: return "v2i1";
case MVT::v4i1: return "v4i1"; case MVT::v4i1: return "v4i1";
case MVT::v8i1: return "v8i1"; case MVT::v8i1: return "v8i1";
case MVT::v16i1: return "v16i1"; case MVT::v16i1: return "v16i1";
case MVT::v32i1: return "v32i1"; case MVT::v32i1: return "v32i1";
case MVT::v64i1: return "v64i1"; case MVT::v64i1: return "v64i1";
case MVT::v128i1: return "v128i1"; case MVT::v128i1: return "v128i1";
Show All 37 Linesstd::string EVT::getEVTString() const {
case MVT::v8f16: return "v8f16"; case MVT::v8f16: return "v8f16";
case MVT::v4f32: return "v4f32"; case MVT::v4f32: return "v4f32";
case MVT::v8f32: return "v8f32"; case MVT::v8f32: return "v8f32";
case MVT::v16f32: return "v16f32"; case MVT::v16f32: return "v16f32";
case MVT::v1f64: return "v1f64"; case MVT::v1f64: return "v1f64";
case MVT::v2f64: return "v2f64"; case MVT::v2f64: return "v2f64";
case MVT::v4f64: return "v4f64"; case MVT::v4f64: return "v4f64";
case MVT::v8f64: return "v8f64"; case MVT::v8f64: return "v8f64";
case MVT::nxv2i1: return "nxv2i1";
case MVT::nxv4i1: return "nxv4i1";
case MVT::nxv8i1: return "nxv8i1";
case MVT::nxv16i1: return "nxv16i1";
case MVT::nxv32i1: return "nxv32i1";
case MVT::nxv1i8: return "nxv1i8";
case MVT::nxv2i8: return "nxv2i8";
case MVT::nxv4i8: return "nxv4i8";
case MVT::nxv8i8: return "nxv8i8";
case MVT::nxv16i8: return "nxv16i8";
case MVT::nxv32i8: return "nxv32i8";
case MVT::nxv1i16: return "nxv1i16";
case MVT::nxv2i16: return "nxv2i16";
case MVT::nxv4i16: return "nxv4i16";
case MVT::nxv8i16: return "nxv8i16";
case MVT::nxv16i16:return "nxv16i16";
case MVT::nxv32i16:return "nxv32i16";
case MVT::nxv1i32: return "nxv1i32";
case MVT::nxv2i32: return "nxv2i32";
case MVT::nxv4i32: return "nxv4i32";
case MVT::nxv8i32: return "nxv8i32";
case MVT::nxv16i32:return "nxv16i32";
case MVT::nxv32i32:return "nxv32i32";
case MVT::nxv1i64: return "nxv1i64";
case MVT::nxv2i64: return "nxv2i64";
case MVT::nxv4i64: return "nxv4i64";
case MVT::nxv8i64: return "nxv8i64";
case MVT::nxv16i64:return "nxv16i64";
case MVT::nxv32i64:return "nxv32i64";
case MVT::nxv2f16: return "nxv2f16";
case MVT::nxv4f16: return "nxv4f16";
case MVT::nxv8f16: return "nxv8f16";
case MVT::nxv1f32: return "nxv1f32";
case MVT::nxv2f32: return "nxv2f32";
case MVT::nxv4f32: return "nxv4f32";
case MVT::nxv8f32: return "nxv8f32";
case MVT::nxv16f32: return "nxv16f32";
case MVT::nxv1f64: return "nxv1f64";
case MVT::nxv2f64: return "nxv2f64";
case MVT::nxv4f64: return "nxv4f64";
case MVT::nxv8f64: return "nxv8f64";
case MVT::Metadata:return "Metadata"; case MVT::Metadata:return "Metadata";
case MVT::Untyped: return "Untyped"; case MVT::Untyped: return "Untyped";
case MVT::ExceptRef: return "ExceptRef"; case MVT::ExceptRef: return "ExceptRef";
} }
} }
/// getTypeForEVT - This method returns an LLVM type corresponding to the /// getTypeForEVT - This method returns an LLVM type corresponding to the
/// specified EVT. For integer types, this returns an unsigned type. Note /// specified EVT. For integer types, this returns an unsigned type. Note
Show All 12 LinesType *EVT::getTypeForEVT(LLVMContext &Context) const {
case MVT::i128: return IntegerType::get(Context, 128); case MVT::i128: return IntegerType::get(Context, 128);
case MVT::f16: return Type::getHalfTy(Context); case MVT::f16: return Type::getHalfTy(Context);
case MVT::f32: return Type::getFloatTy(Context); case MVT::f32: return Type::getFloatTy(Context);
case MVT::f64: return Type::getDoubleTy(Context); case MVT::f64: return Type::getDoubleTy(Context);
case MVT::f80: return Type::getX86_FP80Ty(Context); case MVT::f80: return Type::getX86_FP80Ty(Context);
case MVT::f128: return Type::getFP128Ty(Context); case MVT::f128: return Type::getFP128Ty(Context);
case MVT::ppcf128: return Type::getPPC_FP128Ty(Context); case MVT::ppcf128: return Type::getPPC_FP128Ty(Context);
case MVT::x86mmx: return Type::getX86_MMXTy(Context); case MVT::x86mmx: return Type::getX86_MMXTy(Context);
case MVT::armsve: return Type::getArm_SVETy(Context);
case MVT::armsvepred: return Type::getArm_SVEPredTy(Context);
case MVT::v1i1: return VectorType::get(Type::getInt1Ty(Context), 1); case MVT::v1i1: return VectorType::get(Type::getInt1Ty(Context), 1);
case MVT::v2i1: return VectorType::get(Type::getInt1Ty(Context), 2); case MVT::v2i1: return VectorType::get(Type::getInt1Ty(Context), 2);
case MVT::v4i1: return VectorType::get(Type::getInt1Ty(Context), 4); case MVT::v4i1: return VectorType::get(Type::getInt1Ty(Context), 4);
case MVT::v8i1: return VectorType::get(Type::getInt1Ty(Context), 8); case MVT::v8i1: return VectorType::get(Type::getInt1Ty(Context), 8);
case MVT::v16i1: return VectorType::get(Type::getInt1Ty(Context), 16); case MVT::v16i1: return VectorType::get(Type::getInt1Ty(Context), 16);
case MVT::v32i1: return VectorType::get(Type::getInt1Ty(Context), 32); case MVT::v32i1: return VectorType::get(Type::getInt1Ty(Context), 32);
case MVT::v64i1: return VectorType::get(Type::getInt1Ty(Context), 64); case MVT::v64i1: return VectorType::get(Type::getInt1Ty(Context), 64);
case MVT::v128i1: return VectorType::get(Type::getInt1Ty(Context), 128); case MVT::v128i1: return VectorType::get(Type::getInt1Ty(Context), 128);
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines case Type::VoidTyID:
return MVT::isVoid; return MVT::isVoid;
case Type::IntegerTyID: case Type::IntegerTyID:
return getIntegerVT(cast<IntegerType>(Ty)->getBitWidth()); return getIntegerVT(cast<IntegerType>(Ty)->getBitWidth());
case Type::HalfTyID: return MVT(MVT::f16); case Type::HalfTyID: return MVT(MVT::f16);
case Type::FloatTyID: return MVT(MVT::f32); case Type::FloatTyID: return MVT(MVT::f32);
case Type::DoubleTyID: return MVT(MVT::f64); case Type::DoubleTyID: return MVT(MVT::f64);
case Type::X86_FP80TyID: return MVT(MVT::f80); case Type::X86_FP80TyID: return MVT(MVT::f80);
case Type::X86_MMXTyID: return MVT(MVT::x86mmx); case Type::X86_MMXTyID: return MVT(MVT::x86mmx);
case Type::Arm_SVETyID: return MVT(MVT::armsve);
case Type::Arm_SVEPredTyID: return MVT(MVT::armsvepred);
case Type::FP128TyID: return MVT(MVT::f128); case Type::FP128TyID: return MVT(MVT::f128);
case Type::PPC_FP128TyID: return MVT(MVT::ppcf128); case Type::PPC_FP128TyID: return MVT(MVT::ppcf128);
case Type::PointerTyID: return MVT(MVT::iPTR); case Type::PointerTyID: return MVT(MVT::iPTR);
case Type::VectorTyID: { case Type::VectorTyID: {
VectorType *VTy = cast<VectorType>(Ty); VectorType *VTy = cast<VectorType>(Ty);
return getVectorVT( return getVectorVT(
getVT(VTy->getElementType(), false), VTy->getNumElements()); getVT(VTy->getElementType(), false), VTy->getNumElements());
} }
Show All 19 Lines

lib/IR/AsmWriter.cpp

Show First 20 Lines • Show All 558 Lines • ▼ Show 20 Linesvoid TypePrinting::print(Type *Ty, raw_ostream &OS) {
case Type::FloatTyID: OS << "float"; return; case Type::FloatTyID: OS << "float"; return;
case Type::DoubleTyID: OS << "double"; return; case Type::DoubleTyID: OS << "double"; return;
case Type::X86_FP80TyID: OS << "x86_fp80"; return; case Type::X86_FP80TyID: OS << "x86_fp80"; return;
case Type::FP128TyID: OS << "fp128"; return; case Type::FP128TyID: OS << "fp128"; return;
case Type::PPC_FP128TyID: OS << "ppc_fp128"; return; case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
case Type::LabelTyID: OS << "label"; return; case Type::LabelTyID: OS << "label"; return;
case Type::MetadataTyID: OS << "metadata"; return; case Type::MetadataTyID: OS << "metadata"; return;
case Type::X86_MMXTyID: OS << "x86_mmx"; return; case Type::X86_MMXTyID: OS << "x86_mmx"; return;
case Type::Arm_SVETyID: OS << "arm_sve"; return;
case Type::Arm_SVEPredTyID: OS << "arm_sve_pred"; return;
case Type::TokenTyID: OS << "token"; return; case Type::TokenTyID: OS << "token"; return;
case Type::IntegerTyID: case Type::IntegerTyID:
OS << 'i' << cast<IntegerType>(Ty)->getBitWidth(); OS << 'i' << cast<IntegerType>(Ty)->getBitWidth();
return; return;
case Type::FunctionTyID: { case Type::FunctionTyID: {
FunctionType *FTy = cast<FunctionType>(Ty); FunctionType *FTy = cast<FunctionType>(Ty);
print(FTy->getReturnType(), OS); print(FTy->getReturnType(), OS);
▲ Show 20 Lines • Show All 3,801 Lines • Show Last 20 Lines

lib/IR/Core.cpp

Show First 20 Lines • Show All 493 Lines • ▼ Show 20 LinesLLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) {
case Type::ArrayTyID: case Type::ArrayTyID:
return LLVMArrayTypeKind; return LLVMArrayTypeKind;
case Type::PointerTyID: case Type::PointerTyID:
return LLVMPointerTypeKind; return LLVMPointerTypeKind;
case Type::VectorTyID: case Type::VectorTyID:
return LLVMVectorTypeKind; return LLVMVectorTypeKind;
case Type::X86_MMXTyID: case Type::X86_MMXTyID:
return LLVMX86_MMXTypeKind; return LLVMX86_MMXTypeKind;
case Type::Arm_SVETyID:
return LLVMARM_SVETypeKind;
case Type::Arm_SVEPredTyID:
return LLVMARM_SVEPredTypeKind;
case Type::TokenTyID: case Type::TokenTyID:
return LLVMTokenTypeKind; return LLVMTokenTypeKind;
} }
llvm_unreachable("Unhandled TypeID."); llvm_unreachable("Unhandled TypeID.");
} }
LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty) LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty)
{ {
▲ Show 20 Lines • Show All 3,478 Lines • Show Last 20 Lines

lib/IR/DataLayout.cpp

Show First 20 Lines • Show All 713 Lines • ▼ Show 20 Linesunsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
case Type::FP128TyID: case Type::FP128TyID:
case Type::X86_FP80TyID: case Type::X86_FP80TyID:
AlignType = FLOAT_ALIGN; AlignType = FLOAT_ALIGN;
break; break;
case Type::X86_MMXTyID: case Type::X86_MMXTyID:
case Type::VectorTyID: case Type::VectorTyID:
AlignType = VECTOR_ALIGN; AlignType = VECTOR_ALIGN;
break; break;
case Type::Arm_SVETyID:
return 16;
case Type::Arm_SVEPredTyID:
return 2;
default: default:
llvm_unreachable("Bad type for getAlignment!!!"); llvm_unreachable("Bad type for getAlignment!!!");
} }
return getAlignmentInfo(AlignType, getTypeSizeInBits(Ty), abi_or_pref, Ty); return getAlignmentInfo(AlignType, getTypeSizeInBits(Ty), abi_or_pref, Ty);
} }
unsigned DataLayout::getABITypeAlignment(Type *Ty) const { unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

lib/IR/Function.cpp

Show First 20 Lines • Show All 608 Lines • ▼ Show 20 Lines if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
case Type::MetadataTyID: Result += "Metadata"; break; case Type::MetadataTyID: Result += "Metadata"; break;
case Type::HalfTyID: Result += "f16"; break; case Type::HalfTyID: Result += "f16"; break;
case Type::FloatTyID: Result += "f32"; break; case Type::FloatTyID: Result += "f32"; break;
case Type::DoubleTyID: Result += "f64"; break; case Type::DoubleTyID: Result += "f64"; break;
case Type::X86_FP80TyID: Result += "f80"; break; case Type::X86_FP80TyID: Result += "f80"; break;
case Type::FP128TyID: Result += "f128"; break; case Type::FP128TyID: Result += "f128"; break;
case Type::PPC_FP128TyID: Result += "ppcf128"; break; case Type::PPC_FP128TyID: Result += "ppcf128"; break;
case Type::X86_MMXTyID: Result += "x86mmx"; break; case Type::X86_MMXTyID: Result += "x86mmx"; break;
case Type::Arm_SVETyID: Result += "arm_sve"; break;
case Type::Arm_SVEPredTyID: Result += "arm_sve_pred"; break;
case Type::IntegerTyID: case Type::IntegerTyID:
Result += "i" + utostr(cast<IntegerType>(Ty)->getBitWidth()); Result += "i" + utostr(cast<IntegerType>(Ty)->getBitWidth());
break; break;
} }
} }
return Result; return Result;
} }
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Linesenum IIT_Info {
IIT_PTR_TO_ELT = 33, IIT_PTR_TO_ELT = 33,
IIT_VEC_OF_ANYPTRS_TO_ELT = 34, IIT_VEC_OF_ANYPTRS_TO_ELT = 34,
IIT_I128 = 35, IIT_I128 = 35,
IIT_V512 = 36, IIT_V512 = 36,
IIT_V1024 = 37, IIT_V1024 = 37,
IIT_STRUCT6 = 38, IIT_STRUCT6 = 38,
IIT_STRUCT7 = 39, IIT_STRUCT7 = 39,
IIT_STRUCT8 = 40, IIT_STRUCT8 = 40,
IIT_F128 = 41 IIT_F128 = 41,
IIT_SVE = 42,
IIT_SVE_PRED = 43
}; };
static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos, static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) { SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) {
using namespace Intrinsic; using namespace Intrinsic;
IIT_Info Info = IIT_Info(Infos[NextElt++]); IIT_Info Info = IIT_Info(Infos[NextElt++]);
unsigned StructElts = 2; unsigned StructElts = 2;
switch (Info) { switch (Info) {
case IIT_Done: case IIT_Done:
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0)); OutputTable.push_back(IITDescriptor::get(IITDescriptor::Void, 0));
return; return;
case IIT_VARARG: case IIT_VARARG:
OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0)); OutputTable.push_back(IITDescriptor::get(IITDescriptor::VarArg, 0));
return; return;
case IIT_MMX: case IIT_MMX:
OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0)); OutputTable.push_back(IITDescriptor::get(IITDescriptor::MMX, 0));
return; return;
case IIT_SVE:
OutputTable.push_back(IITDescriptor::get(IITDescriptor::SVE, 0));
return;
case IIT_SVE_PRED:
OutputTable.push_back(IITDescriptor::get(IITDescriptor::SVEPred, 0));
return;
case IIT_TOKEN: case IIT_TOKEN:
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0)); OutputTable.push_back(IITDescriptor::get(IITDescriptor::Token, 0));
return; return;
case IIT_METADATA: case IIT_METADATA:
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0)); OutputTable.push_back(IITDescriptor::get(IITDescriptor::Metadata, 0));
return; return;
case IIT_F16: case IIT_F16:
OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0)); OutputTable.push_back(IITDescriptor::get(IITDescriptor::Half, 0));
▲ Show 20 Lines • Show All 181 Lines • ▼ Show 20 Linesstatic Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos,
IITDescriptor D = Infos.front(); IITDescriptor D = Infos.front();
Infos = Infos.slice(1); Infos = Infos.slice(1);
switch (D.Kind) { switch (D.Kind) {
case IITDescriptor::Void: return Type::getVoidTy(Context); case IITDescriptor::Void: return Type::getVoidTy(Context);
case IITDescriptor::VarArg: return Type::getVoidTy(Context); case IITDescriptor::VarArg: return Type::getVoidTy(Context);
case IITDescriptor::MMX: return Type::getX86_MMXTy(Context); case IITDescriptor::MMX: return Type::getX86_MMXTy(Context);
case IITDescriptor::SVE: return Type::getArm_SVETy(Context);
case IITDescriptor::SVEPred: return Type::getArm_SVEPredTy(Context);
case IITDescriptor::Token: return Type::getTokenTy(Context); case IITDescriptor::Token: return Type::getTokenTy(Context);
case IITDescriptor::Metadata: return Type::getMetadataTy(Context); case IITDescriptor::Metadata: return Type::getMetadataTy(Context);
case IITDescriptor::Half: return Type::getHalfTy(Context); case IITDescriptor::Half: return Type::getHalfTy(Context);
case IITDescriptor::Float: return Type::getFloatTy(Context); case IITDescriptor::Float: return Type::getFloatTy(Context);
case IITDescriptor::Double: return Type::getDoubleTy(Context); case IITDescriptor::Double: return Type::getDoubleTy(Context);
case IITDescriptor::Quad: return Type::getFP128Ty(Context); case IITDescriptor::Quad: return Type::getFP128Ty(Context);
case IITDescriptor::Integer: case IITDescriptor::Integer:
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Linesbool Intrinsic::matchIntrinsicType(Type *Ty, ArrayRef<Intrinsic::IITDescriptor> &Infos,
if (Infos.empty()) return true; if (Infos.empty()) return true;
IITDescriptor D = Infos.front(); IITDescriptor D = Infos.front();
Infos = Infos.slice(1); Infos = Infos.slice(1);
switch (D.Kind) { switch (D.Kind) {
case IITDescriptor::Void: return !Ty->isVoidTy(); case IITDescriptor::Void: return !Ty->isVoidTy();
case IITDescriptor::VarArg: return true; case IITDescriptor::VarArg: return true;
case IITDescriptor::MMX: return !Ty->isX86_MMXTy(); case IITDescriptor::MMX: return !Ty->isX86_MMXTy();
case IITDescriptor::SVE: return !Ty->isArm_SVETy();
case IITDescriptor::SVEPred: return !Ty->isArm_SVEPredTy();
case IITDescriptor::Token: return !Ty->isTokenTy(); case IITDescriptor::Token: return !Ty->isTokenTy();
case IITDescriptor::Metadata: return !Ty->isMetadataTy(); case IITDescriptor::Metadata: return !Ty->isMetadataTy();
case IITDescriptor::Half: return !Ty->isHalfTy(); case IITDescriptor::Half: return !Ty->isHalfTy();
case IITDescriptor::Float: return !Ty->isFloatTy(); case IITDescriptor::Float: return !Ty->isFloatTy();
case IITDescriptor::Double: return !Ty->isDoubleTy(); case IITDescriptor::Double: return !Ty->isDoubleTy();
case IITDescriptor::Quad: return !Ty->isFP128Ty(); case IITDescriptor::Quad: return !Ty->isFP128Ty();
case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width); case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width);
case IITDescriptor::Vector: { case IITDescriptor::Vector: {
▲ Show 20 Lines • Show All 391 Lines • Show Last 20 Lines

lib/IR/LLVMContextImpl.h

Show First 20 Lines • Show All 1,286 Lines • ▼ Show 20 Lines#include "llvm/IR/Metadata.def"
ConstantInt *TheTrueVal = nullptr; ConstantInt *TheTrueVal = nullptr;
ConstantInt *TheFalseVal = nullptr; ConstantInt *TheFalseVal = nullptr;
std::unique_ptr<ConstantTokenNone> TheNoneToken; std::unique_ptr<ConstantTokenNone> TheNoneToken;
// Basic type instances. // Basic type instances.
Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy, TokenTy; Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy, TokenTy;
Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy; Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy, ARM_SVETy, ARM_SVEPredTy;
IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty, Int128Ty; IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty, Int128Ty;
/// TypeAllocator - All dynamically allocated types are allocated from this. /// TypeAllocator - All dynamically allocated types are allocated from this.
/// They live forever until the context is torn down. /// They live forever until the context is torn down.
BumpPtrAllocator TypeAllocator; BumpPtrAllocator TypeAllocator;
DenseMap<unsigned, IntegerType*> IntegerTypes; DenseMap<unsigned, IntegerType*> IntegerTypes;
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

lib/IR/LLVMContextImpl.cpp

Show All 27 Lines : DiagHandler(llvm::make_unique<DiagnosticHandler>()),
FloatTy(C, Type::FloatTyID), FloatTy(C, Type::FloatTyID),
DoubleTy(C, Type::DoubleTyID), DoubleTy(C, Type::DoubleTyID),
MetadataTy(C, Type::MetadataTyID), MetadataTy(C, Type::MetadataTyID),
TokenTy(C, Type::TokenTyID), TokenTy(C, Type::TokenTyID),
X86_FP80Ty(C, Type::X86_FP80TyID), X86_FP80Ty(C, Type::X86_FP80TyID),
FP128Ty(C, Type::FP128TyID), FP128Ty(C, Type::FP128TyID),
PPC_FP128Ty(C, Type::PPC_FP128TyID), PPC_FP128Ty(C, Type::PPC_FP128TyID),
X86_MMXTy(C, Type::X86_MMXTyID), X86_MMXTy(C, Type::X86_MMXTyID),
ARM_SVETy(C, Type::Arm_SVETyID),
ARM_SVEPredTy(C, Type::Arm_SVEPredTyID),
Int1Ty(C, 1), Int1Ty(C, 1),
Int8Ty(C, 8), Int8Ty(C, 8),
Int16Ty(C, 16), Int16Ty(C, 16),
Int32Ty(C, 32), Int32Ty(C, 32),
Int64Ty(C, 64), Int64Ty(C, 64),
Int128Ty(C, 128) {} Int128Ty(C, 128) {}
LLVMContextImpl::~LLVMContextImpl() { LLVMContextImpl::~LLVMContextImpl() {
▲ Show 20 Lines • Show All 208 Lines • Show Last 20 Lines

lib/IR/Type.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 LinesType *Type::getPrimitiveType(LLVMContext &C, TypeID IDNumber) {
case FloatTyID : return getFloatTy(C); case FloatTyID : return getFloatTy(C);
case DoubleTyID : return getDoubleTy(C); case DoubleTyID : return getDoubleTy(C);
case X86_FP80TyID : return getX86_FP80Ty(C); case X86_FP80TyID : return getX86_FP80Ty(C);
case FP128TyID : return getFP128Ty(C); case FP128TyID : return getFP128Ty(C);
case PPC_FP128TyID : return getPPC_FP128Ty(C); case PPC_FP128TyID : return getPPC_FP128Ty(C);
case LabelTyID : return getLabelTy(C); case LabelTyID : return getLabelTy(C);
case MetadataTyID : return getMetadataTy(C); case MetadataTyID : return getMetadataTy(C);
case X86_MMXTyID : return getX86_MMXTy(C); case X86_MMXTyID : return getX86_MMXTy(C);
case Arm_SVETyID : return getArm_SVETy(C);
case Arm_SVEPredTyID: return getArm_SVEPredTy(C);
case TokenTyID : return getTokenTy(C); case TokenTyID : return getTokenTy(C);
default: default:
return nullptr; return nullptr;
} }
} }
bool Type::isIntegerTy(unsigned Bitwidth) const { bool Type::isIntegerTy(unsigned Bitwidth) const {
return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth; return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth;
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; } Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; }
Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; } Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; } Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; } Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; }
Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; } Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; } Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; } Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }
Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; } Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; }
Type *Type::getArm_SVETy(LLVMContext &C) { return &C.pImpl->ARM_SVETy; }
Type *Type::getArm_SVEPredTy(LLVMContext &C) { return &C.pImpl->ARM_SVEPredTy; }
IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; } IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; }
IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; } IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; }
IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; } IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; }
IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; } IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; }
IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; } IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; }
IntegerType *Type::getInt128Ty(LLVMContext &C) { return &C.pImpl->Int128Ty; } IntegerType *Type::getInt128Ty(LLVMContext &C) { return &C.pImpl->Int128Ty; }
▲ Show 20 Lines • Show All 484 Lines • Show Last 20 Lines

lib/Target/AArch64/AArch64CallingConvention.td

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines CCIfType<[i32], CCAssignToRegWithShadow<[W0, W1, W2, W3, W4, W5, W6, W7],
[X0, X1, X2, X3, X4, X5, X6, X7]>>, [X0, X1, X2, X3, X4, X5, X6, X7]>>,
// i128 is split to two i64s, we can't fit half to register X7. // i128 is split to two i64s, we can't fit half to register X7.
CCIfType<[i64], CCIfSplit<CCAssignToRegWithShadow<[X0, X2, X4, X6], CCIfType<[i64], CCIfSplit<CCAssignToRegWithShadow<[X0, X2, X4, X6],
[X0, X1, X3, X5]>>>, [X0, X1, X3, X5]>>>,
// i128 is split to two i64s, and its stack alignment is 16 bytes. // i128 is split to two i64s, and its stack alignment is 16 bytes.
CCIfType<[i64], CCIfSplit<CCAssignToStackWithShadow<8, 16, [X7]>>>, CCIfType<[i64], CCIfSplit<CCAssignToStackWithShadow<8, 16, [X7]>>>,
CCIfType<[armsve],
CCAssignToReg<[Z0, Z1, Z2, Z3, Z4, Z5, Z6, Z7]>>,
CCIfType<[armsvepred],
CCAssignToReg<[P0, P1, P2, P3]>>,
CCIfType<[i64], CCAssignToRegWithShadow<[X0, X1, X2, X3, X4, X5, X6, X7], CCIfType<[i64], CCAssignToRegWithShadow<[X0, X1, X2, X3, X4, X5, X6, X7],
[W0, W1, W2, W3, W4, W5, W6, W7]>>, [W0, W1, W2, W3, W4, W5, W6, W7]>>,
CCIfType<[f16], CCAssignToRegWithShadow<[H0, H1, H2, H3, H4, H5, H6, H7], CCIfType<[f16], CCAssignToRegWithShadow<[H0, H1, H2, H3, H4, H5, H6, H7],
[Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>, [Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>,
CCIfType<[f32], CCAssignToRegWithShadow<[S0, S1, S2, S3, S4, S5, S6, S7], CCIfType<[f32], CCAssignToRegWithShadow<[S0, S1, S2, S3, S4, S5, S6, S7],
[Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>, [Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>,
CCIfType<[f64], CCAssignToRegWithShadow<[D0, D1, D2, D3, D4, D5, D6, D7], CCIfType<[f64], CCAssignToRegWithShadow<[D0, D1, D2, D3, D4, D5, D6, D7],
[Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>, [Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>,
Show All 37 Linesdef RetCC_AArch64_AAPCS : CallingConv<[
CCIfType<[f32], CCAssignToRegWithShadow<[S0, S1, S2, S3, S4, S5, S6, S7], CCIfType<[f32], CCAssignToRegWithShadow<[S0, S1, S2, S3, S4, S5, S6, S7],
[Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>, [Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>,
CCIfType<[f64], CCAssignToRegWithShadow<[D0, D1, D2, D3, D4, D5, D6, D7], CCIfType<[f64], CCAssignToRegWithShadow<[D0, D1, D2, D3, D4, D5, D6, D7],
[Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>, [Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>,
CCIfType<[v1i64, v2i32, v4i16, v8i8, v1f64, v2f32, v4f16], CCIfType<[v1i64, v2i32, v4i16, v8i8, v1f64, v2f32, v4f16],
CCAssignToRegWithShadow<[D0, D1, D2, D3, D4, D5, D6, D7], CCAssignToRegWithShadow<[D0, D1, D2, D3, D4, D5, D6, D7],
[Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>, [Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>,
CCIfType<[f128, v2i64, v4i32, v8i16, v16i8, v4f32, v2f64, v8f16], CCIfType<[f128, v2i64, v4i32, v8i16, v16i8, v4f32, v2f64, v8f16],
CCAssignToReg<[Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>> CCAssignToReg<[Q0, Q1, Q2, Q3, Q4, Q5, Q6, Q7]>>,
CCIfType<[armsve],
CCAssignToReg<[Z0, Z1, Z2, Z3, Z4, Z5, Z6, Z7]>>,
CCIfType<[armsvepred],
CCAssignToReg<[P0, P1, P2, P3]>>
]>; ]>;
// Vararg functions on windows pass floats in integer registers // Vararg functions on windows pass floats in integer registers
let Entry = 1 in let Entry = 1 in
def CC_AArch64_Win64_VarArg : CallingConv<[ def CC_AArch64_Win64_VarArg : CallingConv<[
CCIfType<[f16, f32], CCPromoteToType<f64>>, CCIfType<[f16, f32], CCPromoteToType<f64>>,
CCIfType<[f64], CCBitConvertToType<i64>>, CCIfType<[f64], CCBitConvertToType<i64>>,
CCDelegateTo<CC_AArch64_AAPCS> CCDelegateTo<CC_AArch64_AAPCS>
▲ Show 20 Lines • Show All 259 Lines • Show Last 20 Lines

lib/Target/AArch64/AArch64ISelLowering.h

Show First 20 Lines • Show All 548 Lines • ▼ Show 20 Linesprivate:
void addQRTypeForNEON(MVT VT); void addQRTypeForNEON(MVT VT);
SDValue LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, SDValue LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
const SDLoc &DL, SelectionDAG &DAG, const SDLoc &DL, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const override; SmallVectorImpl<SDValue> &InVals) const override;
unsigned getABIAlignmentForCallingConv(Type *ArgTy,
DataLayout DL) const override {
if (ArgTy->isArm_SVETy())
return 16; // 128b in bytes
if (ArgTy->isArm_SVEPredTy())
return 2; // 16b in bytes
return DL.getABITypeAlignment(ArgTy);
}
SDValue LowerCall(CallLoweringInfo & /*CLI*/, SDValue LowerCall(CallLoweringInfo & /*CLI*/,
SmallVectorImpl<SDValue> &InVals) const override; SmallVectorImpl<SDValue> &InVals) const override;
SDValue LowerCallResult(SDValue Chain, SDValue InFlag, SDValue LowerCallResult(SDValue Chain, SDValue InFlag,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
const SDLoc &DL, SelectionDAG &DAG, const SDLoc &DL, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals, bool isThisReturn, SmallVectorImpl<SDValue> &InVals, bool isThisReturn,
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

lib/Target/AArch64/AArch64ISelLowering.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Lines if (Subtarget->hasNEON()) {
addQRTypeForNEON(MVT::v2f64); addQRTypeForNEON(MVT::v2f64);
addQRTypeForNEON(MVT::v16i8); addQRTypeForNEON(MVT::v16i8);
addQRTypeForNEON(MVT::v8i16); addQRTypeForNEON(MVT::v8i16);
addQRTypeForNEON(MVT::v4i32); addQRTypeForNEON(MVT::v4i32);
addQRTypeForNEON(MVT::v2i64); addQRTypeForNEON(MVT::v2i64);
addQRTypeForNEON(MVT::v8f16); addQRTypeForNEON(MVT::v8f16);
} }
if (Subtarget->hasSVE()) {
addRegisterClass(MVT::armsve, &AArch64::ZPRRegClass);
addRegisterClass(MVT::armsvepred, &AArch64::PPRRegClass);
addRegisterClass(MVT::nxv8i16, &AArch64::ZPRRegClass);
addRegisterClass(MVT::nxv16i8, &AArch64::ZPRRegClass);
addRegisterClass(MVT::nxv4i32, &AArch64::ZPRRegClass);
addRegisterClass(MVT::nxv2i64, &AArch64::ZPRRegClass);
addRegisterClass(MVT::nxv16i1, &AArch64::PPRRegClass);
addRegisterClass(MVT::nxv8i1, &AArch64::PPRRegClass);
addRegisterClass(MVT::nxv4i1, &AArch64::PPRRegClass);
addRegisterClass(MVT::nxv2i1, &AArch64::PPRRegClass);
addRegisterClass(MVT::nxv2f16, &AArch64::ZPRRegClass);
addRegisterClass(MVT::nxv4f16, &AArch64::ZPRRegClass);
addRegisterClass(MVT::nxv8f16, &AArch64::ZPRRegClass);
addRegisterClass(MVT::nxv1f32, &AArch64::ZPRRegClass);
addRegisterClass(MVT::nxv2f32, &AArch64::ZPRRegClass);
addRegisterClass(MVT::nxv4f32, &AArch64::ZPRRegClass);
addRegisterClass(MVT::nxv1f64, &AArch64::ZPRRegClass);
addRegisterClass(MVT::nxv2f64, &AArch64::ZPRRegClass);
}
// Compute derived properties from the register classes // Compute derived properties from the register classes
computeRegisterProperties(Subtarget->getRegisterInfo()); computeRegisterProperties(Subtarget->getRegisterInfo());
// Provide all sorts of operation actions // Provide all sorts of operation actions
setOperationAction(ISD::GlobalAddress, MVT::i64, Custom); setOperationAction(ISD::GlobalAddress, MVT::i64, Custom);
setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom); setOperationAction(ISD::GlobalTLSAddress, MVT::i64, Custom);
setOperationAction(ISD::SETCC, MVT::i32, Custom); setOperationAction(ISD::SETCC, MVT::i32, Custom);
setOperationAction(ISD::SETCC, MVT::i64, Custom); setOperationAction(ISD::SETCC, MVT::i64, Custom);
▲ Show 20 Lines • Show All 2,912 Lines • ▼ Show 20 Lines if (VA.isRegLoc()) {
else if (RegVT == MVT::f16) else if (RegVT == MVT::f16)
RC = &AArch64::FPR16RegClass; RC = &AArch64::FPR16RegClass;
else if (RegVT == MVT::f32) else if (RegVT == MVT::f32)
RC = &AArch64::FPR32RegClass; RC = &AArch64::FPR32RegClass;
else if (RegVT == MVT::f64 || RegVT.is64BitVector()) else if (RegVT == MVT::f64 || RegVT.is64BitVector())
RC = &AArch64::FPR64RegClass; RC = &AArch64::FPR64RegClass;
else if (RegVT == MVT::f128 || RegVT.is128BitVector()) else if (RegVT == MVT::f128 || RegVT.is128BitVector())
RC = &AArch64::FPR128RegClass; RC = &AArch64::FPR128RegClass;
else if (RegVT == MVT::armsve)
RC = &AArch64::ZPRRegClass;
else if (RegVT == MVT::armsvepred)
RC = &AArch64::PPRRegClass;
else else
llvm_unreachable("RegVT not supported by FORMAL_ARGUMENTS Lowering"); llvm_unreachable("RegVT not supported by FORMAL_ARGUMENTS Lowering");
// Transform the arguments in physical registers into virtual ones. // Transform the arguments in physical registers into virtual ones.
unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC); unsigned Reg = MF.addLiveIn(VA.getLocReg(), RC);
ArgValue = DAG.getCopyFromReg(Chain, DL, Reg, RegVT); ArgValue = DAG.getCopyFromReg(Chain, DL, Reg, RegVT);
// If this is an 8, 16 or 32-bit value, it is really passed promoted // If this is an 8, 16 or 32-bit value, it is really passed promoted
▲ Show 20 Lines • Show All 8,859 Lines • Show Last 20 Lines

lib/Target/AArch64/AArch64RegisterInfo.td

Show First 20 Lines • Show All 809 Lines • ▼ Show 20 Lines
class ZPRRegOp <string Suffix, AsmOperandClass C, ElementSizeEnum Size, class ZPRRegOp <string Suffix, AsmOperandClass C, ElementSizeEnum Size,
RegisterClass RC> : SVERegOp<Suffix, C, Size, RC> {} RegisterClass RC> : SVERegOp<Suffix, C, Size, RC> {}
//****************************************************************************** //******************************************************************************
// SVE predicate register classes. // SVE predicate register classes.
class PPRClass<int lastreg> : RegisterClass< class PPRClass<int lastreg> : RegisterClass<
"AArch64", "AArch64",
[ nxv16i1, nxv8i1, nxv4i1, nxv2i1 ], 16, [ nxv16i1, nxv8i1, nxv4i1, nxv2i1, armsvepred ], 16,
(sequence "P%u", 0, lastreg)> { (sequence "P%u", 0, lastreg)> {
let Size = 16; let Size = 16;
} }
def PPR : PPRClass<15>; def PPR : PPRClass<15>;
def PPR_3b : PPRClass<7>; // Restricted 3 bit SVE predicate register class. def PPR_3b : PPRClass<7>; // Restricted 3 bit SVE predicate register class.
class PPRAsmOperand <string name, string RegClass, int Width>: AsmOperandClass { class PPRAsmOperand <string name, string RegClass, int Width>: AsmOperandClass {
Show All 31 Lines
//****************************************************************************** //******************************************************************************
// SVE vector register class // SVE vector register class
def ZPR : RegisterClass<"AArch64", def ZPR : RegisterClass<"AArch64",
[nxv16i8, nxv8i16, nxv4i32, nxv2i64, [nxv16i8, nxv8i16, nxv4i32, nxv2i64,
nxv2f16, nxv4f16, nxv8f16, nxv2f16, nxv4f16, nxv8f16,
nxv1f32, nxv2f32, nxv4f32, nxv1f32, nxv2f32, nxv4f32,
nxv1f64, nxv2f64], nxv1f64, nxv2f64, armsve],
128, (sequence "Z%u", 0, 31)> { 128, (sequence "Z%u", 0, 31)> {
let Size = 128; let Size = 128;
} }
// SVE restricted 4 bit scalable vector register class // SVE restricted 4 bit scalable vector register class
def ZPR_4b : RegisterClass<"AArch64", def ZPR_4b : RegisterClass<"AArch64",
[nxv16i8, nxv8i16, nxv4i32, nxv2i64, [nxv16i8, nxv8i16, nxv4i32, nxv2i64,
nxv2f16, nxv4f16, nxv8f16, nxv2f16, nxv4f16, nxv8f16,
nxv1f32, nxv2f32, nxv4f32, nxv1f32, nxv2f32, nxv4f32,
nxv1f64, nxv2f64], nxv1f64, nxv2f64, armsve],
128, (sequence "Z%u", 0, 15)> { 128, (sequence "Z%u", 0, 15)> {
let Size = 128; let Size = 128;
} }
// SVE restricted 3 bit scalable vector register class // SVE restricted 3 bit scalable vector register class
def ZPR_3b : RegisterClass<"AArch64", def ZPR_3b : RegisterClass<"AArch64",
[nxv16i8, nxv8i16, nxv4i32, nxv2i64, [nxv16i8, nxv8i16, nxv4i32, nxv2i64,
nxv2f16, nxv4f16, nxv8f16, nxv2f16, nxv4f16, nxv8f16,
nxv1f32, nxv2f32, nxv4f32, nxv1f32, nxv2f32, nxv4f32,
nxv1f64, nxv2f64], nxv1f64, nxv2f64, armsve],
128, (sequence "Z%u", 0, 7)> { 128, (sequence "Z%u", 0, 7)> {
let Size = 128; let Size = 128;
} }
class ZPRAsmOperand<string name, int Width, string RegClassSuffix = ""> class ZPRAsmOperand<string name, int Width, string RegClassSuffix = "">
: AsmOperandClass { : AsmOperandClass {
let Name = "SVE" # name # "Reg"; let Name = "SVE" # name # "Reg";
let PredicateMethod = "isSVEDataVectorRegOfWidth<" let PredicateMethod = "isSVEDataVectorRegOfWidth<"
▲ Show 20 Lines • Show All 235 Lines • Show Last 20 Lines

lib/Target/AArch64/AArch64SVEInstrInfo.td

Show First 20 Lines • Show All 1,014 Lines • ▼ Show 20 Lines def : InstAlias<"fcmle $Zd, $Pg/z, $Zm, $Zn",
(FCMGE_PPzZZ_D PPR64:$Zd, PPR3bAny:$Pg, ZPR64:$Zn, ZPR64:$Zm), 0>; (FCMGE_PPzZZ_D PPR64:$Zd, PPR3bAny:$Pg, ZPR64:$Zn, ZPR64:$Zm), 0>;
def : InstAlias<"fcmlt $Zd, $Pg/z, $Zm, $Zn", def : InstAlias<"fcmlt $Zd, $Pg/z, $Zm, $Zn",
(FCMGT_PPzZZ_H PPR16:$Zd, PPR3bAny:$Pg, ZPR16:$Zn, ZPR16:$Zm), 0>; (FCMGT_PPzZZ_H PPR16:$Zd, PPR3bAny:$Pg, ZPR16:$Zn, ZPR16:$Zm), 0>;
def : InstAlias<"fcmlt $Zd, $Pg/z, $Zm, $Zn", def : InstAlias<"fcmlt $Zd, $Pg/z, $Zm, $Zn",
(FCMGT_PPzZZ_S PPR32:$Zd, PPR3bAny:$Pg, ZPR32:$Zn, ZPR32:$Zm), 0>; (FCMGT_PPzZZ_S PPR32:$Zd, PPR3bAny:$Pg, ZPR32:$Zn, ZPR32:$Zm), 0>;
def : InstAlias<"fcmlt $Zd, $Pg/z, $Zm, $Zn", def : InstAlias<"fcmlt $Zd, $Pg/z, $Zm, $Zn",
(FCMGT_PPzZZ_D PPR64:$Zd, PPR3bAny:$Pg, ZPR64:$Zn, ZPR64:$Zm), 0>; (FCMGT_PPzZZ_D PPR64:$Zd, PPR3bAny:$Pg, ZPR64:$Zn, ZPR64:$Zm), 0>;
// Patterns
def : Pat<(armsve (int_aarch64_sve_fdup_D2_d (fpimm64:$imm8))),
(FDUP_ZI_D fpimm64:$imm8)>;
def : Pat<(armsve (int_aarch64_sve_fmul_D2_P2D2D2 armsvepred:$pm, armsve:$zdn, armsve:$zm)),
(FMUL_ZPmZ_D PPR64:$pm, ZPR:$zdn, ZPR:$zm)>;
def : Pat<(armsvepred (int_aarch64_sve_ptrue_P2_i sve_pred_enum:$pattern)),
(PTRUE_D sve_pred_enum:$pattern)>;
} }

lib/Target/Hexagon/HexagonTargetObjectFile.cpp

Show First 20 Lines • Show All 326 Lines • ▼ Show 20 Linesunsigned HexagonTargetObjectFile::getSmallestAddressableSize(const Type *Ty,
case Type::FunctionTyID: case Type::FunctionTyID:
case Type::VoidTyID: case Type::VoidTyID:
case Type::X86_FP80TyID: case Type::X86_FP80TyID:
case Type::FP128TyID: case Type::FP128TyID:
case Type::PPC_FP128TyID: case Type::PPC_FP128TyID:
case Type::LabelTyID: case Type::LabelTyID:
case Type::MetadataTyID: case Type::MetadataTyID:
case Type::X86_MMXTyID: case Type::X86_MMXTyID:
case Type::Arm_SVETyID:
case Type::Arm_SVEPredTyID:
case Type::TokenTyID: case Type::TokenTyID:
return 0; return 0;
} }
return 0; return 0;
} }
MCSection *HexagonTargetObjectFile::selectSmallSectionForGlobal( MCSection *HexagonTargetObjectFile::selectSmallSectionForGlobal(
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

test/Instrumentation/EfficiencySanitizer/struct_field_count_basic.ll

; Test basic EfficiencySanitizer struct field count instrumentation. ; Test basic EfficiencySanitizer struct field count instrumentation.
; ;
; RUN: opt < %s -esan -esan-cache-frag -S | FileCheck %s ; RUN: opt < %s -esan -esan-cache-frag -S | FileCheck %s
%struct.A = type { i32, i32 } %struct.A = type { i32, i32 }
%union.U = type { double } %union.U = type { double }
%struct.C = type { %struct.anon, %union.anon, [10 x i8] } %struct.C = type { %struct.anon, %union.anon, [10 x i8] }
%struct.anon = type { i32, i32 } %struct.anon = type { i32, i32 }
%union.anon = type { double } %union.anon = type { double }
; CHECK: @0 = private unnamed_addr constant [8 x i8] c"<stdin>\00", align 1 ; CHECK: @0 = private unnamed_addr constant [8 x i8] c"<stdin>\00", align 1
; CHECK-NEXT: @1 = private unnamed_addr constant [17 x i8] c"struct.A$2$11$11\00", align 1 ; CHECK-NEXT: @1 = private unnamed_addr constant [17 x i8] c"struct.A$2$13$13\00", align 1
; CHECK-NEXT: @"struct.A$2$11$11" = weak global [3 x i64] zeroinitializer ; CHECK-NEXT: @"struct.A$2$13$13" = weak global [3 x i64] zeroinitializer
; CHECK-NEXT: @2 = internal constant [2 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @5, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @6, i32 0, i32 0)] ; CHECK-NEXT: @2 = internal constant [2 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @5, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @6, i32 0, i32 0)]
; CHECK-NEXT: @3 = internal constant [2 x i32] [i32 0, i32 4] ; CHECK-NEXT: @3 = internal constant [2 x i32] [i32 0, i32 4]
; CHECK-NEXT: @4 = internal constant [2 x i32] [i32 4, i32 4] ; CHECK-NEXT: @4 = internal constant [2 x i32] [i32 4, i32 4]
; CHECK-NEXT: @5 = private unnamed_addr constant [4 x i8] c"i32\00", align 1 ; CHECK-NEXT: @5 = private unnamed_addr constant [4 x i8] c"i32\00", align 1
; CHECK-NEXT: @6 = private unnamed_addr constant [4 x i8] c"i32\00", align 1 ; CHECK-NEXT: @6 = private unnamed_addr constant [4 x i8] c"i32\00", align 1
; CHECK-NEXT: @7 = private unnamed_addr constant [12 x i8] c"union.U$1$3\00", align 1 ; CHECK-NEXT: @7 = private unnamed_addr constant [12 x i8] c"union.U$1$3\00", align 1
; CHECK-NEXT: @"union.U$1$3" = weak global [2 x i64] zeroinitializer ; CHECK-NEXT: @"union.U$1$3" = weak global [2 x i64] zeroinitializer
; CHECK-NEXT: @8 = internal constant [1 x i8*] [i8* getelementptr inbounds ([7 x i8], [7 x i8]* @11, i32 0, i32 0)] ; CHECK-NEXT: @8 = internal constant [1 x i8*] [i8* getelementptr inbounds ([7 x i8], [7 x i8]* @11, i32 0, i32 0)]
; CHECK-NEXT: @9 = internal constant [1 x i32] zeroinitializer ; CHECK-NEXT: @9 = internal constant [1 x i32] zeroinitializer
; CHECK-NEXT: @10 = internal constant [1 x i32] [i32 8] ; CHECK-NEXT: @10 = internal constant [1 x i32] [i32 8]
; CHECK-NEXT: @11 = private unnamed_addr constant [7 x i8] c"double\00", align 1 ; CHECK-NEXT: @11 = private unnamed_addr constant [7 x i8] c"double\00", align 1
; CHECK-NEXT: @12 = private unnamed_addr constant [20 x i8] c"struct.C$3$14$13$13\00", align 1 ; CHECK-NEXT: @12 = private unnamed_addr constant [20 x i8] c"struct.C$3$16$15$15\00", align 1
; CHECK-NEXT: @"struct.C$3$14$13$13" = weak global [4 x i64] zeroinitializer ; CHECK-NEXT: @"struct.C$3$16$15$15" = weak global [4 x i64] zeroinitializer
; CHECK-NEXT: @13 = internal constant [3 x i8*] [i8* getelementptr inbounds ([33 x i8], [33 x i8]* @16, i32 0, i32 0), i8* getelementptr inbounds ([30 x i8], [30 x i8]* @17, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @18, i32 0, i32 0)] ; CHECK-NEXT: @13 = internal constant [3 x i8*] [i8* getelementptr inbounds ([33 x i8], [33 x i8]* @16, i32 0, i32 0), i8* getelementptr inbounds ([30 x i8], [30 x i8]* @17, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @18, i32 0, i32 0)]
; CHECK-NEXT: @14 = internal constant [3 x i32] [i32 0, i32 8, i32 16] ; CHECK-NEXT: @14 = internal constant [3 x i32] [i32 0, i32 8, i32 16]
; CHECK-NEXT: @15 = internal constant [3 x i32] [i32 8, i32 8, i32 10] ; CHECK-NEXT: @15 = internal constant [3 x i32] [i32 8, i32 8, i32 10]
; CHECK-NEXT: @16 = private unnamed_addr constant [33 x i8] c"%struct.anon = type { i32, i32 }\00", align 1 ; CHECK-NEXT: @16 = private unnamed_addr constant [33 x i8] c"%struct.anon = type { i32, i32 }\00", align 1
; CHECK-NEXT: @17 = private unnamed_addr constant [30 x i8] c"%union.anon = type { double }\00", align 1 ; CHECK-NEXT: @17 = private unnamed_addr constant [30 x i8] c"%union.anon = type { double }\00", align 1
; CHECK-NEXT: @18 = private unnamed_addr constant [10 x i8] c"[10 x i8]\00", align 1 ; CHECK-NEXT: @18 = private unnamed_addr constant [10 x i8] c"[10 x i8]\00", align 1
; CHECK-NEXT: @19 = private unnamed_addr constant [20 x i8] c"struct.anon$2$11$11\00", align 1 ; CHECK-NEXT: @19 = private unnamed_addr constant [20 x i8] c"struct.anon$2$13$13\00", align 1
; CHECK-NEXT: @"struct.anon$2$11$11" = weak global [3 x i64] zeroinitializer ; CHECK-NEXT: @"struct.anon$2$13$13" = weak global [3 x i64] zeroinitializer
; CHECK-NEXT: @20 = internal constant [2 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @23, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @24, i32 0, i32 0)] ; CHECK-NEXT: @20 = internal constant [2 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @23, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @24, i32 0, i32 0)]
; CHECK-NEXT: @21 = internal constant [2 x i32] [i32 0, i32 4] ; CHECK-NEXT: @21 = internal constant [2 x i32] [i32 0, i32 4]
; CHECK-NEXT: @22 = internal constant [2 x i32] [i32 4, i32 4] ; CHECK-NEXT: @22 = internal constant [2 x i32] [i32 4, i32 4]
; CHECK-NEXT: @23 = private unnamed_addr constant [4 x i8] c"i32\00", align 1 ; CHECK-NEXT: @23 = private unnamed_addr constant [4 x i8] c"i32\00", align 1
; CHECK-NEXT: @24 = private unnamed_addr constant [4 x i8] c"i32\00", align 1 ; CHECK-NEXT: @24 = private unnamed_addr constant [4 x i8] c"i32\00", align 1
; CHECK-NEXT: @25 = private unnamed_addr constant [15 x i8] c"union.anon$1$3\00", align 1 ; CHECK-NEXT: @25 = private unnamed_addr constant [15 x i8] c"union.anon$1$3\00", align 1
; CHECK-NEXT: @"union.anon$1$3" = weak global [2 x i64] zeroinitializer ; CHECK-NEXT: @"union.anon$1$3" = weak global [2 x i64] zeroinitializer
; CHECK-NEXT: @26 = internal constant [1 x i8*] [i8* getelementptr inbounds ([7 x i8], [7 x i8]* @29, i32 0, i32 0)] ; CHECK-NEXT: @26 = internal constant [1 x i8*] [i8* getelementptr inbounds ([7 x i8], [7 x i8]* @29, i32 0, i32 0)]
; CHECK-NEXT: @27 = internal constant [1 x i32] zeroinitializer ; CHECK-NEXT: @27 = internal constant [1 x i32] zeroinitializer
; CHECK-NEXT: @28 = internal constant [1 x i32] [i32 8] ; CHECK-NEXT: @28 = internal constant [1 x i32] [i32 8]
; CHECK-NEXT: @29 = private unnamed_addr constant [7 x i8] c"double\00", align 1 ; CHECK-NEXT: @29 = private unnamed_addr constant [7 x i8] c"double\00", align 1
; CHECK-NEXT: @30 = internal global [5 x { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }] [{ i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([17 x i8], [17 x i8]* @1, i32 0, i32 0), i32 8, i32 2, i32* getelementptr inbounds ([2 x i32], [2 x i32]* @3, i32 0, i32 0), i32* getelementptr inbounds ([2 x i32], [2 x i32]* @4, i32 0, i32 0), i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @2, i32 0, i32 0), i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$11$11", i32 0, i32 0), i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$11$11", i32 0, i32 2) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([12 x i8], [12 x i8]* @7, i32 0, i32 0), i32 8, i32 1, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @9, i32 0, i32 0), i32* getelementptr inbounds ([1 x i32], [1 x i32]* @10, i32 0, i32 0), i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @8, i32 0, i32 0), i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.U$1$3", i32 0, i32 0), i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.U$1$3", i32 0, i32 1) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([20 x i8], [20 x i8]* @12, i32 0, i32 0), i32 32, i32 3, i32* getelementptr inbounds ([3 x i32], [3 x i32]* @14, i32 0, i32 0), i32* getelementptr inbounds ([3 x i32], [3 x i32]* @15, i32 0, i32 0), i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @13, i32 0, i32 0), i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 0), i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([20 x i8], [20 x i8]* @19, i32 0, i32 0), i32 8, i32 2, i32* getelementptr inbounds ([2 x i32], [2 x i32]* @21, i32 0, i32 0), i32* getelementptr inbounds ([2 x i32], [2 x i32]* @22, i32 0, i32 0), i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @20, i32 0, i32 0), i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$11$11", i32 0, i32 0), i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$11$11", i32 0, i32 2) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @25, i32 0, i32 0), i32 8, i32 1, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @27, i32 0, i32 0), i32* getelementptr inbounds ([1 x i32], [1 x i32]* @28, i32 0, i32 0), i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @26, i32 0, i32 0), i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.anon$1$3", i32 0, i32 0), i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.anon$1$3", i32 0, i32 1) }] ; CHECK-NEXT: @30 = internal global [5 x { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }] [{ i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([17 x i8], [17 x i8]* @1, i32 0, i32 0), i32 8, i32 2, i32* getelementptr inbounds ([2 x i32], [2 x i32]* @3, i32 0, i32 0), i32* getelementptr inbounds ([2 x i32], [2 x i32]* @4, i32 0, i32 0), i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @2, i32 0, i32 0), i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$13$13", i32 0, i32 0), i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$13$13", i32 0, i32 2) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([12 x i8], [12 x i8]* @7, i32 0, i32 0), i32 8, i32 1, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @9, i32 0, i32 0), i32* getelementptr inbounds ([1 x i32], [1 x i32]* @10, i32 0, i32 0), i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @8, i32 0, i32 0), i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.U$1$3", i32 0, i32 0), i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.U$1$3", i32 0, i32 1) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([20 x i8], [20 x i8]* @12, i32 0, i32 0), i32 32, i32 3, i32* getelementptr inbounds ([3 x i32], [3 x i32]* @14, i32 0, i32 0), i32* getelementptr inbounds ([3 x i32], [3 x i32]* @15, i32 0, i32 0), i8** getelementptr inbounds ([3 x i8*], [3 x i8*]* @13, i32 0, i32 0), i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 0), i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([20 x i8], [20 x i8]* @19, i32 0, i32 0), i32 8, i32 2, i32* getelementptr inbounds ([2 x i32], [2 x i32]* @21, i32 0, i32 0), i32* getelementptr inbounds ([2 x i32], [2 x i32]* @22, i32 0, i32 0), i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @20, i32 0, i32 0), i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$13$13", i32 0, i32 0), i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$13$13", i32 0, i32 2) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @25, i32 0, i32 0), i32 8, i32 1, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @27, i32 0, i32 0), i32* getelementptr inbounds ([1 x i32], [1 x i32]* @28, i32 0, i32 0), i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @26, i32 0, i32 0), i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.anon$1$3", i32 0, i32 0), i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.anon$1$3", i32 0, i32 1) }]
; CHECK-NEXT: @31 = internal constant { i8*, i32, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* } { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @0, i32 0, i32 0), i32 5, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* getelementptr inbounds ([5 x { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }], [5 x { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }]* @30, i32 0, i32 0) } ; CHECK-NEXT: @31 = internal constant { i8*, i32, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* } { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @0, i32 0, i32 0), i32 5, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* getelementptr inbounds ([5 x { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }], [5 x { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }]* @30, i32 0, i32 0) }
define i32 @main() { define i32 @main() {
entry: entry:
%a = alloca %struct.A, align 4 %a = alloca %struct.A, align 4
%u = alloca %union.U, align 8 %u = alloca %union.U, align 8
%c = alloca [2 x %struct.C], align 16 %c = alloca [2 x %struct.C], align 16
%k = alloca %struct.A*, align 8 %k = alloca %struct.A*, align 8
Show All 23 Lines
; CHECK: @llvm.global_ctors = {{.*}}@esan.module_ctor ; CHECK: @llvm.global_ctors = {{.*}}@esan.module_ctor
; CHECK: @llvm.global_dtors = {{.*}}@esan.module_dtor ; CHECK: @llvm.global_dtors = {{.*}}@esan.module_dtor
; CHECK: %a = alloca %struct.A, align 4 ; CHECK: %a = alloca %struct.A, align 4
; CHECK-NEXT: %u = alloca %union.U, align 8 ; CHECK-NEXT: %u = alloca %union.U, align 8
; CHECK-NEXT: %c = alloca [2 x %struct.C], align 16 ; CHECK-NEXT: %c = alloca [2 x %struct.C], align 16
; CHECK-NEXT: %k = alloca %struct.A*, align 8 ; CHECK-NEXT: %k = alloca %struct.A*, align 8
; CHECK-NEXT: %0 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$11$11", i32 0, i32 0) ; CHECK-NEXT: %0 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$13$13", i32 0, i32 0)
; CHECK-NEXT: %1 = add i64 %0, 1 ; CHECK-NEXT: %1 = add i64 %0, 1
; CHECK-NEXT: store i64 %1, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$11$11", i32 0, i32 0) ; CHECK-NEXT: store i64 %1, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$13$13", i32 0, i32 0)
; CHECK-NEXT: %x = getelementptr inbounds %struct.A, %struct.A* %a, i32 0, i32 0 ; CHECK-NEXT: %x = getelementptr inbounds %struct.A, %struct.A* %a, i32 0, i32 0
; CHECK-NEXT: %2 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$11$11", i32 0, i32 1) ; CHECK-NEXT: %2 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$13$13", i32 0, i32 1)
; CHECK-NEXT: %3 = add i64 %2, 1 ; CHECK-NEXT: %3 = add i64 %2, 1
; CHECK-NEXT: store i64 %3, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$11$11", i32 0, i32 1) ; CHECK-NEXT: store i64 %3, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$13$13", i32 0, i32 1)
; CHECK-NEXT: %y = getelementptr inbounds %struct.A, %struct.A* %a, i32 0, i32 1 ; CHECK-NEXT: %y = getelementptr inbounds %struct.A, %struct.A* %a, i32 0, i32 1
; CHECK-NEXT: %f = bitcast %union.U* %u to float* ; CHECK-NEXT: %f = bitcast %union.U* %u to float*
; CHECK-NEXT: %d = bitcast %union.U* %u to double* ; CHECK-NEXT: %d = bitcast %union.U* %u to double*
; CHECK-NEXT: %4 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: %4 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %5 = add i64 %4, 1 ; CHECK-NEXT: %5 = add i64 %4, 1
; CHECK-NEXT: store i64 %5, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: store i64 %5, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %arrayidx = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 0 ; CHECK-NEXT: %arrayidx = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 0
; CHECK-NEXT: %6 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 0) ; CHECK-NEXT: %6 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 0)
; CHECK-NEXT: %7 = add i64 %6, 1 ; CHECK-NEXT: %7 = add i64 %6, 1
; CHECK-NEXT: store i64 %7, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 0) ; CHECK-NEXT: store i64 %7, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 0)
; CHECK-NEXT: %cs = getelementptr inbounds %struct.C, %struct.C* %arrayidx, i32 0, i32 0 ; CHECK-NEXT: %cs = getelementptr inbounds %struct.C, %struct.C* %arrayidx, i32 0, i32 0
; CHECK-NEXT: %8 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$11$11", i32 0, i32 0) ; CHECK-NEXT: %8 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$13$13", i32 0, i32 0)
; CHECK-NEXT: %9 = add i64 %8, 1 ; CHECK-NEXT: %9 = add i64 %8, 1
; CHECK-NEXT: store i64 %9, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$11$11", i32 0, i32 0) ; CHECK-NEXT: store i64 %9, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$13$13", i32 0, i32 0)
; CHECK-NEXT: %x1 = getelementptr inbounds %struct.anon, %struct.anon* %cs, i32 0, i32 0 ; CHECK-NEXT: %x1 = getelementptr inbounds %struct.anon, %struct.anon* %cs, i32 0, i32 0
; CHECK-NEXT: %10 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: %10 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %11 = add i64 %10, 1 ; CHECK-NEXT: %11 = add i64 %10, 1
; CHECK-NEXT: store i64 %11, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: store i64 %11, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %arrayidx2 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 1 ; CHECK-NEXT: %arrayidx2 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 1
; CHECK-NEXT: %12 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 0) ; CHECK-NEXT: %12 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 0)
; CHECK-NEXT: %13 = add i64 %12, 1 ; CHECK-NEXT: %13 = add i64 %12, 1
; CHECK-NEXT: store i64 %13, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 0) ; CHECK-NEXT: store i64 %13, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 0)
; CHECK-NEXT: %cs3 = getelementptr inbounds %struct.C, %struct.C* %arrayidx2, i32 0, i32 0 ; CHECK-NEXT: %cs3 = getelementptr inbounds %struct.C, %struct.C* %arrayidx2, i32 0, i32 0
; CHECK-NEXT: %14 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$11$11", i32 0, i32 1) ; CHECK-NEXT: %14 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$13$13", i32 0, i32 1)
; CHECK-NEXT: %15 = add i64 %14, 1 ; CHECK-NEXT: %15 = add i64 %14, 1
; CHECK-NEXT: store i64 %15, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$11$11", i32 0, i32 1) ; CHECK-NEXT: store i64 %15, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$13$13", i32 0, i32 1)
; CHECK-NEXT: %y4 = getelementptr inbounds %struct.anon, %struct.anon* %cs3, i32 0, i32 1 ; CHECK-NEXT: %y4 = getelementptr inbounds %struct.anon, %struct.anon* %cs3, i32 0, i32 1
; CHECK-NEXT: %16 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: %16 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %17 = add i64 %16, 1 ; CHECK-NEXT: %17 = add i64 %16, 1
; CHECK-NEXT: store i64 %17, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: store i64 %17, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %arrayidx5 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 0 ; CHECK-NEXT: %arrayidx5 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 0
; CHECK-NEXT: %18 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 1) ; CHECK-NEXT: %18 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 1)
; CHECK-NEXT: %19 = add i64 %18, 1 ; CHECK-NEXT: %19 = add i64 %18, 1
; CHECK-NEXT: store i64 %19, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 1) ; CHECK-NEXT: store i64 %19, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 1)
; CHECK-NEXT: %cu = getelementptr inbounds %struct.C, %struct.C* %arrayidx5, i32 0, i32 1 ; CHECK-NEXT: %cu = getelementptr inbounds %struct.C, %struct.C* %arrayidx5, i32 0, i32 1
; CHECK-NEXT: %f6 = bitcast %union.anon* %cu to float* ; CHECK-NEXT: %f6 = bitcast %union.anon* %cu to float*
; CHECK-NEXT: %20 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: %20 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %21 = add i64 %20, 1 ; CHECK-NEXT: %21 = add i64 %20, 1
; CHECK-NEXT: store i64 %21, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: store i64 %21, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %arrayidx7 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 1 ; CHECK-NEXT: %arrayidx7 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 1
; CHECK-NEXT: %22 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 1) ; CHECK-NEXT: %22 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 1)
; CHECK-NEXT: %23 = add i64 %22, 1 ; CHECK-NEXT: %23 = add i64 %22, 1
; CHECK-NEXT: store i64 %23, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 1) ; CHECK-NEXT: store i64 %23, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 1)
; CHECK-NEXT: %cu8 = getelementptr inbounds %struct.C, %struct.C* %arrayidx7, i32 0, i32 1 ; CHECK-NEXT: %cu8 = getelementptr inbounds %struct.C, %struct.C* %arrayidx7, i32 0, i32 1
; CHECK-NEXT: %d9 = bitcast %union.anon* %cu8 to double* ; CHECK-NEXT: %d9 = bitcast %union.anon* %cu8 to double*
; CHECK-NEXT: %24 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: %24 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %25 = add i64 %24, 1 ; CHECK-NEXT: %25 = add i64 %24, 1
; CHECK-NEXT: store i64 %25, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: store i64 %25, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %arrayidx10 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 0 ; CHECK-NEXT: %arrayidx10 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 0
; CHECK-NEXT: %26 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 2) ; CHECK-NEXT: %26 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 2)
; CHECK-NEXT: %27 = add i64 %26, 1 ; CHECK-NEXT: %27 = add i64 %26, 1
; CHECK-NEXT: store i64 %27, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 2) ; CHECK-NEXT: store i64 %27, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 2)
; CHECK-NEXT: %c11 = getelementptr inbounds %struct.C, %struct.C* %arrayidx10, i32 0, i32 2 ; CHECK-NEXT: %c11 = getelementptr inbounds %struct.C, %struct.C* %arrayidx10, i32 0, i32 2
; CHECK-NEXT: %arrayidx12 = getelementptr inbounds [10 x i8], [10 x i8]* %c11, i64 0, i64 2 ; CHECK-NEXT: %arrayidx12 = getelementptr inbounds [10 x i8], [10 x i8]* %c11, i64 0, i64 2
; CHECK-NEXT: %k1 = load %struct.A*, %struct.A** %k, align 8 ; CHECK-NEXT: %k1 = load %struct.A*, %struct.A** %k, align 8
; CHECK-NEXT: %arrayidx13 = getelementptr inbounds %struct.A, %struct.A* %k1, i64 0 ; CHECK-NEXT: %arrayidx13 = getelementptr inbounds %struct.A, %struct.A* %k1, i64 0
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Top-level: ; Top-level:
; CHECK: define internal void @esan.module_ctor() ; CHECK: define internal void @esan.module_ctor()
; CHECK: call void @__esan_init(i32 1, i8* bitcast ({ i8*, i32, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* }* @31 to i8*)) ; CHECK: call void @__esan_init(i32 1, i8* bitcast ({ i8*, i32, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* }* @31 to i8*))
; CHECK: define internal void @esan.module_dtor() ; CHECK: define internal void @esan.module_dtor()
; CHECK: call void @__esan_exit(i8* bitcast ({ i8*, i32, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* }* @31 to i8*)) ; CHECK: call void @__esan_exit(i8* bitcast ({ i8*, i32, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* }* @31 to i8*))

test/Instrumentation/EfficiencySanitizer/struct_field_gep.ll

Show All 22 Lines
%struct.ST = type { i32, double, %struct.RT } %struct.ST = type { i32, double, %struct.RT }
define i32* @foo(%struct.ST* %s) nounwind uwtable readnone optsize ssp { define i32* @foo(%struct.ST* %s) nounwind uwtable readnone optsize ssp {
entry: entry:
%arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13 %arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
ret i32* %arrayidx ret i32* %arrayidx
} }
; CHECK: %0 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.ST$3$13$3$11", i32 0, i32 3) ; CHECK: %0 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.ST$3$15$3$13", i32 0, i32 3)
; CHECK-NEXT: %1 = add i64 %0, 1 ; CHECK-NEXT: %1 = add i64 %0, 1
; CHECK-NEXT: store i64 %1, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.ST$3$13$3$11", i32 0, i32 3) ; CHECK-NEXT: store i64 %1, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.ST$3$15$3$13", i32 0, i32 3)
; CHECK-NEXT: %2 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.ST$3$13$3$11", i32 0, i32 2) ; CHECK-NEXT: %2 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.ST$3$15$3$13", i32 0, i32 2)
; CHECK-NEXT: %3 = add i64 %2, 1 ; CHECK-NEXT: %3 = add i64 %2, 1
; CHECK-NEXT: store i64 %3, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.ST$3$13$3$11", i32 0, i32 2) ; CHECK-NEXT: store i64 %3, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.ST$3$15$3$13", i32 0, i32 2)
; CHECK-NEXT: %4 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.RT$3$11$14$11", i32 0, i32 1) ; CHECK-NEXT: %4 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.RT$3$13$16$13", i32 0, i32 1)
; CHECK-NEXT: %5 = add i64 %4, 1 ; CHECK-NEXT: %5 = add i64 %4, 1
; CHECK-NEXT: store i64 %5, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.RT$3$11$14$11", i32 0, i32 1) ; CHECK-NEXT: store i64 %5, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.RT$3$13$16$13", i32 0, i32 1)
; CHECK-NEXT: %arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13 ; CHECK-NEXT: %arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
; CHECK-NEXT: ret i32* %arrayidx ; CHECK-NEXT: ret i32* %arrayidx

test/Instrumentation/EfficiencySanitizer/struct_field_small.ll

; Test basic EfficiencySanitizer struct field count instrumentation with -esan-small-binary ; Test basic EfficiencySanitizer struct field count instrumentation with -esan-small-binary
; ;
; RUN: opt < %s -esan -esan-cache-frag -esan-aux-field-info=false -S | FileCheck %s ; RUN: opt < %s -esan -esan-cache-frag -esan-aux-field-info=false -S | FileCheck %s
%struct.A = type { i32, i32 } %struct.A = type { i32, i32 }
%union.U = type { double } %union.U = type { double }
%struct.C = type { %struct.anon, %union.anon, [10 x i8] } %struct.C = type { %struct.anon, %union.anon, [10 x i8] }
%struct.anon = type { i32, i32 } %struct.anon = type { i32, i32 }
%union.anon = type { double } %union.anon = type { double }
; CHECK: @0 = private unnamed_addr constant [8 x i8] c"<stdin>\00", align 1 ; CHECK: @0 = private unnamed_addr constant [8 x i8] c"<stdin>\00", align 1
; CHECK-NEXT: @1 = private unnamed_addr constant [17 x i8] c"struct.A$2$11$11\00", align 1 ; CHECK-NEXT: @1 = private unnamed_addr constant [17 x i8] c"struct.A$2$13$13\00", align 1
; CHECK-NEXT: @"struct.A$2$11$11" = weak global [3 x i64] zeroinitializer ; CHECK-NEXT: @"struct.A$2$13$13" = weak global [3 x i64] zeroinitializer
; CHECK-NEXT: @2 = private unnamed_addr constant [12 x i8] c"union.U$1$3\00", align 1 ; CHECK-NEXT: @2 = private unnamed_addr constant [12 x i8] c"union.U$1$3\00", align 1
; CHECK-NEXT: @"union.U$1$3" = weak global [2 x i64] zeroinitializer ; CHECK-NEXT: @"union.U$1$3" = weak global [2 x i64] zeroinitializer
; CHECK-NEXT: @3 = private unnamed_addr constant [20 x i8] c"struct.C$3$14$13$13\00", align 1 ; CHECK-NEXT: @3 = private unnamed_addr constant [20 x i8] c"struct.C$3$16$15$15\00", align 1
; CHECK-NEXT: @"struct.C$3$14$13$13" = weak global [4 x i64] zeroinitializer ; CHECK-NEXT: @"struct.C$3$16$15$15" = weak global [4 x i64] zeroinitializer
; CHECK-NEXT: @4 = private unnamed_addr constant [20 x i8] c"struct.anon$2$11$11\00", align 1 ; CHECK-NEXT: @4 = private unnamed_addr constant [20 x i8] c"struct.anon$2$13$13\00", align 1
; CHECK-NEXT: @"struct.anon$2$11$11" = weak global [3 x i64] zeroinitializer ; CHECK-NEXT: @"struct.anon$2$13$13" = weak global [3 x i64] zeroinitializer
; CHECK-NEXT: @5 = private unnamed_addr constant [15 x i8] c"union.anon$1$3\00", align 1 ; CHECK-NEXT: @5 = private unnamed_addr constant [15 x i8] c"union.anon$1$3\00", align 1
; CHECK-NEXT: @"union.anon$1$3" = weak global [2 x i64] zeroinitializer ; CHECK-NEXT: @"union.anon$1$3" = weak global [2 x i64] zeroinitializer
; CHECK-NEXT: @6 = internal global [5 x { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }] [{ i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([17 x i8], [17 x i8]* @1, i32 0, i32 0), i32 8, i32 2, i32* null, i32* null, i8** null, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$11$11", i32 0, i32 0), i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$11$11", i32 0, i32 2) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([12 x i8], [12 x i8]* @2, i32 0, i32 0), i32 8, i32 1, i32* null, i32* null, i8** null, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.U$1$3", i32 0, i32 0), i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.U$1$3", i32 0, i32 1) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([20 x i8], [20 x i8]* @3, i32 0, i32 0), i32 32, i32 3, i32* null, i32* null, i8** null, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 0), i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([20 x i8], [20 x i8]* @4, i32 0, i32 0), i32 8, i32 2, i32* null, i32* null, i8** null, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$11$11", i32 0, i32 0), i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$11$11", i32 0, i32 2) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @5, i32 0, i32 0), i32 8, i32 1, i32* null, i32* null, i8** null, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.anon$1$3", i32 0, i32 0), i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.anon$1$3", i32 0, i32 1) }] ; CHECK-NEXT: @6 = internal global [5 x { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }] [{ i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([17 x i8], [17 x i8]* @1, i32 0, i32 0), i32 8, i32 2, i32* null, i32* null, i8** null, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$13$13", i32 0, i32 0), i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$13$13", i32 0, i32 2) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([12 x i8], [12 x i8]* @2, i32 0, i32 0), i32 8, i32 1, i32* null, i32* null, i8** null, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.U$1$3", i32 0, i32 0), i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.U$1$3", i32 0, i32 1) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([20 x i8], [20 x i8]* @3, i32 0, i32 0), i32 32, i32 3, i32* null, i32* null, i8** null, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 0), i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([20 x i8], [20 x i8]* @4, i32 0, i32 0), i32 8, i32 2, i32* null, i32* null, i8** null, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$13$13", i32 0, i32 0), i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$13$13", i32 0, i32 2) }, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* } { i8* getelementptr inbounds ([15 x i8], [15 x i8]* @5, i32 0, i32 0), i32 8, i32 1, i32* null, i32* null, i8** null, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.anon$1$3", i32 0, i32 0), i64* getelementptr inbounds ([2 x i64], [2 x i64]* @"union.anon$1$3", i32 0, i32 1) }]
; CHECK-NEXT: @7 = internal constant { i8*, i32, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* } { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @0, i32 0, i32 0), i32 5, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* getelementptr inbounds ([5 x { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }], [5 x { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }]* @6, i32 0, i32 0) } ; CHECK-NEXT: @7 = internal constant { i8*, i32, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* } { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @0, i32 0, i32 0), i32 5, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* getelementptr inbounds ([5 x { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }], [5 x { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }]* @6, i32 0, i32 0) }
define i32 @main() { define i32 @main() {
entry: entry:
%a = alloca %struct.A, align 4 %a = alloca %struct.A, align 4
%u = alloca %union.U, align 8 %u = alloca %union.U, align 8
%c = alloca [2 x %struct.C], align 16 %c = alloca [2 x %struct.C], align 16
%k = alloca %struct.A*, align 8 %k = alloca %struct.A*, align 8
Show All 23 Lines
; CHECK: @llvm.global_ctors = {{.*}}@esan.module_ctor ; CHECK: @llvm.global_ctors = {{.*}}@esan.module_ctor
; CHECK: @llvm.global_dtors = {{.*}}@esan.module_dtor ; CHECK: @llvm.global_dtors = {{.*}}@esan.module_dtor
; CHECK: %a = alloca %struct.A, align 4 ; CHECK: %a = alloca %struct.A, align 4
; CHECK-NEXT: %u = alloca %union.U, align 8 ; CHECK-NEXT: %u = alloca %union.U, align 8
; CHECK-NEXT: %c = alloca [2 x %struct.C], align 16 ; CHECK-NEXT: %c = alloca [2 x %struct.C], align 16
; CHECK-NEXT: %k = alloca %struct.A*, align 8 ; CHECK-NEXT: %k = alloca %struct.A*, align 8
; CHECK-NEXT: %0 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$11$11", i32 0, i32 0) ; CHECK-NEXT: %0 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$13$13", i32 0, i32 0)
; CHECK-NEXT: %1 = add i64 %0, 1 ; CHECK-NEXT: %1 = add i64 %0, 1
; CHECK-NEXT: store i64 %1, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$11$11", i32 0, i32 0) ; CHECK-NEXT: store i64 %1, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$13$13", i32 0, i32 0)
; CHECK-NEXT: %x = getelementptr inbounds %struct.A, %struct.A* %a, i32 0, i32 0 ; CHECK-NEXT: %x = getelementptr inbounds %struct.A, %struct.A* %a, i32 0, i32 0
; CHECK-NEXT: %2 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$11$11", i32 0, i32 1) ; CHECK-NEXT: %2 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$13$13", i32 0, i32 1)
; CHECK-NEXT: %3 = add i64 %2, 1 ; CHECK-NEXT: %3 = add i64 %2, 1
; CHECK-NEXT: store i64 %3, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$11$11", i32 0, i32 1) ; CHECK-NEXT: store i64 %3, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.A$2$13$13", i32 0, i32 1)
; CHECK-NEXT: %y = getelementptr inbounds %struct.A, %struct.A* %a, i32 0, i32 1 ; CHECK-NEXT: %y = getelementptr inbounds %struct.A, %struct.A* %a, i32 0, i32 1
; CHECK-NEXT: %f = bitcast %union.U* %u to float* ; CHECK-NEXT: %f = bitcast %union.U* %u to float*
; CHECK-NEXT: %d = bitcast %union.U* %u to double* ; CHECK-NEXT: %d = bitcast %union.U* %u to double*
; CHECK-NEXT: %4 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: %4 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %5 = add i64 %4, 1 ; CHECK-NEXT: %5 = add i64 %4, 1
; CHECK-NEXT: store i64 %5, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: store i64 %5, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %arrayidx = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 0 ; CHECK-NEXT: %arrayidx = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 0
; CHECK-NEXT: %6 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 0) ; CHECK-NEXT: %6 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 0)
; CHECK-NEXT: %7 = add i64 %6, 1 ; CHECK-NEXT: %7 = add i64 %6, 1
; CHECK-NEXT: store i64 %7, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 0) ; CHECK-NEXT: store i64 %7, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 0)
; CHECK-NEXT: %cs = getelementptr inbounds %struct.C, %struct.C* %arrayidx, i32 0, i32 0 ; CHECK-NEXT: %cs = getelementptr inbounds %struct.C, %struct.C* %arrayidx, i32 0, i32 0
; CHECK-NEXT: %8 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$11$11", i32 0, i32 0) ; CHECK-NEXT: %8 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$13$13", i32 0, i32 0)
; CHECK-NEXT: %9 = add i64 %8, 1 ; CHECK-NEXT: %9 = add i64 %8, 1
; CHECK-NEXT: store i64 %9, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$11$11", i32 0, i32 0) ; CHECK-NEXT: store i64 %9, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$13$13", i32 0, i32 0)
; CHECK-NEXT: %x1 = getelementptr inbounds %struct.anon, %struct.anon* %cs, i32 0, i32 0 ; CHECK-NEXT: %x1 = getelementptr inbounds %struct.anon, %struct.anon* %cs, i32 0, i32 0
; CHECK-NEXT: %10 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: %10 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %11 = add i64 %10, 1 ; CHECK-NEXT: %11 = add i64 %10, 1
; CHECK-NEXT: store i64 %11, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: store i64 %11, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %arrayidx2 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 1 ; CHECK-NEXT: %arrayidx2 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 1
; CHECK-NEXT: %12 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 0) ; CHECK-NEXT: %12 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 0)
; CHECK-NEXT: %13 = add i64 %12, 1 ; CHECK-NEXT: %13 = add i64 %12, 1
; CHECK-NEXT: store i64 %13, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 0) ; CHECK-NEXT: store i64 %13, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 0)
; CHECK-NEXT: %cs3 = getelementptr inbounds %struct.C, %struct.C* %arrayidx2, i32 0, i32 0 ; CHECK-NEXT: %cs3 = getelementptr inbounds %struct.C, %struct.C* %arrayidx2, i32 0, i32 0
; CHECK-NEXT: %14 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$11$11", i32 0, i32 1) ; CHECK-NEXT: %14 = load i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$13$13", i32 0, i32 1)
; CHECK-NEXT: %15 = add i64 %14, 1 ; CHECK-NEXT: %15 = add i64 %14, 1
; CHECK-NEXT: store i64 %15, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$11$11", i32 0, i32 1) ; CHECK-NEXT: store i64 %15, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @"struct.anon$2$13$13", i32 0, i32 1)
; CHECK-NEXT: %y4 = getelementptr inbounds %struct.anon, %struct.anon* %cs3, i32 0, i32 1 ; CHECK-NEXT: %y4 = getelementptr inbounds %struct.anon, %struct.anon* %cs3, i32 0, i32 1
; CHECK-NEXT: %16 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: %16 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %17 = add i64 %16, 1 ; CHECK-NEXT: %17 = add i64 %16, 1
; CHECK-NEXT: store i64 %17, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: store i64 %17, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %arrayidx5 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 0 ; CHECK-NEXT: %arrayidx5 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 0
; CHECK-NEXT: %18 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 1) ; CHECK-NEXT: %18 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 1)
; CHECK-NEXT: %19 = add i64 %18, 1 ; CHECK-NEXT: %19 = add i64 %18, 1
; CHECK-NEXT: store i64 %19, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 1) ; CHECK-NEXT: store i64 %19, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 1)
; CHECK-NEXT: %cu = getelementptr inbounds %struct.C, %struct.C* %arrayidx5, i32 0, i32 1 ; CHECK-NEXT: %cu = getelementptr inbounds %struct.C, %struct.C* %arrayidx5, i32 0, i32 1
; CHECK-NEXT: %f6 = bitcast %union.anon* %cu to float* ; CHECK-NEXT: %f6 = bitcast %union.anon* %cu to float*
; CHECK-NEXT: %20 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: %20 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %21 = add i64 %20, 1 ; CHECK-NEXT: %21 = add i64 %20, 1
; CHECK-NEXT: store i64 %21, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: store i64 %21, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %arrayidx7 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 1 ; CHECK-NEXT: %arrayidx7 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 1
; CHECK-NEXT: %22 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 1) ; CHECK-NEXT: %22 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 1)
; CHECK-NEXT: %23 = add i64 %22, 1 ; CHECK-NEXT: %23 = add i64 %22, 1
; CHECK-NEXT: store i64 %23, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 1) ; CHECK-NEXT: store i64 %23, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 1)
; CHECK-NEXT: %cu8 = getelementptr inbounds %struct.C, %struct.C* %arrayidx7, i32 0, i32 1 ; CHECK-NEXT: %cu8 = getelementptr inbounds %struct.C, %struct.C* %arrayidx7, i32 0, i32 1
; CHECK-NEXT: %d9 = bitcast %union.anon* %cu8 to double* ; CHECK-NEXT: %d9 = bitcast %union.anon* %cu8 to double*
; CHECK-NEXT: %24 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: %24 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %25 = add i64 %24, 1 ; CHECK-NEXT: %25 = add i64 %24, 1
; CHECK-NEXT: store i64 %25, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 3) ; CHECK-NEXT: store i64 %25, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 3)
; CHECK-NEXT: %arrayidx10 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 0 ; CHECK-NEXT: %arrayidx10 = getelementptr inbounds [2 x %struct.C], [2 x %struct.C]* %c, i64 0, i64 0
; CHECK-NEXT: %26 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 2) ; CHECK-NEXT: %26 = load i64, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 2)
; CHECK-NEXT: %27 = add i64 %26, 1 ; CHECK-NEXT: %27 = add i64 %26, 1
; CHECK-NEXT: store i64 %27, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$14$13$13", i32 0, i32 2) ; CHECK-NEXT: store i64 %27, i64* getelementptr inbounds ([4 x i64], [4 x i64]* @"struct.C$3$16$15$15", i32 0, i32 2)
; CHECK-NEXT: %c11 = getelementptr inbounds %struct.C, %struct.C* %arrayidx10, i32 0, i32 2 ; CHECK-NEXT: %c11 = getelementptr inbounds %struct.C, %struct.C* %arrayidx10, i32 0, i32 2
; CHECK-NEXT: %arrayidx12 = getelementptr inbounds [10 x i8], [10 x i8]* %c11, i64 0, i64 2 ; CHECK-NEXT: %arrayidx12 = getelementptr inbounds [10 x i8], [10 x i8]* %c11, i64 0, i64 2
; CHECK-NEXT: %k1 = load %struct.A*, %struct.A** %k, align 8 ; CHECK-NEXT: %k1 = load %struct.A*, %struct.A** %k, align 8
; CHECK-NEXT: %arrayidx13 = getelementptr inbounds %struct.A, %struct.A* %k1, i64 0 ; CHECK-NEXT: %arrayidx13 = getelementptr inbounds %struct.A, %struct.A* %k1, i64 0
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Top-level: ; Top-level:
; CHECK: define internal void @esan.module_ctor() ; CHECK: define internal void @esan.module_ctor()
; CHECK: call void @__esan_init(i32 1, i8* bitcast ({ i8*, i32, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* }* @7 to i8*)) ; CHECK: call void @__esan_init(i32 1, i8* bitcast ({ i8*, i32, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* }* @7 to i8*))
; CHECK: define internal void @esan.module_dtor() ; CHECK: define internal void @esan.module_dtor()
; CHECK: call void @__esan_exit(i8* bitcast ({ i8*, i32, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* }* @7 to i8*)) ; CHECK: call void @__esan_exit(i8* bitcast ({ i8*, i32, { i8*, i32, i32, i32*, i32*, i8**, i64*, i64* }* }* @7 to i8*))

test/TableGen/intrinsic-varargs.td

Show All 19 Linesclass Intrinsic<string name, list<LLVMType> param_types = []> {
string TargetPrefix = ""; string TargetPrefix = "";
list<LLVMType> RetTypes = []; list<LLVMType> RetTypes = [];
list<LLVMType> ParamTypes = param_types; list<LLVMType> ParamTypes = param_types;
list<IntrinsicProperty> IntrProperties = []; list<IntrinsicProperty> IntrProperties = [];
list<SDNodeProperty> Properties = []; list<SDNodeProperty> Properties = [];
} }
// isVoid needs to match the definition in ValueTypes.td // isVoid needs to match the definition in ValueTypes.td
def isVoid : ValueType<0, 111>; // Produces no value def isVoid : ValueType<0, 113>; // Produces no value
def llvm_vararg_ty : LLVMType<isVoid>; // this means vararg here def llvm_vararg_ty : LLVMType<isVoid>; // this means vararg here
// CHECK: /* 0 */ 0, 29, 0, // CHECK: /* 0 */ 0, 29, 0,
def int_foo : Intrinsic<"llvm.foo", [llvm_vararg_ty]>; def int_foo : Intrinsic<"llvm.foo", [llvm_vararg_ty]>;

tools/llvm-stress/llvm-stress.cpp

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Linespublic:
// Parse options as IR types. Return true on error. // Parse options as IR types. Return true on error.
bool parse(Option &O, StringRef, StringRef Arg, Type *&Value) { bool parse(Option &O, StringRef, StringRef Arg, Type *&Value) {
if (Arg == "half") Value = Type::getHalfTy(Context); if (Arg == "half") Value = Type::getHalfTy(Context);
else if (Arg == "fp128") Value = Type::getFP128Ty(Context); else if (Arg == "fp128") Value = Type::getFP128Ty(Context);
else if (Arg == "x86_fp80") Value = Type::getX86_FP80Ty(Context); else if (Arg == "x86_fp80") Value = Type::getX86_FP80Ty(Context);
else if (Arg == "ppc_fp128") Value = Type::getPPC_FP128Ty(Context); else if (Arg == "ppc_fp128") Value = Type::getPPC_FP128Ty(Context);
else if (Arg == "x86_mmx") Value = Type::getX86_MMXTy(Context); else if (Arg == "x86_mmx") Value = Type::getX86_MMXTy(Context);
else if (Arg == "arm_sve") Value = Type::getArm_SVETy(Context);
else if (Arg == "arm_sve_pred") Value = Type::getArm_SVEPredTy(Context);
else if (Arg.startswith("i")) { else if (Arg.startswith("i")) {
unsigned N = 0; unsigned N = 0;
Arg.drop_front().getAsInteger(10, N); Arg.drop_front().getAsInteger(10, N);
if (N > 0) if (N > 0)
Value = Type::getIntNTy(Context, N); Value = Type::getIntNTy(Context, N);
} }
if (!Value) if (!Value)
▲ Show 20 Lines • Show All 679 Lines • Show Last 20 Lines

utils/TableGen/CodeGenTarget.cpp

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 LinesStringRef llvm::getEnumName(MVT::SimpleValueType T) {
case MVT::vAny: return "MVT::vAny"; case MVT::vAny: return "MVT::vAny";
case MVT::f16: return "MVT::f16"; case MVT::f16: return "MVT::f16";
case MVT::f32: return "MVT::f32"; case MVT::f32: return "MVT::f32";
case MVT::f64: return "MVT::f64"; case MVT::f64: return "MVT::f64";
case MVT::f80: return "MVT::f80"; case MVT::f80: return "MVT::f80";
case MVT::f128: return "MVT::f128"; case MVT::f128: return "MVT::f128";
case MVT::ppcf128: return "MVT::ppcf128"; case MVT::ppcf128: return "MVT::ppcf128";
case MVT::x86mmx: return "MVT::x86mmx"; case MVT::x86mmx: return "MVT::x86mmx";
case MVT::armsve: return "MVT::armsve";
case MVT::armsvepred: return "MVT::armsvepred";
case MVT::Glue: return "MVT::Glue"; case MVT::Glue: return "MVT::Glue";
case MVT::isVoid: return "MVT::isVoid"; case MVT::isVoid: return "MVT::isVoid";
case MVT::v1i1: return "MVT::v1i1"; case MVT::v1i1: return "MVT::v1i1";
case MVT::v2i1: return "MVT::v2i1"; case MVT::v2i1: return "MVT::v2i1";
case MVT::v4i1: return "MVT::v4i1"; case MVT::v4i1: return "MVT::v4i1";
case MVT::v8i1: return "MVT::v8i1"; case MVT::v8i1: return "MVT::v8i1";
case MVT::v16i1: return "MVT::v16i1"; case MVT::v16i1: return "MVT::v16i1";
case MVT::v32i1: return "MVT::v32i1"; case MVT::v32i1: return "MVT::v32i1";
▲ Show 20 Lines • Show All 642 Lines • Show Last 20 Lines

utils/TableGen/IntrinsicEmitter.cpp

Show First 20 Lines • Show All 213 Lines • ▼ Show 20 Linesenum IIT_Info {
IIT_PTR_TO_ELT = 33, IIT_PTR_TO_ELT = 33,
IIT_VEC_OF_ANYPTRS_TO_ELT = 34, IIT_VEC_OF_ANYPTRS_TO_ELT = 34,
IIT_I128 = 35, IIT_I128 = 35,
IIT_V512 = 36, IIT_V512 = 36,
IIT_V1024 = 37, IIT_V1024 = 37,
IIT_STRUCT6 = 38, IIT_STRUCT6 = 38,
IIT_STRUCT7 = 39, IIT_STRUCT7 = 39,
IIT_STRUCT8 = 40, IIT_STRUCT8 = 40,
IIT_F128 = 41 IIT_F128 = 41,
IIT_SVE = 42,
IIT_SVE_PRED = 43
}; };
static void EncodeFixedValueType(MVT::SimpleValueType VT, static void EncodeFixedValueType(MVT::SimpleValueType VT,
std::vector<unsigned char> &Sig) { std::vector<unsigned char> &Sig) {
if (MVT(VT).isInteger()) { if (MVT(VT).isInteger()) {
unsigned BitWidth = MVT(VT).getSizeInBits(); unsigned BitWidth = MVT(VT).getSizeInBits();
switch (BitWidth) { switch (BitWidth) {
default: PrintFatalError("unhandled integer type width in intrinsic!"); default: PrintFatalError("unhandled integer type width in intrinsic!");
Show All 10 Linesstatic void EncodeFixedValueType(MVT::SimpleValueType VT,
default: PrintFatalError("unhandled MVT in intrinsic!"); default: PrintFatalError("unhandled MVT in intrinsic!");
case MVT::f16: return Sig.push_back(IIT_F16); case MVT::f16: return Sig.push_back(IIT_F16);
case MVT::f32: return Sig.push_back(IIT_F32); case MVT::f32: return Sig.push_back(IIT_F32);
case MVT::f64: return Sig.push_back(IIT_F64); case MVT::f64: return Sig.push_back(IIT_F64);
case MVT::f128: return Sig.push_back(IIT_F128); case MVT::f128: return Sig.push_back(IIT_F128);
case MVT::token: return Sig.push_back(IIT_TOKEN); case MVT::token: return Sig.push_back(IIT_TOKEN);
case MVT::Metadata: return Sig.push_back(IIT_METADATA); case MVT::Metadata: return Sig.push_back(IIT_METADATA);
case MVT::x86mmx: return Sig.push_back(IIT_MMX); case MVT::x86mmx: return Sig.push_back(IIT_MMX);
case MVT::armsve: return Sig.push_back(IIT_SVE);
case MVT::armsvepred: return Sig.push_back(IIT_SVE_PRED);
// MVT::OtherVT is used to mean the empty struct type here. // MVT::OtherVT is used to mean the empty struct type here.
case MVT::Other: return Sig.push_back(IIT_EMPTYSTRUCT); case MVT::Other: return Sig.push_back(IIT_EMPTYSTRUCT);
// MVT::isVoid is used to represent varargs here. // MVT::isVoid is used to represent varargs here.
case MVT::isVoid: return Sig.push_back(IIT_VARARG); case MVT::isVoid: return Sig.push_back(IIT_VARARG);
} }
} }
#if defined(_MSC_VER) && !defined(__clang__) #if defined(_MSC_VER) && !defined(__clang__)
▲ Show 20 Lines • Show All 607 Lines • Show Last 20 Lines