42 "jump-is-expensive",
cl::init(
false),
43 cl::desc(
"Do not create extra branches to split comparison logic."),
681 #define OP_TO_LIBCALL(Name, Enum) \
683 switch (VT.SimpleTy) { \
685 return UNKNOWN_LIBCALL; \
756 UseUnderscoreSetJmp =
false;
757 UseUnderscoreLongJmp =
false;
758 SelectIsExpensive =
false;
759 HasMultipleConditionRegisters =
false;
760 HasExtractBitsInsn =
false;
761 IntDivIsCheap =
false;
762 FsqrtIsCheap =
false;
763 Pow2SDivIsCheap =
false;
768 HasFloatingPointExceptions =
true;
769 StackPointerRegisterToSaveRestore = 0;
770 ExceptionPointerRegister = 0;
771 ExceptionSelectorRegister = 0;
777 JumpBufAlignment = 0;
778 MinFunctionAlignment = 0;
779 PrefFunctionAlignment = 0;
780 PrefLoopAlignment = 0;
781 MinStackArgumentAlignment = 1;
782 InsertFencesForAtomic =
false;
783 MinimumJumpTableEntries = 4;
792 memset(OpActions, 0,
sizeof(OpActions));
793 memset(LoadExtActions, 0,
sizeof(LoadExtActions));
794 memset(TruncStoreActions, 0,
sizeof(TruncStoreActions));
795 memset(IndexedModeActions, 0,
sizeof(IndexedModeActions));
796 memset(CondCodeActions, 0,
sizeof(CondCodeActions));
798 memset(TargetDAGCombineArray, 0,
array_lengthof(TargetDAGCombineArray));
888 assert(LHSTy.
isInteger() &&
"Shift amount is not an integer type!");
914 JumpIsExpensive = isExpensive;
918 TargetLoweringBase::getTypeConversion(
LLVMContext &Context,
EVT VT)
const {
928 "Promote may not follow Expand or Promote");
941 assert(VT.
isInteger() &&
"Float types must be simple");
946 assert(NVT != VT &&
"Unable to round integer VT");
947 LegalizeKind NextStep = getTypeConversion(Context, NVT);
992 EVT OldEltVT = EltVT;
997 .getRoundIntegerType(Context);
1031 if (LargerVector ==
MVT())
1051 unsigned &NumIntermediates,
1058 unsigned NumVectorRegs = 1;
1063 NumVectorRegs = NumElts;
1071 NumVectorRegs <<= 1;
1074 NumIntermediates = NumVectorRegs;
1079 IntermediateVT = NewVT;
1088 RegisterVT = DestVT;
1089 if (
EVT(DestVT).bitsLT(NewVT))
1094 return NumVectorRegs;
1116 for(
unsigned OperIdx = 0; OperIdx != MI->
getNumOperands(); ++OperIdx) {
1127 for (
unsigned i = 0; i < OperIdx; ++i)
1139 assert(MIB->
mayLoad() &&
"Folded a stackmap use to a non-load!");
1143 assert(MFI.getObjectOffset(FI) != -1);
1170 std::pair<const TargetRegisterClass *, uint8_t>
1175 return std::make_pair(RC, 0);
1184 for (
int i = SuperRegRC.find_first(); i >= 0; i = SuperRegRC.find_next(i)) {
1193 return std::make_pair(BestRC, 1);
1201 "Too many value types for ValueTypeActions to hold!");
1205 NumRegistersForVT[i] = 1;
1213 for (; RegClassForVT[LargestIntReg] ==
nullptr; --LargestIntReg)
1214 assert(LargestIntReg !=
MVT::i1 &&
"No integer registers defined!");
1218 for (
unsigned ExpandedReg = LargestIntReg + 1;
1220 NumRegistersForVT[ExpandedReg] = 2*NumRegistersForVT[ExpandedReg-1];
1229 unsigned LegalIntReg = LargestIntReg;
1230 for (
unsigned IntReg = LargestIntReg - 1;
1234 LegalIntReg = IntReg;
1236 RegisterTypeForVT[IntReg] = TransformToType[IntReg] =
1302 bool IsLegalWiderType =
false;
1304 switch (PreferredAction) {
1315 TransformToType[i] = SVT;
1316 RegisterTypeForVT[i] = SVT;
1317 NumRegistersForVT[i] = 1;
1319 IsLegalWiderType =
true;
1323 if (IsLegalWiderType)
1332 TransformToType[i] = SVT;
1333 RegisterTypeForVT[i] = SVT;
1334 NumRegistersForVT[i] = 1;
1336 IsLegalWiderType =
true;
1340 if (IsLegalWiderType)
1347 unsigned NumIntermediates;
1349 NumIntermediates, RegisterVT,
this);
1350 RegisterTypeForVT[i] = RegisterVT;
1365 TransformToType[i] = NVT;
1384 RepRegClassForVT[i] =
RRC;
1385 RepRegClassCostForVT[i] = Cost;
1391 assert(!VT.
isVector() &&
"No default SetCC type for vectors!");
1409 EVT &IntermediateVT,
1410 unsigned &NumIntermediates,
1411 MVT &RegisterVT)
const {
1423 IntermediateVT = RegisterEVT;
1425 NumIntermediates = 1;
1433 unsigned NumVectorRegs = 1;
1438 NumVectorRegs = NumElts;
1447 NumVectorRegs <<= 1;
1450 NumIntermediates = NumVectorRegs;
1455 IntermediateVT = NewVT;
1458 RegisterVT = DestVT;
1465 if (
EVT(DestVT).bitsLT(NewVT))
1470 return NumVectorRegs;
1482 unsigned NumValues = ValueVTs.
size();
1483 if (NumValues == 0)
return;
1485 for (
unsigned j = 0, f = NumValues; j != f; ++j) {
1486 EVT VT = ValueVTs[j];
1518 for (
unsigned i = 0; i < NumParts; ++i)
1536 enum InstructionOpcodes {
1537 #define HANDLE_INST(NUM, OPCODE, CLASS) OPCODE = NUM,
1538 #define LAST_OTHER_INST(NUM) InstructionOpcodesCount = NUM
1539 #include "llvm/IR/Instruction.def"
1541 switch (static_cast<InstructionOpcodes>(Opcode)) {
1544 case Switch:
return 0;
1545 case IndirectBr:
return 0;
1546 case Invoke:
return 0;
1547 case Resume:
return 0;
1548 case Unreachable:
return 0;
1567 case Alloca:
return 0;
1570 case GetElementPtr:
return 0;
1571 case Fence:
return 0;
1572 case AtomicCmpXchg:
return 0;
1573 case AtomicRMW:
return 0;
1590 case Call:
return 0;
1592 case UserOp1:
return 0;
1593 case UserOp2:
return 0;
1594 case VAArg:
return 0;
1600 case LandingPad:
return 0;
1606 std::pair<unsigned, MVT>
1638 unsigned AS)
const {
EVT getRoundIntegerType(LLVMContext &Context) const
getRoundIntegerType - Rounds the bit-width of the given integer EVT up to the nearest power of two (a...
BITCAST - This operator converts between integer, vector and FP values, as if the value was stored to...
X = FP_ROUND(Y, TRUNC) - Rounding 'Y' from a larger floating point type down to the precision of the ...
static MVT getIntegerVT(unsigned BitWidth)
void push_back(const T &Elt)
The memory access reads data.
const MachineFunction * getParent() const
getParent - Return the MachineFunction containing this basic block.
A parsed version of the target data layout string in and methods for querying it. ...
This represents an addressing mode of: BaseGV + BaseOffs + BaseReg + Scale*ScaleReg If BaseGV is null...
vt_iterator vt_end() const
The memory access writes data.
static void InitLibcallCallingConvs(CallingConv::ID *CCs)
InitLibcallCallingConvs - Set default libcall CallingConvs.
LegalizeTypeAction getTypeAction(LLVMContext &Context, EVT VT) const
Return how we should legalize values of this type, either it is already legal (return 'Legal') or we ...
Sign extended before/after call.
unsigned getNumRegisters(LLVMContext &Context, EVT VT) const
Return the number of registers that this ValueType will eventually require.
static MVT getVectorVT(MVT VT, unsigned NumElements)
VECTOR_SHUFFLE(VEC1, VEC2) - Returns a vector, of the same type as VEC1/VEC2.
Force argument to be passed in register.
ZERO_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register zero-extension of the low ...
static void InitLibcallNames(const char **Names, const Triple &TT)
InitLibcallNames - Set default libcall names.
Y = RRC X, rotate right via carry.
static cl::opt< bool > JumpIsExpensiveOverride("jump-is-expensive", cl::init(false), cl::desc("Do not create extra branches to split comparison logic."), cl::Hidden)
Libcall
RTLIB::Libcall enum - This enum defines all of the runtime library calls the backend can emit...
RESULT, BOOL = [SU]ADDO(LHS, RHS) - Overflow-aware nodes for addition.
unsigned getSizeInBits() const
const MCInstrDesc & getDesc() const
Returns the target instruction descriptor of this MachineInstr.
Val, Success, OUTCHAIN = ATOMIC_CMP_SWAP_WITH_SUCCESS(INCHAIN, ptr, cmp, swap) N.b.
SIGN_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register sign-extension of the low ...
[US]{MIN/MAX} - Binary minimum or maximum or signed or unsigned integers.
std::pair< LegalizeTypeAction, EVT > LegalizeKind
LegalizeKind holds the legalization kind that needs to happen to EVT in order to type-legalize it...
bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const
Return true if the attribute exists at the given index.
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, unsigned f, uint64_t s, unsigned base_alignment, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr)
getMachineMemOperand - Allocate a new MachineMemOperand.
NodeType
ISD::NodeType enum - This enum defines the target-independent operators for a SelectionDAG.
Libcall getFPROUND(EVT OpVT, EVT RetVT)
getFPROUND - Return the FPROUND_*_* value for the given types, or UNKNOWN_LIBCALL if there is none...
bool bitsLT(EVT VT) const
bitsLT - Return true if this has less bits than VT.
INT = FGETSIGN(FP) - Return the sign bit of the specified floating point value as an integer 0/1 valu...
static MachinePointerInfo getFixedStack(int FI, int64_t offset=0)
getFixedStack - Return a MachinePointerInfo record that refers to the the specified FrameIndex...
Libcall getUINTTOFP(EVT OpVT, EVT RetVT)
getUINTTOFP - Return the UINTTOFP_*_* value for the given types, or UNKNOWN_LIBCALL if there is none...
const Triple & getTargetTriple() const
bool isVector() const
isVector - Return true if this is a vector value type.
unsigned getSize() const
getSize - Return the size of the register in bytes, which is also the size of a stack slot allocated ...
virtual bool canOpTrap(unsigned Op, EVT VT) const
Returns true if the operation can trap for the value type.
MachineMemOperand - A description of a memory reference used in the backend.
unsigned getNumRegClasses() const
LegalizeTypeAction
This enum indicates whether a types are legal for a target, and if not, what action should be used to...
Shift and rotation operations.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
const TargetRegisterClass * getRegClass(unsigned i) const
getRegClass - Returns the register class associated with the enumeration value.
void eraseFromParent()
Unlink 'this' from the containing basic block and delete it.
bool mayLoad(QueryType Type=AnyInBundle) const
Return true if this instruction could possibly read memory.
MVT getScalarType() const
getScalarType - If this is a vector type, return the element type, otherwise return this...
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
Val, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amt) Val, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amt) For double-word atomic operations: ValLo, ValHi, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amtLo, amtHi) ValLo, ValHi, OUTCHAIN = ATOMIC_LOAD_[OpName](INCHAIN, ptr, amtLo, amtHi) These correspond to the atomicrmw instruction.
void setOperationAction(unsigned Op, MVT VT, LegalizeAction Action)
Indicate that the specified operation does not work with the specified type and indicate what to do a...
The memory access is volatile.
static ConstantInt * ExtractElement(Constant *V, Constant *Idx)
void setJumpIsExpensive(bool isExpensive=true)
Tells the code generator not to expand logic operations on comparison predicates into separate sequen...
const MachineInstrBuilder & addImm(int64_t Val) const
addImm - Add a new immediate operand.
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
bool isInteger() const
isInteger - Return true if this is an integer, or a vector integer type.
int InstructionOpcodeToISD(unsigned Opcode) const
Get the ISD node that corresponds to the Instruction class opcode.
OutputArg - This struct carries flags and a value for a single outgoing (actual) argument or outgoing...
unsigned getNumOperands() const
Access to explicit operands of the instruction.
EVT getVectorElementType() const
getVectorElementType - Given a vector type, return the type of each element.
[SU]INT_TO_FP - These operators convert integers (whose interpreted sign depends on the first letter)...
void computeRegisterProperties(const TargetRegisterInfo *TRI)
Once all of the register classes are added, this allows us to compute derived properties we expose...
LLVMContext & getContext() const
getContext - Return the LLVMContext in which this type was uniqued.
bool isFI() const
isFI - Tests if this is a MO_FrameIndex operand.
void GetReturnInfo(Type *ReturnType, AttributeSet attr, SmallVectorImpl< ISD::OutputArg > &Outs, const TargetLowering &TLI, const DataLayout &DL)
Given an LLVM IR type and return type attributes, compute the return value EVTs and flags...
Simple integer binary arithmetic operators.
MachineBasicBlock * emitPatchPoint(MachineInstr *MI, MachineBasicBlock *MBB) const
Replace/modify any TargetFrameIndex operands with a targte-dependent sequence of memory operands that...
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out...
EVT getValueType(const DataLayout &DL, Type *Ty, bool AllowUnknown=false) const
Return the EVT corresponding to this LLVM type.
void addMemOperand(MachineFunction &MF, MachineMemOperand *MO)
Add a MachineMemOperand to the machine instruction.
ANY_EXTEND_VECTOR_INREG(Vector) - This operator represents an in-register any-extension of the low la...
instr_iterator insert(instr_iterator I, MachineInstr *M)
Insert MI into the instruction list before I, possibly inside a bundle.
void ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL, Type *Ty, SmallVectorImpl< EVT > &ValueVTs, SmallVectorImpl< uint64_t > *Offsets=nullptr, uint64_t StartingOffset=0)
ComputeValueVTs - Given an LLVM IR type, compute a sequence of EVTs that represent all the individual...
bool isLegalRC(const TargetRegisterClass *RC) const
Return true if the value types that can be represented by the specified register class are all legal...
bool isPow2VectorType() const
isPow2VectorType - Returns true if the given vector is a power of 2.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
FP_TO_[US]INT - Convert a floating point value to a signed or unsigned integer.
const MachineBasicBlock * getParent() const
LLVM_CONSTEXPR size_t array_lengthof(T(&)[N])
Find the length of an array.
mmo_iterator memoperands_end() const
bundle_iterator< MachineInstr, instr_iterator > iterator
bool isTypeLegal(EVT VT) const
Return true if the target has native support for the specified value type.
static void InitCmpLibcallCCs(ISD::CondCode *CCs)
InitCmpLibcallCCs - Set default comparison libcall CC.
initializer< Ty > init(const Ty &Val)
bool isInteger() const
isInteger - Return true if this is an integer, or a vector integer type.
unsigned getVectorNumElements() const
MVT - Machine Value Type.
The instances of the Type class are immutable: once they are created, they are never changed...
This is an important class for using LLVM in a threaded context.
Simple binary floating point operators.
INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element at IDX replaced with VAL...
const MachineOperand & getOperand(unsigned i) const
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Libcall getFPTOSINT(EVT OpVT, EVT RetVT)
getFPTOSINT - Return the FPTOSINT_*_* value for the given types, or UNKNOWN_LIBCALL if there is none...
TRAP - Trapping instruction.
Zero extended before/after call.
MVT getRegisterType(MVT VT) const
Return the type of registers that this ValueType will eventually require.
DEBUGTRAP - Trap intended to get the attention of a debugger.
unsigned getVectorTypeBreakdown(LLVMContext &Context, EVT VT, EVT &IntermediateVT, unsigned &NumIntermediates, MVT &RegisterVT) const
Vector types are broken down into some number of legal first class types.
unsigned MaxStoresPerMemmove
Specify maximum bytes of store instructions per memmove call.
MachineInstrBuilder BuildMI(MachineFunction &MF, DebugLoc DL, const MCInstrDesc &MCID)
BuildMI - Builder interface.
Val, OUTCHAIN = ATOMIC_CMP_SWAP(INCHAIN, ptr, cmp, swap) For double-word atomic operations: ValLo...
X = FP_EXTEND(Y) - Extend a smaller FP type into a larger FP type.
EVT - Extended Value Type.
LegalizeTypeAction getTypeAction(MVT VT) const
uint64_t NextPowerOf2(uint64_t A)
NextPowerOf2 - Returns the next power of two (in 64-bits) that is strictly greater than A...
static unsigned getVectorTypeBreakdownMVT(MVT VT, MVT &IntermediateVT, unsigned &NumIntermediates, MVT &RegisterVT, TargetLoweringBase *TLI)
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual unsigned getByValTypeAlignment(Type *Ty, const DataLayout &DL) const
Return the desired alignment for ByVal or InAlloca aggregate function arguments in the caller paramet...
static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements)
getVectorVT - Returns the EVT that represents a vector NumElements in length, where each element is o...
Triple - Helper class for working with autoconf configuration names.
This base class for TargetLowering contains the SelectionDAG-independent parts that can be used from ...
bool isOSDarwin() const
isOSDarwin - Is this a "Darwin" OS (OS X or iOS).
Libcall getFPEXT(EVT OpVT, EVT RetVT)
getFPEXT - Return the FPEXT_*_* value for the given types, or UNKNOWN_LIBCALL if there is none...
void initActions()
Initialize all of the actions to default values.
unsigned getABITypeAlignment(Type *Ty) const
Returns the minimum ABI-required alignment for the specified type.
bool MaskAndBranchFoldingIsLegal
MaskAndBranchFoldingIsLegal - Indicates if the target supports folding a mask of a single bit...
EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR identified by the (potentially...
const DataLayout * getDataLayout() const
Deprecated in 3.7, will be removed in 3.8.
ADDRSPACECAST - This operator converts between pointers of different address spaces.
MachineOperand class - Representation of each machine instruction operand.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
bool isValid() const
Returns true if this iterator is still pointing at a valid entry.
virtual EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context, EVT VT) const
Return the ValueType of the result of SETCC operations.
MachineFrameInfo * getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
void setIndexedLoadAction(unsigned IdxMode, MVT VT, LegalizeAction Action)
Indicate that the specified indexed load does or does not work with the specified type and indicate w...
Select(COND, TRUEVAL, FALSEVAL).
ZERO_EXTEND - Used for integer types, zeroing the new bits.
ANY_EXTEND - Used for integer types. The high bits are undefined.
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
#define OP_TO_LIBCALL(Name, Enum)
FCOPYSIGN(X, Y) - Return the value of X with the sign of Y.
virtual TargetLoweringBase::LegalizeTypeAction getPreferredVectorAction(EVT VT) const
Return the preferred vector type legalization action.
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
virtual MVT::SimpleValueType getCmpLibcallReturnType() const
Return the ValueType for comparison libcalls.
static mvt_range all_valuetypes()
SimpleValueType Iteration.
Representation of each machine instruction.
Libcall getFPTOUINT(EVT OpVT, EVT RetVT)
getFPTOUINT - Return the FPTOUINT_*_* value for the given types, or UNKNOWN_LIBCALL if there is none...
Bitwise operators - logical and, logical or, logical xor.
void setTypeAction(MVT VT, LegalizeTypeAction Action)
virtual bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty, unsigned AddrSpace) const
Return true if the addressing mode represented by AM is legal for this target, for a load/store of th...
Call instruction with associated vm state for deoptimization and list of live pointers for relocation...
virtual MVT getScalarShiftAmountTy(const DataLayout &, EVT) const
EVT is not used in-tree, but is used by out-of-tree target.
LOAD and STORE have token chains as their first operand, then the same operands as an LLVM load/store...
unsigned getSizeInBits() const
getSizeInBits - Return the size of the specified value type in bits.
virtual std::pair< const TargetRegisterClass *, uint8_t > findRepresentativeClass(const TargetRegisterInfo *TRI, MVT VT) const
Return the largest legal super-reg register class of the register class for the specified type and it...
unsigned MaxStoresPerMemmoveOptSize
Maximum number of store instructions that may be substituted for a call to memmove, used for functions with OpSize attribute.
unsigned MaxStoresPerMemcpyOptSize
Maximum number of store operations that may be substituted for a call to memcpy, used for functions w...
unsigned MaxStoresPerMemcpy
Specify maximum bytes of store instructions per memcpy call.
EVT getPow2VectorType(LLVMContext &Context) const
getPow2VectorType - Widens the length of the given vector EVT up to the nearest power of 2 and return...
EnvironmentType getEnvironment() const
getEnvironment - Get the parsed environment type of this triple.
Libcall getSINTTOFP(EVT OpVT, EVT RetVT)
getSINTTOFP - Return the SINTTOFP_*_* value for the given types, or UNKNOWN_LIBCALL if there is none...
Libcall getATOMIC(unsigned Opc, MVT VT)
Return the SYNC_FETCH_AND_* value for the given opcode and type, or UNKNOWN_LIBCALL if there is none...
CONCAT_VECTORS(VECTOR0, VECTOR1, ...) - Given a number of values of vector type with the same length ...
bool EnableExtLdPromotion
bool isSimple() const
isSimple - Test if the given EVT is simple (as opposed to being extended).
MVT getPointerTy(const DataLayout &DL, uint32_t AS=0) const
Return the pointer type for the given address space, defaults to the pointer type from the data layou...
EVT getTypeToTransformTo(LLVMContext &Context, EVT VT) const
For types supported by the target, this is an identity function.
PREFETCH - This corresponds to a prefetch intrinsic.
MVT getPow2VectorType() const
getPow2VectorType - Widens the length of the given vector MVT up to the nearest power of 2 and return...
const MachineInstrBuilder & addOperand(const MachineOperand &MO) const
Primary interface to the complete machine description for the target machine.
C - The default llvm calling convention, compatible with C.
bool isPowerOf2_32(uint32_t Value)
isPowerOf2_32 - This function returns true if the argument is a power of two > 0. ...
vt_iterator vt_begin() const
vt_begin / vt_end - Loop over all of the value types that can be represented by values in this regist...
FMAD - Perform a * b + c, while getting the same result as the separately rounded operations...
SetCC operator - This evaluates to a true value iff the condition is true.
unsigned MaxStoresPerMemset
Specify maximum number of store instructions per memset call.
unsigned MaxStoresPerMemsetOptSize
Maximum number of stores operations that may be substituted for the call to memset, used for functions with OptSize attribute.
MERGE_VALUES - This node takes multiple discrete operands and returns them all as its individual resu...
MVT getVectorElementType() const
TRUNCATE - Completely drop the high bits.
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size FIXME: The defaults need to be removed once all of the backends/clients are updat...
EVT getShiftAmountTy(EVT LHSTy, const DataLayout &DL) const
static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth)
getIntegerVT - Returns the EVT that represents an integer with the given number of bits...
std::pair< unsigned, MVT > getTypeLegalizationCost(const DataLayout &DL, Type *Ty) const
Estimate the cost of type-legalization and the legalized type.
void setMemRefs(mmo_iterator NewMemRefs, mmo_iterator NewMemRefsEnd)
Assign this MachineInstr's memory reference descriptor list.
void setBitsInMask(const uint32_t *Mask, unsigned MaskWords=~0u)
setBitsInMask - Add '1' bits from Mask to this vector.
bool PredictableSelectIsExpensive
Tells the code generator that select is more expensive than a branch if the branch is usually predict...
MVT getSimpleVT() const
getSimpleVT - Return the SimpleValueType held in the specified simple EVT.
This file describes how to lower LLVM code to machine code.
void setIndexedStoreAction(unsigned IdxMode, MVT VT, LegalizeAction Action)
Indicate that the specified indexed store does or does not work with the specified type and indicate ...
mmo_iterator memoperands_begin() const
Access to memory operands of the instruction.
unsigned getVectorNumElements() const
getVectorNumElements - Given a vector type, return the number of elements it contains.