maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

remove trailing whitespace 

llvm-svn: 106628
This commit is contained in:
Jim Grosbach 2010-06-23 15:49:18 +00:00
parent 731ea71f59
commit 41f2ce66a4
1 changed files with 85 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
llvm/include/llvm/Target/TargetLowering.h
View File

@ -114,7 +114,7 @@ public:
/// isSelectExpensive - Return true if the select operation is expensive for /// isSelectExpensive - Return true if the select operation is expensive for
/// this target. /// this target.
bool isSelectExpensive() const { return SelectIsExpensive; } bool isSelectExpensive() const { return SelectIsExpensive; }
/// isIntDivCheap() - Return true if integer divide is usually cheaper than /// isIntDivCheap() - Return true if integer divide is usually cheaper than
/// a sequence of several shifts, adds, and multiplies for this target. /// a sequence of several shifts, adds, and multiplies for this target.
bool isIntDivCheap() const { return IntDivIsCheap; } bool isIntDivCheap() const { return IntDivIsCheap; }
@ -131,10 +131,10 @@ public:
virtual virtual
MVT::SimpleValueType getSetCCResultType(EVT VT) const; MVT::SimpleValueType getSetCCResultType(EVT VT) const;
/// getCmpLibcallReturnType - Return the ValueType for comparison /// getCmpLibcallReturnType - Return the ValueType for comparison
/// libcalls. Comparions libcalls include floating point comparion calls, /// libcalls. Comparions libcalls include floating point comparion calls,
/// and Ordered/Unordered check calls on floating point numbers. /// and Ordered/Unordered check calls on floating point numbers.
virtual virtual
MVT::SimpleValueType getCmpLibcallReturnType() const; MVT::SimpleValueType getCmpLibcallReturnType() const;
/// getBooleanContents - For targets without i1 registers, this gives the /// getBooleanContents - For targets without i1 registers, this gives the
@ -208,7 +208,7 @@ public:
ValueTypeActions[I] = Action; ValueTypeActions[I] = Action;
} }
}; };
const ValueTypeActionImpl &getValueTypeActions() const { const ValueTypeActionImpl &getValueTypeActions() const {
return ValueTypeActions; return ValueTypeActions;
} }
@ -229,7 +229,7 @@ public:
/// returns the integer type to transform to. /// returns the integer type to transform to.
EVT getTypeToTransformTo(LLVMContext &Context, EVT VT) const { EVT getTypeToTransformTo(LLVMContext &Context, EVT VT) const {
if (VT.isSimple()) { if (VT.isSimple()) {
assert((unsigned)VT.getSimpleVT().SimpleTy < assert((unsigned)VT.getSimpleVT().SimpleTy <
array_lengthof(TransformToType)); array_lengthof(TransformToType));
EVT NVT = TransformToType[VT.getSimpleVT().SimpleTy]; EVT NVT = TransformToType[VT.getSimpleVT().SimpleTy];
assert(getTypeAction(Context, NVT) != Promote && assert(getTypeAction(Context, NVT) != Promote &&
@ -256,7 +256,7 @@ public:
return EVT::getIntegerVT(Context, VT.getSizeInBits() / 2); return EVT::getIntegerVT(Context, VT.getSizeInBits() / 2);
else else
// Promote to a power of two size, avoiding multi-step promotion. // Promote to a power of two size, avoiding multi-step promotion.
return getTypeAction(Context, NVT) == Promote ? return getTypeAction(Context, NVT) == Promote ?
getTypeToTransformTo(Context, NVT) : NVT; getTypeToTransformTo(Context, NVT) : NVT;
} }
assert(0 && "Unsupported extended type!"); assert(0 && "Unsupported extended type!");
@ -302,11 +302,11 @@ public:
/// intrinsic will need to map to a MemIntrinsicNode (touches memory). If /// intrinsic will need to map to a MemIntrinsicNode (touches memory). If
/// this is the case, it returns true and store the intrinsic /// this is the case, it returns true and store the intrinsic
/// information into the IntrinsicInfo that was passed to the function. /// information into the IntrinsicInfo that was passed to the function.
struct IntrinsicInfo { struct IntrinsicInfo {
unsigned opc; // target opcode unsigned opc; // target opcode
EVT memVT; // memory VT EVT memVT; // memory VT
const Value* ptrVal; // value representing memory location const Value* ptrVal; // value representing memory location
int offset; // offset off of ptrVal int offset; // offset off of ptrVal
unsigned align; // alignment unsigned align; // alignment
bool vol; // is volatile? bool vol; // is volatile?
bool readMem; // reads memory? bool readMem; // reads memory?
@ -324,7 +324,7 @@ public:
virtual bool isFPImmLegal(const APFloat &Imm, EVT VT) const { virtual bool isFPImmLegal(const APFloat &Imm, EVT VT) const {
return false; return false;
} }
/// isShuffleMaskLegal - Targets can use this to indicate that they only /// isShuffleMaskLegal - Targets can use this to indicate that they only
/// support *some* VECTOR_SHUFFLE operations, those with specific masks. /// support *some* VECTOR_SHUFFLE operations, those with specific masks.
/// By default, if a target supports the VECTOR_SHUFFLE node, all mask values /// By default, if a target supports the VECTOR_SHUFFLE node, all mask values
@ -446,7 +446,7 @@ public:
"Table isn't big enough!"); "Table isn't big enough!");
unsigned Ty = (unsigned)VT.getSimpleVT().SimpleTy; unsigned Ty = (unsigned)VT.getSimpleVT().SimpleTy;
return (LegalizeAction)(IndexedModeActions[Ty][IdxMode] & 0x0f); return (LegalizeAction)(IndexedModeActions[Ty][IdxMode] & 0x0f);
} }
/// isIndexedStoreLegal - Return true if the specified indexed load is legal /// isIndexedStoreLegal - Return true if the specified indexed load is legal
/// on this target. /// on this target.
@ -492,7 +492,7 @@ public:
assert((VT.isInteger() || VT.isFloatingPoint()) && assert((VT.isInteger() || VT.isFloatingPoint()) &&
"Cannot autopromote this type, add it with AddPromotedToType."); "Cannot autopromote this type, add it with AddPromotedToType.");
EVT NVT = VT; EVT NVT = VT;
do { do {
NVT = (MVT::SimpleValueType)(NVT.getSimpleVT().SimpleTy+1); NVT = (MVT::SimpleValueType)(NVT.getSimpleVT().SimpleTy+1);
@ -516,14 +516,14 @@ public:
/// function arguments in the caller parameter area. This is the actual /// function arguments in the caller parameter area. This is the actual
/// alignment, not its logarithm. /// alignment, not its logarithm.
virtual unsigned getByValTypeAlignment(const Type *Ty) const; virtual unsigned getByValTypeAlignment(const Type *Ty) const;
/// getRegisterType - Return the type of registers that this ValueType will /// getRegisterType - Return the type of registers that this ValueType will
/// eventually require. /// eventually require.
EVT getRegisterType(MVT VT) const { EVT getRegisterType(MVT VT) const {
assert((unsigned)VT.SimpleTy < array_lengthof(RegisterTypeForVT)); assert((unsigned)VT.SimpleTy < array_lengthof(RegisterTypeForVT));
return RegisterTypeForVT[VT.SimpleTy]; return RegisterTypeForVT[VT.SimpleTy];
} }
/// getRegisterType - Return the type of registers that this ValueType will /// getRegisterType - Return the type of registers that this ValueType will
/// eventually require. /// eventually require.
EVT getRegisterType(LLVMContext &Context, EVT VT) const { EVT getRegisterType(LLVMContext &Context, EVT VT) const {
@ -606,7 +606,7 @@ public:
/// of the specified type. This is used, for example, in situations where an /// of the specified type. This is used, for example, in situations where an
/// array copy/move/set is converted to a sequence of store operations. It's /// array copy/move/set is converted to a sequence of store operations. It's
/// use helps to ensure that such replacements don't generate code that causes /// use helps to ensure that such replacements don't generate code that causes
/// an alignment error (trap) on the target machine. /// an alignment error (trap) on the target machine.
/// @brief Determine if the target supports unaligned memory accesses. /// @brief Determine if the target supports unaligned memory accesses.
virtual bool allowsUnalignedMemoryAccesses(EVT VT) const { virtual bool allowsUnalignedMemoryAccesses(EVT VT) const {
return false; return false;
@ -637,7 +637,7 @@ public:
MachineFunction &MF) const { MachineFunction &MF) const {
return MVT::Other; return MVT::Other;
} }
/// usesUnderscoreSetJmp - Determine if we should use _setjmp or setjmp /// usesUnderscoreSetJmp - Determine if we should use _setjmp or setjmp
/// to implement llvm.setjmp. /// to implement llvm.setjmp.
bool usesUnderscoreSetJmp() const { bool usesUnderscoreSetJmp() const {
@ -701,7 +701,7 @@ public:
unsigned getPrefLoopAlignment() const { unsigned getPrefLoopAlignment() const {
return PrefLoopAlignment; return PrefLoopAlignment;
} }
/// getPreIndexedAddressParts - returns true by value, base pointer and /// getPreIndexedAddressParts - returns true by value, base pointer and
/// offset pointer and addressing mode by reference if the node's address /// offset pointer and addressing mode by reference if the node's address
/// can be legally represented as pre-indexed load / store address. /// can be legally represented as pre-indexed load / store address.
@ -711,7 +711,7 @@ public:
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
return false; return false;
} }
/// getPostIndexedAddressParts - returns true by value, base pointer and /// getPostIndexedAddressParts - returns true by value, base pointer and
/// offset pointer and addressing mode by reference if this node can be /// offset pointer and addressing mode by reference if this node can be
/// combined with a load / store to form a post-indexed load / store. /// combined with a load / store to form a post-indexed load / store.
@ -721,12 +721,12 @@ public:
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
return false; return false;
} }
/// getJumpTableEncoding - Return the entry encoding for a jump table in the /// getJumpTableEncoding - Return the entry encoding for a jump table in the
/// current function. The returned value is a member of the /// current function. The returned value is a member of the
/// MachineJumpTableInfo::JTEntryKind enum. /// MachineJumpTableInfo::JTEntryKind enum.
virtual unsigned getJumpTableEncoding() const; virtual unsigned getJumpTableEncoding() const;
virtual const MCExpr * virtual const MCExpr *
LowerCustomJumpTableEntry(const MachineJumpTableInfo *MJTI, LowerCustomJumpTableEntry(const MachineJumpTableInfo *MJTI,
const MachineBasicBlock *MBB, unsigned uid, const MachineBasicBlock *MBB, unsigned uid,
@ -734,7 +734,7 @@ public:
assert(0 && "Need to implement this hook if target has custom JTIs"); assert(0 && "Need to implement this hook if target has custom JTIs");
return 0; return 0;
} }
/// getPICJumpTableRelocaBase - Returns relocation base for the given PIC /// getPICJumpTableRelocaBase - Returns relocation base for the given PIC
/// jumptable. /// jumptable.
virtual SDValue getPICJumpTableRelocBase(SDValue Table, virtual SDValue getPICJumpTableRelocBase(SDValue Table,
@ -746,7 +746,7 @@ public:
virtual const MCExpr * virtual const MCExpr *
getPICJumpTableRelocBaseExpr(const MachineFunction *MF, getPICJumpTableRelocBaseExpr(const MachineFunction *MF,
unsigned JTI, MCContext &Ctx) const; unsigned JTI, MCContext &Ctx) const;
/// isOffsetFoldingLegal - Return true if folding a constant offset /// isOffsetFoldingLegal - Return true if folding a constant offset
/// with the given GlobalAddress is legal. It is frequently not legal in /// with the given GlobalAddress is legal. It is frequently not legal in
/// PIC relocation models. /// PIC relocation models.
@ -758,10 +758,10 @@ public:
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// TargetLowering Optimization Methods // TargetLowering Optimization Methods
// //
/// TargetLoweringOpt - A convenience struct that encapsulates a DAG, and two /// TargetLoweringOpt - A convenience struct that encapsulates a DAG, and two
/// SDValues for returning information from TargetLowering to its clients /// SDValues for returning information from TargetLowering to its clients
/// that want to combine /// that want to combine
struct TargetLoweringOpt { struct TargetLoweringOpt {
SelectionDAG &DAG; SelectionDAG &DAG;
bool LegalTys; bool LegalTys;
@ -775,14 +775,14 @@ public:
bool LegalTypes() const { return LegalTys; } bool LegalTypes() const { return LegalTys; }
bool LegalOperations() const { return LegalOps; } bool LegalOperations() const { return LegalOps; }
bool CombineTo(SDValue O, SDValue N) { bool CombineTo(SDValue O, SDValue N) {
Old = O; Old = O;
New = N; New = N;
return true; return true;
} }
/// ShrinkDemandedConstant - Check to see if the specified operand of the /// ShrinkDemandedConstant - Check to see if the specified operand of the
/// specified instruction is a constant integer. If so, check to see if /// specified instruction is a constant integer. If so, check to see if
/// there are any bits set in the constant that are not demanded. If so, /// there are any bits set in the constant that are not demanded. If so,
/// shrink the constant and return true. /// shrink the constant and return true.
@ -795,25 +795,25 @@ public:
bool ShrinkDemandedOp(SDValue Op, unsigned BitWidth, const APInt &Demanded, bool ShrinkDemandedOp(SDValue Op, unsigned BitWidth, const APInt &Demanded,
DebugLoc dl); DebugLoc dl);
}; };
/// SimplifyDemandedBits - Look at Op. At this point, we know that only the /// SimplifyDemandedBits - Look at Op. At this point, we know that only the
/// DemandedMask bits of the result of Op are ever used downstream. If we can /// DemandedMask bits of the result of Op are ever used downstream. If we can
/// use this information to simplify Op, create a new simplified DAG node and /// use this information to simplify Op, create a new simplified DAG node and
/// return true, returning the original and new nodes in Old and New. /// return true, returning the original and new nodes in Old and New.
/// Otherwise, analyze the expression and return a mask of KnownOne and /// Otherwise, analyze the expression and return a mask of KnownOne and
/// KnownZero bits for the expression (used to simplify the caller). /// KnownZero bits for the expression (used to simplify the caller).
/// The KnownZero/One bits may only be accurate for those bits in the /// The KnownZero/One bits may only be accurate for those bits in the
/// DemandedMask. /// DemandedMask.
bool SimplifyDemandedBits(SDValue Op, const APInt &DemandedMask, bool SimplifyDemandedBits(SDValue Op, const APInt &DemandedMask,
APInt &KnownZero, APInt &KnownOne, APInt &KnownZero, APInt &KnownOne,
TargetLoweringOpt &TLO, unsigned Depth = 0) const; TargetLoweringOpt &TLO, unsigned Depth = 0) const;
/// computeMaskedBitsForTargetNode - Determine which of the bits specified in /// computeMaskedBitsForTargetNode - Determine which of the bits specified in
/// Mask are known to be either zero or one and return them in the /// Mask are known to be either zero or one and return them in the
/// KnownZero/KnownOne bitsets. /// KnownZero/KnownOne bitsets.
virtual void computeMaskedBitsForTargetNode(const SDValue Op, virtual void computeMaskedBitsForTargetNode(const SDValue Op,
const APInt &Mask, const APInt &Mask,
APInt &KnownZero, APInt &KnownZero,
APInt &KnownOne, APInt &KnownOne,
const SelectionDAG &DAG, const SelectionDAG &DAG,
unsigned Depth = 0) const; unsigned Depth = 0) const;
@ -823,7 +823,7 @@ public:
/// DAG Combiner. /// DAG Combiner.
virtual unsigned ComputeNumSignBitsForTargetNode(SDValue Op, virtual unsigned ComputeNumSignBitsForTargetNode(SDValue Op,
unsigned Depth = 0) const; unsigned Depth = 0) const;
struct DAGCombinerInfo { struct DAGCombinerInfo {
void *DC; // The DAG Combiner object. void *DC; // The DAG Combiner object.
bool BeforeLegalize; bool BeforeLegalize;
@ -831,15 +831,15 @@ public:
bool CalledByLegalizer; bool CalledByLegalizer;
public: public:
SelectionDAG &DAG; SelectionDAG &DAG;
DAGCombinerInfo(SelectionDAG &dag, bool bl, bool blo, bool cl, void *dc) DAGCombinerInfo(SelectionDAG &dag, bool bl, bool blo, bool cl, void *dc)
: DC(dc), BeforeLegalize(bl), BeforeLegalizeOps(blo), : DC(dc), BeforeLegalize(bl), BeforeLegalizeOps(blo),
CalledByLegalizer(cl), DAG(dag) {} CalledByLegalizer(cl), DAG(dag) {}
bool isBeforeLegalize() const { return BeforeLegalize; } bool isBeforeLegalize() const { return BeforeLegalize; }
bool isBeforeLegalizeOps() const { return BeforeLegalizeOps; } bool isBeforeLegalizeOps() const { return BeforeLegalizeOps; }
bool isCalledByLegalizer() const { return CalledByLegalizer; } bool isCalledByLegalizer() const { return CalledByLegalizer; }
void AddToWorklist(SDNode *N); void AddToWorklist(SDNode *N);
SDValue CombineTo(SDNode *N, const std::vector<SDValue> &To, SDValue CombineTo(SDNode *N, const std::vector<SDValue> &To,
bool AddTo = true); bool AddTo = true);
@ -849,7 +849,7 @@ public:
void CommitTargetLoweringOpt(const TargetLoweringOpt &TLO); void CommitTargetLoweringOpt(const TargetLoweringOpt &TLO);
}; };
/// SimplifySetCC - Try to simplify a setcc built with the specified operands /// SimplifySetCC - Try to simplify a setcc built with the specified operands
/// and cc. If it is unable to simplify it, return a null SDValue. /// and cc. If it is unable to simplify it, return a null SDValue.
SDValue SimplifySetCC(EVT VT, SDValue N0, SDValue N1, SDValue SimplifySetCC(EVT VT, SDValue N0, SDValue N1,
ISD::CondCode Cond, bool foldBooleans, ISD::CondCode Cond, bool foldBooleans,
@ -890,7 +890,7 @@ public:
virtual bool IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const { virtual bool IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const {
return false; return false;
} }
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// TargetLowering Configuration Methods - These methods should be invoked by // TargetLowering Configuration Methods - These methods should be invoked by
// the derived class constructor to configure this object for the target. // the derived class constructor to configure this object for the target.
@ -930,7 +930,7 @@ protected:
void setStackPointerRegisterToSaveRestore(unsigned R) { void setStackPointerRegisterToSaveRestore(unsigned R) {
StackPointerRegisterToSaveRestore = R; StackPointerRegisterToSaveRestore = R;
} }
/// setExceptionPointerRegister - If set to a physical register, this sets /// setExceptionPointerRegister - If set to a physical register, this sets
/// the register that receives the exception address on entry to a landing /// the register that receives the exception address on entry to a landing
/// pad. /// pad.
@ -953,12 +953,12 @@ protected:
/// expensive, and if possible, should be replaced by an alternate sequence /// expensive, and if possible, should be replaced by an alternate sequence
/// of instructions not containing an integer divide. /// of instructions not containing an integer divide.
void setIntDivIsCheap(bool isCheap = true) { IntDivIsCheap = isCheap; } void setIntDivIsCheap(bool isCheap = true) { IntDivIsCheap = isCheap; }
/// setPow2DivIsCheap - Tells the code generator that it shouldn't generate /// setPow2DivIsCheap - Tells the code generator that it shouldn't generate
/// srl/add/sra for a signed divide by power of two, and let the target handle /// srl/add/sra for a signed divide by power of two, and let the target handle
/// it. /// it.
void setPow2DivIsCheap(bool isCheap = true) { Pow2DivIsCheap = isCheap; } void setPow2DivIsCheap(bool isCheap = true) { Pow2DivIsCheap = isCheap; }
/// addRegisterClass - Add the specified register class as an available /// addRegisterClass - Add the specified register class as an available
/// regclass for the specified value type. This indicates the selector can /// regclass for the specified value type. This indicates the selector can
/// handle values of that class natively. /// handle values of that class natively.
@ -981,7 +981,7 @@ protected:
assert(Op < array_lengthof(OpActions[0]) && "Table isn't big enough!"); assert(Op < array_lengthof(OpActions[0]) && "Table isn't big enough!");
OpActions[(unsigned)VT.SimpleTy][Op] = (uint8_t)Action; OpActions[(unsigned)VT.SimpleTy][Op] = (uint8_t)Action;
} }
/// setLoadExtAction - Indicate that the specified load with extension does /// setLoadExtAction - Indicate that the specified load with extension does
/// not work with the specified type and indicate what to do about it. /// not work with the specified type and indicate what to do about it.
void setLoadExtAction(unsigned ExtType, MVT VT, void setLoadExtAction(unsigned ExtType, MVT VT,
@ -991,7 +991,7 @@ protected:
"Table isn't big enough!"); "Table isn't big enough!");
LoadExtActions[VT.SimpleTy][ExtType] = (uint8_t)Action; LoadExtActions[VT.SimpleTy][ExtType] = (uint8_t)Action;
} }
/// setTruncStoreAction - Indicate that the specified truncating store does /// setTruncStoreAction - Indicate that the specified truncating store does
/// not work with the specified type and indicate what to do about it. /// not work with the specified type and indicate what to do about it.
void setTruncStoreAction(MVT ValVT, MVT MemVT, void setTruncStoreAction(MVT ValVT, MVT MemVT,
@ -1016,7 +1016,7 @@ protected:
IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] &= ~0xf0; IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] &= ~0xf0;
IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] |= ((uint8_t)Action) <<4; IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] |= ((uint8_t)Action) <<4;
} }
/// setIndexedStoreAction - Indicate that the specified indexed store does or /// setIndexedStoreAction - Indicate that the specified indexed store does or
/// does not work with the specified type and indicate what to do about /// does not work with the specified type and indicate what to do about
/// it. NOTE: All indexed mode stores are initialized to Expand in /// it. NOTE: All indexed mode stores are initialized to Expand in
@ -1031,7 +1031,7 @@ protected:
IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] &= ~0x0f; IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] &= ~0x0f;
IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] |= ((uint8_t)Action); IndexedModeActions[(unsigned)VT.SimpleTy][IdxMode] |= ((uint8_t)Action);
} }
/// setCondCodeAction - Indicate that the specified condition code is or isn't /// setCondCodeAction - Indicate that the specified condition code is or isn't
/// supported on the target and indicate what to do about it. /// supported on the target and indicate what to do about it.
void setCondCodeAction(ISD::CondCode CC, MVT VT, void setCondCodeAction(ISD::CondCode CC, MVT VT,
@ -1058,7 +1058,7 @@ protected:
assert(unsigned(NT >> 3) < array_lengthof(TargetDAGCombineArray)); assert(unsigned(NT >> 3) < array_lengthof(TargetDAGCombineArray));
TargetDAGCombineArray[NT >> 3] |= 1 << (NT&7); TargetDAGCombineArray[NT >> 3] |= 1 << (NT&7);
} }
/// setJumpBufSize - Set the target's required jmp_buf buffer size (in /// setJumpBufSize - Set the target's required jmp_buf buffer size (in
/// bytes); default is 200 /// bytes); default is 200
void setJumpBufSize(unsigned Size) { void setJumpBufSize(unsigned Size) {
@ -1076,7 +1076,7 @@ protected:
void setIfCvtBlockSizeLimit(unsigned Limit) { void setIfCvtBlockSizeLimit(unsigned Limit) {
IfCvtBlockSizeLimit = Limit; IfCvtBlockSizeLimit = Limit;
} }
/// setIfCvtDupBlockSizeLimit - Set the target's block size limit (in number /// setIfCvtDupBlockSizeLimit - Set the target's block size limit (in number
/// of instructions) to be considered for code duplication during /// of instructions) to be considered for code duplication during
/// if-conversion; default is 2. /// if-conversion; default is 2.
@ -1089,7 +1089,7 @@ protected:
void setPrefLoopAlignment(unsigned Align) { void setPrefLoopAlignment(unsigned Align) {
PrefLoopAlignment = Align; PrefLoopAlignment = Align;
} }
public: public:
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Lowering methods - These methods must be implemented by targets so that // Lowering methods - These methods must be implemented by targets so that
@ -1198,7 +1198,7 @@ public:
SmallVectorImpl<SDValue> &Results, SmallVectorImpl<SDValue> &Results,
SelectionDAG &DAG) const; SelectionDAG &DAG) const;
/// LowerOperation - This callback is invoked for operations that are /// LowerOperation - This callback is invoked for operations that are
/// unsupported by the target, which are registered to use 'custom' lowering, /// unsupported by the target, which are registered to use 'custom' lowering,
/// and whose defined values are all legal. /// and whose defined values are all legal.
/// If the target has no operations that require custom lowering, it need not /// If the target has no operations that require custom lowering, it need not
@ -1241,7 +1241,7 @@ public:
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Inline Asm Support hooks // Inline Asm Support hooks
// //
/// ExpandInlineAsm - This hook allows the target to expand an inline asm /// ExpandInlineAsm - This hook allows the target to expand an inline asm
/// call to be explicit llvm code if it wants to. This is useful for /// call to be explicit llvm code if it wants to. This is useful for
/// turning simple inline asms into LLVM intrinsics, which gives the /// turning simple inline asms into LLVM intrinsics, which gives the
@ -1249,7 +1249,7 @@ public:
virtual bool ExpandInlineAsm(CallInst *CI) const { virtual bool ExpandInlineAsm(CallInst *CI) const {
return false; return false;
} }
enum ConstraintType { enum ConstraintType {
C_Register, // Constraint represents specific register(s). C_Register, // Constraint represents specific register(s).
C_RegisterClass, // Constraint represents any of register(s) in class. C_RegisterClass, // Constraint represents any of register(s) in class.
@ -1257,7 +1257,7 @@ public:
C_Other, // Something else. C_Other, // Something else.
C_Unknown // Unsupported constraint. C_Unknown // Unsupported constraint.
}; };
/// AsmOperandInfo - This contains information for each constraint that we are /// AsmOperandInfo - This contains information for each constraint that we are
/// lowering. /// lowering.
struct AsmOperandInfo : public InlineAsm::ConstraintInfo { struct AsmOperandInfo : public InlineAsm::ConstraintInfo {
@ -1269,25 +1269,25 @@ public:
/// ConstraintType - Information about the constraint code, e.g. Register, /// ConstraintType - Information about the constraint code, e.g. Register,
/// RegisterClass, Memory, Other, Unknown. /// RegisterClass, Memory, Other, Unknown.
TargetLowering::ConstraintType ConstraintType; TargetLowering::ConstraintType ConstraintType;
/// CallOperandval - If this is the result output operand or a /// CallOperandval - If this is the result output operand or a
/// clobber, this is null, otherwise it is the incoming operand to the /// clobber, this is null, otherwise it is the incoming operand to the
/// CallInst. This gets modified as the asm is processed. /// CallInst. This gets modified as the asm is processed.
Value *CallOperandVal; Value *CallOperandVal;
/// ConstraintVT - The ValueType for the operand value. /// ConstraintVT - The ValueType for the operand value.
EVT ConstraintVT; EVT ConstraintVT;
/// isMatchingInputConstraint - Return true of this is an input operand that /// isMatchingInputConstraint - Return true of this is an input operand that
/// is a matching constraint like "4". /// is a matching constraint like "4".
bool isMatchingInputConstraint() const; bool isMatchingInputConstraint() const;
/// getMatchedOperand - If this is an input matching constraint, this method /// getMatchedOperand - If this is an input matching constraint, this method
/// returns the output operand it matches. /// returns the output operand it matches.
unsigned getMatchedOperand() const; unsigned getMatchedOperand() const;
AsmOperandInfo(const InlineAsm::ConstraintInfo &info) AsmOperandInfo(const InlineAsm::ConstraintInfo &info)
: InlineAsm::ConstraintInfo(info), : InlineAsm::ConstraintInfo(info),
ConstraintType(TargetLowering::C_Unknown), ConstraintType(TargetLowering::C_Unknown),
CallOperandVal(0), ConstraintVT(MVT::Other) { CallOperandVal(0), ConstraintVT(MVT::Other) {
} }
@ -1303,15 +1303,15 @@ public:
SDValue Op, SDValue Op,
bool hasMemory, bool hasMemory,
SelectionDAG *DAG = 0) const; SelectionDAG *DAG = 0) const;
/// getConstraintType - Given a constraint, return the type of constraint it /// getConstraintType - Given a constraint, return the type of constraint it
/// is for this target. /// is for this target.
virtual ConstraintType getConstraintType(const std::string &Constraint) const; virtual ConstraintType getConstraintType(const std::string &Constraint) const;
/// getRegClassForInlineAsmConstraint - Given a constraint letter (e.g. "r"), /// getRegClassForInlineAsmConstraint - Given a constraint letter (e.g. "r"),
/// return a list of registers that can be used to satisfy the constraint. /// return a list of registers that can be used to satisfy the constraint.
/// This should only be used for C_RegisterClass constraints. /// This should only be used for C_RegisterClass constraints.
virtual std::vector<unsigned> virtual std::vector<unsigned>
getRegClassForInlineAsmConstraint(const std::string &Constraint, getRegClassForInlineAsmConstraint(const std::string &Constraint,
EVT VT) const; EVT VT) const;
@ -1325,16 +1325,16 @@ public:
/// ///
/// This should only be used for C_Register constraints. On error, /// This should only be used for C_Register constraints. On error,
/// this returns a register number of 0 and a null register class pointer.. /// this returns a register number of 0 and a null register class pointer..
virtual std::pair<unsigned, const TargetRegisterClass*> virtual std::pair<unsigned, const TargetRegisterClass*>
getRegForInlineAsmConstraint(const std::string &Constraint, getRegForInlineAsmConstraint(const std::string &Constraint,
EVT VT) const; EVT VT) const;
/// LowerXConstraint - try to replace an X constraint, which matches anything, /// LowerXConstraint - try to replace an X constraint, which matches anything,
/// with another that has more specific requirements based on the type of the /// with another that has more specific requirements based on the type of the
/// corresponding operand. This returns null if there is no replacement to /// corresponding operand. This returns null if there is no replacement to
/// make. /// make.
virtual const char *LowerXConstraint(EVT ConstraintVT) const; virtual const char *LowerXConstraint(EVT ConstraintVT) const;
/// LowerAsmOperandForConstraint - Lower the specified operand into the Ops /// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
/// vector. If it is invalid, don't add anything to Ops. If hasMemory is true /// vector. If it is invalid, don't add anything to Ops. If hasMemory is true
/// it means one of the asm constraint of the inline asm instruction being /// it means one of the asm constraint of the inline asm instruction being
@ -1343,11 +1343,11 @@ public:
bool hasMemory, bool hasMemory,
std::vector<SDValue> &Ops, std::vector<SDValue> &Ops,
SelectionDAG &DAG) const; SelectionDAG &DAG) const;
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Instruction Emitting Hooks // Instruction Emitting Hooks
// //
// EmitInstrWithCustomInserter - This method should be implemented by targets // EmitInstrWithCustomInserter - This method should be implemented by targets
// that mark instructions with the 'usesCustomInserter' flag. These // that mark instructions with the 'usesCustomInserter' flag. These
// instructions are special in various ways, which require special support to // instructions are special in various ways, which require special support to
@ -1376,7 +1376,7 @@ public:
int64_t Scale; int64_t Scale;
AddrMode() : BaseGV(0), BaseOffs(0), HasBaseReg(false), Scale(0) {} AddrMode() : BaseGV(0), BaseOffs(0), HasBaseReg(false), Scale(0) {}
}; };
/// isLegalAddressingMode - Return true if the addressing mode represented by /// isLegalAddressingMode - Return true if the addressing mode represented by
/// AM is legal for this target, for a load/store of the specified type. /// AM is legal for this target, for a load/store of the specified type.
/// The type may be VoidTy, in which case only return true if the addressing /// The type may be VoidTy, in which case only return true if the addressing
@ -1429,9 +1429,9 @@ public:
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Div utility functions // Div utility functions
// //
SDValue BuildSDIV(SDNode *N, SelectionDAG &DAG, SDValue BuildSDIV(SDNode *N, SelectionDAG &DAG,
std::vector<SDNode*>* Created) const; std::vector<SDNode*>* Created) const;
SDValue BuildUDIV(SDNode *N, SelectionDAG &DAG, SDValue BuildUDIV(SDNode *N, SelectionDAG &DAG,
std::vector<SDNode*>* Created) const; std::vector<SDNode*>* Created) const;
@ -1468,7 +1468,7 @@ public:
void setLibcallCallingConv(RTLIB::Libcall Call, CallingConv::ID CC) { void setLibcallCallingConv(RTLIB::Libcall Call, CallingConv::ID CC) {
LibcallCallingConvs[Call] = CC; LibcallCallingConvs[Call] = CC;
} }
/// getLibcallCallingConv - Get the CallingConv that should be used for the /// getLibcallCallingConv - Get the CallingConv that should be used for the
/// specified libcall. /// specified libcall.
CallingConv::ID getLibcallCallingConv(RTLIB::Libcall Call) const { CallingConv::ID getLibcallCallingConv(RTLIB::Libcall Call) const {
@ -1497,12 +1497,12 @@ private:
/// a real cost model is in place. If we ever optimize for size, this will be /// a real cost model is in place. If we ever optimize for size, this will be
/// set to true unconditionally. /// set to true unconditionally.
bool IntDivIsCheap; bool IntDivIsCheap;
/// Pow2DivIsCheap - Tells the code generator that it shouldn't generate /// Pow2DivIsCheap - Tells the code generator that it shouldn't generate
/// srl/add/sra for a signed divide by power of two, and let the target handle /// srl/add/sra for a signed divide by power of two, and let the target handle
/// it. /// it.
bool Pow2DivIsCheap; bool Pow2DivIsCheap;
/// UseUnderscoreSetJmp - This target prefers to use _setjmp to implement /// UseUnderscoreSetJmp - This target prefers to use _setjmp to implement
/// llvm.setjmp. Defaults to false. /// llvm.setjmp. Defaults to false.
bool UseUnderscoreSetJmp; bool UseUnderscoreSetJmp;
@ -1522,10 +1522,10 @@ private:
/// SchedPreferenceInfo - The target scheduling preference: shortest possible /// SchedPreferenceInfo - The target scheduling preference: shortest possible
/// total cycles or lowest register usage. /// total cycles or lowest register usage.
Sched::Preference SchedPreferenceInfo; Sched::Preference SchedPreferenceInfo;
/// JumpBufSize - The size, in bytes, of the target's jmp_buf buffers /// JumpBufSize - The size, in bytes, of the target's jmp_buf buffers
unsigned JumpBufSize; unsigned JumpBufSize;
/// JumpBufAlignment - The alignment, in bytes, of the target's jmp_buf /// JumpBufAlignment - The alignment, in bytes, of the target's jmp_buf
/// buffers /// buffers
unsigned JumpBufAlignment; unsigned JumpBufAlignment;
@ -1533,7 +1533,7 @@ private:
/// IfCvtBlockSizeLimit - The maximum allowed size for a block to be /// IfCvtBlockSizeLimit - The maximum allowed size for a block to be
/// if-converted. /// if-converted.
unsigned IfCvtBlockSizeLimit; unsigned IfCvtBlockSizeLimit;
/// IfCvtDupBlockSizeLimit - The maximum allowed size for a block to be /// IfCvtDupBlockSizeLimit - The maximum allowed size for a block to be
/// duplicated during if-conversion. /// duplicated during if-conversion.
unsigned IfCvtDupBlockSizeLimit; unsigned IfCvtDupBlockSizeLimit;
@ -1581,12 +1581,12 @@ private:
/// operations that are not should be described. Note that operations on /// operations that are not should be described. Note that operations on
/// non-legal value types are not described here. /// non-legal value types are not described here.
uint8_t OpActions[MVT::LAST_VALUETYPE][ISD::BUILTIN_OP_END]; uint8_t OpActions[MVT::LAST_VALUETYPE][ISD::BUILTIN_OP_END];
/// LoadExtActions - For each load extension type and each value type, /// LoadExtActions - For each load extension type and each value type,
/// keep a LegalizeAction that indicates how instruction selection should deal /// keep a LegalizeAction that indicates how instruction selection should deal
/// with a load of a specific value type and extension type. /// with a load of a specific value type and extension type.
uint8_t LoadExtActions[MVT::LAST_VALUETYPE][ISD::LAST_LOADEXT_TYPE]; uint8_t LoadExtActions[MVT::LAST_VALUETYPE][ISD::LAST_LOADEXT_TYPE];
/// TruncStoreActions - For each value type pair keep a LegalizeAction that /// TruncStoreActions - For each value type pair keep a LegalizeAction that
/// indicates whether a truncating store of a specific value type and /// indicates whether a truncating store of a specific value type and
/// truncating type is legal. /// truncating type is legal.
@ -1598,7 +1598,7 @@ private:
/// value_type for the reference. The second dimension represents the various /// value_type for the reference. The second dimension represents the various
/// modes for load store. /// modes for load store.
uint8_t IndexedModeActions[MVT::LAST_VALUETYPE][ISD::LAST_INDEXED_MODE]; uint8_t IndexedModeActions[MVT::LAST_VALUETYPE][ISD::LAST_INDEXED_MODE];
/// CondCodeActions - For each condition code (ISD::CondCode) keep a /// CondCodeActions - For each condition code (ISD::CondCode) keep a
/// LegalizeAction that indicates how instruction selection should /// LegalizeAction that indicates how instruction selection should
/// deal with the condition code. /// deal with the condition code.
@ -1613,7 +1613,7 @@ private:
/// which sets a bit in this array. /// which sets a bit in this array.
unsigned char unsigned char
TargetDAGCombineArray[(ISD::BUILTIN_OP_END+CHAR_BIT-1)/CHAR_BIT]; TargetDAGCombineArray[(ISD::BUILTIN_OP_END+CHAR_BIT-1)/CHAR_BIT];
/// PromoteToType - For operations that must be promoted to a specific type, /// PromoteToType - For operations that must be promoted to a specific type,
/// this holds the destination type. This map should be sparse, so don't hold /// this holds the destination type. This map should be sparse, so don't hold
/// it as an array. /// it as an array.