RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-04-04 14:22:26 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Track IR ordering of SelectionDAG nodes 2/4.

Browse Source 
Change SelectionDAG::getXXXNode() interfaces as well as call sites of
these functions to pass in SDLoc instead of DebugLoc.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182703 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Andrew Trick 2013-05-25 02:42:55 +00:00
parent ea5db0c315
commit ac6d9bec67
74 changed files with 2187 additions and 2190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
include/llvm/CodeGen/SelectionDAG.h
View File

@ -386,10 +386,10 @@ public:
SDValue getTargetConstantFP(const ConstantFP &Val, EVT VT) { SDValue getTargetConstantFP(const ConstantFP &Val, EVT VT) {
return getConstantFP(Val, VT, true); return getConstantFP(Val, VT, true);
} }
SDValue getGlobalAddress(const GlobalValue *GV, DebugLoc DL, EVT VT, SDValue getGlobalAddress(const GlobalValue *GV, SDLoc DL, EVT VT,
int64_t offset = 0, bool isTargetGA = false, int64_t offset = 0, bool isTargetGA = false,
unsigned char TargetFlags = 0); unsigned char TargetFlags = 0);
SDValue getTargetGlobalAddress(const GlobalValue *GV, DebugLoc DL, EVT VT, SDValue getTargetGlobalAddress(const GlobalValue *GV, SDLoc DL, EVT VT,
int64_t offset = 0, int64_t offset = 0,
unsigned char TargetFlags = 0) { unsigned char TargetFlags = 0) {
return getGlobalAddress(GV, DL, VT, offset, true, TargetFlags); return getGlobalAddress(GV, DL, VT, offset, true, TargetFlags);
@ -424,15 +424,15 @@ public:
// When generating a branch to a BB, we don't in general know enough // When generating a branch to a BB, we don't in general know enough
// to provide debug info for the BB at that time, so keep this one around. // to provide debug info for the BB at that time, so keep this one around.
SDValue getBasicBlock(MachineBasicBlock *MBB); SDValue getBasicBlock(MachineBasicBlock *MBB);
SDValue getBasicBlock(MachineBasicBlock *MBB, DebugLoc dl); SDValue getBasicBlock(MachineBasicBlock *MBB, SDLoc dl);
SDValue getExternalSymbol(const char *Sym, EVT VT); SDValue getExternalSymbol(const char *Sym, EVT VT);
SDValue getExternalSymbol(const char *Sym, DebugLoc dl, EVT VT); SDValue getExternalSymbol(const char *Sym, SDLoc dl, EVT VT);
SDValue getTargetExternalSymbol(const char *Sym, EVT VT, SDValue getTargetExternalSymbol(const char *Sym, EVT VT,
unsigned char TargetFlags = 0); unsigned char TargetFlags = 0);
SDValue getValueType(EVT); SDValue getValueType(EVT);
SDValue getRegister(unsigned Reg, EVT VT); SDValue getRegister(unsigned Reg, EVT VT);
SDValue getRegisterMask(const uint32_t *RegMask); SDValue getRegisterMask(const uint32_t *RegMask);
SDValue getEHLabel(DebugLoc dl, SDValue Root, MCSymbol *Label); SDValue getEHLabel(SDLoc dl, SDValue Root, MCSymbol *Label);
SDValue getBlockAddress(const BlockAddress *BA, EVT VT, SDValue getBlockAddress(const BlockAddress *BA, EVT VT,
int64_t Offset = 0, bool isTarget = false, int64_t Offset = 0, bool isTarget = false,
unsigned char TargetFlags = 0); unsigned char TargetFlags = 0);
@ -442,7 +442,7 @@ public:
return getBlockAddress(BA, VT, Offset, true, TargetFlags); return getBlockAddress(BA, VT, Offset, true, TargetFlags);
} }
SDValue getCopyToReg(SDValue Chain, DebugLoc dl, unsigned Reg, SDValue N) { SDValue getCopyToReg(SDValue Chain, SDLoc dl, unsigned Reg, SDValue N) {
return getNode(ISD::CopyToReg, dl, MVT::Other, Chain, return getNode(ISD::CopyToReg, dl, MVT::Other, Chain,
getRegister(Reg, N.getValueType()), N); getRegister(Reg, N.getValueType()), N);
} }
@ -450,7 +450,7 @@ public:
// This version of the getCopyToReg method takes an extra operand, which // This version of the getCopyToReg method takes an extra operand, which
// indicates that there is potentially an incoming glue value (if Glue is not // indicates that there is potentially an incoming glue value (if Glue is not
// null) and that there should be a glue result. // null) and that there should be a glue result.
SDValue getCopyToReg(SDValue Chain, DebugLoc dl, unsigned Reg, SDValue N, SDValue getCopyToReg(SDValue Chain, SDLoc dl, unsigned Reg, SDValue N,
SDValue Glue) { SDValue Glue) {
SDVTList VTs = getVTList(MVT::Other, MVT::Glue); SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
SDValue Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Glue }; SDValue Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Glue };
@ -458,14 +458,14 @@ public:
} }
// Similar to last getCopyToReg() except parameter Reg is a SDValue // Similar to last getCopyToReg() except parameter Reg is a SDValue
SDValue getCopyToReg(SDValue Chain, DebugLoc dl, SDValue Reg, SDValue N, SDValue getCopyToReg(SDValue Chain, SDLoc dl, SDValue Reg, SDValue N,
SDValue Glue) { SDValue Glue) {
SDVTList VTs = getVTList(MVT::Other, MVT::Glue); SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
SDValue Ops[] = { Chain, Reg, N, Glue }; SDValue Ops[] = { Chain, Reg, N, Glue };
return getNode(ISD::CopyToReg, dl, VTs, Ops, Glue.getNode() ? 4 : 3); return getNode(ISD::CopyToReg, dl, VTs, Ops, Glue.getNode() ? 4 : 3);
} }
SDValue getCopyFromReg(SDValue Chain, DebugLoc dl, unsigned Reg, EVT VT) { SDValue getCopyFromReg(SDValue Chain, SDLoc dl, unsigned Reg, EVT VT) {
SDVTList VTs = getVTList(VT, MVT::Other); SDVTList VTs = getVTList(VT, MVT::Other);
SDValue Ops[] = { Chain, getRegister(Reg, VT) }; SDValue Ops[] = { Chain, getRegister(Reg, VT) };
return getNode(ISD::CopyFromReg, dl, VTs, Ops, 2); return getNode(ISD::CopyFromReg, dl, VTs, Ops, 2);
@ -474,7 +474,7 @@ public:
// This version of the getCopyFromReg method takes an extra operand, which // This version of the getCopyFromReg method takes an extra operand, which
// indicates that there is potentially an incoming glue value (if Glue is not // indicates that there is potentially an incoming glue value (if Glue is not
// null) and that there should be a glue result. // null) and that there should be a glue result.
SDValue getCopyFromReg(SDValue Chain, DebugLoc dl, unsigned Reg, EVT VT, SDValue getCopyFromReg(SDValue Chain, SDLoc dl, unsigned Reg, EVT VT,
SDValue Glue) { SDValue Glue) {
SDVTList VTs = getVTList(VT, MVT::Other, MVT::Glue); SDVTList VTs = getVTList(VT, MVT::Other, MVT::Glue);
SDValue Ops[] = { Chain, getRegister(Reg, VT), Glue }; SDValue Ops[] = { Chain, getRegister(Reg, VT), Glue };
@ -485,7 +485,7 @@ public:
/// Returns the ConvertRndSat Note: Avoid using this node because it may /// Returns the ConvertRndSat Note: Avoid using this node because it may
/// disappear in the future and most targets don't support it. /// disappear in the future and most targets don't support it.
SDValue getConvertRndSat(EVT VT, DebugLoc dl, SDValue Val, SDValue DTy, SDValue getConvertRndSat(EVT VT, SDLoc dl, SDValue Val, SDValue DTy,
SDValue STy, SDValue STy,
SDValue Rnd, SDValue Sat, ISD::CvtCode Code); SDValue Rnd, SDValue Sat, ISD::CvtCode Code);
@ -493,40 +493,40 @@ public:
/// elements in VT, which must be a vector type, must match the number of /// elements in VT, which must be a vector type, must match the number of
/// mask elements NumElts. A integer mask element equal to -1 is treated as /// mask elements NumElts. A integer mask element equal to -1 is treated as
/// undefined. /// undefined.
SDValue getVectorShuffle(EVT VT, DebugLoc dl, SDValue N1, SDValue N2, SDValue getVectorShuffle(EVT VT, SDLoc dl, SDValue N1, SDValue N2,
const int *MaskElts); const int *MaskElts);
/// getAnyExtOrTrunc - Convert Op, which must be of integer type, to the /// getAnyExtOrTrunc - Convert Op, which must be of integer type, to the
/// integer type VT, by either any-extending or truncating it. /// integer type VT, by either any-extending or truncating it.
SDValue getAnyExtOrTrunc(SDValue Op, DebugLoc DL, EVT VT); SDValue getAnyExtOrTrunc(SDValue Op, SDLoc DL, EVT VT);
/// getSExtOrTrunc - Convert Op, which must be of integer type, to the /// getSExtOrTrunc - Convert Op, which must be of integer type, to the
/// integer type VT, by either sign-extending or truncating it. /// integer type VT, by either sign-extending or truncating it.
SDValue getSExtOrTrunc(SDValue Op, DebugLoc DL, EVT VT); SDValue getSExtOrTrunc(SDValue Op, SDLoc DL, EVT VT);
/// getZExtOrTrunc - Convert Op, which must be of integer type, to the /// getZExtOrTrunc - Convert Op, which must be of integer type, to the
/// integer type VT, by either zero-extending or truncating it. /// integer type VT, by either zero-extending or truncating it.
SDValue getZExtOrTrunc(SDValue Op, DebugLoc DL, EVT VT); SDValue getZExtOrTrunc(SDValue Op, SDLoc DL, EVT VT);
/// getZeroExtendInReg - Return the expression required to zero extend the Op /// getZeroExtendInReg - Return the expression required to zero extend the Op
/// value assuming it was the smaller SrcTy value. /// value assuming it was the smaller SrcTy value.
SDValue getZeroExtendInReg(SDValue Op, DebugLoc DL, EVT SrcTy); SDValue getZeroExtendInReg(SDValue Op, SDLoc DL, EVT SrcTy);
/// getNOT - Create a bitwise NOT operation as (XOR Val, -1). /// getNOT - Create a bitwise NOT operation as (XOR Val, -1).
SDValue getNOT(DebugLoc DL, SDValue Val, EVT VT); SDValue getNOT(SDLoc DL, SDValue Val, EVT VT);
/// getCALLSEQ_START - Return a new CALLSEQ_START node, which always must have /// getCALLSEQ_START - Return a new CALLSEQ_START node, which always must have
/// a glue result (to ensure it's not CSE'd). CALLSEQ_START does not have a /// a glue result (to ensure it's not CSE'd). CALLSEQ_START does not have a
/// useful DebugLoc. /// useful SDLoc.
SDValue getCALLSEQ_START(SDValue Chain, SDValue Op) { SDValue getCALLSEQ_START(SDValue Chain, SDValue Op) {
SDVTList VTs = getVTList(MVT::Other, MVT::Glue); SDVTList VTs = getVTList(MVT::Other, MVT::Glue);
SDValue Ops[] = { Chain, Op }; SDValue Ops[] = { Chain, Op };
return getNode(ISD::CALLSEQ_START, DebugLoc(), VTs, Ops, 2); return getNode(ISD::CALLSEQ_START, SDLoc(), VTs, Ops, 2);
} }
/// getCALLSEQ_END - Return a new CALLSEQ_END node, which always must have a /// getCALLSEQ_END - Return a new CALLSEQ_END node, which always must have a
/// glue result (to ensure it's not CSE'd). CALLSEQ_END does not have /// glue result (to ensure it's not CSE'd). CALLSEQ_END does not have
/// a useful DebugLoc. /// a useful SDLoc.
SDValue getCALLSEQ_END(SDValue Chain, SDValue Op1, SDValue Op2, SDValue getCALLSEQ_END(SDValue Chain, SDValue Op1, SDValue Op2,
SDValue InGlue) { SDValue InGlue) {
SDVTList NodeTys = getVTList(MVT::Other, MVT::Glue); SDVTList NodeTys = getVTList(MVT::Other, MVT::Glue);
@ -535,53 +535,53 @@ public:
Ops.push_back(Op1); Ops.push_back(Op1);
Ops.push_back(Op2); Ops.push_back(Op2);
Ops.push_back(InGlue); Ops.push_back(InGlue);
return getNode(ISD::CALLSEQ_END, DebugLoc(), NodeTys, &Ops[0], return getNode(ISD::CALLSEQ_END, SDLoc(), NodeTys, &Ops[0],
(unsigned)Ops.size() - (InGlue.getNode() == 0 ? 1 : 0)); (unsigned)Ops.size() - (InGlue.getNode() == 0 ? 1 : 0));
} }
/// getUNDEF - Return an UNDEF node. UNDEF does not have a useful DebugLoc. /// getUNDEF - Return an UNDEF node. UNDEF does not have a useful SDLoc.
SDValue getUNDEF(EVT VT) { SDValue getUNDEF(EVT VT) {
return getNode(ISD::UNDEF, DebugLoc(), VT); return getNode(ISD::UNDEF, SDLoc(), VT);
} }
/// getGLOBAL_OFFSET_TABLE - Return a GLOBAL_OFFSET_TABLE node. This does /// getGLOBAL_OFFSET_TABLE - Return a GLOBAL_OFFSET_TABLE node. This does
/// not have a useful DebugLoc. /// not have a useful SDLoc.
SDValue getGLOBAL_OFFSET_TABLE(EVT VT) { SDValue getGLOBAL_OFFSET_TABLE(EVT VT) {
return getNode(ISD::GLOBAL_OFFSET_TABLE, DebugLoc(), VT); return getNode(ISD::GLOBAL_OFFSET_TABLE, SDLoc(), VT);
} }
/// getNode - Gets or creates the specified node. /// getNode - Gets or creates the specified node.
/// ///
SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT); SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT);
SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue N); SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT, SDValue N);
SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue N1, SDValue N2); SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT, SDValue N1, SDValue N2);
SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT,
SDValue N1, SDValue N2, SDValue N3); SDValue N1, SDValue N2, SDValue N3);
SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT,
SDValue N1, SDValue N2, SDValue N3, SDValue N4); SDValue N1, SDValue N2, SDValue N3, SDValue N4);
SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT,
SDValue N1, SDValue N2, SDValue N3, SDValue N4, SDValue N1, SDValue N2, SDValue N3, SDValue N4,
SDValue N5); SDValue N5);
SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT,
const SDUse *Ops, unsigned NumOps); const SDUse *Ops, unsigned NumOps);
SDValue getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue getNode(unsigned Opcode, SDLoc DL, EVT VT,
const SDValue *Ops, unsigned NumOps); const SDValue *Ops, unsigned NumOps);
SDValue getNode(unsigned Opcode, DebugLoc DL, SDValue getNode(unsigned Opcode, SDLoc DL,
ArrayRef<EVT> ResultTys, ArrayRef<EVT> ResultTys,
const SDValue *Ops, unsigned NumOps); const SDValue *Ops, unsigned NumOps);
SDValue getNode(unsigned Opcode, DebugLoc DL, const EVT *VTs, unsigned NumVTs, SDValue getNode(unsigned Opcode, SDLoc DL, const EVT *VTs, unsigned NumVTs,
const SDValue *Ops, unsigned NumOps); const SDValue *Ops, unsigned NumOps);
SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs,
const SDValue *Ops, unsigned NumOps); const SDValue *Ops, unsigned NumOps);
SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs); SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs);
SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, SDValue N); SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs, SDValue N);
SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs,
SDValue N1, SDValue N2); SDValue N1, SDValue N2);
SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs,
SDValue N1, SDValue N2, SDValue N3); SDValue N1, SDValue N2, SDValue N3);
SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs,
SDValue N1, SDValue N2, SDValue N3, SDValue N4); SDValue N1, SDValue N2, SDValue N3, SDValue N4);
SDValue getNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, SDValue getNode(unsigned Opcode, SDLoc DL, SDVTList VTs,
SDValue N1, SDValue N2, SDValue N3, SDValue N4, SDValue N1, SDValue N2, SDValue N3, SDValue N4,
SDValue N5); SDValue N5);
@ -591,24 +591,24 @@ public:
/// clobbered. /// clobbered.
SDValue getStackArgumentTokenFactor(SDValue Chain); SDValue getStackArgumentTokenFactor(SDValue Chain);
SDValue getMemcpy(SDValue Chain, DebugLoc dl, SDValue Dst, SDValue Src, SDValue getMemcpy(SDValue Chain, SDLoc dl, SDValue Dst, SDValue Src,
SDValue Size, unsigned Align, bool isVol, bool AlwaysInline, SDValue Size, unsigned Align, bool isVol, bool AlwaysInline,
MachinePointerInfo DstPtrInfo, MachinePointerInfo DstPtrInfo,
MachinePointerInfo SrcPtrInfo); MachinePointerInfo SrcPtrInfo);
SDValue getMemmove(SDValue Chain, DebugLoc dl, SDValue Dst, SDValue Src, SDValue getMemmove(SDValue Chain, SDLoc dl, SDValue Dst, SDValue Src,
SDValue Size, unsigned Align, bool isVol, SDValue Size, unsigned Align, bool isVol,
MachinePointerInfo DstPtrInfo, MachinePointerInfo DstPtrInfo,
MachinePointerInfo SrcPtrInfo); MachinePointerInfo SrcPtrInfo);
SDValue getMemset(SDValue Chain, DebugLoc dl, SDValue Dst, SDValue Src, SDValue getMemset(SDValue Chain, SDLoc dl, SDValue Dst, SDValue Src,
SDValue Size, unsigned Align, bool isVol, SDValue Size, unsigned Align, bool isVol,
MachinePointerInfo DstPtrInfo); MachinePointerInfo DstPtrInfo);
/// getSetCC - Helper function to make it easier to build SetCC's if you just /// getSetCC - Helper function to make it easier to build SetCC's if you just
/// have an ISD::CondCode instead of an SDValue. /// have an ISD::CondCode instead of an SDValue.
/// ///
SDValue getSetCC(DebugLoc DL, EVT VT, SDValue LHS, SDValue RHS, SDValue getSetCC(SDLoc DL, EVT VT, SDValue LHS, SDValue RHS,
ISD::CondCode Cond) { ISD::CondCode Cond) {
assert(LHS.getValueType().isVector() == RHS.getValueType().isVector() && assert(LHS.getValueType().isVector() == RHS.getValueType().isVector() &&
"Cannot compare scalars to vectors"); "Cannot compare scalars to vectors");
@ -620,7 +620,7 @@ public:
/// getSelectCC - Helper function to make it easier to build SelectCC's if you /// getSelectCC - Helper function to make it easier to build SelectCC's if you
/// just have an ISD::CondCode instead of an SDValue. /// just have an ISD::CondCode instead of an SDValue.
/// ///
SDValue getSelectCC(DebugLoc DL, SDValue LHS, SDValue RHS, SDValue getSelectCC(SDLoc DL, SDValue LHS, SDValue RHS,
SDValue True, SDValue False, ISD::CondCode Cond) { SDValue True, SDValue False, ISD::CondCode Cond) {
return getNode(ISD::SELECT_CC, DL, True.getValueType(), return getNode(ISD::SELECT_CC, DL, True.getValueType(),
LHS, RHS, True, False, getCondCode(Cond)); LHS, RHS, True, False, getCondCode(Cond));
@ -628,17 +628,17 @@ public:
/// getVAArg - VAArg produces a result and token chain, and takes a pointer /// getVAArg - VAArg produces a result and token chain, and takes a pointer
/// and a source value as input. /// and a source value as input.
SDValue getVAArg(EVT VT, DebugLoc dl, SDValue Chain, SDValue Ptr, SDValue getVAArg(EVT VT, SDLoc dl, SDValue Chain, SDValue Ptr,
SDValue SV, unsigned Align); SDValue SV, unsigned Align);
/// getAtomic - Gets a node for an atomic op, produces result and chain and /// getAtomic - Gets a node for an atomic op, produces result and chain and
/// takes 3 operands /// takes 3 operands
SDValue getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue Chain, SDValue getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT, SDValue Chain,
SDValue Ptr, SDValue Cmp, SDValue Swp, SDValue Ptr, SDValue Cmp, SDValue Swp,
MachinePointerInfo PtrInfo, unsigned Alignment, MachinePointerInfo PtrInfo, unsigned Alignment,
AtomicOrdering Ordering, AtomicOrdering Ordering,
SynchronizationScope SynchScope); SynchronizationScope SynchScope);
SDValue getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue Chain, SDValue getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT, SDValue Chain,
SDValue Ptr, SDValue Cmp, SDValue Swp, SDValue Ptr, SDValue Cmp, SDValue Swp,
MachineMemOperand *MMO, MachineMemOperand *MMO,
AtomicOrdering Ordering, AtomicOrdering Ordering,
@ -646,23 +646,23 @@ public:
/// getAtomic - Gets a node for an atomic op, produces result (if relevant) /// getAtomic - Gets a node for an atomic op, produces result (if relevant)
/// and chain and takes 2 operands. /// and chain and takes 2 operands.
SDValue getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue Chain, SDValue getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT, SDValue Chain,
SDValue Ptr, SDValue Val, const Value* PtrVal, SDValue Ptr, SDValue Val, const Value* PtrVal,
unsigned Alignment, AtomicOrdering Ordering, unsigned Alignment, AtomicOrdering Ordering,
SynchronizationScope SynchScope); SynchronizationScope SynchScope);
SDValue getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue Chain, SDValue getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT, SDValue Chain,
SDValue Ptr, SDValue Val, MachineMemOperand *MMO, SDValue Ptr, SDValue Val, MachineMemOperand *MMO,
AtomicOrdering Ordering, AtomicOrdering Ordering,
SynchronizationScope SynchScope); SynchronizationScope SynchScope);
/// getAtomic - Gets a node for an atomic op, produces result and chain and /// getAtomic - Gets a node for an atomic op, produces result and chain and
/// takes 1 operand. /// takes 1 operand.
SDValue getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, EVT VT, SDValue getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT, EVT VT,
SDValue Chain, SDValue Ptr, const Value* PtrVal, SDValue Chain, SDValue Ptr, const Value* PtrVal,
unsigned Alignment, unsigned Alignment,
AtomicOrdering Ordering, AtomicOrdering Ordering,
SynchronizationScope SynchScope); SynchronizationScope SynchScope);
SDValue getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, EVT VT, SDValue getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT, EVT VT,
SDValue Chain, SDValue Ptr, MachineMemOperand *MMO, SDValue Chain, SDValue Ptr, MachineMemOperand *MMO,
AtomicOrdering Ordering, AtomicOrdering Ordering,
SynchronizationScope SynchScope); SynchronizationScope SynchScope);
@ -671,68 +671,68 @@ public:
/// result and takes a list of operands. Opcode may be INTRINSIC_VOID, /// result and takes a list of operands. Opcode may be INTRINSIC_VOID,
/// INTRINSIC_W_CHAIN, or a target-specific opcode with a value not /// INTRINSIC_W_CHAIN, or a target-specific opcode with a value not
/// less than FIRST_TARGET_MEMORY_OPCODE. /// less than FIRST_TARGET_MEMORY_OPCODE.
SDValue getMemIntrinsicNode(unsigned Opcode, DebugLoc dl, SDValue getMemIntrinsicNode(unsigned Opcode, SDLoc dl,
const EVT *VTs, unsigned NumVTs, const EVT *VTs, unsigned NumVTs,
const SDValue *Ops, unsigned NumOps, const SDValue *Ops, unsigned NumOps,
EVT MemVT, MachinePointerInfo PtrInfo, EVT MemVT, MachinePointerInfo PtrInfo,
unsigned Align = 0, bool Vol = false, unsigned Align = 0, bool Vol = false,
bool ReadMem = true, bool WriteMem = true); bool ReadMem = true, bool WriteMem = true);
SDValue getMemIntrinsicNode(unsigned Opcode, DebugLoc dl, SDVTList VTList, SDValue getMemIntrinsicNode(unsigned Opcode, SDLoc dl, SDVTList VTList,
const SDValue *Ops, unsigned NumOps, const SDValue *Ops, unsigned NumOps,
EVT MemVT, MachinePointerInfo PtrInfo, EVT MemVT, MachinePointerInfo PtrInfo,
unsigned Align = 0, bool Vol = false, unsigned Align = 0, bool Vol = false,
bool ReadMem = true, bool WriteMem = true); bool ReadMem = true, bool WriteMem = true);
SDValue getMemIntrinsicNode(unsigned Opcode, DebugLoc dl, SDVTList VTList, SDValue getMemIntrinsicNode(unsigned Opcode, SDLoc dl, SDVTList VTList,
const SDValue *Ops, unsigned NumOps, const SDValue *Ops, unsigned NumOps,
EVT MemVT, MachineMemOperand *MMO); EVT MemVT, MachineMemOperand *MMO);
/// getMergeValues - Create a MERGE_VALUES node from the given operands. /// getMergeValues - Create a MERGE_VALUES node from the given operands.
SDValue getMergeValues(const SDValue *Ops, unsigned NumOps, DebugLoc dl); SDValue getMergeValues(const SDValue *Ops, unsigned NumOps, SDLoc dl);
/// getLoad - Loads are not normal binary operators: their result type is not /// getLoad - Loads are not normal binary operators: their result type is not
/// determined by their operands, and they produce a value AND a token chain. /// determined by their operands, and they produce a value AND a token chain.
/// ///
SDValue getLoad(EVT VT, DebugLoc dl, SDValue Chain, SDValue Ptr, SDValue getLoad(EVT VT, SDLoc dl, SDValue Chain, SDValue Ptr,
MachinePointerInfo PtrInfo, bool isVolatile, MachinePointerInfo PtrInfo, bool isVolatile,
bool isNonTemporal, bool isInvariant, unsigned Alignment, bool isNonTemporal, bool isInvariant, unsigned Alignment,
const MDNode *TBAAInfo = 0, const MDNode *Ranges = 0); const MDNode *TBAAInfo = 0, const MDNode *Ranges = 0);
SDValue getExtLoad(ISD::LoadExtType ExtType, DebugLoc dl, EVT VT, SDValue getExtLoad(ISD::LoadExtType ExtType, SDLoc dl, EVT VT,
SDValue Chain, SDValue Ptr, MachinePointerInfo PtrInfo, SDValue Chain, SDValue Ptr, MachinePointerInfo PtrInfo,
EVT MemVT, bool isVolatile, EVT MemVT, bool isVolatile,
bool isNonTemporal, unsigned Alignment, bool isNonTemporal, unsigned Alignment,
const MDNode *TBAAInfo = 0); const MDNode *TBAAInfo = 0);
SDValue getIndexedLoad(SDValue OrigLoad, DebugLoc dl, SDValue Base, SDValue getIndexedLoad(SDValue OrigLoad, SDLoc dl, SDValue Base,
SDValue Offset, ISD::MemIndexedMode AM); SDValue Offset, ISD::MemIndexedMode AM);
SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType,
EVT VT, DebugLoc dl, EVT VT, SDLoc dl,
SDValue Chain, SDValue Ptr, SDValue Offset, SDValue Chain, SDValue Ptr, SDValue Offset,
MachinePointerInfo PtrInfo, EVT MemVT, MachinePointerInfo PtrInfo, EVT MemVT,
bool isVolatile, bool isNonTemporal, bool isInvariant, bool isVolatile, bool isNonTemporal, bool isInvariant,
unsigned Alignment, const MDNode *TBAAInfo = 0, unsigned Alignment, const MDNode *TBAAInfo = 0,
const MDNode *Ranges = 0); const MDNode *Ranges = 0);
SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType,
EVT VT, DebugLoc dl, EVT VT, SDLoc dl,
SDValue Chain, SDValue Ptr, SDValue Offset, SDValue Chain, SDValue Ptr, SDValue Offset,
EVT MemVT, MachineMemOperand *MMO); EVT MemVT, MachineMemOperand *MMO);
/// getStore - Helper function to build ISD::STORE nodes. /// getStore - Helper function to build ISD::STORE nodes.
/// ///
SDValue getStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue Ptr, SDValue getStore(SDValue Chain, SDLoc dl, SDValue Val, SDValue Ptr,
MachinePointerInfo PtrInfo, bool isVolatile, MachinePointerInfo PtrInfo, bool isVolatile,
bool isNonTemporal, unsigned Alignment, bool isNonTemporal, unsigned Alignment,
const MDNode *TBAAInfo = 0); const MDNode *TBAAInfo = 0);
SDValue getStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue Ptr, SDValue getStore(SDValue Chain, SDLoc dl, SDValue Val, SDValue Ptr,
MachineMemOperand *MMO); MachineMemOperand *MMO);
SDValue getTruncStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue Ptr, SDValue getTruncStore(SDValue Chain, SDLoc dl, SDValue Val, SDValue Ptr,
MachinePointerInfo PtrInfo, EVT TVT, MachinePointerInfo PtrInfo, EVT TVT,
bool isNonTemporal, bool isVolatile, bool isNonTemporal, bool isVolatile,
unsigned Alignment, unsigned Alignment,
const MDNode *TBAAInfo = 0); const MDNode *TBAAInfo = 0);
SDValue getTruncStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue Ptr, SDValue getTruncStore(SDValue Chain, SDLoc dl, SDValue Val, SDValue Ptr,
EVT TVT, MachineMemOperand *MMO); EVT TVT, MachineMemOperand *MMO);
SDValue getIndexedStore(SDValue OrigStoe, DebugLoc dl, SDValue Base, SDValue getIndexedStore(SDValue OrigStoe, SDLoc dl, SDValue Base,
SDValue Offset, ISD::MemIndexedMode AM); SDValue Offset, ISD::MemIndexedMode AM);
/// getSrcValue - Construct a node to track a Value* through the backend. /// getSrcValue - Construct a node to track a Value* through the backend.
@ -804,47 +804,47 @@ public:
/// Note that getMachineNode returns the resultant node. If there is already /// Note that getMachineNode returns the resultant node. If there is already
/// a node of the specified opcode and operands, it returns that node instead /// a node of the specified opcode and operands, it returns that node instead
/// of the current one. /// of the current one.
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT); MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT,
SDValue Op1); SDValue Op1);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT,
SDValue Op1, SDValue Op2); SDValue Op1, SDValue Op2);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT,
SDValue Op1, SDValue Op2, SDValue Op3); SDValue Op1, SDValue Op2, SDValue Op3);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT,
ArrayRef<SDValue> Ops); ArrayRef<SDValue> Ops);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2); MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2,
SDValue Op1); SDValue Op1);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2,
SDValue Op1, SDValue Op2); SDValue Op1, SDValue Op2);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2,
SDValue Op1, SDValue Op2, SDValue Op3); SDValue Op1, SDValue Op2, SDValue Op3);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2,
ArrayRef<SDValue> Ops); ArrayRef<SDValue> Ops);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2,
EVT VT3, SDValue Op1, SDValue Op2); EVT VT3, SDValue Op1, SDValue Op2);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2,
EVT VT3, SDValue Op1, SDValue Op2, EVT VT3, SDValue Op1, SDValue Op2,
SDValue Op3); SDValue Op3);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2,
EVT VT3, ArrayRef<SDValue> Ops); EVT VT3, ArrayRef<SDValue> Ops);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2,
EVT VT3, EVT VT4, ArrayRef<SDValue> Ops); EVT VT3, EVT VT4, ArrayRef<SDValue> Ops);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl,
ArrayRef<EVT> ResultTys, ArrayRef<EVT> ResultTys,
ArrayRef<SDValue> Ops); ArrayRef<SDValue> Ops);
MachineSDNode *getMachineNode(unsigned Opcode, DebugLoc dl, SDVTList VTs, MachineSDNode *getMachineNode(unsigned Opcode, SDLoc dl, SDVTList VTs,
ArrayRef<SDValue> Ops); ArrayRef<SDValue> Ops);
/// getTargetExtractSubreg - A convenience function for creating /// getTargetExtractSubreg - A convenience function for creating
/// TargetInstrInfo::EXTRACT_SUBREG nodes. /// TargetInstrInfo::EXTRACT_SUBREG nodes.
SDValue getTargetExtractSubreg(int SRIdx, DebugLoc DL, EVT VT, SDValue getTargetExtractSubreg(int SRIdx, SDLoc DL, EVT VT,
SDValue Operand); SDValue Operand);
/// getTargetInsertSubreg - A convenience function for creating /// getTargetInsertSubreg - A convenience function for creating
/// TargetInstrInfo::INSERT_SUBREG nodes. /// TargetInstrInfo::INSERT_SUBREG nodes.
SDValue getTargetInsertSubreg(int SRIdx, DebugLoc DL, EVT VT, SDValue getTargetInsertSubreg(int SRIdx, SDLoc DL, EVT VT,
SDValue Operand, SDValue Subreg); SDValue Operand, SDValue Subreg);
/// getNodeIfExists - Get the specified node if it's already available, or /// getNodeIfExists - Get the specified node if it's already available, or
@ -998,7 +998,7 @@ public:
/// FoldSetCC - Constant fold a setcc to true or false. /// FoldSetCC - Constant fold a setcc to true or false.
SDValue FoldSetCC(EVT VT, SDValue N1, SDValue FoldSetCC(EVT VT, SDValue N1,
SDValue N2, ISD::CondCode Cond, DebugLoc dl); SDValue N2, ISD::CondCode Cond, SDLoc dl);
/// SignBitIsZero - Return true if the sign bit of Op is known to be zero. We /// SignBitIsZero - Return true if the sign bit of Op is known to be zero. We
/// use this predicate to simplify operations downstream. /// use this predicate to simplify operations downstream.
@ -1072,7 +1072,7 @@ private:
void *&InsertPos); void *&InsertPos);
SDNode *FindModifiedNodeSlot(SDNode *N, const SDValue *Ops, unsigned NumOps, SDNode *FindModifiedNodeSlot(SDNode *N, const SDValue *Ops, unsigned NumOps,
void *&InsertPos); void *&InsertPos);
SDNode *UpdadeDebugLocOnMergedSDNode(SDNode *N, DebugLoc loc); SDNode *UpdadeSDLocOnMergedSDNode(SDNode *N, SDLoc loc);
void DeleteNodeNotInCSEMaps(SDNode *N); void DeleteNodeNotInCSEMaps(SDNode *N);
void DeallocateNode(SDNode *N); void DeallocateNode(SDNode *N);

120
include/llvm/CodeGen/SelectionDAGNodes.h
View File

@ -696,14 +696,14 @@ protected:
return Ret; return Ret;
} }
SDNode(unsigned Opc, const DebugLoc dl, SDVTList VTs, const SDValue *Ops, SDNode(unsigned Opc, unsigned Order, const DebugLoc dl, SDVTList VTs,
unsigned NumOps) const SDValue *Ops, unsigned NumOps)
: NodeType(Opc), OperandsNeedDelete(true), HasDebugValue(false), : NodeType(Opc), OperandsNeedDelete(true), HasDebugValue(false),
SubclassData(0), NodeId(-1), SubclassData(0), NodeId(-1),
OperandList(NumOps ? new SDUse[NumOps] : 0), OperandList(NumOps ? new SDUse[NumOps] : 0),
ValueList(VTs.VTs), UseList(NULL), ValueList(VTs.VTs), UseList(NULL),
NumOperands(NumOps), NumValues(VTs.NumVTs), NumOperands(NumOps), NumValues(VTs.NumVTs),
debugLoc(dl) { debugLoc(dl), IROrder(Order) {
for (unsigned i = 0; i != NumOps; ++i) { for (unsigned i = 0; i != NumOps; ++i) {
OperandList[i].setUser(this); OperandList[i].setUser(this);
OperandList[i].setInitial(Ops[i]); OperandList[i].setInitial(Ops[i]);
@ -713,11 +713,11 @@ protected:
/// This constructor adds no operands itself; operands can be /// This constructor adds no operands itself; operands can be
/// set later with InitOperands. /// set later with InitOperands.
SDNode(unsigned Opc, const DebugLoc dl, SDVTList VTs) SDNode(unsigned Opc, unsigned Order, const DebugLoc dl, SDVTList VTs)
: NodeType(Opc), OperandsNeedDelete(false), HasDebugValue(false), : NodeType(Opc), OperandsNeedDelete(false), HasDebugValue(false),
SubclassData(0), NodeId(-1), OperandList(0), ValueList(VTs.VTs), SubclassData(0), NodeId(-1), OperandList(0),
UseList(NULL), NumOperands(0), NumValues(VTs.NumVTs), ValueList(VTs.VTs), UseList(NULL), NumOperands(0), NumValues(VTs.NumVTs),
debugLoc(dl) {} debugLoc(dl), IROrder(Order) {}
/// InitOperands - Initialize the operands list of this with 1 operand. /// InitOperands - Initialize the operands list of this with 1 operand.
void InitOperands(SDUse *Ops, const SDValue &Op0) { void InitOperands(SDUse *Ops, const SDValue &Op0) {
@ -901,8 +901,8 @@ inline void SDUse::setNode(SDNode *N) {
class UnarySDNode : public SDNode { class UnarySDNode : public SDNode {
SDUse Op; SDUse Op;
public: public:
UnarySDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, SDValue X) UnarySDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs, SDValue X)
: SDNode(Opc, dl, VTs) { : SDNode(Opc, Order, dl, VTs) {
InitOperands(&Op, X); InitOperands(&Op, X);
} }
}; };
@ -912,8 +912,8 @@ public:
class BinarySDNode : public SDNode { class BinarySDNode : public SDNode {
SDUse Ops[2]; SDUse Ops[2];
public: public:
BinarySDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, SDValue X, SDValue Y) BinarySDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs, SDValue X, SDValue Y)
: SDNode(Opc, dl, VTs) { : SDNode(Opc, Order, dl, VTs) {
InitOperands(Ops, X, Y); InitOperands(Ops, X, Y);
} }
}; };
@ -923,9 +923,9 @@ public:
class TernarySDNode : public SDNode { class TernarySDNode : public SDNode {
SDUse Ops[3]; SDUse Ops[3];
public: public:
TernarySDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, SDValue X, SDValue Y, TernarySDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs,
SDValue Z) SDValue X, SDValue Y, SDValue Z)
: SDNode(Opc, dl, VTs) { : SDNode(Opc, Order, dl, VTs) {
InitOperands(Ops, X, Y, Z); InitOperands(Ops, X, Y, Z);
} }
}; };
@ -945,7 +945,7 @@ public:
#else #else
explicit HandleSDNode(SDValue X) explicit HandleSDNode(SDValue X)
#endif #endif
: SDNode(ISD::HANDLENODE, DebugLoc(), getSDVTList(MVT::Other)) { : SDNode(ISD::HANDLENODE, 0, DebugLoc(), getSDVTList(MVT::Other)) {
InitOperands(&Op, X); InitOperands(&Op, X);
} }
~HandleSDNode(); ~HandleSDNode();
@ -963,10 +963,10 @@ protected:
MachineMemOperand *MMO; MachineMemOperand *MMO;
public: public:
MemSDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, EVT MemoryVT, MemSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs,
MachineMemOperand *MMO); EVT MemoryVT, MachineMemOperand *MMO);
MemSDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, const SDValue *Ops, MemSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs, const SDValue *Ops,
unsigned NumOps, EVT MemoryVT, MachineMemOperand *MMO); unsigned NumOps, EVT MemoryVT, MachineMemOperand *MMO);
bool readMem() const { return MMO->isLoad(); } bool readMem() const { return MMO->isLoad(); }
@ -1090,27 +1090,27 @@ public:
// Swp: swap value // Swp: swap value
// SrcVal: address to update as a Value (used for MemOperand) // SrcVal: address to update as a Value (used for MemOperand)
// Align: alignment of memory // Align: alignment of memory
AtomicSDNode(unsigned Opc, DebugLoc dl, SDVTList VTL, EVT MemVT, AtomicSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTL, EVT MemVT,
SDValue Chain, SDValue Ptr, SDValue Chain, SDValue Ptr,
SDValue Cmp, SDValue Swp, MachineMemOperand *MMO, SDValue Cmp, SDValue Swp, MachineMemOperand *MMO,
AtomicOrdering Ordering, SynchronizationScope SynchScope) AtomicOrdering Ordering, SynchronizationScope SynchScope)
: MemSDNode(Opc, dl, VTL, MemVT, MMO) { : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) {
InitAtomic(Ordering, SynchScope); InitAtomic(Ordering, SynchScope);
InitOperands(Ops, Chain, Ptr, Cmp, Swp); InitOperands(Ops, Chain, Ptr, Cmp, Swp);
} }
AtomicSDNode(unsigned Opc, DebugLoc dl, SDVTList VTL, EVT MemVT, AtomicSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTL, EVT MemVT,
SDValue Chain, SDValue Ptr, SDValue Chain, SDValue Ptr,
SDValue Val, MachineMemOperand *MMO, SDValue Val, MachineMemOperand *MMO,
AtomicOrdering Ordering, SynchronizationScope SynchScope) AtomicOrdering Ordering, SynchronizationScope SynchScope)
: MemSDNode(Opc, dl, VTL, MemVT, MMO) { : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) {
InitAtomic(Ordering, SynchScope); InitAtomic(Ordering, SynchScope);
InitOperands(Ops, Chain, Ptr, Val); InitOperands(Ops, Chain, Ptr, Val);
} }
AtomicSDNode(unsigned Opc, DebugLoc dl, SDVTList VTL, EVT MemVT, AtomicSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTL, EVT MemVT,
SDValue Chain, SDValue Ptr, SDValue Chain, SDValue Ptr,
MachineMemOperand *MMO, MachineMemOperand *MMO,
AtomicOrdering Ordering, SynchronizationScope SynchScope) AtomicOrdering Ordering, SynchronizationScope SynchScope)
: MemSDNode(Opc, dl, VTL, MemVT, MMO) { : MemSDNode(Opc, Order, dl, VTL, MemVT, MMO) {
InitAtomic(Ordering, SynchScope); InitAtomic(Ordering, SynchScope);
InitOperands(Ops, Chain, Ptr); InitOperands(Ops, Chain, Ptr);
} }
@ -1148,10 +1148,10 @@ public:
/// with a value not less than FIRST_TARGET_MEMORY_OPCODE. /// with a value not less than FIRST_TARGET_MEMORY_OPCODE.
class MemIntrinsicSDNode : public MemSDNode { class MemIntrinsicSDNode : public MemSDNode {
public: public:
MemIntrinsicSDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, MemIntrinsicSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs,
const SDValue *Ops, unsigned NumOps, const SDValue *Ops, unsigned NumOps,
EVT MemoryVT, MachineMemOperand *MMO) EVT MemoryVT, MachineMemOperand *MMO)
: MemSDNode(Opc, dl, VTs, Ops, NumOps, MemoryVT, MMO) { : MemSDNode(Opc, Order, dl, VTs, Ops, NumOps, MemoryVT, MMO) {
} }
// Methods to support isa and dyn_cast // Methods to support isa and dyn_cast
@ -1181,9 +1181,8 @@ class ShuffleVectorSDNode : public SDNode {
const int *Mask; const int *Mask;
protected: protected:
friend class SelectionDAG; friend class SelectionDAG;
ShuffleVectorSDNode(EVT VT, DebugLoc dl, SDValue N1, SDValue N2, ShuffleVectorSDNode(EVT VT, unsigned Order, DebugLoc dl, SDValue N1, SDValue N2, const int *M)
const int *M) : SDNode(ISD::VECTOR_SHUFFLE, Order, dl, getSDVTList(VT)), Mask(M) {
: SDNode(ISD::VECTOR_SHUFFLE, dl, getSDVTList(VT)), Mask(M) {
InitOperands(Ops, N1, N2); InitOperands(Ops, N1, N2);
} }
public: public:
@ -1219,7 +1218,7 @@ class ConstantSDNode : public SDNode {
friend class SelectionDAG; friend class SelectionDAG;
ConstantSDNode(bool isTarget, const ConstantInt *val, EVT VT) ConstantSDNode(bool isTarget, const ConstantInt *val, EVT VT)
: SDNode(isTarget ? ISD::TargetConstant : ISD::Constant, : SDNode(isTarget ? ISD::TargetConstant : ISD::Constant,
DebugLoc(), getSDVTList(VT)), Value(val) { 0, DebugLoc(), getSDVTList(VT)), Value(val) {
} }
public: public:
@ -1243,7 +1242,7 @@ class ConstantFPSDNode : public SDNode {
friend class SelectionDAG; friend class SelectionDAG;
ConstantFPSDNode(bool isTarget, const ConstantFP *val, EVT VT) ConstantFPSDNode(bool isTarget, const ConstantFP *val, EVT VT)
: SDNode(isTarget ? ISD::TargetConstantFP : ISD::ConstantFP, : SDNode(isTarget ? ISD::TargetConstantFP : ISD::ConstantFP,
DebugLoc(), getSDVTList(VT)), Value(val) { 0, DebugLoc(), getSDVTList(VT)), Value(val) {
} }
public: public:
@ -1286,7 +1285,7 @@ class GlobalAddressSDNode : public SDNode {
int64_t Offset; int64_t Offset;
unsigned char TargetFlags; unsigned char TargetFlags;
friend class SelectionDAG; friend class SelectionDAG;
GlobalAddressSDNode(unsigned Opc, DebugLoc DL, const GlobalValue *GA, EVT VT, GlobalAddressSDNode(unsigned Opc, unsigned Order, DebugLoc DL, const GlobalValue *GA, EVT VT,
int64_t o, unsigned char TargetFlags); int64_t o, unsigned char TargetFlags);
public: public:
@ -1309,7 +1308,7 @@ class FrameIndexSDNode : public SDNode {
friend class SelectionDAG; friend class SelectionDAG;
FrameIndexSDNode(int fi, EVT VT, bool isTarg) FrameIndexSDNode(int fi, EVT VT, bool isTarg)
: SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex, : SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex,
DebugLoc(), getSDVTList(VT)), FI(fi) { 0, DebugLoc(), getSDVTList(VT)), FI(fi) {
} }
public: public:
@ -1327,7 +1326,7 @@ class JumpTableSDNode : public SDNode {
friend class SelectionDAG; friend class SelectionDAG;
JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned char TF) JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned char TF)
: SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable, : SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable,
DebugLoc(), getSDVTList(VT)), JTI(jti), TargetFlags(TF) { 0, DebugLoc(), getSDVTList(VT)), JTI(jti), TargetFlags(TF) {
} }
public: public:
@ -1351,16 +1350,14 @@ class ConstantPoolSDNode : public SDNode {
friend class SelectionDAG; friend class SelectionDAG;
ConstantPoolSDNode(bool isTarget, const Constant *c, EVT VT, int o, ConstantPoolSDNode(bool isTarget, const Constant *c, EVT VT, int o,
unsigned Align, unsigned char TF) unsigned Align, unsigned char TF)
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0, DebugLoc(),
DebugLoc(),
getSDVTList(VT)), Offset(o), Alignment(Align), TargetFlags(TF) { getSDVTList(VT)), Offset(o), Alignment(Align), TargetFlags(TF) {
assert(Offset >= 0 && "Offset is too large"); assert(Offset >= 0 && "Offset is too large");
Val.ConstVal = c; Val.ConstVal = c;
} }
ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v, ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v,
EVT VT, int o, unsigned Align, unsigned char TF) EVT VT, int o, unsigned Align, unsigned char TF)
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0, DebugLoc(),
DebugLoc(),
getSDVTList(VT)), Offset(o), Alignment(Align), TargetFlags(TF) { getSDVTList(VT)), Offset(o), Alignment(Align), TargetFlags(TF) {
assert(Offset >= 0 && "Offset is too large"); assert(Offset >= 0 && "Offset is too large");
Val.MachineCPVal = v; Val.MachineCPVal = v;
@ -1409,7 +1406,7 @@ class TargetIndexSDNode : public SDNode {
public: public:
TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned char TF) TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned char TF)
: SDNode(ISD::TargetIndex, DebugLoc(), getSDVTList(VT)), : SDNode(ISD::TargetIndex, 0, DebugLoc(), getSDVTList(VT)),
TargetFlags(TF), Index(Idx), Offset(Ofs) {} TargetFlags(TF), Index(Idx), Offset(Ofs) {}
public: public:
@ -1429,7 +1426,7 @@ class BasicBlockSDNode : public SDNode {
/// blocks out of order when they're jumped to, which makes it a bit /// blocks out of order when they're jumped to, which makes it a bit
/// harder. Let's see if we need it first. /// harder. Let's see if we need it first.
explicit BasicBlockSDNode(MachineBasicBlock *mbb) explicit BasicBlockSDNode(MachineBasicBlock *mbb)
: SDNode(ISD::BasicBlock, DebugLoc(), getSDVTList(MVT::Other)), MBB(mbb) { : SDNode(ISD::BasicBlock, 0, DebugLoc(), getSDVTList(MVT::Other)), MBB(mbb) {
} }
public: public:
@ -1473,7 +1470,7 @@ class SrcValueSDNode : public SDNode {
friend class SelectionDAG; friend class SelectionDAG;
/// Create a SrcValue for a general value. /// Create a SrcValue for a general value.
explicit SrcValueSDNode(const Value *v) explicit SrcValueSDNode(const Value *v)
: SDNode(ISD::SRCVALUE, DebugLoc(), getSDVTList(MVT::Other)), V(v) {} : SDNode(ISD::SRCVALUE, 0, DebugLoc(), getSDVTList(MVT::Other)), V(v) {}
public: public:
/// getValue - return the contained Value. /// getValue - return the contained Value.
@ -1488,7 +1485,7 @@ class MDNodeSDNode : public SDNode {
const MDNode *MD; const MDNode *MD;
friend class SelectionDAG; friend class SelectionDAG;
explicit MDNodeSDNode(const MDNode *md) explicit MDNodeSDNode(const MDNode *md)
: SDNode(ISD::MDNODE_SDNODE, DebugLoc(), getSDVTList(MVT::Other)), MD(md) {} : SDNode(ISD::MDNODE_SDNODE, 0, DebugLoc(), getSDVTList(MVT::Other)), MD(md) {}
public: public:
const MDNode *getMD() const { return MD; } const MDNode *getMD() const { return MD; }
@ -1503,7 +1500,7 @@ class RegisterSDNode : public SDNode {
unsigned Reg; unsigned Reg;
friend class SelectionDAG; friend class SelectionDAG;
RegisterSDNode(unsigned reg, EVT VT) RegisterSDNode(unsigned reg, EVT VT)
: SDNode(ISD::Register, DebugLoc(), getSDVTList(VT)), Reg(reg) { : SDNode(ISD::Register, 0, DebugLoc(), getSDVTList(VT)), Reg(reg) {
} }
public: public:
@ -1519,7 +1516,7 @@ class RegisterMaskSDNode : public SDNode {
const uint32_t *RegMask; const uint32_t *RegMask;
friend class SelectionDAG; friend class SelectionDAG;
RegisterMaskSDNode(const uint32_t *mask) RegisterMaskSDNode(const uint32_t *mask)
: SDNode(ISD::RegisterMask, DebugLoc(), getSDVTList(MVT::Untyped)), : SDNode(ISD::RegisterMask, 0, DebugLoc(), getSDVTList(MVT::Untyped)),
RegMask(mask) {} RegMask(mask) {}
public: public:
@ -1537,7 +1534,7 @@ class BlockAddressSDNode : public SDNode {
friend class SelectionDAG; friend class SelectionDAG;
BlockAddressSDNode(unsigned NodeTy, EVT VT, const BlockAddress *ba, BlockAddressSDNode(unsigned NodeTy, EVT VT, const BlockAddress *ba,
int64_t o, unsigned char Flags) int64_t o, unsigned char Flags)
: SDNode(NodeTy, DebugLoc(), getSDVTList(VT)), : SDNode(NodeTy, 0, DebugLoc(), getSDVTList(VT)),
BA(ba), Offset(o), TargetFlags(Flags) { BA(ba), Offset(o), TargetFlags(Flags) {
} }
public: public:
@ -1555,8 +1552,8 @@ class EHLabelSDNode : public SDNode {
SDUse Chain; SDUse Chain;
MCSymbol *Label; MCSymbol *Label;
friend class SelectionDAG; friend class SelectionDAG;
EHLabelSDNode(DebugLoc dl, SDValue ch, MCSymbol *L) EHLabelSDNode(unsigned Order, DebugLoc dl, SDValue ch, MCSymbol *L)
: SDNode(ISD::EH_LABEL, dl, getSDVTList(MVT::Other)), Label(L) { : SDNode(ISD::EH_LABEL, Order, dl, getSDVTList(MVT::Other)), Label(L) {
InitOperands(&Chain, ch); InitOperands(&Chain, ch);
} }
public: public:
@ -1574,7 +1571,7 @@ class ExternalSymbolSDNode : public SDNode {
friend class SelectionDAG; friend class SelectionDAG;
ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned char TF, EVT VT) ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned char TF, EVT VT)
: SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol, : SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol,
DebugLoc(), getSDVTList(VT)), Symbol(Sym), TargetFlags(TF) { 0, DebugLoc(), getSDVTList(VT)), Symbol(Sym), TargetFlags(TF) {
} }
public: public:
@ -1591,7 +1588,7 @@ class CondCodeSDNode : public SDNode {
ISD::CondCode Condition; ISD::CondCode Condition;
friend class SelectionDAG; friend class SelectionDAG;
explicit CondCodeSDNode(ISD::CondCode Cond) explicit CondCodeSDNode(ISD::CondCode Cond)
: SDNode(ISD::CONDCODE, DebugLoc(), getSDVTList(MVT::Other)), : SDNode(ISD::CONDCODE, 0, DebugLoc(), getSDVTList(MVT::Other)),
Condition(Cond) { Condition(Cond) {
} }
public: public:
@ -1608,9 +1605,9 @@ public:
class CvtRndSatSDNode : public SDNode { class CvtRndSatSDNode : public SDNode {
ISD::CvtCode CvtCode; ISD::CvtCode CvtCode;
friend class SelectionDAG; friend class SelectionDAG;
explicit CvtRndSatSDNode(EVT VT, DebugLoc dl, const SDValue *Ops, explicit CvtRndSatSDNode(EVT VT, unsigned Order, DebugLoc dl, const SDValue *Ops,
unsigned NumOps, ISD::CvtCode Code) unsigned NumOps, ISD::CvtCode Code)
: SDNode(ISD::CONVERT_RNDSAT, dl, getSDVTList(VT), Ops, NumOps), : SDNode(ISD::CONVERT_RNDSAT, Order, dl, getSDVTList(VT), Ops, NumOps),
CvtCode(Code) { CvtCode(Code) {
assert(NumOps == 5 && "wrong number of operations"); assert(NumOps == 5 && "wrong number of operations");
} }
@ -1628,7 +1625,7 @@ class VTSDNode : public SDNode {
EVT ValueType; EVT ValueType;
friend class SelectionDAG; friend class SelectionDAG;
explicit VTSDNode(EVT VT) explicit VTSDNode(EVT VT)
: SDNode(ISD::VALUETYPE, DebugLoc(), getSDVTList(MVT::Other)), : SDNode(ISD::VALUETYPE, 0, DebugLoc(), getSDVTList(MVT::Other)),
ValueType(VT) { ValueType(VT) {
} }
public: public:
@ -1651,10 +1648,10 @@ class LSBaseSDNode : public MemSDNode {
*/ */
SDUse Ops[4]; SDUse Ops[4];
public: public:
LSBaseSDNode(ISD::NodeType NodeTy, DebugLoc dl, SDValue *Operands, LSBaseSDNode(ISD::NodeType NodeTy, unsigned Order, DebugLoc dl, SDValue *Operands,
unsigned numOperands, SDVTList VTs, ISD::MemIndexedMode AM, unsigned numOperands, SDVTList VTs, ISD::MemIndexedMode AM,
EVT MemVT, MachineMemOperand *MMO) EVT MemVT, MachineMemOperand *MMO)
: MemSDNode(NodeTy, dl, VTs, MemVT, MMO) { : MemSDNode(NodeTy, Order, dl, VTs, MemVT, MMO) {
SubclassData |= AM << 2; SubclassData |= AM << 2;
assert(getAddressingMode() == AM && "MemIndexedMode encoding error!"); assert(getAddressingMode() == AM && "MemIndexedMode encoding error!");
InitOperands(Ops, Operands, numOperands); InitOperands(Ops, Operands, numOperands);
@ -1688,11 +1685,10 @@ public:
/// ///
class LoadSDNode : public LSBaseSDNode { class LoadSDNode : public LSBaseSDNode {
friend class SelectionDAG; friend class SelectionDAG;
LoadSDNode(SDValue *ChainPtrOff, DebugLoc dl, SDVTList VTs, LoadSDNode(SDValue *ChainPtrOff, unsigned Order, DebugLoc dl, SDVTList VTs,
ISD::MemIndexedMode AM, ISD::LoadExtType ETy, EVT MemVT, ISD::MemIndexedMode AM, ISD::LoadExtType ETy, EVT MemVT,
MachineMemOperand *MMO) MachineMemOperand *MMO)
: LSBaseSDNode(ISD::LOAD, dl, ChainPtrOff, 3, : LSBaseSDNode(ISD::LOAD, Order, dl, ChainPtrOff, 3, VTs, AM, MemVT, MMO) {
VTs, AM, MemVT, MMO) {
SubclassData |= (unsigned short)ETy; SubclassData |= (unsigned short)ETy;
assert(getExtensionType() == ETy && "LoadExtType encoding error!"); assert(getExtensionType() == ETy && "LoadExtType encoding error!");
assert(readMem() && "Load MachineMemOperand is not a load!"); assert(readMem() && "Load MachineMemOperand is not a load!");
@ -1718,10 +1714,10 @@ public:
/// ///
class StoreSDNode : public LSBaseSDNode { class StoreSDNode : public LSBaseSDNode {
friend class SelectionDAG; friend class SelectionDAG;
StoreSDNode(SDValue *ChainValuePtrOff, DebugLoc dl, SDVTList VTs, StoreSDNode(SDValue *ChainValuePtrOff, unsigned Order, DebugLoc dl,
ISD::MemIndexedMode AM, bool isTrunc, EVT MemVT, SDVTList VTs, ISD::MemIndexedMode AM, bool isTrunc, EVT MemVT,
MachineMemOperand *MMO) MachineMemOperand *MMO)
: LSBaseSDNode(ISD::STORE, dl, ChainValuePtrOff, 4, : LSBaseSDNode(ISD::STORE, Order, dl, ChainValuePtrOff, 4,
VTs, AM, MemVT, MMO) { VTs, AM, MemVT, MMO) {
SubclassData |= (unsigned short)isTrunc; SubclassData |= (unsigned short)isTrunc;
assert(isTruncatingStore() == isTrunc && "isTrunc encoding error!"); assert(isTruncatingStore() == isTrunc && "isTrunc encoding error!");
@ -1754,8 +1750,8 @@ public:
private: private:
friend class SelectionDAG; friend class SelectionDAG;
MachineSDNode(unsigned Opc, const DebugLoc DL, SDVTList VTs) MachineSDNode(unsigned Opc, unsigned Order, const DebugLoc DL, SDVTList VTs)
: SDNode(Opc, DL, VTs), MemRefs(0), MemRefsEnd(0) {} : SDNode(Opc, Order, DL, VTs), MemRefs(0), MemRefsEnd(0) {}
/// LocalOperands - Operands for this instruction, if they fit here. If /// LocalOperands - Operands for this instruction, if they fit here. If
/// they don't, this field is unused. /// they don't, this field is unused.

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

@ -30,7 +30,6 @@
#include "llvm/IR/CallingConv.h" #include "llvm/IR/CallingConv.h"
#include "llvm/IR/InlineAsm.h" #include "llvm/IR/InlineAsm.h"
#include "llvm/Support/CallSite.h" #include "llvm/Support/CallSite.h"
#include "llvm/Support/DebugLoc.h"
#include "llvm/Target/TargetCallingConv.h" #include "llvm/Target/TargetCallingConv.h"
#include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetMachine.h"
#include <climits> #include <climits>
@ -1717,11 +1716,11 @@ public:
void softenSetCCOperands(SelectionDAG &DAG, EVT VT, void softenSetCCOperands(SelectionDAG &DAG, EVT VT,
SDValue &NewLHS, SDValue &NewRHS, SDValue &NewLHS, SDValue &NewRHS,
ISD::CondCode &CCCode, DebugLoc DL) const; ISD::CondCode &CCCode, SDLoc DL) const;
SDValue makeLibCall(SelectionDAG &DAG, RTLIB::Libcall LC, EVT RetVT, SDValue makeLibCall(SelectionDAG &DAG, RTLIB::Libcall LC, EVT RetVT,
const SDValue *Ops, unsigned NumOps, const SDValue *Ops, unsigned NumOps,
bool isSigned, DebugLoc dl) const; bool isSigned, SDLoc dl) const;
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// TargetLowering Optimization Methods // TargetLowering Optimization Methods
@ -1761,7 +1760,7 @@ public:
/// cast, but it could be generalized for targets with other types of /// cast, but it could be generalized for targets with other types of
/// implicit widening casts. /// implicit widening casts.
bool ShrinkDemandedOp(SDValue Op, unsigned BitWidth, const APInt &Demanded, bool ShrinkDemandedOp(SDValue Op, unsigned BitWidth, const APInt &Demanded,
DebugLoc dl); SDLoc 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
@ -1823,7 +1822,7 @@ public:
/// 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,
DAGCombinerInfo &DCI, DebugLoc dl) const; DAGCombinerInfo &DCI, SDLoc dl) const;
/// isGAPlusOffset - Returns true (and the GlobalValue and the offset) if the /// isGAPlusOffset - Returns true (and the GlobalValue and the offset) if the
/// node is a GlobalAddress + offset. /// node is a GlobalAddress + offset.
@ -1884,7 +1883,7 @@ public:
LowerFormalArguments(SDValue /*Chain*/, CallingConv::ID /*CallConv*/, LowerFormalArguments(SDValue /*Chain*/, CallingConv::ID /*CallConv*/,
bool /*isVarArg*/, bool /*isVarArg*/,
const SmallVectorImpl<ISD::InputArg> &/*Ins*/, const SmallVectorImpl<ISD::InputArg> &/*Ins*/,
DebugLoc /*dl*/, SelectionDAG &/*DAG*/, SDLoc /*dl*/, SelectionDAG &/*DAG*/,
SmallVectorImpl<SDValue> &/*InVals*/) const { SmallVectorImpl<SDValue> &/*InVals*/) const {
llvm_unreachable("Not Implemented"); llvm_unreachable("Not Implemented");
} }
@ -1930,7 +1929,7 @@ public:
SDValue Callee; SDValue Callee;
ArgListTy &Args; ArgListTy &Args;
SelectionDAG &DAG; SelectionDAG &DAG;
DebugLoc DL; SDLoc DL;
ImmutableCallSite *CS; ImmutableCallSite *CS;
SmallVector<ISD::OutputArg, 32> Outs; SmallVector<ISD::OutputArg, 32> Outs;
SmallVector<SDValue, 32> OutVals; SmallVector<SDValue, 32> OutVals;
@ -1941,7 +1940,7 @@ public:
/// ImmutableCallSite \p cs. /// ImmutableCallSite \p cs.
CallLoweringInfo(SDValue chain, Type *retTy, CallLoweringInfo(SDValue chain, Type *retTy,
FunctionType *FTy, bool isTailCall, SDValue callee, FunctionType *FTy, bool isTailCall, SDValue callee,
ArgListTy &args, SelectionDAG &dag, DebugLoc dl, ArgListTy &args, SelectionDAG &dag, SDLoc dl,
ImmutableCallSite &cs) ImmutableCallSite &cs)
: Chain(chain), RetTy(retTy), RetSExt(cs.paramHasAttr(0, Attribute::SExt)), : Chain(chain), RetTy(retTy), RetSExt(cs.paramHasAttr(0, Attribute::SExt)),
RetZExt(cs.paramHasAttr(0, Attribute::ZExt)), IsVarArg(FTy->isVarArg()), RetZExt(cs.paramHasAttr(0, Attribute::ZExt)), IsVarArg(FTy->isVarArg()),
@ -1958,7 +1957,7 @@ public:
bool isVarArg, bool isInReg, unsigned numFixedArgs, bool isVarArg, bool isInReg, unsigned numFixedArgs,
CallingConv::ID callConv, bool isTailCall, CallingConv::ID callConv, bool isTailCall,
bool doesNotReturn, bool isReturnValueUsed, SDValue callee, bool doesNotReturn, bool isReturnValueUsed, SDValue callee,
ArgListTy &args, SelectionDAG &dag, DebugLoc dl) ArgListTy &args, SelectionDAG &dag, SDLoc dl)
: Chain(chain), RetTy(retTy), RetSExt(retSExt), RetZExt(retZExt), : Chain(chain), RetTy(retTy), RetSExt(retSExt), RetZExt(retZExt),
IsVarArg(isVarArg), IsInReg(isInReg), DoesNotReturn(doesNotReturn), IsVarArg(isVarArg), IsInReg(isInReg), DoesNotReturn(doesNotReturn),
IsReturnValueUsed(isReturnValueUsed), IsTailCall(isTailCall), IsReturnValueUsed(isReturnValueUsed), IsTailCall(isTailCall),
@ -2011,7 +2010,7 @@ public:
bool /*isVarArg*/, bool /*isVarArg*/,
const SmallVectorImpl<ISD::OutputArg> &/*Outs*/, const SmallVectorImpl<ISD::OutputArg> &/*Outs*/,
const SmallVectorImpl<SDValue> &/*OutVals*/, const SmallVectorImpl<SDValue> &/*OutVals*/,
DebugLoc /*dl*/, SelectionDAG &/*DAG*/) const { SDLoc /*dl*/, SelectionDAG &/*DAG*/) const {
llvm_unreachable("Not Implemented"); llvm_unreachable("Not Implemented");
} }
@ -2235,7 +2234,7 @@ public:
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Div utility functions // Div utility functions
// //
SDValue BuildExactSDIV(SDValue Op1, SDValue Op2, DebugLoc dl, SDValue BuildExactSDIV(SDValue Op1, SDValue Op2, SDLoc dl,
SelectionDAG &DAG) const; SelectionDAG &DAG) const;
SDValue BuildSDIV(SDNode *N, SelectionDAG &DAG, bool IsAfterLegalization, SDValue BuildSDIV(SDNode *N, SelectionDAG &DAG, bool IsAfterLegalization,
std::vector<SDNode*> *Created) const; std::vector<SDNode*> *Created) const;

6
include/llvm/Target/TargetSelectionDAGInfo.h
View File

@ -54,7 +54,7 @@ public:
/// for another call). If the target chooses to decline an AlwaysInline /// for another call). If the target chooses to decline an AlwaysInline
/// request here, legalize will resort to using simple loads and stores. /// request here, legalize will resort to using simple loads and stores.
virtual SDValue virtual SDValue
EmitTargetCodeForMemcpy(SelectionDAG &DAG, DebugLoc dl, EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Chain,
SDValue Op1, SDValue Op2, SDValue Op1, SDValue Op2,
SDValue Op3, unsigned Align, bool isVolatile, SDValue Op3, unsigned Align, bool isVolatile,
@ -71,7 +71,7 @@ public:
/// SDValue if the target declines to use custom code and a different /// SDValue if the target declines to use custom code and a different
/// lowering strategy should be used. /// lowering strategy should be used.
virtual SDValue virtual SDValue
EmitTargetCodeForMemmove(SelectionDAG &DAG, DebugLoc dl, EmitTargetCodeForMemmove(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Chain,
SDValue Op1, SDValue Op2, SDValue Op1, SDValue Op2,
SDValue Op3, unsigned Align, bool isVolatile, SDValue Op3, unsigned Align, bool isVolatile,
@ -87,7 +87,7 @@ public:
/// SDValue if the target declines to use custom code and a different /// SDValue if the target declines to use custom code and a different
/// lowering strategy should be used. /// lowering strategy should be used.
virtual SDValue virtual SDValue
EmitTargetCodeForMemset(SelectionDAG &DAG, DebugLoc dl, EmitTargetCodeForMemset(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Chain,
SDValue Op1, SDValue Op2, SDValue Op1, SDValue Op2,
SDValue Op3, unsigned Align, bool isVolatile, SDValue Op3, unsigned Align, bool isVolatile,

1056
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
View File

File diff suppressed because it is too large Load Diff

84
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
View File

@ -83,24 +83,24 @@ private:
/// is necessary to spill the vector being inserted into to memory, perform /// is necessary to spill the vector being inserted into to memory, perform
/// the insert there, and then read the result back. /// the insert there, and then read the result back.
SDValue PerformInsertVectorEltInMemory(SDValue Vec, SDValue Val, SDValue PerformInsertVectorEltInMemory(SDValue Vec, SDValue Val,
SDValue Idx, DebugLoc dl); SDValue Idx, SDLoc dl);
SDValue ExpandINSERT_VECTOR_ELT(SDValue Vec, SDValue Val, SDValue ExpandINSERT_VECTOR_ELT(SDValue Vec, SDValue Val,
SDValue Idx, DebugLoc dl); SDValue Idx, SDLoc dl);
/// ShuffleWithNarrowerEltType - Return a vector shuffle operation which /// ShuffleWithNarrowerEltType - Return a vector shuffle operation which
/// performs the same shuffe in terms of order or result bytes, but on a type /// performs the same shuffe in terms of order or result bytes, but on a type
/// whose vector element type is narrower than the original shuffle type. /// whose vector element type is narrower than the original shuffle type.
/// e.g. <v4i32> <0, 1, 0, 1> -> v8i16 <0, 1, 2, 3, 0, 1, 2, 3> /// e.g. <v4i32> <0, 1, 0, 1> -> v8i16 <0, 1, 2, 3, 0, 1, 2, 3>
SDValue ShuffleWithNarrowerEltType(EVT NVT, EVT VT, DebugLoc dl, SDValue ShuffleWithNarrowerEltType(EVT NVT, EVT VT, SDLoc dl,
SDValue N1, SDValue N2, SDValue N1, SDValue N2,
ArrayRef<int> Mask) const; ArrayRef<int> Mask) const;
void LegalizeSetCCCondCode(EVT VT, SDValue &LHS, SDValue &RHS, SDValue &CC, void LegalizeSetCCCondCode(EVT VT, SDValue &LHS, SDValue &RHS, SDValue &CC,
DebugLoc dl); SDLoc dl);
SDValue ExpandLibCall(RTLIB::Libcall LC, SDNode *Node, bool isSigned); SDValue ExpandLibCall(RTLIB::Libcall LC, SDNode *Node, bool isSigned);
SDValue ExpandLibCall(RTLIB::Libcall LC, EVT RetVT, const SDValue *Ops, SDValue ExpandLibCall(RTLIB::Libcall LC, EVT RetVT, const SDValue *Ops,
unsigned NumOps, bool isSigned, DebugLoc dl); unsigned NumOps, bool isSigned, SDLoc dl);
std::pair<SDValue, SDValue> ExpandChainLibCall(RTLIB::Libcall LC, std::pair<SDValue, SDValue> ExpandChainLibCall(RTLIB::Libcall LC,
SDNode *Node, bool isSigned); SDNode *Node, bool isSigned);
@ -117,21 +117,21 @@ private:
void ExpandDivRemLibCall(SDNode *Node, SmallVectorImpl<SDValue> &Results); void ExpandDivRemLibCall(SDNode *Node, SmallVectorImpl<SDValue> &Results);
void ExpandSinCosLibCall(SDNode *Node, SmallVectorImpl<SDValue> &Results); void ExpandSinCosLibCall(SDNode *Node, SmallVectorImpl<SDValue> &Results);
SDValue EmitStackConvert(SDValue SrcOp, EVT SlotVT, EVT DestVT, DebugLoc dl); SDValue EmitStackConvert(SDValue SrcOp, EVT SlotVT, EVT DestVT, SDLoc dl);
SDValue ExpandBUILD_VECTOR(SDNode *Node); SDValue ExpandBUILD_VECTOR(SDNode *Node);
SDValue ExpandSCALAR_TO_VECTOR(SDNode *Node); SDValue ExpandSCALAR_TO_VECTOR(SDNode *Node);
void ExpandDYNAMIC_STACKALLOC(SDNode *Node, void ExpandDYNAMIC_STACKALLOC(SDNode *Node,
SmallVectorImpl<SDValue> &Results); SmallVectorImpl<SDValue> &Results);
SDValue ExpandFCOPYSIGN(SDNode *Node); SDValue ExpandFCOPYSIGN(SDNode *Node);
SDValue ExpandLegalINT_TO_FP(bool isSigned, SDValue LegalOp, EVT DestVT, SDValue ExpandLegalINT_TO_FP(bool isSigned, SDValue LegalOp, EVT DestVT,
DebugLoc dl); SDLoc dl);
SDValue PromoteLegalINT_TO_FP(SDValue LegalOp, EVT DestVT, bool isSigned, SDValue PromoteLegalINT_TO_FP(SDValue LegalOp, EVT DestVT, bool isSigned,
DebugLoc dl); SDLoc dl);
SDValue PromoteLegalFP_TO_INT(SDValue LegalOp, EVT DestVT, bool isSigned, SDValue PromoteLegalFP_TO_INT(SDValue LegalOp, EVT DestVT, bool isSigned,
DebugLoc dl); SDLoc dl);
SDValue ExpandBSWAP(SDValue Op, DebugLoc dl); SDValue ExpandBSWAP(SDValue Op, SDLoc dl);
SDValue ExpandBitCount(unsigned Opc, SDValue Op, DebugLoc dl); SDValue ExpandBitCount(unsigned Opc, SDValue Op, SDLoc dl);
SDValue ExpandExtractFromVectorThroughStack(SDValue Op); SDValue ExpandExtractFromVectorThroughStack(SDValue Op);
SDValue ExpandInsertToVectorThroughStack(SDValue Op); SDValue ExpandInsertToVectorThroughStack(SDValue Op);
@ -185,7 +185,7 @@ public:
/// whose vector element type is narrower than the original shuffle type. /// whose vector element type is narrower than the original shuffle type.
/// e.g. <v4i32> <0, 1, 0, 1> -> v8i16 <0, 1, 2, 3, 0, 1, 2, 3> /// e.g. <v4i32> <0, 1, 0, 1> -> v8i16 <0, 1, 2, 3, 0, 1, 2, 3>
SDValue SDValue
SelectionDAGLegalize::ShuffleWithNarrowerEltType(EVT NVT, EVT VT, DebugLoc dl, SelectionDAGLegalize::ShuffleWithNarrowerEltType(EVT NVT, EVT VT, SDLoc dl,
SDValue N1, SDValue N2, SDValue N1, SDValue N2,
ArrayRef<int> Mask) const { ArrayRef<int> Mask) const {
unsigned NumMaskElts = VT.getVectorNumElements(); unsigned NumMaskElts = VT.getVectorNumElements();
@ -251,7 +251,7 @@ void SelectionDAGLegalize::LegalizeDAG() {
SDValue SDValue
SelectionDAGLegalize::ExpandConstantFP(ConstantFPSDNode *CFP, bool UseCP) { SelectionDAGLegalize::ExpandConstantFP(ConstantFPSDNode *CFP, bool UseCP) {
bool Extend = false; bool Extend = false;
DebugLoc dl = CFP->getDebugLoc(); SDLoc dl(CFP);
// If a FP immediate is precise when represented as a float and if the // If a FP immediate is precise when represented as a float and if the
// target can do an extending load from float to double, we put it into // target can do an extending load from float to double, we put it into
@ -311,7 +311,7 @@ static void ExpandUnalignedStore(StoreSDNode *ST, SelectionDAG &DAG,
SDValue Val = ST->getValue(); SDValue Val = ST->getValue();
EVT VT = Val.getValueType(); EVT VT = Val.getValueType();
int Alignment = ST->getAlignment(); int Alignment = ST->getAlignment();
DebugLoc dl = ST->getDebugLoc(); SDLoc dl(ST);
if (ST->getMemoryVT().isFloatingPoint() || if (ST->getMemoryVT().isFloatingPoint() ||
ST->getMemoryVT().isVector()) { ST->getMemoryVT().isVector()) {
EVT intVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits()); EVT intVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
@ -432,7 +432,7 @@ ExpandUnalignedLoad(LoadSDNode *LD, SelectionDAG &DAG,
SDValue Ptr = LD->getBasePtr(); SDValue Ptr = LD->getBasePtr();
EVT VT = LD->getValueType(0); EVT VT = LD->getValueType(0);
EVT LoadedVT = LD->getMemoryVT(); EVT LoadedVT = LD->getMemoryVT();
DebugLoc dl = LD->getDebugLoc(); SDLoc dl(LD);
if (VT.isFloatingPoint() || VT.isVector()) { if (VT.isFloatingPoint() || VT.isVector()) {
EVT intVT = EVT::getIntegerVT(*DAG.getContext(), LoadedVT.getSizeInBits()); EVT intVT = EVT::getIntegerVT(*DAG.getContext(), LoadedVT.getSizeInBits());
if (TLI.isTypeLegal(intVT) && TLI.isTypeLegal(LoadedVT)) { if (TLI.isTypeLegal(intVT) && TLI.isTypeLegal(LoadedVT)) {
@ -574,7 +574,7 @@ ExpandUnalignedLoad(LoadSDNode *LD, SelectionDAG &DAG,
/// the insert there, and then read the result back. /// the insert there, and then read the result back.
SDValue SelectionDAGLegalize:: SDValue SelectionDAGLegalize::
PerformInsertVectorEltInMemory(SDValue Vec, SDValue Val, SDValue Idx, PerformInsertVectorEltInMemory(SDValue Vec, SDValue Val, SDValue Idx,
DebugLoc dl) { SDLoc dl) {
SDValue Tmp1 = Vec; SDValue Tmp1 = Vec;
SDValue Tmp2 = Val; SDValue Tmp2 = Val;
SDValue Tmp3 = Idx; SDValue Tmp3 = Idx;
@ -616,7 +616,7 @@ PerformInsertVectorEltInMemory(SDValue Vec, SDValue Val, SDValue Idx,
SDValue SelectionDAGLegalize:: SDValue SelectionDAGLegalize::
ExpandINSERT_VECTOR_ELT(SDValue Vec, SDValue Val, SDValue Idx, DebugLoc dl) { ExpandINSERT_VECTOR_ELT(SDValue Vec, SDValue Val, SDValue Idx, SDLoc dl) {
if (ConstantSDNode *InsertPos = dyn_cast<ConstantSDNode>(Idx)) { if (ConstantSDNode *InsertPos = dyn_cast<ConstantSDNode>(Idx)) {
// SCALAR_TO_VECTOR requires that the type of the value being inserted // SCALAR_TO_VECTOR requires that the type of the value being inserted
// match the element type of the vector being created, except for // match the element type of the vector being created, except for
@ -655,7 +655,7 @@ SDValue SelectionDAGLegalize::OptimizeFloatStore(StoreSDNode* ST) {
unsigned Alignment = ST->getAlignment(); unsigned Alignment = ST->getAlignment();
bool isVolatile = ST->isVolatile(); bool isVolatile = ST->isVolatile();
bool isNonTemporal = ST->isNonTemporal(); bool isNonTemporal = ST->isNonTemporal();
DebugLoc dl = ST->getDebugLoc(); SDLoc dl(ST);
if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(ST->getValue())) { if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(ST->getValue())) {
if (CFP->getValueType(0) == MVT::f32 && if (CFP->getValueType(0) == MVT::f32 &&
TLI.isTypeLegal(MVT::i32)) { TLI.isTypeLegal(MVT::i32)) {
@ -703,7 +703,7 @@ void SelectionDAGLegalize::LegalizeStoreOps(SDNode *Node) {
StoreSDNode *ST = cast<StoreSDNode>(Node); StoreSDNode *ST = cast<StoreSDNode>(Node);
SDValue Chain = ST->getChain(); SDValue Chain = ST->getChain();
SDValue Ptr = ST->getBasePtr(); SDValue Ptr = ST->getBasePtr();
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
unsigned Alignment = ST->getAlignment(); unsigned Alignment = ST->getAlignment();
bool isVolatile = ST->isVolatile(); bool isVolatile = ST->isVolatile();
@ -867,7 +867,7 @@ void SelectionDAGLegalize::LegalizeLoadOps(SDNode *Node) {
SDValue Chain = LD->getChain(); // The chain. SDValue Chain = LD->getChain(); // The chain.
SDValue Ptr = LD->getBasePtr(); // The base pointer. SDValue Ptr = LD->getBasePtr(); // The base pointer.
SDValue Value; // The value returned by the load op. SDValue Value; // The value returned by the load op.
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
ISD::LoadExtType ExtType = LD->getExtensionType(); ISD::LoadExtType ExtType = LD->getExtensionType();
if (ExtType == ISD::NON_EXTLOAD) { if (ExtType == ISD::NON_EXTLOAD) {
@ -1253,7 +1253,7 @@ void SelectionDAGLegalize::LegalizeOp(SDNode *Node) {
if (Action == TargetLowering::Expand) { if (Action == TargetLowering::Expand) {
// replace ISD::DEBUGTRAP with ISD::TRAP // replace ISD::DEBUGTRAP with ISD::TRAP
SDValue NewVal; SDValue NewVal;
NewVal = DAG.getNode(ISD::TRAP, Node->getDebugLoc(), Node->getVTList(), NewVal = DAG.getNode(ISD::TRAP, SDLoc(Node), Node->getVTList(),
Node->getOperand(0)); Node->getOperand(0));
ReplaceNode(Node, NewVal.getNode()); ReplaceNode(Node, NewVal.getNode());
LegalizeOp(NewVal.getNode()); LegalizeOp(NewVal.getNode());
@ -1374,7 +1374,7 @@ void SelectionDAGLegalize::LegalizeOp(SDNode *Node) {
SDValue SelectionDAGLegalize::ExpandExtractFromVectorThroughStack(SDValue Op) { SDValue SelectionDAGLegalize::ExpandExtractFromVectorThroughStack(SDValue Op) {
SDValue Vec = Op.getOperand(0); SDValue Vec = Op.getOperand(0);
SDValue Idx = Op.getOperand(1); SDValue Idx = Op.getOperand(1);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// Store the value to a temporary stack slot, then LOAD the returned part. // Store the value to a temporary stack slot, then LOAD the returned part.
SDValue StackPtr = DAG.CreateStackTemporary(Vec.getValueType()); SDValue StackPtr = DAG.CreateStackTemporary(Vec.getValueType());
SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr, SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr,
@ -1408,7 +1408,7 @@ SDValue SelectionDAGLegalize::ExpandInsertToVectorThroughStack(SDValue Op) {
SDValue Vec = Op.getOperand(0); SDValue Vec = Op.getOperand(0);
SDValue Part = Op.getOperand(1); SDValue Part = Op.getOperand(1);
SDValue Idx = Op.getOperand(2); SDValue Idx = Op.getOperand(2);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// Store the value to a temporary stack slot, then LOAD the returned part. // Store the value to a temporary stack slot, then LOAD the returned part.
@ -1453,7 +1453,7 @@ SDValue SelectionDAGLegalize::ExpandVectorBuildThroughStack(SDNode* Node) {
// Create the stack frame object. // Create the stack frame object.
EVT VT = Node->getValueType(0); EVT VT = Node->getValueType(0);
EVT EltVT = VT.getVectorElementType(); EVT EltVT = VT.getVectorElementType();
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
SDValue FIPtr = DAG.CreateStackTemporary(VT); SDValue FIPtr = DAG.CreateStackTemporary(VT);
int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex(); int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex();
MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(FI); MachinePointerInfo PtrInfo = MachinePointerInfo::getFixedStack(FI);
@ -1498,7 +1498,7 @@ SDValue SelectionDAGLegalize::ExpandVectorBuildThroughStack(SDNode* Node) {
} }
SDValue SelectionDAGLegalize::ExpandFCOPYSIGN(SDNode* Node) { SDValue SelectionDAGLegalize::ExpandFCOPYSIGN(SDNode* Node) {
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
SDValue Tmp1 = Node->getOperand(0); SDValue Tmp1 = Node->getOperand(0);
SDValue Tmp2 = Node->getOperand(1); SDValue Tmp2 = Node->getOperand(1);
@ -1563,7 +1563,7 @@ void SelectionDAGLegalize::ExpandDYNAMIC_STACKALLOC(SDNode* Node,
unsigned SPReg = TLI.getStackPointerRegisterToSaveRestore(); unsigned SPReg = TLI.getStackPointerRegisterToSaveRestore();
assert(SPReg && "Target cannot require DYNAMIC_STACKALLOC expansion and" assert(SPReg && "Target cannot require DYNAMIC_STACKALLOC expansion and"
" not tell us which reg is the stack pointer!"); " not tell us which reg is the stack pointer!");
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
EVT VT = Node->getValueType(0); EVT VT = Node->getValueType(0);
SDValue Tmp1 = SDValue(Node, 0); SDValue Tmp1 = SDValue(Node, 0);
SDValue Tmp2 = SDValue(Node, 1); SDValue Tmp2 = SDValue(Node, 1);
@ -1598,7 +1598,7 @@ void SelectionDAGLegalize::ExpandDYNAMIC_STACKALLOC(SDNode* Node,
void SelectionDAGLegalize::LegalizeSetCCCondCode(EVT VT, void SelectionDAGLegalize::LegalizeSetCCCondCode(EVT VT,
SDValue &LHS, SDValue &RHS, SDValue &LHS, SDValue &RHS,
SDValue &CC, SDValue &CC,
DebugLoc dl) { SDLoc dl) {
MVT OpVT = LHS.getSimpleValueType(); MVT OpVT = LHS.getSimpleValueType();
ISD::CondCode CCCode = cast<CondCodeSDNode>(CC)->get(); ISD::CondCode CCCode = cast<CondCodeSDNode>(CC)->get();
switch (TLI.getCondCodeAction(CCCode, OpVT)) { switch (TLI.getCondCodeAction(CCCode, OpVT)) {
@ -1688,7 +1688,7 @@ void SelectionDAGLegalize::LegalizeSetCCCondCode(EVT VT,
SDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp, SDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp,
EVT SlotVT, EVT SlotVT,
EVT DestVT, EVT DestVT,
DebugLoc dl) { SDLoc dl) {
// Create the stack frame object. // Create the stack frame object.
unsigned SrcAlign = unsigned SrcAlign =
TLI.getDataLayout()->getPrefTypeAlignment(SrcOp.getValueType(). TLI.getDataLayout()->getPrefTypeAlignment(SrcOp.getValueType().
@ -1729,7 +1729,7 @@ SDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp,
} }
SDValue SelectionDAGLegalize::ExpandSCALAR_TO_VECTOR(SDNode *Node) { SDValue SelectionDAGLegalize::ExpandSCALAR_TO_VECTOR(SDNode *Node) {
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
// Create a vector sized/aligned stack slot, store the value to element #0, // Create a vector sized/aligned stack slot, store the value to element #0,
// then load the whole vector back out. // then load the whole vector back out.
SDValue StackPtr = DAG.CreateStackTemporary(Node->getValueType(0)); SDValue StackPtr = DAG.CreateStackTemporary(Node->getValueType(0));
@ -1753,7 +1753,7 @@ SDValue SelectionDAGLegalize::ExpandSCALAR_TO_VECTOR(SDNode *Node) {
SDValue SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) { SDValue SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) {
unsigned NumElems = Node->getNumOperands(); unsigned NumElems = Node->getNumOperands();
SDValue Value1, Value2; SDValue Value1, Value2;
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
EVT VT = Node->getValueType(0); EVT VT = Node->getValueType(0);
EVT OpVT = Node->getOperand(0).getValueType(); EVT OpVT = Node->getOperand(0).getValueType();
EVT EltVT = VT.getVectorElementType(); EVT EltVT = VT.getVectorElementType();
@ -1885,7 +1885,7 @@ SDValue SelectionDAGLegalize::ExpandLibCall(RTLIB::Libcall LC, SDNode *Node,
CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false, false, CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false, false,
0, TLI.getLibcallCallingConv(LC), isTailCall, 0, TLI.getLibcallCallingConv(LC), isTailCall,
/*doesNotReturn=*/false, /*isReturnValueUsed=*/true, /*doesNotReturn=*/false, /*isReturnValueUsed=*/true,
Callee, Args, DAG, Node->getDebugLoc()); Callee, Args, DAG, SDLoc(Node));
std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI); std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI);
@ -1900,7 +1900,7 @@ SDValue SelectionDAGLegalize::ExpandLibCall(RTLIB::Libcall LC, SDNode *Node,
/// and returning a result of type RetVT. /// and returning a result of type RetVT.
SDValue SelectionDAGLegalize::ExpandLibCall(RTLIB::Libcall LC, EVT RetVT, SDValue SelectionDAGLegalize::ExpandLibCall(RTLIB::Libcall LC, EVT RetVT,
const SDValue *Ops, unsigned NumOps, const SDValue *Ops, unsigned NumOps,
bool isSigned, DebugLoc dl) { bool isSigned, SDLoc dl) {
TargetLowering::ArgListTy Args; TargetLowering::ArgListTy Args;
Args.reserve(NumOps); Args.reserve(NumOps);
@ -1954,7 +1954,7 @@ SelectionDAGLegalize::ExpandChainLibCall(RTLIB::Libcall LC,
CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false, false, CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false, false,
0, TLI.getLibcallCallingConv(LC), /*isTailCall=*/false, 0, TLI.getLibcallCallingConv(LC), /*isTailCall=*/false,
/*doesNotReturn=*/false, /*isReturnValueUsed=*/true, /*doesNotReturn=*/false, /*isReturnValueUsed=*/true,
Callee, Args, DAG, Node->getDebugLoc()); Callee, Args, DAG, SDLoc(Node));
std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI); std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI);
return CallInfo; return CallInfo;
@ -2086,7 +2086,7 @@ SelectionDAGLegalize::ExpandDivRemLibCall(SDNode *Node,
SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC), SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
TLI.getPointerTy()); TLI.getPointerTy());
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
TargetLowering:: TargetLowering::
CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false, false, CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false, false,
0, TLI.getLibcallCallingConv(LC), /*isTailCall=*/false, 0, TLI.getLibcallCallingConv(LC), /*isTailCall=*/false,
@ -2200,7 +2200,7 @@ SelectionDAGLegalize::ExpandSinCosLibCall(SDNode *Node,
SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC), SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
TLI.getPointerTy()); TLI.getPointerTy());
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
TargetLowering:: TargetLowering::
CallLoweringInfo CLI(InChain, Type::getVoidTy(*DAG.getContext()), CallLoweringInfo CLI(InChain, Type::getVoidTy(*DAG.getContext()),
false, false, false, false, false, false, false, false,
@ -2222,7 +2222,7 @@ SelectionDAGLegalize::ExpandSinCosLibCall(SDNode *Node,
SDValue SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned, SDValue SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned,
SDValue Op0, SDValue Op0,
EVT DestVT, EVT DestVT,
DebugLoc dl) { SDLoc dl) {
if (Op0.getValueType() == MVT::i32 && TLI.isTypeLegal(MVT::f64)) { if (Op0.getValueType() == MVT::i32 && TLI.isTypeLegal(MVT::f64)) {
// simple 32-bit [signed|unsigned] integer to float/double expansion // simple 32-bit [signed|unsigned] integer to float/double expansion
@ -2421,7 +2421,7 @@ SDValue SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned,
SDValue SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDValue LegalOp, SDValue SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDValue LegalOp,
EVT DestVT, EVT DestVT,
bool isSigned, bool isSigned,
DebugLoc dl) { SDLoc dl) {
// First step, figure out the appropriate *INT_TO_FP operation to use. // First step, figure out the appropriate *INT_TO_FP operation to use.
EVT NewInTy = LegalOp.getValueType(); EVT NewInTy = LegalOp.getValueType();
@ -2463,7 +2463,7 @@ SDValue SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDValue LegalOp,
SDValue SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDValue LegalOp, SDValue SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDValue LegalOp,
EVT DestVT, EVT DestVT,
bool isSigned, bool isSigned,
DebugLoc dl) { SDLoc dl) {
// First step, figure out the appropriate FP_TO*INT operation to use. // First step, figure out the appropriate FP_TO*INT operation to use.
EVT NewOutTy = DestVT; EVT NewOutTy = DestVT;
@ -2498,7 +2498,7 @@ SDValue SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDValue LegalOp,
/// ExpandBSWAP - Open code the operations for BSWAP of the specified operation. /// ExpandBSWAP - Open code the operations for BSWAP of the specified operation.
/// ///
SDValue SelectionDAGLegalize::ExpandBSWAP(SDValue Op, DebugLoc dl) { SDValue SelectionDAGLegalize::ExpandBSWAP(SDValue Op, SDLoc dl) {
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
EVT SHVT = TLI.getShiftAmountTy(VT); EVT SHVT = TLI.getShiftAmountTy(VT);
SDValue Tmp1, Tmp2, Tmp3, Tmp4, Tmp5, Tmp6, Tmp7, Tmp8; SDValue Tmp1, Tmp2, Tmp3, Tmp4, Tmp5, Tmp6, Tmp7, Tmp8;
@ -2546,7 +2546,7 @@ SDValue SelectionDAGLegalize::ExpandBSWAP(SDValue Op, DebugLoc dl) {
/// ExpandBitCount - Expand the specified bitcount instruction into operations. /// ExpandBitCount - Expand the specified bitcount instruction into operations.
/// ///
SDValue SelectionDAGLegalize::ExpandBitCount(unsigned Opc, SDValue Op, SDValue SelectionDAGLegalize::ExpandBitCount(unsigned Opc, SDValue Op,
DebugLoc dl) { SDLoc dl) {
switch (Opc) { switch (Opc) {
default: llvm_unreachable("Cannot expand this yet!"); default: llvm_unreachable("Cannot expand this yet!");
case ISD::CTPOP: { case ISD::CTPOP: {
@ -2726,7 +2726,7 @@ std::pair <SDValue, SDValue> SelectionDAGLegalize::ExpandAtomic(SDNode *Node) {
void SelectionDAGLegalize::ExpandNode(SDNode *Node) { void SelectionDAGLegalize::ExpandNode(SDNode *Node) {
SmallVector<SDValue, 8> Results; SmallVector<SDValue, 8> Results;
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
SDValue Tmp1, Tmp2, Tmp3, Tmp4; SDValue Tmp1, Tmp2, Tmp3, Tmp4;
switch (Node->getOpcode()) { switch (Node->getOpcode()) {
case ISD::CTPOP: case ISD::CTPOP:
@ -3742,7 +3742,7 @@ void SelectionDAGLegalize::PromoteNode(SDNode *Node) {
OVT = Node->getOperand(0).getSimpleValueType(); OVT = Node->getOperand(0).getSimpleValueType();
} }
MVT NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT); MVT NVT = TLI.getTypeToPromoteTo(Node->getOpcode(), OVT);
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
SDValue Tmp1, Tmp2, Tmp3; SDValue Tmp1, Tmp2, Tmp3;
switch (Node->getOpcode()) { switch (Node->getOpcode()) {
case ISD::CTTZ: case ISD::CTTZ:

120
lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
View File

@ -118,7 +118,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_MERGE_VALUES(SDNode *N,
SDValue DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(SDNode *N) {
// Convert the inputs to integers, and build a new pair out of them. // Convert the inputs to integers, and build a new pair out of them.
return DAG.getNode(ISD::BUILD_PAIR, N->getDebugLoc(), return DAG.getNode(ISD::BUILD_PAIR, SDLoc(N),
TLI.getTypeToTransformTo(*DAG.getContext(), TLI.getTypeToTransformTo(*DAG.getContext(),
N->getValueType(0)), N->getValueType(0)),
BitConvertToInteger(N->getOperand(0)), BitConvertToInteger(N->getOperand(0)),
@ -133,7 +133,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_ConstantFP(ConstantFPSDNode *N) {
SDValue DAGTypeLegalizer::SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *N) {
SDValue NewOp = BitConvertVectorToIntegerVector(N->getOperand(0)); SDValue NewOp = BitConvertVectorToIntegerVector(N->getOperand(0));
return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, N->getDebugLoc(), return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N),
NewOp.getValueType().getVectorElementType(), NewOp.getValueType().getVectorElementType(),
NewOp, N->getOperand(1)); NewOp, N->getOperand(1));
} }
@ -147,7 +147,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FABS(SDNode *N) {
API.clearBit(Size-1); API.clearBit(Size-1);
SDValue Mask = DAG.getConstant(API, NVT); SDValue Mask = DAG.getConstant(API, NVT);
SDValue Op = GetSoftenedFloat(N->getOperand(0)); SDValue Op = GetSoftenedFloat(N->getOperand(0));
return DAG.getNode(ISD::AND, N->getDebugLoc(), NVT, Op, Mask); return DAG.getNode(ISD::AND, SDLoc(N), NVT, Op, Mask);
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FADD(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FADD(SDNode *N) {
@ -160,7 +160,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FADD(SDNode *N) {
RTLIB::ADD_F80, RTLIB::ADD_F80,
RTLIB::ADD_F128, RTLIB::ADD_F128,
RTLIB::ADD_PPCF128), RTLIB::ADD_PPCF128),
NVT, Ops, 2, false, N->getDebugLoc()); NVT, Ops, 2, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FCEIL(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FCEIL(SDNode *N) {
@ -172,13 +172,13 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FCEIL(SDNode *N) {
RTLIB::CEIL_F80, RTLIB::CEIL_F80,
RTLIB::CEIL_F128, RTLIB::CEIL_F128,
RTLIB::CEIL_PPCF128), RTLIB::CEIL_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FCOPYSIGN(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FCOPYSIGN(SDNode *N) {
SDValue LHS = GetSoftenedFloat(N->getOperand(0)); SDValue LHS = GetSoftenedFloat(N->getOperand(0));
SDValue RHS = BitConvertToInteger(N->getOperand(1)); SDValue RHS = BitConvertToInteger(N->getOperand(1));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT LVT = LHS.getValueType(); EVT LVT = LHS.getValueType();
EVT RVT = RHS.getValueType(); EVT RVT = RHS.getValueType();
@ -226,7 +226,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FCOS(SDNode *N) {
RTLIB::COS_F80, RTLIB::COS_F80,
RTLIB::COS_F128, RTLIB::COS_F128,
RTLIB::COS_PPCF128), RTLIB::COS_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FDIV(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FDIV(SDNode *N) {
@ -239,7 +239,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FDIV(SDNode *N) {
RTLIB::DIV_F80, RTLIB::DIV_F80,
RTLIB::DIV_F128, RTLIB::DIV_F128,
RTLIB::DIV_PPCF128), RTLIB::DIV_PPCF128),
NVT, Ops, 2, false, N->getDebugLoc()); NVT, Ops, 2, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP(SDNode *N) {
@ -251,7 +251,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP(SDNode *N) {
RTLIB::EXP_F80, RTLIB::EXP_F80,
RTLIB::EXP_F128, RTLIB::EXP_F128,
RTLIB::EXP_PPCF128), RTLIB::EXP_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP2(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP2(SDNode *N) {
@ -263,7 +263,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP2(SDNode *N) {
RTLIB::EXP2_F80, RTLIB::EXP2_F80,
RTLIB::EXP2_F128, RTLIB::EXP2_F128,
RTLIB::EXP2_PPCF128), RTLIB::EXP2_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FFLOOR(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FFLOOR(SDNode *N) {
@ -275,7 +275,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FFLOOR(SDNode *N) {
RTLIB::FLOOR_F80, RTLIB::FLOOR_F80,
RTLIB::FLOOR_F128, RTLIB::FLOOR_F128,
RTLIB::FLOOR_PPCF128), RTLIB::FLOOR_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG(SDNode *N) {
@ -287,7 +287,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG(SDNode *N) {
RTLIB::LOG_F80, RTLIB::LOG_F80,
RTLIB::LOG_F128, RTLIB::LOG_F128,
RTLIB::LOG_PPCF128), RTLIB::LOG_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG2(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG2(SDNode *N) {
@ -299,7 +299,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG2(SDNode *N) {
RTLIB::LOG2_F80, RTLIB::LOG2_F80,
RTLIB::LOG2_F128, RTLIB::LOG2_F128,
RTLIB::LOG2_PPCF128), RTLIB::LOG2_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG10(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG10(SDNode *N) {
@ -311,7 +311,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG10(SDNode *N) {
RTLIB::LOG10_F80, RTLIB::LOG10_F80,
RTLIB::LOG10_F128, RTLIB::LOG10_F128,
RTLIB::LOG10_PPCF128), RTLIB::LOG10_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FMA(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FMA(SDNode *N) {
@ -325,7 +325,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FMA(SDNode *N) {
RTLIB::FMA_F80, RTLIB::FMA_F80,
RTLIB::FMA_F128, RTLIB::FMA_F128,
RTLIB::FMA_PPCF128), RTLIB::FMA_PPCF128),
NVT, Ops, 3, false, N->getDebugLoc()); NVT, Ops, 3, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) {
@ -338,7 +338,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) {
RTLIB::MUL_F80, RTLIB::MUL_F80,
RTLIB::MUL_F128, RTLIB::MUL_F128,
RTLIB::MUL_PPCF128), RTLIB::MUL_PPCF128),
NVT, Ops, 2, false, N->getDebugLoc()); NVT, Ops, 2, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FNEARBYINT(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FNEARBYINT(SDNode *N) {
@ -350,7 +350,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FNEARBYINT(SDNode *N) {
RTLIB::NEARBYINT_F80, RTLIB::NEARBYINT_F80,
RTLIB::NEARBYINT_F128, RTLIB::NEARBYINT_F128,
RTLIB::NEARBYINT_PPCF128), RTLIB::NEARBYINT_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FNEG(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FNEG(SDNode *N) {
@ -364,7 +364,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FNEG(SDNode *N) {
RTLIB::SUB_F80, RTLIB::SUB_F80,
RTLIB::SUB_F128, RTLIB::SUB_F128,
RTLIB::SUB_PPCF128), RTLIB::SUB_PPCF128),
NVT, Ops, 2, false, N->getDebugLoc()); NVT, Ops, 2, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(SDNode *N) {
@ -372,7 +372,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(SDNode *N) {
SDValue Op = N->getOperand(0); SDValue Op = N->getOperand(0);
RTLIB::Libcall LC = RTLIB::getFPEXT(Op.getValueType(), N->getValueType(0)); RTLIB::Libcall LC = RTLIB::getFPEXT(Op.getValueType(), N->getValueType(0));
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_EXTEND!"); assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_EXTEND!");
return TLI.makeLibCall(DAG, LC, NVT, &Op, 1, false, N->getDebugLoc()); return TLI.makeLibCall(DAG, LC, NVT, &Op, 1, false, SDLoc(N));
} }
// FIXME: Should we just use 'normal' FP_EXTEND / FP_TRUNC instead of special // FIXME: Should we just use 'normal' FP_EXTEND / FP_TRUNC instead of special
@ -381,7 +381,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FP16_TO_FP32(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue Op = N->getOperand(0); SDValue Op = N->getOperand(0);
return TLI.makeLibCall(DAG, RTLIB::FPEXT_F16_F32, NVT, &Op, 1, false, return TLI.makeLibCall(DAG, RTLIB::FPEXT_F16_F32, NVT, &Op, 1, false,
N->getDebugLoc()); SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FP_ROUND(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FP_ROUND(SDNode *N) {
@ -389,7 +389,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FP_ROUND(SDNode *N) {
SDValue Op = N->getOperand(0); SDValue Op = N->getOperand(0);
RTLIB::Libcall LC = RTLIB::getFPROUND(Op.getValueType(), N->getValueType(0)); RTLIB::Libcall LC = RTLIB::getFPROUND(Op.getValueType(), N->getValueType(0));
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND!"); assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND!");
return TLI.makeLibCall(DAG, LC, NVT, &Op, 1, false, N->getDebugLoc()); return TLI.makeLibCall(DAG, LC, NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) {
@ -402,7 +402,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) {
RTLIB::POW_F80, RTLIB::POW_F80,
RTLIB::POW_F128, RTLIB::POW_F128,
RTLIB::POW_PPCF128), RTLIB::POW_PPCF128),
NVT, Ops, 2, false, N->getDebugLoc()); NVT, Ops, 2, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FPOWI(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FPOWI(SDNode *N) {
@ -416,7 +416,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FPOWI(SDNode *N) {
RTLIB::POWI_F80, RTLIB::POWI_F80,
RTLIB::POWI_F128, RTLIB::POWI_F128,
RTLIB::POWI_PPCF128), RTLIB::POWI_PPCF128),
NVT, Ops, 2, false, N->getDebugLoc()); NVT, Ops, 2, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FREM(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FREM(SDNode *N) {
@ -429,7 +429,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FREM(SDNode *N) {
RTLIB::REM_F80, RTLIB::REM_F80,
RTLIB::REM_F128, RTLIB::REM_F128,
RTLIB::REM_PPCF128), RTLIB::REM_PPCF128),
NVT, Ops, 2, false, N->getDebugLoc()); NVT, Ops, 2, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FRINT(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FRINT(SDNode *N) {
@ -441,7 +441,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FRINT(SDNode *N) {
RTLIB::RINT_F80, RTLIB::RINT_F80,
RTLIB::RINT_F128, RTLIB::RINT_F128,
RTLIB::RINT_PPCF128), RTLIB::RINT_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FSIN(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FSIN(SDNode *N) {
@ -453,7 +453,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FSIN(SDNode *N) {
RTLIB::SIN_F80, RTLIB::SIN_F80,
RTLIB::SIN_F128, RTLIB::SIN_F128,
RTLIB::SIN_PPCF128), RTLIB::SIN_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FSQRT(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FSQRT(SDNode *N) {
@ -465,7 +465,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FSQRT(SDNode *N) {
RTLIB::SQRT_F80, RTLIB::SQRT_F80,
RTLIB::SQRT_F128, RTLIB::SQRT_F128,
RTLIB::SQRT_PPCF128), RTLIB::SQRT_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FSUB(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FSUB(SDNode *N) {
@ -478,7 +478,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FSUB(SDNode *N) {
RTLIB::SUB_F80, RTLIB::SUB_F80,
RTLIB::SUB_F128, RTLIB::SUB_F128,
RTLIB::SUB_PPCF128), RTLIB::SUB_PPCF128),
NVT, Ops, 2, false, N->getDebugLoc()); NVT, Ops, 2, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FTRUNC(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FTRUNC(SDNode *N) {
@ -490,14 +490,14 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FTRUNC(SDNode *N) {
RTLIB::TRUNC_F80, RTLIB::TRUNC_F80,
RTLIB::TRUNC_F128, RTLIB::TRUNC_F128,
RTLIB::TRUNC_PPCF128), RTLIB::TRUNC_PPCF128),
NVT, &Op, 1, false, N->getDebugLoc()); NVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_LOAD(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_LOAD(SDNode *N) {
LoadSDNode *L = cast<LoadSDNode>(N); LoadSDNode *L = cast<LoadSDNode>(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue NewL; SDValue NewL;
if (L->getExtensionType() == ISD::NON_EXTLOAD) { if (L->getExtensionType() == ISD::NON_EXTLOAD) {
@ -526,14 +526,14 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_LOAD(SDNode *N) {
SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT(SDNode *N) {
SDValue LHS = GetSoftenedFloat(N->getOperand(1)); SDValue LHS = GetSoftenedFloat(N->getOperand(1));
SDValue RHS = GetSoftenedFloat(N->getOperand(2)); SDValue RHS = GetSoftenedFloat(N->getOperand(2));
return DAG.getNode(ISD::SELECT, N->getDebugLoc(), return DAG.getNode(ISD::SELECT, SDLoc(N),
LHS.getValueType(), N->getOperand(0),LHS,RHS); LHS.getValueType(), N->getOperand(0),LHS,RHS);
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT_CC(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT_CC(SDNode *N) {
SDValue LHS = GetSoftenedFloat(N->getOperand(2)); SDValue LHS = GetSoftenedFloat(N->getOperand(2));
SDValue RHS = GetSoftenedFloat(N->getOperand(3)); SDValue RHS = GetSoftenedFloat(N->getOperand(3));
return DAG.getNode(ISD::SELECT_CC, N->getDebugLoc(), return DAG.getNode(ISD::SELECT_CC, SDLoc(N),
LHS.getValueType(), N->getOperand(0), LHS.getValueType(), N->getOperand(0),
N->getOperand(1), LHS, RHS, N->getOperand(4)); N->getOperand(1), LHS, RHS, N->getOperand(4));
} }
@ -548,7 +548,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_VAARG(SDNode *N) {
SDValue Ptr = N->getOperand(1); // Get the pointer. SDValue Ptr = N->getOperand(1); // Get the pointer.
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue NewVAARG; SDValue NewVAARG;
NewVAARG = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2), NewVAARG = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2),
@ -565,7 +565,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_XINT_TO_FP(SDNode *N) {
EVT SVT = N->getOperand(0).getValueType(); EVT SVT = N->getOperand(0).getValueType();
EVT RVT = N->getValueType(0); EVT RVT = N->getValueType(0);
EVT NVT = EVT(); EVT NVT = EVT();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// If the input is not legal, eg: i1 -> fp, then it needs to be promoted to // If the input is not legal, eg: i1 -> fp, then it needs to be promoted to
// a larger type, eg: i8 -> fp. Even if it is legal, no libcall may exactly // a larger type, eg: i8 -> fp. Even if it is legal, no libcall may exactly
@ -633,7 +633,7 @@ bool DAGTypeLegalizer::SoftenFloatOperand(SDNode *N, unsigned OpNo) {
} }
SDValue DAGTypeLegalizer::SoftenFloatOp_BITCAST(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatOp_BITCAST(SDNode *N) {
return DAG.getNode(ISD::BITCAST, N->getDebugLoc(), N->getValueType(0), return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0),
GetSoftenedFloat(N->getOperand(0))); GetSoftenedFloat(N->getOperand(0)));
} }
@ -645,7 +645,7 @@ SDValue DAGTypeLegalizer::SoftenFloatOp_FP_ROUND(SDNode *N) {
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND libcall"); assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND libcall");
SDValue Op = GetSoftenedFloat(N->getOperand(0)); SDValue Op = GetSoftenedFloat(N->getOperand(0));
return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, N->getDebugLoc()); return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatOp_BR_CC(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatOp_BR_CC(SDNode *N) {
@ -655,7 +655,7 @@ SDValue DAGTypeLegalizer::SoftenFloatOp_BR_CC(SDNode *N) {
EVT VT = NewLHS.getValueType(); EVT VT = NewLHS.getValueType();
NewLHS = GetSoftenedFloat(NewLHS); NewLHS = GetSoftenedFloat(NewLHS);
NewRHS = GetSoftenedFloat(NewRHS); NewRHS = GetSoftenedFloat(NewRHS);
TLI.softenSetCCOperands(DAG, VT, NewLHS, NewRHS, CCCode, N->getDebugLoc()); TLI.softenSetCCOperands(DAG, VT, NewLHS, NewRHS, CCCode, SDLoc(N));
// If softenSetCCOperands returned a scalar, we need to compare the result // If softenSetCCOperands returned a scalar, we need to compare the result
// against zero to select between true and false values. // against zero to select between true and false values.
@ -676,7 +676,7 @@ SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_SINT(SDNode *N) {
RTLIB::Libcall LC = RTLIB::getFPTOSINT(N->getOperand(0).getValueType(), RVT); RTLIB::Libcall LC = RTLIB::getFPTOSINT(N->getOperand(0).getValueType(), RVT);
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_SINT!"); assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_SINT!");
SDValue Op = GetSoftenedFloat(N->getOperand(0)); SDValue Op = GetSoftenedFloat(N->getOperand(0));
return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, N->getDebugLoc()); return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_UINT(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_UINT(SDNode *N) {
@ -684,14 +684,14 @@ SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_UINT(SDNode *N) {
RTLIB::Libcall LC = RTLIB::getFPTOUINT(N->getOperand(0).getValueType(), RVT); RTLIB::Libcall LC = RTLIB::getFPTOUINT(N->getOperand(0).getValueType(), RVT);
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_UINT!"); assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_UINT!");
SDValue Op = GetSoftenedFloat(N->getOperand(0)); SDValue Op = GetSoftenedFloat(N->getOperand(0));
return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, N->getDebugLoc()); return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatOp_FP32_TO_FP16(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatOp_FP32_TO_FP16(SDNode *N) {
EVT RVT = N->getValueType(0); EVT RVT = N->getValueType(0);
RTLIB::Libcall LC = RTLIB::FPROUND_F32_F16; RTLIB::Libcall LC = RTLIB::FPROUND_F32_F16;
SDValue Op = GetSoftenedFloat(N->getOperand(0)); SDValue Op = GetSoftenedFloat(N->getOperand(0));
return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, N->getDebugLoc()); return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N));
} }
SDValue DAGTypeLegalizer::SoftenFloatOp_SELECT_CC(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatOp_SELECT_CC(SDNode *N) {
@ -701,7 +701,7 @@ SDValue DAGTypeLegalizer::SoftenFloatOp_SELECT_CC(SDNode *N) {
EVT VT = NewLHS.getValueType(); EVT VT = NewLHS.getValueType();
NewLHS = GetSoftenedFloat(NewLHS); NewLHS = GetSoftenedFloat(NewLHS);
NewRHS = GetSoftenedFloat(NewRHS); NewRHS = GetSoftenedFloat(NewRHS);
TLI.softenSetCCOperands(DAG, VT, NewLHS, NewRHS, CCCode, N->getDebugLoc()); TLI.softenSetCCOperands(DAG, VT, NewLHS, NewRHS, CCCode, SDLoc(N));
// If softenSetCCOperands returned a scalar, we need to compare the result // If softenSetCCOperands returned a scalar, we need to compare the result
// against zero to select between true and false values. // against zero to select between true and false values.
@ -724,7 +724,7 @@ SDValue DAGTypeLegalizer::SoftenFloatOp_SETCC(SDNode *N) {
EVT VT = NewLHS.getValueType(); EVT VT = NewLHS.getValueType();
NewLHS = GetSoftenedFloat(NewLHS); NewLHS = GetSoftenedFloat(NewLHS);
NewRHS = GetSoftenedFloat(NewRHS); NewRHS = GetSoftenedFloat(NewRHS);
TLI.softenSetCCOperands(DAG, VT, NewLHS, NewRHS, CCCode, N->getDebugLoc()); TLI.softenSetCCOperands(DAG, VT, NewLHS, NewRHS, CCCode, SDLoc(N));
// If softenSetCCOperands returned a scalar, use it. // If softenSetCCOperands returned a scalar, use it.
if (NewRHS.getNode() == 0) { if (NewRHS.getNode() == 0) {
@ -744,7 +744,7 @@ SDValue DAGTypeLegalizer::SoftenFloatOp_STORE(SDNode *N, unsigned OpNo) {
assert(OpNo == 1 && "Can only soften the stored value!"); assert(OpNo == 1 && "Can only soften the stored value!");
StoreSDNode *ST = cast<StoreSDNode>(N); StoreSDNode *ST = cast<StoreSDNode>(N);
SDValue Val = ST->getValue(); SDValue Val = ST->getValue();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (ST->isTruncatingStore()) if (ST->isTruncatingStore())
// Do an FP_ROUND followed by a non-truncating store. // Do an FP_ROUND followed by a non-truncating store.
@ -850,7 +850,7 @@ void DAGTypeLegalizer::ExpandFloatRes_FABS(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
assert(N->getValueType(0) == MVT::ppcf128 && assert(N->getValueType(0) == MVT::ppcf128 &&
"Logic only correct for ppcf128!"); "Logic only correct for ppcf128!");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Tmp; SDValue Tmp;
GetExpandedFloat(N->getOperand(0), Lo, Tmp); GetExpandedFloat(N->getOperand(0), Lo, Tmp);
Hi = DAG.getNode(ISD::FABS, dl, Tmp.getValueType(), Tmp); Hi = DAG.getNode(ISD::FABS, dl, Tmp.getValueType(), Tmp);
@ -912,7 +912,7 @@ void DAGTypeLegalizer::ExpandFloatRes_FDIV(SDNode *N, SDValue &Lo,
RTLIB::DIV_F128, RTLIB::DIV_F128,
RTLIB::DIV_PPCF128), RTLIB::DIV_PPCF128),
N->getValueType(0), Ops, 2, false, N->getValueType(0), Ops, 2, false,
N->getDebugLoc()); SDLoc(N));
GetPairElements(Call, Lo, Hi); GetPairElements(Call, Lo, Hi);
} }
@ -986,7 +986,7 @@ void DAGTypeLegalizer::ExpandFloatRes_FMA(SDNode *N, SDValue &Lo,
RTLIB::FMA_F128, RTLIB::FMA_F128,
RTLIB::FMA_PPCF128), RTLIB::FMA_PPCF128),
N->getValueType(0), Ops, 3, false, N->getValueType(0), Ops, 3, false,
N->getDebugLoc()); SDLoc(N));
GetPairElements(Call, Lo, Hi); GetPairElements(Call, Lo, Hi);
} }
@ -1000,7 +1000,7 @@ void DAGTypeLegalizer::ExpandFloatRes_FMUL(SDNode *N, SDValue &Lo,
RTLIB::MUL_F128, RTLIB::MUL_F128,
RTLIB::MUL_PPCF128), RTLIB::MUL_PPCF128),
N->getValueType(0), Ops, 2, false, N->getValueType(0), Ops, 2, false,
N->getDebugLoc()); SDLoc(N));
GetPairElements(Call, Lo, Hi); GetPairElements(Call, Lo, Hi);
} }
@ -1018,7 +1018,7 @@ void DAGTypeLegalizer::ExpandFloatRes_FNEARBYINT(SDNode *N,
void DAGTypeLegalizer::ExpandFloatRes_FNEG(SDNode *N, SDValue &Lo, void DAGTypeLegalizer::ExpandFloatRes_FNEG(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
GetExpandedFloat(N->getOperand(0), Lo, Hi); GetExpandedFloat(N->getOperand(0), Lo, Hi);
Lo = DAG.getNode(ISD::FNEG, dl, Lo.getValueType(), Lo); Lo = DAG.getNode(ISD::FNEG, dl, Lo.getValueType(), Lo);
Hi = DAG.getNode(ISD::FNEG, dl, Hi.getValueType(), Hi); Hi = DAG.getNode(ISD::FNEG, dl, Hi.getValueType(), Hi);
@ -1027,7 +1027,7 @@ void DAGTypeLegalizer::ExpandFloatRes_FNEG(SDNode *N, SDValue &Lo,
void DAGTypeLegalizer::ExpandFloatRes_FP_EXTEND(SDNode *N, SDValue &Lo, void DAGTypeLegalizer::ExpandFloatRes_FP_EXTEND(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
Hi = DAG.getNode(ISD::FP_EXTEND, N->getDebugLoc(), NVT, N->getOperand(0)); Hi = DAG.getNode(ISD::FP_EXTEND, SDLoc(N), NVT, N->getOperand(0));
Lo = DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(NVT), Lo = DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(NVT),
APInt(NVT.getSizeInBits(), 0)), NVT); APInt(NVT.getSizeInBits(), 0)), NVT);
} }
@ -1102,7 +1102,7 @@ void DAGTypeLegalizer::ExpandFloatRes_FSUB(SDNode *N, SDValue &Lo,
RTLIB::SUB_F128, RTLIB::SUB_F128,
RTLIB::SUB_PPCF128), RTLIB::SUB_PPCF128),
N->getValueType(0), Ops, 2, false, N->getValueType(0), Ops, 2, false,
N->getDebugLoc()); SDLoc(N));
GetPairElements(Call, Lo, Hi); GetPairElements(Call, Lo, Hi);
} }
@ -1127,7 +1127,7 @@ void DAGTypeLegalizer::ExpandFloatRes_LOAD(SDNode *N, SDValue &Lo,
LoadSDNode *LD = cast<LoadSDNode>(N); LoadSDNode *LD = cast<LoadSDNode>(N);
SDValue Chain = LD->getChain(); SDValue Chain = LD->getChain();
SDValue Ptr = LD->getBasePtr(); SDValue Ptr = LD->getBasePtr();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), LD->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), LD->getValueType(0));
assert(NVT.isByteSized() && "Expanded type not byte sized!"); assert(NVT.isByteSized() && "Expanded type not byte sized!");
@ -1157,7 +1157,7 @@ void DAGTypeLegalizer::ExpandFloatRes_XINT_TO_FP(SDNode *N, SDValue &Lo,
SDValue Src = N->getOperand(0); SDValue Src = N->getOperand(0);
EVT SrcVT = Src.getValueType(); EVT SrcVT = Src.getValueType();
bool isSigned = N->getOpcode() == ISD::SINT_TO_FP; bool isSigned = N->getOpcode() == ISD::SINT_TO_FP;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// First do an SINT_TO_FP, whether the original was signed or unsigned. // First do an SINT_TO_FP, whether the original was signed or unsigned.
// When promoting partial word types to i32 we must honor the signedness, // When promoting partial word types to i32 we must honor the signedness,
@ -1280,7 +1280,7 @@ bool DAGTypeLegalizer::ExpandFloatOperand(SDNode *N, unsigned OpNo) {
void DAGTypeLegalizer::FloatExpandSetCCOperands(SDValue &NewLHS, void DAGTypeLegalizer::FloatExpandSetCCOperands(SDValue &NewLHS,
SDValue &NewRHS, SDValue &NewRHS,
ISD::CondCode &CCCode, ISD::CondCode &CCCode,
DebugLoc dl) { SDLoc dl) {
SDValue LHSLo, LHSHi, RHSLo, RHSHi; SDValue LHSLo, LHSHi, RHSLo, RHSHi;
GetExpandedFloat(NewLHS, LHSLo, LHSHi); GetExpandedFloat(NewLHS, LHSLo, LHSHi);
GetExpandedFloat(NewRHS, RHSLo, RHSHi); GetExpandedFloat(NewRHS, RHSLo, RHSHi);
@ -1310,7 +1310,7 @@ void DAGTypeLegalizer::FloatExpandSetCCOperands(SDValue &NewLHS,
SDValue DAGTypeLegalizer::ExpandFloatOp_BR_CC(SDNode *N) { SDValue DAGTypeLegalizer::ExpandFloatOp_BR_CC(SDNode *N) {
SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3); SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3);
ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get(); ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get();
FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode, N->getDebugLoc()); FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode, SDLoc(N));
// If ExpandSetCCOperands returned a scalar, we need to compare the result // If ExpandSetCCOperands returned a scalar, we need to compare the result
// against zero to select between true and false values. // against zero to select between true and false values.
@ -1331,13 +1331,13 @@ SDValue DAGTypeLegalizer::ExpandFloatOp_FP_ROUND(SDNode *N) {
SDValue Lo, Hi; SDValue Lo, Hi;
GetExpandedFloat(N->getOperand(0), Lo, Hi); GetExpandedFloat(N->getOperand(0), Lo, Hi);
// Round it the rest of the way (e.g. to f32) if needed. // Round it the rest of the way (e.g. to f32) if needed.
return DAG.getNode(ISD::FP_ROUND, N->getDebugLoc(), return DAG.getNode(ISD::FP_ROUND, SDLoc(N),
N->getValueType(0), Hi, N->getOperand(1)); N->getValueType(0), Hi, N->getOperand(1));
} }
SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_SINT(SDNode *N) { SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_SINT(SDNode *N) {
EVT RVT = N->getValueType(0); EVT RVT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on // Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on
// PPC (the libcall is not available). FIXME: Do this in a less hacky way. // PPC (the libcall is not available). FIXME: Do this in a less hacky way.
@ -1358,7 +1358,7 @@ SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_SINT(SDNode *N) {
SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_UINT(SDNode *N) { SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_UINT(SDNode *N) {
EVT RVT = N->getValueType(0); EVT RVT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on // Expand ppcf128 to i32 by hand for the benefit of llvm-gcc bootstrap on
// PPC (the libcall is not available). FIXME: Do this in a less hacky way. // PPC (the libcall is not available). FIXME: Do this in a less hacky way.
@ -1392,7 +1392,7 @@ SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_UINT(SDNode *N) {
SDValue DAGTypeLegalizer::ExpandFloatOp_SELECT_CC(SDNode *N) { SDValue DAGTypeLegalizer::ExpandFloatOp_SELECT_CC(SDNode *N) {
SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1); SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(4))->get(); ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(4))->get();
FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode, N->getDebugLoc()); FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode, SDLoc(N));
// If ExpandSetCCOperands returned a scalar, we need to compare the result // If ExpandSetCCOperands returned a scalar, we need to compare the result
// against zero to select between true and false values. // against zero to select between true and false values.
@ -1410,7 +1410,7 @@ SDValue DAGTypeLegalizer::ExpandFloatOp_SELECT_CC(SDNode *N) {
SDValue DAGTypeLegalizer::ExpandFloatOp_SETCC(SDNode *N) { SDValue DAGTypeLegalizer::ExpandFloatOp_SETCC(SDNode *N) {
SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1); SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get(); ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get();
FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode, N->getDebugLoc()); FloatExpandSetCCOperands(NewLHS, NewRHS, CCCode, SDLoc(N));
// If ExpandSetCCOperands returned a scalar, use it. // If ExpandSetCCOperands returned a scalar, use it.
if (NewRHS.getNode() == 0) { if (NewRHS.getNode() == 0) {
@ -1444,7 +1444,7 @@ SDValue DAGTypeLegalizer::ExpandFloatOp_STORE(SDNode *N, unsigned OpNo) {
SDValue Lo, Hi; SDValue Lo, Hi;
GetExpandedOp(ST->getValue(), Lo, Hi); GetExpandedOp(ST->getValue(), Lo, Hi);
return DAG.getTruncStore(Chain, N->getDebugLoc(), Hi, Ptr, return DAG.getTruncStore(Chain, SDLoc(N), Hi, Ptr,
ST->getPointerInfo(), ST->getPointerInfo(),
ST->getMemoryVT(), ST->isVolatile(), ST->getMemoryVT(), ST->isVolatile(),
ST->isNonTemporal(), ST->getAlignment()); ST->isNonTemporal(), ST->getAlignment());

182
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp
View File

@ -153,20 +153,20 @@ SDValue DAGTypeLegalizer::PromoteIntRes_MERGE_VALUES(SDNode *N,
SDValue DAGTypeLegalizer::PromoteIntRes_AssertSext(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_AssertSext(SDNode *N) {
// Sign-extend the new bits, and continue the assertion. // Sign-extend the new bits, and continue the assertion.
SDValue Op = SExtPromotedInteger(N->getOperand(0)); SDValue Op = SExtPromotedInteger(N->getOperand(0));
return DAG.getNode(ISD::AssertSext, N->getDebugLoc(), return DAG.getNode(ISD::AssertSext, SDLoc(N),
Op.getValueType(), Op, N->getOperand(1)); Op.getValueType(), Op, N->getOperand(1));
} }
SDValue DAGTypeLegalizer::PromoteIntRes_AssertZext(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_AssertZext(SDNode *N) {
// Zero the new bits, and continue the assertion. // Zero the new bits, and continue the assertion.
SDValue Op = ZExtPromotedInteger(N->getOperand(0)); SDValue Op = ZExtPromotedInteger(N->getOperand(0));
return DAG.getNode(ISD::AssertZext, N->getDebugLoc(), return DAG.getNode(ISD::AssertZext, SDLoc(N),
Op.getValueType(), Op, N->getOperand(1)); Op.getValueType(), Op, N->getOperand(1));
} }
SDValue DAGTypeLegalizer::PromoteIntRes_Atomic0(AtomicSDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_Atomic0(AtomicSDNode *N) {
EVT ResVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT ResVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue Res = DAG.getAtomic(N->getOpcode(), N->getDebugLoc(), SDValue Res = DAG.getAtomic(N->getOpcode(), SDLoc(N),
N->getMemoryVT(), ResVT, N->getMemoryVT(), ResVT,
N->getChain(), N->getBasePtr(), N->getChain(), N->getBasePtr(),
N->getMemOperand(), N->getOrdering(), N->getMemOperand(), N->getOrdering(),
@ -179,7 +179,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_Atomic0(AtomicSDNode *N) {
SDValue DAGTypeLegalizer::PromoteIntRes_Atomic1(AtomicSDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_Atomic1(AtomicSDNode *N) {
SDValue Op2 = GetPromotedInteger(N->getOperand(2)); SDValue Op2 = GetPromotedInteger(N->getOperand(2));
SDValue Res = DAG.getAtomic(N->getOpcode(), N->getDebugLoc(), SDValue Res = DAG.getAtomic(N->getOpcode(), SDLoc(N),
N->getMemoryVT(), N->getMemoryVT(),
N->getChain(), N->getBasePtr(), N->getChain(), N->getBasePtr(),
Op2, N->getMemOperand(), N->getOrdering(), Op2, N->getMemOperand(), N->getOrdering(),
@ -193,7 +193,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_Atomic1(AtomicSDNode *N) {
SDValue DAGTypeLegalizer::PromoteIntRes_Atomic2(AtomicSDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_Atomic2(AtomicSDNode *N) {
SDValue Op2 = GetPromotedInteger(N->getOperand(2)); SDValue Op2 = GetPromotedInteger(N->getOperand(2));
SDValue Op3 = GetPromotedInteger(N->getOperand(3)); SDValue Op3 = GetPromotedInteger(N->getOperand(3));
SDValue Res = DAG.getAtomic(N->getOpcode(), N->getDebugLoc(), SDValue Res = DAG.getAtomic(N->getOpcode(), SDLoc(N),
N->getMemoryVT(), N->getChain(), N->getBasePtr(), N->getMemoryVT(), N->getChain(), N->getBasePtr(),
Op2, Op3, N->getMemOperand(), N->getOrdering(), Op2, Op3, N->getMemOperand(), N->getOrdering(),
N->getSynchScope()); N->getSynchScope());
@ -209,7 +209,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_BITCAST(SDNode *N) {
EVT NInVT = TLI.getTypeToTransformTo(*DAG.getContext(), InVT); EVT NInVT = TLI.getTypeToTransformTo(*DAG.getContext(), InVT);
EVT OutVT = N->getValueType(0); EVT OutVT = N->getValueType(0);
EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT); EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
switch (getTypeAction(InVT)) { switch (getTypeAction(InVT)) {
case TargetLowering::TypeLegal: case TargetLowering::TypeLegal:
@ -264,7 +264,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_BSWAP(SDNode *N) {
SDValue Op = GetPromotedInteger(N->getOperand(0)); SDValue Op = GetPromotedInteger(N->getOperand(0));
EVT OVT = N->getValueType(0); EVT OVT = N->getValueType(0);
EVT NVT = Op.getValueType(); EVT NVT = Op.getValueType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
unsigned DiffBits = NVT.getSizeInBits() - OVT.getSizeInBits(); unsigned DiffBits = NVT.getSizeInBits() - OVT.getSizeInBits();
return DAG.getNode(ISD::SRL, dl, NVT, DAG.getNode(ISD::BSWAP, dl, NVT, Op), return DAG.getNode(ISD::SRL, dl, NVT, DAG.getNode(ISD::BSWAP, dl, NVT, Op),
@ -274,7 +274,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_BSWAP(SDNode *N) {
SDValue DAGTypeLegalizer::PromoteIntRes_BUILD_PAIR(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_BUILD_PAIR(SDNode *N) {
// The pair element type may be legal, or may not promote to the same type as // The pair element type may be legal, or may not promote to the same type as
// the result, for example i14 = BUILD_PAIR (i7, i7). Handle all cases. // the result, for example i14 = BUILD_PAIR (i7, i7). Handle all cases.
return DAG.getNode(ISD::ANY_EXTEND, N->getDebugLoc(), return DAG.getNode(ISD::ANY_EXTEND, SDLoc(N),
TLI.getTypeToTransformTo(*DAG.getContext(), TLI.getTypeToTransformTo(*DAG.getContext(),
N->getValueType(0)), JoinIntegers(N->getOperand(0), N->getValueType(0)), JoinIntegers(N->getOperand(0),
N->getOperand(1))); N->getOperand(1)));
@ -283,7 +283,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_BUILD_PAIR(SDNode *N) {
SDValue DAGTypeLegalizer::PromoteIntRes_Constant(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_Constant(SDNode *N) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
// FIXME there is no actual debug info here // FIXME there is no actual debug info here
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Zero extend things like i1, sign extend everything else. It shouldn't // Zero extend things like i1, sign extend everything else. It shouldn't
// matter in theory which one we pick, but this tends to give better code? // matter in theory which one we pick, but this tends to give better code?
unsigned Opc = VT.isByteSized() ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND; unsigned Opc = VT.isByteSized() ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND;
@ -301,7 +301,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_CONVERT_RNDSAT(SDNode *N) {
CvtCode == ISD::CVT_SF || CvtCode == ISD::CVT_UF) && CvtCode == ISD::CVT_SF || CvtCode == ISD::CVT_UF) &&
"can only promote integers"); "can only promote integers");
EVT OutVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT OutVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
return DAG.getConvertRndSat(OutVT, N->getDebugLoc(), N->getOperand(0), return DAG.getConvertRndSat(OutVT, SDLoc(N), N->getOperand(0),
N->getOperand(1), N->getOperand(2), N->getOperand(1), N->getOperand(2),
N->getOperand(3), N->getOperand(4), CvtCode); N->getOperand(3), N->getOperand(4), CvtCode);
} }
@ -309,7 +309,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_CONVERT_RNDSAT(SDNode *N) {
SDValue DAGTypeLegalizer::PromoteIntRes_CTLZ(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_CTLZ(SDNode *N) {
// Zero extend to the promoted type and do the count there. // Zero extend to the promoted type and do the count there.
SDValue Op = ZExtPromotedInteger(N->getOperand(0)); SDValue Op = ZExtPromotedInteger(N->getOperand(0));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT OVT = N->getValueType(0); EVT OVT = N->getValueType(0);
EVT NVT = Op.getValueType(); EVT NVT = Op.getValueType();
Op = DAG.getNode(N->getOpcode(), dl, NVT, Op); Op = DAG.getNode(N->getOpcode(), dl, NVT, Op);
@ -322,14 +322,14 @@ SDValue DAGTypeLegalizer::PromoteIntRes_CTLZ(SDNode *N) {
SDValue DAGTypeLegalizer::PromoteIntRes_CTPOP(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_CTPOP(SDNode *N) {
// Zero extend to the promoted type and do the count there. // Zero extend to the promoted type and do the count there.
SDValue Op = ZExtPromotedInteger(N->getOperand(0)); SDValue Op = ZExtPromotedInteger(N->getOperand(0));
return DAG.getNode(ISD::CTPOP, N->getDebugLoc(), Op.getValueType(), Op); return DAG.getNode(ISD::CTPOP, SDLoc(N), Op.getValueType(), Op);
} }
SDValue DAGTypeLegalizer::PromoteIntRes_CTTZ(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_CTTZ(SDNode *N) {
SDValue Op = GetPromotedInteger(N->getOperand(0)); SDValue Op = GetPromotedInteger(N->getOperand(0));
EVT OVT = N->getValueType(0); EVT OVT = N->getValueType(0);
EVT NVT = Op.getValueType(); EVT NVT = Op.getValueType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (N->getOpcode() == ISD::CTTZ) { if (N->getOpcode() == ISD::CTTZ) {
// The count is the same in the promoted type except if the original // The count is the same in the promoted type except if the original
// value was zero. This can be handled by setting the bit just off // value was zero. This can be handled by setting the bit just off
@ -342,7 +342,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_CTTZ(SDNode *N) {
} }
SDValue DAGTypeLegalizer::PromoteIntRes_EXTRACT_VECTOR_ELT(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_EXTRACT_VECTOR_ELT(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NVT, N->getOperand(0), return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NVT, N->getOperand(0),
N->getOperand(1)); N->getOperand(1));
@ -351,7 +351,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_EXTRACT_VECTOR_ELT(SDNode *N) {
SDValue DAGTypeLegalizer::PromoteIntRes_FP_TO_XINT(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_FP_TO_XINT(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
unsigned NewOpc = N->getOpcode(); unsigned NewOpc = N->getOpcode();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// If we're promoting a UINT to a larger size and the larger FP_TO_UINT is // If we're promoting a UINT to a larger size and the larger FP_TO_UINT is
// not Legal, check to see if we can use FP_TO_SINT instead. (If both UINT // not Legal, check to see if we can use FP_TO_SINT instead. (If both UINT
@ -374,7 +374,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_FP_TO_XINT(SDNode *N) {
SDValue DAGTypeLegalizer::PromoteIntRes_FP32_TO_FP16(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_FP32_TO_FP16(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Res = DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0)); SDValue Res = DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
@ -384,7 +384,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_FP32_TO_FP16(SDNode *N) {
SDValue DAGTypeLegalizer::PromoteIntRes_INT_EXTEND(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_INT_EXTEND(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (getTypeAction(N->getOperand(0).getValueType()) if (getTypeAction(N->getOperand(0).getValueType())
== TargetLowering::TypePromoteInteger) { == TargetLowering::TypePromoteInteger) {
@ -415,7 +415,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_LOAD(LoadSDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
ISD::LoadExtType ExtType = ISD::LoadExtType ExtType =
ISD::isNON_EXTLoad(N) ? ISD::EXTLOAD : N->getExtensionType(); ISD::isNON_EXTLoad(N) ? ISD::EXTLOAD : N->getExtensionType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Res = DAG.getExtLoad(ExtType, dl, NVT, N->getChain(), N->getBasePtr(), SDValue Res = DAG.getExtLoad(ExtType, dl, NVT, N->getChain(), N->getBasePtr(),
N->getPointerInfo(), N->getPointerInfo(),
N->getMemoryVT(), N->isVolatile(), N->getMemoryVT(), N->isVolatile(),
@ -433,7 +433,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_Overflow(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
EVT ValueVTs[] = { N->getValueType(0), NVT }; EVT ValueVTs[] = { N->getValueType(0), NVT };
SDValue Ops[] = { N->getOperand(0), N->getOperand(1) }; SDValue Ops[] = { N->getOperand(0), N->getOperand(1) };
SDValue Res = DAG.getNode(N->getOpcode(), N->getDebugLoc(), SDValue Res = DAG.getNode(N->getOpcode(), SDLoc(N),
DAG.getVTList(ValueVTs, 2), Ops, 2); DAG.getVTList(ValueVTs, 2), Ops, 2);
// Modified the sum result - switch anything that used the old sum to use // Modified the sum result - switch anything that used the old sum to use
@ -453,7 +453,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_SADDSUBO(SDNode *N, unsigned ResNo) {
SDValue RHS = SExtPromotedInteger(N->getOperand(1)); SDValue RHS = SExtPromotedInteger(N->getOperand(1));
EVT OVT = N->getOperand(0).getValueType(); EVT OVT = N->getOperand(0).getValueType();
EVT NVT = LHS.getValueType(); EVT NVT = LHS.getValueType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Do the arithmetic in the larger type. // Do the arithmetic in the larger type.
unsigned Opcode = N->getOpcode() == ISD::SADDO ? ISD::ADD : ISD::SUB; unsigned Opcode = N->getOpcode() == ISD::SADDO ? ISD::ADD : ISD::SUB;
@ -476,14 +476,14 @@ SDValue DAGTypeLegalizer::PromoteIntRes_SDIV(SDNode *N) {
// Sign extend the input. // Sign extend the input.
SDValue LHS = SExtPromotedInteger(N->getOperand(0)); SDValue LHS = SExtPromotedInteger(N->getOperand(0));
SDValue RHS = SExtPromotedInteger(N->getOperand(1)); SDValue RHS = SExtPromotedInteger(N->getOperand(1));
return DAG.getNode(N->getOpcode(), N->getDebugLoc(), return DAG.getNode(N->getOpcode(), SDLoc(N),
LHS.getValueType(), LHS, RHS); LHS.getValueType(), LHS, RHS);
} }
SDValue DAGTypeLegalizer::PromoteIntRes_SELECT(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_SELECT(SDNode *N) {
SDValue LHS = GetPromotedInteger(N->getOperand(1)); SDValue LHS = GetPromotedInteger(N->getOperand(1));
SDValue RHS = GetPromotedInteger(N->getOperand(2)); SDValue RHS = GetPromotedInteger(N->getOperand(2));
return DAG.getNode(ISD::SELECT, N->getDebugLoc(), return DAG.getNode(ISD::SELECT, SDLoc(N),
LHS.getValueType(), N->getOperand(0),LHS,RHS); LHS.getValueType(), N->getOperand(0),LHS,RHS);
} }
@ -495,14 +495,14 @@ SDValue DAGTypeLegalizer::PromoteIntRes_VSELECT(SDNode *N) {
Mask = PromoteTargetBoolean(Mask, getSetCCResultType(OpTy)); Mask = PromoteTargetBoolean(Mask, getSetCCResultType(OpTy));
SDValue LHS = GetPromotedInteger(N->getOperand(1)); SDValue LHS = GetPromotedInteger(N->getOperand(1));
SDValue RHS = GetPromotedInteger(N->getOperand(2)); SDValue RHS = GetPromotedInteger(N->getOperand(2));
return DAG.getNode(ISD::VSELECT, N->getDebugLoc(), return DAG.getNode(ISD::VSELECT, SDLoc(N),
LHS.getValueType(), Mask, LHS, RHS); LHS.getValueType(), Mask, LHS, RHS);
} }
SDValue DAGTypeLegalizer::PromoteIntRes_SELECT_CC(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_SELECT_CC(SDNode *N) {
SDValue LHS = GetPromotedInteger(N->getOperand(2)); SDValue LHS = GetPromotedInteger(N->getOperand(2));
SDValue RHS = GetPromotedInteger(N->getOperand(3)); SDValue RHS = GetPromotedInteger(N->getOperand(3));
return DAG.getNode(ISD::SELECT_CC, N->getDebugLoc(), return DAG.getNode(ISD::SELECT_CC, SDLoc(N),
LHS.getValueType(), N->getOperand(0), LHS.getValueType(), N->getOperand(0),
N->getOperand(1), LHS, RHS, N->getOperand(4)); N->getOperand(1), LHS, RHS, N->getOperand(4));
} }
@ -517,7 +517,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_SETCC(SDNode *N) {
if (!TLI.isTypeLegal(SVT)) if (!TLI.isTypeLegal(SVT))
SVT = NVT; SVT = NVT;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
assert(SVT.isVector() == N->getOperand(0).getValueType().isVector() && assert(SVT.isVector() == N->getOperand(0).getValueType().isVector() &&
"Vector compare must return a vector result!"); "Vector compare must return a vector result!");
@ -545,12 +545,12 @@ SDValue DAGTypeLegalizer::PromoteIntRes_SHL(SDNode *N) {
SDValue Res = GetPromotedInteger(N->getOperand(0)); SDValue Res = GetPromotedInteger(N->getOperand(0));
SDValue Amt = N->getOperand(1); SDValue Amt = N->getOperand(1);
Amt = Amt.getValueType().isVector() ? ZExtPromotedInteger(Amt) : Amt; Amt = Amt.getValueType().isVector() ? ZExtPromotedInteger(Amt) : Amt;
return DAG.getNode(ISD::SHL, N->getDebugLoc(), Res.getValueType(), Res, Amt); return DAG.getNode(ISD::SHL, SDLoc(N), Res.getValueType(), Res, Amt);
} }
SDValue DAGTypeLegalizer::PromoteIntRes_SIGN_EXTEND_INREG(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_SIGN_EXTEND_INREG(SDNode *N) {
SDValue Op = GetPromotedInteger(N->getOperand(0)); SDValue Op = GetPromotedInteger(N->getOperand(0));
return DAG.getNode(ISD::SIGN_EXTEND_INREG, N->getDebugLoc(), return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N),
Op.getValueType(), Op, N->getOperand(1)); Op.getValueType(), Op, N->getOperand(1));
} }
@ -560,7 +560,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_SimpleIntBinOp(SDNode *N) {
// that too is okay if they are integer operations. // that too is okay if they are integer operations.
SDValue LHS = GetPromotedInteger(N->getOperand(0)); SDValue LHS = GetPromotedInteger(N->getOperand(0));
SDValue RHS = GetPromotedInteger(N->getOperand(1)); SDValue RHS = GetPromotedInteger(N->getOperand(1));
return DAG.getNode(N->getOpcode(), N->getDebugLoc(), return DAG.getNode(N->getOpcode(), SDLoc(N),
LHS.getValueType(), LHS, RHS); LHS.getValueType(), LHS, RHS);
} }
@ -569,7 +569,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_SRA(SDNode *N) {
SDValue Res = SExtPromotedInteger(N->getOperand(0)); SDValue Res = SExtPromotedInteger(N->getOperand(0));
SDValue Amt = N->getOperand(1); SDValue Amt = N->getOperand(1);
Amt = Amt.getValueType().isVector() ? ZExtPromotedInteger(Amt) : Amt; Amt = Amt.getValueType().isVector() ? ZExtPromotedInteger(Amt) : Amt;
return DAG.getNode(ISD::SRA, N->getDebugLoc(), Res.getValueType(), Res, Amt); return DAG.getNode(ISD::SRA, SDLoc(N), Res.getValueType(), Res, Amt);
} }
SDValue DAGTypeLegalizer::PromoteIntRes_SRL(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_SRL(SDNode *N) {
@ -577,14 +577,14 @@ SDValue DAGTypeLegalizer::PromoteIntRes_SRL(SDNode *N) {
SDValue Res = ZExtPromotedInteger(N->getOperand(0)); SDValue Res = ZExtPromotedInteger(N->getOperand(0));
SDValue Amt = N->getOperand(1); SDValue Amt = N->getOperand(1);
Amt = Amt.getValueType().isVector() ? ZExtPromotedInteger(Amt) : Amt; Amt = Amt.getValueType().isVector() ? ZExtPromotedInteger(Amt) : Amt;
return DAG.getNode(ISD::SRL, N->getDebugLoc(), Res.getValueType(), Res, Amt); return DAG.getNode(ISD::SRL, SDLoc(N), Res.getValueType(), Res, Amt);
} }
SDValue DAGTypeLegalizer::PromoteIntRes_TRUNCATE(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_TRUNCATE(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue Res; SDValue Res;
SDValue InOp = N->getOperand(0); SDValue InOp = N->getOperand(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
switch (getTypeAction(InOp.getValueType())) { switch (getTypeAction(InOp.getValueType())) {
default: llvm_unreachable("Unknown type action!"); default: llvm_unreachable("Unknown type action!");
@ -629,7 +629,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_UADDSUBO(SDNode *N, unsigned ResNo) {
SDValue RHS = ZExtPromotedInteger(N->getOperand(1)); SDValue RHS = ZExtPromotedInteger(N->getOperand(1));
EVT OVT = N->getOperand(0).getValueType(); EVT OVT = N->getOperand(0).getValueType();
EVT NVT = LHS.getValueType(); EVT NVT = LHS.getValueType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Do the arithmetic in the larger type. // Do the arithmetic in the larger type.
unsigned Opcode = N->getOpcode() == ISD::UADDO ? ISD::ADD : ISD::SUB; unsigned Opcode = N->getOpcode() == ISD::UADDO ? ISD::ADD : ISD::SUB;
@ -653,7 +653,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_XMULO(SDNode *N, unsigned ResNo) {
return PromoteIntRes_Overflow(N); return PromoteIntRes_Overflow(N);
SDValue LHS = N->getOperand(0), RHS = N->getOperand(1); SDValue LHS = N->getOperand(0), RHS = N->getOperand(1);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
EVT SmallVT = LHS.getValueType(); EVT SmallVT = LHS.getValueType();
// To determine if the result overflowed in a larger type, we extend the // To determine if the result overflowed in a larger type, we extend the
@ -701,7 +701,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_UDIV(SDNode *N) {
// Zero extend the input. // Zero extend the input.
SDValue LHS = ZExtPromotedInteger(N->getOperand(0)); SDValue LHS = ZExtPromotedInteger(N->getOperand(0));
SDValue RHS = ZExtPromotedInteger(N->getOperand(1)); SDValue RHS = ZExtPromotedInteger(N->getOperand(1));
return DAG.getNode(N->getOpcode(), N->getDebugLoc(), return DAG.getNode(N->getOpcode(), SDLoc(N),
LHS.getValueType(), LHS, RHS); LHS.getValueType(), LHS, RHS);
} }
@ -714,7 +714,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_VAARG(SDNode *N) {
SDValue Chain = N->getOperand(0); // Get the chain. SDValue Chain = N->getOperand(0); // Get the chain.
SDValue Ptr = N->getOperand(1); // Get the pointer. SDValue Ptr = N->getOperand(1); // Get the pointer.
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
MVT RegVT = TLI.getRegisterType(*DAG.getContext(), VT); MVT RegVT = TLI.getRegisterType(*DAG.getContext(), VT);
unsigned NumRegs = TLI.getNumRegisters(*DAG.getContext(), VT); unsigned NumRegs = TLI.getNumRegisters(*DAG.getContext(), VT);
@ -858,12 +858,12 @@ void DAGTypeLegalizer::PromoteSetCCOperands(SDValue &NewLHS,SDValue &NewRHS,
SDValue DAGTypeLegalizer::PromoteIntOp_ANY_EXTEND(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntOp_ANY_EXTEND(SDNode *N) {
SDValue Op = GetPromotedInteger(N->getOperand(0)); SDValue Op = GetPromotedInteger(N->getOperand(0));
return DAG.getNode(ISD::ANY_EXTEND, N->getDebugLoc(), N->getValueType(0), Op); return DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), N->getValueType(0), Op);
} }
SDValue DAGTypeLegalizer::PromoteIntOp_ATOMIC_STORE(AtomicSDNode *N) { SDValue DAGTypeLegalizer::PromoteIntOp_ATOMIC_STORE(AtomicSDNode *N) {
SDValue Op2 = GetPromotedInteger(N->getOperand(2)); SDValue Op2 = GetPromotedInteger(N->getOperand(2));
return DAG.getAtomic(N->getOpcode(), N->getDebugLoc(), N->getMemoryVT(), return DAG.getAtomic(N->getOpcode(), SDLoc(N), N->getMemoryVT(),
N->getChain(), N->getBasePtr(), Op2, N->getMemOperand(), N->getChain(), N->getBasePtr(), Op2, N->getMemOperand(),
N->getOrdering(), N->getSynchScope()); N->getOrdering(), N->getSynchScope());
} }
@ -906,7 +906,7 @@ SDValue DAGTypeLegalizer::PromoteIntOp_BUILD_PAIR(SDNode *N) {
SDValue Lo = ZExtPromotedInteger(N->getOperand(0)); SDValue Lo = ZExtPromotedInteger(N->getOperand(0));
SDValue Hi = GetPromotedInteger(N->getOperand(1)); SDValue Hi = GetPromotedInteger(N->getOperand(1));
assert(Lo.getValueType() == N->getValueType(0) && "Operand over promoted?"); assert(Lo.getValueType() == N->getValueType(0) && "Operand over promoted?");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
Hi = DAG.getNode(ISD::SHL, dl, N->getValueType(0), Hi, Hi = DAG.getNode(ISD::SHL, dl, N->getValueType(0), Hi,
DAG.getConstant(OVT.getSizeInBits(), TLI.getPointerTy())); DAG.getConstant(OVT.getSizeInBits(), TLI.getPointerTy()));
@ -942,7 +942,7 @@ SDValue DAGTypeLegalizer::PromoteIntOp_CONVERT_RNDSAT(SDNode *N) {
CvtCode == ISD::CVT_FS || CvtCode == ISD::CVT_FU) && CvtCode == ISD::CVT_FS || CvtCode == ISD::CVT_FU) &&
"can only promote integer arguments"); "can only promote integer arguments");
SDValue InOp = GetPromotedInteger(N->getOperand(0)); SDValue InOp = GetPromotedInteger(N->getOperand(0));
return DAG.getConvertRndSat(N->getValueType(0), N->getDebugLoc(), InOp, return DAG.getConvertRndSat(N->getValueType(0), SDLoc(N), InOp,
N->getOperand(1), N->getOperand(2), N->getOperand(1), N->getOperand(2),
N->getOperand(3), N->getOperand(4), CvtCode); N->getOperand(3), N->getOperand(4), CvtCode);
} }
@ -1022,7 +1022,7 @@ SDValue DAGTypeLegalizer::PromoteIntOp_Shift(SDNode *N) {
SDValue DAGTypeLegalizer::PromoteIntOp_SIGN_EXTEND(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntOp_SIGN_EXTEND(SDNode *N) {
SDValue Op = GetPromotedInteger(N->getOperand(0)); SDValue Op = GetPromotedInteger(N->getOperand(0));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
Op = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Op); Op = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Op);
return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Op.getValueType(), return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Op.getValueType(),
Op, DAG.getValueType(N->getOperand(0).getValueType())); Op, DAG.getValueType(N->getOperand(0).getValueType()));
@ -1039,7 +1039,7 @@ SDValue DAGTypeLegalizer::PromoteIntOp_STORE(StoreSDNode *N, unsigned OpNo){
unsigned Alignment = N->getAlignment(); unsigned Alignment = N->getAlignment();
bool isVolatile = N->isVolatile(); bool isVolatile = N->isVolatile();
bool isNonTemporal = N->isNonTemporal(); bool isNonTemporal = N->isNonTemporal();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Val = GetPromotedInteger(N->getValue()); // Get promoted value. SDValue Val = GetPromotedInteger(N->getValue()); // Get promoted value.
@ -1051,7 +1051,7 @@ SDValue DAGTypeLegalizer::PromoteIntOp_STORE(StoreSDNode *N, unsigned OpNo){
SDValue DAGTypeLegalizer::PromoteIntOp_TRUNCATE(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntOp_TRUNCATE(SDNode *N) {
SDValue Op = GetPromotedInteger(N->getOperand(0)); SDValue Op = GetPromotedInteger(N->getOperand(0));
return DAG.getNode(ISD::TRUNCATE, N->getDebugLoc(), N->getValueType(0), Op); return DAG.getNode(ISD::TRUNCATE, SDLoc(N), N->getValueType(0), Op);
} }
SDValue DAGTypeLegalizer::PromoteIntOp_UINT_TO_FP(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntOp_UINT_TO_FP(SDNode *N) {
@ -1060,7 +1060,7 @@ SDValue DAGTypeLegalizer::PromoteIntOp_UINT_TO_FP(SDNode *N) {
} }
SDValue DAGTypeLegalizer::PromoteIntOp_ZERO_EXTEND(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntOp_ZERO_EXTEND(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Op = GetPromotedInteger(N->getOperand(0)); SDValue Op = GetPromotedInteger(N->getOperand(0));
Op = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Op); Op = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Op);
return DAG.getZeroExtendInReg(Op, dl, return DAG.getZeroExtendInReg(Op, dl,
@ -1265,7 +1265,7 @@ std::pair <SDValue, SDValue> DAGTypeLegalizer::ExpandAtomic(SDNode *Node) {
/// and the shift amount is a constant 'Amt'. Expand the operation. /// and the shift amount is a constant 'Amt'. Expand the operation.
void DAGTypeLegalizer::ExpandShiftByConstant(SDNode *N, unsigned Amt, void DAGTypeLegalizer::ExpandShiftByConstant(SDNode *N, unsigned Amt,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
// Expand the incoming operand to be shifted, so that we have its parts // Expand the incoming operand to be shifted, so that we have its parts
SDValue InL, InH; SDValue InL, InH;
GetExpandedInteger(N->getOperand(0), InL, InH); GetExpandedInteger(N->getOperand(0), InL, InH);
@ -1363,7 +1363,7 @@ ExpandShiftWithKnownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
unsigned NVTBits = NVT.getScalarType().getSizeInBits(); unsigned NVTBits = NVT.getScalarType().getSizeInBits();
assert(isPowerOf2_32(NVTBits) && assert(isPowerOf2_32(NVTBits) &&
"Expanded integer type size not a power of two!"); "Expanded integer type size not a power of two!");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
APInt HighBitMask = APInt::getHighBitsSet(ShBits, ShBits - Log2_32(NVTBits)); APInt HighBitMask = APInt::getHighBitsSet(ShBits, ShBits - Log2_32(NVTBits));
APInt KnownZero, KnownOne; APInt KnownZero, KnownOne;
@ -1450,7 +1450,7 @@ ExpandShiftWithUnknownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
unsigned NVTBits = NVT.getSizeInBits(); unsigned NVTBits = NVT.getSizeInBits();
assert(isPowerOf2_32(NVTBits) && assert(isPowerOf2_32(NVTBits) &&
"Expanded integer type size not a power of two!"); "Expanded integer type size not a power of two!");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Get the incoming operand to be shifted. // Get the incoming operand to be shifted.
SDValue InL, InH; SDValue InL, InH;
@ -1519,7 +1519,7 @@ ExpandShiftWithUnknownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
void DAGTypeLegalizer::ExpandIntRes_ADDSUB(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_ADDSUB(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Expand the subcomponents. // Expand the subcomponents.
SDValue LHSL, LHSH, RHSL, RHSH; SDValue LHSL, LHSH, RHSL, RHSH;
GetExpandedInteger(N->getOperand(0), LHSL, LHSH); GetExpandedInteger(N->getOperand(0), LHSL, LHSH);
@ -1583,7 +1583,7 @@ void DAGTypeLegalizer::ExpandIntRes_ADDSUBC(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
// Expand the subcomponents. // Expand the subcomponents.
SDValue LHSL, LHSH, RHSL, RHSH; SDValue LHSL, LHSH, RHSL, RHSH;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
GetExpandedInteger(N->getOperand(0), LHSL, LHSH); GetExpandedInteger(N->getOperand(0), LHSL, LHSH);
GetExpandedInteger(N->getOperand(1), RHSL, RHSH); GetExpandedInteger(N->getOperand(1), RHSL, RHSH);
SDVTList VTList = DAG.getVTList(LHSL.getValueType(), MVT::Glue); SDVTList VTList = DAG.getVTList(LHSL.getValueType(), MVT::Glue);
@ -1609,7 +1609,7 @@ void DAGTypeLegalizer::ExpandIntRes_ADDSUBE(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
// Expand the subcomponents. // Expand the subcomponents.
SDValue LHSL, LHSH, RHSL, RHSH; SDValue LHSL, LHSH, RHSL, RHSH;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
GetExpandedInteger(N->getOperand(0), LHSL, LHSH); GetExpandedInteger(N->getOperand(0), LHSL, LHSH);
GetExpandedInteger(N->getOperand(1), RHSL, RHSH); GetExpandedInteger(N->getOperand(1), RHSL, RHSH);
SDVTList VTList = DAG.getVTList(LHSL.getValueType(), MVT::Glue); SDVTList VTList = DAG.getVTList(LHSL.getValueType(), MVT::Glue);
@ -1634,7 +1634,7 @@ void DAGTypeLegalizer::ExpandIntRes_MERGE_VALUES(SDNode *N, unsigned ResNo,
void DAGTypeLegalizer::ExpandIntRes_ANY_EXTEND(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_ANY_EXTEND(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Op = N->getOperand(0); SDValue Op = N->getOperand(0);
if (Op.getValueType().bitsLE(NVT)) { if (Op.getValueType().bitsLE(NVT)) {
// The low part is any extension of the input (which degenerates to a copy). // The low part is any extension of the input (which degenerates to a copy).
@ -1656,7 +1656,7 @@ void DAGTypeLegalizer::ExpandIntRes_ANY_EXTEND(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_AssertSext(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_AssertSext(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
GetExpandedInteger(N->getOperand(0), Lo, Hi); GetExpandedInteger(N->getOperand(0), Lo, Hi);
EVT NVT = Lo.getValueType(); EVT NVT = Lo.getValueType();
EVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT(); EVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT();
@ -1677,7 +1677,7 @@ void DAGTypeLegalizer::ExpandIntRes_AssertSext(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_AssertZext(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_AssertZext(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
GetExpandedInteger(N->getOperand(0), Lo, Hi); GetExpandedInteger(N->getOperand(0), Lo, Hi);
EVT NVT = Lo.getValueType(); EVT NVT = Lo.getValueType();
EVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT(); EVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT();
@ -1697,7 +1697,7 @@ void DAGTypeLegalizer::ExpandIntRes_AssertZext(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_BSWAP(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_BSWAP(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
GetExpandedInteger(N->getOperand(0), Hi, Lo); // Note swapped operands. GetExpandedInteger(N->getOperand(0), Hi, Lo); // Note swapped operands.
Lo = DAG.getNode(ISD::BSWAP, dl, Lo.getValueType(), Lo); Lo = DAG.getNode(ISD::BSWAP, dl, Lo.getValueType(), Lo);
Hi = DAG.getNode(ISD::BSWAP, dl, Hi.getValueType(), Hi); Hi = DAG.getNode(ISD::BSWAP, dl, Hi.getValueType(), Hi);
@ -1714,7 +1714,7 @@ void DAGTypeLegalizer::ExpandIntRes_Constant(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_CTLZ(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_CTLZ(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// ctlz (HiLo) -> Hi != 0 ? ctlz(Hi) : (ctlz(Lo)+32) // ctlz (HiLo) -> Hi != 0 ? ctlz(Hi) : (ctlz(Lo)+32)
GetExpandedInteger(N->getOperand(0), Lo, Hi); GetExpandedInteger(N->getOperand(0), Lo, Hi);
EVT NVT = Lo.getValueType(); EVT NVT = Lo.getValueType();
@ -1733,7 +1733,7 @@ void DAGTypeLegalizer::ExpandIntRes_CTLZ(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_CTPOP(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_CTPOP(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// ctpop(HiLo) -> ctpop(Hi)+ctpop(Lo) // ctpop(HiLo) -> ctpop(Hi)+ctpop(Lo)
GetExpandedInteger(N->getOperand(0), Lo, Hi); GetExpandedInteger(N->getOperand(0), Lo, Hi);
EVT NVT = Lo.getValueType(); EVT NVT = Lo.getValueType();
@ -1744,7 +1744,7 @@ void DAGTypeLegalizer::ExpandIntRes_CTPOP(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_CTTZ(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_CTTZ(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// cttz (HiLo) -> Lo != 0 ? cttz(Lo) : (cttz(Hi)+32) // cttz (HiLo) -> Lo != 0 ? cttz(Lo) : (cttz(Hi)+32)
GetExpandedInteger(N->getOperand(0), Lo, Hi); GetExpandedInteger(N->getOperand(0), Lo, Hi);
EVT NVT = Lo.getValueType(); EVT NVT = Lo.getValueType();
@ -1763,7 +1763,7 @@ void DAGTypeLegalizer::ExpandIntRes_CTTZ(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_FP_TO_SINT(SDNode *N, SDValue &Lo, void DAGTypeLegalizer::ExpandIntRes_FP_TO_SINT(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
SDValue Op = N->getOperand(0); SDValue Op = N->getOperand(0);
RTLIB::Libcall LC = RTLIB::getFPTOSINT(Op.getValueType(), VT); RTLIB::Libcall LC = RTLIB::getFPTOSINT(Op.getValueType(), VT);
@ -1774,7 +1774,7 @@ void DAGTypeLegalizer::ExpandIntRes_FP_TO_SINT(SDNode *N, SDValue &Lo,
void DAGTypeLegalizer::ExpandIntRes_FP_TO_UINT(SDNode *N, SDValue &Lo, void DAGTypeLegalizer::ExpandIntRes_FP_TO_UINT(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
SDValue Op = N->getOperand(0); SDValue Op = N->getOperand(0);
RTLIB::Libcall LC = RTLIB::getFPTOUINT(Op.getValueType(), VT); RTLIB::Libcall LC = RTLIB::getFPTOUINT(Op.getValueType(), VT);
@ -1801,7 +1801,7 @@ void DAGTypeLegalizer::ExpandIntRes_LOAD(LoadSDNode *N,
bool isVolatile = N->isVolatile(); bool isVolatile = N->isVolatile();
bool isNonTemporal = N->isNonTemporal(); bool isNonTemporal = N->isNonTemporal();
bool isInvariant = N->isInvariant(); bool isInvariant = N->isInvariant();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
assert(NVT.isByteSized() && "Expanded type not byte sized!"); assert(NVT.isByteSized() && "Expanded type not byte sized!");
@ -1900,7 +1900,7 @@ void DAGTypeLegalizer::ExpandIntRes_LOAD(LoadSDNode *N,
void DAGTypeLegalizer::ExpandIntRes_Logical(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_Logical(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue LL, LH, RL, RH; SDValue LL, LH, RL, RH;
GetExpandedInteger(N->getOperand(0), LL, LH); GetExpandedInteger(N->getOperand(0), LL, LH);
GetExpandedInteger(N->getOperand(1), RL, RH); GetExpandedInteger(N->getOperand(1), RL, RH);
@ -1912,7 +1912,7 @@ void DAGTypeLegalizer::ExpandIntRes_MUL(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
bool HasMULHS = TLI.isOperationLegalOrCustom(ISD::MULHS, NVT); bool HasMULHS = TLI.isOperationLegalOrCustom(ISD::MULHS, NVT);
bool HasMULHU = TLI.isOperationLegalOrCustom(ISD::MULHU, NVT); bool HasMULHU = TLI.isOperationLegalOrCustom(ISD::MULHU, NVT);
@ -2003,7 +2003,7 @@ void DAGTypeLegalizer::ExpandIntRes_SADDSUBO(SDNode *Node,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
SDValue LHS = Node->getOperand(0); SDValue LHS = Node->getOperand(0);
SDValue RHS = Node->getOperand(1); SDValue RHS = Node->getOperand(1);
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
// Expand the result by simply replacing it with the equivalent // Expand the result by simply replacing it with the equivalent
// non-overflow-checking operation. // non-overflow-checking operation.
@ -2044,7 +2044,7 @@ void DAGTypeLegalizer::ExpandIntRes_SADDSUBO(SDNode *Node,
void DAGTypeLegalizer::ExpandIntRes_SDIV(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_SDIV(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
if (VT == MVT::i16) if (VT == MVT::i16)
@ -2064,7 +2064,7 @@ void DAGTypeLegalizer::ExpandIntRes_SDIV(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_Shift(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_Shift(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// If we can emit an efficient shift operation, do so now. Check to see if // If we can emit an efficient shift operation, do so now. Check to see if
// the RHS is a constant. // the RHS is a constant.
@ -2164,7 +2164,7 @@ void DAGTypeLegalizer::ExpandIntRes_Shift(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_SIGN_EXTEND(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_SIGN_EXTEND(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Op = N->getOperand(0); SDValue Op = N->getOperand(0);
if (Op.getValueType().bitsLE(NVT)) { if (Op.getValueType().bitsLE(NVT)) {
// The low part is sign extension of the input (degenerates to a copy). // The low part is sign extension of the input (degenerates to a copy).
@ -2194,7 +2194,7 @@ void DAGTypeLegalizer::ExpandIntRes_SIGN_EXTEND(SDNode *N,
void DAGTypeLegalizer:: void DAGTypeLegalizer::
ExpandIntRes_SIGN_EXTEND_INREG(SDNode *N, SDValue &Lo, SDValue &Hi) { ExpandIntRes_SIGN_EXTEND_INREG(SDNode *N, SDValue &Lo, SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
GetExpandedInteger(N->getOperand(0), Lo, Hi); GetExpandedInteger(N->getOperand(0), Lo, Hi);
EVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT(); EVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT();
@ -2222,7 +2222,7 @@ ExpandIntRes_SIGN_EXTEND_INREG(SDNode *N, SDValue &Lo, SDValue &Hi) {
void DAGTypeLegalizer::ExpandIntRes_SREM(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_SREM(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
if (VT == MVT::i16) if (VT == MVT::i16)
@ -2242,7 +2242,7 @@ void DAGTypeLegalizer::ExpandIntRes_SREM(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_TRUNCATE(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_TRUNCATE(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0)); Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
Hi = DAG.getNode(ISD::SRL, dl, Hi = DAG.getNode(ISD::SRL, dl,
N->getOperand(0).getValueType(), N->getOperand(0), N->getOperand(0).getValueType(), N->getOperand(0),
@ -2254,7 +2254,7 @@ void DAGTypeLegalizer::ExpandIntRes_UADDSUBO(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
SDValue LHS = N->getOperand(0); SDValue LHS = N->getOperand(0);
SDValue RHS = N->getOperand(1); SDValue RHS = N->getOperand(1);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Expand the result by simply replacing it with the equivalent // Expand the result by simply replacing it with the equivalent
// non-overflow-checking operation. // non-overflow-checking operation.
@ -2276,7 +2276,7 @@ void DAGTypeLegalizer::ExpandIntRes_UADDSUBO(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_XMULO(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_XMULO(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// A divide for UMULO should be faster than a function call. // A divide for UMULO should be faster than a function call.
if (N->getOpcode() == ISD::UMULO) { if (N->getOpcode() == ISD::UMULO) {
@ -2362,7 +2362,7 @@ void DAGTypeLegalizer::ExpandIntRes_XMULO(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_UDIV(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_UDIV(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
if (VT == MVT::i16) if (VT == MVT::i16)
@ -2382,7 +2382,7 @@ void DAGTypeLegalizer::ExpandIntRes_UDIV(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_UREM(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_UREM(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL; RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
if (VT == MVT::i16) if (VT == MVT::i16)
@ -2402,7 +2402,7 @@ void DAGTypeLegalizer::ExpandIntRes_UREM(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_ZERO_EXTEND(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_ZERO_EXTEND(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Op = N->getOperand(0); SDValue Op = N->getOperand(0);
if (Op.getValueType().bitsLE(NVT)) { if (Op.getValueType().bitsLE(NVT)) {
// The low part is zero extension of the input (degenerates to a copy). // The low part is zero extension of the input (degenerates to a copy).
@ -2429,7 +2429,7 @@ void DAGTypeLegalizer::ExpandIntRes_ZERO_EXTEND(SDNode *N,
void DAGTypeLegalizer::ExpandIntRes_ATOMIC_LOAD(SDNode *N, void DAGTypeLegalizer::ExpandIntRes_ATOMIC_LOAD(SDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT VT = cast<AtomicSDNode>(N)->getMemoryVT(); EVT VT = cast<AtomicSDNode>(N)->getMemoryVT();
SDValue Zero = DAG.getConstant(0, VT); SDValue Zero = DAG.getConstant(0, VT);
SDValue Swap = DAG.getAtomic(ISD::ATOMIC_CMP_SWAP, dl, VT, SDValue Swap = DAG.getAtomic(ISD::ATOMIC_CMP_SWAP, dl, VT,
@ -2509,7 +2509,7 @@ bool DAGTypeLegalizer::ExpandIntegerOperand(SDNode *N, unsigned OpNo) {
void DAGTypeLegalizer::IntegerExpandSetCCOperands(SDValue &NewLHS, void DAGTypeLegalizer::IntegerExpandSetCCOperands(SDValue &NewLHS,
SDValue &NewRHS, SDValue &NewRHS,
ISD::CondCode &CCCode, ISD::CondCode &CCCode,
DebugLoc dl) { SDLoc dl) {
SDValue LHSLo, LHSHi, RHSLo, RHSHi; SDValue LHSLo, LHSHi, RHSLo, RHSHi;
GetExpandedInteger(NewLHS, LHSLo, LHSHi); GetExpandedInteger(NewLHS, LHSLo, LHSHi);
GetExpandedInteger(NewRHS, RHSLo, RHSHi); GetExpandedInteger(NewRHS, RHSLo, RHSHi);
@ -2609,7 +2609,7 @@ void DAGTypeLegalizer::IntegerExpandSetCCOperands(SDValue &NewLHS,
SDValue DAGTypeLegalizer::ExpandIntOp_BR_CC(SDNode *N) { SDValue DAGTypeLegalizer::ExpandIntOp_BR_CC(SDNode *N) {
SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3); SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3);
ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get(); ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get();
IntegerExpandSetCCOperands(NewLHS, NewRHS, CCCode, N->getDebugLoc()); IntegerExpandSetCCOperands(NewLHS, NewRHS, CCCode, SDLoc(N));
// If ExpandSetCCOperands returned a scalar, we need to compare the result // If ExpandSetCCOperands returned a scalar, we need to compare the result
// against zero to select between true and false values. // against zero to select between true and false values.
@ -2627,7 +2627,7 @@ SDValue DAGTypeLegalizer::ExpandIntOp_BR_CC(SDNode *N) {
SDValue DAGTypeLegalizer::ExpandIntOp_SELECT_CC(SDNode *N) { SDValue DAGTypeLegalizer::ExpandIntOp_SELECT_CC(SDNode *N) {
SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1); SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(4))->get(); ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(4))->get();
IntegerExpandSetCCOperands(NewLHS, NewRHS, CCCode, N->getDebugLoc()); IntegerExpandSetCCOperands(NewLHS, NewRHS, CCCode, SDLoc(N));
// If ExpandSetCCOperands returned a scalar, we need to compare the result // If ExpandSetCCOperands returned a scalar, we need to compare the result
// against zero to select between true and false values. // against zero to select between true and false values.
@ -2645,7 +2645,7 @@ SDValue DAGTypeLegalizer::ExpandIntOp_SELECT_CC(SDNode *N) {
SDValue DAGTypeLegalizer::ExpandIntOp_SETCC(SDNode *N) { SDValue DAGTypeLegalizer::ExpandIntOp_SETCC(SDNode *N) {
SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1); SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get(); ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get();
IntegerExpandSetCCOperands(NewLHS, NewRHS, CCCode, N->getDebugLoc()); IntegerExpandSetCCOperands(NewLHS, NewRHS, CCCode, SDLoc(N));
// If ExpandSetCCOperands returned a scalar, use it. // If ExpandSetCCOperands returned a scalar, use it.
if (NewRHS.getNode() == 0) { if (NewRHS.getNode() == 0) {
@ -2683,7 +2683,7 @@ SDValue DAGTypeLegalizer::ExpandIntOp_SINT_TO_FP(SDNode *N) {
RTLIB::Libcall LC = RTLIB::getSINTTOFP(Op.getValueType(), DstVT); RTLIB::Libcall LC = RTLIB::getSINTTOFP(Op.getValueType(), DstVT);
assert(LC != RTLIB::UNKNOWN_LIBCALL && assert(LC != RTLIB::UNKNOWN_LIBCALL &&
"Don't know how to expand this SINT_TO_FP!"); "Don't know how to expand this SINT_TO_FP!");
return TLI.makeLibCall(DAG, LC, DstVT, &Op, 1, true, N->getDebugLoc()); return TLI.makeLibCall(DAG, LC, DstVT, &Op, 1, true, SDLoc(N));
} }
SDValue DAGTypeLegalizer::ExpandIntOp_STORE(StoreSDNode *N, unsigned OpNo) { SDValue DAGTypeLegalizer::ExpandIntOp_STORE(StoreSDNode *N, unsigned OpNo) {
@ -2700,7 +2700,7 @@ SDValue DAGTypeLegalizer::ExpandIntOp_STORE(StoreSDNode *N, unsigned OpNo) {
unsigned Alignment = N->getAlignment(); unsigned Alignment = N->getAlignment();
bool isVolatile = N->isVolatile(); bool isVolatile = N->isVolatile();
bool isNonTemporal = N->isNonTemporal(); bool isNonTemporal = N->isNonTemporal();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Lo, Hi; SDValue Lo, Hi;
assert(NVT.isByteSized() && "Expanded type not byte sized!"); assert(NVT.isByteSized() && "Expanded type not byte sized!");
@ -2776,14 +2776,14 @@ SDValue DAGTypeLegalizer::ExpandIntOp_TRUNCATE(SDNode *N) {
SDValue InL, InH; SDValue InL, InH;
GetExpandedInteger(N->getOperand(0), InL, InH); GetExpandedInteger(N->getOperand(0), InL, InH);
// Just truncate the low part of the source. // Just truncate the low part of the source.
return DAG.getNode(ISD::TRUNCATE, N->getDebugLoc(), N->getValueType(0), InL); return DAG.getNode(ISD::TRUNCATE, SDLoc(N), N->getValueType(0), InL);
} }
SDValue DAGTypeLegalizer::ExpandIntOp_UINT_TO_FP(SDNode *N) { SDValue DAGTypeLegalizer::ExpandIntOp_UINT_TO_FP(SDNode *N) {
SDValue Op = N->getOperand(0); SDValue Op = N->getOperand(0);
EVT SrcVT = Op.getValueType(); EVT SrcVT = Op.getValueType();
EVT DstVT = N->getValueType(0); EVT DstVT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// The following optimization is valid only if every value in SrcVT (when // The following optimization is valid only if every value in SrcVT (when
// treated as signed) is representable in DstVT. Check that the mantissa // treated as signed) is representable in DstVT. Check that the mantissa
@ -2854,7 +2854,7 @@ SDValue DAGTypeLegalizer::ExpandIntOp_UINT_TO_FP(SDNode *N) {
} }
SDValue DAGTypeLegalizer::ExpandIntOp_ATOMIC_STORE(SDNode *N) { SDValue DAGTypeLegalizer::ExpandIntOp_ATOMIC_STORE(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl, SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
cast<AtomicSDNode>(N)->getMemoryVT(), cast<AtomicSDNode>(N)->getMemoryVT(),
N->getOperand(0), N->getOperand(0),
@ -2876,7 +2876,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_EXTRACT_SUBVECTOR(SDNode *N) {
unsigned OutNumElems = OutVT.getVectorNumElements(); unsigned OutNumElems = OutVT.getVectorNumElements();
EVT NOutVTElem = NOutVT.getVectorElementType(); EVT NOutVTElem = NOutVT.getVectorElementType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue BaseIdx = N->getOperand(1); SDValue BaseIdx = N->getOperand(1);
SmallVector<SDValue, 8> Ops; SmallVector<SDValue, 8> Ops;
@ -2901,7 +2901,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_EXTRACT_SUBVECTOR(SDNode *N) {
SDValue DAGTypeLegalizer::PromoteIntRes_VECTOR_SHUFFLE(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_VECTOR_SHUFFLE(SDNode *N) {
ShuffleVectorSDNode *SV = cast<ShuffleVectorSDNode>(N); ShuffleVectorSDNode *SV = cast<ShuffleVectorSDNode>(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
unsigned NumElts = VT.getVectorNumElements(); unsigned NumElts = VT.getVectorNumElements();
SmallVector<int, 8> NewMask; SmallVector<int, 8> NewMask;
@ -2924,7 +2924,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_BUILD_VECTOR(SDNode *N) {
unsigned NumElems = N->getNumOperands(); unsigned NumElems = N->getNumOperands();
EVT NOutVTElem = NOutVT.getVectorElementType(); EVT NOutVTElem = NOutVT.getVectorElementType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SmallVector<SDValue, 8> Ops; SmallVector<SDValue, 8> Ops;
Ops.reserve(NumElems); Ops.reserve(NumElems);
@ -2938,7 +2938,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_BUILD_VECTOR(SDNode *N) {
SDValue DAGTypeLegalizer::PromoteIntRes_SCALAR_TO_VECTOR(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_SCALAR_TO_VECTOR(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
assert(!N->getOperand(0).getValueType().isVector() && assert(!N->getOperand(0).getValueType().isVector() &&
"Input must be a scalar"); "Input must be a scalar");
@ -2954,7 +2954,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_SCALAR_TO_VECTOR(SDNode *N) {
} }
SDValue DAGTypeLegalizer::PromoteIntRes_CONCAT_VECTORS(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntRes_CONCAT_VECTORS(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT OutVT = N->getValueType(0); EVT OutVT = N->getValueType(0);
EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT); EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
@ -2990,7 +2990,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_INSERT_VECTOR_ELT(SDNode *N) {
EVT NOutVTElem = NOutVT.getVectorElementType(); EVT NOutVTElem = NOutVT.getVectorElementType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue V0 = GetPromotedInteger(N->getOperand(0)); SDValue V0 = GetPromotedInteger(N->getOperand(0));
SDValue ConvElem = DAG.getNode(ISD::ANY_EXTEND, dl, SDValue ConvElem = DAG.getNode(ISD::ANY_EXTEND, dl,
@ -3000,7 +3000,7 @@ SDValue DAGTypeLegalizer::PromoteIntRes_INSERT_VECTOR_ELT(SDNode *N) {
} }
SDValue DAGTypeLegalizer::PromoteIntOp_EXTRACT_VECTOR_ELT(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntOp_EXTRACT_VECTOR_ELT(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue V0 = GetPromotedInteger(N->getOperand(0)); SDValue V0 = GetPromotedInteger(N->getOperand(0));
SDValue V1 = N->getOperand(1); SDValue V1 = N->getOperand(1);
SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
@ -3013,7 +3013,7 @@ SDValue DAGTypeLegalizer::PromoteIntOp_EXTRACT_VECTOR_ELT(SDNode *N) {
} }
SDValue DAGTypeLegalizer::PromoteIntOp_CONCAT_VECTORS(SDNode *N) { SDValue DAGTypeLegalizer::PromoteIntOp_CONCAT_VECTORS(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
unsigned NumElems = N->getNumOperands(); unsigned NumElems = N->getNumOperands();
EVT RetSclrTy = N->getValueType(0).getVectorElementType(); EVT RetSclrTy = N->getValueType(0).getVectorElementType();

24
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp
View File

@ -888,7 +888,7 @@ void DAGTypeLegalizer::SetWidenedVector(SDValue Op, SDValue Result) {
/// BitConvertToInteger - Convert to an integer of the same size. /// BitConvertToInteger - Convert to an integer of the same size.
SDValue DAGTypeLegalizer::BitConvertToInteger(SDValue Op) { SDValue DAGTypeLegalizer::BitConvertToInteger(SDValue Op) {
unsigned BitWidth = Op.getValueType().getSizeInBits(); unsigned BitWidth = Op.getValueType().getSizeInBits();
return DAG.getNode(ISD::BITCAST, Op.getDebugLoc(), return DAG.getNode(ISD::BITCAST, SDLoc(Op),
EVT::getIntegerVT(*DAG.getContext(), BitWidth), Op); EVT::getIntegerVT(*DAG.getContext(), BitWidth), Op);
} }
@ -899,13 +899,13 @@ SDValue DAGTypeLegalizer::BitConvertVectorToIntegerVector(SDValue Op) {
unsigned EltWidth = Op.getValueType().getVectorElementType().getSizeInBits(); unsigned EltWidth = Op.getValueType().getVectorElementType().getSizeInBits();
EVT EltNVT = EVT::getIntegerVT(*DAG.getContext(), EltWidth); EVT EltNVT = EVT::getIntegerVT(*DAG.getContext(), EltWidth);
unsigned NumElts = Op.getValueType().getVectorNumElements(); unsigned NumElts = Op.getValueType().getVectorNumElements();
return DAG.getNode(ISD::BITCAST, Op.getDebugLoc(), return DAG.getNode(ISD::BITCAST, SDLoc(Op),
EVT::getVectorVT(*DAG.getContext(), EltNVT, NumElts), Op); EVT::getVectorVT(*DAG.getContext(), EltNVT, NumElts), Op);
} }
SDValue DAGTypeLegalizer::CreateStackStoreLoad(SDValue Op, SDValue DAGTypeLegalizer::CreateStackStoreLoad(SDValue Op,
EVT DestVT) { EVT DestVT) {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);;
// Create the stack frame object. Make sure it is aligned for both // Create the stack frame object. Make sure it is aligned for both
// the source and destination types. // the source and destination types.
SDValue StackPtr = DAG.CreateStackTemporary(Op.getValueType(), DestVT); SDValue StackPtr = DAG.CreateStackTemporary(Op.getValueType(), DestVT);
@ -999,7 +999,7 @@ void DAGTypeLegalizer::GetSplitDestVTs(EVT InVT, EVT &LoVT, EVT &HiVT) {
/// high parts of the given value. /// high parts of the given value.
void DAGTypeLegalizer::GetPairElements(SDValue Pair, void DAGTypeLegalizer::GetPairElements(SDValue Pair,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
DebugLoc dl = Pair.getDebugLoc(); SDLoc dl(Pair);;
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), Pair.getValueType()); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), Pair.getValueType());
Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, NVT, Pair, Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, NVT, Pair,
DAG.getIntPtrConstant(0)); DAG.getIntPtrConstant(0));
@ -1009,7 +1009,7 @@ void DAGTypeLegalizer::GetPairElements(SDValue Pair,
SDValue DAGTypeLegalizer::GetVectorElementPointer(SDValue VecPtr, EVT EltVT, SDValue DAGTypeLegalizer::GetVectorElementPointer(SDValue VecPtr, EVT EltVT,
SDValue Index) { SDValue Index) {
DebugLoc dl = Index.getDebugLoc(); SDLoc dl(Index);;
// Make sure the index type is big enough to compute in. // Make sure the index type is big enough to compute in.
if (Index.getValueType().bitsGT(TLI.getPointerTy())) if (Index.getValueType().bitsGT(TLI.getPointerTy()))
Index = DAG.getNode(ISD::TRUNCATE, dl, TLI.getPointerTy(), Index); Index = DAG.getNode(ISD::TRUNCATE, dl, TLI.getPointerTy(), Index);
@ -1026,9 +1026,9 @@ SDValue DAGTypeLegalizer::GetVectorElementPointer(SDValue VecPtr, EVT EltVT,
/// JoinIntegers - Build an integer with low bits Lo and high bits Hi. /// JoinIntegers - Build an integer with low bits Lo and high bits Hi.
SDValue DAGTypeLegalizer::JoinIntegers(SDValue Lo, SDValue Hi) { SDValue DAGTypeLegalizer::JoinIntegers(SDValue Lo, SDValue Hi) {
// Arbitrarily use dlHi for result DebugLoc // Arbitrarily use dlHi for result SDLoc
DebugLoc dlHi = Hi.getDebugLoc(); SDLoc dlHi(Hi);;
DebugLoc dlLo = Lo.getDebugLoc(); SDLoc dlLo(Lo);;
EVT LVT = Lo.getValueType(); EVT LVT = Lo.getValueType();
EVT HVT = Hi.getValueType(); EVT HVT = Hi.getValueType();
EVT NVT = EVT::getIntegerVT(*DAG.getContext(), EVT NVT = EVT::getIntegerVT(*DAG.getContext(),
@ -1045,7 +1045,7 @@ SDValue DAGTypeLegalizer::JoinIntegers(SDValue Lo, SDValue Hi) {
SDValue DAGTypeLegalizer::LibCallify(RTLIB::Libcall LC, SDNode *N, SDValue DAGTypeLegalizer::LibCallify(RTLIB::Libcall LC, SDNode *N,
bool isSigned) { bool isSigned) {
unsigned NumOps = N->getNumOperands(); unsigned NumOps = N->getNumOperands();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (NumOps == 0) { if (NumOps == 0) {
return TLI.makeLibCall(DAG, LC, N->getValueType(0), 0, 0, isSigned, dl); return TLI.makeLibCall(DAG, LC, N->getValueType(0), 0, 0, isSigned, dl);
} else if (NumOps == 1) { } else if (NumOps == 1) {
@ -1090,7 +1090,7 @@ DAGTypeLegalizer::ExpandChainLibCall(RTLIB::Libcall LC,
CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false, false, CallLoweringInfo CLI(InChain, RetTy, isSigned, !isSigned, false, false,
0, TLI.getLibcallCallingConv(LC), /*isTailCall=*/false, 0, TLI.getLibcallCallingConv(LC), /*isTailCall=*/false,
/*doesNotReturn=*/false, /*isReturnValueUsed=*/true, /*doesNotReturn=*/false, /*isReturnValueUsed=*/true,
Callee, Args, DAG, Node->getDebugLoc()); Callee, Args, DAG, SDLoc(Node));
std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI); std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI);
return CallInfo; return CallInfo;
@ -1100,7 +1100,7 @@ DAGTypeLegalizer::ExpandChainLibCall(RTLIB::Libcall LC,
/// of the given type. A target boolean is an integer value, not necessarily of /// of the given type. A target boolean is an integer value, not necessarily of
/// type i1, the bits of which conform to getBooleanContents. /// type i1, the bits of which conform to getBooleanContents.
SDValue DAGTypeLegalizer::PromoteTargetBoolean(SDValue Bool, EVT VT) { SDValue DAGTypeLegalizer::PromoteTargetBoolean(SDValue Bool, EVT VT) {
DebugLoc dl = Bool.getDebugLoc(); SDLoc dl(Bool);;
ISD::NodeType ExtendCode = ISD::NodeType ExtendCode =
TargetLowering::getExtendForContent(TLI.getBooleanContents(VT.isVector())); TargetLowering::getExtendForContent(TLI.getBooleanContents(VT.isVector()));
return DAG.getNode(ExtendCode, dl, VT, Bool); return DAG.getNode(ExtendCode, dl, VT, Bool);
@ -1111,7 +1111,7 @@ SDValue DAGTypeLegalizer::PromoteTargetBoolean(SDValue Bool, EVT VT) {
void DAGTypeLegalizer::SplitInteger(SDValue Op, void DAGTypeLegalizer::SplitInteger(SDValue Op,
EVT LoVT, EVT HiVT, EVT LoVT, EVT HiVT,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);;
assert(LoVT.getSizeInBits() + HiVT.getSizeInBits() == assert(LoVT.getSizeInBits() + HiVT.getSizeInBits() ==
Op.getValueType().getSizeInBits() && "Invalid integer splitting!"); Op.getValueType().getSizeInBits() && "Invalid integer splitting!");
Lo = DAG.getNode(ISD::TRUNCATE, dl, LoVT, Op); Lo = DAG.getNode(ISD::TRUNCATE, dl, LoVT, Op);

8
lib/CodeGen/SelectionDAG/LegalizeTypes.h
View File

@ -199,7 +199,7 @@ private:
/// final size. /// final size.
SDValue SExtPromotedInteger(SDValue Op) { SDValue SExtPromotedInteger(SDValue Op) {
EVT OldVT = Op.getValueType(); EVT OldVT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
Op = GetPromotedInteger(Op); Op = GetPromotedInteger(Op);
return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Op.getValueType(), Op, return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Op.getValueType(), Op,
DAG.getValueType(OldVT)); DAG.getValueType(OldVT));
@ -209,7 +209,7 @@ private:
/// final size. /// final size.
SDValue ZExtPromotedInteger(SDValue Op) { SDValue ZExtPromotedInteger(SDValue Op) {
EVT OldVT = Op.getValueType(); EVT OldVT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
Op = GetPromotedInteger(Op); Op = GetPromotedInteger(Op);
return DAG.getZeroExtendInReg(Op, dl, OldVT.getScalarType()); return DAG.getZeroExtendInReg(Op, dl, OldVT.getScalarType());
} }
@ -361,7 +361,7 @@ private:
SDValue ExpandIntOp_ATOMIC_STORE(SDNode *N); SDValue ExpandIntOp_ATOMIC_STORE(SDNode *N);
void IntegerExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS, void IntegerExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS,
ISD::CondCode &CCCode, DebugLoc dl); ISD::CondCode &CCCode, SDLoc dl);
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Float to Integer Conversion Support: LegalizeFloatTypes.cpp // Float to Integer Conversion Support: LegalizeFloatTypes.cpp
@ -488,7 +488,7 @@ private:
SDValue ExpandFloatOp_STORE(SDNode *N, unsigned OpNo); SDValue ExpandFloatOp_STORE(SDNode *N, unsigned OpNo);
void FloatExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS, void FloatExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS,
ISD::CondCode &CCCode, DebugLoc dl); ISD::CondCode &CCCode, SDLoc dl);
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Scalarization Support: LegalizeVectorTypes.cpp // Scalarization Support: LegalizeVectorTypes.cpp

22
lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp
View File

@ -41,7 +41,7 @@ void DAGTypeLegalizer::ExpandRes_BITCAST(SDNode *N, SDValue &Lo, SDValue &Hi) {
EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT); EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
SDValue InOp = N->getOperand(0); SDValue InOp = N->getOperand(0);
EVT InVT = InOp.getValueType(); EVT InVT = InOp.getValueType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Handle some special cases efficiently. // Handle some special cases efficiently.
switch (getTypeAction(InVT)) { switch (getTypeAction(InVT)) {
@ -203,7 +203,7 @@ void DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo,
SDValue OldVec = N->getOperand(0); SDValue OldVec = N->getOperand(0);
unsigned OldElts = OldVec.getValueType().getVectorNumElements(); unsigned OldElts = OldVec.getValueType().getVectorNumElements();
EVT OldEltVT = OldVec.getValueType().getVectorElementType(); EVT OldEltVT = OldVec.getValueType().getVectorElementType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Convert to a vector of the expanded element type, for example // Convert to a vector of the expanded element type, for example
// <3 x i64> -> <6 x i32>. // <3 x i64> -> <6 x i32>.
@ -245,7 +245,7 @@ void DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo,
void DAGTypeLegalizer::ExpandRes_NormalLoad(SDNode *N, SDValue &Lo, void DAGTypeLegalizer::ExpandRes_NormalLoad(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
assert(ISD::isNormalLoad(N) && "This routine only for normal loads!"); assert(ISD::isNormalLoad(N) && "This routine only for normal loads!");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
LoadSDNode *LD = cast<LoadSDNode>(N); LoadSDNode *LD = cast<LoadSDNode>(N);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), LD->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), LD->getValueType(0));
@ -289,7 +289,7 @@ void DAGTypeLegalizer::ExpandRes_VAARG(SDNode *N, SDValue &Lo, SDValue &Hi) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), OVT); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), OVT);
SDValue Chain = N->getOperand(0); SDValue Chain = N->getOperand(0);
SDValue Ptr = N->getOperand(1); SDValue Ptr = N->getOperand(1);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
const unsigned Align = N->getConstantOperandVal(3); const unsigned Align = N->getConstantOperandVal(3);
Lo = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2), Align); Lo = DAG.getVAArg(NVT, dl, Chain, Ptr, N->getOperand(2), Align);
@ -310,7 +310,7 @@ void DAGTypeLegalizer::ExpandRes_VAARG(SDNode *N, SDValue &Lo, SDValue &Hi) {
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
SDValue DAGTypeLegalizer::ExpandOp_BITCAST(SDNode *N) { SDValue DAGTypeLegalizer::ExpandOp_BITCAST(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (N->getValueType(0).isVector()) { if (N->getValueType(0).isVector()) {
// An illegal expanding type is being converted to a legal vector type. // An illegal expanding type is being converted to a legal vector type.
// Make a two element vector out of the expanded parts and convert that // Make a two element vector out of the expanded parts and convert that
@ -344,7 +344,7 @@ SDValue DAGTypeLegalizer::ExpandOp_BUILD_VECTOR(SDNode *N) {
unsigned NumElts = VecVT.getVectorNumElements(); unsigned NumElts = VecVT.getVectorNumElements();
EVT OldVT = N->getOperand(0).getValueType(); EVT OldVT = N->getOperand(0).getValueType();
EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT); EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
assert(OldVT == VecVT.getVectorElementType() && assert(OldVT == VecVT.getVectorElementType() &&
"BUILD_VECTOR operand type doesn't match vector element type!"); "BUILD_VECTOR operand type doesn't match vector element type!");
@ -382,7 +382,7 @@ SDValue DAGTypeLegalizer::ExpandOp_INSERT_VECTOR_ELT(SDNode *N) {
// The vector type is legal but the element type needs expansion. // The vector type is legal but the element type needs expansion.
EVT VecVT = N->getValueType(0); EVT VecVT = N->getValueType(0);
unsigned NumElts = VecVT.getVectorNumElements(); unsigned NumElts = VecVT.getVectorNumElements();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Val = N->getOperand(1); SDValue Val = N->getOperand(1);
EVT OldEVT = Val.getValueType(); EVT OldEVT = Val.getValueType();
@ -414,7 +414,7 @@ SDValue DAGTypeLegalizer::ExpandOp_INSERT_VECTOR_ELT(SDNode *N) {
} }
SDValue DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(SDNode *N) { SDValue DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
assert(VT.getVectorElementType() == N->getOperand(0).getValueType() && assert(VT.getVectorElementType() == N->getOperand(0).getValueType() &&
"SCALAR_TO_VECTOR operand type doesn't match vector element type!"); "SCALAR_TO_VECTOR operand type doesn't match vector element type!");
@ -430,7 +430,7 @@ SDValue DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(SDNode *N) {
SDValue DAGTypeLegalizer::ExpandOp_NormalStore(SDNode *N, unsigned OpNo) { SDValue DAGTypeLegalizer::ExpandOp_NormalStore(SDNode *N, unsigned OpNo) {
assert(ISD::isNormalStore(N) && "This routine only for normal stores!"); assert(ISD::isNormalStore(N) && "This routine only for normal stores!");
assert(OpNo == 1 && "Can only expand the stored value so far"); assert(OpNo == 1 && "Can only expand the stored value so far");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
StoreSDNode *St = cast<StoreSDNode>(N); StoreSDNode *St = cast<StoreSDNode>(N);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(),
@ -483,7 +483,7 @@ void DAGTypeLegalizer::SplitRes_MERGE_VALUES(SDNode *N, unsigned ResNo,
void DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDValue &Lo, void DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
SDValue LL, LH, RL, RH, CL, CH; SDValue LL, LH, RL, RH, CL, CH;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
GetSplitOp(N->getOperand(1), LL, LH); GetSplitOp(N->getOperand(1), LL, LH);
GetSplitOp(N->getOperand(2), RL, RH); GetSplitOp(N->getOperand(2), RL, RH);
@ -507,7 +507,7 @@ void DAGTypeLegalizer::SplitRes_SELECT(SDNode *N, SDValue &Lo,
void DAGTypeLegalizer::SplitRes_SELECT_CC(SDNode *N, SDValue &Lo, void DAGTypeLegalizer::SplitRes_SELECT_CC(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
SDValue LL, LH, RL, RH; SDValue LL, LH, RL, RH;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
GetSplitOp(N->getOperand(2), LL, LH); GetSplitOp(N->getOperand(2), LL, LH);
GetSplitOp(N->getOperand(3), RL, RH); GetSplitOp(N->getOperand(3), RL, RH);

20
lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp
View File

@ -320,7 +320,7 @@ SDValue VectorLegalizer::PromoteVectorOp(SDValue Op) {
assert(Op.getNode()->getNumValues() == 1 && assert(Op.getNode()->getNumValues() == 1 &&
"Can't promote a vector with multiple results!"); "Can't promote a vector with multiple results!");
MVT NVT = TLI.getTypeToPromoteTo(Op.getOpcode(), VT); MVT NVT = TLI.getTypeToPromoteTo(Op.getOpcode(), VT);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);;
SmallVector<SDValue, 4> Operands(Op.getNumOperands()); SmallVector<SDValue, 4> Operands(Op.getNumOperands());
for (unsigned j = 0; j != Op.getNumOperands(); ++j) { for (unsigned j = 0; j != Op.getNumOperands(); ++j) {
@ -357,7 +357,7 @@ SDValue VectorLegalizer::PromoteVectorOpINT_TO_FP(SDValue Op) {
// Build a new vector type and check if it is legal. // Build a new vector type and check if it is legal.
MVT NVT = MVT::getVectorVT(EltVT.getSimpleVT(), NumElts); MVT NVT = MVT::getVectorVT(EltVT.getSimpleVT(), NumElts);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);;
SmallVector<SDValue, 4> Operands(Op.getNumOperands()); SmallVector<SDValue, 4> Operands(Op.getNumOperands());
unsigned Opc = Op.getOpcode() == ISD::UINT_TO_FP ? ISD::ZERO_EXTEND : unsigned Opc = Op.getOpcode() == ISD::UINT_TO_FP ? ISD::ZERO_EXTEND :
@ -375,7 +375,7 @@ SDValue VectorLegalizer::PromoteVectorOpINT_TO_FP(SDValue Op) {
SDValue VectorLegalizer::ExpandLoad(SDValue Op) { SDValue VectorLegalizer::ExpandLoad(SDValue Op) {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);;
LoadSDNode *LD = cast<LoadSDNode>(Op.getNode()); LoadSDNode *LD = cast<LoadSDNode>(Op.getNode());
SDValue Chain = LD->getChain(); SDValue Chain = LD->getChain();
SDValue BasePTR = LD->getBasePtr(); SDValue BasePTR = LD->getBasePtr();
@ -519,7 +519,7 @@ SDValue VectorLegalizer::ExpandLoad(SDValue Op) {
} }
SDValue VectorLegalizer::ExpandStore(SDValue Op) { SDValue VectorLegalizer::ExpandStore(SDValue Op) {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);;
StoreSDNode *ST = cast<StoreSDNode>(Op.getNode()); StoreSDNode *ST = cast<StoreSDNode>(Op.getNode());
SDValue Chain = ST->getChain(); SDValue Chain = ST->getChain();
SDValue BasePTR = ST->getBasePtr(); SDValue BasePTR = ST->getBasePtr();
@ -574,7 +574,7 @@ SDValue VectorLegalizer::ExpandSELECT(SDValue Op) {
// operands are vectors. Lower this select to VSELECT and implement it // operands are vectors. Lower this select to VSELECT and implement it
// using XOR AND OR. The selector bit is broadcasted. // using XOR AND OR. The selector bit is broadcasted.
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);;
SDValue Mask = Op.getOperand(0); SDValue Mask = Op.getOperand(0);
SDValue Op1 = Op.getOperand(1); SDValue Op1 = Op.getOperand(1);
@ -637,7 +637,7 @@ SDValue VectorLegalizer::ExpandSEXTINREG(SDValue Op) {
TLI.getOperationAction(ISD::SHL, VT) == TargetLowering::Expand) TLI.getOperationAction(ISD::SHL, VT) == TargetLowering::Expand)
return DAG.UnrollVectorOp(Op.getNode()); return DAG.UnrollVectorOp(Op.getNode());
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);;
EVT OrigTy = cast<VTSDNode>(Op->getOperand(1))->getVT(); EVT OrigTy = cast<VTSDNode>(Op->getOperand(1))->getVT();
unsigned BW = VT.getScalarType().getSizeInBits(); unsigned BW = VT.getScalarType().getSizeInBits();
@ -652,7 +652,7 @@ SDValue VectorLegalizer::ExpandSEXTINREG(SDValue Op) {
SDValue VectorLegalizer::ExpandVSELECT(SDValue Op) { SDValue VectorLegalizer::ExpandVSELECT(SDValue Op) {
// Implement VSELECT in terms of XOR, AND, OR // Implement VSELECT in terms of XOR, AND, OR
// on platforms which do not support blend natively. // on platforms which do not support blend natively.
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);;
SDValue Mask = Op.getOperand(0); SDValue Mask = Op.getOperand(0);
SDValue Op1 = Op.getOperand(1); SDValue Op1 = Op.getOperand(1);
@ -698,7 +698,7 @@ SDValue VectorLegalizer::ExpandVSELECT(SDValue Op) {
SDValue VectorLegalizer::ExpandUINT_TO_FLOAT(SDValue Op) { SDValue VectorLegalizer::ExpandUINT_TO_FLOAT(SDValue Op) {
EVT VT = Op.getOperand(0).getValueType(); EVT VT = Op.getOperand(0).getValueType();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);;
// Make sure that the SINT_TO_FP and SRL instructions are available. // Make sure that the SINT_TO_FP and SRL instructions are available.
if (TLI.getOperationAction(ISD::SINT_TO_FP, VT) == TargetLowering::Expand || if (TLI.getOperationAction(ISD::SINT_TO_FP, VT) == TargetLowering::Expand ||
@ -739,7 +739,7 @@ SDValue VectorLegalizer::ExpandUINT_TO_FLOAT(SDValue Op) {
SDValue VectorLegalizer::ExpandFNEG(SDValue Op) { SDValue VectorLegalizer::ExpandFNEG(SDValue Op) {
if (TLI.isOperationLegalOrCustom(ISD::FSUB, Op.getValueType())) { if (TLI.isOperationLegalOrCustom(ISD::FSUB, Op.getValueType())) {
SDValue Zero = DAG.getConstantFP(-0.0, Op.getValueType()); SDValue Zero = DAG.getConstantFP(-0.0, Op.getValueType());
return DAG.getNode(ISD::FSUB, Op.getDebugLoc(), Op.getValueType(), return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
Zero, Op.getOperand(0)); Zero, Op.getOperand(0));
} }
return DAG.UnrollVectorOp(Op.getNode()); return DAG.UnrollVectorOp(Op.getNode());
@ -751,7 +751,7 @@ SDValue VectorLegalizer::UnrollVSETCC(SDValue Op) {
EVT EltVT = VT.getVectorElementType(); EVT EltVT = VT.getVectorElementType();
SDValue LHS = Op.getOperand(0), RHS = Op.getOperand(1), CC = Op.getOperand(2); SDValue LHS = Op.getOperand(0), RHS = Op.getOperand(1), CC = Op.getOperand(2);
EVT TmpEltVT = LHS.getValueType().getVectorElementType(); EVT TmpEltVT = LHS.getValueType().getVectorElementType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);;
SmallVector<SDValue, 8> Ops(NumElems); SmallVector<SDValue, 8> Ops(NumElems);
for (unsigned i = 0; i < NumElems; ++i) { for (unsigned i = 0; i < NumElems; ++i) {
SDValue LHSElem = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, TmpEltVT, LHS, SDValue LHSElem = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, TmpEltVT, LHS,

168
lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
View File

@ -128,7 +128,7 @@ void DAGTypeLegalizer::ScalarizeVectorResult(SDNode *N, unsigned ResNo) {
SDValue DAGTypeLegalizer::ScalarizeVecRes_BinOp(SDNode *N) { SDValue DAGTypeLegalizer::ScalarizeVecRes_BinOp(SDNode *N) {
SDValue LHS = GetScalarizedVector(N->getOperand(0)); SDValue LHS = GetScalarizedVector(N->getOperand(0));
SDValue RHS = GetScalarizedVector(N->getOperand(1)); SDValue RHS = GetScalarizedVector(N->getOperand(1));
return DAG.getNode(N->getOpcode(), N->getDebugLoc(), return DAG.getNode(N->getOpcode(), SDLoc(N),
LHS.getValueType(), LHS, RHS); LHS.getValueType(), LHS, RHS);
} }
@ -136,7 +136,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_TernaryOp(SDNode *N) {
SDValue Op0 = GetScalarizedVector(N->getOperand(0)); SDValue Op0 = GetScalarizedVector(N->getOperand(0));
SDValue Op1 = GetScalarizedVector(N->getOperand(1)); SDValue Op1 = GetScalarizedVector(N->getOperand(1));
SDValue Op2 = GetScalarizedVector(N->getOperand(2)); SDValue Op2 = GetScalarizedVector(N->getOperand(2));
return DAG.getNode(N->getOpcode(), N->getDebugLoc(), return DAG.getNode(N->getOpcode(), SDLoc(N),
Op0.getValueType(), Op0, Op1, Op2); Op0.getValueType(), Op0, Op1, Op2);
} }
@ -148,7 +148,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_MERGE_VALUES(SDNode *N,
SDValue DAGTypeLegalizer::ScalarizeVecRes_BITCAST(SDNode *N) { SDValue DAGTypeLegalizer::ScalarizeVecRes_BITCAST(SDNode *N) {
EVT NewVT = N->getValueType(0).getVectorElementType(); EVT NewVT = N->getValueType(0).getVectorElementType();
return DAG.getNode(ISD::BITCAST, N->getDebugLoc(), return DAG.getNode(ISD::BITCAST, SDLoc(N),
NewVT, N->getOperand(0)); NewVT, N->getOperand(0));
} }
@ -158,14 +158,14 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_BUILD_VECTOR(SDNode *N) {
// The BUILD_VECTOR operands may be of wider element types and // The BUILD_VECTOR operands may be of wider element types and
// we may need to truncate them back to the requested return type. // we may need to truncate them back to the requested return type.
if (EltVT.isInteger()) if (EltVT.isInteger())
return DAG.getNode(ISD::TRUNCATE, N->getDebugLoc(), EltVT, InOp); return DAG.getNode(ISD::TRUNCATE, SDLoc(N), EltVT, InOp);
return InOp; return InOp;
} }
SDValue DAGTypeLegalizer::ScalarizeVecRes_CONVERT_RNDSAT(SDNode *N) { SDValue DAGTypeLegalizer::ScalarizeVecRes_CONVERT_RNDSAT(SDNode *N) {
EVT NewVT = N->getValueType(0).getVectorElementType(); EVT NewVT = N->getValueType(0).getVectorElementType();
SDValue Op0 = GetScalarizedVector(N->getOperand(0)); SDValue Op0 = GetScalarizedVector(N->getOperand(0));
return DAG.getConvertRndSat(NewVT, N->getDebugLoc(), return DAG.getConvertRndSat(NewVT, SDLoc(N),
Op0, DAG.getValueType(NewVT), Op0, DAG.getValueType(NewVT),
DAG.getValueType(Op0.getValueType()), DAG.getValueType(Op0.getValueType()),
N->getOperand(3), N->getOperand(3),
@ -174,7 +174,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_CONVERT_RNDSAT(SDNode *N) {
} }
SDValue DAGTypeLegalizer::ScalarizeVecRes_EXTRACT_SUBVECTOR(SDNode *N) { SDValue DAGTypeLegalizer::ScalarizeVecRes_EXTRACT_SUBVECTOR(SDNode *N) {
return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, N->getDebugLoc(), return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N),
N->getValueType(0).getVectorElementType(), N->getValueType(0).getVectorElementType(),
N->getOperand(0), N->getOperand(1)); N->getOperand(0), N->getOperand(1));
} }
@ -182,13 +182,13 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_EXTRACT_SUBVECTOR(SDNode *N) {
SDValue DAGTypeLegalizer::ScalarizeVecRes_FP_ROUND(SDNode *N) { SDValue DAGTypeLegalizer::ScalarizeVecRes_FP_ROUND(SDNode *N) {
EVT NewVT = N->getValueType(0).getVectorElementType(); EVT NewVT = N->getValueType(0).getVectorElementType();
SDValue Op = GetScalarizedVector(N->getOperand(0)); SDValue Op = GetScalarizedVector(N->getOperand(0));
return DAG.getNode(ISD::FP_ROUND, N->getDebugLoc(), return DAG.getNode(ISD::FP_ROUND, SDLoc(N),
NewVT, Op, N->getOperand(1)); NewVT, Op, N->getOperand(1));
} }
SDValue DAGTypeLegalizer::ScalarizeVecRes_FPOWI(SDNode *N) { SDValue DAGTypeLegalizer::ScalarizeVecRes_FPOWI(SDNode *N) {
SDValue Op = GetScalarizedVector(N->getOperand(0)); SDValue Op = GetScalarizedVector(N->getOperand(0));
return DAG.getNode(ISD::FPOWI, N->getDebugLoc(), return DAG.getNode(ISD::FPOWI, SDLoc(N),
Op.getValueType(), Op, N->getOperand(1)); Op.getValueType(), Op, N->getOperand(1));
} }
@ -199,7 +199,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_INSERT_VECTOR_ELT(SDNode *N) {
EVT EltVT = N->getValueType(0).getVectorElementType(); EVT EltVT = N->getValueType(0).getVectorElementType();
if (Op.getValueType() != EltVT) if (Op.getValueType() != EltVT)
// FIXME: Can this happen for floating point types? // FIXME: Can this happen for floating point types?
Op = DAG.getNode(ISD::TRUNCATE, N->getDebugLoc(), EltVT, Op); Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N), EltVT, Op);
return Op; return Op;
} }
@ -209,7 +209,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_LOAD(LoadSDNode *N) {
SDValue Result = DAG.getLoad(ISD::UNINDEXED, SDValue Result = DAG.getLoad(ISD::UNINDEXED,
N->getExtensionType(), N->getExtensionType(),
N->getValueType(0).getVectorElementType(), N->getValueType(0).getVectorElementType(),
N->getDebugLoc(), SDLoc(N),
N->getChain(), N->getBasePtr(), N->getChain(), N->getBasePtr(),
DAG.getUNDEF(N->getBasePtr().getValueType()), DAG.getUNDEF(N->getBasePtr().getValueType()),
N->getPointerInfo(), N->getPointerInfo(),
@ -227,14 +227,14 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_UnaryOp(SDNode *N) {
// Get the dest type - it doesn't always match the input type, e.g. int_to_fp. // Get the dest type - it doesn't always match the input type, e.g. int_to_fp.
EVT DestVT = N->getValueType(0).getVectorElementType(); EVT DestVT = N->getValueType(0).getVectorElementType();
SDValue Op = GetScalarizedVector(N->getOperand(0)); SDValue Op = GetScalarizedVector(N->getOperand(0));
return DAG.getNode(N->getOpcode(), N->getDebugLoc(), DestVT, Op); return DAG.getNode(N->getOpcode(), SDLoc(N), DestVT, Op);
} }
SDValue DAGTypeLegalizer::ScalarizeVecRes_InregOp(SDNode *N) { SDValue DAGTypeLegalizer::ScalarizeVecRes_InregOp(SDNode *N) {
EVT EltVT = N->getValueType(0).getVectorElementType(); EVT EltVT = N->getValueType(0).getVectorElementType();
EVT ExtVT = cast<VTSDNode>(N->getOperand(1))->getVT().getVectorElementType(); EVT ExtVT = cast<VTSDNode>(N->getOperand(1))->getVT().getVectorElementType();
SDValue LHS = GetScalarizedVector(N->getOperand(0)); SDValue LHS = GetScalarizedVector(N->getOperand(0));
return DAG.getNode(N->getOpcode(), N->getDebugLoc(), EltVT, return DAG.getNode(N->getOpcode(), SDLoc(N), EltVT,
LHS, DAG.getValueType(ExtVT)); LHS, DAG.getValueType(ExtVT));
} }
@ -244,7 +244,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_SCALAR_TO_VECTOR(SDNode *N) {
EVT EltVT = N->getValueType(0).getVectorElementType(); EVT EltVT = N->getValueType(0).getVectorElementType();
SDValue InOp = N->getOperand(0); SDValue InOp = N->getOperand(0);
if (InOp.getValueType() != EltVT) if (InOp.getValueType() != EltVT)
return DAG.getNode(ISD::TRUNCATE, N->getDebugLoc(), EltVT, InOp); return DAG.getNode(ISD::TRUNCATE, SDLoc(N), EltVT, InOp);
return InOp; return InOp;
} }
@ -262,33 +262,33 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_VSELECT(SDNode *N) {
assert(VecBool == TargetLowering::UndefinedBooleanContent || assert(VecBool == TargetLowering::UndefinedBooleanContent ||
VecBool == TargetLowering::ZeroOrNegativeOneBooleanContent); VecBool == TargetLowering::ZeroOrNegativeOneBooleanContent);
// Vector read from all ones, scalar expects a single 1 so mask. // Vector read from all ones, scalar expects a single 1 so mask.
Cond = DAG.getNode(ISD::AND, N->getDebugLoc(), CondVT, Cond = DAG.getNode(ISD::AND, SDLoc(N), CondVT,
Cond, DAG.getConstant(1, CondVT)); Cond, DAG.getConstant(1, CondVT));
break; break;
case TargetLowering::ZeroOrNegativeOneBooleanContent: case TargetLowering::ZeroOrNegativeOneBooleanContent:
assert(VecBool == TargetLowering::UndefinedBooleanContent || assert(VecBool == TargetLowering::UndefinedBooleanContent ||
VecBool == TargetLowering::ZeroOrOneBooleanContent); VecBool == TargetLowering::ZeroOrOneBooleanContent);
// Vector reads from a one, scalar from all ones so sign extend. // Vector reads from a one, scalar from all ones so sign extend.
Cond = DAG.getNode(ISD::SIGN_EXTEND_INREG, N->getDebugLoc(), CondVT, Cond = DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), CondVT,
Cond, DAG.getValueType(MVT::i1)); Cond, DAG.getValueType(MVT::i1));
break; break;
} }
} }
return DAG.getNode(ISD::SELECT, N->getDebugLoc(), return DAG.getNode(ISD::SELECT, SDLoc(N),
LHS.getValueType(), Cond, LHS, LHS.getValueType(), Cond, LHS,
GetScalarizedVector(N->getOperand(2))); GetScalarizedVector(N->getOperand(2)));
} }
SDValue DAGTypeLegalizer::ScalarizeVecRes_SELECT(SDNode *N) { SDValue DAGTypeLegalizer::ScalarizeVecRes_SELECT(SDNode *N) {
SDValue LHS = GetScalarizedVector(N->getOperand(1)); SDValue LHS = GetScalarizedVector(N->getOperand(1));
return DAG.getNode(ISD::SELECT, N->getDebugLoc(), return DAG.getNode(ISD::SELECT, SDLoc(N),
LHS.getValueType(), N->getOperand(0), LHS, LHS.getValueType(), N->getOperand(0), LHS,
GetScalarizedVector(N->getOperand(2))); GetScalarizedVector(N->getOperand(2)));
} }
SDValue DAGTypeLegalizer::ScalarizeVecRes_SELECT_CC(SDNode *N) { SDValue DAGTypeLegalizer::ScalarizeVecRes_SELECT_CC(SDNode *N) {
SDValue LHS = GetScalarizedVector(N->getOperand(2)); SDValue LHS = GetScalarizedVector(N->getOperand(2));
return DAG.getNode(ISD::SELECT_CC, N->getDebugLoc(), LHS.getValueType(), return DAG.getNode(ISD::SELECT_CC, SDLoc(N), LHS.getValueType(),
N->getOperand(0), N->getOperand(1), N->getOperand(0), N->getOperand(1),
LHS, GetScalarizedVector(N->getOperand(3)), LHS, GetScalarizedVector(N->getOperand(3)),
N->getOperand(4)); N->getOperand(4));
@ -303,7 +303,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_SETCC(SDNode *N) {
SDValue LHS = GetScalarizedVector(N->getOperand(0)); SDValue LHS = GetScalarizedVector(N->getOperand(0));
SDValue RHS = GetScalarizedVector(N->getOperand(1)); SDValue RHS = GetScalarizedVector(N->getOperand(1));
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);;
// Turn it into a scalar SETCC. // Turn it into a scalar SETCC.
return DAG.getNode(ISD::SETCC, DL, MVT::i1, LHS, RHS, N->getOperand(2)); return DAG.getNode(ISD::SETCC, DL, MVT::i1, LHS, RHS, N->getOperand(2));
@ -330,7 +330,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_VSETCC(SDNode *N) {
SDValue LHS = GetScalarizedVector(N->getOperand(0)); SDValue LHS = GetScalarizedVector(N->getOperand(0));
SDValue RHS = GetScalarizedVector(N->getOperand(1)); SDValue RHS = GetScalarizedVector(N->getOperand(1));
EVT NVT = N->getValueType(0).getVectorElementType(); EVT NVT = N->getValueType(0).getVectorElementType();
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);;
// Turn it into a scalar SETCC. // Turn it into a scalar SETCC.
SDValue Res = DAG.getNode(ISD::SETCC, DL, MVT::i1, LHS, RHS, SDValue Res = DAG.getNode(ISD::SETCC, DL, MVT::i1, LHS, RHS,
@ -401,7 +401,7 @@ bool DAGTypeLegalizer::ScalarizeVectorOperand(SDNode *N, unsigned OpNo) {
/// to be scalarized, it must be <1 x ty>. Convert the element instead. /// to be scalarized, it must be <1 x ty>. Convert the element instead.
SDValue DAGTypeLegalizer::ScalarizeVecOp_BITCAST(SDNode *N) { SDValue DAGTypeLegalizer::ScalarizeVecOp_BITCAST(SDNode *N) {
SDValue Elt = GetScalarizedVector(N->getOperand(0)); SDValue Elt = GetScalarizedVector(N->getOperand(0));
return DAG.getNode(ISD::BITCAST, N->getDebugLoc(), return DAG.getNode(ISD::BITCAST, SDLoc(N),
N->getValueType(0), Elt); N->getValueType(0), Elt);
} }
@ -412,11 +412,11 @@ SDValue DAGTypeLegalizer::ScalarizeVecOp_EXTEND(SDNode *N) {
"Unexected vector type!"); "Unexected vector type!");
SDValue Elt = GetScalarizedVector(N->getOperand(0)); SDValue Elt = GetScalarizedVector(N->getOperand(0));
SmallVector<SDValue, 1> Ops(1); SmallVector<SDValue, 1> Ops(1);
Ops[0] = DAG.getNode(N->getOpcode(), N->getDebugLoc(), Ops[0] = DAG.getNode(N->getOpcode(), SDLoc(N),
N->getValueType(0).getScalarType(), Elt); N->getValueType(0).getScalarType(), Elt);
// Revectorize the result so the types line up with what the uses of this // Revectorize the result so the types line up with what the uses of this
// expression expect. // expression expect.
return DAG.getNode(ISD::BUILD_VECTOR, N->getDebugLoc(), N->getValueType(0), return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), N->getValueType(0),
&Ops[0], 1); &Ops[0], 1);
} }
@ -426,7 +426,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecOp_CONCAT_VECTORS(SDNode *N) {
SmallVector<SDValue, 8> Ops(N->getNumOperands()); SmallVector<SDValue, 8> Ops(N->getNumOperands());
for (unsigned i = 0, e = N->getNumOperands(); i < e; ++i) for (unsigned i = 0, e = N->getNumOperands(); i < e; ++i)
Ops[i] = GetScalarizedVector(N->getOperand(i)); Ops[i] = GetScalarizedVector(N->getOperand(i));
return DAG.getNode(ISD::BUILD_VECTOR, N->getDebugLoc(), N->getValueType(0), return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), N->getValueType(0),
&Ops[0], Ops.size()); &Ops[0], Ops.size());
} }
@ -436,7 +436,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecOp_CONCAT_VECTORS(SDNode *N) {
SDValue DAGTypeLegalizer::ScalarizeVecOp_EXTRACT_VECTOR_ELT(SDNode *N) { SDValue DAGTypeLegalizer::ScalarizeVecOp_EXTRACT_VECTOR_ELT(SDNode *N) {
SDValue Res = GetScalarizedVector(N->getOperand(0)); SDValue Res = GetScalarizedVector(N->getOperand(0));
if (Res.getValueType() != N->getValueType(0)) if (Res.getValueType() != N->getValueType(0))
Res = DAG.getNode(ISD::ANY_EXTEND, N->getDebugLoc(), N->getValueType(0), Res = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), N->getValueType(0),
Res); Res);
return Res; return Res;
} }
@ -446,7 +446,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecOp_EXTRACT_VECTOR_ELT(SDNode *N) {
SDValue DAGTypeLegalizer::ScalarizeVecOp_STORE(StoreSDNode *N, unsigned OpNo){ SDValue DAGTypeLegalizer::ScalarizeVecOp_STORE(StoreSDNode *N, unsigned OpNo){
assert(N->isUnindexed() && "Indexed store of one-element vector?"); assert(N->isUnindexed() && "Indexed store of one-element vector?");
assert(OpNo == 1 && "Do not know how to scalarize this operand!"); assert(OpNo == 1 && "Do not know how to scalarize this operand!");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
if (N->isTruncatingStore()) if (N->isTruncatingStore())
return DAG.getTruncStore(N->getChain(), dl, return DAG.getTruncStore(N->getChain(), dl,
@ -587,7 +587,7 @@ void DAGTypeLegalizer::SplitVecRes_BinOp(SDNode *N, SDValue &Lo,
GetSplitVector(N->getOperand(0), LHSLo, LHSHi); GetSplitVector(N->getOperand(0), LHSLo, LHSHi);
SDValue RHSLo, RHSHi; SDValue RHSLo, RHSHi;
GetSplitVector(N->getOperand(1), RHSLo, RHSHi); GetSplitVector(N->getOperand(1), RHSLo, RHSHi);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
Lo = DAG.getNode(N->getOpcode(), dl, LHSLo.getValueType(), LHSLo, RHSLo); Lo = DAG.getNode(N->getOpcode(), dl, LHSLo.getValueType(), LHSLo, RHSLo);
Hi = DAG.getNode(N->getOpcode(), dl, LHSHi.getValueType(), LHSHi, RHSHi); Hi = DAG.getNode(N->getOpcode(), dl, LHSHi.getValueType(), LHSHi, RHSHi);
@ -601,7 +601,7 @@ void DAGTypeLegalizer::SplitVecRes_TernaryOp(SDNode *N, SDValue &Lo,
GetSplitVector(N->getOperand(1), Op1Lo, Op1Hi); GetSplitVector(N->getOperand(1), Op1Lo, Op1Hi);
SDValue Op2Lo, Op2Hi; SDValue Op2Lo, Op2Hi;
GetSplitVector(N->getOperand(2), Op2Lo, Op2Hi); GetSplitVector(N->getOperand(2), Op2Lo, Op2Hi);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
Lo = DAG.getNode(N->getOpcode(), dl, Op0Lo.getValueType(), Lo = DAG.getNode(N->getOpcode(), dl, Op0Lo.getValueType(),
Op0Lo, Op1Lo, Op2Lo); Op0Lo, Op1Lo, Op2Lo);
@ -615,7 +615,7 @@ void DAGTypeLegalizer::SplitVecRes_BITCAST(SDNode *N, SDValue &Lo,
// scalar value. // scalar value.
EVT LoVT, HiVT; EVT LoVT, HiVT;
GetSplitDestVTs(N->getValueType(0), LoVT, HiVT); GetSplitDestVTs(N->getValueType(0), LoVT, HiVT);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
SDValue InOp = N->getOperand(0); SDValue InOp = N->getOperand(0);
EVT InVT = InOp.getValueType(); EVT InVT = InOp.getValueType();
@ -668,7 +668,7 @@ void DAGTypeLegalizer::SplitVecRes_BITCAST(SDNode *N, SDValue &Lo,
void DAGTypeLegalizer::SplitVecRes_BUILD_VECTOR(SDNode *N, SDValue &Lo, void DAGTypeLegalizer::SplitVecRes_BUILD_VECTOR(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
EVT LoVT, HiVT; EVT LoVT, HiVT;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
GetSplitDestVTs(N->getValueType(0), LoVT, HiVT); GetSplitDestVTs(N->getValueType(0), LoVT, HiVT);
unsigned LoNumElts = LoVT.getVectorNumElements(); unsigned LoNumElts = LoVT.getVectorNumElements();
SmallVector<SDValue, 8> LoOps(N->op_begin(), N->op_begin()+LoNumElts); SmallVector<SDValue, 8> LoOps(N->op_begin(), N->op_begin()+LoNumElts);
@ -681,7 +681,7 @@ void DAGTypeLegalizer::SplitVecRes_BUILD_VECTOR(SDNode *N, SDValue &Lo,
void DAGTypeLegalizer::SplitVecRes_CONCAT_VECTORS(SDNode *N, SDValue &Lo, void DAGTypeLegalizer::SplitVecRes_CONCAT_VECTORS(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
assert(!(N->getNumOperands() & 1) && "Unsupported CONCAT_VECTORS"); assert(!(N->getNumOperands() & 1) && "Unsupported CONCAT_VECTORS");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
unsigned NumSubvectors = N->getNumOperands() / 2; unsigned NumSubvectors = N->getNumOperands() / 2;
if (NumSubvectors == 1) { if (NumSubvectors == 1) {
Lo = N->getOperand(0); Lo = N->getOperand(0);
@ -703,7 +703,7 @@ void DAGTypeLegalizer::SplitVecRes_EXTRACT_SUBVECTOR(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
SDValue Vec = N->getOperand(0); SDValue Vec = N->getOperand(0);
SDValue Idx = N->getOperand(1); SDValue Idx = N->getOperand(1);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
EVT LoVT, HiVT; EVT LoVT, HiVT;
GetSplitDestVTs(N->getValueType(0), LoVT, HiVT); GetSplitDestVTs(N->getValueType(0), LoVT, HiVT);
@ -716,7 +716,7 @@ void DAGTypeLegalizer::SplitVecRes_EXTRACT_SUBVECTOR(SDNode *N, SDValue &Lo,
void DAGTypeLegalizer::SplitVecRes_FPOWI(SDNode *N, SDValue &Lo, void DAGTypeLegalizer::SplitVecRes_FPOWI(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
GetSplitVector(N->getOperand(0), Lo, Hi); GetSplitVector(N->getOperand(0), Lo, Hi);
Lo = DAG.getNode(ISD::FPOWI, dl, Lo.getValueType(), Lo, N->getOperand(1)); Lo = DAG.getNode(ISD::FPOWI, dl, Lo.getValueType(), Lo, N->getOperand(1));
Hi = DAG.getNode(ISD::FPOWI, dl, Hi.getValueType(), Hi, N->getOperand(1)); Hi = DAG.getNode(ISD::FPOWI, dl, Hi.getValueType(), Hi, N->getOperand(1));
@ -726,7 +726,7 @@ void DAGTypeLegalizer::SplitVecRes_InregOp(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
SDValue LHSLo, LHSHi; SDValue LHSLo, LHSHi;
GetSplitVector(N->getOperand(0), LHSLo, LHSHi); GetSplitVector(N->getOperand(0), LHSLo, LHSHi);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
EVT LoVT, HiVT; EVT LoVT, HiVT;
GetSplitDestVTs(cast<VTSDNode>(N->getOperand(1))->getVT(), LoVT, HiVT); GetSplitDestVTs(cast<VTSDNode>(N->getOperand(1))->getVT(), LoVT, HiVT);
@ -742,7 +742,7 @@ void DAGTypeLegalizer::SplitVecRes_INSERT_VECTOR_ELT(SDNode *N, SDValue &Lo,
SDValue Vec = N->getOperand(0); SDValue Vec = N->getOperand(0);
SDValue Elt = N->getOperand(1); SDValue Elt = N->getOperand(1);
SDValue Idx = N->getOperand(2); SDValue Idx = N->getOperand(2);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
GetSplitVector(Vec, Lo, Hi); GetSplitVector(Vec, Lo, Hi);
if (ConstantSDNode *CIdx = dyn_cast<ConstantSDNode>(Idx)) { if (ConstantSDNode *CIdx = dyn_cast<ConstantSDNode>(Idx)) {
@ -790,7 +790,7 @@ void DAGTypeLegalizer::SplitVecRes_INSERT_VECTOR_ELT(SDNode *N, SDValue &Lo,
void DAGTypeLegalizer::SplitVecRes_SCALAR_TO_VECTOR(SDNode *N, SDValue &Lo, void DAGTypeLegalizer::SplitVecRes_SCALAR_TO_VECTOR(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
EVT LoVT, HiVT; EVT LoVT, HiVT;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
GetSplitDestVTs(N->getValueType(0), LoVT, HiVT); GetSplitDestVTs(N->getValueType(0), LoVT, HiVT);
Lo = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoVT, N->getOperand(0)); Lo = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoVT, N->getOperand(0));
Hi = DAG.getUNDEF(HiVT); Hi = DAG.getUNDEF(HiVT);
@ -800,7 +800,7 @@ void DAGTypeLegalizer::SplitVecRes_LOAD(LoadSDNode *LD, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
assert(ISD::isUNINDEXEDLoad(LD) && "Indexed load during type legalization!"); assert(ISD::isUNINDEXEDLoad(LD) && "Indexed load during type legalization!");
EVT LoVT, HiVT; EVT LoVT, HiVT;
DebugLoc dl = LD->getDebugLoc(); SDLoc dl(LD);;
GetSplitDestVTs(LD->getValueType(0), LoVT, HiVT); GetSplitDestVTs(LD->getValueType(0), LoVT, HiVT);
ISD::LoadExtType ExtType = LD->getExtensionType(); ISD::LoadExtType ExtType = LD->getExtensionType();
@ -843,7 +843,7 @@ void DAGTypeLegalizer::SplitVecRes_SETCC(SDNode *N, SDValue &Lo, SDValue &Hi) {
"Operand types must be vectors"); "Operand types must be vectors");
EVT LoVT, HiVT; EVT LoVT, HiVT;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);;
GetSplitDestVTs(N->getValueType(0), LoVT, HiVT); GetSplitDestVTs(N->getValueType(0), LoVT, HiVT);
// Split the input. // Split the input.
@ -869,7 +869,7 @@ void DAGTypeLegalizer::SplitVecRes_UnaryOp(SDNode *N, SDValue &Lo,
SDValue &Hi) { SDValue &Hi) {
// Get the dest types - they may not match the input types, e.g. int_to_fp. // Get the dest types - they may not match the input types, e.g. int_to_fp.
EVT LoVT, HiVT; EVT LoVT, HiVT;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
GetSplitDestVTs(N->getValueType(0), LoVT, HiVT); GetSplitDestVTs(N->getValueType(0), LoVT, HiVT);
// If the input also splits, handle it directly for a compile time speedup. // If the input also splits, handle it directly for a compile time speedup.
@ -911,7 +911,7 @@ void DAGTypeLegalizer::SplitVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *N,
SDValue &Lo, SDValue &Hi) { SDValue &Lo, SDValue &Hi) {
// The low and high parts of the original input give four input vectors. // The low and high parts of the original input give four input vectors.
SDValue Inputs[4]; SDValue Inputs[4];
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
GetSplitVector(N->getOperand(0), Inputs[0], Inputs[1]); GetSplitVector(N->getOperand(0), Inputs[0], Inputs[1]);
GetSplitVector(N->getOperand(1), Inputs[2], Inputs[3]); GetSplitVector(N->getOperand(1), Inputs[2], Inputs[3]);
EVT NewVT = Inputs[0].getValueType(); EVT NewVT = Inputs[0].getValueType();
@ -1094,7 +1094,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_VSELECT(SDNode *N, unsigned OpNo) {
SDValue Mask = N->getOperand(0); SDValue Mask = N->getOperand(0);
SDValue Src0 = N->getOperand(1); SDValue Src0 = N->getOperand(1);
SDValue Src1 = N->getOperand(2); SDValue Src1 = N->getOperand(2);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);;
EVT MaskVT = Mask.getValueType(); EVT MaskVT = Mask.getValueType();
assert(MaskVT.isVector() && "VSELECT without a vector mask?"); assert(MaskVT.isVector() && "VSELECT without a vector mask?");
@ -1142,7 +1142,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_UnaryOp(SDNode *N) {
// The result has a legal vector type, but the input needs splitting. // The result has a legal vector type, but the input needs splitting.
EVT ResVT = N->getValueType(0); EVT ResVT = N->getValueType(0);
SDValue Lo, Hi; SDValue Lo, Hi;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
GetSplitVector(N->getOperand(0), Lo, Hi); GetSplitVector(N->getOperand(0), Lo, Hi);
EVT InVT = Lo.getValueType(); EVT InVT = Lo.getValueType();
@ -1167,7 +1167,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_BITCAST(SDNode *N) {
if (TLI.isBigEndian()) if (TLI.isBigEndian())
std::swap(Lo, Hi); std::swap(Lo, Hi);
return DAG.getNode(ISD::BITCAST, N->getDebugLoc(), N->getValueType(0), return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0),
JoinIntegers(Lo, Hi)); JoinIntegers(Lo, Hi));
} }
@ -1175,7 +1175,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_EXTRACT_SUBVECTOR(SDNode *N) {
// We know that the extracted result type is legal. // We know that the extracted result type is legal.
EVT SubVT = N->getValueType(0); EVT SubVT = N->getValueType(0);
SDValue Idx = N->getOperand(1); SDValue Idx = N->getOperand(1);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
SDValue Lo, Hi; SDValue Lo, Hi;
GetSplitVector(N->getOperand(0), Lo, Hi); GetSplitVector(N->getOperand(0), Lo, Hi);
@ -1215,7 +1215,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_EXTRACT_VECTOR_ELT(SDNode *N) {
// Store the vector to the stack. // Store the vector to the stack.
EVT EltVT = VecVT.getVectorElementType(); EVT EltVT = VecVT.getVectorElementType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
SDValue StackPtr = DAG.CreateStackTemporary(VecVT); SDValue StackPtr = DAG.CreateStackTemporary(VecVT);
SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr, SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr,
MachinePointerInfo(), false, false, 0); MachinePointerInfo(), false, false, 0);
@ -1229,7 +1229,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_EXTRACT_VECTOR_ELT(SDNode *N) {
SDValue DAGTypeLegalizer::SplitVecOp_STORE(StoreSDNode *N, unsigned OpNo) { SDValue DAGTypeLegalizer::SplitVecOp_STORE(StoreSDNode *N, unsigned OpNo) {
assert(N->isUnindexed() && "Indexed store of vector?"); assert(N->isUnindexed() && "Indexed store of vector?");
assert(OpNo == 1 && "Can only split the stored value"); assert(OpNo == 1 && "Can only split the stored value");
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);;
bool isTruncating = N->isTruncatingStore(); bool isTruncating = N->isTruncatingStore();
SDValue Ch = N->getChain(); SDValue Ch = N->getChain();
@ -1270,7 +1270,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_STORE(StoreSDNode *N, unsigned OpNo) {
} }
SDValue DAGTypeLegalizer::SplitVecOp_CONCAT_VECTORS(SDNode *N) { SDValue DAGTypeLegalizer::SplitVecOp_CONCAT_VECTORS(SDNode *N) {
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);;
// The input operands all must have the same type, and we know the result // The input operands all must have the same type, and we know the result
// type is valid. Convert this to a buildvector which extracts all the // type is valid. Convert this to a buildvector which extracts all the
@ -1327,7 +1327,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_TRUNCATE(SDNode *N) {
// to split more than once. // to split more than once.
if (InElementSize <= OutElementSize * 2) if (InElementSize <= OutElementSize * 2)
return SplitVecOp_UnaryOp(N); return SplitVecOp_UnaryOp(N);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);;
// Extract the halves of the input via extract_subvector. // Extract the halves of the input via extract_subvector.
EVT SplitVT = EVT::getVectorVT(*DAG.getContext(), EVT SplitVT = EVT::getVectorVT(*DAG.getContext(),
@ -1359,7 +1359,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_VSETCC(SDNode *N) {
"Operand types must be vectors"); "Operand types must be vectors");
// The result has a legal vector type, but the input needs splitting. // The result has a legal vector type, but the input needs splitting.
SDValue Lo0, Hi0, Lo1, Hi1, LoRes, HiRes; SDValue Lo0, Hi0, Lo1, Hi1, LoRes, HiRes;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);;
GetSplitVector(N->getOperand(0), Lo0, Hi0); GetSplitVector(N->getOperand(0), Lo0, Hi0);
GetSplitVector(N->getOperand(1), Lo1, Hi1); GetSplitVector(N->getOperand(1), Lo1, Hi1);
unsigned PartElements = Lo0.getValueType().getVectorNumElements(); unsigned PartElements = Lo0.getValueType().getVectorNumElements();
@ -1377,7 +1377,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_FP_ROUND(SDNode *N) {
// The result has a legal vector type, but the input needs splitting. // The result has a legal vector type, but the input needs splitting.
EVT ResVT = N->getValueType(0); EVT ResVT = N->getValueType(0);
SDValue Lo, Hi; SDValue Lo, Hi;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);;
GetSplitVector(N->getOperand(0), Lo, Hi); GetSplitVector(N->getOperand(0), Lo, Hi);
EVT InVT = Lo.getValueType(); EVT InVT = Lo.getValueType();
@ -1512,7 +1512,7 @@ void DAGTypeLegalizer::WidenVectorResult(SDNode *N, unsigned ResNo) {
SDValue DAGTypeLegalizer::WidenVecRes_Ternary(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_Ternary(SDNode *N) {
// Ternary op widening. // Ternary op widening.
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue InOp1 = GetWidenedVector(N->getOperand(0)); SDValue InOp1 = GetWidenedVector(N->getOperand(0));
SDValue InOp2 = GetWidenedVector(N->getOperand(1)); SDValue InOp2 = GetWidenedVector(N->getOperand(1));
@ -1523,7 +1523,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_Ternary(SDNode *N) {
SDValue DAGTypeLegalizer::WidenVecRes_Binary(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_Binary(SDNode *N) {
// Binary op widening. // Binary op widening.
unsigned Opcode = N->getOpcode(); unsigned Opcode = N->getOpcode();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
EVT WidenEltVT = WidenVT.getVectorElementType(); EVT WidenEltVT = WidenVT.getVectorElementType();
EVT VT = WidenVT; EVT VT = WidenVT;
@ -1659,7 +1659,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_Binary(SDNode *N) {
SDValue DAGTypeLegalizer::WidenVecRes_Convert(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_Convert(SDNode *N) {
SDValue InOp = N->getOperand(0); SDValue InOp = N->getOperand(0);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);;
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
unsigned WidenNumElts = WidenVT.getVectorNumElements(); unsigned WidenNumElts = WidenVT.getVectorNumElements();
@ -1738,7 +1738,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_POWI(SDNode *N) {
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue InOp = GetWidenedVector(N->getOperand(0)); SDValue InOp = GetWidenedVector(N->getOperand(0));
SDValue ShOp = N->getOperand(1); SDValue ShOp = N->getOperand(1);
return DAG.getNode(N->getOpcode(), N->getDebugLoc(), WidenVT, InOp, ShOp); return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp, ShOp);
} }
SDValue DAGTypeLegalizer::WidenVecRes_Shift(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_Shift(SDNode *N) {
@ -1757,14 +1757,14 @@ SDValue DAGTypeLegalizer::WidenVecRes_Shift(SDNode *N) {
if (ShVT != ShWidenVT) if (ShVT != ShWidenVT)
ShOp = ModifyToType(ShOp, ShWidenVT); ShOp = ModifyToType(ShOp, ShWidenVT);
return DAG.getNode(N->getOpcode(), N->getDebugLoc(), WidenVT, InOp, ShOp); return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp, ShOp);
} }
SDValue DAGTypeLegalizer::WidenVecRes_Unary(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_Unary(SDNode *N) {
// Unary op widening. // Unary op widening.
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue InOp = GetWidenedVector(N->getOperand(0)); SDValue InOp = GetWidenedVector(N->getOperand(0));
return DAG.getNode(N->getOpcode(), N->getDebugLoc(), WidenVT, InOp); return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp);
} }
SDValue DAGTypeLegalizer::WidenVecRes_InregOp(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_InregOp(SDNode *N) {
@ -1774,7 +1774,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_InregOp(SDNode *N) {
.getVectorElementType(), .getVectorElementType(),
WidenVT.getVectorNumElements()); WidenVT.getVectorNumElements());
SDValue WidenLHS = GetWidenedVector(N->getOperand(0)); SDValue WidenLHS = GetWidenedVector(N->getOperand(0));
return DAG.getNode(N->getOpcode(), N->getDebugLoc(), return DAG.getNode(N->getOpcode(), SDLoc(N),
WidenVT, WidenLHS, DAG.getValueType(ExtVT)); WidenVT, WidenLHS, DAG.getValueType(ExtVT));
} }
@ -1788,7 +1788,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_BITCAST(SDNode *N) {
EVT InVT = InOp.getValueType(); EVT InVT = InOp.getValueType();
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT); EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
switch (getTypeAction(InVT)) { switch (getTypeAction(InVT)) {
case TargetLowering::TypeLegal: case TargetLowering::TypeLegal:
@ -1868,7 +1868,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_BITCAST(SDNode *N) {
} }
SDValue DAGTypeLegalizer::WidenVecRes_BUILD_VECTOR(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_BUILD_VECTOR(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
// Build a vector with undefined for the new nodes. // Build a vector with undefined for the new nodes.
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
EVT EltVT = VT.getVectorElementType(); EVT EltVT = VT.getVectorElementType();
@ -1888,7 +1888,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_BUILD_VECTOR(SDNode *N) {
SDValue DAGTypeLegalizer::WidenVecRes_CONCAT_VECTORS(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_CONCAT_VECTORS(SDNode *N) {
EVT InVT = N->getOperand(0).getValueType(); EVT InVT = N->getOperand(0).getValueType();
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
unsigned WidenNumElts = WidenVT.getVectorNumElements(); unsigned WidenNumElts = WidenVT.getVectorNumElements();
unsigned NumInElts = InVT.getVectorNumElements(); unsigned NumInElts = InVT.getVectorNumElements();
unsigned NumOperands = N->getNumOperands(); unsigned NumOperands = N->getNumOperands();
@ -1955,7 +1955,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_CONCAT_VECTORS(SDNode *N) {
} }
SDValue DAGTypeLegalizer::WidenVecRes_CONVERT_RNDSAT(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_CONVERT_RNDSAT(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
SDValue InOp = N->getOperand(0); SDValue InOp = N->getOperand(0);
SDValue RndOp = N->getOperand(3); SDValue RndOp = N->getOperand(3);
SDValue SatOp = N->getOperand(4); SDValue SatOp = N->getOperand(4);
@ -2038,7 +2038,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_EXTRACT_SUBVECTOR(SDNode *N) {
unsigned WidenNumElts = WidenVT.getVectorNumElements(); unsigned WidenNumElts = WidenVT.getVectorNumElements();
SDValue InOp = N->getOperand(0); SDValue InOp = N->getOperand(0);
SDValue Idx = N->getOperand(1); SDValue Idx = N->getOperand(1);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
if (getTypeAction(InOp.getValueType()) == TargetLowering::TypeWidenVector) if (getTypeAction(InOp.getValueType()) == TargetLowering::TypeWidenVector)
InOp = GetWidenedVector(InOp); InOp = GetWidenedVector(InOp);
@ -2073,7 +2073,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_EXTRACT_SUBVECTOR(SDNode *N) {
SDValue DAGTypeLegalizer::WidenVecRes_INSERT_VECTOR_ELT(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_INSERT_VECTOR_ELT(SDNode *N) {
SDValue InOp = GetWidenedVector(N->getOperand(0)); SDValue InOp = GetWidenedVector(N->getOperand(0));
return DAG.getNode(ISD::INSERT_VECTOR_ELT, N->getDebugLoc(), return DAG.getNode(ISD::INSERT_VECTOR_ELT, SDLoc(N),
InOp.getValueType(), InOp, InOp.getValueType(), InOp,
N->getOperand(1), N->getOperand(2)); N->getOperand(1), N->getOperand(2));
} }
@ -2096,7 +2096,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_LOAD(SDNode *N) {
if (LdChain.size() == 1) if (LdChain.size() == 1)
NewChain = LdChain[0]; NewChain = LdChain[0];
else else
NewChain = DAG.getNode(ISD::TokenFactor, LD->getDebugLoc(), MVT::Other, NewChain = DAG.getNode(ISD::TokenFactor, SDLoc(LD), MVT::Other,
&LdChain[0], LdChain.size()); &LdChain[0], LdChain.size());
// Modified the chain - switch anything that used the old chain to use // Modified the chain - switch anything that used the old chain to use
@ -2108,7 +2108,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_LOAD(SDNode *N) {
SDValue DAGTypeLegalizer::WidenVecRes_SCALAR_TO_VECTOR(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_SCALAR_TO_VECTOR(SDNode *N) {
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
return DAG.getNode(ISD::SCALAR_TO_VECTOR, N->getDebugLoc(), return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N),
WidenVT, N->getOperand(0)); WidenVT, N->getOperand(0));
} }
@ -2132,14 +2132,14 @@ SDValue DAGTypeLegalizer::WidenVecRes_SELECT(SDNode *N) {
SDValue InOp1 = GetWidenedVector(N->getOperand(1)); SDValue InOp1 = GetWidenedVector(N->getOperand(1));
SDValue InOp2 = GetWidenedVector(N->getOperand(2)); SDValue InOp2 = GetWidenedVector(N->getOperand(2));
assert(InOp1.getValueType() == WidenVT && InOp2.getValueType() == WidenVT); assert(InOp1.getValueType() == WidenVT && InOp2.getValueType() == WidenVT);
return DAG.getNode(N->getOpcode(), N->getDebugLoc(), return DAG.getNode(N->getOpcode(), SDLoc(N),
WidenVT, Cond1, InOp1, InOp2); WidenVT, Cond1, InOp1, InOp2);
} }
SDValue DAGTypeLegalizer::WidenVecRes_SELECT_CC(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_SELECT_CC(SDNode *N) {
SDValue InOp1 = GetWidenedVector(N->getOperand(2)); SDValue InOp1 = GetWidenedVector(N->getOperand(2));
SDValue InOp2 = GetWidenedVector(N->getOperand(3)); SDValue InOp2 = GetWidenedVector(N->getOperand(3));
return DAG.getNode(ISD::SELECT_CC, N->getDebugLoc(), return DAG.getNode(ISD::SELECT_CC, SDLoc(N),
InOp1.getValueType(), N->getOperand(0), InOp1.getValueType(), N->getOperand(0),
N->getOperand(1), InOp1, InOp2, N->getOperand(4)); N->getOperand(1), InOp1, InOp2, N->getOperand(4));
} }
@ -2153,7 +2153,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_SETCC(SDNode *N) {
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue InOp1 = GetWidenedVector(N->getOperand(0)); SDValue InOp1 = GetWidenedVector(N->getOperand(0));
SDValue InOp2 = GetWidenedVector(N->getOperand(1)); SDValue InOp2 = GetWidenedVector(N->getOperand(1));
return DAG.getNode(ISD::SETCC, N->getDebugLoc(), WidenVT, return DAG.getNode(ISD::SETCC, SDLoc(N), WidenVT,
InOp1, InOp2, N->getOperand(2)); InOp1, InOp2, N->getOperand(2));
} }
@ -2164,7 +2164,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_UNDEF(SDNode *N) {
SDValue DAGTypeLegalizer::WidenVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *N) { SDValue DAGTypeLegalizer::WidenVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *N) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT); EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
unsigned NumElts = VT.getVectorNumElements(); unsigned NumElts = VT.getVectorNumElements();
@ -2208,7 +2208,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_VSETCC(SDNode *N) {
InOp2.getValueType() == WidenInVT && InOp2.getValueType() == WidenInVT &&
"Input not widened to expected type!"); "Input not widened to expected type!");
(void)WidenInVT; (void)WidenInVT;
return DAG.getNode(ISD::SETCC, N->getDebugLoc(), return DAG.getNode(ISD::SETCC, SDLoc(N),
WidenVT, InOp1, InOp2, N->getOperand(2)); WidenVT, InOp1, InOp2, N->getOperand(2));
} }
@ -2277,7 +2277,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_Convert(SDNode *N) {
// into some scalar code and create a nasty build vector. // into some scalar code and create a nasty build vector.
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
EVT EltVT = VT.getVectorElementType(); EVT EltVT = VT.getVectorElementType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
unsigned NumElts = VT.getVectorNumElements(); unsigned NumElts = VT.getVectorNumElements();
SDValue InOp = N->getOperand(0); SDValue InOp = N->getOperand(0);
if (getTypeAction(InOp.getValueType()) == TargetLowering::TypeWidenVector) if (getTypeAction(InOp.getValueType()) == TargetLowering::TypeWidenVector)
@ -2299,7 +2299,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_BITCAST(SDNode *N) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
SDValue InOp = GetWidenedVector(N->getOperand(0)); SDValue InOp = GetWidenedVector(N->getOperand(0));
EVT InWidenVT = InOp.getValueType(); EVT InWidenVT = InOp.getValueType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
// Check if we can convert between two legal vector types and extract. // Check if we can convert between two legal vector types and extract.
unsigned InWidenSize = InWidenVT.getSizeInBits(); unsigned InWidenSize = InWidenVT.getSizeInBits();
@ -2324,7 +2324,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_CONCAT_VECTORS(SDNode *N) {
// nasty build vector. // nasty build vector.
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
EVT EltVT = VT.getVectorElementType(); EVT EltVT = VT.getVectorElementType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
unsigned NumElts = VT.getVectorNumElements(); unsigned NumElts = VT.getVectorNumElements();
SmallVector<SDValue, 16> Ops(NumElts); SmallVector<SDValue, 16> Ops(NumElts);
@ -2346,13 +2346,13 @@ SDValue DAGTypeLegalizer::WidenVecOp_CONCAT_VECTORS(SDNode *N) {
SDValue DAGTypeLegalizer::WidenVecOp_EXTRACT_SUBVECTOR(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecOp_EXTRACT_SUBVECTOR(SDNode *N) {
SDValue InOp = GetWidenedVector(N->getOperand(0)); SDValue InOp = GetWidenedVector(N->getOperand(0));
return DAG.getNode(ISD::EXTRACT_SUBVECTOR, N->getDebugLoc(), return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N),
N->getValueType(0), InOp, N->getOperand(1)); N->getValueType(0), InOp, N->getOperand(1));
} }
SDValue DAGTypeLegalizer::WidenVecOp_EXTRACT_VECTOR_ELT(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecOp_EXTRACT_VECTOR_ELT(SDNode *N) {
SDValue InOp = GetWidenedVector(N->getOperand(0)); SDValue InOp = GetWidenedVector(N->getOperand(0));
return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, N->getDebugLoc(), return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N),
N->getValueType(0), InOp, N->getOperand(1)); N->getValueType(0), InOp, N->getOperand(1));
} }
@ -2370,14 +2370,14 @@ SDValue DAGTypeLegalizer::WidenVecOp_STORE(SDNode *N) {
if (StChain.size() == 1) if (StChain.size() == 1)
return StChain[0]; return StChain[0];
else else
return DAG.getNode(ISD::TokenFactor, ST->getDebugLoc(), return DAG.getNode(ISD::TokenFactor, SDLoc(ST),
MVT::Other,&StChain[0],StChain.size()); MVT::Other,&StChain[0],StChain.size());
} }
SDValue DAGTypeLegalizer::WidenVecOp_SETCC(SDNode *N) { SDValue DAGTypeLegalizer::WidenVecOp_SETCC(SDNode *N) {
SDValue InOp0 = GetWidenedVector(N->getOperand(0)); SDValue InOp0 = GetWidenedVector(N->getOperand(0));
SDValue InOp1 = GetWidenedVector(N->getOperand(1)); SDValue InOp1 = GetWidenedVector(N->getOperand(1));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);;
// WARNING: In this code we widen the compare instruction with garbage. // WARNING: In this code we widen the compare instruction with garbage.
// This garbage may contain denormal floats which may be slow. Is this a real // This garbage may contain denormal floats which may be slow. Is this a real
@ -2386,7 +2386,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_SETCC(SDNode *N) {
// Get a new SETCC node to compare the newly widened operands. // Get a new SETCC node to compare the newly widened operands.
// Only some of the compared elements are legal. // Only some of the compared elements are legal.
EVT SVT = TLI.getSetCCResultType(*DAG.getContext(), InOp0.getValueType()); EVT SVT = TLI.getSetCCResultType(*DAG.getContext(), InOp0.getValueType());
SDValue WideSETCC = DAG.getNode(ISD::SETCC, N->getDebugLoc(), SDValue WideSETCC = DAG.getNode(ISD::SETCC, SDLoc(N),
SVT, InOp0, InOp1, N->getOperand(2)); SVT, InOp0, InOp1, N->getOperand(2));
// Extract the needed results from the result vector. // Extract the needed results from the result vector.
@ -2467,7 +2467,7 @@ static EVT FindMemType(SelectionDAG& DAG, const TargetLowering &TLI,
static SDValue BuildVectorFromScalar(SelectionDAG& DAG, EVT VecTy, static SDValue BuildVectorFromScalar(SelectionDAG& DAG, EVT VecTy,
SmallVector<SDValue, 16>& LdOps, SmallVector<SDValue, 16>& LdOps,
unsigned Start, unsigned End) { unsigned Start, unsigned End) {
DebugLoc dl = LdOps[Start].getDebugLoc(); SDLoc dl(LdOps[Start]);;
EVT LdTy = LdOps[Start].getValueType(); EVT LdTy = LdOps[Start].getValueType();
unsigned Width = VecTy.getSizeInBits(); unsigned Width = VecTy.getSizeInBits();
unsigned NumElts = Width / LdTy.getSizeInBits(); unsigned NumElts = Width / LdTy.getSizeInBits();
@ -2501,7 +2501,7 @@ SDValue DAGTypeLegalizer::GenWidenVectorLoads(SmallVector<SDValue, 16> &LdChain,
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),LD->getValueType(0)); EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),LD->getValueType(0));
unsigned WidenWidth = WidenVT.getSizeInBits(); unsigned WidenWidth = WidenVT.getSizeInBits();
EVT LdVT = LD->getMemoryVT(); EVT LdVT = LD->getMemoryVT();
DebugLoc dl = LD->getDebugLoc(); SDLoc dl(LD);;
assert(LdVT.isVector() && WidenVT.isVector()); assert(LdVT.isVector() && WidenVT.isVector());
assert(LdVT.getVectorElementType() == WidenVT.getVectorElementType()); assert(LdVT.getVectorElementType() == WidenVT.getVectorElementType());
@ -2653,7 +2653,7 @@ DAGTypeLegalizer::GenWidenVectorExtLoads(SmallVector<SDValue, 16>& LdChain,
// and then extended it. Instead, we unroll the load and build a new vector. // and then extended it. Instead, we unroll the load and build a new vector.
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),LD->getValueType(0)); EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),LD->getValueType(0));
EVT LdVT = LD->getMemoryVT(); EVT LdVT = LD->getMemoryVT();
DebugLoc dl = LD->getDebugLoc(); SDLoc dl(LD);;
assert(LdVT.isVector() && WidenVT.isVector()); assert(LdVT.isVector() && WidenVT.isVector());
// Load information // Load information
@ -2705,7 +2705,7 @@ void DAGTypeLegalizer::GenWidenVectorStores(SmallVector<SDValue, 16>& StChain,
bool isVolatile = ST->isVolatile(); bool isVolatile = ST->isVolatile();
bool isNonTemporal = ST->isNonTemporal(); bool isNonTemporal = ST->isNonTemporal();
SDValue ValOp = GetWidenedVector(ST->getValue()); SDValue ValOp = GetWidenedVector(ST->getValue());
DebugLoc dl = ST->getDebugLoc(); SDLoc dl(ST);;
EVT StVT = ST->getMemoryVT(); EVT StVT = ST->getMemoryVT();
unsigned StWidth = StVT.getSizeInBits(); unsigned StWidth = StVT.getSizeInBits();
@ -2773,7 +2773,7 @@ DAGTypeLegalizer::GenWidenVectorTruncStores(SmallVector<SDValue, 16>& StChain,
bool isVolatile = ST->isVolatile(); bool isVolatile = ST->isVolatile();
bool isNonTemporal = ST->isNonTemporal(); bool isNonTemporal = ST->isNonTemporal();
SDValue ValOp = GetWidenedVector(ST->getValue()); SDValue ValOp = GetWidenedVector(ST->getValue());
DebugLoc dl = ST->getDebugLoc(); SDLoc dl(ST);;
EVT StVT = ST->getMemoryVT(); EVT StVT = ST->getMemoryVT();
EVT ValVT = ValOp.getValueType(); EVT ValVT = ValOp.getValueType();
@ -2816,7 +2816,7 @@ SDValue DAGTypeLegalizer::ModifyToType(SDValue InOp, EVT NVT) {
EVT InVT = InOp.getValueType(); EVT InVT = InOp.getValueType();
assert(InVT.getVectorElementType() == NVT.getVectorElementType() && assert(InVT.getVectorElementType() == NVT.getVectorElementType() &&
"input and widen element type must match"); "input and widen element type must match");
DebugLoc dl = InOp.getDebugLoc(); SDLoc dl(InOp);;
// Check if InOp already has the right width. // Check if InOp already has the right width.
if (InVT == NVT) if (InVT == NVT)

267
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
View File

@ -874,7 +874,7 @@ unsigned SelectionDAG::getEVTAlignment(EVT VT) const {
// EntryNode could meaningfully have debug info if we can find it... // EntryNode could meaningfully have debug info if we can find it...
SelectionDAG::SelectionDAG(const TargetMachine &tm, CodeGenOpt::Level OL) SelectionDAG::SelectionDAG(const TargetMachine &tm, CodeGenOpt::Level OL)
: TM(tm), TLI(*tm.getTargetLowering()), TSI(*tm.getSelectionDAGInfo()), : TM(tm), TLI(*tm.getTargetLowering()), TSI(*tm.getSelectionDAGInfo()),
TTI(0), OptLevel(OL), EntryNode(ISD::EntryToken, DebugLoc(), TTI(0), OptLevel(OL), EntryNode(ISD::EntryToken, 0, DebugLoc(),
getVTList(MVT::Other)), getVTList(MVT::Other)),
Root(getEntryNode()), Ordering(0), UpdateListeners(0) { Root(getEntryNode()), Ordering(0), UpdateListeners(0) {
AllNodes.push_back(&EntryNode); AllNodes.push_back(&EntryNode);
@ -922,25 +922,25 @@ void SelectionDAG::clear() {
DbgInfo->clear(); DbgInfo->clear();
} }
SDValue SelectionDAG::getAnyExtOrTrunc(SDValue Op, DebugLoc DL, EVT VT) { SDValue SelectionDAG::getAnyExtOrTrunc(SDValue Op, SDLoc DL, EVT VT) {
return VT.bitsGT(Op.getValueType()) ? return VT.bitsGT(Op.getValueType()) ?
getNode(ISD::ANY_EXTEND, DL, VT, Op) : getNode(ISD::ANY_EXTEND, DL, VT, Op) :
getNode(ISD::TRUNCATE, DL, VT, Op); getNode(ISD::TRUNCATE, DL, VT, Op);
} }
SDValue SelectionDAG::getSExtOrTrunc(SDValue Op, DebugLoc DL, EVT VT) { SDValue SelectionDAG::getSExtOrTrunc(SDValue Op, SDLoc DL, EVT VT) {
return VT.bitsGT(Op.getValueType()) ? return VT.bitsGT(Op.getValueType()) ?
getNode(ISD::SIGN_EXTEND, DL, VT, Op) : getNode(ISD::SIGN_EXTEND, DL, VT, Op) :
getNode(ISD::TRUNCATE, DL, VT, Op); getNode(ISD::TRUNCATE, DL, VT, Op);
} }
SDValue SelectionDAG::getZExtOrTrunc(SDValue Op, DebugLoc DL, EVT VT) { SDValue SelectionDAG::getZExtOrTrunc(SDValue Op, SDLoc DL, EVT VT) {
return VT.bitsGT(Op.getValueType()) ? return VT.bitsGT(Op.getValueType()) ?
getNode(ISD::ZERO_EXTEND, DL, VT, Op) : getNode(ISD::ZERO_EXTEND, DL, VT, Op) :
getNode(ISD::TRUNCATE, DL, VT, Op); getNode(ISD::TRUNCATE, DL, VT, Op);
} }
SDValue SelectionDAG::getZeroExtendInReg(SDValue Op, DebugLoc DL, EVT VT) { SDValue SelectionDAG::getZeroExtendInReg(SDValue Op, SDLoc DL, EVT VT) {
assert(!VT.isVector() && assert(!VT.isVector() &&
"getZeroExtendInReg should use the vector element type instead of " "getZeroExtendInReg should use the vector element type instead of "
"the vector type!"); "the vector type!");
@ -954,7 +954,7 @@ SDValue SelectionDAG::getZeroExtendInReg(SDValue Op, DebugLoc DL, EVT VT) {
/// getNOT - Create a bitwise NOT operation as (XOR Val, -1). /// getNOT - Create a bitwise NOT operation as (XOR Val, -1).
/// ///
SDValue SelectionDAG::getNOT(DebugLoc DL, SDValue Val, EVT VT) { SDValue SelectionDAG::getNOT(SDLoc DL, SDValue Val, EVT VT) {
EVT EltVT = VT.getScalarType(); EVT EltVT = VT.getScalarType();
SDValue NegOne = SDValue NegOne =
getConstant(APInt::getAllOnesValue(EltVT.getSizeInBits()), VT); getConstant(APInt::getAllOnesValue(EltVT.getSizeInBits()), VT);
@ -1012,7 +1012,7 @@ SDValue SelectionDAG::getConstant(const ConstantInt &Val, EVT VT, bool isT) {
if (VT.isVector()) { if (VT.isVector()) {
SmallVector<SDValue, 8> Ops; SmallVector<SDValue, 8> Ops;
Ops.assign(VT.getVectorNumElements(), Result); Ops.assign(VT.getVectorNumElements(), Result);
Result = getNode(ISD::BUILD_VECTOR, DebugLoc(), VT, &Ops[0], Ops.size()); Result = getNode(ISD::BUILD_VECTOR, SDLoc(), VT, &Ops[0], Ops.size());
} }
return Result; return Result;
} }
@ -1054,8 +1054,8 @@ SDValue SelectionDAG::getConstantFP(const ConstantFP& V, EVT VT, bool isTarget){
if (VT.isVector()) { if (VT.isVector()) {
SmallVector<SDValue, 8> Ops; SmallVector<SDValue, 8> Ops;
Ops.assign(VT.getVectorNumElements(), Result); Ops.assign(VT.getVectorNumElements(), Result);
// FIXME DebugLoc info might be appropriate here // FIXME SDLoc info might be appropriate here
Result = getNode(ISD::BUILD_VECTOR, DebugLoc(), VT, &Ops[0], Ops.size()); Result = getNode(ISD::BUILD_VECTOR, SDLoc(), VT, &Ops[0], Ops.size());
} }
return Result; return Result;
} }
@ -1077,7 +1077,7 @@ SDValue SelectionDAG::getConstantFP(double Val, EVT VT, bool isTarget) {
llvm_unreachable("Unsupported type in getConstantFP"); llvm_unreachable("Unsupported type in getConstantFP");
} }
SDValue SelectionDAG::getGlobalAddress(const GlobalValue *GV, DebugLoc DL, SDValue SelectionDAG::getGlobalAddress(const GlobalValue *GV, SDLoc DL,
EVT VT, int64_t Offset, EVT VT, int64_t Offset,
bool isTargetGA, bool isTargetGA,
unsigned char TargetFlags) { unsigned char TargetFlags) {
@ -1112,7 +1112,8 @@ SDValue SelectionDAG::getGlobalAddress(const GlobalValue *GV, DebugLoc DL,
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0); return SDValue(E, 0);
SDNode *N = new (NodeAllocator) GlobalAddressSDNode(Opc, DL, GV, VT, SDNode *N = new (NodeAllocator) GlobalAddressSDNode(Opc, DL.getIROrder(),
DL.getDebugLoc(), GV, VT,
Offset, TargetFlags); Offset, TargetFlags);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
AllNodes.push_back(N); AllNodes.push_back(N);
@ -1299,7 +1300,7 @@ static void commuteShuffle(SDValue &N1, SDValue &N2, SmallVectorImpl<int> &M) {
} }
} }
SDValue SelectionDAG::getVectorShuffle(EVT VT, DebugLoc dl, SDValue N1, SDValue SelectionDAG::getVectorShuffle(EVT VT, SDLoc dl, SDValue N1,
SDValue N2, const int *Mask) { SDValue N2, const int *Mask) {
assert(N1.getValueType() == N2.getValueType() && "Invalid VECTOR_SHUFFLE"); assert(N1.getValueType() == N2.getValueType() && "Invalid VECTOR_SHUFFLE");
assert(VT.isVector() && N1.getValueType().isVector() && assert(VT.isVector() && N1.getValueType().isVector() &&
@ -1383,13 +1384,13 @@ SDValue SelectionDAG::getVectorShuffle(EVT VT, DebugLoc dl, SDValue N1,
memcpy(MaskAlloc, &MaskVec[0], NElts * sizeof(int)); memcpy(MaskAlloc, &MaskVec[0], NElts * sizeof(int));
ShuffleVectorSDNode *N = ShuffleVectorSDNode *N =
new (NodeAllocator) ShuffleVectorSDNode(VT, dl, N1, N2, MaskAlloc); new (NodeAllocator) ShuffleVectorSDNode(VT, dl.getIROrder(), dl.getDebugLoc(), N1, N2, MaskAlloc);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
AllNodes.push_back(N); AllNodes.push_back(N);
return SDValue(N, 0); return SDValue(N, 0);
} }
SDValue SelectionDAG::getConvertRndSat(EVT VT, DebugLoc dl, SDValue SelectionDAG::getConvertRndSat(EVT VT, SDLoc dl,
SDValue Val, SDValue DTy, SDValue Val, SDValue DTy,
SDValue STy, SDValue Rnd, SDValue Sat, SDValue STy, SDValue Rnd, SDValue Sat,
ISD::CvtCode Code) { ISD::CvtCode Code) {
@ -1406,7 +1407,7 @@ SDValue SelectionDAG::getConvertRndSat(EVT VT, DebugLoc dl,
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0); return SDValue(E, 0);
CvtRndSatSDNode *N = new (NodeAllocator) CvtRndSatSDNode(VT, dl, Ops, 5, CvtRndSatSDNode *N = new (NodeAllocator) CvtRndSatSDNode(VT, dl.getIROrder(), dl.getDebugLoc(), Ops, 5,
Code); Code);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
AllNodes.push_back(N); AllNodes.push_back(N);
@ -1441,7 +1442,7 @@ SDValue SelectionDAG::getRegisterMask(const uint32_t *RegMask) {
return SDValue(N, 0); return SDValue(N, 0);
} }
SDValue SelectionDAG::getEHLabel(DebugLoc dl, SDValue Root, MCSymbol *Label) { SDValue SelectionDAG::getEHLabel(SDLoc dl, SDValue Root, MCSymbol *Label) {
FoldingSetNodeID ID; FoldingSetNodeID ID;
SDValue Ops[] = { Root }; SDValue Ops[] = { Root };
AddNodeIDNode(ID, ISD::EH_LABEL, getVTList(MVT::Other), &Ops[0], 1); AddNodeIDNode(ID, ISD::EH_LABEL, getVTList(MVT::Other), &Ops[0], 1);
@ -1450,7 +1451,7 @@ SDValue SelectionDAG::getEHLabel(DebugLoc dl, SDValue Root, MCSymbol *Label) {
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0); return SDValue(E, 0);
SDNode *N = new (NodeAllocator) EHLabelSDNode(dl, Root, Label); SDNode *N = new (NodeAllocator) EHLabelSDNode(dl.getIROrder(), dl.getDebugLoc(), Root, Label);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
AllNodes.push_back(N); AllNodes.push_back(N);
return SDValue(N, 0); return SDValue(N, 0);
@ -1522,7 +1523,7 @@ SDValue SelectionDAG::getShiftAmountOperand(EVT LHSTy, SDValue Op) {
if (OpTy == ShTy || OpTy.isVector()) return Op; if (OpTy == ShTy || OpTy.isVector()) return Op;
ISD::NodeType Opcode = OpTy.bitsGT(ShTy) ? ISD::TRUNCATE : ISD::ZERO_EXTEND; ISD::NodeType Opcode = OpTy.bitsGT(ShTy) ? ISD::TRUNCATE : ISD::ZERO_EXTEND;
return getNode(Opcode, Op.getDebugLoc(), ShTy, Op); return getNode(Opcode, SDLoc(Op), ShTy, Op);
} }
/// CreateStackTemporary - Create a stack temporary, suitable for holding the /// CreateStackTemporary - Create a stack temporary, suitable for holding the
@ -1555,7 +1556,7 @@ SDValue SelectionDAG::CreateStackTemporary(EVT VT1, EVT VT2) {
} }
SDValue SelectionDAG::FoldSetCC(EVT VT, SDValue N1, SDValue SelectionDAG::FoldSetCC(EVT VT, SDValue N1,
SDValue N2, ISD::CondCode Cond, DebugLoc dl) { SDValue N2, ISD::CondCode Cond, SDLoc dl) {
// These setcc operations always fold. // These setcc operations always fold.
switch (Cond) { switch (Cond) {
default: break; default: break;
@ -2403,14 +2404,14 @@ bool SelectionDAG::isEqualTo(SDValue A, SDValue B) const {
/// getNode - Gets or creates the specified node. /// getNode - Gets or creates the specified node.
/// ///
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT) { SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT) {
FoldingSetNodeID ID; FoldingSetNodeID ID;
AddNodeIDNode(ID, Opcode, getVTList(VT), 0, 0); AddNodeIDNode(ID, Opcode, getVTList(VT), 0, 0);
void *IP = 0; void *IP = 0;
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0); return SDValue(E, 0);
SDNode *N = new (NodeAllocator) SDNode(Opcode, DL, getVTList(VT)); SDNode *N = new (NodeAllocator) SDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), getVTList(VT));
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
AllNodes.push_back(N); AllNodes.push_back(N);
@ -2420,7 +2421,7 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT) {
return SDValue(N, 0); return SDValue(N, 0);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL,
EVT VT, SDValue Operand) { EVT VT, SDValue Operand) {
// Constant fold unary operations with an integer constant operand. // Constant fold unary operations with an integer constant operand.
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Operand.getNode())) { if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Operand.getNode())) {
@ -2671,10 +2672,10 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL,
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0); return SDValue(E, 0);
N = new (NodeAllocator) UnarySDNode(Opcode, DL, VTs, Operand); N = new (NodeAllocator) UnarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTs, Operand);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
} else { } else {
N = new (NodeAllocator) UnarySDNode(Opcode, DL, VTs, Operand); N = new (NodeAllocator) UnarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTs, Operand);
} }
AllNodes.push_back(N); AllNodes.push_back(N);
@ -2789,11 +2790,11 @@ SDValue SelectionDAG::FoldConstantArithmetic(unsigned Opcode, EVT VT,
return Outputs.back(); return Outputs.back();
// Otherwise build a big vector out of the scalar elements we generated. // Otherwise build a big vector out of the scalar elements we generated.
return getNode(ISD::BUILD_VECTOR, DebugLoc(), VT, Outputs.data(), return getNode(ISD::BUILD_VECTOR, SDLoc(), VT, Outputs.data(),
Outputs.size()); Outputs.size());
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue N1, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT, SDValue N1,
SDValue N2) { SDValue N2) {
ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode()); ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.getNode()); ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.getNode());
@ -3243,10 +3244,10 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue N1,
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0); return SDValue(E, 0);
N = new (NodeAllocator) BinarySDNode(Opcode, DL, VTs, N1, N2); N = new (NodeAllocator) BinarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTs, N1, N2);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
} else { } else {
N = new (NodeAllocator) BinarySDNode(Opcode, DL, VTs, N1, N2); N = new (NodeAllocator) BinarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTs, N1, N2);
} }
AllNodes.push_back(N); AllNodes.push_back(N);
@ -3256,7 +3257,7 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue N1,
return SDValue(N, 0); return SDValue(N, 0);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT,
SDValue N1, SDValue N2, SDValue N3) { SDValue N1, SDValue N2, SDValue N3) {
// Perform various simplifications. // Perform various simplifications.
ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode()); ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
@ -3348,10 +3349,10 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT,
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0); return SDValue(E, 0);
N = new (NodeAllocator) TernarySDNode(Opcode, DL, VTs, N1, N2, N3); N = new (NodeAllocator) TernarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTs, N1, N2, N3);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
} else { } else {
N = new (NodeAllocator) TernarySDNode(Opcode, DL, VTs, N1, N2, N3); N = new (NodeAllocator) TernarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTs, N1, N2, N3);
} }
AllNodes.push_back(N); AllNodes.push_back(N);
@ -3361,14 +3362,14 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT,
return SDValue(N, 0); return SDValue(N, 0);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT,
SDValue N1, SDValue N2, SDValue N3, SDValue N1, SDValue N2, SDValue N3,
SDValue N4) { SDValue N4) {
SDValue Ops[] = { N1, N2, N3, N4 }; SDValue Ops[] = { N1, N2, N3, N4 };
return getNode(Opcode, DL, VT, Ops, 4); return getNode(Opcode, DL, VT, Ops, 4);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT,
SDValue N1, SDValue N2, SDValue N3, SDValue N1, SDValue N2, SDValue N3,
SDValue N4, SDValue N5) { SDValue N4, SDValue N5) {
SDValue Ops[] = { N1, N2, N3, N4, N5 }; SDValue Ops[] = { N1, N2, N3, N4, N5 };
@ -3394,14 +3395,14 @@ SDValue SelectionDAG::getStackArgumentTokenFactor(SDValue Chain) {
ArgChains.push_back(SDValue(L, 1)); ArgChains.push_back(SDValue(L, 1));
// Build a tokenfactor for all the chains. // Build a tokenfactor for all the chains.
return getNode(ISD::TokenFactor, Chain.getDebugLoc(), MVT::Other, return getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other,
&ArgChains[0], ArgChains.size()); &ArgChains[0], ArgChains.size());
} }
/// getMemsetValue - Vectorized representation of the memset value /// getMemsetValue - Vectorized representation of the memset value
/// operand. /// operand.
static SDValue getMemsetValue(SDValue Value, EVT VT, SelectionDAG &DAG, static SDValue getMemsetValue(SDValue Value, EVT VT, SelectionDAG &DAG,
DebugLoc dl) { SDLoc dl) {
assert(Value.getOpcode() != ISD::UNDEF); assert(Value.getOpcode() != ISD::UNDEF);
unsigned NumBits = VT.getScalarType().getSizeInBits(); unsigned NumBits = VT.getScalarType().getSizeInBits();
@ -3427,7 +3428,7 @@ static SDValue getMemsetValue(SDValue Value, EVT VT, SelectionDAG &DAG,
/// getMemsetStringVal - Similar to getMemsetValue. Except this is only /// getMemsetStringVal - Similar to getMemsetValue. Except this is only
/// used when a memcpy is turned into a memset when the source is a constant /// used when a memcpy is turned into a memset when the source is a constant
/// string ptr. /// string ptr.
static SDValue getMemsetStringVal(EVT VT, DebugLoc dl, SelectionDAG &DAG, static SDValue getMemsetStringVal(EVT VT, SDLoc dl, SelectionDAG &DAG,
const TargetLowering &TLI, StringRef Str) { const TargetLowering &TLI, StringRef Str) {
// Handle vector with all elements zero. // Handle vector with all elements zero.
if (Str.empty()) { if (Str.empty()) {
@ -3472,7 +3473,7 @@ static SDValue getMemsetStringVal(EVT VT, DebugLoc dl, SelectionDAG &DAG,
static SDValue getMemBasePlusOffset(SDValue Base, unsigned Offset, static SDValue getMemBasePlusOffset(SDValue Base, unsigned Offset,
SelectionDAG &DAG) { SelectionDAG &DAG) {
EVT VT = Base.getValueType(); EVT VT = Base.getValueType();
return DAG.getNode(ISD::ADD, Base.getDebugLoc(), return DAG.getNode(ISD::ADD, SDLoc(Base),
VT, Base, DAG.getConstant(Offset, VT)); VT, Base, DAG.getConstant(Offset, VT));
} }
@ -3600,7 +3601,7 @@ static bool FindOptimalMemOpLowering(std::vector<EVT> &MemOps,
return true; return true;
} }
static SDValue getMemcpyLoadsAndStores(SelectionDAG &DAG, DebugLoc dl, static SDValue getMemcpyLoadsAndStores(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Dst, SDValue Chain, SDValue Dst,
SDValue Src, uint64_t Size, SDValue Src, uint64_t Size,
unsigned Align, bool isVol, unsigned Align, bool isVol,
@ -3718,7 +3719,7 @@ static SDValue getMemcpyLoadsAndStores(SelectionDAG &DAG, DebugLoc dl,
&OutChains[0], OutChains.size()); &OutChains[0], OutChains.size());
} }
static SDValue getMemmoveLoadsAndStores(SelectionDAG &DAG, DebugLoc dl, static SDValue getMemmoveLoadsAndStores(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Dst, SDValue Chain, SDValue Dst,
SDValue Src, uint64_t Size, SDValue Src, uint64_t Size,
unsigned Align, bool isVol, unsigned Align, bool isVol,
@ -3799,7 +3800,7 @@ static SDValue getMemmoveLoadsAndStores(SelectionDAG &DAG, DebugLoc dl,
&OutChains[0], OutChains.size()); &OutChains[0], OutChains.size());
} }
static SDValue getMemsetStores(SelectionDAG &DAG, DebugLoc dl, static SDValue getMemsetStores(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Dst, SDValue Chain, SDValue Dst,
SDValue Src, uint64_t Size, SDValue Src, uint64_t Size,
unsigned Align, bool isVol, unsigned Align, bool isVol,
@ -3883,7 +3884,7 @@ static SDValue getMemsetStores(SelectionDAG &DAG, DebugLoc dl,
&OutChains[0], OutChains.size()); &OutChains[0], OutChains.size());
} }
SDValue SelectionDAG::getMemcpy(SDValue Chain, DebugLoc dl, SDValue Dst, SDValue SelectionDAG::getMemcpy(SDValue Chain, SDLoc dl, SDValue Dst,
SDValue Src, SDValue Size, SDValue Src, SDValue Size,
unsigned Align, bool isVol, bool AlwaysInline, unsigned Align, bool isVol, bool AlwaysInline,
MachinePointerInfo DstPtrInfo, MachinePointerInfo DstPtrInfo,
@ -3936,7 +3937,7 @@ SDValue SelectionDAG::getMemcpy(SDValue Chain, DebugLoc dl, SDValue Dst,
Entry.Node = Dst; Args.push_back(Entry); Entry.Node = Dst; Args.push_back(Entry);
Entry.Node = Src; Args.push_back(Entry); Entry.Node = Src; Args.push_back(Entry);
Entry.Node = Size; Args.push_back(Entry); Entry.Node = Size; Args.push_back(Entry);
// FIXME: pass in DebugLoc // FIXME: pass in SDLoc
TargetLowering:: TargetLowering::
CallLoweringInfo CLI(Chain, Type::getVoidTy(*getContext()), CallLoweringInfo CLI(Chain, Type::getVoidTy(*getContext()),
false, false, false, false, 0, false, false, false, false, 0,
@ -3951,7 +3952,7 @@ SDValue SelectionDAG::getMemcpy(SDValue Chain, DebugLoc dl, SDValue Dst,
return CallResult.second; return CallResult.second;
} }
SDValue SelectionDAG::getMemmove(SDValue Chain, DebugLoc dl, SDValue Dst, SDValue SelectionDAG::getMemmove(SDValue Chain, SDLoc dl, SDValue Dst,
SDValue Src, SDValue Size, SDValue Src, SDValue Size,
unsigned Align, bool isVol, unsigned Align, bool isVol,
MachinePointerInfo DstPtrInfo, MachinePointerInfo DstPtrInfo,
@ -3992,7 +3993,7 @@ SDValue SelectionDAG::getMemmove(SDValue Chain, DebugLoc dl, SDValue Dst,
Entry.Node = Dst; Args.push_back(Entry); Entry.Node = Dst; Args.push_back(Entry);
Entry.Node = Src; Args.push_back(Entry); Entry.Node = Src; Args.push_back(Entry);
Entry.Node = Size; Args.push_back(Entry); Entry.Node = Size; Args.push_back(Entry);
// FIXME: pass in DebugLoc // FIXME: pass in SDLoc
TargetLowering:: TargetLowering::
CallLoweringInfo CLI(Chain, Type::getVoidTy(*getContext()), CallLoweringInfo CLI(Chain, Type::getVoidTy(*getContext()),
false, false, false, false, 0, false, false, false, false, 0,
@ -4007,7 +4008,7 @@ SDValue SelectionDAG::getMemmove(SDValue Chain, DebugLoc dl, SDValue Dst,
return CallResult.second; return CallResult.second;
} }
SDValue SelectionDAG::getMemset(SDValue Chain, DebugLoc dl, SDValue Dst, SDValue SelectionDAG::getMemset(SDValue Chain, SDLoc dl, SDValue Dst,
SDValue Src, SDValue Size, SDValue Src, SDValue Size,
unsigned Align, bool isVol, unsigned Align, bool isVol,
MachinePointerInfo DstPtrInfo) { MachinePointerInfo DstPtrInfo) {
@ -4056,7 +4057,7 @@ SDValue SelectionDAG::getMemset(SDValue Chain, DebugLoc dl, SDValue Dst,
Entry.Ty = IntPtrTy; Entry.Ty = IntPtrTy;
Entry.isSExt = false; Entry.isSExt = false;
Args.push_back(Entry); Args.push_back(Entry);
// FIXME: pass in DebugLoc // FIXME: pass in SDLoc
TargetLowering:: TargetLowering::
CallLoweringInfo CLI(Chain, Type::getVoidTy(*getContext()), CallLoweringInfo CLI(Chain, Type::getVoidTy(*getContext()),
false, false, false, false, 0, false, false, false, false, 0,
@ -4071,7 +4072,7 @@ SDValue SelectionDAG::getMemset(SDValue Chain, DebugLoc dl, SDValue Dst,
return CallResult.second; return CallResult.second;
} }
SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
SDValue Chain, SDValue Ptr, SDValue Cmp, SDValue Chain, SDValue Ptr, SDValue Cmp,
SDValue Swp, MachinePointerInfo PtrInfo, SDValue Swp, MachinePointerInfo PtrInfo,
unsigned Alignment, unsigned Alignment,
@ -4099,7 +4100,7 @@ SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT,
Ordering, SynchScope); Ordering, SynchScope);
} }
SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
SDValue Chain, SDValue Chain,
SDValue Ptr, SDValue Cmp, SDValue Ptr, SDValue Cmp,
SDValue Swp, MachineMemOperand *MMO, SDValue Swp, MachineMemOperand *MMO,
@ -4121,7 +4122,7 @@ SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT,
cast<AtomicSDNode>(E)->refineAlignment(MMO); cast<AtomicSDNode>(E)->refineAlignment(MMO);
return SDValue(E, 0); return SDValue(E, 0);
} }
SDNode *N = new (NodeAllocator) AtomicSDNode(Opcode, dl, VTs, MemVT, Chain, SDNode *N = new (NodeAllocator) AtomicSDNode(Opcode, dl.getIROrder(), dl.getDebugLoc(), VTs, MemVT, Chain,
Ptr, Cmp, Swp, MMO, Ordering, Ptr, Cmp, Swp, MMO, Ordering,
SynchScope); SynchScope);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
@ -4129,7 +4130,7 @@ SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT,
return SDValue(N, 0); return SDValue(N, 0);
} }
SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
SDValue Chain, SDValue Chain,
SDValue Ptr, SDValue Val, SDValue Ptr, SDValue Val,
const Value* PtrVal, const Value* PtrVal,
@ -4160,7 +4161,7 @@ SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT,
Ordering, SynchScope); Ordering, SynchScope);
} }
SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
SDValue Chain, SDValue Chain,
SDValue Ptr, SDValue Val, SDValue Ptr, SDValue Val,
MachineMemOperand *MMO, MachineMemOperand *MMO,
@ -4194,7 +4195,7 @@ SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT,
cast<AtomicSDNode>(E)->refineAlignment(MMO); cast<AtomicSDNode>(E)->refineAlignment(MMO);
return SDValue(E, 0); return SDValue(E, 0);
} }
SDNode *N = new (NodeAllocator) AtomicSDNode(Opcode, dl, VTs, MemVT, Chain, SDNode *N = new (NodeAllocator) AtomicSDNode(Opcode, dl.getIROrder(), dl.getDebugLoc(), VTs, MemVT, Chain,
Ptr, Val, MMO, Ptr, Val, MMO,
Ordering, SynchScope); Ordering, SynchScope);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
@ -4202,7 +4203,7 @@ SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT,
return SDValue(N, 0); return SDValue(N, 0);
} }
SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
EVT VT, SDValue Chain, EVT VT, SDValue Chain,
SDValue Ptr, SDValue Ptr,
const Value* PtrVal, const Value* PtrVal,
@ -4233,7 +4234,7 @@ SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT,
Ordering, SynchScope); Ordering, SynchScope);
} }
SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT, SDValue SelectionDAG::getAtomic(unsigned Opcode, SDLoc dl, EVT MemVT,
EVT VT, SDValue Chain, EVT VT, SDValue Chain,
SDValue Ptr, SDValue Ptr,
MachineMemOperand *MMO, MachineMemOperand *MMO,
@ -4252,7 +4253,7 @@ SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT,
cast<AtomicSDNode>(E)->refineAlignment(MMO); cast<AtomicSDNode>(E)->refineAlignment(MMO);
return SDValue(E, 0); return SDValue(E, 0);
} }
SDNode *N = new (NodeAllocator) AtomicSDNode(Opcode, dl, VTs, MemVT, Chain, SDNode *N = new (NodeAllocator) AtomicSDNode(Opcode, dl.getIROrder(), dl.getDebugLoc(), VTs, MemVT, Chain,
Ptr, MMO, Ordering, SynchScope); Ptr, MMO, Ordering, SynchScope);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
AllNodes.push_back(N); AllNodes.push_back(N);
@ -4261,7 +4262,7 @@ SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, EVT MemVT,
/// getMergeValues - Create a MERGE_VALUES node from the given operands. /// getMergeValues - Create a MERGE_VALUES node from the given operands.
SDValue SelectionDAG::getMergeValues(const SDValue *Ops, unsigned NumOps, SDValue SelectionDAG::getMergeValues(const SDValue *Ops, unsigned NumOps,
DebugLoc dl) { SDLoc dl) {
if (NumOps == 1) if (NumOps == 1)
return Ops[0]; return Ops[0];
@ -4274,7 +4275,7 @@ SDValue SelectionDAG::getMergeValues(const SDValue *Ops, unsigned NumOps,
} }
SDValue SDValue
SelectionDAG::getMemIntrinsicNode(unsigned Opcode, DebugLoc dl, SelectionDAG::getMemIntrinsicNode(unsigned Opcode, SDLoc dl,
const EVT *VTs, unsigned NumVTs, const EVT *VTs, unsigned NumVTs,
const SDValue *Ops, unsigned NumOps, const SDValue *Ops, unsigned NumOps,
EVT MemVT, MachinePointerInfo PtrInfo, EVT MemVT, MachinePointerInfo PtrInfo,
@ -4286,7 +4287,7 @@ SelectionDAG::getMemIntrinsicNode(unsigned Opcode, DebugLoc dl,
} }
SDValue SDValue
SelectionDAG::getMemIntrinsicNode(unsigned Opcode, DebugLoc dl, SDVTList VTList, SelectionDAG::getMemIntrinsicNode(unsigned Opcode, SDLoc dl, SDVTList VTList,
const SDValue *Ops, unsigned NumOps, const SDValue *Ops, unsigned NumOps,
EVT MemVT, MachinePointerInfo PtrInfo, EVT MemVT, MachinePointerInfo PtrInfo,
unsigned Align, bool Vol, unsigned Align, bool Vol,
@ -4309,7 +4310,7 @@ SelectionDAG::getMemIntrinsicNode(unsigned Opcode, DebugLoc dl, SDVTList VTList,
} }
SDValue SDValue
SelectionDAG::getMemIntrinsicNode(unsigned Opcode, DebugLoc dl, SDVTList VTList, SelectionDAG::getMemIntrinsicNode(unsigned Opcode, SDLoc dl, SDVTList VTList,
const SDValue *Ops, unsigned NumOps, const SDValue *Ops, unsigned NumOps,
EVT MemVT, MachineMemOperand *MMO) { EVT MemVT, MachineMemOperand *MMO) {
assert((Opcode == ISD::INTRINSIC_VOID || assert((Opcode == ISD::INTRINSIC_VOID ||
@ -4333,11 +4334,11 @@ SelectionDAG::getMemIntrinsicNode(unsigned Opcode, DebugLoc dl, SDVTList VTList,
return SDValue(E, 0); return SDValue(E, 0);
} }
N = new (NodeAllocator) MemIntrinsicSDNode(Opcode, dl, VTList, Ops, NumOps, N = new (NodeAllocator) MemIntrinsicSDNode(Opcode, dl.getIROrder(), dl.getDebugLoc(), VTList, Ops, NumOps,
MemVT, MMO); MemVT, MMO);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
} else { } else {
N = new (NodeAllocator) MemIntrinsicSDNode(Opcode, dl, VTList, Ops, NumOps, N = new (NodeAllocator) MemIntrinsicSDNode(Opcode, dl.getIROrder(), dl.getDebugLoc(), VTList, Ops, NumOps,
MemVT, MMO); MemVT, MMO);
} }
AllNodes.push_back(N); AllNodes.push_back(N);
@ -4380,7 +4381,7 @@ static MachinePointerInfo InferPointerInfo(SDValue Ptr, SDValue OffsetOp) {
SDValue SDValue
SelectionDAG::getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, SelectionDAG::getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType,
EVT VT, DebugLoc dl, SDValue Chain, EVT VT, SDLoc dl, SDValue Chain,
SDValue Ptr, SDValue Offset, SDValue Ptr, SDValue Offset,
MachinePointerInfo PtrInfo, EVT MemVT, MachinePointerInfo PtrInfo, EVT MemVT,
bool isVolatile, bool isNonTemporal, bool isInvariant, bool isVolatile, bool isNonTemporal, bool isInvariant,
@ -4413,7 +4414,7 @@ SelectionDAG::getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType,
SDValue SDValue
SelectionDAG::getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, SelectionDAG::getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType,
EVT VT, DebugLoc dl, SDValue Chain, EVT VT, SDLoc dl, SDValue Chain,
SDValue Ptr, SDValue Offset, EVT MemVT, SDValue Ptr, SDValue Offset, EVT MemVT,
MachineMemOperand *MMO) { MachineMemOperand *MMO) {
if (VT == MemVT) { if (VT == MemVT) {
@ -4452,14 +4453,14 @@ SelectionDAG::getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType,
cast<LoadSDNode>(E)->refineAlignment(MMO); cast<LoadSDNode>(E)->refineAlignment(MMO);
return SDValue(E, 0); return SDValue(E, 0);
} }
SDNode *N = new (NodeAllocator) LoadSDNode(Ops, dl, VTs, AM, ExtType, SDNode *N = new (NodeAllocator) LoadSDNode(Ops, dl.getIROrder(), dl.getDebugLoc(), VTs, AM, ExtType,
MemVT, MMO); MemVT, MMO);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
AllNodes.push_back(N); AllNodes.push_back(N);
return SDValue(N, 0); return SDValue(N, 0);
} }
SDValue SelectionDAG::getLoad(EVT VT, DebugLoc dl, SDValue SelectionDAG::getLoad(EVT VT, SDLoc dl,
SDValue Chain, SDValue Ptr, SDValue Chain, SDValue Ptr,
MachinePointerInfo PtrInfo, MachinePointerInfo PtrInfo,
bool isVolatile, bool isNonTemporal, bool isVolatile, bool isNonTemporal,
@ -4472,7 +4473,7 @@ SDValue SelectionDAG::getLoad(EVT VT, DebugLoc dl,
TBAAInfo, Ranges); TBAAInfo, Ranges);
} }
SDValue SelectionDAG::getExtLoad(ISD::LoadExtType ExtType, DebugLoc dl, EVT VT, SDValue SelectionDAG::getExtLoad(ISD::LoadExtType ExtType, SDLoc dl, EVT VT,
SDValue Chain, SDValue Ptr, SDValue Chain, SDValue Ptr,
MachinePointerInfo PtrInfo, EVT MemVT, MachinePointerInfo PtrInfo, EVT MemVT,
bool isVolatile, bool isNonTemporal, bool isVolatile, bool isNonTemporal,
@ -4485,7 +4486,7 @@ SDValue SelectionDAG::getExtLoad(ISD::LoadExtType ExtType, DebugLoc dl, EVT VT,
SDValue SDValue
SelectionDAG::getIndexedLoad(SDValue OrigLoad, DebugLoc dl, SDValue Base, SelectionDAG::getIndexedLoad(SDValue OrigLoad, SDLoc dl, SDValue Base,
SDValue Offset, ISD::MemIndexedMode AM) { SDValue Offset, ISD::MemIndexedMode AM) {
LoadSDNode *LD = cast<LoadSDNode>(OrigLoad); LoadSDNode *LD = cast<LoadSDNode>(OrigLoad);
assert(LD->getOffset().getOpcode() == ISD::UNDEF && assert(LD->getOffset().getOpcode() == ISD::UNDEF &&
@ -4496,7 +4497,7 @@ SelectionDAG::getIndexedLoad(SDValue OrigLoad, DebugLoc dl, SDValue Base,
false, LD->getAlignment()); false, LD->getAlignment());
} }
SDValue SelectionDAG::getStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue SelectionDAG::getStore(SDValue Chain, SDLoc dl, SDValue Val,
SDValue Ptr, MachinePointerInfo PtrInfo, SDValue Ptr, MachinePointerInfo PtrInfo,
bool isVolatile, bool isNonTemporal, bool isVolatile, bool isNonTemporal,
unsigned Alignment, const MDNode *TBAAInfo) { unsigned Alignment, const MDNode *TBAAInfo) {
@ -4523,7 +4524,7 @@ SDValue SelectionDAG::getStore(SDValue Chain, DebugLoc dl, SDValue Val,
return getStore(Chain, dl, Val, Ptr, MMO); return getStore(Chain, dl, Val, Ptr, MMO);
} }
SDValue SelectionDAG::getStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue SelectionDAG::getStore(SDValue Chain, SDLoc dl, SDValue Val,
SDValue Ptr, MachineMemOperand *MMO) { SDValue Ptr, MachineMemOperand *MMO) {
assert(Chain.getValueType() == MVT::Other && assert(Chain.getValueType() == MVT::Other &&
"Invalid chain type"); "Invalid chain type");
@ -4542,14 +4543,14 @@ SDValue SelectionDAG::getStore(SDValue Chain, DebugLoc dl, SDValue Val,
cast<StoreSDNode>(E)->refineAlignment(MMO); cast<StoreSDNode>(E)->refineAlignment(MMO);
return SDValue(E, 0); return SDValue(E, 0);
} }
SDNode *N = new (NodeAllocator) StoreSDNode(Ops, dl, VTs, ISD::UNINDEXED, SDNode *N = new (NodeAllocator) StoreSDNode(Ops, dl.getIROrder(), dl.getDebugLoc(), VTs, ISD::UNINDEXED,
false, VT, MMO); false, VT, MMO);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
AllNodes.push_back(N); AllNodes.push_back(N);
return SDValue(N, 0); return SDValue(N, 0);
} }
SDValue SelectionDAG::getTruncStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue SelectionDAG::getTruncStore(SDValue Chain, SDLoc dl, SDValue Val,
SDValue Ptr, MachinePointerInfo PtrInfo, SDValue Ptr, MachinePointerInfo PtrInfo,
EVT SVT,bool isVolatile, bool isNonTemporal, EVT SVT,bool isVolatile, bool isNonTemporal,
unsigned Alignment, unsigned Alignment,
@ -4576,7 +4577,7 @@ SDValue SelectionDAG::getTruncStore(SDValue Chain, DebugLoc dl, SDValue Val,
return getTruncStore(Chain, dl, Val, Ptr, SVT, MMO); return getTruncStore(Chain, dl, Val, Ptr, SVT, MMO);
} }
SDValue SelectionDAG::getTruncStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue SelectionDAG::getTruncStore(SDValue Chain, SDLoc dl, SDValue Val,
SDValue Ptr, EVT SVT, SDValue Ptr, EVT SVT,
MachineMemOperand *MMO) { MachineMemOperand *MMO) {
EVT VT = Val.getValueType(); EVT VT = Val.getValueType();
@ -4610,7 +4611,7 @@ SDValue SelectionDAG::getTruncStore(SDValue Chain, DebugLoc dl, SDValue Val,
cast<StoreSDNode>(E)->refineAlignment(MMO); cast<StoreSDNode>(E)->refineAlignment(MMO);
return SDValue(E, 0); return SDValue(E, 0);
} }
SDNode *N = new (NodeAllocator) StoreSDNode(Ops, dl, VTs, ISD::UNINDEXED, SDNode *N = new (NodeAllocator) StoreSDNode(Ops, dl.getIROrder(), dl.getDebugLoc(), VTs, ISD::UNINDEXED,
true, SVT, MMO); true, SVT, MMO);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
AllNodes.push_back(N); AllNodes.push_back(N);
@ -4618,7 +4619,7 @@ SDValue SelectionDAG::getTruncStore(SDValue Chain, DebugLoc dl, SDValue Val,
} }
SDValue SDValue
SelectionDAG::getIndexedStore(SDValue OrigStore, DebugLoc dl, SDValue Base, SelectionDAG::getIndexedStore(SDValue OrigStore, SDLoc dl, SDValue Base,
SDValue Offset, ISD::MemIndexedMode AM) { SDValue Offset, ISD::MemIndexedMode AM) {
StoreSDNode *ST = cast<StoreSDNode>(OrigStore); StoreSDNode *ST = cast<StoreSDNode>(OrigStore);
assert(ST->getOffset().getOpcode() == ISD::UNDEF && assert(ST->getOffset().getOpcode() == ISD::UNDEF &&
@ -4634,7 +4635,7 @@ SelectionDAG::getIndexedStore(SDValue OrigStore, DebugLoc dl, SDValue Base,
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0); return SDValue(E, 0);
SDNode *N = new (NodeAllocator) StoreSDNode(Ops, dl, VTs, AM, SDNode *N = new (NodeAllocator) StoreSDNode(Ops, dl.getIROrder(), dl.getDebugLoc(), VTs, AM,
ST->isTruncatingStore(), ST->isTruncatingStore(),
ST->getMemoryVT(), ST->getMemoryVT(),
ST->getMemOperand()); ST->getMemOperand());
@ -4643,7 +4644,7 @@ SelectionDAG::getIndexedStore(SDValue OrigStore, DebugLoc dl, SDValue Base,
return SDValue(N, 0); return SDValue(N, 0);
} }
SDValue SelectionDAG::getVAArg(EVT VT, DebugLoc dl, SDValue SelectionDAG::getVAArg(EVT VT, SDLoc dl,
SDValue Chain, SDValue Ptr, SDValue Chain, SDValue Ptr,
SDValue SV, SDValue SV,
unsigned Align) { unsigned Align) {
@ -4651,7 +4652,7 @@ SDValue SelectionDAG::getVAArg(EVT VT, DebugLoc dl,
return getNode(ISD::VAARG, dl, getVTList(VT, MVT::Other), Ops, 4); return getNode(ISD::VAARG, dl, getVTList(VT, MVT::Other), Ops, 4);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT,
const SDUse *Ops, unsigned NumOps) { const SDUse *Ops, unsigned NumOps) {
switch (NumOps) { switch (NumOps) {
case 0: return getNode(Opcode, DL, VT); case 0: return getNode(Opcode, DL, VT);
@ -4667,7 +4668,7 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT,
return getNode(Opcode, DL, VT, &NewOps[0], NumOps); return getNode(Opcode, DL, VT, &NewOps[0], NumOps);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, EVT VT,
const SDValue *Ops, unsigned NumOps) { const SDValue *Ops, unsigned NumOps) {
switch (NumOps) { switch (NumOps) {
case 0: return getNode(Opcode, DL, VT); case 0: return getNode(Opcode, DL, VT);
@ -4709,10 +4710,10 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT,
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
return SDValue(E, 0); return SDValue(E, 0);
N = new (NodeAllocator) SDNode(Opcode, DL, VTs, Ops, NumOps); N = new (NodeAllocator) SDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTs, Ops, NumOps);
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
} else { } else {
N = new (NodeAllocator) SDNode(Opcode, DL, VTs, Ops, NumOps); N = new (NodeAllocator) SDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTs, Ops, NumOps);
} }
AllNodes.push_back(N); AllNodes.push_back(N);
@ -4722,14 +4723,14 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, EVT VT,
return SDValue(N, 0); return SDValue(N, 0);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL,
ArrayRef<EVT> ResultTys, ArrayRef<EVT> ResultTys,
const SDValue *Ops, unsigned NumOps) { const SDValue *Ops, unsigned NumOps) {
return getNode(Opcode, DL, getVTList(&ResultTys[0], ResultTys.size()), return getNode(Opcode, DL, getVTList(&ResultTys[0], ResultTys.size()),
Ops, NumOps); Ops, NumOps);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL,
const EVT *VTs, unsigned NumVTs, const EVT *VTs, unsigned NumVTs,
const SDValue *Ops, unsigned NumOps) { const SDValue *Ops, unsigned NumOps) {
if (NumVTs == 1) if (NumVTs == 1)
@ -4737,7 +4738,7 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL,
return getNode(Opcode, DL, makeVTList(VTs, NumVTs), Ops, NumOps); return getNode(Opcode, DL, makeVTList(VTs, NumVTs), Ops, NumOps);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDVTList VTList, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList,
const SDValue *Ops, unsigned NumOps) { const SDValue *Ops, unsigned NumOps) {
if (VTList.NumVTs == 1) if (VTList.NumVTs == 1)
return getNode(Opcode, DL, VTList.VTs[0], Ops, NumOps); return getNode(Opcode, DL, VTList.VTs[0], Ops, NumOps);
@ -4775,26 +4776,26 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDVTList VTList,
return SDValue(E, 0); return SDValue(E, 0);
if (NumOps == 1) { if (NumOps == 1) {
N = new (NodeAllocator) UnarySDNode(Opcode, DL, VTList, Ops[0]); N = new (NodeAllocator) UnarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTList, Ops[0]);
} else if (NumOps == 2) { } else if (NumOps == 2) {
N = new (NodeAllocator) BinarySDNode(Opcode, DL, VTList, Ops[0], Ops[1]); N = new (NodeAllocator) BinarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTList, Ops[0], Ops[1]);
} else if (NumOps == 3) { } else if (NumOps == 3) {
N = new (NodeAllocator) TernarySDNode(Opcode, DL, VTList, Ops[0], Ops[1], N = new (NodeAllocator) TernarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTList, Ops[0], Ops[1],
Ops[2]); Ops[2]);
} else { } else {
N = new (NodeAllocator) SDNode(Opcode, DL, VTList, Ops, NumOps); N = new (NodeAllocator) SDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTList, Ops, NumOps);
} }
CSEMap.InsertNode(N, IP); CSEMap.InsertNode(N, IP);
} else { } else {
if (NumOps == 1) { if (NumOps == 1) {
N = new (NodeAllocator) UnarySDNode(Opcode, DL, VTList, Ops[0]); N = new (NodeAllocator) UnarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTList, Ops[0]);
} else if (NumOps == 2) { } else if (NumOps == 2) {
N = new (NodeAllocator) BinarySDNode(Opcode, DL, VTList, Ops[0], Ops[1]); N = new (NodeAllocator) BinarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTList, Ops[0], Ops[1]);
} else if (NumOps == 3) { } else if (NumOps == 3) {
N = new (NodeAllocator) TernarySDNode(Opcode, DL, VTList, Ops[0], Ops[1], N = new (NodeAllocator) TernarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTList, Ops[0], Ops[1],
Ops[2]); Ops[2]);
} else { } else {
N = new (NodeAllocator) SDNode(Opcode, DL, VTList, Ops, NumOps); N = new (NodeAllocator) SDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTList, Ops, NumOps);
} }
} }
AllNodes.push_back(N); AllNodes.push_back(N);
@ -4804,36 +4805,36 @@ SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDVTList VTList,
return SDValue(N, 0); return SDValue(N, 0);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDVTList VTList) { SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList) {
return getNode(Opcode, DL, VTList, 0, 0); return getNode(Opcode, DL, VTList, 0, 0);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDVTList VTList, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList,
SDValue N1) { SDValue N1) {
SDValue Ops[] = { N1 }; SDValue Ops[] = { N1 };
return getNode(Opcode, DL, VTList, Ops, 1); return getNode(Opcode, DL, VTList, Ops, 1);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDVTList VTList, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList,
SDValue N1, SDValue N2) { SDValue N1, SDValue N2) {
SDValue Ops[] = { N1, N2 }; SDValue Ops[] = { N1, N2 };
return getNode(Opcode, DL, VTList, Ops, 2); return getNode(Opcode, DL, VTList, Ops, 2);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDVTList VTList, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList,
SDValue N1, SDValue N2, SDValue N3) { SDValue N1, SDValue N2, SDValue N3) {
SDValue Ops[] = { N1, N2, N3 }; SDValue Ops[] = { N1, N2, N3 };
return getNode(Opcode, DL, VTList, Ops, 3); return getNode(Opcode, DL, VTList, Ops, 3);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDVTList VTList, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList,
SDValue N1, SDValue N2, SDValue N3, SDValue N1, SDValue N2, SDValue N3,
SDValue N4) { SDValue N4) {
SDValue Ops[] = { N1, N2, N3, N4 }; SDValue Ops[] = { N1, N2, N3, N4 };
return getNode(Opcode, DL, VTList, Ops, 4); return getNode(Opcode, DL, VTList, Ops, 4);
} }
SDValue SelectionDAG::getNode(unsigned Opcode, DebugLoc DL, SDVTList VTList, SDValue SelectionDAG::getNode(unsigned Opcode, SDLoc DL, SDVTList VTList,
SDValue N1, SDValue N2, SDValue N3, SDValue N1, SDValue N2, SDValue N3,
SDValue N4, SDValue N5) { SDValue N4, SDValue N5) {
SDValue Ops[] = { N1, N2, N3, N4, N5 }; SDValue Ops[] = { N1, N2, N3, N4, N5 };
@ -5153,17 +5154,21 @@ SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned MachineOpc,
return N; return N;
} }
/// UpdadeDebugLocOnMergedSDNode - If the opt level is -O0 then it throws away /// UpdadeSDLocOnMergedSDNode - If the opt level is -O0 then it throws away
/// the line number information on the merged node since it is not possible to /// the line number information on the merged node since it is not possible to
/// preserve the information that operation is associated with multiple lines. /// preserve the information that operation is associated with multiple lines.
/// This will make the debugger working better at -O0, were there is a higher /// This will make the debugger working better at -O0, were there is a higher
/// probability having other instructions associated with that line. /// probability having other instructions associated with that line.
/// ///
SDNode *SelectionDAG::UpdadeDebugLocOnMergedSDNode(SDNode *N, DebugLoc OLoc) { /// For IROrder, we keep the smaller of the two
SDNode *SelectionDAG::UpdadeSDLocOnMergedSDNode(SDNode *N, SDLoc OLoc) {
DebugLoc NLoc = N->getDebugLoc(); DebugLoc NLoc = N->getDebugLoc();
if (!(NLoc.isUnknown()) && (OptLevel == CodeGenOpt::None) && (OLoc != NLoc)) { if (!(NLoc.isUnknown()) && (OptLevel == CodeGenOpt::None) &&
(OLoc.getDebugLoc() != NLoc)) {
N->setDebugLoc(DebugLoc()); N->setDebugLoc(DebugLoc());
} }
unsigned Order = std::min(N->getIROrder(), OLoc.getIROrder());
N->setIROrder(Order);
return N; return N;
} }
@ -5172,7 +5177,7 @@ SDNode *SelectionDAG::UpdadeDebugLocOnMergedSDNode(SDNode *N, DebugLoc OLoc) {
/// ///
/// Note that MorphNodeTo returns the resultant node. If there is already a /// Note that MorphNodeTo returns the resultant node. If there is already a
/// node of the specified opcode and operands, it returns that node instead of /// node of the specified opcode and operands, it returns that node instead of
/// the current one. Note that the DebugLoc need not be the same. /// the current one. Note that the SDLoc need not be the same.
/// ///
/// Using MorphNodeTo is faster than creating a new node and swapping it in /// Using MorphNodeTo is faster than creating a new node and swapping it in
/// with ReplaceAllUsesWith both because it often avoids allocating a new /// with ReplaceAllUsesWith both because it often avoids allocating a new
@ -5188,7 +5193,7 @@ SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
FoldingSetNodeID ID; FoldingSetNodeID ID;
AddNodeIDNode(ID, Opc, VTs, Ops, NumOps); AddNodeIDNode(ID, Opc, VTs, Ops, NumOps);
if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP)) if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP))
return UpdadeDebugLocOnMergedSDNode(ON, N->getDebugLoc()); return UpdadeSDLocOnMergedSDNode(ON, SDLoc(N));
} }
if (!RemoveNodeFromCSEMaps(N)) if (!RemoveNodeFromCSEMaps(N))
@ -5265,20 +5270,20 @@ SDNode *SelectionDAG::MorphNodeTo(SDNode *N, unsigned Opc,
/// node of the specified opcode and operands, it returns that node instead of /// node of the specified opcode and operands, it returns that node instead of
/// the current one. /// the current one.
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT) { SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT) {
SDVTList VTs = getVTList(VT); SDVTList VTs = getVTList(VT);
return getMachineNode(Opcode, dl, VTs, None); return getMachineNode(Opcode, dl, VTs, None);
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT, SDValue Op1) { SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT, SDValue Op1) {
SDVTList VTs = getVTList(VT); SDVTList VTs = getVTList(VT);
SDValue Ops[] = { Op1 }; SDValue Ops[] = { Op1 };
return getMachineNode(Opcode, dl, VTs, Ops); return getMachineNode(Opcode, dl, VTs, Ops);
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT,
SDValue Op1, SDValue Op2) { SDValue Op1, SDValue Op2) {
SDVTList VTs = getVTList(VT); SDVTList VTs = getVTList(VT);
SDValue Ops[] = { Op1, Op2 }; SDValue Ops[] = { Op1, Op2 };
@ -5286,7 +5291,7 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT,
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT,
SDValue Op1, SDValue Op2, SDValue Op3) { SDValue Op1, SDValue Op2, SDValue Op3) {
SDVTList VTs = getVTList(VT); SDVTList VTs = getVTList(VT);
SDValue Ops[] = { Op1, Op2, Op3 }; SDValue Ops[] = { Op1, Op2, Op3 };
@ -5294,20 +5299,20 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT,
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT,
ArrayRef<SDValue> Ops) { ArrayRef<SDValue> Ops) {
SDVTList VTs = getVTList(VT); SDVTList VTs = getVTList(VT);
return getMachineNode(Opcode, dl, VTs, Ops); return getMachineNode(Opcode, dl, VTs, Ops);
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, EVT VT2) { SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1, EVT VT2) {
SDVTList VTs = getVTList(VT1, VT2); SDVTList VTs = getVTList(VT1, VT2);
return getMachineNode(Opcode, dl, VTs, None); return getMachineNode(Opcode, dl, VTs, None);
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
EVT VT1, EVT VT2, SDValue Op1) { EVT VT1, EVT VT2, SDValue Op1) {
SDVTList VTs = getVTList(VT1, VT2); SDVTList VTs = getVTList(VT1, VT2);
SDValue Ops[] = { Op1 }; SDValue Ops[] = { Op1 };
@ -5315,7 +5320,7 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl,
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
EVT VT1, EVT VT2, SDValue Op1, SDValue Op2) { EVT VT1, EVT VT2, SDValue Op1, SDValue Op2) {
SDVTList VTs = getVTList(VT1, VT2); SDVTList VTs = getVTList(VT1, VT2);
SDValue Ops[] = { Op1, Op2 }; SDValue Ops[] = { Op1, Op2 };
@ -5323,7 +5328,7 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl,
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
EVT VT1, EVT VT2, SDValue Op1, EVT VT1, EVT VT2, SDValue Op1,
SDValue Op2, SDValue Op3) { SDValue Op2, SDValue Op3) {
SDVTList VTs = getVTList(VT1, VT2); SDVTList VTs = getVTList(VT1, VT2);
@ -5332,7 +5337,7 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl,
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
EVT VT1, EVT VT2, EVT VT1, EVT VT2,
ArrayRef<SDValue> Ops) { ArrayRef<SDValue> Ops) {
SDVTList VTs = getVTList(VT1, VT2); SDVTList VTs = getVTList(VT1, VT2);
@ -5340,7 +5345,7 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl,
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
EVT VT1, EVT VT2, EVT VT3, EVT VT1, EVT VT2, EVT VT3,
SDValue Op1, SDValue Op2) { SDValue Op1, SDValue Op2) {
SDVTList VTs = getVTList(VT1, VT2, VT3); SDVTList VTs = getVTList(VT1, VT2, VT3);
@ -5349,7 +5354,7 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl,
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
EVT VT1, EVT VT2, EVT VT3, EVT VT1, EVT VT2, EVT VT3,
SDValue Op1, SDValue Op2, SDValue Op3) { SDValue Op1, SDValue Op2, SDValue Op3) {
SDVTList VTs = getVTList(VT1, VT2, VT3); SDVTList VTs = getVTList(VT1, VT2, VT3);
@ -5358,7 +5363,7 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl,
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
EVT VT1, EVT VT2, EVT VT3, EVT VT1, EVT VT2, EVT VT3,
ArrayRef<SDValue> Ops) { ArrayRef<SDValue> Ops) {
SDVTList VTs = getVTList(VT1, VT2, VT3); SDVTList VTs = getVTList(VT1, VT2, VT3);
@ -5366,7 +5371,7 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl,
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl, EVT VT1,
EVT VT2, EVT VT3, EVT VT4, EVT VT2, EVT VT3, EVT VT4,
ArrayRef<SDValue> Ops) { ArrayRef<SDValue> Ops) {
SDVTList VTs = getVTList(VT1, VT2, VT3, VT4); SDVTList VTs = getVTList(VT1, VT2, VT3, VT4);
@ -5374,7 +5379,7 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, EVT VT1,
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc dl,
ArrayRef<EVT> ResultTys, ArrayRef<EVT> ResultTys,
ArrayRef<SDValue> Ops) { ArrayRef<SDValue> Ops) {
SDVTList VTs = getVTList(&ResultTys[0], ResultTys.size()); SDVTList VTs = getVTList(&ResultTys[0], ResultTys.size());
@ -5382,7 +5387,7 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc dl,
} }
MachineSDNode * MachineSDNode *
SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc DL, SDVTList VTs, SelectionDAG::getMachineNode(unsigned Opcode, SDLoc DL, SDVTList VTs,
ArrayRef<SDValue> OpsArray) { ArrayRef<SDValue> OpsArray) {
bool DoCSE = VTs.VTs[VTs.NumVTs-1] != MVT::Glue; bool DoCSE = VTs.VTs[VTs.NumVTs-1] != MVT::Glue;
MachineSDNode *N; MachineSDNode *N;
@ -5395,12 +5400,12 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc DL, SDVTList VTs,
AddNodeIDNode(ID, ~Opcode, VTs, Ops, NumOps); AddNodeIDNode(ID, ~Opcode, VTs, Ops, NumOps);
IP = 0; IP = 0;
if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) { if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
return cast<MachineSDNode>(UpdadeDebugLocOnMergedSDNode(E, DL)); return cast<MachineSDNode>(UpdadeSDLocOnMergedSDNode(E, DL));
} }
} }
// Allocate a new MachineSDNode. // Allocate a new MachineSDNode.
N = new (NodeAllocator) MachineSDNode(~Opcode, DL, VTs); N = new (NodeAllocator) MachineSDNode(~Opcode, DL.getIROrder(), DL.getDebugLoc(), VTs);
// Initialize the operands list. // Initialize the operands list.
if (NumOps > array_lengthof(N->LocalOperands)) if (NumOps > array_lengthof(N->LocalOperands))
@ -5426,7 +5431,7 @@ SelectionDAG::getMachineNode(unsigned Opcode, DebugLoc DL, SDVTList VTs,
/// getTargetExtractSubreg - A convenience function for creating /// getTargetExtractSubreg - A convenience function for creating
/// TargetOpcode::EXTRACT_SUBREG nodes. /// TargetOpcode::EXTRACT_SUBREG nodes.
SDValue SDValue
SelectionDAG::getTargetExtractSubreg(int SRIdx, DebugLoc DL, EVT VT, SelectionDAG::getTargetExtractSubreg(int SRIdx, SDLoc DL, EVT VT,
SDValue Operand) { SDValue Operand) {
SDValue SRIdxVal = getTargetConstant(SRIdx, MVT::i32); SDValue SRIdxVal = getTargetConstant(SRIdx, MVT::i32);
SDNode *Subreg = getMachineNode(TargetOpcode::EXTRACT_SUBREG, DL, SDNode *Subreg = getMachineNode(TargetOpcode::EXTRACT_SUBREG, DL,
@ -5437,7 +5442,7 @@ SelectionDAG::getTargetExtractSubreg(int SRIdx, DebugLoc DL, EVT VT,
/// getTargetInsertSubreg - A convenience function for creating /// getTargetInsertSubreg - A convenience function for creating
/// TargetOpcode::INSERT_SUBREG nodes. /// TargetOpcode::INSERT_SUBREG nodes.
SDValue SDValue
SelectionDAG::getTargetInsertSubreg(int SRIdx, DebugLoc DL, EVT VT, SelectionDAG::getTargetInsertSubreg(int SRIdx, SDLoc DL, EVT VT,
SDValue Operand, SDValue Subreg) { SDValue Operand, SDValue Subreg) {
SDValue SRIdxVal = getTargetConstant(SRIdx, MVT::i32); SDValue SRIdxVal = getTargetConstant(SRIdx, MVT::i32);
SDNode *Result = getMachineNode(TargetOpcode::INSERT_SUBREG, DL, SDNode *Result = getMachineNode(TargetOpcode::INSERT_SUBREG, DL,
@ -5911,16 +5916,16 @@ HandleSDNode::~HandleSDNode() {
DropOperands(); DropOperands();
} }
GlobalAddressSDNode::GlobalAddressSDNode(unsigned Opc, DebugLoc DL, GlobalAddressSDNode::GlobalAddressSDNode(unsigned Opc, unsigned Order,
const GlobalValue *GA, DebugLoc DL, const GlobalValue *GA,
EVT VT, int64_t o, unsigned char TF) EVT VT, int64_t o, unsigned char TF)
: SDNode(Opc, DL, getSDVTList(VT)), Offset(o), TargetFlags(TF) { : SDNode(Opc, Order, DL, getSDVTList(VT)), Offset(o), TargetFlags(TF) {
TheGlobal = GA; TheGlobal = GA;
} }
MemSDNode::MemSDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, EVT memvt, MemSDNode::MemSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs,
MachineMemOperand *mmo) EVT memvt, MachineMemOperand *mmo)
: SDNode(Opc, dl, VTs), MemoryVT(memvt), MMO(mmo) { : SDNode(Opc, Order, dl, VTs), MemoryVT(memvt), MMO(mmo) {
SubclassData = encodeMemSDNodeFlags(0, ISD::UNINDEXED, MMO->isVolatile(), SubclassData = encodeMemSDNodeFlags(0, ISD::UNINDEXED, MMO->isVolatile(),
MMO->isNonTemporal(), MMO->isInvariant()); MMO->isNonTemporal(), MMO->isInvariant());
assert(isVolatile() == MMO->isVolatile() && "Volatile encoding error!"); assert(isVolatile() == MMO->isVolatile() && "Volatile encoding error!");
@ -5929,10 +5934,10 @@ MemSDNode::MemSDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, EVT memvt,
assert(memvt.getStoreSize() == MMO->getSize() && "Size mismatch!"); assert(memvt.getStoreSize() == MMO->getSize() && "Size mismatch!");
} }
MemSDNode::MemSDNode(unsigned Opc, DebugLoc dl, SDVTList VTs, MemSDNode::MemSDNode(unsigned Opc, unsigned Order, DebugLoc dl, SDVTList VTs,
const SDValue *Ops, unsigned NumOps, EVT memvt, const SDValue *Ops, unsigned NumOps, EVT memvt,
MachineMemOperand *mmo) MachineMemOperand *mmo)
: SDNode(Opc, dl, VTs, Ops, NumOps), : SDNode(Opc, Order, dl, VTs, Ops, NumOps),
MemoryVT(memvt), MMO(mmo) { MemoryVT(memvt), MMO(mmo) {
SubclassData = encodeMemSDNodeFlags(0, ISD::UNINDEXED, MMO->isVolatile(), SubclassData = encodeMemSDNodeFlags(0, ISD::UNINDEXED, MMO->isVolatile(),
MMO->isNonTemporal(), MMO->isInvariant()); MMO->isNonTemporal(), MMO->isInvariant());
@ -6118,7 +6123,7 @@ SDValue SelectionDAG::UnrollVectorOp(SDNode *N, unsigned ResNE) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
unsigned NE = VT.getVectorNumElements(); unsigned NE = VT.getVectorNumElements();
EVT EltVT = VT.getVectorElementType(); EVT EltVT = VT.getVectorElementType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SmallVector<SDValue, 8> Scalars; SmallVector<SDValue, 8> Scalars;
SmallVector<SDValue, 4> Operands(N->getNumOperands()); SmallVector<SDValue, 4> Operands(N->getNumOperands());

439
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
View File

File diff suppressed because it is too large Load Diff

1
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h
View File

@ -366,7 +366,6 @@ public:
SDValue getControlRoot(); SDValue getControlRoot();
SDLoc getCurSDLoc() const { SDLoc getCurSDLoc() const {
assert(CurInst && "CurInst NULL");
return SDLoc(CurInst, SDNodeOrder); return SDLoc(CurInst, SDNodeOrder);
} }

3
lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp
View File

@ -489,8 +489,7 @@ void SDNode::print_details(raw_ostream &OS, const SelectionDAG *G) const {
OS << " [TF=" << TF << ']'; OS << " [TF=" << TF << ']';
} }
if (G) if (unsigned Order = getIROrder())
if (unsigned Order = G->GetOrdering(this))
OS << " [ORD=" << Order << ']'; OS << " [ORD=" << Order << ']';
if (getNodeId() != -1) if (getNodeId() != -1)

8
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
View File

@ -1606,7 +1606,7 @@ SDNode *SelectionDAGISel::Select_INLINEASM(SDNode *N) {
SelectInlineAsmMemoryOperands(Ops); SelectInlineAsmMemoryOperands(Ops);
EVT VTs[] = { MVT::Other, MVT::Glue }; EVT VTs[] = { MVT::Other, MVT::Glue };
SDValue New = CurDAG->getNode(ISD::INLINEASM, N->getDebugLoc(), SDValue New = CurDAG->getNode(ISD::INLINEASM, SDLoc(N),
VTs, &Ops[0], Ops.size()); VTs, &Ops[0], Ops.size());
New->setNodeId(-1); New->setNodeId(-1);
return New.getNode(); return New.getNode();
@ -1881,7 +1881,7 @@ HandleMergeInputChains(SmallVectorImpl<SDNode*> &ChainNodesMatched,
SDValue Res; SDValue Res;
if (InputChains.size() == 1) if (InputChains.size() == 1)
return InputChains[0]; return InputChains[0];
return CurDAG->getNode(ISD::TokenFactor, ChainNodesMatched[0]->getDebugLoc(), return CurDAG->getNode(ISD::TokenFactor, SDLoc(ChainNodesMatched[0]),
MVT::Other, &InputChains[0], InputChains.size()); MVT::Other, &InputChains[0], InputChains.size());
} }
@ -2630,7 +2630,7 @@ SelectCodeCommon(SDNode *NodeToMatch, const unsigned char *MatcherTable,
if (InputChain.getNode() == 0) if (InputChain.getNode() == 0)
InputChain = CurDAG->getEntryNode(); InputChain = CurDAG->getEntryNode();
InputChain = CurDAG->getCopyToReg(InputChain, NodeToMatch->getDebugLoc(), InputChain = CurDAG->getCopyToReg(InputChain, SDLoc(NodeToMatch),
DestPhysReg, RecordedNodes[RecNo].first, DestPhysReg, RecordedNodes[RecNo].first,
InputGlue); InputGlue);
@ -2717,7 +2717,7 @@ SelectCodeCommon(SDNode *NodeToMatch, const unsigned char *MatcherTable,
if (Opcode != OPC_MorphNodeTo) { if (Opcode != OPC_MorphNodeTo) {
// If this is a normal EmitNode command, just create the new node and // If this is a normal EmitNode command, just create the new node and
// add the results to the RecordedNodes list. // add the results to the RecordedNodes list.
Res = CurDAG->getMachineNode(TargetOpc, NodeToMatch->getDebugLoc(), Res = CurDAG->getMachineNode(TargetOpc, SDLoc(NodeToMatch),
VTList, Ops); VTList, Ops);
// Add all the non-glue/non-chain results to the RecordedNodes list. // Add all the non-glue/non-chain results to the RecordedNodes list.

20
lib/CodeGen/SelectionDAG/TargetLowering.cpp
View File

@ -70,7 +70,7 @@ bool TargetLowering::isInTailCallPosition(SelectionDAG &DAG, SDNode *Node,
SDValue TargetLowering::makeLibCall(SelectionDAG &DAG, SDValue TargetLowering::makeLibCall(SelectionDAG &DAG,
RTLIB::Libcall LC, EVT RetVT, RTLIB::Libcall LC, EVT RetVT,
const SDValue *Ops, unsigned NumOps, const SDValue *Ops, unsigned NumOps,
bool isSigned, DebugLoc dl) const { bool isSigned, SDLoc dl) const {
TargetLowering::ArgListTy Args; TargetLowering::ArgListTy Args;
Args.reserve(NumOps); Args.reserve(NumOps);
@ -102,7 +102,7 @@ SDValue TargetLowering::makeLibCall(SelectionDAG &DAG,
void TargetLowering::softenSetCCOperands(SelectionDAG &DAG, EVT VT, void TargetLowering::softenSetCCOperands(SelectionDAG &DAG, EVT VT,
SDValue &NewLHS, SDValue &NewRHS, SDValue &NewLHS, SDValue &NewRHS,
ISD::CondCode &CCCode, ISD::CondCode &CCCode,
DebugLoc dl) const { SDLoc dl) const {
assert((VT == MVT::f32 || VT == MVT::f64 || VT == MVT::f128) assert((VT == MVT::f32 || VT == MVT::f64 || VT == MVT::f128)
&& "Unsupported setcc type!"); && "Unsupported setcc type!");
@ -264,7 +264,7 @@ TargetLowering::isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const {
/// constant and return true. /// constant and return true.
bool TargetLowering::TargetLoweringOpt::ShrinkDemandedConstant(SDValue Op, bool TargetLowering::TargetLoweringOpt::ShrinkDemandedConstant(SDValue Op,
const APInt &Demanded) { const APInt &Demanded) {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// FIXME: ISD::SELECT, ISD::SELECT_CC // FIXME: ISD::SELECT, ISD::SELECT_CC
switch (Op.getOpcode()) { switch (Op.getOpcode()) {
@ -304,7 +304,7 @@ bool
TargetLowering::TargetLoweringOpt::ShrinkDemandedOp(SDValue Op, TargetLowering::TargetLoweringOpt::ShrinkDemandedOp(SDValue Op,
unsigned BitWidth, unsigned BitWidth,
const APInt &Demanded, const APInt &Demanded,
DebugLoc dl) { SDLoc dl) {
assert(Op.getNumOperands() == 2 && assert(Op.getNumOperands() == 2 &&
"ShrinkDemandedOp only supports binary operators!"); "ShrinkDemandedOp only supports binary operators!");
assert(Op.getNode()->getNumValues() == 1 && assert(Op.getNode()->getNumValues() == 1 &&
@ -358,7 +358,7 @@ bool TargetLowering::SimplifyDemandedBits(SDValue Op,
assert(Op.getValueType().getScalarType().getSizeInBits() == BitWidth && assert(Op.getValueType().getScalarType().getSizeInBits() == BitWidth &&
"Mask size mismatches value type size!"); "Mask size mismatches value type size!");
APInt NewMask = DemandedMask; APInt NewMask = DemandedMask;
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// Don't know anything. // Don't know anything.
KnownZero = KnownOne = APInt(BitWidth, 0); KnownZero = KnownOne = APInt(BitWidth, 0);
@ -1068,7 +1068,7 @@ static bool ValueHasExactlyOneBitSet(SDValue Val, const SelectionDAG &DAG) {
SDValue SDValue
TargetLowering::SimplifySetCC(EVT VT, SDValue N0, SDValue N1, TargetLowering::SimplifySetCC(EVT VT, SDValue N0, SDValue N1,
ISD::CondCode Cond, bool foldBooleans, ISD::CondCode Cond, bool foldBooleans,
DAGCombinerInfo &DCI, DebugLoc dl) const { DAGCombinerInfo &DCI, SDLoc dl) const {
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
// These setcc operations always fold. // These setcc operations always fold.
@ -1969,7 +1969,7 @@ void TargetLowering::LowerAsmOperandForConstraint(SDValue Op,
int64_t Offs = GA->getOffset(); int64_t Offs = GA->getOffset();
if (C) Offs += C->getZExtValue(); if (C) Offs += C->getZExtValue();
Ops.push_back(DAG.getTargetGlobalAddress(GA->getGlobal(), Ops.push_back(DAG.getTargetGlobalAddress(GA->getGlobal(),
C ? C->getDebugLoc() : DebugLoc(), C ? SDLoc(C) : SDLoc(),
Op.getValueType(), Offs)); Op.getValueType(), Offs));
return; return;
} }
@ -2440,7 +2440,7 @@ void TargetLowering::ComputeConstraintToUse(AsmOperandInfo &OpInfo,
/// BuildExactDiv - Given an exact SDIV by a constant, create a multiplication /// BuildExactDiv - Given an exact SDIV by a constant, create a multiplication
/// with the multiplicative inverse of the constant. /// with the multiplicative inverse of the constant.
SDValue TargetLowering::BuildExactSDIV(SDValue Op1, SDValue Op2, DebugLoc dl, SDValue TargetLowering::BuildExactSDIV(SDValue Op1, SDValue Op2, SDLoc dl,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
ConstantSDNode *C = cast<ConstantSDNode>(Op2); ConstantSDNode *C = cast<ConstantSDNode>(Op2);
APInt d = C->getAPIntValue(); APInt d = C->getAPIntValue();
@ -2472,7 +2472,7 @@ SDValue TargetLowering::
BuildSDIV(SDNode *N, SelectionDAG &DAG, bool IsAfterLegalization, BuildSDIV(SDNode *N, SelectionDAG &DAG, bool IsAfterLegalization,
std::vector<SDNode*> *Created) const { std::vector<SDNode*> *Created) const {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl= N->getDebugLoc(); SDLoc dl(N);
// Check to see if we can do this. // Check to see if we can do this.
// FIXME: We should be more aggressive here. // FIXME: We should be more aggressive here.
@ -2532,7 +2532,7 @@ SDValue TargetLowering::
BuildUDIV(SDNode *N, SelectionDAG &DAG, bool IsAfterLegalization, BuildUDIV(SDNode *N, SelectionDAG &DAG, bool IsAfterLegalization,
std::vector<SDNode*> *Created) const { std::vector<SDNode*> *Created) const {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Check to see if we can do this. // Check to see if we can do this.
// FIXME: We should be more aggressive here. // FIXME: We should be more aggressive here.

12
lib/Target/AArch64/AArch64ISelDAGToDAG.cpp
View File

@ -102,7 +102,7 @@ public:
/// Put the given constant into a pool and return a DAG which will give its /// Put the given constant into a pool and return a DAG which will give its
/// address. /// address.
SDValue getConstantPoolItemAddress(DebugLoc DL, const Constant *CV); SDValue getConstantPoolItemAddress(SDLoc DL, const Constant *CV);
SDNode *TrySelectToMoveImm(SDNode *N); SDNode *TrySelectToMoveImm(SDNode *N);
SDNode *LowerToFPLitPool(SDNode *Node); SDNode *LowerToFPLitPool(SDNode *Node);
@ -191,7 +191,7 @@ bool AArch64DAGToDAGISel::SelectLogicalImm(SDValue N, SDValue &Imm) {
SDNode *AArch64DAGToDAGISel::TrySelectToMoveImm(SDNode *Node) { SDNode *AArch64DAGToDAGISel::TrySelectToMoveImm(SDNode *Node) {
SDNode *ResNode; SDNode *ResNode;
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
EVT DestType = Node->getValueType(0); EVT DestType = Node->getValueType(0);
unsigned DestWidth = DestType.getSizeInBits(); unsigned DestWidth = DestType.getSizeInBits();
@ -241,7 +241,7 @@ SDNode *AArch64DAGToDAGISel::TrySelectToMoveImm(SDNode *Node) {
} }
SDValue SDValue
AArch64DAGToDAGISel::getConstantPoolItemAddress(DebugLoc DL, AArch64DAGToDAGISel::getConstantPoolItemAddress(SDLoc DL,
const Constant *CV) { const Constant *CV) {
EVT PtrVT = TLI.getPointerTy(); EVT PtrVT = TLI.getPointerTy();
@ -281,7 +281,7 @@ AArch64DAGToDAGISel::getConstantPoolItemAddress(DebugLoc DL,
} }
SDNode *AArch64DAGToDAGISel::SelectToLitPool(SDNode *Node) { SDNode *AArch64DAGToDAGISel::SelectToLitPool(SDNode *Node) {
DebugLoc DL = Node->getDebugLoc(); SDLoc DL(Node);
uint64_t UnsignedVal = cast<ConstantSDNode>(Node)->getZExtValue(); uint64_t UnsignedVal = cast<ConstantSDNode>(Node)->getZExtValue();
int64_t SignedVal = cast<ConstantSDNode>(Node)->getSExtValue(); int64_t SignedVal = cast<ConstantSDNode>(Node)->getSExtValue();
EVT DestType = Node->getValueType(0); EVT DestType = Node->getValueType(0);
@ -323,7 +323,7 @@ SDNode *AArch64DAGToDAGISel::SelectToLitPool(SDNode *Node) {
} }
SDNode *AArch64DAGToDAGISel::LowerToFPLitPool(SDNode *Node) { SDNode *AArch64DAGToDAGISel::LowerToFPLitPool(SDNode *Node) {
DebugLoc DL = Node->getDebugLoc(); SDLoc DL(Node);
const ConstantFP *FV = cast<ConstantFPSDNode>(Node)->getConstantFPValue(); const ConstantFP *FV = cast<ConstantFPSDNode>(Node)->getConstantFPValue();
EVT DestType = Node->getValueType(0); EVT DestType = Node->getValueType(0);
@ -497,7 +497,7 @@ SDNode *AArch64DAGToDAGISel::Select(SDNode *Node) {
assert((Ty == MVT::i32 || Ty == MVT::i64) && "unexpected type"); assert((Ty == MVT::i32 || Ty == MVT::i64) && "unexpected type");
uint16_t Register = Ty == MVT::i32 ? AArch64::WZR : AArch64::XZR; uint16_t Register = Ty == MVT::i32 ? AArch64::WZR : AArch64::XZR;
ResNode = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), ResNode = CurDAG->getCopyFromReg(CurDAG->getEntryNode(),
Node->getDebugLoc(), SDLoc(Node),
Register, Ty).getNode(); Register, Ty).getNode();
} }

58
lib/Target/AArch64/AArch64ISelLowering.cpp
View File

@ -826,7 +826,7 @@ CCAssignFn *AArch64TargetLowering::CCAssignFnForNode(CallingConv::ID CC) const {
void void
AArch64TargetLowering::SaveVarArgRegisters(CCState &CCInfo, SelectionDAG &DAG, AArch64TargetLowering::SaveVarArgRegisters(CCState &CCInfo, SelectionDAG &DAG,
DebugLoc DL, SDValue &Chain) const { SDLoc DL, SDValue &Chain) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo *MFI = MF.getFrameInfo(); MachineFrameInfo *MFI = MF.getFrameInfo();
AArch64MachineFunctionInfo *FuncInfo AArch64MachineFunctionInfo *FuncInfo
@ -897,7 +897,7 @@ SDValue
AArch64TargetLowering::LowerFormalArguments(SDValue Chain, AArch64TargetLowering::LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
AArch64MachineFunctionInfo *FuncInfo AArch64MachineFunctionInfo *FuncInfo
@ -1012,7 +1012,7 @@ AArch64TargetLowering::LowerReturn(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const { SDLoc dl, SelectionDAG &DAG) const {
// CCValAssign - represent the assignment of the return value to a location. // CCValAssign - represent the assignment of the return value to a location.
SmallVector<CCValAssign, 16> RVLocs; SmallVector<CCValAssign, 16> RVLocs;
@ -1085,7 +1085,7 @@ SDValue
AArch64TargetLowering::LowerCall(CallLoweringInfo &CLI, AArch64TargetLowering::LowerCall(CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG; SelectionDAG &DAG = CLI.DAG;
DebugLoc &dl = CLI.DL; SDLoc &dl = CLI.DL;
SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs; SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
SmallVector<SDValue, 32> &OutVals = CLI.OutVals; SmallVector<SDValue, 32> &OutVals = CLI.OutVals;
SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins; SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;
@ -1348,7 +1348,7 @@ SDValue
AArch64TargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag, AArch64TargetLowering::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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
// Assign locations to each value returned by this call. // Assign locations to each value returned by this call.
SmallVector<CCValAssign, 16> RVLocs; SmallVector<CCValAssign, 16> RVLocs;
@ -1537,7 +1537,7 @@ SDValue AArch64TargetLowering::addTokenForArgument(SDValue Chain,
} }
// Build a tokenfactor for all the chains. // Build a tokenfactor for all the chains.
return DAG.getNode(ISD::TokenFactor, Chain.getDebugLoc(), MVT::Other, return DAG.getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other,
&ArgChains[0], ArgChains.size()); &ArgChains[0], ArgChains.size());
} }
@ -1570,7 +1570,7 @@ bool AArch64TargetLowering::isLegalICmpImmediate(int64_t Val) const {
SDValue AArch64TargetLowering::getSelectableIntSetCC(SDValue LHS, SDValue RHS, SDValue AArch64TargetLowering::getSelectableIntSetCC(SDValue LHS, SDValue RHS,
ISD::CondCode CC, SDValue &A64cc, ISD::CondCode CC, SDValue &A64cc,
SelectionDAG &DAG, DebugLoc &dl) const { SelectionDAG &DAG, SDLoc &dl) const {
if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS.getNode())) { if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS.getNode())) {
int64_t C = 0; int64_t C = 0;
EVT VT = RHSC->getValueType(0); EVT VT = RHSC->getValueType(0);
@ -1663,7 +1663,7 @@ static A64CC::CondCodes FPCCToA64CC(ISD::CondCode CC,
SDValue SDValue
AArch64TargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const { AArch64TargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress(); const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
@ -1693,7 +1693,7 @@ AArch64TargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const {
// (BRCOND chain, val, dest) // (BRCOND chain, val, dest)
SDValue SDValue
AArch64TargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) const { AArch64TargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue TheBit = Op.getOperand(1); SDValue TheBit = Op.getOperand(1);
SDValue DestBB = Op.getOperand(2); SDValue DestBB = Op.getOperand(2);
@ -1716,7 +1716,7 @@ AArch64TargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) const {
// (BR_CC chain, condcode, lhs, rhs, dest) // (BR_CC chain, condcode, lhs, rhs, dest)
SDValue SDValue
AArch64TargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG) const { AArch64TargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get(); ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get();
SDValue LHS = Op.getOperand(2); SDValue LHS = Op.getOperand(2);
@ -1802,7 +1802,7 @@ AArch64TargetLowering::LowerF128ToCall(SDValue Op, SelectionDAG &DAG,
CallLoweringInfo CLI(InChain, RetTy, false, false, false, false, CallLoweringInfo CLI(InChain, RetTy, false, false, false, false,
0, getLibcallCallingConv(Call), isTailCall, 0, getLibcallCallingConv(Call), isTailCall,
/*doesNotReturn=*/false, /*isReturnValueUsed=*/true, /*doesNotReturn=*/false, /*isReturnValueUsed=*/true,
Callee, Args, DAG, Op->getDebugLoc()); Callee, Args, DAG, SDLoc(Op));
std::pair<SDValue, SDValue> CallInfo = LowerCallTo(CLI); std::pair<SDValue, SDValue> CallInfo = LowerCallTo(CLI);
if (!CallInfo.second.getNode()) if (!CallInfo.second.getNode())
@ -1824,7 +1824,7 @@ AArch64TargetLowering::LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const {
SDValue SrcVal = Op.getOperand(0); SDValue SrcVal = Op.getOperand(0);
return makeLibCall(DAG, LC, Op.getValueType(), &SrcVal, 1, return makeLibCall(DAG, LC, Op.getValueType(), &SrcVal, 1,
/*isSigned*/ false, Op.getDebugLoc()); /*isSigned*/ false, SDLoc(Op));
} }
SDValue SDValue
@ -1861,7 +1861,7 @@ AArch64TargetLowering::LowerGlobalAddressELFLarge(SDValue Op,
assert(getTargetMachine().getRelocationModel() == Reloc::Static); assert(getTargetMachine().getRelocationModel() == Reloc::Static);
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
const GlobalAddressSDNode *GN = cast<GlobalAddressSDNode>(Op); const GlobalAddressSDNode *GN = cast<GlobalAddressSDNode>(Op);
const GlobalValue *GV = GN->getGlobal(); const GlobalValue *GV = GN->getGlobal();
@ -1885,7 +1885,7 @@ AArch64TargetLowering::LowerGlobalAddressELFSmall(SDValue Op,
assert(getTargetMachine().getCodeModel() == CodeModel::Small); assert(getTargetMachine().getCodeModel() == CodeModel::Small);
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
const GlobalAddressSDNode *GN = cast<GlobalAddressSDNode>(Op); const GlobalAddressSDNode *GN = cast<GlobalAddressSDNode>(Op);
const GlobalValue *GV = GN->getGlobal(); const GlobalValue *GV = GN->getGlobal();
unsigned Alignment = GV->getAlignment(); unsigned Alignment = GV->getAlignment();
@ -1978,7 +1978,7 @@ AArch64TargetLowering::LowerGlobalAddressELF(SDValue Op,
SDValue AArch64TargetLowering::LowerTLSDescCall(SDValue SymAddr, SDValue AArch64TargetLowering::LowerTLSDescCall(SDValue SymAddr,
SDValue DescAddr, SDValue DescAddr,
DebugLoc DL, SDLoc DL,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
@ -2033,7 +2033,7 @@ AArch64TargetLowering::LowerGlobalTLSAddress(SDValue Op,
SDValue TPOff; SDValue TPOff;
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
const GlobalValue *GV = GA->getGlobal(); const GlobalValue *GV = GA->getGlobal();
SDValue ThreadBase = DAG.getNode(AArch64ISD::THREAD_POINTER, DL, PtrVT); SDValue ThreadBase = DAG.getNode(AArch64ISD::THREAD_POINTER, DL, PtrVT);
@ -2134,7 +2134,7 @@ AArch64TargetLowering::LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG,
SDValue SDValue
AArch64TargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const { AArch64TargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
JumpTableSDNode *JT = cast<JumpTableSDNode>(Op); JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
DebugLoc dl = JT->getDebugLoc(); SDLoc dl(JT);
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
// When compiling PIC, jump tables get put in the code section so a static // When compiling PIC, jump tables get put in the code section so a static
@ -2161,7 +2161,7 @@ AArch64TargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
// (SELECT_CC lhs, rhs, iftrue, iffalse, condcode) // (SELECT_CC lhs, rhs, iftrue, iffalse, condcode)
SDValue SDValue
AArch64TargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const { AArch64TargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue LHS = Op.getOperand(0); SDValue LHS = Op.getOperand(0);
SDValue RHS = Op.getOperand(1); SDValue RHS = Op.getOperand(1);
SDValue IfTrue = Op.getOperand(2); SDValue IfTrue = Op.getOperand(2);
@ -2217,7 +2217,7 @@ AArch64TargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
// (SELECT testbit, iftrue, iffalse) // (SELECT testbit, iftrue, iffalse)
SDValue SDValue
AArch64TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const { AArch64TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue TheBit = Op.getOperand(0); SDValue TheBit = Op.getOperand(0);
SDValue IfTrue = Op.getOperand(1); SDValue IfTrue = Op.getOperand(1);
SDValue IfFalse = Op.getOperand(2); SDValue IfFalse = Op.getOperand(2);
@ -2239,7 +2239,7 @@ AArch64TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
// (SETCC lhs, rhs, condcode) // (SETCC lhs, rhs, condcode)
SDValue SDValue
AArch64TargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const { AArch64TargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue LHS = Op.getOperand(0); SDValue LHS = Op.getOperand(0);
SDValue RHS = Op.getOperand(1); SDValue RHS = Op.getOperand(1);
ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get(); ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
@ -2298,7 +2298,7 @@ AArch64TargetLowering::LowerVACOPY(SDValue Op, SelectionDAG &DAG) const {
// We have to make sure we copy the entire structure: 8+8+8+4+4 = 32 bytes // We have to make sure we copy the entire structure: 8+8+8+4+4 = 32 bytes
// rather than just 8. // rather than just 8.
return DAG.getMemcpy(Op.getOperand(0), Op.getDebugLoc(), return DAG.getMemcpy(Op.getOperand(0), SDLoc(Op),
Op.getOperand(1), Op.getOperand(2), Op.getOperand(1), Op.getOperand(2),
DAG.getConstant(32, MVT::i32), 8, false, false, DAG.getConstant(32, MVT::i32), 8, false, false,
MachinePointerInfo(DestSV), MachinePointerInfo(SrcSV)); MachinePointerInfo(DestSV), MachinePointerInfo(SrcSV));
@ -2311,7 +2311,7 @@ AArch64TargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
AArch64MachineFunctionInfo *FuncInfo AArch64MachineFunctionInfo *FuncInfo
= MF.getInfo<AArch64MachineFunctionInfo>(); = MF.getInfo<AArch64MachineFunctionInfo>();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue VAList = Op.getOperand(1); SDValue VAList = Op.getOperand(1);
@ -2410,7 +2410,7 @@ static SDValue PerformANDCombine(SDNode *N,
TargetLowering::DAGCombinerInfo &DCI) { TargetLowering::DAGCombinerInfo &DCI) {
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
// We're looking for an SRA/SHL pair which form an SBFX. // We're looking for an SRA/SHL pair which form an SBFX.
@ -2448,7 +2448,7 @@ static SDValue PerformANDCombine(SDNode *N,
/// a compatible SHL operation (unless they're already low). This function /// a compatible SHL operation (unless they're already low). This function
/// checks that condition and returns the least-significant bit that's /// checks that condition and returns the least-significant bit that's
/// intended. If the operation not a field preparation, -1 is returned. /// intended. If the operation not a field preparation, -1 is returned.
static int32_t getLSBForBFI(SelectionDAG &DAG, DebugLoc DL, EVT VT, static int32_t getLSBForBFI(SelectionDAG &DAG, SDLoc DL, EVT VT,
SDValue &MaskedVal, uint64_t Mask) { SDValue &MaskedVal, uint64_t Mask) {
if (!isShiftedMask_64(Mask)) if (!isShiftedMask_64(Mask))
return -1; return -1;
@ -2524,7 +2524,7 @@ static SDValue tryCombineToBFI(SDNode *N,
TargetLowering::DAGCombinerInfo &DCI, TargetLowering::DAGCombinerInfo &DCI,
const AArch64Subtarget *Subtarget) { const AArch64Subtarget *Subtarget) {
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
assert(N->getOpcode() == ISD::OR && "Unexpected root"); assert(N->getOpcode() == ISD::OR && "Unexpected root");
@ -2605,7 +2605,7 @@ static SDValue tryCombineToLargerBFI(SDNode *N,
TargetLowering::DAGCombinerInfo &DCI, TargetLowering::DAGCombinerInfo &DCI,
const AArch64Subtarget *Subtarget) { const AArch64Subtarget *Subtarget) {
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
// First job is to hunt for a MaskedBFI on either the left or right. Swap // First job is to hunt for a MaskedBFI on either the left or right. Swap
@ -2687,7 +2687,7 @@ static bool findEXTRHalf(SDValue N, SDValue &Src, uint32_t &ShiftAmount,
static SDValue tryCombineToEXTR(SDNode *N, static SDValue tryCombineToEXTR(SDNode *N,
TargetLowering::DAGCombinerInfo &DCI) { TargetLowering::DAGCombinerInfo &DCI) {
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
assert(N->getOpcode() == ISD::OR && "Unexpected root"); assert(N->getOpcode() == ISD::OR && "Unexpected root");
@ -2759,7 +2759,7 @@ static SDValue PerformSRACombine(SDNode *N,
TargetLowering::DAGCombinerInfo &DCI) { TargetLowering::DAGCombinerInfo &DCI) {
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
// We're looking for an SRA/SHL pair which form an SBFX. // We're looking for an SRA/SHL pair which form an SBFX.
@ -2899,7 +2899,7 @@ AArch64TargetLowering::LowerAsmOperandForConstraint(SDValue Op,
case 'S': { case 'S': {
// An absolute symbolic address or label reference. // An absolute symbolic address or label reference.
if (const GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Op)) { if (const GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Op)) {
Result = DAG.getTargetGlobalAddress(GA->getGlobal(), Op.getDebugLoc(), Result = DAG.getTargetGlobalAddress(GA->getGlobal(), SDLoc(Op),
GA->getValueType(0)); GA->getValueType(0));
} else if (const BlockAddressSDNode *BA } else if (const BlockAddressSDNode *BA
= dyn_cast<BlockAddressSDNode>(Op)) { = dyn_cast<BlockAddressSDNode>(Op)) {

12
lib/Target/AArch64/AArch64ISelLowering.h
View File

@ -130,14 +130,14 @@ public:
SDValue LowerFormalArguments(SDValue Chain, SDValue LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue LowerReturn(SDValue Chain, SDValue LowerReturn(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const; SDLoc dl, SelectionDAG &DAG) const;
SDValue LowerCall(CallLoweringInfo &CLI, SDValue LowerCall(CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
@ -145,11 +145,11 @@ public:
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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
void SaveVarArgRegisters(CCState &CCInfo, SelectionDAG &DAG, void SaveVarArgRegisters(CCState &CCInfo, SelectionDAG &DAG,
DebugLoc DL, SDValue &Chain) const; SDLoc DL, SDValue &Chain) const;
/// IsEligibleForTailCallOptimization - Check whether the call is eligible /// IsEligibleForTailCallOptimization - Check whether the call is eligible
@ -181,7 +181,7 @@ public:
bool isLegalICmpImmediate(int64_t Val) const; bool isLegalICmpImmediate(int64_t Val) const;
SDValue getSelectableIntSetCC(SDValue LHS, SDValue RHS, ISD::CondCode CC, SDValue getSelectableIntSetCC(SDValue LHS, SDValue RHS, ISD::CondCode CC,
SDValue &A64cc, SelectionDAG &DAG, DebugLoc &dl) const; SDValue &A64cc, SelectionDAG &DAG, SDLoc &dl) const;
virtual MachineBasicBlock * virtual MachineBasicBlock *
EmitInstrWithCustomInserter(MachineInstr *MI, MachineBasicBlock *MBB) const; EmitInstrWithCustomInserter(MachineInstr *MI, MachineBasicBlock *MBB) const;
@ -216,7 +216,7 @@ public:
SDValue LowerGlobalAddressELFLarge(SDValue Op, SelectionDAG &DAG) const; SDValue LowerGlobalAddressELFLarge(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerGlobalAddressELF(SDValue Op, SelectionDAG &DAG) const; SDValue LowerGlobalAddressELF(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerTLSDescCall(SDValue SymAddr, SDValue DescAddr, DebugLoc DL, SDValue LowerTLSDescCall(SDValue SymAddr, SDValue DescAddr, SDLoc DL,
SelectionDAG &DAG) const; SelectionDAG &DAG) const;
SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const; SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG, bool IsSigned) const; SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG, bool IsSigned) const;

52
lib/Target/ARM/ARMISelDAGToDAG.cpp
View File

@ -402,12 +402,12 @@ void ARMDAGToDAGISel::PreprocessISelDAG() {
} }
// Now make the transformation. // Now make the transformation.
Srl = CurDAG->getNode(ISD::SRL, Srl.getDebugLoc(), MVT::i32, Srl = CurDAG->getNode(ISD::SRL, SDLoc(Srl), MVT::i32,
Srl.getOperand(0), Srl.getOperand(0),
CurDAG->getConstant(Srl_imm+TZ, MVT::i32)); CurDAG->getConstant(Srl_imm+TZ, MVT::i32));
N1 = CurDAG->getNode(ISD::AND, N1.getDebugLoc(), MVT::i32, N1 = CurDAG->getNode(ISD::AND, SDLoc(N1), MVT::i32,
Srl, CurDAG->getConstant(And_imm, MVT::i32)); Srl, CurDAG->getConstant(And_imm, MVT::i32));
N1 = CurDAG->getNode(ISD::SHL, N1.getDebugLoc(), MVT::i32, N1 = CurDAG->getNode(ISD::SHL, SDLoc(N1), MVT::i32,
N1, CurDAG->getConstant(TZ, MVT::i32)); N1, CurDAG->getConstant(TZ, MVT::i32));
CurDAG->UpdateNodeOperands(N, N0, N1); CurDAG->UpdateNodeOperands(N, N0, N1);
} }
@ -1468,14 +1468,14 @@ SDNode *ARMDAGToDAGISel::SelectARMIndexedLoad(SDNode *N) {
SDValue Base = LD->getBasePtr(); SDValue Base = LD->getBasePtr();
SDValue Ops[]= { Base, AMOpc, getAL(CurDAG), SDValue Ops[]= { Base, AMOpc, getAL(CurDAG),
CurDAG->getRegister(0, MVT::i32), Chain }; CurDAG->getRegister(0, MVT::i32), Chain };
return CurDAG->getMachineNode(Opcode, N->getDebugLoc(), MVT::i32, return CurDAG->getMachineNode(Opcode, SDLoc(N), MVT::i32,
MVT::i32, MVT::Other, Ops); MVT::i32, MVT::Other, Ops);
} else { } else {
SDValue Chain = LD->getChain(); SDValue Chain = LD->getChain();
SDValue Base = LD->getBasePtr(); SDValue Base = LD->getBasePtr();
SDValue Ops[]= { Base, Offset, AMOpc, getAL(CurDAG), SDValue Ops[]= { Base, Offset, AMOpc, getAL(CurDAG),
CurDAG->getRegister(0, MVT::i32), Chain }; CurDAG->getRegister(0, MVT::i32), Chain };
return CurDAG->getMachineNode(Opcode, N->getDebugLoc(), MVT::i32, return CurDAG->getMachineNode(Opcode, SDLoc(N), MVT::i32,
MVT::i32, MVT::Other, Ops); MVT::i32, MVT::Other, Ops);
} }
} }
@ -1524,7 +1524,7 @@ SDNode *ARMDAGToDAGISel::SelectT2IndexedLoad(SDNode *N) {
SDValue Base = LD->getBasePtr(); SDValue Base = LD->getBasePtr();
SDValue Ops[]= { Base, Offset, getAL(CurDAG), SDValue Ops[]= { Base, Offset, getAL(CurDAG),
CurDAG->getRegister(0, MVT::i32), Chain }; CurDAG->getRegister(0, MVT::i32), Chain };
return CurDAG->getMachineNode(Opcode, N->getDebugLoc(), MVT::i32, MVT::i32, return CurDAG->getMachineNode(Opcode, SDLoc(N), MVT::i32, MVT::i32,
MVT::Other, Ops); MVT::Other, Ops);
} }
@ -1533,7 +1533,7 @@ SDNode *ARMDAGToDAGISel::SelectT2IndexedLoad(SDNode *N) {
/// \brief Form a GPRPair pseudo register from a pair of GPR regs. /// \brief Form a GPRPair pseudo register from a pair of GPR regs.
SDNode *ARMDAGToDAGISel::createGPRPairNode(EVT VT, SDValue V0, SDValue V1) { SDNode *ARMDAGToDAGISel::createGPRPairNode(EVT VT, SDValue V0, SDValue V1) {
DebugLoc dl = V0.getNode()->getDebugLoc(); SDLoc dl(V0.getNode());
SDValue RegClass = SDValue RegClass =
CurDAG->getTargetConstant(ARM::GPRPairRegClassID, MVT::i32); CurDAG->getTargetConstant(ARM::GPRPairRegClassID, MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::gsub_0, MVT::i32); SDValue SubReg0 = CurDAG->getTargetConstant(ARM::gsub_0, MVT::i32);
@ -1544,7 +1544,7 @@ SDNode *ARMDAGToDAGISel::createGPRPairNode(EVT VT, SDValue V0, SDValue V1) {
/// \brief Form a D register from a pair of S registers. /// \brief Form a D register from a pair of S registers.
SDNode *ARMDAGToDAGISel::createSRegPairNode(EVT VT, SDValue V0, SDValue V1) { SDNode *ARMDAGToDAGISel::createSRegPairNode(EVT VT, SDValue V0, SDValue V1) {
DebugLoc dl = V0.getNode()->getDebugLoc(); SDLoc dl(V0.getNode());
SDValue RegClass = SDValue RegClass =
CurDAG->getTargetConstant(ARM::DPR_VFP2RegClassID, MVT::i32); CurDAG->getTargetConstant(ARM::DPR_VFP2RegClassID, MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::ssub_0, MVT::i32); SDValue SubReg0 = CurDAG->getTargetConstant(ARM::ssub_0, MVT::i32);
@ -1555,7 +1555,7 @@ SDNode *ARMDAGToDAGISel::createSRegPairNode(EVT VT, SDValue V0, SDValue V1) {
/// \brief Form a quad register from a pair of D registers. /// \brief Form a quad register from a pair of D registers.
SDNode *ARMDAGToDAGISel::createDRegPairNode(EVT VT, SDValue V0, SDValue V1) { SDNode *ARMDAGToDAGISel::createDRegPairNode(EVT VT, SDValue V0, SDValue V1) {
DebugLoc dl = V0.getNode()->getDebugLoc(); SDLoc dl(V0.getNode());
SDValue RegClass = CurDAG->getTargetConstant(ARM::QPRRegClassID, MVT::i32); SDValue RegClass = CurDAG->getTargetConstant(ARM::QPRRegClassID, MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::dsub_0, MVT::i32); SDValue SubReg0 = CurDAG->getTargetConstant(ARM::dsub_0, MVT::i32);
SDValue SubReg1 = CurDAG->getTargetConstant(ARM::dsub_1, MVT::i32); SDValue SubReg1 = CurDAG->getTargetConstant(ARM::dsub_1, MVT::i32);
@ -1565,7 +1565,7 @@ SDNode *ARMDAGToDAGISel::createDRegPairNode(EVT VT, SDValue V0, SDValue V1) {
/// \brief Form 4 consecutive D registers from a pair of Q registers. /// \brief Form 4 consecutive D registers from a pair of Q registers.
SDNode *ARMDAGToDAGISel::createQRegPairNode(EVT VT, SDValue V0, SDValue V1) { SDNode *ARMDAGToDAGISel::createQRegPairNode(EVT VT, SDValue V0, SDValue V1) {
DebugLoc dl = V0.getNode()->getDebugLoc(); SDLoc dl(V0.getNode());
SDValue RegClass = CurDAG->getTargetConstant(ARM::QQPRRegClassID, MVT::i32); SDValue RegClass = CurDAG->getTargetConstant(ARM::QQPRRegClassID, MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::qsub_0, MVT::i32); SDValue SubReg0 = CurDAG->getTargetConstant(ARM::qsub_0, MVT::i32);
SDValue SubReg1 = CurDAG->getTargetConstant(ARM::qsub_1, MVT::i32); SDValue SubReg1 = CurDAG->getTargetConstant(ARM::qsub_1, MVT::i32);
@ -1576,7 +1576,7 @@ SDNode *ARMDAGToDAGISel::createQRegPairNode(EVT VT, SDValue V0, SDValue V1) {
/// \brief Form 4 consecutive S registers. /// \brief Form 4 consecutive S registers.
SDNode *ARMDAGToDAGISel::createQuadSRegsNode(EVT VT, SDValue V0, SDValue V1, SDNode *ARMDAGToDAGISel::createQuadSRegsNode(EVT VT, SDValue V0, SDValue V1,
SDValue V2, SDValue V3) { SDValue V2, SDValue V3) {
DebugLoc dl = V0.getNode()->getDebugLoc(); SDLoc dl(V0.getNode());
SDValue RegClass = SDValue RegClass =
CurDAG->getTargetConstant(ARM::QPR_VFP2RegClassID, MVT::i32); CurDAG->getTargetConstant(ARM::QPR_VFP2RegClassID, MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::ssub_0, MVT::i32); SDValue SubReg0 = CurDAG->getTargetConstant(ARM::ssub_0, MVT::i32);
@ -1591,7 +1591,7 @@ SDNode *ARMDAGToDAGISel::createQuadSRegsNode(EVT VT, SDValue V0, SDValue V1,
/// \brief Form 4 consecutive D registers. /// \brief Form 4 consecutive D registers.
SDNode *ARMDAGToDAGISel::createQuadDRegsNode(EVT VT, SDValue V0, SDValue V1, SDNode *ARMDAGToDAGISel::createQuadDRegsNode(EVT VT, SDValue V0, SDValue V1,
SDValue V2, SDValue V3) { SDValue V2, SDValue V3) {
DebugLoc dl = V0.getNode()->getDebugLoc(); SDLoc dl(V0.getNode());
SDValue RegClass = CurDAG->getTargetConstant(ARM::QQPRRegClassID, MVT::i32); SDValue RegClass = CurDAG->getTargetConstant(ARM::QQPRRegClassID, MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::dsub_0, MVT::i32); SDValue SubReg0 = CurDAG->getTargetConstant(ARM::dsub_0, MVT::i32);
SDValue SubReg1 = CurDAG->getTargetConstant(ARM::dsub_1, MVT::i32); SDValue SubReg1 = CurDAG->getTargetConstant(ARM::dsub_1, MVT::i32);
@ -1605,7 +1605,7 @@ SDNode *ARMDAGToDAGISel::createQuadDRegsNode(EVT VT, SDValue V0, SDValue V1,
/// \brief Form 4 consecutive Q registers. /// \brief Form 4 consecutive Q registers.
SDNode *ARMDAGToDAGISel::createQuadQRegsNode(EVT VT, SDValue V0, SDValue V1, SDNode *ARMDAGToDAGISel::createQuadQRegsNode(EVT VT, SDValue V0, SDValue V1,
SDValue V2, SDValue V3) { SDValue V2, SDValue V3) {
DebugLoc dl = V0.getNode()->getDebugLoc(); SDLoc dl(V0.getNode());
SDValue RegClass = CurDAG->getTargetConstant(ARM::QQQQPRRegClassID, MVT::i32); SDValue RegClass = CurDAG->getTargetConstant(ARM::QQQQPRRegClassID, MVT::i32);
SDValue SubReg0 = CurDAG->getTargetConstant(ARM::qsub_0, MVT::i32); SDValue SubReg0 = CurDAG->getTargetConstant(ARM::qsub_0, MVT::i32);
SDValue SubReg1 = CurDAG->getTargetConstant(ARM::qsub_1, MVT::i32); SDValue SubReg1 = CurDAG->getTargetConstant(ARM::qsub_1, MVT::i32);
@ -1689,7 +1689,7 @@ SDNode *ARMDAGToDAGISel::SelectVLD(SDNode *N, bool isUpdating, unsigned NumVecs,
const uint16_t *QOpcodes0, const uint16_t *QOpcodes0,
const uint16_t *QOpcodes1) { const uint16_t *QOpcodes1) {
assert(NumVecs >= 1 && NumVecs <= 4 && "VLD NumVecs out-of-range"); assert(NumVecs >= 1 && NumVecs <= 4 && "VLD NumVecs out-of-range");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue MemAddr, Align; SDValue MemAddr, Align;
unsigned AddrOpIdx = isUpdating ? 1 : 2; unsigned AddrOpIdx = isUpdating ? 1 : 2;
@ -1821,7 +1821,7 @@ SDNode *ARMDAGToDAGISel::SelectVST(SDNode *N, bool isUpdating, unsigned NumVecs,
const uint16_t *QOpcodes0, const uint16_t *QOpcodes0,
const uint16_t *QOpcodes1) { const uint16_t *QOpcodes1) {
assert(NumVecs >= 1 && NumVecs <= 4 && "VST NumVecs out-of-range"); assert(NumVecs >= 1 && NumVecs <= 4 && "VST NumVecs out-of-range");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue MemAddr, Align; SDValue MemAddr, Align;
unsigned AddrOpIdx = isUpdating ? 1 : 2; unsigned AddrOpIdx = isUpdating ? 1 : 2;
@ -1966,7 +1966,7 @@ SDNode *ARMDAGToDAGISel::SelectVLDSTLane(SDNode *N, bool IsLoad,
const uint16_t *DOpcodes, const uint16_t *DOpcodes,
const uint16_t *QOpcodes) { const uint16_t *QOpcodes) {
assert(NumVecs >=2 && NumVecs <= 4 && "VLDSTLane NumVecs out-of-range"); assert(NumVecs >=2 && NumVecs <= 4 && "VLDSTLane NumVecs out-of-range");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue MemAddr, Align; SDValue MemAddr, Align;
unsigned AddrOpIdx = isUpdating ? 1 : 2; unsigned AddrOpIdx = isUpdating ? 1 : 2;
@ -2084,7 +2084,7 @@ SDNode *ARMDAGToDAGISel::SelectVLDDup(SDNode *N, bool isUpdating,
unsigned NumVecs, unsigned NumVecs,
const uint16_t *Opcodes) { const uint16_t *Opcodes) {
assert(NumVecs >=2 && NumVecs <= 4 && "VLDDup NumVecs out-of-range"); assert(NumVecs >=2 && NumVecs <= 4 && "VLDDup NumVecs out-of-range");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue MemAddr, Align; SDValue MemAddr, Align;
if (!SelectAddrMode6(N, N->getOperand(1), MemAddr, Align)) if (!SelectAddrMode6(N, N->getOperand(1), MemAddr, Align))
@ -2166,7 +2166,7 @@ SDNode *ARMDAGToDAGISel::SelectVLDDup(SDNode *N, bool isUpdating,
SDNode *ARMDAGToDAGISel::SelectVTBL(SDNode *N, bool IsExt, unsigned NumVecs, SDNode *ARMDAGToDAGISel::SelectVTBL(SDNode *N, bool IsExt, unsigned NumVecs,
unsigned Opc) { unsigned Opc) {
assert(NumVecs >= 2 && NumVecs <= 4 && "VTBL NumVecs out-of-range"); assert(NumVecs >= 2 && NumVecs <= 4 && "VTBL NumVecs out-of-range");
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
unsigned FirstTblReg = IsExt ? 2 : 1; unsigned FirstTblReg = IsExt ? 2 : 1;
@ -2536,7 +2536,7 @@ SDNode *ARMDAGToDAGISel::SelectAtomic64(SDNode *Node, unsigned Opc) {
Ops.push_back(Node->getOperand(0)); // Chain Ops.push_back(Node->getOperand(0)); // Chain
MachineSDNode::mmo_iterator MemOp = MF->allocateMemRefsArray(1); MachineSDNode::mmo_iterator MemOp = MF->allocateMemRefsArray(1);
MemOp[0] = cast<MemSDNode>(Node)->getMemOperand(); MemOp[0] = cast<MemSDNode>(Node)->getMemOperand();
SDNode *ResNode = CurDAG->getMachineNode(Opc, Node->getDebugLoc(), SDNode *ResNode = CurDAG->getMachineNode(Opc, SDLoc(Node),
MVT::i32, MVT::i32, MVT::Other, MVT::i32, MVT::i32, MVT::Other,
Ops); Ops);
cast<MachineSDNode>(ResNode)->setMemRefs(MemOp, MemOp + 1); cast<MachineSDNode>(ResNode)->setMemRefs(MemOp, MemOp + 1);
@ -2544,7 +2544,7 @@ SDNode *ARMDAGToDAGISel::SelectAtomic64(SDNode *Node, unsigned Opc) {
} }
SDNode *ARMDAGToDAGISel::Select(SDNode *N) { SDNode *ARMDAGToDAGISel::Select(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (N->isMachineOpcode()) if (N->isMachineOpcode())
return NULL; // Already selected. return NULL; // Already selected.
@ -3121,7 +3121,7 @@ SDNode *ARMDAGToDAGISel::Select(SDNode *N) {
case Intrinsic::arm_ldrexd: { case Intrinsic::arm_ldrexd: {
SDValue MemAddr = N->getOperand(2); SDValue MemAddr = N->getOperand(2);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Chain = N->getOperand(0); SDValue Chain = N->getOperand(0);
bool isThumb = Subtarget->isThumb() && Subtarget->hasThumb2(); bool isThumb = Subtarget->isThumb() && Subtarget->hasThumb2();
@ -3179,7 +3179,7 @@ SDNode *ARMDAGToDAGISel::Select(SDNode *N) {
} }
case Intrinsic::arm_strexd: { case Intrinsic::arm_strexd: {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Chain = N->getOperand(0); SDValue Chain = N->getOperand(0);
SDValue Val0 = N->getOperand(2); SDValue Val0 = N->getOperand(2);
SDValue Val1 = N->getOperand(3); SDValue Val1 = N->getOperand(3);
@ -3383,7 +3383,7 @@ SDNode *ARMDAGToDAGISel::Select(SDNode *N) {
} }
case ARMISD::VTBL1: { case ARMISD::VTBL1: {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
SmallVector<SDValue, 6> Ops; SmallVector<SDValue, 6> Ops;
@ -3394,7 +3394,7 @@ SDNode *ARMDAGToDAGISel::Select(SDNode *N) {
return CurDAG->getMachineNode(ARM::VTBL1, dl, VT, Ops); return CurDAG->getMachineNode(ARM::VTBL1, dl, VT, Ops);
} }
case ARMISD::VTBL2: { case ARMISD::VTBL2: {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
// Form a REG_SEQUENCE to force register allocation. // Form a REG_SEQUENCE to force register allocation.
@ -3462,7 +3462,7 @@ SDNode *ARMDAGToDAGISel::SelectInlineAsm(SDNode *N){
if (AsmString.find(":H}") == StringRef::npos) if (AsmString.find(":H}") == StringRef::npos)
return NULL; return NULL;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Glue = N->getOperand(NumOps-1); SDValue Glue = N->getOperand(NumOps-1);
// Glue node will be appended late. // Glue node will be appended late.
@ -3567,7 +3567,7 @@ SDNode *ARMDAGToDAGISel::SelectInlineAsm(SDNode *N){
if (!Changed) if (!Changed)
return NULL; return NULL;
SDValue New = CurDAG->getNode(ISD::INLINEASM, N->getDebugLoc(), SDValue New = CurDAG->getNode(ISD::INLINEASM, SDLoc(N),
CurDAG->getVTList(MVT::Other, MVT::Glue), &AsmNodeOperands[0], CurDAG->getVTList(MVT::Other, MVT::Glue), &AsmNodeOperands[0],
AsmNodeOperands.size()); AsmNodeOperands.size());
New->setNodeId(-1); New->setNodeId(-1);

230
lib/Target/ARM/ARMISelLowering.cpp
View File

@ -1235,7 +1235,7 @@ SDValue
ARMTargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag, ARMTargetLowering::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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals, SmallVectorImpl<SDValue> &InVals,
bool isThisReturn, SDValue ThisVal) const { bool isThisReturn, SDValue ThisVal) const {
@ -1316,7 +1316,7 @@ ARMTargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
SDValue SDValue
ARMTargetLowering::LowerMemOpCallTo(SDValue Chain, ARMTargetLowering::LowerMemOpCallTo(SDValue Chain,
SDValue StackPtr, SDValue Arg, SDValue StackPtr, SDValue Arg,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
const CCValAssign &VA, const CCValAssign &VA,
ISD::ArgFlagsTy Flags) const { ISD::ArgFlagsTy Flags) const {
unsigned LocMemOffset = VA.getLocMemOffset(); unsigned LocMemOffset = VA.getLocMemOffset();
@ -1327,7 +1327,7 @@ ARMTargetLowering::LowerMemOpCallTo(SDValue Chain,
false, false, 0); false, false, 0);
} }
void ARMTargetLowering::PassF64ArgInRegs(DebugLoc dl, SelectionDAG &DAG, void ARMTargetLowering::PassF64ArgInRegs(SDLoc dl, SelectionDAG &DAG,
SDValue Chain, SDValue &Arg, SDValue Chain, SDValue &Arg,
RegsToPassVector &RegsToPass, RegsToPassVector &RegsToPass,
CCValAssign &VA, CCValAssign &NextVA, CCValAssign &VA, CCValAssign &NextVA,
@ -1359,7 +1359,7 @@ SDValue
ARMTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI, ARMTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG; SelectionDAG &DAG = CLI.DAG;
DebugLoc &dl = CLI.DL; SDLoc &dl = CLI.DL;
SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs; SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
SmallVector<SDValue, 32> &OutVals = CLI.OutVals; SmallVector<SDValue, 32> &OutVals = CLI.OutVals;
SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins; SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;
@ -2021,7 +2021,7 @@ ARMTargetLowering::LowerReturn(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const { SDLoc dl, SelectionDAG &DAG) const {
// CCValAssign - represent the assignment of the return value to a location. // CCValAssign - represent the assignment of the return value to a location.
SmallVector<CCValAssign, 16> RVLocs; SmallVector<CCValAssign, 16> RVLocs;
@ -2188,7 +2188,7 @@ bool ARMTargetLowering::mayBeEmittedAsTailCall(CallInst *CI) const {
static SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) { static SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) {
EVT PtrVT = Op.getValueType(); EVT PtrVT = Op.getValueType();
// FIXME there is no actual debug info here // FIXME there is no actual debug info here
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op); ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
SDValue Res; SDValue Res;
if (CP->isMachineConstantPoolEntry()) if (CP->isMachineConstantPoolEntry())
@ -2209,7 +2209,7 @@ SDValue ARMTargetLowering::LowerBlockAddress(SDValue Op,
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>(); ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
unsigned ARMPCLabelIndex = 0; unsigned ARMPCLabelIndex = 0;
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress(); const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
Reloc::Model RelocM = getTargetMachine().getRelocationModel(); Reloc::Model RelocM = getTargetMachine().getRelocationModel();
@ -2238,7 +2238,7 @@ SDValue ARMTargetLowering::LowerBlockAddress(SDValue Op,
SDValue SDValue
ARMTargetLowering::LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA, ARMTargetLowering::LowerToTLSGeneralDynamicModel(GlobalAddressSDNode *GA,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc dl = GA->getDebugLoc(); SDLoc dl(GA);
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
unsigned char PCAdj = Subtarget->isThumb() ? 4 : 8; unsigned char PCAdj = Subtarget->isThumb() ? 4 : 8;
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
@ -2281,7 +2281,7 @@ ARMTargetLowering::LowerToTLSExecModels(GlobalAddressSDNode *GA,
SelectionDAG &DAG, SelectionDAG &DAG,
TLSModel::Model model) const { TLSModel::Model model) const {
const GlobalValue *GV = GA->getGlobal(); const GlobalValue *GV = GA->getGlobal();
DebugLoc dl = GA->getDebugLoc(); SDLoc dl(GA);
SDValue Offset; SDValue Offset;
SDValue Chain = DAG.getEntryNode(); SDValue Chain = DAG.getEntryNode();
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
@ -2351,7 +2351,7 @@ ARMTargetLowering::LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const {
SDValue ARMTargetLowering::LowerGlobalAddressELF(SDValue Op, SDValue ARMTargetLowering::LowerGlobalAddressELF(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal(); const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
if (getTargetMachine().getRelocationModel() == Reloc::PIC_) { if (getTargetMachine().getRelocationModel() == Reloc::PIC_) {
bool UseGOTOFF = GV->hasLocalLinkage() || GV->hasHiddenVisibility(); bool UseGOTOFF = GV->hasLocalLinkage() || GV->hasHiddenVisibility();
@ -2394,7 +2394,7 @@ SDValue ARMTargetLowering::LowerGlobalAddressELF(SDValue Op,
SDValue ARMTargetLowering::LowerGlobalAddressDarwin(SDValue Op, SDValue ARMTargetLowering::LowerGlobalAddressDarwin(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal(); const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
Reloc::Model RelocM = getTargetMachine().getRelocationModel(); Reloc::Model RelocM = getTargetMachine().getRelocationModel();
@ -2459,7 +2459,7 @@ SDValue ARMTargetLowering::LowerGLOBAL_OFFSET_TABLE(SDValue Op,
ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>(); ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
unsigned ARMPCLabelIndex = AFI->createPICLabelUId(); unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned PCAdj = Subtarget->isThumb() ? 4 : 8; unsigned PCAdj = Subtarget->isThumb() ? 4 : 8;
ARMConstantPoolValue *CPV = ARMConstantPoolValue *CPV =
ARMConstantPoolSymbol::Create(*DAG.getContext(), "_GLOBAL_OFFSET_TABLE_", ARMConstantPoolSymbol::Create(*DAG.getContext(), "_GLOBAL_OFFSET_TABLE_",
@ -2475,7 +2475,7 @@ SDValue ARMTargetLowering::LowerGLOBAL_OFFSET_TABLE(SDValue Op,
SDValue SDValue
ARMTargetLowering::LowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const { ARMTargetLowering::LowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue Val = DAG.getConstant(0, MVT::i32); SDValue Val = DAG.getConstant(0, MVT::i32);
return DAG.getNode(ARMISD::EH_SJLJ_SETJMP, dl, return DAG.getNode(ARMISD::EH_SJLJ_SETJMP, dl,
DAG.getVTList(MVT::i32, MVT::Other), Op.getOperand(0), DAG.getVTList(MVT::i32, MVT::Other), Op.getOperand(0),
@ -2484,7 +2484,7 @@ ARMTargetLowering::LowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const {
SDValue SDValue
ARMTargetLowering::LowerEH_SJLJ_LONGJMP(SDValue Op, SelectionDAG &DAG) const { ARMTargetLowering::LowerEH_SJLJ_LONGJMP(SDValue Op, SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
return DAG.getNode(ARMISD::EH_SJLJ_LONGJMP, dl, MVT::Other, Op.getOperand(0), return DAG.getNode(ARMISD::EH_SJLJ_LONGJMP, dl, MVT::Other, Op.getOperand(0),
Op.getOperand(1), DAG.getConstant(0, MVT::i32)); Op.getOperand(1), DAG.getConstant(0, MVT::i32));
} }
@ -2493,7 +2493,7 @@ SDValue
ARMTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG, ARMTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG,
const ARMSubtarget *Subtarget) const { const ARMSubtarget *Subtarget) const {
unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue(); unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
switch (IntNo) { switch (IntNo) {
default: return SDValue(); // Don't custom lower most intrinsics. default: return SDValue(); // Don't custom lower most intrinsics.
case Intrinsic::arm_thread_pointer: { case Intrinsic::arm_thread_pointer: {
@ -2529,7 +2529,7 @@ ARMTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG,
case Intrinsic::arm_neon_vmullu: { case Intrinsic::arm_neon_vmullu: {
unsigned NewOpc = (IntNo == Intrinsic::arm_neon_vmulls) unsigned NewOpc = (IntNo == Intrinsic::arm_neon_vmulls)
? ARMISD::VMULLs : ARMISD::VMULLu; ? ARMISD::VMULLs : ARMISD::VMULLu;
return DAG.getNode(NewOpc, Op.getDebugLoc(), Op.getValueType(), return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
Op.getOperand(1), Op.getOperand(2)); Op.getOperand(1), Op.getOperand(2));
} }
} }
@ -2538,7 +2538,7 @@ ARMTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG,
static SDValue LowerATOMIC_FENCE(SDValue Op, SelectionDAG &DAG, static SDValue LowerATOMIC_FENCE(SDValue Op, SelectionDAG &DAG,
const ARMSubtarget *Subtarget) { const ARMSubtarget *Subtarget) {
// FIXME: handle "fence singlethread" more efficiently. // FIXME: handle "fence singlethread" more efficiently.
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
if (!Subtarget->hasDataBarrier()) { if (!Subtarget->hasDataBarrier()) {
// Some ARMv6 cpus can support data barriers with an mcr instruction. // Some ARMv6 cpus can support data barriers with an mcr instruction.
// Thumb1 and pre-v6 ARM mode use a libcall instead and should never get // Thumb1 and pre-v6 ARM mode use a libcall instead and should never get
@ -2561,7 +2561,7 @@ static SDValue LowerPREFETCH(SDValue Op, SelectionDAG &DAG,
// Just preserve the chain. // Just preserve the chain.
return Op.getOperand(0); return Op.getOperand(0);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned isRead = ~cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue() & 1; unsigned isRead = ~cast<ConstantSDNode>(Op.getOperand(2))->getZExtValue() & 1;
if (!isRead && if (!isRead &&
(!Subtarget->hasV7Ops() || !Subtarget->hasMPExtension())) (!Subtarget->hasV7Ops() || !Subtarget->hasMPExtension()))
@ -2586,7 +2586,7 @@ static SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) {
// vastart just stores the address of the VarArgsFrameIndex slot into the // vastart just stores the address of the VarArgsFrameIndex slot into the
// memory location argument. // memory location argument.
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(); EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT); SDValue FR = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT);
const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue(); const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
@ -2597,7 +2597,7 @@ static SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG) {
SDValue SDValue
ARMTargetLowering::GetF64FormalArgument(CCValAssign &VA, CCValAssign &NextVA, ARMTargetLowering::GetF64FormalArgument(CCValAssign &VA, CCValAssign &NextVA,
SDValue &Root, SelectionDAG &DAG, SDValue &Root, SelectionDAG &DAG,
DebugLoc dl) const { SDLoc dl) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>(); ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
@ -2686,7 +2686,7 @@ ARMTargetLowering::computeRegArea(CCState &CCInfo, MachineFunction &MF,
// Return: The frame index registers were stored into. // Return: The frame index registers were stored into.
int int
ARMTargetLowering::StoreByValRegs(CCState &CCInfo, SelectionDAG &DAG, ARMTargetLowering::StoreByValRegs(CCState &CCInfo, SelectionDAG &DAG,
DebugLoc dl, SDValue &Chain, SDLoc dl, SDValue &Chain,
const Value *OrigArg, const Value *OrigArg,
unsigned InRegsParamRecordIdx, unsigned InRegsParamRecordIdx,
unsigned OffsetFromOrigArg, unsigned OffsetFromOrigArg,
@ -2779,7 +2779,7 @@ ARMTargetLowering::StoreByValRegs(CCState &CCInfo, SelectionDAG &DAG,
// Setup stack frame, the va_list pointer will start from. // Setup stack frame, the va_list pointer will start from.
void void
ARMTargetLowering::VarArgStyleRegisters(CCState &CCInfo, SelectionDAG &DAG, ARMTargetLowering::VarArgStyleRegisters(CCState &CCInfo, SelectionDAG &DAG,
DebugLoc dl, SDValue &Chain, SDLoc dl, SDValue &Chain,
unsigned ArgOffset, unsigned ArgOffset,
bool ForceMutable) const { bool ForceMutable) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
@ -2802,7 +2802,7 @@ ARMTargetLowering::LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> const SmallVectorImpl<ISD::InputArg>
&Ins, &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) SmallVectorImpl<SDValue> &InVals)
const { const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
@ -2982,7 +2982,7 @@ static bool isFloatingPointZero(SDValue Op) {
SDValue SDValue
ARMTargetLowering::getARMCmp(SDValue LHS, SDValue RHS, ISD::CondCode CC, ARMTargetLowering::getARMCmp(SDValue LHS, SDValue RHS, ISD::CondCode CC,
SDValue &ARMcc, SelectionDAG &DAG, SDValue &ARMcc, SelectionDAG &DAG,
DebugLoc dl) const { SDLoc dl) const {
if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS.getNode())) { if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS.getNode())) {
unsigned C = RHSC->getZExtValue(); unsigned C = RHSC->getZExtValue();
if (!isLegalICmpImmediate(C)) { if (!isLegalICmpImmediate(C)) {
@ -3040,7 +3040,7 @@ ARMTargetLowering::getARMCmp(SDValue LHS, SDValue RHS, ISD::CondCode CC,
/// Returns a appropriate VFP CMP (fcmp{s|d}+fmstat) for the given operands. /// Returns a appropriate VFP CMP (fcmp{s|d}+fmstat) for the given operands.
SDValue SDValue
ARMTargetLowering::getVFPCmp(SDValue LHS, SDValue RHS, SelectionDAG &DAG, ARMTargetLowering::getVFPCmp(SDValue LHS, SDValue RHS, SelectionDAG &DAG,
DebugLoc dl) const { SDLoc dl) const {
SDValue Cmp; SDValue Cmp;
if (!isFloatingPointZero(RHS)) if (!isFloatingPointZero(RHS))
Cmp = DAG.getNode(ARMISD::CMPFP, dl, MVT::Glue, LHS, RHS); Cmp = DAG.getNode(ARMISD::CMPFP, dl, MVT::Glue, LHS, RHS);
@ -3054,7 +3054,7 @@ ARMTargetLowering::getVFPCmp(SDValue LHS, SDValue RHS, SelectionDAG &DAG,
SDValue SDValue
ARMTargetLowering::duplicateCmp(SDValue Cmp, SelectionDAG &DAG) const { ARMTargetLowering::duplicateCmp(SDValue Cmp, SelectionDAG &DAG) const {
unsigned Opc = Cmp.getOpcode(); unsigned Opc = Cmp.getOpcode();
DebugLoc DL = Cmp.getDebugLoc(); SDLoc DL(Cmp);
if (Opc == ARMISD::CMP || Opc == ARMISD::CMPZ) if (Opc == ARMISD::CMP || Opc == ARMISD::CMPZ)
return DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0),Cmp.getOperand(1)); return DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0),Cmp.getOperand(1));
@ -3074,7 +3074,7 @@ SDValue ARMTargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
SDValue Cond = Op.getOperand(0); SDValue Cond = Op.getOperand(0);
SDValue SelectTrue = Op.getOperand(1); SDValue SelectTrue = Op.getOperand(1);
SDValue SelectFalse = Op.getOperand(2); SDValue SelectFalse = Op.getOperand(2);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// Convert: // Convert:
// //
@ -3129,7 +3129,7 @@ SDValue ARMTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get(); ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
SDValue TrueVal = Op.getOperand(2); SDValue TrueVal = Op.getOperand(2);
SDValue FalseVal = Op.getOperand(3); SDValue FalseVal = Op.getOperand(3);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
if (LHS.getValueType() == MVT::i32) { if (LHS.getValueType() == MVT::i32) {
SDValue ARMcc; SDValue ARMcc;
@ -3184,7 +3184,7 @@ static SDValue bitcastf32Toi32(SDValue Op, SelectionDAG &DAG) {
return DAG.getConstant(0, MVT::i32); return DAG.getConstant(0, MVT::i32);
if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Op)) if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Op))
return DAG.getLoad(MVT::i32, Op.getDebugLoc(), return DAG.getLoad(MVT::i32, SDLoc(Op),
Ld->getChain(), Ld->getBasePtr(), Ld->getPointerInfo(), Ld->getChain(), Ld->getBasePtr(), Ld->getPointerInfo(),
Ld->isVolatile(), Ld->isNonTemporal(), Ld->isVolatile(), Ld->isNonTemporal(),
Ld->isInvariant(), Ld->getAlignment()); Ld->isInvariant(), Ld->getAlignment());
@ -3202,7 +3202,7 @@ static void expandf64Toi32(SDValue Op, SelectionDAG &DAG,
if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Op)) { if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Op)) {
SDValue Ptr = Ld->getBasePtr(); SDValue Ptr = Ld->getBasePtr();
RetVal1 = DAG.getLoad(MVT::i32, Op.getDebugLoc(), RetVal1 = DAG.getLoad(MVT::i32, SDLoc(Op),
Ld->getChain(), Ptr, Ld->getChain(), Ptr,
Ld->getPointerInfo(), Ld->getPointerInfo(),
Ld->isVolatile(), Ld->isNonTemporal(), Ld->isVolatile(), Ld->isNonTemporal(),
@ -3210,9 +3210,9 @@ static void expandf64Toi32(SDValue Op, SelectionDAG &DAG,
EVT PtrType = Ptr.getValueType(); EVT PtrType = Ptr.getValueType();
unsigned NewAlign = MinAlign(Ld->getAlignment(), 4); unsigned NewAlign = MinAlign(Ld->getAlignment(), 4);
SDValue NewPtr = DAG.getNode(ISD::ADD, Op.getDebugLoc(), SDValue NewPtr = DAG.getNode(ISD::ADD, SDLoc(Op),
PtrType, Ptr, DAG.getConstant(4, PtrType)); PtrType, Ptr, DAG.getConstant(4, PtrType));
RetVal2 = DAG.getLoad(MVT::i32, Op.getDebugLoc(), RetVal2 = DAG.getLoad(MVT::i32, SDLoc(Op),
Ld->getChain(), NewPtr, Ld->getChain(), NewPtr,
Ld->getPointerInfo().getWithOffset(4), Ld->getPointerInfo().getWithOffset(4),
Ld->isVolatile(), Ld->isNonTemporal(), Ld->isVolatile(), Ld->isNonTemporal(),
@ -3232,7 +3232,7 @@ ARMTargetLowering::OptimizeVFPBrcond(SDValue Op, SelectionDAG &DAG) const {
SDValue LHS = Op.getOperand(2); SDValue LHS = Op.getOperand(2);
SDValue RHS = Op.getOperand(3); SDValue RHS = Op.getOperand(3);
SDValue Dest = Op.getOperand(4); SDValue Dest = Op.getOperand(4);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
bool LHSSeenZero = false; bool LHSSeenZero = false;
bool LHSOk = canChangeToInt(LHS, LHSSeenZero, Subtarget); bool LHSOk = canChangeToInt(LHS, LHSSeenZero, Subtarget);
@ -3282,7 +3282,7 @@ SDValue ARMTargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG) const {
SDValue LHS = Op.getOperand(2); SDValue LHS = Op.getOperand(2);
SDValue RHS = Op.getOperand(3); SDValue RHS = Op.getOperand(3);
SDValue Dest = Op.getOperand(4); SDValue Dest = Op.getOperand(4);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
if (LHS.getValueType() == MVT::i32) { if (LHS.getValueType() == MVT::i32) {
SDValue ARMcc; SDValue ARMcc;
@ -3323,7 +3323,7 @@ SDValue ARMTargetLowering::LowerBR_JT(SDValue Op, SelectionDAG &DAG) const {
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Table = Op.getOperand(1); SDValue Table = Op.getOperand(1);
SDValue Index = Op.getOperand(2); SDValue Index = Op.getOperand(2);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
EVT PTy = getPointerTy(); EVT PTy = getPointerTy();
JumpTableSDNode *JT = cast<JumpTableSDNode>(Table); JumpTableSDNode *JT = cast<JumpTableSDNode>(Table);
@ -3359,7 +3359,7 @@ SDValue ARMTargetLowering::LowerBR_JT(SDValue Op, SelectionDAG &DAG) const {
static SDValue LowerVectorFP_TO_INT(SDValue Op, SelectionDAG &DAG) { static SDValue LowerVectorFP_TO_INT(SDValue Op, SelectionDAG &DAG) {
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
if (Op.getValueType().getVectorElementType() == MVT::i32) { if (Op.getValueType().getVectorElementType() == MVT::i32) {
if (Op.getOperand(0).getValueType().getVectorElementType() == MVT::f32) if (Op.getOperand(0).getValueType().getVectorElementType() == MVT::f32)
@ -3381,7 +3381,7 @@ static SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG) {
if (VT.isVector()) if (VT.isVector())
return LowerVectorFP_TO_INT(Op, DAG); return LowerVectorFP_TO_INT(Op, DAG);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned Opc; unsigned Opc;
switch (Op.getOpcode()) { switch (Op.getOpcode()) {
@ -3399,7 +3399,7 @@ static SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG) {
static SDValue LowerVectorINT_TO_FP(SDValue Op, SelectionDAG &DAG) { static SDValue LowerVectorINT_TO_FP(SDValue Op, SelectionDAG &DAG) {
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
if (Op.getOperand(0).getValueType().getVectorElementType() == MVT::i32) { if (Op.getOperand(0).getValueType().getVectorElementType() == MVT::i32) {
if (VT.getVectorElementType() == MVT::f32) if (VT.getVectorElementType() == MVT::f32)
@ -3435,7 +3435,7 @@ static SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) {
if (VT.isVector()) if (VT.isVector())
return LowerVectorINT_TO_FP(Op, DAG); return LowerVectorINT_TO_FP(Op, DAG);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned Opc; unsigned Opc;
switch (Op.getOpcode()) { switch (Op.getOpcode()) {
@ -3456,7 +3456,7 @@ SDValue ARMTargetLowering::LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const {
// Implement fcopysign with a fabs and a conditional fneg. // Implement fcopysign with a fabs and a conditional fneg.
SDValue Tmp0 = Op.getOperand(0); SDValue Tmp0 = Op.getOperand(0);
SDValue Tmp1 = Op.getOperand(1); SDValue Tmp1 = Op.getOperand(1);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
EVT SrcVT = Tmp1.getValueType(); EVT SrcVT = Tmp1.getValueType();
bool InGPR = Tmp0.getOpcode() == ISD::BITCAST || bool InGPR = Tmp0.getOpcode() == ISD::BITCAST ||
@ -3540,7 +3540,7 @@ SDValue ARMTargetLowering::LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const{
MFI->setReturnAddressIsTaken(true); MFI->setReturnAddressIsTaken(true);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue(); unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
if (Depth) { if (Depth) {
SDValue FrameAddr = LowerFRAMEADDR(Op, DAG); SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
@ -3560,7 +3560,7 @@ SDValue ARMTargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
MFI->setFrameAddressIsTaken(true); MFI->setFrameAddressIsTaken(true);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); // FIXME probably not meaningful SDLoc dl(Op); // FIXME probably not meaningful
unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue(); unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
unsigned FrameReg = (Subtarget->isThumb() || Subtarget->isTargetDarwin()) unsigned FrameReg = (Subtarget->isThumb() || Subtarget->isTargetDarwin())
? ARM::R7 : ARM::R11; ? ARM::R7 : ARM::R11;
@ -3589,7 +3589,7 @@ static SDValue ExpandVectorExtension(SDNode *N, SelectionDAG &DAG) {
SrcVT.getSizeInBits()*8 != DestVT.getSizeInBits()) SrcVT.getSizeInBits()*8 != DestVT.getSizeInBits())
return SDValue(); return SDValue();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
unsigned SrcEltSize = SrcVT.getVectorElementType().getSizeInBits(); unsigned SrcEltSize = SrcVT.getVectorElementType().getSizeInBits();
unsigned DestEltSize = DestVT.getVectorElementType().getSizeInBits(); unsigned DestEltSize = DestVT.getVectorElementType().getSizeInBits();
unsigned NumElts = SrcVT.getVectorNumElements(); unsigned NumElts = SrcVT.getVectorNumElements();
@ -3620,7 +3620,7 @@ static SDValue ExpandVectorExtension(SDNode *N, SelectionDAG &DAG) {
/// vectors), since the legalizer won't know what to do with that. /// vectors), since the legalizer won't know what to do with that.
static SDValue ExpandBITCAST(SDNode *N, SelectionDAG &DAG) { static SDValue ExpandBITCAST(SDNode *N, SelectionDAG &DAG) {
const TargetLowering &TLI = DAG.getTargetLoweringInfo(); const TargetLowering &TLI = DAG.getTargetLoweringInfo();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Op = N->getOperand(0); SDValue Op = N->getOperand(0);
// This function is only supposed to be called for i64 types, either as the // This function is only supposed to be called for i64 types, either as the
@ -3657,7 +3657,7 @@ static SDValue ExpandBITCAST(SDNode *N, SelectionDAG &DAG) {
/// not support i64 elements, so sometimes the zero vectors will need to be /// not support i64 elements, so sometimes the zero vectors will need to be
/// explicitly constructed. Regardless, use a canonical VMOV to create the /// explicitly constructed. Regardless, use a canonical VMOV to create the
/// zero vector. /// zero vector.
static SDValue getZeroVector(EVT VT, SelectionDAG &DAG, DebugLoc dl) { static SDValue getZeroVector(EVT VT, SelectionDAG &DAG, SDLoc dl) {
assert(VT.isVector() && "Expected a vector type"); assert(VT.isVector() && "Expected a vector type");
// The canonical modified immediate encoding of a zero vector is....0! // The canonical modified immediate encoding of a zero vector is....0!
SDValue EncodedVal = DAG.getTargetConstant(0, MVT::i32); SDValue EncodedVal = DAG.getTargetConstant(0, MVT::i32);
@ -3673,7 +3673,7 @@ SDValue ARMTargetLowering::LowerShiftRightParts(SDValue Op,
assert(Op.getNumOperands() == 3 && "Not a double-shift!"); assert(Op.getNumOperands() == 3 && "Not a double-shift!");
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
unsigned VTBits = VT.getSizeInBits(); unsigned VTBits = VT.getSizeInBits();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue ShOpLo = Op.getOperand(0); SDValue ShOpLo = Op.getOperand(0);
SDValue ShOpHi = Op.getOperand(1); SDValue ShOpHi = Op.getOperand(1);
SDValue ShAmt = Op.getOperand(2); SDValue ShAmt = Op.getOperand(2);
@ -3709,7 +3709,7 @@ SDValue ARMTargetLowering::LowerShiftLeftParts(SDValue Op,
assert(Op.getNumOperands() == 3 && "Not a double-shift!"); assert(Op.getNumOperands() == 3 && "Not a double-shift!");
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
unsigned VTBits = VT.getSizeInBits(); unsigned VTBits = VT.getSizeInBits();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue ShOpLo = Op.getOperand(0); SDValue ShOpLo = Op.getOperand(0);
SDValue ShOpHi = Op.getOperand(1); SDValue ShOpHi = Op.getOperand(1);
SDValue ShAmt = Op.getOperand(2); SDValue ShAmt = Op.getOperand(2);
@ -3742,7 +3742,7 @@ SDValue ARMTargetLowering::LowerFLT_ROUNDS_(SDValue Op,
// The ARM rounding mode value to FLT_ROUNDS mapping is 0->1, 1->2, 2->3, 3->0 // The ARM rounding mode value to FLT_ROUNDS mapping is 0->1, 1->2, 2->3, 3->0
// The formula we use to implement this is (((FPSCR + 1 << 22) >> 22) & 3) // The formula we use to implement this is (((FPSCR + 1 << 22) >> 22) & 3)
// so that the shift + and get folded into a bitfield extract. // so that the shift + and get folded into a bitfield extract.
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue FPSCR = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::i32, SDValue FPSCR = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::i32,
DAG.getConstant(Intrinsic::arm_get_fpscr, DAG.getConstant(Intrinsic::arm_get_fpscr,
MVT::i32)); MVT::i32));
@ -3757,7 +3757,7 @@ SDValue ARMTargetLowering::LowerFLT_ROUNDS_(SDValue Op,
static SDValue LowerCTTZ(SDNode *N, SelectionDAG &DAG, static SDValue LowerCTTZ(SDNode *N, SelectionDAG &DAG,
const ARMSubtarget *ST) { const ARMSubtarget *ST) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (!ST->hasV6T2Ops()) if (!ST->hasV6T2Ops())
return SDValue(); return SDValue();
@ -3781,7 +3781,7 @@ static SDValue LowerCTTZ(SDNode *N, SelectionDAG &DAG,
/// vuzp: = [k0 k1 k2 k3 k0 k1 k2 k3] each ki is 8-bits) /// vuzp: = [k0 k1 k2 k3 k0 k1 k2 k3] each ki is 8-bits)
static SDValue getCTPOP16BitCounts(SDNode *N, SelectionDAG &DAG) { static SDValue getCTPOP16BitCounts(SDNode *N, SelectionDAG &DAG) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
EVT VT8Bit = VT.is64BitVector() ? MVT::v8i8 : MVT::v16i8; EVT VT8Bit = VT.is64BitVector() ? MVT::v8i8 : MVT::v16i8;
SDValue N0 = DAG.getNode(ISD::BITCAST, DL, VT8Bit, N->getOperand(0)); SDValue N0 = DAG.getNode(ISD::BITCAST, DL, VT8Bit, N->getOperand(0));
@ -3803,7 +3803,7 @@ static SDValue getCTPOP16BitCounts(SDNode *N, SelectionDAG &DAG) {
/// v4i16:Extracted = [k0 k1 k2 k3 ] /// v4i16:Extracted = [k0 k1 k2 k3 ]
static SDValue lowerCTPOP16BitElements(SDNode *N, SelectionDAG &DAG) { static SDValue lowerCTPOP16BitElements(SDNode *N, SelectionDAG &DAG) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
SDValue BitCounts = getCTPOP16BitCounts(N, DAG); SDValue BitCounts = getCTPOP16BitCounts(N, DAG);
if (VT.is64BitVector()) { if (VT.is64BitVector()) {
@ -3838,7 +3838,7 @@ static SDValue lowerCTPOP16BitElements(SDNode *N, SelectionDAG &DAG) {
/// ///
static SDValue lowerCTPOP32BitElements(SDNode *N, SelectionDAG &DAG) { static SDValue lowerCTPOP32BitElements(SDNode *N, SelectionDAG &DAG) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
EVT VT16Bit = VT.is64BitVector() ? MVT::v4i16 : MVT::v8i16; EVT VT16Bit = VT.is64BitVector() ? MVT::v4i16 : MVT::v8i16;
@ -3877,7 +3877,7 @@ static SDValue LowerCTPOP(SDNode *N, SelectionDAG &DAG,
static SDValue LowerShift(SDNode *N, SelectionDAG &DAG, static SDValue LowerShift(SDNode *N, SelectionDAG &DAG,
const ARMSubtarget *ST) { const ARMSubtarget *ST) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (!VT.isVector()) if (!VT.isVector())
return SDValue(); return SDValue();
@ -3912,7 +3912,7 @@ static SDValue LowerShift(SDNode *N, SelectionDAG &DAG,
static SDValue Expand64BitShift(SDNode *N, SelectionDAG &DAG, static SDValue Expand64BitShift(SDNode *N, SelectionDAG &DAG,
const ARMSubtarget *ST) { const ARMSubtarget *ST) {
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// We can get here for a node like i32 = ISD::SHL i32, i64 // We can get here for a node like i32 = ISD::SHL i32, i64
if (VT != MVT::i64) if (VT != MVT::i64)
@ -3958,7 +3958,7 @@ static SDValue LowerVSETCC(SDValue Op, SelectionDAG &DAG) {
SDValue CC = Op.getOperand(2); SDValue CC = Op.getOperand(2);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get(); ISD::CondCode SetCCOpcode = cast<CondCodeSDNode>(CC)->get();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
if (Op.getOperand(1).getValueType().isFloatingPoint()) { if (Op.getOperand(1).getValueType().isFloatingPoint()) {
switch (SetCCOpcode) { switch (SetCCOpcode) {
@ -4227,7 +4227,7 @@ SDValue ARMTargetLowering::LowerConstantFP(SDValue Op, SelectionDAG &DAG,
APFloat FPVal = CFP->getValueAPF(); APFloat FPVal = CFP->getValueAPF();
int ImmVal = ARM_AM::getFP32Imm(FPVal); int ImmVal = ARM_AM::getFP32Imm(FPVal);
if (ImmVal != -1) { if (ImmVal != -1) {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue NewVal = DAG.getTargetConstant(ImmVal, MVT::i32); SDValue NewVal = DAG.getTargetConstant(ImmVal, MVT::i32);
SDValue VecConstant = DAG.getNode(ARMISD::VMOVFPIMM, DL, MVT::v2f32, SDValue VecConstant = DAG.getNode(ARMISD::VMOVFPIMM, DL, MVT::v2f32,
NewVal); NewVal);
@ -4241,7 +4241,7 @@ SDValue ARMTargetLowering::LowerConstantFP(SDValue Op, SelectionDAG &DAG,
SDValue NewVal = isNEONModifiedImm(iVal, 0, 32, DAG, VMovVT, false, SDValue NewVal = isNEONModifiedImm(iVal, 0, 32, DAG, VMovVT, false,
VMOVModImm); VMOVModImm);
if (NewVal != SDValue()) { if (NewVal != SDValue()) {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue VecConstant = DAG.getNode(ARMISD::VMOVIMM, DL, VMovVT, SDValue VecConstant = DAG.getNode(ARMISD::VMOVIMM, DL, VMovVT,
NewVal); NewVal);
SDValue VecFConstant = DAG.getNode(ISD::BITCAST, DL, MVT::v2f32, SDValue VecFConstant = DAG.getNode(ISD::BITCAST, DL, MVT::v2f32,
@ -4254,7 +4254,7 @@ SDValue ARMTargetLowering::LowerConstantFP(SDValue Op, SelectionDAG &DAG,
NewVal = isNEONModifiedImm(~iVal & 0xffffffff, 0, 32, DAG, VMovVT, false, NewVal = isNEONModifiedImm(~iVal & 0xffffffff, 0, 32, DAG, VMovVT, false,
VMVNModImm); VMVNModImm);
if (NewVal != SDValue()) { if (NewVal != SDValue()) {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue VecConstant = DAG.getNode(ARMISD::VMVNIMM, DL, VMovVT, NewVal); SDValue VecConstant = DAG.getNode(ARMISD::VMVNIMM, DL, VMovVT, NewVal);
SDValue VecFConstant = DAG.getNode(ISD::BITCAST, DL, MVT::v2f32, SDValue VecFConstant = DAG.getNode(ISD::BITCAST, DL, MVT::v2f32,
VecConstant); VecConstant);
@ -4514,7 +4514,7 @@ static bool isReverseMask(ArrayRef<int> M, EVT VT) {
// instruction, return an SDValue of such a constant (will become a MOV // instruction, return an SDValue of such a constant (will become a MOV
// instruction). Otherwise return null. // instruction). Otherwise return null.
static SDValue IsSingleInstrConstant(SDValue N, SelectionDAG &DAG, static SDValue IsSingleInstrConstant(SDValue N, SelectionDAG &DAG,
const ARMSubtarget *ST, DebugLoc dl) { const ARMSubtarget *ST, SDLoc dl) {
uint64_t Val; uint64_t Val;
if (!isa<ConstantSDNode>(N)) if (!isa<ConstantSDNode>(N))
return SDValue(); return SDValue();
@ -4535,7 +4535,7 @@ static SDValue IsSingleInstrConstant(SDValue N, SelectionDAG &DAG,
SDValue ARMTargetLowering::LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG, SDValue ARMTargetLowering::LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG,
const ARMSubtarget *ST) const { const ARMSubtarget *ST) const {
BuildVectorSDNode *BVN = cast<BuildVectorSDNode>(Op.getNode()); BuildVectorSDNode *BVN = cast<BuildVectorSDNode>(Op.getNode());
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
APInt SplatBits, SplatUndef; APInt SplatBits, SplatUndef;
@ -4725,7 +4725,7 @@ SDValue ARMTargetLowering::LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG,
// shuffle in combination with VEXTs. // shuffle in combination with VEXTs.
SDValue ARMTargetLowering::ReconstructShuffle(SDValue Op, SDValue ARMTargetLowering::ReconstructShuffle(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
unsigned NumElts = VT.getVectorNumElements(); unsigned NumElts = VT.getVectorNumElements();
@ -4914,7 +4914,7 @@ ARMTargetLowering::isShuffleMaskLegal(const SmallVectorImpl<int> &M,
/// the specified operations to build the shuffle. /// the specified operations to build the shuffle.
static SDValue GeneratePerfectShuffle(unsigned PFEntry, SDValue LHS, static SDValue GeneratePerfectShuffle(unsigned PFEntry, SDValue LHS,
SDValue RHS, SelectionDAG &DAG, SDValue RHS, SelectionDAG &DAG,
DebugLoc dl) { SDLoc dl) {
unsigned OpNum = (PFEntry >> 26) & 0x0F; unsigned OpNum = (PFEntry >> 26) & 0x0F;
unsigned LHSID = (PFEntry >> 13) & ((1 << 13)-1); unsigned LHSID = (PFEntry >> 13) & ((1 << 13)-1);
unsigned RHSID = (PFEntry >> 0) & ((1 << 13)-1); unsigned RHSID = (PFEntry >> 0) & ((1 << 13)-1);
@ -4994,7 +4994,7 @@ static SDValue LowerVECTOR_SHUFFLEv8i8(SDValue Op,
// Check to see if we can use the VTBL instruction. // Check to see if we can use the VTBL instruction.
SDValue V1 = Op.getOperand(0); SDValue V1 = Op.getOperand(0);
SDValue V2 = Op.getOperand(1); SDValue V2 = Op.getOperand(1);
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SmallVector<SDValue, 8> VTBLMask; SmallVector<SDValue, 8> VTBLMask;
for (ArrayRef<int>::iterator for (ArrayRef<int>::iterator
@ -5013,7 +5013,7 @@ static SDValue LowerVECTOR_SHUFFLEv8i8(SDValue Op,
static SDValue LowerReverse_VECTOR_SHUFFLEv16i8_v8i16(SDValue Op, static SDValue LowerReverse_VECTOR_SHUFFLEv16i8_v8i16(SDValue Op,
SelectionDAG &DAG) { SelectionDAG &DAG) {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue OpLHS = Op.getOperand(0); SDValue OpLHS = Op.getOperand(0);
EVT VT = OpLHS.getValueType(); EVT VT = OpLHS.getValueType();
@ -5031,7 +5031,7 @@ static SDValue LowerReverse_VECTOR_SHUFFLEv16i8_v8i16(SDValue Op,
static SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) { static SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) {
SDValue V1 = Op.getOperand(0); SDValue V1 = Op.getOperand(0);
SDValue V2 = Op.getOperand(1); SDValue V2 = Op.getOperand(1);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(Op.getNode()); ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(Op.getNode());
@ -5195,7 +5195,7 @@ static SDValue LowerEXTRACT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) {
SDValue Vec = Op.getOperand(0); SDValue Vec = Op.getOperand(0);
if (Op.getValueType() == MVT::i32 && if (Op.getValueType() == MVT::i32 &&
Vec.getValueType().getVectorElementType().getSizeInBits() < 32) { Vec.getValueType().getVectorElementType().getSizeInBits() < 32) {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
return DAG.getNode(ARMISD::VGETLANEu, dl, MVT::i32, Vec, Lane); return DAG.getNode(ARMISD::VGETLANEu, dl, MVT::i32, Vec, Lane);
} }
@ -5207,7 +5207,7 @@ static SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) {
// two 64-bit vectors are concatenated to a 128-bit vector. // two 64-bit vectors are concatenated to a 128-bit vector.
assert(Op.getValueType().is128BitVector() && Op.getNumOperands() == 2 && assert(Op.getValueType().is128BitVector() && Op.getNumOperands() == 2 &&
"unexpected CONCAT_VECTORS"); "unexpected CONCAT_VECTORS");
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue Val = DAG.getUNDEF(MVT::v2f64); SDValue Val = DAG.getUNDEF(MVT::v2f64);
SDValue Op0 = Op.getOperand(0); SDValue Op0 = Op.getOperand(0);
SDValue Op1 = Op.getOperand(1); SDValue Op1 = Op.getOperand(1);
@ -5330,7 +5330,7 @@ static SDValue AddRequiredExtensionForVMULL(SDValue N, SelectionDAG &DAG,
// Must extend size to at least 64 bits to be used as an operand for VMULL. // Must extend size to at least 64 bits to be used as an operand for VMULL.
EVT NewVT = getExtensionTo64Bits(OrigTy); EVT NewVT = getExtensionTo64Bits(OrigTy);
return DAG.getNode(ExtOpcode, N->getDebugLoc(), NewVT, N); return DAG.getNode(ExtOpcode, SDLoc(N), NewVT, N);
} }
/// SkipLoadExtensionForVMULL - return a load of the original vector size that /// SkipLoadExtensionForVMULL - return a load of the original vector size that
@ -5343,7 +5343,7 @@ static SDValue SkipLoadExtensionForVMULL(LoadSDNode *LD, SelectionDAG& DAG) {
// The load already has the right type. // The load already has the right type.
if (ExtendedTy == LD->getMemoryVT()) if (ExtendedTy == LD->getMemoryVT())
return DAG.getLoad(LD->getMemoryVT(), LD->getDebugLoc(), LD->getChain(), return DAG.getLoad(LD->getMemoryVT(), SDLoc(LD), LD->getChain(),
LD->getBasePtr(), LD->getPointerInfo(), LD->isVolatile(), LD->getBasePtr(), LD->getPointerInfo(), LD->isVolatile(),
LD->isNonTemporal(), LD->isInvariant(), LD->isNonTemporal(), LD->isInvariant(),
LD->getAlignment()); LD->getAlignment());
@ -5351,7 +5351,7 @@ static SDValue SkipLoadExtensionForVMULL(LoadSDNode *LD, SelectionDAG& DAG) {
// We need to create a zextload/sextload. We cannot just create a load // We need to create a zextload/sextload. We cannot just create a load
// followed by a zext/zext node because LowerMUL is also run during normal // followed by a zext/zext node because LowerMUL is also run during normal
// operation legalization where we can't create illegal types. // operation legalization where we can't create illegal types.
return DAG.getExtLoad(LD->getExtensionType(), LD->getDebugLoc(), ExtendedTy, return DAG.getExtLoad(LD->getExtensionType(), SDLoc(LD), ExtendedTy,
LD->getChain(), LD->getBasePtr(), LD->getPointerInfo(), LD->getChain(), LD->getBasePtr(), LD->getPointerInfo(),
LD->getMemoryVT(), LD->isVolatile(), LD->getMemoryVT(), LD->isVolatile(),
LD->isNonTemporal(), LD->getAlignment()); LD->isNonTemporal(), LD->getAlignment());
@ -5380,7 +5380,7 @@ static SDValue SkipExtensionForVMULL(SDNode *N, SelectionDAG &DAG) {
assert(BVN->getOpcode() == ISD::BUILD_VECTOR && assert(BVN->getOpcode() == ISD::BUILD_VECTOR &&
BVN->getValueType(0) == MVT::v4i32 && "expected v4i32 BUILD_VECTOR"); BVN->getValueType(0) == MVT::v4i32 && "expected v4i32 BUILD_VECTOR");
unsigned LowElt = DAG.getTargetLoweringInfo().isBigEndian() ? 1 : 0; unsigned LowElt = DAG.getTargetLoweringInfo().isBigEndian() ? 1 : 0;
return DAG.getNode(ISD::BUILD_VECTOR, N->getDebugLoc(), MVT::v2i32, return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), MVT::v2i32,
BVN->getOperand(LowElt), BVN->getOperand(LowElt+2)); BVN->getOperand(LowElt), BVN->getOperand(LowElt+2));
} }
// Construct a new BUILD_VECTOR with elements truncated to half the size. // Construct a new BUILD_VECTOR with elements truncated to half the size.
@ -5397,7 +5397,7 @@ static SDValue SkipExtensionForVMULL(SDNode *N, SelectionDAG &DAG) {
// The values are implicitly truncated so sext vs. zext doesn't matter. // The values are implicitly truncated so sext vs. zext doesn't matter.
Ops.push_back(DAG.getConstant(CInt.zextOrTrunc(32), MVT::i32)); Ops.push_back(DAG.getConstant(CInt.zextOrTrunc(32), MVT::i32));
} }
return DAG.getNode(ISD::BUILD_VECTOR, N->getDebugLoc(), return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N),
MVT::getVectorVT(TruncVT, NumElts), Ops.data(), NumElts); MVT::getVectorVT(TruncVT, NumElts), Ops.data(), NumElts);
} }
@ -5469,7 +5469,7 @@ static SDValue LowerMUL(SDValue Op, SelectionDAG &DAG) {
} }
// Legalize to a VMULL instruction. // Legalize to a VMULL instruction.
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue Op0; SDValue Op0;
SDValue Op1 = SkipExtensionForVMULL(N1, DAG); SDValue Op1 = SkipExtensionForVMULL(N1, DAG);
if (!isMLA) { if (!isMLA) {
@ -5499,7 +5499,7 @@ static SDValue LowerMUL(SDValue Op, SelectionDAG &DAG) {
} }
static SDValue static SDValue
LowerSDIV_v4i8(SDValue X, SDValue Y, DebugLoc dl, SelectionDAG &DAG) { LowerSDIV_v4i8(SDValue X, SDValue Y, SDLoc dl, SelectionDAG &DAG) {
// Convert to float // Convert to float
// float4 xf = vcvt_f32_s32(vmovl_s16(a.lo)); // float4 xf = vcvt_f32_s32(vmovl_s16(a.lo));
// float4 yf = vcvt_f32_s32(vmovl_s16(b.lo)); // float4 yf = vcvt_f32_s32(vmovl_s16(b.lo));
@ -5528,7 +5528,7 @@ LowerSDIV_v4i8(SDValue X, SDValue Y, DebugLoc dl, SelectionDAG &DAG) {
} }
static SDValue static SDValue
LowerSDIV_v4i16(SDValue N0, SDValue N1, DebugLoc dl, SelectionDAG &DAG) { LowerSDIV_v4i16(SDValue N0, SDValue N1, SDLoc dl, SelectionDAG &DAG) {
SDValue N2; SDValue N2;
// Convert to float. // Convert to float.
// float4 yf = vcvt_f32_s32(vmovl_s16(y)); // float4 yf = vcvt_f32_s32(vmovl_s16(y));
@ -5569,7 +5569,7 @@ static SDValue LowerSDIV(SDValue Op, SelectionDAG &DAG) {
assert((VT == MVT::v4i16 || VT == MVT::v8i8) && assert((VT == MVT::v4i16 || VT == MVT::v8i8) &&
"unexpected type for custom-lowering ISD::SDIV"); "unexpected type for custom-lowering ISD::SDIV");
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue N0 = Op.getOperand(0); SDValue N0 = Op.getOperand(0);
SDValue N1 = Op.getOperand(1); SDValue N1 = Op.getOperand(1);
SDValue N2, N3; SDValue N2, N3;
@ -5604,7 +5604,7 @@ static SDValue LowerUDIV(SDValue Op, SelectionDAG &DAG) {
assert((VT == MVT::v4i16 || VT == MVT::v8i8) && assert((VT == MVT::v4i16 || VT == MVT::v8i8) &&
"unexpected type for custom-lowering ISD::UDIV"); "unexpected type for custom-lowering ISD::UDIV");
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue N0 = Op.getOperand(0); SDValue N0 = Op.getOperand(0);
SDValue N1 = Op.getOperand(1); SDValue N1 = Op.getOperand(1);
SDValue N2, N3; SDValue N2, N3;
@ -5688,9 +5688,9 @@ static SDValue LowerADDC_ADDE_SUBC_SUBE(SDValue Op, SelectionDAG &DAG) {
} }
if (!ExtraOp) if (!ExtraOp)
return DAG.getNode(Opc, Op->getDebugLoc(), VTs, Op.getOperand(0), return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
Op.getOperand(1)); Op.getOperand(1));
return DAG.getNode(Opc, Op->getDebugLoc(), VTs, Op.getOperand(0), return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
Op.getOperand(1), Op.getOperand(2)); Op.getOperand(1), Op.getOperand(2));
} }
@ -5707,7 +5707,7 @@ static SDValue LowerAtomicLoadStore(SDValue Op, SelectionDAG &DAG) {
static void static void
ReplaceATOMIC_OP_64(SDNode *Node, SmallVectorImpl<SDValue>& Results, ReplaceATOMIC_OP_64(SDNode *Node, SmallVectorImpl<SDValue>& Results,
SelectionDAG &DAG, unsigned NewOp) { SelectionDAG &DAG, unsigned NewOp) {
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
assert (Node->getValueType(0) == MVT::i64 && assert (Node->getValueType(0) == MVT::i64 &&
"Only know how to expand i64 atomics"); "Only know how to expand i64 atomics");
@ -5741,7 +5741,7 @@ static void ReplaceREADCYCLECOUNTER(SDNode *N,
SmallVectorImpl<SDValue> &Results, SmallVectorImpl<SDValue> &Results,
SelectionDAG &DAG, SelectionDAG &DAG,
const ARMSubtarget *Subtarget) { const ARMSubtarget *Subtarget) {
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
SDValue Cycles32, OutChain; SDValue Cycles32, OutChain;
if (Subtarget->hasPerfMon()) { if (Subtarget->hasPerfMon()) {
@ -7789,13 +7789,13 @@ SDValue combineSelectAndUse(SDNode *N, SDValue Slct, SDValue OtherOp,
// Slct is now know to be the desired identity constant when CC is true. // Slct is now know to be the desired identity constant when CC is true.
SDValue TrueVal = OtherOp; SDValue TrueVal = OtherOp;
SDValue FalseVal = DAG.getNode(N->getOpcode(), N->getDebugLoc(), VT, SDValue FalseVal = DAG.getNode(N->getOpcode(), SDLoc(N), VT,
OtherOp, NonConstantVal); OtherOp, NonConstantVal);
// Unless SwapSelectOps says CC should be false. // Unless SwapSelectOps says CC should be false.
if (SwapSelectOps) if (SwapSelectOps)
std::swap(TrueVal, FalseVal); std::swap(TrueVal, FalseVal);
return DAG.getNode(ISD::SELECT, N->getDebugLoc(), VT, return DAG.getNode(ISD::SELECT, SDLoc(N), VT,
CCOp, TrueVal, FalseVal); CCOp, TrueVal, FalseVal);
} }
@ -7902,9 +7902,9 @@ static SDValue AddCombineToVPADDL(SDNode *N, SDValue N0, SDValue N1,
llvm_unreachable("Invalid vector element type for padd optimization."); llvm_unreachable("Invalid vector element type for padd optimization.");
} }
SDValue tmp = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, N->getDebugLoc(), SDValue tmp = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, SDLoc(N),
widenType, &Ops[0], Ops.size()); widenType, &Ops[0], Ops.size());
return DAG.getNode(ISD::TRUNCATE, N->getDebugLoc(), VT, tmp); return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, tmp);
} }
static SDValue findMUL_LOHI(SDValue V) { static SDValue findMUL_LOHI(SDValue V) {
@ -8029,7 +8029,7 @@ static SDValue AddCombineTo64bitMLAL(SDNode *AddcNode,
Ops.push_back(*LowAdd); Ops.push_back(*LowAdd);
Ops.push_back(*HiAdd); Ops.push_back(*HiAdd);
SDValue MLALNode = DAG.getNode(FinalOpc, AddcNode->getDebugLoc(), SDValue MLALNode = DAG.getNode(FinalOpc, SDLoc(AddcNode),
DAG.getVTList(MVT::i32, MVT::i32), DAG.getVTList(MVT::i32, MVT::i32),
&Ops[0], Ops.size()); &Ops[0], Ops.size());
@ -8137,7 +8137,7 @@ static SDValue PerformVMULCombine(SDNode *N,
} }
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
SDValue N00 = N0->getOperand(0); SDValue N00 = N0->getOperand(0);
SDValue N01 = N0->getOperand(1); SDValue N01 = N0->getOperand(1);
return DAG.getNode(Opcode, DL, VT, return DAG.getNode(Opcode, DL, VT,
@ -8171,7 +8171,7 @@ static SDValue PerformMULCombine(SDNode *N,
ShiftAmt = ShiftAmt & (32 - 1); ShiftAmt = ShiftAmt & (32 - 1);
SDValue V = N->getOperand(0); SDValue V = N->getOperand(0);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
SDValue Res; SDValue Res;
MulAmt >>= ShiftAmt; MulAmt >>= ShiftAmt;
@ -8235,7 +8235,7 @@ static SDValue PerformANDCombine(SDNode *N,
// Attempt to use immediate-form VBIC // Attempt to use immediate-form VBIC
BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(N->getOperand(1)); BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(N->getOperand(1));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
@ -8278,7 +8278,7 @@ static SDValue PerformORCombine(SDNode *N,
const ARMSubtarget *Subtarget) { const ARMSubtarget *Subtarget) {
// Attempt to use immediate-form VORR // Attempt to use immediate-form VORR
BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(N->getOperand(1)); BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(N->getOperand(1));
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
@ -8353,7 +8353,7 @@ static SDValue PerformORCombine(SDNode *N,
if (Subtarget->isThumb1Only() || !Subtarget->hasV6T2Ops()) if (Subtarget->isThumb1Only() || !Subtarget->hasV6T2Ops())
return SDValue(); return SDValue();
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
// 1) or (and A, mask), val => ARMbfi A, val, mask // 1) or (and A, mask), val => ARMbfi A, val, mask
// iff (val & mask) == val // iff (val & mask) == val
// //
@ -8497,7 +8497,7 @@ static SDValue PerformBFICombine(SDNode *N,
unsigned Mask = (1 << Width)-1; unsigned Mask = (1 << Width)-1;
unsigned Mask2 = N11C->getZExtValue(); unsigned Mask2 = N11C->getZExtValue();
if ((Mask & (~Mask2)) == 0) if ((Mask & (~Mask2)) == 0)
return DCI.DAG.getNode(ARMISD::BFI, N->getDebugLoc(), N->getValueType(0), return DCI.DAG.getNode(ARMISD::BFI, SDLoc(N), N->getValueType(0),
N->getOperand(0), N1.getOperand(0), N->getOperand(0), N1.getOperand(0),
N->getOperand(2)); N->getOperand(2));
} }
@ -8523,7 +8523,7 @@ static SDValue PerformVMOVRRDCombine(SDNode *N,
LoadSDNode *LD = cast<LoadSDNode>(InNode); LoadSDNode *LD = cast<LoadSDNode>(InNode);
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc DL = LD->getDebugLoc(); SDLoc DL(LD);
SDValue BasePtr = LD->getBasePtr(); SDValue BasePtr = LD->getBasePtr();
SDValue NewLD1 = DAG.getLoad(MVT::i32, DL, LD->getChain(), BasePtr, SDValue NewLD1 = DAG.getLoad(MVT::i32, DL, LD->getChain(), BasePtr,
LD->getPointerInfo(), LD->isVolatile(), LD->getPointerInfo(), LD->isVolatile(),
@ -8560,7 +8560,7 @@ static SDValue PerformVMOVDRRCombine(SDNode *N, SelectionDAG &DAG) {
if (Op0.getOpcode() == ARMISD::VMOVRRD && if (Op0.getOpcode() == ARMISD::VMOVRRD &&
Op0.getNode() == Op1.getNode() && Op0.getNode() == Op1.getNode() &&
Op0.getResNo() == 0 && Op1.getResNo() == 1) Op0.getResNo() == 0 && Op1.getResNo() == 1)
return DAG.getNode(ISD::BITCAST, N->getDebugLoc(), return DAG.getNode(ISD::BITCAST, SDLoc(N),
N->getValueType(0), Op0.getOperand(0)); N->getValueType(0), Op0.getOperand(0));
return SDValue(); return SDValue();
} }
@ -8602,7 +8602,7 @@ static SDValue PerformSTORECombine(SDNode *N,
NumElems*SizeRatio); NumElems*SizeRatio);
assert(WideVecVT.getSizeInBits() == VT.getSizeInBits()); assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
DebugLoc DL = St->getDebugLoc(); SDLoc DL(St);
SDValue WideVec = DAG.getNode(ISD::BITCAST, DL, WideVecVT, StVal); SDValue WideVec = DAG.getNode(ISD::BITCAST, DL, WideVecVT, StVal);
SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1); SmallVector<int, 8> ShuffleVec(NumElems * SizeRatio, -1);
for (unsigned i = 0; i < NumElems; ++i) ShuffleVec[i] = i * SizeRatio; for (unsigned i = 0; i < NumElems; ++i) ShuffleVec[i] = i * SizeRatio;
@ -8663,7 +8663,7 @@ static SDValue PerformSTORECombine(SDNode *N,
if (StVal.getNode()->getOpcode() == ARMISD::VMOVDRR && if (StVal.getNode()->getOpcode() == ARMISD::VMOVDRR &&
StVal.getNode()->hasOneUse()) { StVal.getNode()->hasOneUse()) {
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc DL = St->getDebugLoc(); SDLoc DL(St);
SDValue BasePtr = St->getBasePtr(); SDValue BasePtr = St->getBasePtr();
SDValue NewST1 = DAG.getStore(St->getChain(), DL, SDValue NewST1 = DAG.getStore(St->getChain(), DL,
StVal.getNode()->getOperand(0), BasePtr, StVal.getNode()->getOperand(0), BasePtr,
@ -8685,14 +8685,14 @@ static SDValue PerformSTORECombine(SDNode *N,
// Bitcast an i64 store extracted from a vector to f64. // Bitcast an i64 store extracted from a vector to f64.
// Otherwise, the i64 value will be legalized to a pair of i32 values. // Otherwise, the i64 value will be legalized to a pair of i32 values.
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc dl = StVal.getDebugLoc(); SDLoc dl(StVal);
SDValue IntVec = StVal.getOperand(0); SDValue IntVec = StVal.getOperand(0);
EVT FloatVT = EVT::getVectorVT(*DAG.getContext(), MVT::f64, EVT FloatVT = EVT::getVectorVT(*DAG.getContext(), MVT::f64,
IntVec.getValueType().getVectorNumElements()); IntVec.getValueType().getVectorNumElements());
SDValue Vec = DAG.getNode(ISD::BITCAST, dl, FloatVT, IntVec); SDValue Vec = DAG.getNode(ISD::BITCAST, dl, FloatVT, IntVec);
SDValue ExtElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, SDValue ExtElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
Vec, StVal.getOperand(1)); Vec, StVal.getOperand(1));
dl = N->getDebugLoc(); dl = SDLoc(N);
SDValue V = DAG.getNode(ISD::BITCAST, dl, MVT::i64, ExtElt); SDValue V = DAG.getNode(ISD::BITCAST, dl, MVT::i64, ExtElt);
// Make the DAGCombiner fold the bitcasts. // Make the DAGCombiner fold the bitcasts.
DCI.AddToWorklist(Vec.getNode()); DCI.AddToWorklist(Vec.getNode());
@ -8738,7 +8738,7 @@ static SDValue PerformBUILD_VECTORCombine(SDNode *N,
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
if (VT.getVectorElementType() != MVT::i64 || !hasNormalLoadOperand(N)) if (VT.getVectorElementType() != MVT::i64 || !hasNormalLoadOperand(N))
return SDValue(); return SDValue();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SmallVector<SDValue, 8> Ops; SmallVector<SDValue, 8> Ops;
unsigned NumElts = VT.getVectorNumElements(); unsigned NumElts = VT.getVectorNumElements();
for (unsigned i = 0; i < NumElts; ++i) { for (unsigned i = 0; i < NumElts; ++i) {
@ -8765,7 +8765,7 @@ static SDValue PerformInsertEltCombine(SDNode *N,
return SDValue(); return SDValue();
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
EVT FloatVT = EVT::getVectorVT(*DAG.getContext(), MVT::f64, EVT FloatVT = EVT::getVectorVT(*DAG.getContext(), MVT::f64,
VT.getVectorNumElements()); VT.getVectorNumElements());
SDValue Vec = DAG.getNode(ISD::BITCAST, dl, FloatVT, N->getOperand(0)); SDValue Vec = DAG.getNode(ISD::BITCAST, dl, FloatVT, N->getOperand(0));
@ -8811,7 +8811,7 @@ static SDValue PerformVECTOR_SHUFFLECombine(SDNode *N, SelectionDAG &DAG) {
!TLI.isTypeLegal(Concat1Op1.getValueType())) !TLI.isTypeLegal(Concat1Op1.getValueType()))
return SDValue(); return SDValue();
SDValue NewConcat = DAG.getNode(ISD::CONCAT_VECTORS, N->getDebugLoc(), VT, SDValue NewConcat = DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT,
Op0.getOperand(0), Op1.getOperand(0)); Op0.getOperand(0), Op1.getOperand(0));
// Translate the shuffle mask. // Translate the shuffle mask.
SmallVector<int, 16> NewMask; SmallVector<int, 16> NewMask;
@ -8827,7 +8827,7 @@ static SDValue PerformVECTOR_SHUFFLECombine(SDNode *N, SelectionDAG &DAG) {
NewElt = HalfElts + MaskElt - NumElts; NewElt = HalfElts + MaskElt - NumElts;
NewMask.push_back(NewElt); NewMask.push_back(NewElt);
} }
return DAG.getVectorShuffle(VT, N->getDebugLoc(), NewConcat, return DAG.getVectorShuffle(VT, SDLoc(N), NewConcat,
DAG.getUNDEF(VT), NewMask.data()); DAG.getUNDEF(VT), NewMask.data());
} }
@ -8944,7 +8944,7 @@ static SDValue CombineBaseUpdate(SDNode *N,
Ops.push_back(N->getOperand(i)); Ops.push_back(N->getOperand(i));
} }
MemIntrinsicSDNode *MemInt = cast<MemIntrinsicSDNode>(N); MemIntrinsicSDNode *MemInt = cast<MemIntrinsicSDNode>(N);
SDValue UpdN = DAG.getMemIntrinsicNode(NewOpc, N->getDebugLoc(), SDTys, SDValue UpdN = DAG.getMemIntrinsicNode(NewOpc, SDLoc(N), SDTys,
Ops.data(), Ops.size(), Ops.data(), Ops.size(),
MemInt->getMemoryVT(), MemInt->getMemoryVT(),
MemInt->getMemOperand()); MemInt->getMemOperand());
@ -9018,7 +9018,7 @@ static bool CombineVLDDUP(SDNode *N, TargetLowering::DAGCombinerInfo &DCI) {
SDVTList SDTys = DAG.getVTList(Tys, NumVecs+1); SDVTList SDTys = DAG.getVTList(Tys, NumVecs+1);
SDValue Ops[] = { VLD->getOperand(0), VLD->getOperand(2) }; SDValue Ops[] = { VLD->getOperand(0), VLD->getOperand(2) };
MemIntrinsicSDNode *VLDMemInt = cast<MemIntrinsicSDNode>(VLD); MemIntrinsicSDNode *VLDMemInt = cast<MemIntrinsicSDNode>(VLD);
SDValue VLDDup = DAG.getMemIntrinsicNode(NewOpc, VLD->getDebugLoc(), SDTys, SDValue VLDDup = DAG.getMemIntrinsicNode(NewOpc, SDLoc(VLD), SDTys,
Ops, 2, VLDMemInt->getMemoryVT(), Ops, 2, VLDMemInt->getMemoryVT(),
VLDMemInt->getMemOperand()); VLDMemInt->getMemOperand());
@ -9073,7 +9073,7 @@ static SDValue PerformVDUPLANECombine(SDNode *N,
if (EltSize > VT.getVectorElementType().getSizeInBits()) if (EltSize > VT.getVectorElementType().getSizeInBits())
return SDValue(); return SDValue();
return DCI.DAG.getNode(ISD::BITCAST, N->getDebugLoc(), VT, Op); return DCI.DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
} }
// isConstVecPow2 - Return true if each vector element is a power of 2, all // isConstVecPow2 - Return true if each vector element is a power of 2, all
@ -9132,7 +9132,7 @@ static SDValue PerformVCVTCombine(SDNode *N,
unsigned IntrinsicOpcode = isSigned ? Intrinsic::arm_neon_vcvtfp2fxs : unsigned IntrinsicOpcode = isSigned ? Intrinsic::arm_neon_vcvtfp2fxs :
Intrinsic::arm_neon_vcvtfp2fxu; Intrinsic::arm_neon_vcvtfp2fxu;
return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, N->getDebugLoc(), return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, SDLoc(N),
N->getValueType(0), N->getValueType(0),
DAG.getConstant(IntrinsicOpcode, MVT::i32), N0, DAG.getConstant(IntrinsicOpcode, MVT::i32), N0,
DAG.getConstant(Log2_64(C), MVT::i32)); DAG.getConstant(Log2_64(C), MVT::i32));
@ -9168,7 +9168,7 @@ static SDValue PerformVDIVCombine(SDNode *N,
unsigned IntrinsicOpcode = isSigned ? Intrinsic::arm_neon_vcvtfxs2fp : unsigned IntrinsicOpcode = isSigned ? Intrinsic::arm_neon_vcvtfxs2fp :
Intrinsic::arm_neon_vcvtfxu2fp; Intrinsic::arm_neon_vcvtfxu2fp;
return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, N->getDebugLoc(), return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, SDLoc(N),
Op.getValueType(), Op.getValueType(),
DAG.getConstant(IntrinsicOpcode, MVT::i32), DAG.getConstant(IntrinsicOpcode, MVT::i32),
Op.getOperand(0), DAG.getConstant(Log2_64(C), MVT::i32)); Op.getOperand(0), DAG.getConstant(Log2_64(C), MVT::i32));
@ -9352,7 +9352,7 @@ static SDValue PerformIntrinsicCombine(SDNode *N, SelectionDAG &DAG) {
VShiftOpc = ARMISD::VQRSHRNsu; break; VShiftOpc = ARMISD::VQRSHRNsu; break;
} }
return DAG.getNode(VShiftOpc, N->getDebugLoc(), N->getValueType(0), return DAG.getNode(VShiftOpc, SDLoc(N), N->getValueType(0),
N->getOperand(1), DAG.getConstant(Cnt, MVT::i32)); N->getOperand(1), DAG.getConstant(Cnt, MVT::i32));
} }
@ -9369,7 +9369,7 @@ static SDValue PerformIntrinsicCombine(SDNode *N, SelectionDAG &DAG) {
llvm_unreachable("invalid shift count for vsli/vsri intrinsic"); llvm_unreachable("invalid shift count for vsli/vsri intrinsic");
} }
return DAG.getNode(VShiftOpc, N->getDebugLoc(), N->getValueType(0), return DAG.getNode(VShiftOpc, SDLoc(N), N->getValueType(0),
N->getOperand(1), N->getOperand(2), N->getOperand(1), N->getOperand(2),
DAG.getConstant(Cnt, MVT::i32)); DAG.getConstant(Cnt, MVT::i32));
} }
@ -9400,7 +9400,7 @@ static SDValue PerformShiftCombine(SDNode *N, SelectionDAG &DAG,
if (C->getZExtValue() == 16 && N0.getOpcode() == ISD::BSWAP && if (C->getZExtValue() == 16 && N0.getOpcode() == ISD::BSWAP &&
DAG.MaskedValueIsZero(N0.getOperand(0), DAG.MaskedValueIsZero(N0.getOperand(0),
APInt::getHighBitsSet(32, 16))) APInt::getHighBitsSet(32, 16)))
return DAG.getNode(ISD::ROTR, N->getDebugLoc(), VT, N0, N1); return DAG.getNode(ISD::ROTR, SDLoc(N), VT, N0, N1);
} }
} }
@ -9417,7 +9417,7 @@ static SDValue PerformShiftCombine(SDNode *N, SelectionDAG &DAG,
case ISD::SHL: case ISD::SHL:
if (isVShiftLImm(N->getOperand(1), VT, false, Cnt)) if (isVShiftLImm(N->getOperand(1), VT, false, Cnt))
return DAG.getNode(ARMISD::VSHL, N->getDebugLoc(), VT, N->getOperand(0), return DAG.getNode(ARMISD::VSHL, SDLoc(N), VT, N->getOperand(0),
DAG.getConstant(Cnt, MVT::i32)); DAG.getConstant(Cnt, MVT::i32));
break; break;
@ -9426,7 +9426,7 @@ static SDValue PerformShiftCombine(SDNode *N, SelectionDAG &DAG,
if (isVShiftRImm(N->getOperand(1), VT, false, false, Cnt)) { if (isVShiftRImm(N->getOperand(1), VT, false, false, Cnt)) {
unsigned VShiftOpc = (N->getOpcode() == ISD::SRA ? unsigned VShiftOpc = (N->getOpcode() == ISD::SRA ?
ARMISD::VSHRs : ARMISD::VSHRu); ARMISD::VSHRs : ARMISD::VSHRu);
return DAG.getNode(VShiftOpc, N->getDebugLoc(), VT, N->getOperand(0), return DAG.getNode(VShiftOpc, SDLoc(N), VT, N->getOperand(0),
DAG.getConstant(Cnt, MVT::i32)); DAG.getConstant(Cnt, MVT::i32));
} }
} }
@ -9466,7 +9466,7 @@ static SDValue PerformExtendCombine(SDNode *N, SelectionDAG &DAG,
Opc = ARMISD::VGETLANEu; Opc = ARMISD::VGETLANEu;
break; break;
} }
return DAG.getNode(Opc, N->getDebugLoc(), VT, Vec, Lane); return DAG.getNode(Opc, SDLoc(N), VT, Vec, Lane);
} }
} }
@ -9555,7 +9555,7 @@ static SDValue PerformSELECT_CCCombine(SDNode *N, SelectionDAG &DAG,
if (!Opcode) if (!Opcode)
return SDValue(); return SDValue();
return DAG.getNode(Opcode, N->getDebugLoc(), N->getValueType(0), LHS, RHS); return DAG.getNode(Opcode, SDLoc(N), N->getValueType(0), LHS, RHS);
} }
/// PerformCMOVCombine - Target-specific DAG combining for ARMISD::CMOV. /// PerformCMOVCombine - Target-specific DAG combining for ARMISD::CMOV.
@ -9567,7 +9567,7 @@ ARMTargetLowering::PerformCMOVCombine(SDNode *N, SelectionDAG &DAG) const {
return SDValue(); return SDValue();
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue LHS = Cmp.getOperand(0); SDValue LHS = Cmp.getOperand(0);
SDValue RHS = Cmp.getOperand(1); SDValue RHS = Cmp.getOperand(1);
SDValue FalseVal = N->getOperand(0); SDValue FalseVal = N->getOperand(0);

20
lib/Target/ARM/ARMISelLowering.h
View File

@ -412,7 +412,7 @@ namespace llvm {
void addQRTypeForNEON(MVT VT); void addQRTypeForNEON(MVT VT);
typedef SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPassVector; typedef SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPassVector;
void PassF64ArgInRegs(DebugLoc dl, SelectionDAG &DAG, void PassF64ArgInRegs(SDLoc dl, SelectionDAG &DAG,
SDValue Chain, SDValue &Arg, SDValue Chain, SDValue &Arg,
RegsToPassVector &RegsToPass, RegsToPassVector &RegsToPass,
CCValAssign &VA, CCValAssign &NextVA, CCValAssign &VA, CCValAssign &NextVA,
@ -421,12 +421,12 @@ namespace llvm {
ISD::ArgFlagsTy Flags) const; ISD::ArgFlagsTy Flags) const;
SDValue GetF64FormalArgument(CCValAssign &VA, CCValAssign &NextVA, SDValue GetF64FormalArgument(CCValAssign &VA, CCValAssign &NextVA,
SDValue &Root, SelectionDAG &DAG, SDValue &Root, SelectionDAG &DAG,
DebugLoc dl) const; SDLoc dl) const;
CCAssignFn *CCAssignFnForNode(CallingConv::ID CC, bool Return, CCAssignFn *CCAssignFnForNode(CallingConv::ID CC, bool Return,
bool isVarArg) const; bool isVarArg) const;
SDValue LowerMemOpCallTo(SDValue Chain, SDValue StackPtr, SDValue Arg, SDValue LowerMemOpCallTo(SDValue Chain, SDValue StackPtr, SDValue Arg,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
const CCValAssign &VA, const CCValAssign &VA,
ISD::ArgFlagsTy Flags) const; ISD::ArgFlagsTy Flags) const;
SDValue LowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const; SDValue LowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const;
@ -463,7 +463,7 @@ namespace llvm {
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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals, SmallVectorImpl<SDValue> &InVals,
bool isThisReturn, SDValue ThisVal) const; bool isThisReturn, SDValue ThisVal) const;
@ -471,11 +471,11 @@ namespace llvm {
LowerFormalArguments(SDValue Chain, LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
int StoreByValRegs(CCState &CCInfo, SelectionDAG &DAG, int StoreByValRegs(CCState &CCInfo, SelectionDAG &DAG,
DebugLoc dl, SDValue &Chain, SDLoc dl, SDValue &Chain,
const Value *OrigArg, const Value *OrigArg,
unsigned InRegsParamRecordIdx, unsigned InRegsParamRecordIdx,
unsigned OffsetFromOrigArg, unsigned OffsetFromOrigArg,
@ -484,7 +484,7 @@ namespace llvm {
bool ForceMutable) const; bool ForceMutable) const;
void VarArgStyleRegisters(CCState &CCInfo, SelectionDAG &DAG, void VarArgStyleRegisters(CCState &CCInfo, SelectionDAG &DAG,
DebugLoc dl, SDValue &Chain, SDLoc dl, SDValue &Chain,
unsigned ArgOffset, unsigned ArgOffset,
bool ForceMutable = false) const; bool ForceMutable = false) const;
@ -524,16 +524,16 @@ namespace llvm {
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const; SDLoc dl, SelectionDAG &DAG) const;
virtual bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const; virtual bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const;
virtual bool mayBeEmittedAsTailCall(CallInst *CI) const; virtual bool mayBeEmittedAsTailCall(CallInst *CI) const;
SDValue getARMCmp(SDValue LHS, SDValue RHS, ISD::CondCode CC, SDValue getARMCmp(SDValue LHS, SDValue RHS, ISD::CondCode CC,
SDValue &ARMcc, SelectionDAG &DAG, DebugLoc dl) const; SDValue &ARMcc, SelectionDAG &DAG, SDLoc dl) const;
SDValue getVFPCmp(SDValue LHS, SDValue RHS, SDValue getVFPCmp(SDValue LHS, SDValue RHS,
SelectionDAG &DAG, DebugLoc dl) const; SelectionDAG &DAG, SDLoc dl) const;
SDValue duplicateCmp(SDValue Cmp, SelectionDAG &DAG) const; SDValue duplicateCmp(SDValue Cmp, SelectionDAG &DAG) const;
SDValue OptimizeVFPBrcond(SDValue Op, SelectionDAG &DAG) const; SDValue OptimizeVFPBrcond(SDValue Op, SelectionDAG &DAG) const;

4
lib/Target/ARM/ARMSelectionDAGInfo.cpp
View File

@ -26,7 +26,7 @@ ARMSelectionDAGInfo::~ARMSelectionDAGInfo() {
} }
SDValue SDValue
ARMSelectionDAGInfo::EmitTargetCodeForMemcpy(SelectionDAG &DAG, DebugLoc dl, ARMSelectionDAGInfo::EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Chain,
SDValue Dst, SDValue Src, SDValue Dst, SDValue Src,
SDValue Size, unsigned Align, SDValue Size, unsigned Align,
@ -140,7 +140,7 @@ ARMSelectionDAGInfo::EmitTargetCodeForMemcpy(SelectionDAG &DAG, DebugLoc dl,
// GNU library uses (ptr, value, size) // GNU library uses (ptr, value, size)
// See RTABI section 4.3.4 // See RTABI section 4.3.4
SDValue ARMSelectionDAGInfo:: SDValue ARMSelectionDAGInfo::
EmitTargetCodeForMemset(SelectionDAG &DAG, DebugLoc dl, EmitTargetCodeForMemset(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Dst, SDValue Chain, SDValue Dst,
SDValue Src, SDValue Size, SDValue Src, SDValue Size,
unsigned Align, bool isVolatile, unsigned Align, bool isVolatile,

4
lib/Target/ARM/ARMSelectionDAGInfo.h
View File

@ -45,7 +45,7 @@ public:
~ARMSelectionDAGInfo(); ~ARMSelectionDAGInfo();
virtual virtual
SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, DebugLoc dl, SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Chain,
SDValue Dst, SDValue Src, SDValue Dst, SDValue Src,
SDValue Size, unsigned Align, SDValue Size, unsigned Align,
@ -55,7 +55,7 @@ public:
// Adjust parameters for memset, see RTABI section 4.3.4 // Adjust parameters for memset, see RTABI section 4.3.4
virtual virtual
SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, DebugLoc dl, SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Chain,
SDValue Op1, SDValue Op2, SDValue Op1, SDValue Op2,
SDValue Op3, unsigned Align, SDValue Op3, unsigned Align,

48
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp
View File

@ -92,14 +92,14 @@ public:
bool SelectAddr(SDNode *Op, SDValue Addr, SDValue &Base, SDValue &Offset); bool SelectAddr(SDNode *Op, SDValue Addr, SDValue &Base, SDValue &Offset);
SDNode *SelectLoad(SDNode *N); SDNode *SelectLoad(SDNode *N);
SDNode *SelectBaseOffsetLoad(LoadSDNode *LD, DebugLoc dl); SDNode *SelectBaseOffsetLoad(LoadSDNode *LD, SDLoc dl);
SDNode *SelectIndexedLoad(LoadSDNode *LD, DebugLoc dl); SDNode *SelectIndexedLoad(LoadSDNode *LD, SDLoc dl);
SDNode *SelectIndexedLoadZeroExtend64(LoadSDNode *LD, unsigned Opcode, SDNode *SelectIndexedLoadZeroExtend64(LoadSDNode *LD, unsigned Opcode,
DebugLoc dl); SDLoc dl);
SDNode *SelectIndexedLoadSignExtend64(LoadSDNode *LD, unsigned Opcode, SDNode *SelectIndexedLoadSignExtend64(LoadSDNode *LD, unsigned Opcode,
DebugLoc dl); SDLoc dl);
SDNode *SelectBaseOffsetStore(StoreSDNode *ST, DebugLoc dl); SDNode *SelectBaseOffsetStore(StoreSDNode *ST, SDLoc dl);
SDNode *SelectIndexedStore(StoreSDNode *ST, DebugLoc dl); SDNode *SelectIndexedStore(StoreSDNode *ST, SDLoc dl);
SDNode *SelectStore(SDNode *N); SDNode *SelectStore(SDNode *N);
SDNode *SelectSHL(SDNode *N); SDNode *SelectSHL(SDNode *N);
SDNode *SelectSelect(SDNode *N); SDNode *SelectSelect(SDNode *N);
@ -385,7 +385,7 @@ static bool OffsetFitsS11(EVT MemType, int64_t Offset) {
// lowering for GlobalAddress nodes has already turned it into a // lowering for GlobalAddress nodes has already turned it into a
// CONST32. // CONST32.
// //
SDNode *HexagonDAGToDAGISel::SelectBaseOffsetLoad(LoadSDNode *LD, DebugLoc dl) { SDNode *HexagonDAGToDAGISel::SelectBaseOffsetLoad(LoadSDNode *LD, SDLoc dl) {
SDValue Chain = LD->getChain(); SDValue Chain = LD->getChain();
SDNode* Const32 = LD->getBasePtr().getNode(); SDNode* Const32 = LD->getBasePtr().getNode();
unsigned Opcode = 0; unsigned Opcode = 0;
@ -433,7 +433,7 @@ SDNode *HexagonDAGToDAGISel::SelectBaseOffsetLoad(LoadSDNode *LD, DebugLoc dl) {
SDNode *HexagonDAGToDAGISel::SelectIndexedLoadSignExtend64(LoadSDNode *LD, SDNode *HexagonDAGToDAGISel::SelectIndexedLoadSignExtend64(LoadSDNode *LD,
unsigned Opcode, unsigned Opcode,
DebugLoc dl) SDLoc dl)
{ {
SDValue Chain = LD->getChain(); SDValue Chain = LD->getChain();
EVT LoadedVT = LD->getMemoryVT(); EVT LoadedVT = LD->getMemoryVT();
@ -497,7 +497,7 @@ SDNode *HexagonDAGToDAGISel::SelectIndexedLoadSignExtend64(LoadSDNode *LD,
SDNode *HexagonDAGToDAGISel::SelectIndexedLoadZeroExtend64(LoadSDNode *LD, SDNode *HexagonDAGToDAGISel::SelectIndexedLoadZeroExtend64(LoadSDNode *LD,
unsigned Opcode, unsigned Opcode,
DebugLoc dl) SDLoc dl)
{ {
SDValue Chain = LD->getChain(); SDValue Chain = LD->getChain();
EVT LoadedVT = LD->getMemoryVT(); EVT LoadedVT = LD->getMemoryVT();
@ -572,7 +572,7 @@ SDNode *HexagonDAGToDAGISel::SelectIndexedLoadZeroExtend64(LoadSDNode *LD,
} }
SDNode *HexagonDAGToDAGISel::SelectIndexedLoad(LoadSDNode *LD, DebugLoc dl) { SDNode *HexagonDAGToDAGISel::SelectIndexedLoad(LoadSDNode *LD, SDLoc dl) {
SDValue Chain = LD->getChain(); SDValue Chain = LD->getChain();
SDValue Base = LD->getBasePtr(); SDValue Base = LD->getBasePtr();
SDValue Offset = LD->getOffset(); SDValue Offset = LD->getOffset();
@ -667,7 +667,7 @@ SDNode *HexagonDAGToDAGISel::SelectIndexedLoad(LoadSDNode *LD, DebugLoc dl) {
SDNode *HexagonDAGToDAGISel::SelectLoad(SDNode *N) { SDNode *HexagonDAGToDAGISel::SelectLoad(SDNode *N) {
SDNode *result; SDNode *result;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
LoadSDNode *LD = cast<LoadSDNode>(N); LoadSDNode *LD = cast<LoadSDNode>(N);
ISD::MemIndexedMode AM = LD->getAddressingMode(); ISD::MemIndexedMode AM = LD->getAddressingMode();
@ -682,7 +682,7 @@ SDNode *HexagonDAGToDAGISel::SelectLoad(SDNode *N) {
} }
SDNode *HexagonDAGToDAGISel::SelectIndexedStore(StoreSDNode *ST, DebugLoc dl) { SDNode *HexagonDAGToDAGISel::SelectIndexedStore(StoreSDNode *ST, SDLoc dl) {
SDValue Chain = ST->getChain(); SDValue Chain = ST->getChain();
SDValue Base = ST->getBasePtr(); SDValue Base = ST->getBasePtr();
SDValue Offset = ST->getOffset(); SDValue Offset = ST->getOffset();
@ -751,7 +751,7 @@ SDNode *HexagonDAGToDAGISel::SelectIndexedStore(StoreSDNode *ST, DebugLoc dl) {
SDNode *HexagonDAGToDAGISel::SelectBaseOffsetStore(StoreSDNode *ST, SDNode *HexagonDAGToDAGISel::SelectBaseOffsetStore(StoreSDNode *ST,
DebugLoc dl) { SDLoc dl) {
SDValue Chain = ST->getChain(); SDValue Chain = ST->getChain();
SDNode* Const32 = ST->getBasePtr().getNode(); SDNode* Const32 = ST->getBasePtr().getNode();
SDValue Value = ST->getValue(); SDValue Value = ST->getValue();
@ -805,7 +805,7 @@ SDNode *HexagonDAGToDAGISel::SelectBaseOffsetStore(StoreSDNode *ST,
SDNode *HexagonDAGToDAGISel::SelectStore(SDNode *N) { SDNode *HexagonDAGToDAGISel::SelectStore(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
StoreSDNode *ST = cast<StoreSDNode>(N); StoreSDNode *ST = cast<StoreSDNode>(N);
ISD::MemIndexedMode AM = ST->getAddressingMode(); ISD::MemIndexedMode AM = ST->getAddressingMode();
@ -818,7 +818,7 @@ SDNode *HexagonDAGToDAGISel::SelectStore(SDNode *N) {
} }
SDNode *HexagonDAGToDAGISel::SelectMul(SDNode *N) { SDNode *HexagonDAGToDAGISel::SelectMul(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// //
// %conv.i = sext i32 %tmp1 to i64 // %conv.i = sext i32 %tmp1 to i64
@ -902,7 +902,7 @@ SDNode *HexagonDAGToDAGISel::SelectMul(SDNode *N) {
SDNode *HexagonDAGToDAGISel::SelectSelect(SDNode *N) { SDNode *HexagonDAGToDAGISel::SelectSelect(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue N0 = N->getOperand(0); SDValue N0 = N->getOperand(0);
if (N0.getOpcode() == ISD::SETCC) { if (N0.getOpcode() == ISD::SETCC) {
SDValue N00 = N0.getOperand(0); SDValue N00 = N0.getOperand(0);
@ -969,7 +969,7 @@ SDNode *HexagonDAGToDAGISel::SelectSelect(SDNode *N) {
SDNode *HexagonDAGToDAGISel::SelectTruncate(SDNode *N) { SDNode *HexagonDAGToDAGISel::SelectTruncate(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue Shift = N->getOperand(0); SDValue Shift = N->getOperand(0);
// //
@ -1082,7 +1082,7 @@ SDNode *HexagonDAGToDAGISel::SelectTruncate(SDNode *N) {
SDNode *HexagonDAGToDAGISel::SelectSHL(SDNode *N) { SDNode *HexagonDAGToDAGISel::SelectSHL(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (N->getValueType(0) == MVT::i32) { if (N->getValueType(0) == MVT::i32) {
SDValue Shl_0 = N->getOperand(0); SDValue Shl_0 = N->getOperand(0);
SDValue Shl_1 = N->getOperand(1); SDValue Shl_1 = N->getOperand(1);
@ -1158,7 +1158,7 @@ SDNode *HexagonDAGToDAGISel::SelectSHL(SDNode *N) {
// We want to preserve all the lower 8-bits and, not just 1 LSB bit. // We want to preserve all the lower 8-bits and, not just 1 LSB bit.
// //
SDNode *HexagonDAGToDAGISel::SelectZeroExtend(SDNode *N) { SDNode *HexagonDAGToDAGISel::SelectZeroExtend(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDNode *IsIntrinsic = N->getOperand(0).getNode(); SDNode *IsIntrinsic = N->getOperand(0).getNode();
if ((IsIntrinsic->getOpcode() == ISD::INTRINSIC_WO_CHAIN)) { if ((IsIntrinsic->getOpcode() == ISD::INTRINSIC_WO_CHAIN)) {
unsigned ID = unsigned ID =
@ -1201,7 +1201,7 @@ SDNode *HexagonDAGToDAGISel::SelectZeroExtend(SDNode *N) {
// and lowering to the actual intrinsic. // and lowering to the actual intrinsic.
// //
SDNode *HexagonDAGToDAGISel::SelectIntrinsicWOChain(SDNode *N) { SDNode *HexagonDAGToDAGISel::SelectIntrinsicWOChain(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
unsigned ID = cast<ConstantSDNode>(N->getOperand(0))->getZExtValue(); unsigned ID = cast<ConstantSDNode>(N->getOperand(0))->getZExtValue();
unsigned IntrinsicWithPred = doesIntrinsicContainPredicate(ID); unsigned IntrinsicWithPred = doesIntrinsicContainPredicate(ID);
@ -1251,7 +1251,7 @@ SDNode *HexagonDAGToDAGISel::SelectIntrinsicWOChain(SDNode *N) {
// Map floating point constant values. // Map floating point constant values.
// //
SDNode *HexagonDAGToDAGISel::SelectConstantFP(SDNode *N) { SDNode *HexagonDAGToDAGISel::SelectConstantFP(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
ConstantFPSDNode *CN = dyn_cast<ConstantFPSDNode>(N); ConstantFPSDNode *CN = dyn_cast<ConstantFPSDNode>(N);
APFloat APF = CN->getValueAPF(); APFloat APF = CN->getValueAPF();
if (N->getValueType(0) == MVT::f32) { if (N->getValueType(0) == MVT::f32) {
@ -1271,7 +1271,7 @@ SDNode *HexagonDAGToDAGISel::SelectConstantFP(SDNode *N) {
// Map predicate true (encoded as -1 in LLVM) to a XOR. // Map predicate true (encoded as -1 in LLVM) to a XOR.
// //
SDNode *HexagonDAGToDAGISel::SelectConstant(SDNode *N) { SDNode *HexagonDAGToDAGISel::SelectConstant(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (N->getValueType(0) == MVT::i1) { if (N->getValueType(0) == MVT::i1) {
SDNode* Result; SDNode* Result;
int32_t Val = cast<ConstantSDNode>(N)->getSExtValue(); int32_t Val = cast<ConstantSDNode>(N)->getSExtValue();
@ -1310,7 +1310,7 @@ SDNode *HexagonDAGToDAGISel::SelectConstant(SDNode *N) {
// Map add followed by a asr -> asr +=. // Map add followed by a asr -> asr +=.
// //
SDNode *HexagonDAGToDAGISel::SelectAdd(SDNode *N) { SDNode *HexagonDAGToDAGISel::SelectAdd(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (N->getValueType(0) != MVT::i32) { if (N->getValueType(0) != MVT::i32) {
return SelectCode(N); return SelectCode(N);
} }
@ -1660,7 +1660,7 @@ bool HexagonDAGToDAGISel::foldGlobalAddressImpl(SDValue &N, SDValue &R,
!hasNumUsesBelowThresGA(GA)) !hasNumUsesBelowThresGA(GA))
return false; return false;
R = CurDAG->getTargetGlobalAddress(GA->getGlobal(), R = CurDAG->getTargetGlobalAddress(GA->getGlobal(),
Const->getDebugLoc(), SDLoc(Const),
N.getValueType(), N.getValueType(),
GA->getOffset() + GA->getOffset() +
(uint64_t)Const->getSExtValue()); (uint64_t)Const->getSExtValue());

32
lib/Target/Hexagon/HexagonISelLowering.cpp
View File

@ -285,7 +285,7 @@ const {
static SDValue static SDValue
CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain, CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain,
ISD::ArgFlagsTy Flags, SelectionDAG &DAG, ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
DebugLoc dl) { SDLoc dl) {
SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32); SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32);
return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(), return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(),
@ -302,7 +302,7 @@ HexagonTargetLowering::LowerReturn(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const { SDLoc dl, SelectionDAG &DAG) const {
// CCValAssign - represent the assignment of the return value to locations. // CCValAssign - represent the assignment of the return value to locations.
SmallVector<CCValAssign, 16> RVLocs; SmallVector<CCValAssign, 16> RVLocs;
@ -351,7 +351,7 @@ HexagonTargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const const
SmallVectorImpl<ISD::InputArg> &Ins, SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals, SmallVectorImpl<SDValue> &InVals,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
SDValue Callee) const { SDValue Callee) const {
@ -382,7 +382,7 @@ SDValue
HexagonTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI, HexagonTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG; SelectionDAG &DAG = CLI.DAG;
DebugLoc &dl = CLI.DL; SDLoc &dl = CLI.DL;
SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs; SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
SmallVector<SDValue, 32> &OutVals = CLI.OutVals; SmallVector<SDValue, 32> &OutVals = CLI.OutVals;
SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins; SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;
@ -730,7 +730,7 @@ LowerBR_JT(SDValue Op, SelectionDAG &DAG) const
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Table = Op.getOperand(1); SDValue Table = Op.getOperand(1);
SDValue Index = Op.getOperand(2); SDValue Index = Op.getOperand(2);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
JumpTableSDNode *JT = cast<JumpTableSDNode>(Table); JumpTableSDNode *JT = cast<JumpTableSDNode>(Table);
unsigned JTI = JT->getIndex(); unsigned JTI = JT->getIndex();
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
@ -766,7 +766,7 @@ HexagonTargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Size = Op.getOperand(1); SDValue Size = Op.getOperand(1);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned SPReg = getStackPointerRegisterToSaveRestore(); unsigned SPReg = getStackPointerRegisterToSaveRestore();
@ -812,7 +812,7 @@ HexagonTargetLowering::LowerFormalArguments(SDValue Chain,
bool isVarArg, bool isVarArg,
const const
SmallVectorImpl<ISD::InputArg> &Ins, SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) SmallVectorImpl<SDValue> &InVals)
const { const {
@ -925,7 +925,7 @@ HexagonTargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const {
HexagonMachineFunctionInfo *QFI = MF.getInfo<HexagonMachineFunctionInfo>(); HexagonMachineFunctionInfo *QFI = MF.getInfo<HexagonMachineFunctionInfo>();
SDValue Addr = DAG.getFrameIndex(QFI->getVarArgsFrameIndex(), MVT::i32); SDValue Addr = DAG.getFrameIndex(QFI->getVarArgsFrameIndex(), MVT::i32);
const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue(); const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
return DAG.getStore(Op.getOperand(0), Op.getDebugLoc(), Addr, return DAG.getStore(Op.getOperand(0), SDLoc(Op), Addr,
Op.getOperand(1), MachinePointerInfo(SV), false, Op.getOperand(1), MachinePointerInfo(SV), false,
false, 0); false, 0);
} }
@ -937,7 +937,7 @@ HexagonTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
SDValue CC = Op.getOperand(4); SDValue CC = Op.getOperand(4);
SDValue TrueVal = Op.getOperand(2); SDValue TrueVal = Op.getOperand(2);
SDValue FalseVal = Op.getOperand(3); SDValue FalseVal = Op.getOperand(3);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDNode* OpNode = Op.getNode(); SDNode* OpNode = Op.getNode();
EVT SVT = OpNode->getValueType(0); EVT SVT = OpNode->getValueType(0);
@ -948,7 +948,7 @@ HexagonTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
SDValue SDValue
HexagonTargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) const { HexagonTargetLowering::LowerConstantPool(SDValue Op, SelectionDAG &DAG) const {
EVT ValTy = Op.getValueType(); EVT ValTy = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op); ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
SDValue Res; SDValue Res;
if (CP->isMachineConstantPoolEntry()) if (CP->isMachineConstantPoolEntry())
@ -968,7 +968,7 @@ HexagonTargetLowering::LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const {
MFI->setReturnAddressIsTaken(true); MFI->setReturnAddressIsTaken(true);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue(); unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
if (Depth) { if (Depth) {
SDValue FrameAddr = LowerFRAMEADDR(Op, DAG); SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
@ -990,7 +990,7 @@ HexagonTargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
MFI->setFrameAddressIsTaken(true); MFI->setFrameAddressIsTaken(true);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue(); unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl,
TRI->getFrameRegister(), VT); TRI->getFrameRegister(), VT);
@ -1003,7 +1003,7 @@ HexagonTargetLowering::LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
SDValue HexagonTargetLowering::LowerATOMIC_FENCE(SDValue Op, SDValue HexagonTargetLowering::LowerATOMIC_FENCE(SDValue Op,
SelectionDAG& DAG) const { SelectionDAG& DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
return DAG.getNode(HexagonISD::BARRIER, dl, MVT::Other, Op.getOperand(0)); return DAG.getNode(HexagonISD::BARRIER, dl, MVT::Other, Op.getOperand(0));
} }
@ -1013,7 +1013,7 @@ SDValue HexagonTargetLowering::LowerGLOBALADDRESS(SDValue Op,
SDValue Result; SDValue Result;
const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal(); const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset(); int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), Offset); Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), Offset);
const HexagonTargetObjectFile &TLOF = const HexagonTargetObjectFile &TLOF =
@ -1029,7 +1029,7 @@ SDValue
HexagonTargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const { HexagonTargetLowering::LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const {
const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress(); const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
SDValue BA_SD = DAG.getTargetBlockAddress(BA, MVT::i32); SDValue BA_SD = DAG.getTargetBlockAddress(BA, MVT::i32);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
return DAG.getNode(HexagonISD::CONST32_GP, dl, getPointerTy(), BA_SD); return DAG.getNode(HexagonISD::CONST32_GP, dl, getPointerTy(), BA_SD);
} }
@ -1513,7 +1513,7 @@ HexagonTargetLowering::LowerEH_RETURN(SDValue Op, SelectionDAG &DAG) const {
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Offset = Op.getOperand(1); SDValue Offset = Op.getOperand(1);
SDValue Handler = Op.getOperand(2); SDValue Handler = Op.getOperand(2);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// Mark function as containing a call to EH_RETURN. // Mark function as containing a call to EH_RETURN.
HexagonMachineFunctionInfo *FuncInfo = HexagonMachineFunctionInfo *FuncInfo =

6
lib/Target/Hexagon/HexagonISelLowering.h
View File

@ -106,7 +106,7 @@ namespace llvm {
SDValue LowerFormalArguments(SDValue Chain, SDValue LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue LowerGLOBALADDRESS(SDValue Op, SelectionDAG &DAG) const; SDValue LowerGLOBALADDRESS(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const; SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
@ -117,7 +117,7 @@ namespace llvm {
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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals, SmallVectorImpl<SDValue> &InVals,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
SDValue Callee) const; SDValue Callee) const;
@ -131,7 +131,7 @@ namespace llvm {
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const; SDLoc dl, SelectionDAG &DAG) const;
virtual MachineBasicBlock virtual MachineBasicBlock
*EmitInstrWithCustomInserter(MachineInstr *MI, *EmitInstrWithCustomInserter(MachineInstr *MI,

2
lib/Target/Hexagon/HexagonSelectionDAGInfo.cpp
View File

@ -27,7 +27,7 @@ HexagonSelectionDAGInfo::~HexagonSelectionDAGInfo() {
SDValue SDValue
HexagonSelectionDAGInfo:: HexagonSelectionDAGInfo::
EmitTargetCodeForMemcpy(SelectionDAG &DAG, DebugLoc dl, SDValue Chain, EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl, SDValue Chain,
SDValue Dst, SDValue Src, SDValue Size, unsigned Align, SDValue Dst, SDValue Src, SDValue Size, unsigned Align,
bool isVolatile, bool AlwaysInline, bool isVolatile, bool AlwaysInline,
MachinePointerInfo DstPtrInfo, MachinePointerInfo DstPtrInfo,

2
lib/Target/Hexagon/HexagonSelectionDAGInfo.h
View File

@ -26,7 +26,7 @@ public:
~HexagonSelectionDAGInfo(); ~HexagonSelectionDAGInfo();
virtual virtual
SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, DebugLoc dl, SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Chain,
SDValue Dst, SDValue Src, SDValue Dst, SDValue Src,
SDValue Size, unsigned Align, SDValue Size, unsigned Align,

2
lib/Target/MBlaze/MBlazeISelDAGToDAG.cpp
View File

@ -188,7 +188,7 @@ SDNode *MBlazeDAGToDAGISel::getGlobalBaseReg() {
/// expanded, promoted and normal instructions /// expanded, promoted and normal instructions
SDNode* MBlazeDAGToDAGISel::Select(SDNode *Node) { SDNode* MBlazeDAGToDAGISel::Select(SDNode *Node) {
unsigned Opcode = Node->getOpcode(); unsigned Opcode = Node->getOpcode();
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
// If we have a custom node, we already have selected! // If we have a custom node, we already have selected!
if (Node->isMachineOpcode()) if (Node->isMachineOpcode())

18
lib/Target/MBlaze/MBlazeISelLowering.cpp
View File

@ -575,7 +575,7 @@ SDValue MBlazeTargetLowering::LowerSELECT_CC(SDValue Op,
SDValue RHS = Op.getOperand(1); SDValue RHS = Op.getOperand(1);
SDValue TrueVal = Op.getOperand(2); SDValue TrueVal = Op.getOperand(2);
SDValue FalseVal = Op.getOperand(3); SDValue FalseVal = Op.getOperand(3);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned Opc; unsigned Opc;
SDValue CompareFlag; SDValue CompareFlag;
@ -594,7 +594,7 @@ SDValue MBlazeTargetLowering::LowerSELECT_CC(SDValue Op,
SDValue MBlazeTargetLowering:: SDValue MBlazeTargetLowering::
LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const { LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const {
// FIXME there isn't actually debug info here // FIXME there isn't actually debug info here
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal(); const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
SDValue GA = DAG.getTargetGlobalAddress(GV, dl, MVT::i32); SDValue GA = DAG.getTargetGlobalAddress(GV, dl, MVT::i32);
@ -611,7 +611,7 @@ LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
SDValue ResNode; SDValue ResNode;
SDValue HiPart; SDValue HiPart;
// FIXME there isn't actually debug info here // FIXME there isn't actually debug info here
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
EVT PtrVT = Op.getValueType(); EVT PtrVT = Op.getValueType();
JumpTableSDNode *JT = cast<JumpTableSDNode>(Op); JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
@ -625,7 +625,7 @@ LowerConstantPool(SDValue Op, SelectionDAG &DAG) const {
SDValue ResNode; SDValue ResNode;
ConstantPoolSDNode *N = cast<ConstantPoolSDNode>(Op); ConstantPoolSDNode *N = cast<ConstantPoolSDNode>(Op);
const Constant *C = N->getConstVal(); const Constant *C = N->getConstVal();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue CP = DAG.getTargetConstantPool(C, MVT::i32, N->getAlignment(), SDValue CP = DAG.getTargetConstantPool(C, MVT::i32, N->getAlignment(),
N->getOffset(), 0); N->getOffset(), 0);
@ -637,7 +637,7 @@ SDValue MBlazeTargetLowering::LowerVASTART(SDValue Op,
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
MBlazeFunctionInfo *FuncInfo = MF.getInfo<MBlazeFunctionInfo>(); MBlazeFunctionInfo *FuncInfo = MF.getInfo<MBlazeFunctionInfo>();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue FI = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), SDValue FI = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
getPointerTy()); getPointerTy());
@ -686,7 +686,7 @@ SDValue MBlazeTargetLowering::
LowerCall(TargetLowering::CallLoweringInfo &CLI, LowerCall(TargetLowering::CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG; SelectionDAG &DAG = CLI.DAG;
DebugLoc &dl = CLI.DL; SDLoc dl = CLI.DL;
SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs; SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
SmallVector<SDValue, 32> &OutVals = CLI.OutVals; SmallVector<SDValue, 32> &OutVals = CLI.OutVals;
SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins; SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;
@ -844,7 +844,7 @@ LowerCall(TargetLowering::CallLoweringInfo &CLI,
SDValue MBlazeTargetLowering:: SDValue MBlazeTargetLowering::
LowerCallResult(SDValue Chain, SDValue InFlag, CallingConv::ID CallConv, LowerCallResult(SDValue Chain, SDValue InFlag, CallingConv::ID CallConv,
bool isVarArg, const SmallVectorImpl<ISD::InputArg> &Ins, bool isVarArg, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
// Assign locations to each value returned by this call. // Assign locations to each value returned by this call.
SmallVector<CCValAssign, 16> RVLocs; SmallVector<CCValAssign, 16> RVLocs;
@ -874,7 +874,7 @@ LowerCallResult(SDValue Chain, SDValue InFlag, CallingConv::ID CallConv,
SDValue MBlazeTargetLowering:: SDValue MBlazeTargetLowering::
LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg, LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo *MFI = MF.getFrameInfo(); MachineFrameInfo *MFI = MF.getFrameInfo();
@ -1017,7 +1017,7 @@ SDValue MBlazeTargetLowering::
LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg, LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const { SDLoc dl, SelectionDAG &DAG) const {
// CCValAssign - represent the assignment of // CCValAssign - represent the assignment of
// the return value to a location // the return value to a location
SmallVector<CCValAssign, 16> RVLocs; SmallVector<CCValAssign, 16> RVLocs;

6
lib/Target/MBlaze/MBlazeISelLowering.h
View File

@ -113,7 +113,7 @@ namespace llvm {
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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
// Lower Operand specifics // Lower Operand specifics
@ -128,7 +128,7 @@ namespace llvm {
LowerFormalArguments(SDValue Chain, LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
virtual SDValue virtual SDValue
@ -140,7 +140,7 @@ namespace llvm {
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const; SDLoc dl, SelectionDAG &DAG) const;
virtual MachineBasicBlock* virtual MachineBasicBlock*
EmitCustomShift(MachineInstr *MI, MachineBasicBlock *MBB) const; EmitCustomShift(MachineInstr *MI, MachineBasicBlock *MBB) const;

6
lib/Target/MSP430/MSP430ISelDAGToDAG.cpp
View File

@ -263,7 +263,7 @@ bool MSP430DAGToDAGISel::SelectAddr(SDValue N,
AM.Base.Reg; AM.Base.Reg;
if (AM.GV) if (AM.GV)
Disp = CurDAG->getTargetGlobalAddress(AM.GV, N->getDebugLoc(), Disp = CurDAG->getTargetGlobalAddress(AM.GV, SDLoc(N),
MVT::i16, AM.Disp, MVT::i16, AM.Disp,
0/*AM.SymbolFlags*/); 0/*AM.SymbolFlags*/);
else if (AM.CP) else if (AM.CP)
@ -345,7 +345,7 @@ SDNode *MSP430DAGToDAGISel::SelectIndexedLoad(SDNode *N) {
return NULL; return NULL;
} }
return CurDAG->getMachineNode(Opcode, N->getDebugLoc(), return CurDAG->getMachineNode(Opcode, SDLoc(N),
VT, MVT::i16, MVT::Other, VT, MVT::i16, MVT::Other,
LD->getBasePtr(), LD->getChain()); LD->getBasePtr(), LD->getChain());
} }
@ -382,7 +382,7 @@ SDNode *MSP430DAGToDAGISel::SelectIndexedBinOp(SDNode *Op,
SDNode *MSP430DAGToDAGISel::Select(SDNode *Node) { SDNode *MSP430DAGToDAGISel::Select(SDNode *Node) {
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
// Dump information about the Node being selected // Dump information about the Node being selected
DEBUG(errs() << "Selecting: "); DEBUG(errs() << "Selecting: ");

38
lib/Target/MSP430/MSP430ISelLowering.cpp
View File

@ -254,7 +254,7 @@ MSP430TargetLowering::LowerFormalArguments(SDValue Chain,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> const SmallVectorImpl<ISD::InputArg>
&Ins, &Ins,
DebugLoc dl, SDLoc dl,
SelectionDAG &DAG, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) SmallVectorImpl<SDValue> &InVals)
const { const {
@ -276,7 +276,7 @@ SDValue
MSP430TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI, MSP430TargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG; SelectionDAG &DAG = CLI.DAG;
DebugLoc &dl = CLI.DL; SDLoc &dl = CLI.DL;
SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs; SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
SmallVector<SDValue, 32> &OutVals = CLI.OutVals; SmallVector<SDValue, 32> &OutVals = CLI.OutVals;
SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins; SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;
@ -310,7 +310,7 @@ MSP430TargetLowering::LowerCCCArguments(SDValue Chain,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> const SmallVectorImpl<ISD::InputArg>
&Ins, &Ins,
DebugLoc dl, SDLoc dl,
SelectionDAG &DAG, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) SmallVectorImpl<SDValue> &InVals)
const { const {
@ -407,7 +407,7 @@ MSP430TargetLowering::LowerReturn(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const { SDLoc dl, SelectionDAG &DAG) const {
// CCValAssign - represent the assignment of the return value to a location // CCValAssign - represent the assignment of the return value to a location
SmallVector<CCValAssign, 16> RVLocs; SmallVector<CCValAssign, 16> RVLocs;
@ -463,7 +463,7 @@ MSP430TargetLowering::LowerCCCCallTo(SDValue Chain, SDValue Callee,
&Outs, &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
// Analyze operands of the call, assigning locations to each operand. // Analyze operands of the call, assigning locations to each operand.
SmallVector<CCValAssign, 16> ArgLocs; SmallVector<CCValAssign, 16> ArgLocs;
@ -599,7 +599,7 @@ SDValue
MSP430TargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag, MSP430TargetLowering::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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
// Assign locations to each value returned by this call. // Assign locations to each value returned by this call.
@ -625,7 +625,7 @@ SDValue MSP430TargetLowering::LowerShifts(SDValue Op,
unsigned Opc = Op.getOpcode(); unsigned Opc = Op.getOpcode();
SDNode* N = Op.getNode(); SDNode* N = Op.getNode();
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Expand non-constant shifts to loops: // Expand non-constant shifts to loops:
if (!isa<ConstantSDNode>(N->getOperand(1))) if (!isa<ConstantSDNode>(N->getOperand(1)))
@ -669,15 +669,15 @@ SDValue MSP430TargetLowering::LowerGlobalAddress(SDValue Op,
int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset(); int64_t Offset = cast<GlobalAddressSDNode>(Op)->getOffset();
// Create the TargetGlobalAddress node, folding in the constant offset. // Create the TargetGlobalAddress node, folding in the constant offset.
SDValue Result = DAG.getTargetGlobalAddress(GV, Op.getDebugLoc(), SDValue Result = DAG.getTargetGlobalAddress(GV, SDLoc(Op),
getPointerTy(), Offset); getPointerTy(), Offset);
return DAG.getNode(MSP430ISD::Wrapper, Op.getDebugLoc(), return DAG.getNode(MSP430ISD::Wrapper, SDLoc(Op),
getPointerTy(), Result); getPointerTy(), Result);
} }
SDValue MSP430TargetLowering::LowerExternalSymbol(SDValue Op, SDValue MSP430TargetLowering::LowerExternalSymbol(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
const char *Sym = cast<ExternalSymbolSDNode>(Op)->getSymbol(); const char *Sym = cast<ExternalSymbolSDNode>(Op)->getSymbol();
SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy()); SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy());
@ -686,7 +686,7 @@ SDValue MSP430TargetLowering::LowerExternalSymbol(SDValue Op,
SDValue MSP430TargetLowering::LowerBlockAddress(SDValue Op, SDValue MSP430TargetLowering::LowerBlockAddress(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress(); const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
SDValue Result = DAG.getTargetBlockAddress(BA, getPointerTy()); SDValue Result = DAG.getTargetBlockAddress(BA, getPointerTy());
@ -695,7 +695,7 @@ SDValue MSP430TargetLowering::LowerBlockAddress(SDValue Op,
static SDValue EmitCMP(SDValue &LHS, SDValue &RHS, SDValue &TargetCC, static SDValue EmitCMP(SDValue &LHS, SDValue &RHS, SDValue &TargetCC,
ISD::CondCode CC, ISD::CondCode CC,
DebugLoc dl, SelectionDAG &DAG) { SDLoc dl, SelectionDAG &DAG) {
// FIXME: Handle bittests someday // FIXME: Handle bittests someday
assert(!LHS.getValueType().isFloatingPoint() && "We don't handle FP yet"); assert(!LHS.getValueType().isFloatingPoint() && "We don't handle FP yet");
@ -782,7 +782,7 @@ SDValue MSP430TargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG) const {
SDValue LHS = Op.getOperand(2); SDValue LHS = Op.getOperand(2);
SDValue RHS = Op.getOperand(3); SDValue RHS = Op.getOperand(3);
SDValue Dest = Op.getOperand(4); SDValue Dest = Op.getOperand(4);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl (Op);
SDValue TargetCC; SDValue TargetCC;
SDValue Flag = EmitCMP(LHS, RHS, TargetCC, CC, dl, DAG); SDValue Flag = EmitCMP(LHS, RHS, TargetCC, CC, dl, DAG);
@ -794,7 +794,7 @@ SDValue MSP430TargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG) const {
SDValue MSP430TargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const { SDValue MSP430TargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
SDValue LHS = Op.getOperand(0); SDValue LHS = Op.getOperand(0);
SDValue RHS = Op.getOperand(1); SDValue RHS = Op.getOperand(1);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl (Op);
// If we are doing an AND and testing against zero, then the CMP // If we are doing an AND and testing against zero, then the CMP
// will not be generated. The AND (or BIT) will generate the condition codes, // will not be generated. The AND (or BIT) will generate the condition codes,
@ -878,7 +878,7 @@ SDValue MSP430TargetLowering::LowerSELECT_CC(SDValue Op,
SDValue TrueV = Op.getOperand(2); SDValue TrueV = Op.getOperand(2);
SDValue FalseV = Op.getOperand(3); SDValue FalseV = Op.getOperand(3);
ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get(); ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl (Op);
SDValue TargetCC; SDValue TargetCC;
SDValue Flag = EmitCMP(LHS, RHS, TargetCC, CC, dl, DAG); SDValue Flag = EmitCMP(LHS, RHS, TargetCC, CC, dl, DAG);
@ -897,7 +897,7 @@ SDValue MSP430TargetLowering::LowerSIGN_EXTEND(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
SDValue Val = Op.getOperand(0); SDValue Val = Op.getOperand(0);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
assert(VT == MVT::i16 && "Only support i16 for now!"); assert(VT == MVT::i16 && "Only support i16 for now!");
@ -929,7 +929,7 @@ SDValue MSP430TargetLowering::LowerRETURNADDR(SDValue Op,
MFI->setReturnAddressIsTaken(true); MFI->setReturnAddressIsTaken(true);
unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue(); unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
if (Depth > 0) { if (Depth > 0) {
SDValue FrameAddr = LowerFRAMEADDR(Op, DAG); SDValue FrameAddr = LowerFRAMEADDR(Op, DAG);
@ -953,7 +953,7 @@ SDValue MSP430TargetLowering::LowerFRAMEADDR(SDValue Op,
MFI->setFrameAddressIsTaken(true); MFI->setFrameAddressIsTaken(true);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); // FIXME probably not meaningful SDLoc dl(Op); // FIXME probably not meaningful
unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue(); unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl, SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl,
MSP430::FPW, VT); MSP430::FPW, VT);
@ -975,7 +975,7 @@ SDValue MSP430TargetLowering::LowerVASTART(SDValue Op,
const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue(); const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
// Create a store of the frame index to the location operand // Create a store of the frame index to the location operand
return DAG.getStore(Op.getOperand(0), Op.getDebugLoc(), FrameIndex, return DAG.getStore(Op.getOperand(0), SDLoc(Op), FrameIndex,
Op.getOperand(1), MachinePointerInfo(SV), Op.getOperand(1), MachinePointerInfo(SV),
false, false, 0); false, false, 0);
} }

10
lib/Target/MSP430/MSP430ISelLowering.h
View File

@ -130,28 +130,28 @@ namespace llvm {
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue LowerCCCArguments(SDValue Chain, SDValue LowerCCCArguments(SDValue Chain,
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SDLoc dl,
SelectionDAG &DAG, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
virtual SDValue virtual SDValue
LowerFormalArguments(SDValue Chain, LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
virtual SDValue virtual SDValue
LowerCall(TargetLowering::CallLoweringInfo &CLI, LowerCall(TargetLowering::CallLoweringInfo &CLI,
@ -162,7 +162,7 @@ namespace llvm {
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const; SDLoc dl, SelectionDAG &DAG) const;
virtual bool getPostIndexedAddressParts(SDNode *N, SDNode *Op, virtual bool getPostIndexedAddressParts(SDNode *N, SDNode *Op,
SDValue &Base, SDValue &Base,

4
lib/Target/Mips/Mips16ISelDAGToDAG.cpp
View File

@ -42,7 +42,7 @@ bool Mips16DAGToDAGISel::runOnMachineFunction(MachineFunction &MF) {
} }
/// Select multiply instructions. /// Select multiply instructions.
std::pair<SDNode*, SDNode*> std::pair<SDNode*, SDNode*>
Mips16DAGToDAGISel::selectMULT(SDNode *N, unsigned Opc, DebugLoc DL, EVT Ty, Mips16DAGToDAGISel::selectMULT(SDNode *N, unsigned Opc, SDLoc DL, EVT Ty,
bool HasLo, bool HasHi) { bool HasLo, bool HasHi) {
SDNode *Lo = 0, *Hi = 0; SDNode *Lo = 0, *Hi = 0;
SDNode *Mul = CurDAG->getMachineNode(Opc, DL, MVT::Glue, N->getOperand(0), SDNode *Mul = CurDAG->getMachineNode(Opc, DL, MVT::Glue, N->getOperand(0),
@ -235,7 +235,7 @@ bool Mips16DAGToDAGISel::selectAddr16(
/// expanded, promoted and normal instructions /// expanded, promoted and normal instructions
std::pair<bool, SDNode*> Mips16DAGToDAGISel::selectNode(SDNode *Node) { std::pair<bool, SDNode*> Mips16DAGToDAGISel::selectNode(SDNode *Node) {
unsigned Opcode = Node->getOpcode(); unsigned Opcode = Node->getOpcode();
DebugLoc DL = Node->getDebugLoc(); SDLoc DL(Node);
/// ///
// Instruction Selection not handled by the auto-generated // Instruction Selection not handled by the auto-generated

2
lib/Target/Mips/Mips16ISelDAGToDAG.h
View File

@ -23,7 +23,7 @@ public:
explicit Mips16DAGToDAGISel(MipsTargetMachine &TM) : MipsDAGToDAGISel(TM) {} explicit Mips16DAGToDAGISel(MipsTargetMachine &TM) : MipsDAGToDAGISel(TM) {}
private: private:
std::pair<SDNode*, SDNode*> selectMULT(SDNode *N, unsigned Opc, DebugLoc DL, std::pair<SDNode*, SDNode*> selectMULT(SDNode *N, unsigned Opc, SDLoc DL,
EVT Ty, bool HasLo, bool HasHi); EVT Ty, bool HasLo, bool HasHi);
SDValue getMips16SPAliasReg(); SDValue getMips16SPAliasReg();

92
lib/Target/Mips/MipsISelLowering.cpp
View File

@ -83,7 +83,7 @@ static SDValue getTargetNode(SDValue Op, SelectionDAG &DAG, unsigned Flag) {
EVT Ty = Op.getValueType(); EVT Ty = Op.getValueType();
if (GlobalAddressSDNode *N = dyn_cast<GlobalAddressSDNode>(Op)) if (GlobalAddressSDNode *N = dyn_cast<GlobalAddressSDNode>(Op))
return DAG.getTargetGlobalAddress(N->getGlobal(), Op.getDebugLoc(), Ty, 0, return DAG.getTargetGlobalAddress(N->getGlobal(), SDLoc(Op), Ty, 0,
Flag); Flag);
if (ExternalSymbolSDNode *N = dyn_cast<ExternalSymbolSDNode>(Op)) if (ExternalSymbolSDNode *N = dyn_cast<ExternalSymbolSDNode>(Op))
return DAG.getTargetExternalSymbol(N->getSymbol(), Ty, Flag); return DAG.getTargetExternalSymbol(N->getSymbol(), Ty, Flag);
@ -100,7 +100,7 @@ static SDValue getTargetNode(SDValue Op, SelectionDAG &DAG, unsigned Flag) {
} }
static SDValue getAddrNonPIC(SDValue Op, SelectionDAG &DAG) { static SDValue getAddrNonPIC(SDValue Op, SelectionDAG &DAG) {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT Ty = Op.getValueType(); EVT Ty = Op.getValueType();
SDValue Hi = getTargetNode(Op, DAG, MipsII::MO_ABS_HI); SDValue Hi = getTargetNode(Op, DAG, MipsII::MO_ABS_HI);
SDValue Lo = getTargetNode(Op, DAG, MipsII::MO_ABS_LO); SDValue Lo = getTargetNode(Op, DAG, MipsII::MO_ABS_LO);
@ -111,7 +111,7 @@ static SDValue getAddrNonPIC(SDValue Op, SelectionDAG &DAG) {
SDValue MipsTargetLowering::getAddrLocal(SDValue Op, SelectionDAG &DAG, SDValue MipsTargetLowering::getAddrLocal(SDValue Op, SelectionDAG &DAG,
bool HasMips64) const { bool HasMips64) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT Ty = Op.getValueType(); EVT Ty = Op.getValueType();
unsigned GOTFlag = HasMips64 ? MipsII::MO_GOT_PAGE : MipsII::MO_GOT; unsigned GOTFlag = HasMips64 ? MipsII::MO_GOT_PAGE : MipsII::MO_GOT;
SDValue GOT = DAG.getNode(MipsISD::Wrapper, DL, Ty, getGlobalReg(DAG, Ty), SDValue GOT = DAG.getNode(MipsISD::Wrapper, DL, Ty, getGlobalReg(DAG, Ty),
@ -126,7 +126,7 @@ SDValue MipsTargetLowering::getAddrLocal(SDValue Op, SelectionDAG &DAG,
SDValue MipsTargetLowering::getAddrGlobal(SDValue Op, SelectionDAG &DAG, SDValue MipsTargetLowering::getAddrGlobal(SDValue Op, SelectionDAG &DAG,
unsigned Flag) const { unsigned Flag) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT Ty = Op.getValueType(); EVT Ty = Op.getValueType();
SDValue Tgt = DAG.getNode(MipsISD::Wrapper, DL, Ty, getGlobalReg(DAG, Ty), SDValue Tgt = DAG.getNode(MipsISD::Wrapper, DL, Ty, getGlobalReg(DAG, Ty),
getTargetNode(Op, DAG, Flag)); getTargetNode(Op, DAG, Flag));
@ -137,7 +137,7 @@ SDValue MipsTargetLowering::getAddrGlobal(SDValue Op, SelectionDAG &DAG,
SDValue MipsTargetLowering::getAddrGlobalLargeGOT(SDValue Op, SelectionDAG &DAG, SDValue MipsTargetLowering::getAddrGlobalLargeGOT(SDValue Op, SelectionDAG &DAG,
unsigned HiFlag, unsigned HiFlag,
unsigned LoFlag) const { unsigned LoFlag) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT Ty = Op.getValueType(); EVT Ty = Op.getValueType();
SDValue Hi = DAG.getNode(MipsISD::Hi, DL, Ty, getTargetNode(Op, DAG, HiFlag)); SDValue Hi = DAG.getNode(MipsISD::Hi, DL, Ty, getTargetNode(Op, DAG, HiFlag));
Hi = DAG.getNode(ISD::ADD, DL, Ty, Hi, getGlobalReg(DAG, Ty)); Hi = DAG.getNode(ISD::ADD, DL, Ty, Hi, getGlobalReg(DAG, Ty));
@ -431,7 +431,7 @@ static SDValue performDivRemCombine(SDNode *N, SelectionDAG &DAG,
unsigned HI = (Ty == MVT::i32) ? Mips::HI : Mips::HI64; unsigned HI = (Ty == MVT::i32) ? Mips::HI : Mips::HI64;
unsigned Opc = N->getOpcode() == ISD::SDIVREM ? MipsISD::DivRem16 : unsigned Opc = N->getOpcode() == ISD::SDIVREM ? MipsISD::DivRem16 :
MipsISD::DivRemU16; MipsISD::DivRemU16;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
SDValue DivRem = DAG.getNode(Opc, DL, MVT::Glue, SDValue DivRem = DAG.getNode(Opc, DL, MVT::Glue,
N->getOperand(0), N->getOperand(1)); N->getOperand(0), N->getOperand(1));
@ -509,7 +509,7 @@ static SDValue createFPCmp(SelectionDAG &DAG, const SDValue &Op) {
return Op; return Op;
SDValue RHS = Op.getOperand(1); SDValue RHS = Op.getOperand(1);
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
// Assume the 3rd operand is a CondCodeSDNode. Add code to check the type of // Assume the 3rd operand is a CondCodeSDNode. Add code to check the type of
// node if necessary. // node if necessary.
@ -521,7 +521,7 @@ static SDValue createFPCmp(SelectionDAG &DAG, const SDValue &Op) {
// Creates and returns a CMovFPT/F node. // Creates and returns a CMovFPT/F node.
static SDValue createCMovFP(SelectionDAG &DAG, SDValue Cond, SDValue True, static SDValue createCMovFP(SelectionDAG &DAG, SDValue Cond, SDValue True,
SDValue False, DebugLoc DL) { SDValue False, SDLoc DL) {
ConstantSDNode *CC = cast<ConstantSDNode>(Cond.getOperand(2)); ConstantSDNode *CC = cast<ConstantSDNode>(Cond.getOperand(2));
bool invert = invertFPCondCodeUser((Mips::CondCode)CC->getSExtValue()); bool invert = invertFPCondCodeUser((Mips::CondCode)CC->getSExtValue());
@ -552,7 +552,7 @@ static SDValue performSELECTCombine(SDNode *N, SelectionDAG &DAG,
if (!CN || CN->getZExtValue()) if (!CN || CN->getZExtValue())
return SDValue(); return SDValue();
const DebugLoc DL = N->getDebugLoc(); const SDLoc DL(N);
ISD::CondCode CC = cast<CondCodeSDNode>(SetCC.getOperand(2))->get(); ISD::CondCode CC = cast<CondCodeSDNode>(SetCC.getOperand(2))->get();
SDValue True = N->getOperand(1); SDValue True = N->getOperand(1);
@ -597,7 +597,7 @@ static SDValue performANDCombine(SDNode *N, SelectionDAG &DAG,
if (SMPos != 0 || Pos + SMSize > ValTy.getSizeInBits()) if (SMPos != 0 || Pos + SMSize > ValTy.getSizeInBits())
return SDValue(); return SDValue();
return DAG.getNode(MipsISD::Ext, N->getDebugLoc(), ValTy, return DAG.getNode(MipsISD::Ext, SDLoc(N), ValTy,
ShiftRight.getOperand(0), DAG.getConstant(Pos, MVT::i32), ShiftRight.getOperand(0), DAG.getConstant(Pos, MVT::i32),
DAG.getConstant(SMSize, MVT::i32)); DAG.getConstant(SMSize, MVT::i32));
} }
@ -651,7 +651,7 @@ static SDValue performORCombine(SDNode *N, SelectionDAG &DAG,
if ((Shamt != SMPos0) || (SMPos0 + SMSize0 > ValTy.getSizeInBits())) if ((Shamt != SMPos0) || (SMPos0 + SMSize0 > ValTy.getSizeInBits()))
return SDValue(); return SDValue();
return DAG.getNode(MipsISD::Ins, N->getDebugLoc(), ValTy, Shl.getOperand(0), return DAG.getNode(MipsISD::Ins, SDLoc(N), ValTy, Shl.getOperand(0),
DAG.getConstant(SMPos0, MVT::i32), DAG.getConstant(SMPos0, MVT::i32),
DAG.getConstant(SMSize0, MVT::i32), And0.getOperand(0)); DAG.getConstant(SMSize0, MVT::i32), And0.getOperand(0));
} }
@ -676,7 +676,7 @@ static SDValue performADDCombine(SDNode *N, SelectionDAG &DAG,
return SDValue(); return SDValue();
EVT ValTy = N->getValueType(0); EVT ValTy = N->getValueType(0);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
SDValue Add1 = DAG.getNode(ISD::ADD, DL, ValTy, N->getOperand(0), SDValue Add1 = DAG.getNode(ISD::ADD, DL, ValTy, N->getOperand(0),
Add.getOperand(0)); Add.getOperand(0));
@ -1383,7 +1383,7 @@ SDValue MipsTargetLowering::lowerBR_JT(SDValue Op, SelectionDAG &DAG) const {
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Table = Op.getOperand(1); SDValue Table = Op.getOperand(1);
SDValue Index = Op.getOperand(2); SDValue Index = Op.getOperand(2);
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT PTy = getPointerTy(); EVT PTy = getPointerTy();
unsigned EntrySize = unsigned EntrySize =
DAG.getMachineFunction().getJumpTableInfo()->getEntrySize(*getDataLayout()); DAG.getMachineFunction().getJumpTableInfo()->getEntrySize(*getDataLayout());
@ -1416,7 +1416,7 @@ lowerBRCOND(SDValue Op, SelectionDAG &DAG) const
// the block to branch to if the condition is true. // the block to branch to if the condition is true.
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Dest = Op.getOperand(2); SDValue Dest = Op.getOperand(2);
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue CondRes = createFPCmp(DAG, Op.getOperand(1)); SDValue CondRes = createFPCmp(DAG, Op.getOperand(1));
@ -1443,13 +1443,13 @@ lowerSELECT(SDValue Op, SelectionDAG &DAG) const
return Op; return Op;
return createCMovFP(DAG, Cond, Op.getOperand(1), Op.getOperand(2), return createCMovFP(DAG, Cond, Op.getOperand(1), Op.getOperand(2),
Op.getDebugLoc()); SDLoc(Op));
} }
SDValue MipsTargetLowering:: SDValue MipsTargetLowering::
lowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const lowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const
{ {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT Ty = Op.getOperand(0).getValueType(); EVT Ty = Op.getOperand(0).getValueType();
SDValue Cond = DAG.getNode(ISD::SETCC, DL, SDValue Cond = DAG.getNode(ISD::SETCC, DL,
getSetCCResultType(*DAG.getContext(), Ty), getSetCCResultType(*DAG.getContext(), Ty),
@ -1469,13 +1469,13 @@ SDValue MipsTargetLowering::lowerSETCC(SDValue Op, SelectionDAG &DAG) const {
SDValue True = DAG.getConstant(1, MVT::i32); SDValue True = DAG.getConstant(1, MVT::i32);
SDValue False = DAG.getConstant(0, MVT::i32); SDValue False = DAG.getConstant(0, MVT::i32);
return createCMovFP(DAG, Cond, True, False, Op.getDebugLoc()); return createCMovFP(DAG, Cond, True, False, SDLoc(Op));
} }
SDValue MipsTargetLowering::lowerGlobalAddress(SDValue Op, SDValue MipsTargetLowering::lowerGlobalAddress(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
// FIXME there isn't actually debug info here // FIXME there isn't actually debug info here
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal(); const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
if (getTargetMachine().getRelocationModel() != Reloc::PIC_ && !IsN64) { if (getTargetMachine().getRelocationModel() != Reloc::PIC_ && !IsN64) {
@ -1523,7 +1523,7 @@ lowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const
// Local Exec TLS Model. // Local Exec TLS Model.
GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op); GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
DebugLoc DL = GA->getDebugLoc(); SDLoc DL(GA);
const GlobalValue *GV = GA->getGlobal(); const GlobalValue *GV = GA->getGlobal();
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
@ -1628,7 +1628,7 @@ SDValue MipsTargetLowering::lowerVASTART(SDValue Op, SelectionDAG &DAG) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
MipsFunctionInfo *FuncInfo = MF.getInfo<MipsFunctionInfo>(); MipsFunctionInfo *FuncInfo = MF.getInfo<MipsFunctionInfo>();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue FI = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), SDValue FI = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(),
getPointerTy()); getPointerTy());
@ -1644,7 +1644,7 @@ static SDValue lowerFCOPYSIGN32(SDValue Op, SelectionDAG &DAG, bool HasR2) {
EVT TyY = Op.getOperand(1).getValueType(); EVT TyY = Op.getOperand(1).getValueType();
SDValue Const1 = DAG.getConstant(1, MVT::i32); SDValue Const1 = DAG.getConstant(1, MVT::i32);
SDValue Const31 = DAG.getConstant(31, MVT::i32); SDValue Const31 = DAG.getConstant(31, MVT::i32);
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue Res; SDValue Res;
// If operand is of type f64, extract the upper 32-bit. Otherwise, bitcast it // If operand is of type f64, extract the upper 32-bit. Otherwise, bitcast it
@ -1689,7 +1689,7 @@ static SDValue lowerFCOPYSIGN64(SDValue Op, SelectionDAG &DAG, bool HasR2) {
unsigned WidthY = Op.getOperand(1).getValueSizeInBits(); unsigned WidthY = Op.getOperand(1).getValueSizeInBits();
EVT TyX = MVT::getIntegerVT(WidthX), TyY = MVT::getIntegerVT(WidthY); EVT TyX = MVT::getIntegerVT(WidthX), TyY = MVT::getIntegerVT(WidthY);
SDValue Const1 = DAG.getConstant(1, MVT::i32); SDValue Const1 = DAG.getConstant(1, MVT::i32);
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
// Bitcast to integer nodes. // Bitcast to integer nodes.
SDValue X = DAG.getNode(ISD::BITCAST, DL, TyX, Op.getOperand(0)); SDValue X = DAG.getNode(ISD::BITCAST, DL, TyX, Op.getOperand(0));
@ -1742,7 +1742,7 @@ MipsTargetLowering::lowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const {
static SDValue lowerFABS32(SDValue Op, SelectionDAG &DAG, bool HasR2) { static SDValue lowerFABS32(SDValue Op, SelectionDAG &DAG, bool HasR2) {
SDValue Res, Const1 = DAG.getConstant(1, MVT::i32); SDValue Res, Const1 = DAG.getConstant(1, MVT::i32);
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
// If operand is of type f64, extract the upper 32-bit. Otherwise, bitcast it // If operand is of type f64, extract the upper 32-bit. Otherwise, bitcast it
// to i32. // to i32.
@ -1771,7 +1771,7 @@ static SDValue lowerFABS32(SDValue Op, SelectionDAG &DAG, bool HasR2) {
static SDValue lowerFABS64(SDValue Op, SelectionDAG &DAG, bool HasR2) { static SDValue lowerFABS64(SDValue Op, SelectionDAG &DAG, bool HasR2) {
SDValue Res, Const1 = DAG.getConstant(1, MVT::i32); SDValue Res, Const1 = DAG.getConstant(1, MVT::i32);
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
// Bitcast to integer node. // Bitcast to integer node.
SDValue X = DAG.getNode(ISD::BITCAST, DL, MVT::i64, Op.getOperand(0)); SDValue X = DAG.getNode(ISD::BITCAST, DL, MVT::i64, Op.getOperand(0));
@ -1806,7 +1806,7 @@ lowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const {
MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo(); MachineFrameInfo *MFI = DAG.getMachineFunction().getFrameInfo();
MFI->setFrameAddressIsTaken(true); MFI->setFrameAddressIsTaken(true);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), DL, SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), DL,
IsN64 ? Mips::FP_64 : Mips::FP, VT); IsN64 ? Mips::FP_64 : Mips::FP, VT);
return FrameAddr; return FrameAddr;
@ -1826,7 +1826,7 @@ SDValue MipsTargetLowering::lowerRETURNADDR(SDValue Op,
// Return RA, which contains the return address. Mark it an implicit live-in. // Return RA, which contains the return address. Mark it an implicit live-in.
unsigned Reg = MF.addLiveIn(RA, getRegClassFor(VT)); unsigned Reg = MF.addLiveIn(RA, getRegClassFor(VT));
return DAG.getCopyFromReg(DAG.getEntryNode(), Op.getDebugLoc(), Reg, VT); return DAG.getCopyFromReg(DAG.getEntryNode(), SDLoc(Op), Reg, VT);
} }
// An EH_RETURN is the result of lowering llvm.eh.return which in turn is // An EH_RETURN is the result of lowering llvm.eh.return which in turn is
@ -1842,7 +1842,7 @@ SDValue MipsTargetLowering::lowerEH_RETURN(SDValue Op, SelectionDAG &DAG)
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Offset = Op.getOperand(1); SDValue Offset = Op.getOperand(1);
SDValue Handler = Op.getOperand(2); SDValue Handler = Op.getOperand(2);
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT Ty = IsN64 ? MVT::i64 : MVT::i32; EVT Ty = IsN64 ? MVT::i64 : MVT::i32;
// Store stack offset in V1, store jump target in V0. Glue CopyToReg and // Store stack offset in V1, store jump target in V0. Glue CopyToReg and
@ -1862,14 +1862,14 @@ SDValue MipsTargetLowering::lowerATOMIC_FENCE(SDValue Op,
// FIXME: Need pseudo-fence for 'singlethread' fences // FIXME: Need pseudo-fence for 'singlethread' fences
// FIXME: Set SType for weaker fences where supported/appropriate. // FIXME: Set SType for weaker fences where supported/appropriate.
unsigned SType = 0; unsigned SType = 0;
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
return DAG.getNode(MipsISD::Sync, DL, MVT::Other, Op.getOperand(0), return DAG.getNode(MipsISD::Sync, DL, MVT::Other, Op.getOperand(0),
DAG.getConstant(SType, MVT::i32)); DAG.getConstant(SType, MVT::i32));
} }
SDValue MipsTargetLowering::lowerShiftLeftParts(SDValue Op, SDValue MipsTargetLowering::lowerShiftLeftParts(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue Lo = Op.getOperand(0), Hi = Op.getOperand(1); SDValue Lo = Op.getOperand(0), Hi = Op.getOperand(1);
SDValue Shamt = Op.getOperand(2); SDValue Shamt = Op.getOperand(2);
@ -1900,7 +1900,7 @@ SDValue MipsTargetLowering::lowerShiftLeftParts(SDValue Op,
SDValue MipsTargetLowering::lowerShiftRightParts(SDValue Op, SelectionDAG &DAG, SDValue MipsTargetLowering::lowerShiftRightParts(SDValue Op, SelectionDAG &DAG,
bool IsSRA) const { bool IsSRA) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue Lo = Op.getOperand(0), Hi = Op.getOperand(1); SDValue Lo = Op.getOperand(0), Hi = Op.getOperand(1);
SDValue Shamt = Op.getOperand(2); SDValue Shamt = Op.getOperand(2);
@ -1944,7 +1944,7 @@ static SDValue createLoadLR(unsigned Opc, SelectionDAG &DAG, LoadSDNode *LD,
SDValue Ptr = LD->getBasePtr(); SDValue Ptr = LD->getBasePtr();
EVT VT = LD->getValueType(0), MemVT = LD->getMemoryVT(); EVT VT = LD->getValueType(0), MemVT = LD->getMemoryVT();
EVT BasePtrVT = Ptr.getValueType(); EVT BasePtrVT = Ptr.getValueType();
DebugLoc DL = LD->getDebugLoc(); SDLoc DL(LD);
SDVTList VTList = DAG.getVTList(VT, MVT::Other); SDVTList VTList = DAG.getVTList(VT, MVT::Other);
if (Offset) if (Offset)
@ -2010,7 +2010,7 @@ SDValue MipsTargetLowering::lowerLOAD(SDValue Op, SelectionDAG &DAG) const {
// (set tmp1, (lwr baseptr, tmp0)) // (set tmp1, (lwr baseptr, tmp0))
// (set tmp2, (shl tmp1, 32)) // (set tmp2, (shl tmp1, 32))
// (set dst, (srl tmp2, 32)) // (set dst, (srl tmp2, 32))
DebugLoc DL = LD->getDebugLoc(); SDLoc DL(LD);
SDValue Const32 = DAG.getConstant(32, MVT::i32); SDValue Const32 = DAG.getConstant(32, MVT::i32);
SDValue SLL = DAG.getNode(ISD::SHL, DL, MVT::i64, LWR, Const32); SDValue SLL = DAG.getNode(ISD::SHL, DL, MVT::i64, LWR, Const32);
SDValue SRL = DAG.getNode(ISD::SRL, DL, MVT::i64, SLL, Const32); SDValue SRL = DAG.getNode(ISD::SRL, DL, MVT::i64, SLL, Const32);
@ -2022,7 +2022,7 @@ static SDValue createStoreLR(unsigned Opc, SelectionDAG &DAG, StoreSDNode *SD,
SDValue Chain, unsigned Offset) { SDValue Chain, unsigned Offset) {
SDValue Ptr = SD->getBasePtr(), Value = SD->getValue(); SDValue Ptr = SD->getBasePtr(), Value = SD->getValue();
EVT MemVT = SD->getMemoryVT(), BasePtrVT = Ptr.getValueType(); EVT MemVT = SD->getMemoryVT(), BasePtrVT = Ptr.getValueType();
DebugLoc DL = SD->getDebugLoc(); SDLoc DL(SD);
SDVTList VTList = DAG.getVTList(MVT::Other); SDVTList VTList = DAG.getVTList(MVT::Other);
if (Offset) if (Offset)
@ -2071,10 +2071,10 @@ static SDValue lowerFP_TO_SINT_STORE(StoreSDNode *SD, SelectionDAG &DAG) {
return SDValue(); return SDValue();
EVT FPTy = EVT::getFloatingPointVT(Val.getValueSizeInBits()); EVT FPTy = EVT::getFloatingPointVT(Val.getValueSizeInBits());
SDValue Tr = DAG.getNode(MipsISD::TruncIntFP, Val.getDebugLoc(), FPTy, SDValue Tr = DAG.getNode(MipsISD::TruncIntFP, SDLoc(Val), FPTy,
Val.getOperand(0)); Val.getOperand(0));
return DAG.getStore(SD->getChain(), SD->getDebugLoc(), Tr, SD->getBasePtr(), return DAG.getStore(SD->getChain(), SDLoc(SD), Tr, SD->getBasePtr(),
SD->getPointerInfo(), SD->isVolatile(), SD->getPointerInfo(), SD->isVolatile(),
SD->isNonTemporal(), SD->getAlignment()); SD->isNonTemporal(), SD->getAlignment());
} }
@ -2108,16 +2108,16 @@ SDValue MipsTargetLowering::lowerADD(SDValue Op, SelectionDAG &DAG) const {
EVT ValTy = Op->getValueType(0); EVT ValTy = Op->getValueType(0);
int FI = MFI->CreateFixedObject(Op.getValueSizeInBits() / 8, 0, false); int FI = MFI->CreateFixedObject(Op.getValueSizeInBits() / 8, 0, false);
SDValue InArgsAddr = DAG.getFrameIndex(FI, ValTy); SDValue InArgsAddr = DAG.getFrameIndex(FI, ValTy);
return DAG.getNode(ISD::ADD, Op->getDebugLoc(), ValTy, InArgsAddr, return DAG.getNode(ISD::ADD, SDLoc(Op), ValTy, InArgsAddr,
DAG.getConstant(0, ValTy)); DAG.getConstant(0, ValTy));
} }
SDValue MipsTargetLowering::lowerFP_TO_SINT(SDValue Op, SDValue MipsTargetLowering::lowerFP_TO_SINT(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
EVT FPTy = EVT::getFloatingPointVT(Op.getValueSizeInBits()); EVT FPTy = EVT::getFloatingPointVT(Op.getValueSizeInBits());
SDValue Trunc = DAG.getNode(MipsISD::TruncIntFP, Op.getDebugLoc(), FPTy, SDValue Trunc = DAG.getNode(MipsISD::TruncIntFP, SDLoc(Op), FPTy,
Op.getOperand(0)); Op.getOperand(0));
return DAG.getNode(ISD::BITCAST, Op.getDebugLoc(), Op.getValueType(), Trunc); return DAG.getNode(ISD::BITCAST, SDLoc(Op), Op.getValueType(), Trunc);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
@ -2238,7 +2238,7 @@ static unsigned getNextIntArgReg(unsigned Reg) {
SDValue SDValue
MipsTargetLowering::passArgOnStack(SDValue StackPtr, unsigned Offset, MipsTargetLowering::passArgOnStack(SDValue StackPtr, unsigned Offset,
SDValue Chain, SDValue Arg, DebugLoc DL, SDValue Chain, SDValue Arg, SDLoc DL,
bool IsTailCall, SelectionDAG &DAG) const { bool IsTailCall, SelectionDAG &DAG) const {
if (!IsTailCall) { if (!IsTailCall) {
SDValue PtrOff = DAG.getNode(ISD::ADD, DL, getPointerTy(), StackPtr, SDValue PtrOff = DAG.getNode(ISD::ADD, DL, getPointerTy(), StackPtr,
@ -2313,7 +2313,7 @@ SDValue
MipsTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI, MipsTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG; SelectionDAG &DAG = CLI.DAG;
DebugLoc &DL = CLI.DL; SDLoc DL = CLI.DL;
SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs; SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
SmallVector<SDValue, 32> &OutVals = CLI.OutVals; SmallVector<SDValue, 32> &OutVals = CLI.OutVals;
SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins; SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;
@ -2513,7 +2513,7 @@ SDValue
MipsTargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag, MipsTargetLowering::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,
DebugLoc DL, SelectionDAG &DAG, SDLoc DL, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals, SmallVectorImpl<SDValue> &InVals,
const SDNode *CallNode, const SDNode *CallNode,
const Type *RetTy) const { const Type *RetTy) const {
@ -2552,7 +2552,7 @@ MipsTargetLowering::LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool IsVarArg, bool IsVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc DL, SelectionDAG &DAG, SDLoc DL, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) SmallVectorImpl<SDValue> &InVals)
const { const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
@ -2718,7 +2718,7 @@ MipsTargetLowering::LowerReturn(SDValue Chain,
CallingConv::ID CallConv, bool IsVarArg, CallingConv::ID CallConv, bool IsVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc DL, SelectionDAG &DAG) const { SDLoc DL, SelectionDAG &DAG) const {
// CCValAssign - represent the assignment of // CCValAssign - represent the assignment of
// the return value to a location // the return value to a location
SmallVector<CCValAssign, 16> RVLocs; SmallVector<CCValAssign, 16> RVLocs;
@ -3328,7 +3328,7 @@ MVT MipsTargetLowering::MipsCC::getRegVT(MVT VT, const Type *OrigTy,
} }
void MipsTargetLowering:: void MipsTargetLowering::
copyByValRegs(SDValue Chain, DebugLoc DL, std::vector<SDValue> &OutChains, copyByValRegs(SDValue Chain, SDLoc DL, std::vector<SDValue> &OutChains,
SelectionDAG &DAG, const ISD::ArgFlagsTy &Flags, SelectionDAG &DAG, const ISD::ArgFlagsTy &Flags,
SmallVectorImpl<SDValue> &InVals, const Argument *FuncArg, SmallVectorImpl<SDValue> &InVals, const Argument *FuncArg,
const MipsCC &CC, const ByValArgInfo &ByVal) const { const MipsCC &CC, const ByValArgInfo &ByVal) const {
@ -3372,7 +3372,7 @@ copyByValRegs(SDValue Chain, DebugLoc DL, std::vector<SDValue> &OutChains,
// Copy byVal arg to registers and stack. // Copy byVal arg to registers and stack.
void MipsTargetLowering:: void MipsTargetLowering::
passByValArg(SDValue Chain, DebugLoc DL, passByValArg(SDValue Chain, SDLoc DL,
std::deque< std::pair<unsigned, SDValue> > &RegsToPass, std::deque< std::pair<unsigned, SDValue> > &RegsToPass,
SmallVector<SDValue, 8> &MemOpChains, SDValue StackPtr, SmallVector<SDValue, 8> &MemOpChains, SDValue StackPtr,
MachineFrameInfo *MFI, SelectionDAG &DAG, SDValue Arg, MachineFrameInfo *MFI, SelectionDAG &DAG, SDValue Arg,
@ -3470,7 +3470,7 @@ passByValArg(SDValue Chain, DebugLoc DL,
void void
MipsTargetLowering::writeVarArgRegs(std::vector<SDValue> &OutChains, MipsTargetLowering::writeVarArgRegs(std::vector<SDValue> &OutChains,
const MipsCC &CC, SDValue Chain, const MipsCC &CC, SDValue Chain,
DebugLoc DL, SelectionDAG &DAG) const { SDLoc DL, SelectionDAG &DAG) const {
unsigned NumRegs = CC.numIntArgRegs(); unsigned NumRegs = CC.numIntArgRegs();
const uint16_t *ArgRegs = CC.intArgRegs(); const uint16_t *ArgRegs = CC.intArgRegs();
const CCState &CCInfo = CC.getCCInfo(); const CCState &CCInfo = CC.getCCInfo();

14
lib/Target/Mips/MipsISelLowering.h
View File

@ -336,7 +336,7 @@ namespace llvm {
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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals, SmallVectorImpl<SDValue> &InVals,
const SDNode *CallNode, const Type *RetTy) const; const SDNode *CallNode, const Type *RetTy) const;
@ -376,7 +376,7 @@ namespace llvm {
/// copyByValArg - Copy argument registers which were used to pass a byval /// copyByValArg - Copy argument registers which were used to pass a byval
/// argument to the stack. Create a stack frame object for the byval /// argument to the stack. Create a stack frame object for the byval
/// argument. /// argument.
void copyByValRegs(SDValue Chain, DebugLoc DL, void copyByValRegs(SDValue Chain, SDLoc DL,
std::vector<SDValue> &OutChains, SelectionDAG &DAG, std::vector<SDValue> &OutChains, SelectionDAG &DAG,
const ISD::ArgFlagsTy &Flags, const ISD::ArgFlagsTy &Flags,
SmallVectorImpl<SDValue> &InVals, SmallVectorImpl<SDValue> &InVals,
@ -384,7 +384,7 @@ namespace llvm {
const MipsCC &CC, const ByValArgInfo &ByVal) const; const MipsCC &CC, const ByValArgInfo &ByVal) const;
/// passByValArg - Pass a byval argument in registers or on stack. /// passByValArg - Pass a byval argument in registers or on stack.
void passByValArg(SDValue Chain, DebugLoc DL, void passByValArg(SDValue Chain, SDLoc DL,
std::deque< std::pair<unsigned, SDValue> > &RegsToPass, std::deque< std::pair<unsigned, SDValue> > &RegsToPass,
SmallVector<SDValue, 8> &MemOpChains, SDValue StackPtr, SmallVector<SDValue, 8> &MemOpChains, SDValue StackPtr,
MachineFrameInfo *MFI, SelectionDAG &DAG, SDValue Arg, MachineFrameInfo *MFI, SelectionDAG &DAG, SDValue Arg,
@ -395,17 +395,17 @@ namespace llvm {
/// to the stack. Also create a stack frame object for the first variable /// to the stack. Also create a stack frame object for the first variable
/// argument. /// argument.
void writeVarArgRegs(std::vector<SDValue> &OutChains, const MipsCC &CC, void writeVarArgRegs(std::vector<SDValue> &OutChains, const MipsCC &CC,
SDValue Chain, DebugLoc DL, SelectionDAG &DAG) const; SDValue Chain, SDLoc DL, SelectionDAG &DAG) const;
virtual SDValue virtual SDValue
LowerFormalArguments(SDValue Chain, LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue passArgOnStack(SDValue StackPtr, unsigned Offset, SDValue Chain, SDValue passArgOnStack(SDValue StackPtr, unsigned Offset, SDValue Chain,
SDValue Arg, DebugLoc DL, bool IsTailCall, SDValue Arg, SDLoc DL, bool IsTailCall,
SelectionDAG &DAG) const; SelectionDAG &DAG) const;
virtual SDValue virtual SDValue
@ -423,7 +423,7 @@ namespace llvm {
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const; SDLoc dl, SelectionDAG &DAG) const;
// Inline asm support // Inline asm support
ConstraintType getConstraintType(const std::string &Constraint) const; ConstraintType getConstraintType(const std::string &Constraint) const;

8
lib/Target/Mips/MipsSEISelDAGToDAG.cpp
View File

@ -214,7 +214,7 @@ void MipsSEDAGToDAGISel::processFunctionAfterISel(MachineFunction &MF) {
} }
SDNode *MipsSEDAGToDAGISel::selectAddESubE(unsigned MOp, SDValue InFlag, SDNode *MipsSEDAGToDAGISel::selectAddESubE(unsigned MOp, SDValue InFlag,
SDValue CmpLHS, DebugLoc DL, SDValue CmpLHS, SDLoc DL,
SDNode *Node) const { SDNode *Node) const {
unsigned Opc = InFlag.getOpcode(); (void)Opc; unsigned Opc = InFlag.getOpcode(); (void)Opc;
@ -316,7 +316,7 @@ bool MipsSEDAGToDAGISel::selectIntAddr(SDValue Addr, SDValue &Base,
std::pair<bool, SDNode*> MipsSEDAGToDAGISel::selectNode(SDNode *Node) { std::pair<bool, SDNode*> MipsSEDAGToDAGISel::selectNode(SDNode *Node) {
unsigned Opcode = Node->getOpcode(); unsigned Opcode = Node->getOpcode();
DebugLoc DL = Node->getDebugLoc(); SDLoc DL(Node);
/// ///
// Instruction Selection not handled by the auto-generated // Instruction Selection not handled by the auto-generated
@ -374,7 +374,7 @@ std::pair<bool, SDNode*> MipsSEDAGToDAGISel::selectNode(SDNode *Node) {
AnalyzeImm.Analyze(Imm, Size, false); AnalyzeImm.Analyze(Imm, Size, false);
MipsAnalyzeImmediate::InstSeq::const_iterator Inst = Seq.begin(); MipsAnalyzeImmediate::InstSeq::const_iterator Inst = Seq.begin();
DebugLoc DL = CN->getDebugLoc(); SDLoc DL(CN);
SDNode *RegOpnd; SDNode *RegOpnd;
SDValue ImmOpnd = CurDAG->getTargetConstant(SignExtend64<16>(Inst->ImmOpnd), SDValue ImmOpnd = CurDAG->getTargetConstant(SignExtend64<16>(Inst->ImmOpnd),
MVT::i64); MVT::i64);
@ -416,7 +416,7 @@ std::pair<bool, SDNode*> MipsSEDAGToDAGISel::selectNode(SDNode *Node) {
} }
SDNode *Rdhwr = SDNode *Rdhwr =
CurDAG->getMachineNode(RdhwrOpc, Node->getDebugLoc(), CurDAG->getMachineNode(RdhwrOpc, SDLoc(Node),
Node->getValueType(0), Node->getValueType(0),
CurDAG->getRegister(SrcReg, PtrVT)); CurDAG->getRegister(SrcReg, PtrVT));
SDValue Chain = CurDAG->getCopyToReg(CurDAG->getEntryNode(), DL, DestReg, SDValue Chain = CurDAG->getCopyToReg(CurDAG->getEntryNode(), DL, DestReg,

4
lib/Target/Mips/MipsSEISelDAGToDAG.h
View File

@ -32,11 +32,11 @@ private:
bool replaceUsesWithZeroReg(MachineRegisterInfo *MRI, const MachineInstr&); bool replaceUsesWithZeroReg(MachineRegisterInfo *MRI, const MachineInstr&);
std::pair<SDNode*, SDNode*> selectMULT(SDNode *N, unsigned Opc, DebugLoc dl, std::pair<SDNode*, SDNode*> selectMULT(SDNode *N, unsigned Opc, SDLoc dl,
EVT Ty, bool HasLo, bool HasHi); EVT Ty, bool HasLo, bool HasHi);
SDNode *selectAddESubE(unsigned MOp, SDValue InFlag, SDValue CmpLHS, SDNode *selectAddESubE(unsigned MOp, SDValue InFlag, SDValue CmpLHS,
DebugLoc DL, SDNode *Node) const; SDLoc DL, SDNode *Node) const;
virtual bool selectAddrRegImm(SDValue Addr, SDValue &Base, virtual bool selectAddrRegImm(SDValue Addr, SDValue &Base,
SDValue &Offset) const; SDValue &Offset) const;

18
lib/Target/Mips/MipsSEISelLowering.cpp
View File

@ -186,7 +186,7 @@ static bool selectMADD(SDNode *ADDENode, SelectionDAG *CurDAG) {
if (!MultHi.hasOneUse() || !MultLo.hasOneUse()) if (!MultHi.hasOneUse() || !MultLo.hasOneUse())
return false; return false;
DebugLoc DL = ADDENode->getDebugLoc(); SDLoc DL(ADDENode);
// Initialize accumulator. // Initialize accumulator.
SDValue ACCIn = CurDAG->getNode(MipsISD::InsertLOHI, DL, MVT::Untyped, SDValue ACCIn = CurDAG->getNode(MipsISD::InsertLOHI, DL, MVT::Untyped,
@ -262,7 +262,7 @@ static bool selectMSUB(SDNode *SUBENode, SelectionDAG *CurDAG) {
if (!MultHi.hasOneUse() || !MultLo.hasOneUse()) if (!MultHi.hasOneUse() || !MultLo.hasOneUse())
return false; return false;
DebugLoc DL = SUBENode->getDebugLoc(); SDLoc DL(SUBENode);
// Initialize accumulator. // Initialize accumulator.
SDValue ACCIn = CurDAG->getNode(MipsISD::InsertLOHI, DL, MVT::Untyped, SDValue ACCIn = CurDAG->getNode(MipsISD::InsertLOHI, DL, MVT::Untyped,
@ -337,7 +337,7 @@ static SDValue performDSPShiftCombine(unsigned Opc, SDNode *N, EVT Ty,
(SplatValue.getZExtValue() >= EltSize)) (SplatValue.getZExtValue() >= EltSize))
return SDValue(); return SDValue();
return DAG.getNode(Opc, N->getDebugLoc(), Ty, N->getOperand(0), return DAG.getNode(Opc, SDLoc(N), Ty, N->getOperand(0),
DAG.getConstant(SplatValue.getZExtValue(), MVT::i32)); DAG.getConstant(SplatValue.getZExtValue(), MVT::i32));
} }
@ -402,7 +402,7 @@ static SDValue performSETCCCombine(SDNode *N, SelectionDAG &DAG) {
if (!isLegalDSPCondCode(Ty, cast<CondCodeSDNode>(N->getOperand(2))->get())) if (!isLegalDSPCondCode(Ty, cast<CondCodeSDNode>(N->getOperand(2))->get()))
return SDValue(); return SDValue();
return DAG.getNode(MipsISD::SETCC_DSP, N->getDebugLoc(), Ty, N->getOperand(0), return DAG.getNode(MipsISD::SETCC_DSP, SDLoc(N), Ty, N->getOperand(0),
N->getOperand(1), N->getOperand(2)); N->getOperand(1), N->getOperand(2));
} }
@ -417,7 +417,7 @@ static SDValue performVSELECTCombine(SDNode *N, SelectionDAG &DAG) {
if (SetCC.getOpcode() != MipsISD::SETCC_DSP) if (SetCC.getOpcode() != MipsISD::SETCC_DSP)
return SDValue(); return SDValue();
return DAG.getNode(MipsISD::SELECT_CC_DSP, N->getDebugLoc(), Ty, return DAG.getNode(MipsISD::SELECT_CC_DSP, SDLoc(N), Ty,
SetCC.getOperand(0), SetCC.getOperand(1), N->getOperand(1), SetCC.getOperand(0), SetCC.getOperand(1), N->getOperand(1),
N->getOperand(2), SetCC.getOperand(2)); N->getOperand(2), SetCC.getOperand(2));
} }
@ -500,7 +500,7 @@ SDValue MipsSETargetLowering::lowerMulDiv(SDValue Op, unsigned NewOpc,
bool HasLo, bool HasHi, bool HasLo, bool HasHi,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
EVT Ty = Op.getOperand(0).getValueType(); EVT Ty = Op.getOperand(0).getValueType();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue Mult = DAG.getNode(NewOpc, DL, MVT::Untyped, SDValue Mult = DAG.getNode(NewOpc, DL, MVT::Untyped,
Op.getOperand(0), Op.getOperand(1)); Op.getOperand(0), Op.getOperand(1));
SDValue Lo, Hi; SDValue Lo, Hi;
@ -520,7 +520,7 @@ SDValue MipsSETargetLowering::lowerMulDiv(SDValue Op, unsigned NewOpc,
} }
static SDValue initAccumulator(SDValue In, DebugLoc DL, SelectionDAG &DAG) { static SDValue initAccumulator(SDValue In, SDLoc DL, SelectionDAG &DAG) {
SDValue InLo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, In, SDValue InLo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, In,
DAG.getConstant(0, MVT::i32)); DAG.getConstant(0, MVT::i32));
SDValue InHi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, In, SDValue InHi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, In,
@ -528,7 +528,7 @@ static SDValue initAccumulator(SDValue In, DebugLoc DL, SelectionDAG &DAG) {
return DAG.getNode(MipsISD::InsertLOHI, DL, MVT::Untyped, InLo, InHi); return DAG.getNode(MipsISD::InsertLOHI, DL, MVT::Untyped, InLo, InHi);
} }
static SDValue extractLOHI(SDValue Op, DebugLoc DL, SelectionDAG &DAG) { static SDValue extractLOHI(SDValue Op, SDLoc DL, SelectionDAG &DAG) {
SDValue Lo = DAG.getNode(MipsISD::ExtractLOHI, DL, MVT::i32, Op, SDValue Lo = DAG.getNode(MipsISD::ExtractLOHI, DL, MVT::i32, Op,
DAG.getConstant(Mips::sub_lo, MVT::i32)); DAG.getConstant(Mips::sub_lo, MVT::i32));
SDValue Hi = DAG.getNode(MipsISD::ExtractLOHI, DL, MVT::i32, Op, SDValue Hi = DAG.getNode(MipsISD::ExtractLOHI, DL, MVT::i32, Op,
@ -549,7 +549,7 @@ static SDValue extractLOHI(SDValue Op, DebugLoc DL, SelectionDAG &DAG) {
// out64 = merge-values (v0, v1) // out64 = merge-values (v0, v1)
// //
static SDValue lowerDSPIntr(SDValue Op, SelectionDAG &DAG, unsigned Opc) { static SDValue lowerDSPIntr(SDValue Op, SelectionDAG &DAG, unsigned Opc) {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
bool HasChainIn = Op->getOperand(0).getValueType() == MVT::Other; bool HasChainIn = Op->getOperand(0).getValueType() == MVT::Other;
SmallVector<SDValue, 3> Ops; SmallVector<SDValue, 3> Ops;
unsigned OpNo = 0; unsigned OpNo = 0;

10
lib/Target/NVPTX/NVPTXISelDAGToDAG.cpp
View File

@ -162,7 +162,7 @@ static unsigned int getCodeAddrSpace(MemSDNode *N,
} }
SDNode *NVPTXDAGToDAGISel::SelectLoad(SDNode *N) { SDNode *NVPTXDAGToDAGISel::SelectLoad(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
LoadSDNode *LD = cast<LoadSDNode>(N); LoadSDNode *LD = cast<LoadSDNode>(N);
EVT LoadedVT = LD->getMemoryVT(); EVT LoadedVT = LD->getMemoryVT();
SDNode *NVPTXLD = NULL; SDNode *NVPTXLD = NULL;
@ -401,7 +401,7 @@ SDNode *NVPTXDAGToDAGISel::SelectLoadVector(SDNode *N) {
SDValue Op1 = N->getOperand(1); SDValue Op1 = N->getOperand(1);
SDValue Addr, Offset, Base; SDValue Addr, Offset, Base;
unsigned Opcode; unsigned Opcode;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
SDNode *LD; SDNode *LD;
MemSDNode *MemSD = cast<MemSDNode>(N); MemSDNode *MemSD = cast<MemSDNode>(N);
EVT LoadedVT = MemSD->getMemoryVT(); EVT LoadedVT = MemSD->getMemoryVT();
@ -782,7 +782,7 @@ SDNode *NVPTXDAGToDAGISel::SelectLDGLDUVector(SDNode *N) {
SDValue Chain = N->getOperand(0); SDValue Chain = N->getOperand(0);
SDValue Op1 = N->getOperand(1); SDValue Op1 = N->getOperand(1);
unsigned Opcode; unsigned Opcode;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
SDNode *LD; SDNode *LD;
EVT RetVT = N->getValueType(0); EVT RetVT = N->getValueType(0);
@ -979,7 +979,7 @@ SDNode *NVPTXDAGToDAGISel::SelectLDGLDUVector(SDNode *N) {
} }
SDNode *NVPTXDAGToDAGISel::SelectStore(SDNode *N) { SDNode *NVPTXDAGToDAGISel::SelectStore(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
StoreSDNode *ST = cast<StoreSDNode>(N); StoreSDNode *ST = cast<StoreSDNode>(N);
EVT StoreVT = ST->getMemoryVT(); EVT StoreVT = ST->getMemoryVT();
SDNode *NVPTXST = NULL; SDNode *NVPTXST = NULL;
@ -1214,7 +1214,7 @@ SDNode *NVPTXDAGToDAGISel::SelectStoreVector(SDNode *N) {
SDValue Op1 = N->getOperand(1); SDValue Op1 = N->getOperand(1);
SDValue Addr, Offset, Base; SDValue Addr, Offset, Base;
unsigned Opcode; unsigned Opcode;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
SDNode *ST; SDNode *ST;
EVT EltVT = Op1.getValueType(); EVT EltVT = Op1.getValueType();
MemSDNode *MemSD = cast<MemSDNode>(N); MemSDNode *MemSD = cast<MemSDNode>(N);

20
lib/Target/NVPTX/NVPTXISelLowering.cpp
View File

@ -275,7 +275,7 @@ bool NVPTXTargetLowering::shouldSplitVectorElementType(EVT VT) const {
SDValue SDValue
NVPTXTargetLowering::LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const { NVPTXTargetLowering::LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal(); const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
Op = DAG.getTargetGlobalAddress(GV, dl, getPointerTy()); Op = DAG.getTargetGlobalAddress(GV, dl, getPointerTy());
return DAG.getNode(NVPTXISD::Wrapper, dl, getPointerTy(), Op); return DAG.getNode(NVPTXISD::Wrapper, dl, getPointerTy(), Op);
@ -435,7 +435,7 @@ std::string NVPTXTargetLowering::getPrototype(
SDValue NVPTXTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI, SDValue NVPTXTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG; SelectionDAG &DAG = CLI.DAG;
DebugLoc &dl = CLI.DL; SDLoc dl = CLI.DL;
SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs; SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
SmallVector<SDValue, 32> &OutVals = CLI.OutVals; SmallVector<SDValue, 32> &OutVals = CLI.OutVals;
SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins; SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;
@ -810,7 +810,7 @@ SDValue NVPTXTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
SDValue SDValue
NVPTXTargetLowering::LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const { NVPTXTargetLowering::LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const {
SDNode *Node = Op.getNode(); SDNode *Node = Op.getNode();
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
SmallVector<SDValue, 8> Ops; SmallVector<SDValue, 8> Ops;
unsigned NumOperands = Node->getNumOperands(); unsigned NumOperands = Node->getNumOperands();
for (unsigned i = 0; i < NumOperands; ++i) { for (unsigned i = 0; i < NumOperands; ++i) {
@ -866,7 +866,7 @@ SDValue NVPTXTargetLowering::LowerLOAD(SDValue Op, SelectionDAG &DAG) const {
SDValue NVPTXTargetLowering::LowerLOADi1(SDValue Op, SelectionDAG &DAG) const { SDValue NVPTXTargetLowering::LowerLOADi1(SDValue Op, SelectionDAG &DAG) const {
SDNode *Node = Op.getNode(); SDNode *Node = Op.getNode();
LoadSDNode *LD = cast<LoadSDNode>(Node); LoadSDNode *LD = cast<LoadSDNode>(Node);
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
assert(LD->getExtensionType() == ISD::NON_EXTLOAD); assert(LD->getExtensionType() == ISD::NON_EXTLOAD);
assert(Node->getValueType(0) == MVT::i1 && assert(Node->getValueType(0) == MVT::i1 &&
"Custom lowering for i1 load only"); "Custom lowering for i1 load only");
@ -896,7 +896,7 @@ SDValue
NVPTXTargetLowering::LowerSTOREVector(SDValue Op, SelectionDAG &DAG) const { NVPTXTargetLowering::LowerSTOREVector(SDValue Op, SelectionDAG &DAG) const {
SDNode *N = Op.getNode(); SDNode *N = Op.getNode();
SDValue Val = N->getOperand(1); SDValue Val = N->getOperand(1);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
EVT ValVT = Val.getValueType(); EVT ValVT = Val.getValueType();
if (ValVT.isVector()) { if (ValVT.isVector()) {
@ -985,7 +985,7 @@ NVPTXTargetLowering::LowerSTOREVector(SDValue Op, SelectionDAG &DAG) const {
// st i8, addr // st i8, addr
SDValue NVPTXTargetLowering::LowerSTOREi1(SDValue Op, SelectionDAG &DAG) const { SDValue NVPTXTargetLowering::LowerSTOREi1(SDValue Op, SelectionDAG &DAG) const {
SDNode *Node = Op.getNode(); SDNode *Node = Op.getNode();
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
StoreSDNode *ST = cast<StoreSDNode>(Node); StoreSDNode *ST = cast<StoreSDNode>(Node);
SDValue Tmp1 = ST->getChain(); SDValue Tmp1 = ST->getChain();
SDValue Tmp2 = ST->getBasePtr(); SDValue Tmp2 = ST->getBasePtr();
@ -1046,7 +1046,7 @@ bool llvm::isImageOrSamplerVal(const Value *arg, const Module *context) {
SDValue NVPTXTargetLowering::LowerFormalArguments( SDValue NVPTXTargetLowering::LowerFormalArguments(
SDValue Chain, CallingConv::ID CallConv, bool isVarArg, SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, DebugLoc dl, SelectionDAG &DAG, const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
const DataLayout *TD = getDataLayout(); const DataLayout *TD = getDataLayout();
@ -1240,7 +1240,7 @@ SDValue NVPTXTargetLowering::LowerFormalArguments(
SDValue NVPTXTargetLowering::LowerReturn( SDValue NVPTXTargetLowering::LowerReturn(
SDValue Chain, CallingConv::ID CallConv, bool isVarArg, SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, DebugLoc dl, const SmallVectorImpl<SDValue> &OutVals, SDLoc dl,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
bool isABI = (nvptxSubtarget.getSmVersion() >= 20); bool isABI = (nvptxSubtarget.getSmVersion() >= 20);
@ -1450,7 +1450,7 @@ unsigned NVPTXTargetLowering::getFunctionAlignment(const Function *) const {
static void ReplaceLoadVector(SDNode *N, SelectionDAG &DAG, static void ReplaceLoadVector(SDNode *N, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &Results) { SmallVectorImpl<SDValue> &Results) {
EVT ResVT = N->getValueType(0); EVT ResVT = N->getValueType(0);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
assert(ResVT.isVector() && "Vector load must have vector type"); assert(ResVT.isVector() && "Vector load must have vector type");
@ -1543,7 +1543,7 @@ static void ReplaceINTRINSIC_W_CHAIN(SDNode *N, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &Results) { SmallVectorImpl<SDValue> &Results) {
SDValue Chain = N->getOperand(0); SDValue Chain = N->getOperand(0);
SDValue Intrin = N->getOperand(1); SDValue Intrin = N->getOperand(1);
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
// Get the intrinsic ID // Get the intrinsic ID
unsigned IntrinNo = cast<ConstantSDNode>(Intrin.getNode())->getZExtValue(); unsigned IntrinNo = cast<ConstantSDNode>(Intrin.getNode())->getZExtValue();

4
lib/Target/NVPTX/NVPTXISelLowering.h
View File

@ -112,7 +112,7 @@ public:
virtual SDValue LowerFormalArguments( virtual SDValue LowerFormalArguments(
SDValue Chain, CallingConv::ID CallConv, bool isVarArg, SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, DebugLoc dl, SelectionDAG &DAG, const SmallVectorImpl<ISD::InputArg> &Ins, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
virtual SDValue virtual SDValue
@ -125,7 +125,7 @@ public:
virtual SDValue virtual SDValue
LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg, LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, DebugLoc dl, const SmallVectorImpl<SDValue> &OutVals, SDLoc dl,
SelectionDAG &DAG) const; SelectionDAG &DAG) const;
virtual void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint, virtual void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint,

12
lib/Target/PowerPC/PPCISelDAGToDAG.cpp
View File

@ -110,7 +110,7 @@ namespace {
/// SelectCC - Select a comparison of the specified values with the /// SelectCC - Select a comparison of the specified values with the
/// specified condition code, returning the CR# of the expression. /// specified condition code, returning the CR# of the expression.
SDValue SelectCC(SDValue LHS, SDValue RHS, ISD::CondCode CC, DebugLoc dl); SDValue SelectCC(SDValue LHS, SDValue RHS, ISD::CondCode CC, SDLoc dl);
/// SelectAddrImm - Returns true if the address N can be represented by /// SelectAddrImm - Returns true if the address N can be represented by
/// a base register plus a signed 16-bit displacement [r+imm]. /// a base register plus a signed 16-bit displacement [r+imm].
@ -397,7 +397,7 @@ bool PPCDAGToDAGISel::isRotateAndMask(SDNode *N, unsigned Mask,
SDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) { SDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) {
SDValue Op0 = N->getOperand(0); SDValue Op0 = N->getOperand(0);
SDValue Op1 = N->getOperand(1); SDValue Op1 = N->getOperand(1);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
APInt LKZ, LKO, RKZ, RKO; APInt LKZ, LKO, RKZ, RKO;
CurDAG->ComputeMaskedBits(Op0, LKZ, LKO); CurDAG->ComputeMaskedBits(Op0, LKZ, LKO);
@ -466,7 +466,7 @@ SDNode *PPCDAGToDAGISel::SelectBitfieldInsert(SDNode *N) {
/// SelectCC - Select a comparison of the specified values with the specified /// SelectCC - Select a comparison of the specified values with the specified
/// condition code, returning the CR# of the expression. /// condition code, returning the CR# of the expression.
SDValue PPCDAGToDAGISel::SelectCC(SDValue LHS, SDValue RHS, SDValue PPCDAGToDAGISel::SelectCC(SDValue LHS, SDValue RHS,
ISD::CondCode CC, DebugLoc dl) { ISD::CondCode CC, SDLoc dl) {
// Always select the LHS. // Always select the LHS.
unsigned Opc; unsigned Opc;
@ -710,7 +710,7 @@ static unsigned int getVCmpEQInst(MVT::SimpleValueType VecVT) {
SDNode *PPCDAGToDAGISel::SelectSETCC(SDNode *N) { SDNode *PPCDAGToDAGISel::SelectSETCC(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
unsigned Imm; unsigned Imm;
ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get(); ISD::CondCode CC = cast<CondCodeSDNode>(N->getOperand(2))->get();
EVT PtrVT = CurDAG->getTargetLoweringInfo().getPointerTy(); EVT PtrVT = CurDAG->getTargetLoweringInfo().getPointerTy();
@ -894,7 +894,7 @@ SDNode *PPCDAGToDAGISel::SelectSETCC(SDNode *N) {
// Select - Convert the specified operand from a target-independent to a // Select - Convert the specified operand from a target-independent to a
// target-specific node if it hasn't already been changed. // target-specific node if it hasn't already been changed.
SDNode *PPCDAGToDAGISel::Select(SDNode *N) { SDNode *PPCDAGToDAGISel::Select(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (N->isMachineOpcode()) if (N->isMachineOpcode())
return NULL; // Already selected. return NULL; // Already selected.
@ -1528,7 +1528,7 @@ void PPCDAGToDAGISel::PostprocessISelDAG() {
// immediate operand, add it now. // immediate operand, add it now.
if (ReplaceFlags) { if (ReplaceFlags) {
if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(ImmOpnd)) { if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(ImmOpnd)) {
DebugLoc dl = GA->getDebugLoc(); SDLoc dl(GA);
const GlobalValue *GV = GA->getGlobal(); const GlobalValue *GV = GA->getGlobal();
ImmOpnd = CurDAG->getTargetGlobalAddress(GV, dl, MVT::i64, 0, Flags); ImmOpnd = CurDAG->getTargetGlobalAddress(GV, dl, MVT::i64, 0, Flags);
} else if (ConstantPoolSDNode *CP = } else if (ConstantPoolSDNode *CP =

123
lib/Target/PowerPC/PPCISelLowering.cpp
View File

@ -1056,7 +1056,7 @@ bool PPCTargetLowering::SelectAddressRegImm(SDValue N, SDValue &Disp,
SelectionDAG &DAG, SelectionDAG &DAG,
bool Aligned) const { bool Aligned) const {
// FIXME dl should come from parent load or store, not from address // FIXME dl should come from parent load or store, not from address
DebugLoc dl = N.getDebugLoc(); SDLoc dl(N);
// If this can be more profitably realized as r+r, fail. // If this can be more profitably realized as r+r, fail.
if (SelectAddressRegReg(N, Disp, Base, DAG)) if (SelectAddressRegReg(N, Disp, Base, DAG))
return false; return false;
@ -1166,7 +1166,6 @@ bool PPCTargetLowering::SelectAddressRegRegOnly(SDValue N, SDValue &Base,
return true; return true;
} }
/// 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.
@ -1284,7 +1283,7 @@ static SDValue LowerLabelRef(SDValue HiPart, SDValue LoPart, bool isPIC,
SelectionDAG &DAG) { SelectionDAG &DAG) {
EVT PtrVT = HiPart.getValueType(); EVT PtrVT = HiPart.getValueType();
SDValue Zero = DAG.getConstant(0, PtrVT); SDValue Zero = DAG.getConstant(0, PtrVT);
DebugLoc DL = HiPart.getDebugLoc(); SDLoc DL(HiPart);
SDValue Hi = DAG.getNode(PPCISD::Hi, DL, PtrVT, HiPart, Zero); SDValue Hi = DAG.getNode(PPCISD::Hi, DL, PtrVT, HiPart, Zero);
SDValue Lo = DAG.getNode(PPCISD::Lo, DL, PtrVT, LoPart, Zero); SDValue Lo = DAG.getNode(PPCISD::Lo, DL, PtrVT, LoPart, Zero);
@ -1309,7 +1308,7 @@ SDValue PPCTargetLowering::LowerConstantPool(SDValue Op,
// The actual address of the GlobalValue is stored in the TOC. // The actual address of the GlobalValue is stored in the TOC.
if (PPCSubTarget.isSVR4ABI() && PPCSubTarget.isPPC64()) { if (PPCSubTarget.isSVR4ABI() && PPCSubTarget.isPPC64()) {
SDValue GA = DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment(), 0); SDValue GA = DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment(), 0);
return DAG.getNode(PPCISD::TOC_ENTRY, CP->getDebugLoc(), MVT::i64, GA, return DAG.getNode(PPCISD::TOC_ENTRY, SDLoc(CP), MVT::i64, GA,
DAG.getRegister(PPC::X2, MVT::i64)); DAG.getRegister(PPC::X2, MVT::i64));
} }
@ -1330,7 +1329,7 @@ SDValue PPCTargetLowering::LowerJumpTable(SDValue Op, SelectionDAG &DAG) const {
// The actual address of the GlobalValue is stored in the TOC. // The actual address of the GlobalValue is stored in the TOC.
if (PPCSubTarget.isSVR4ABI() && PPCSubTarget.isPPC64()) { if (PPCSubTarget.isSVR4ABI() && PPCSubTarget.isPPC64()) {
SDValue GA = DAG.getTargetJumpTable(JT->getIndex(), PtrVT); SDValue GA = DAG.getTargetJumpTable(JT->getIndex(), PtrVT);
return DAG.getNode(PPCISD::TOC_ENTRY, JT->getDebugLoc(), MVT::i64, GA, return DAG.getNode(PPCISD::TOC_ENTRY, SDLoc(JT), MVT::i64, GA,
DAG.getRegister(PPC::X2, MVT::i64)); DAG.getRegister(PPC::X2, MVT::i64));
} }
@ -1358,7 +1357,7 @@ SDValue PPCTargetLowering::LowerGlobalTLSAddress(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op); GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
DebugLoc dl = GA->getDebugLoc(); SDLoc dl(GA);
const GlobalValue *GV = GA->getGlobal(); const GlobalValue *GV = GA->getGlobal();
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
bool is64bit = PPCSubTarget.isPPC64(); bool is64bit = PPCSubTarget.isPPC64();
@ -1444,7 +1443,7 @@ SDValue PPCTargetLowering::LowerGlobalAddress(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
EVT PtrVT = Op.getValueType(); EVT PtrVT = Op.getValueType();
GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(Op); GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(Op);
DebugLoc DL = GSDN->getDebugLoc(); SDLoc DL(GSDN);
const GlobalValue *GV = GSDN->getGlobal(); const GlobalValue *GV = GSDN->getGlobal();
// 64-bit SVR4 ABI code is always position-independent. // 64-bit SVR4 ABI code is always position-independent.
@ -1475,7 +1474,7 @@ SDValue PPCTargetLowering::LowerGlobalAddress(SDValue Op,
SDValue PPCTargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const { SDValue PPCTargetLowering::LowerSETCC(SDValue Op, SelectionDAG &DAG) const {
ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get(); ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(2))->get();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// If we're comparing for equality to zero, expose the fact that this is // If we're comparing for equality to zero, expose the fact that this is
// implented as a ctlz/srl pair on ppc, so that the dag combiner can // implented as a ctlz/srl pair on ppc, so that the dag combiner can
@ -1524,7 +1523,7 @@ SDValue PPCTargetLowering::LowerVAARG(SDValue Op, SelectionDAG &DAG,
SDValue InChain = Node->getOperand(0); SDValue InChain = Node->getOperand(0);
SDValue VAListPtr = Node->getOperand(1); SDValue VAListPtr = Node->getOperand(1);
const Value *SV = cast<SrcValueSDNode>(Node->getOperand(2))->getValue(); const Value *SV = cast<SrcValueSDNode>(Node->getOperand(2))->getValue();
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
assert(!Subtarget.isPPC64() && "LowerVAARG is PPC32 only"); assert(!Subtarget.isPPC64() && "LowerVAARG is PPC32 only");
@ -1635,7 +1634,7 @@ SDValue PPCTargetLowering::LowerINIT_TRAMPOLINE(SDValue Op,
SDValue Trmp = Op.getOperand(1); // trampoline SDValue Trmp = Op.getOperand(1); // trampoline
SDValue FPtr = Op.getOperand(2); // nested function SDValue FPtr = Op.getOperand(2); // nested function
SDValue Nest = Op.getOperand(3); // 'nest' parameter value SDValue Nest = Op.getOperand(3); // 'nest' parameter value
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(); EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
bool isPPC64 = (PtrVT == MVT::i64); bool isPPC64 = (PtrVT == MVT::i64);
@ -1677,7 +1676,7 @@ SDValue PPCTargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG,
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>(); PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
if (Subtarget.isDarwinABI() || Subtarget.isPPC64()) { if (Subtarget.isDarwinABI() || Subtarget.isPPC64()) {
// vastart just stores the address of the VarArgsFrameIndex slot into the // vastart just stores the address of the VarArgsFrameIndex slot into the
@ -1860,7 +1859,7 @@ PPCTargetLowering::LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> const SmallVectorImpl<ISD::InputArg>
&Ins, &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) SmallVectorImpl<SDValue> &InVals)
const { const {
if (PPCSubTarget.isSVR4ABI()) { if (PPCSubTarget.isSVR4ABI()) {
@ -1882,7 +1881,7 @@ PPCTargetLowering::LowerFormalArguments_32SVR4(
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> const SmallVectorImpl<ISD::InputArg>
&Ins, &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
// 32-bit SVR4 ABI Stack Frame Layout: // 32-bit SVR4 ABI Stack Frame Layout:
@ -2099,7 +2098,7 @@ PPCTargetLowering::LowerFormalArguments_32SVR4(
SDValue SDValue
PPCTargetLowering::extendArgForPPC64(ISD::ArgFlagsTy Flags, EVT ObjectVT, PPCTargetLowering::extendArgForPPC64(ISD::ArgFlagsTy Flags, EVT ObjectVT,
SelectionDAG &DAG, SDValue ArgVal, SelectionDAG &DAG, SDValue ArgVal,
DebugLoc dl) const { SDLoc dl) const {
if (Flags.isSExt()) if (Flags.isSExt())
ArgVal = DAG.getNode(ISD::AssertSext, dl, MVT::i64, ArgVal, ArgVal = DAG.getNode(ISD::AssertSext, dl, MVT::i64, ArgVal,
DAG.getValueType(ObjectVT)); DAG.getValueType(ObjectVT));
@ -2142,7 +2141,7 @@ PPCTargetLowering::LowerFormalArguments_64SVR4(
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> const SmallVectorImpl<ISD::InputArg>
&Ins, &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
// TODO: add description of PPC stack frame format, or at least some docs. // TODO: add description of PPC stack frame format, or at least some docs.
// //
@ -2431,7 +2430,7 @@ PPCTargetLowering::LowerFormalArguments_Darwin(
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> const SmallVectorImpl<ISD::InputArg>
&Ins, &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
// TODO: add description of PPC stack frame format, or at least some docs. // TODO: add description of PPC stack frame format, or at least some docs.
// //
@ -2933,7 +2932,7 @@ StoreTailCallArgumentsToStackSlot(SelectionDAG &DAG,
SDValue Chain, SDValue Chain,
const SmallVector<TailCallArgumentInfo, 8> &TailCallArgs, const SmallVector<TailCallArgumentInfo, 8> &TailCallArgs,
SmallVector<SDValue, 8> &MemOpChains, SmallVector<SDValue, 8> &MemOpChains,
DebugLoc dl) { SDLoc dl) {
for (unsigned i = 0, e = TailCallArgs.size(); i != e; ++i) { for (unsigned i = 0, e = TailCallArgs.size(); i != e; ++i) {
SDValue Arg = TailCallArgs[i].Arg; SDValue Arg = TailCallArgs[i].Arg;
SDValue FIN = TailCallArgs[i].FrameIdxOp; SDValue FIN = TailCallArgs[i].FrameIdxOp;
@ -2955,7 +2954,7 @@ static SDValue EmitTailCallStoreFPAndRetAddr(SelectionDAG &DAG,
int SPDiff, int SPDiff,
bool isPPC64, bool isPPC64,
bool isDarwinABI, bool isDarwinABI,
DebugLoc dl) { SDLoc dl) {
if (SPDiff) { if (SPDiff) {
// Calculate the new stack slot for the return address. // Calculate the new stack slot for the return address.
int SlotSize = isPPC64 ? 8 : 4; int SlotSize = isPPC64 ? 8 : 4;
@ -3012,7 +3011,7 @@ SDValue PPCTargetLowering::EmitTailCallLoadFPAndRetAddr(SelectionDAG & DAG,
SDValue &LROpOut, SDValue &LROpOut,
SDValue &FPOpOut, SDValue &FPOpOut,
bool isDarwinABI, bool isDarwinABI,
DebugLoc dl) const { SDLoc dl) const {
if (SPDiff) { if (SPDiff) {
// Load the LR and FP stack slot for later adjusting. // Load the LR and FP stack slot for later adjusting.
EVT VT = PPCSubTarget.isPPC64() ? MVT::i64 : MVT::i32; EVT VT = PPCSubTarget.isPPC64() ? MVT::i64 : MVT::i32;
@ -3042,7 +3041,7 @@ SDValue PPCTargetLowering::EmitTailCallLoadFPAndRetAddr(SelectionDAG & DAG,
static SDValue static SDValue
CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain, CreateCopyOfByValArgument(SDValue Src, SDValue Dst, SDValue Chain,
ISD::ArgFlagsTy Flags, SelectionDAG &DAG, ISD::ArgFlagsTy Flags, SelectionDAG &DAG,
DebugLoc dl) { SDLoc dl) {
SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32); SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), MVT::i32);
return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(), return DAG.getMemcpy(Chain, dl, Dst, Src, SizeNode, Flags.getByValAlign(),
false, false, MachinePointerInfo(0), false, false, MachinePointerInfo(0),
@ -3057,7 +3056,7 @@ LowerMemOpCallTo(SelectionDAG &DAG, MachineFunction &MF, SDValue Chain,
unsigned ArgOffset, bool isPPC64, bool isTailCall, unsigned ArgOffset, bool isPPC64, bool isTailCall,
bool isVector, SmallVector<SDValue, 8> &MemOpChains, bool isVector, SmallVector<SDValue, 8> &MemOpChains,
SmallVector<TailCallArgumentInfo, 8> &TailCallArguments, SmallVector<TailCallArgumentInfo, 8> &TailCallArguments,
DebugLoc dl) { SDLoc dl) {
EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(); EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
if (!isTailCall) { if (!isTailCall) {
if (isVector) { if (isVector) {
@ -3078,7 +3077,7 @@ LowerMemOpCallTo(SelectionDAG &DAG, MachineFunction &MF, SDValue Chain,
static static
void PrepareTailCall(SelectionDAG &DAG, SDValue &InFlag, SDValue &Chain, void PrepareTailCall(SelectionDAG &DAG, SDValue &InFlag, SDValue &Chain,
DebugLoc dl, bool isPPC64, int SPDiff, unsigned NumBytes, SDLoc dl, bool isPPC64, int SPDiff, unsigned NumBytes,
SDValue LROp, SDValue FPOp, bool isDarwinABI, SDValue LROp, SDValue FPOp, bool isDarwinABI,
SmallVector<TailCallArgumentInfo, 8> &TailCallArguments) { SmallVector<TailCallArgumentInfo, 8> &TailCallArguments) {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
@ -3106,7 +3105,7 @@ void PrepareTailCall(SelectionDAG &DAG, SDValue &InFlag, SDValue &Chain,
static static
unsigned PrepareCall(SelectionDAG &DAG, SDValue &Callee, SDValue &InFlag, unsigned PrepareCall(SelectionDAG &DAG, SDValue &Callee, SDValue &InFlag,
SDValue &Chain, DebugLoc dl, int SPDiff, bool isTailCall, SDValue &Chain, SDLoc dl, int SPDiff, bool isTailCall,
SmallVector<std::pair<unsigned, SDValue>, 8> &RegsToPass, SmallVector<std::pair<unsigned, SDValue>, 8> &RegsToPass,
SmallVector<SDValue, 8> &Ops, std::vector<EVT> &NodeTys, SmallVector<SDValue, 8> &Ops, std::vector<EVT> &NodeTys,
const PPCSubtarget &PPCSubTarget) { const PPCSubtarget &PPCSubTarget) {
@ -3292,7 +3291,7 @@ SDValue
PPCTargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag, PPCTargetLowering::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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SmallVector<CCValAssign, 16> RVLocs; SmallVector<CCValAssign, 16> RVLocs;
@ -3335,7 +3334,7 @@ PPCTargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag,
} }
SDValue SDValue
PPCTargetLowering::FinishCall(CallingConv::ID CallConv, DebugLoc dl, PPCTargetLowering::FinishCall(CallingConv::ID CallConv, SDLoc dl,
bool isTailCall, bool isVarArg, bool isTailCall, bool isVarArg,
SelectionDAG &DAG, SelectionDAG &DAG,
SmallVector<std::pair<unsigned, SDValue>, 8> SmallVector<std::pair<unsigned, SDValue>, 8>
@ -3434,7 +3433,7 @@ SDValue
PPCTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI, PPCTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG; SelectionDAG &DAG = CLI.DAG;
DebugLoc &dl = CLI.DL; SDLoc &dl = CLI.DL;
SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs; SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
SmallVector<SDValue, 32> &OutVals = CLI.OutVals; SmallVector<SDValue, 32> &OutVals = CLI.OutVals;
SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins; SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;
@ -3471,7 +3470,7 @@ PPCTargetLowering::LowerCall_32SVR4(SDValue Chain, SDValue Callee,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
// See PPCTargetLowering::LowerFormalArguments_32SVR4() for a description // See PPCTargetLowering::LowerFormalArguments_32SVR4() for a description
// of the 32-bit SVR4 ABI stack frame layout. // of the 32-bit SVR4 ABI stack frame layout.
@ -3684,7 +3683,7 @@ PPCTargetLowering::createMemcpyOutsideCallSeq(SDValue Arg, SDValue PtrOff,
SDValue CallSeqStart, SDValue CallSeqStart,
ISD::ArgFlagsTy Flags, ISD::ArgFlagsTy Flags,
SelectionDAG &DAG, SelectionDAG &DAG,
DebugLoc dl) const { SDLoc dl) const {
SDValue MemcpyCall = CreateCopyOfByValArgument(Arg, PtrOff, SDValue MemcpyCall = CreateCopyOfByValArgument(Arg, PtrOff,
CallSeqStart.getNode()->getOperand(0), CallSeqStart.getNode()->getOperand(0),
Flags, DAG, dl); Flags, DAG, dl);
@ -3703,7 +3702,7 @@ PPCTargetLowering::LowerCall_64SVR4(SDValue Chain, SDValue Callee,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
unsigned NumOps = Outs.size(); unsigned NumOps = Outs.size();
@ -4074,7 +4073,7 @@ PPCTargetLowering::LowerCall_Darwin(SDValue Chain, SDValue Callee,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
unsigned NumOps = Outs.size(); unsigned NumOps = Outs.size();
@ -4431,7 +4430,7 @@ PPCTargetLowering::LowerReturn(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const { SDLoc dl, SelectionDAG &DAG) const {
SmallVector<CCValAssign, 16> RVLocs; SmallVector<CCValAssign, 16> RVLocs;
CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(), CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
@ -4480,7 +4479,7 @@ PPCTargetLowering::LowerReturn(SDValue Chain,
SDValue PPCTargetLowering::LowerSTACKRESTORE(SDValue Op, SelectionDAG &DAG, SDValue PPCTargetLowering::LowerSTACKRESTORE(SDValue Op, SelectionDAG &DAG,
const PPCSubtarget &Subtarget) const { const PPCSubtarget &Subtarget) const {
// When we pop the dynamic allocation we need to restore the SP link. // When we pop the dynamic allocation we need to restore the SP link.
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// Get the corect type for pointers. // Get the corect type for pointers.
EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(); EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
@ -4565,7 +4564,7 @@ SDValue PPCTargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
// Get the inputs. // Get the inputs.
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Size = Op.getOperand(1); SDValue Size = Op.getOperand(1);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// Get the corect type for pointers. // Get the corect type for pointers.
EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(); EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();
@ -4582,7 +4581,7 @@ SDValue PPCTargetLowering::LowerDYNAMIC_STACKALLOC(SDValue Op,
SDValue PPCTargetLowering::lowerEH_SJLJ_SETJMP(SDValue Op, SDValue PPCTargetLowering::lowerEH_SJLJ_SETJMP(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
return DAG.getNode(PPCISD::EH_SJLJ_SETJMP, DL, return DAG.getNode(PPCISD::EH_SJLJ_SETJMP, DL,
DAG.getVTList(MVT::i32, MVT::Other), DAG.getVTList(MVT::i32, MVT::Other),
Op.getOperand(0), Op.getOperand(1)); Op.getOperand(0), Op.getOperand(1));
@ -4590,7 +4589,7 @@ SDValue PPCTargetLowering::lowerEH_SJLJ_SETJMP(SDValue Op,
SDValue PPCTargetLowering::lowerEH_SJLJ_LONGJMP(SDValue Op, SDValue PPCTargetLowering::lowerEH_SJLJ_LONGJMP(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
return DAG.getNode(PPCISD::EH_SJLJ_LONGJMP, DL, MVT::Other, return DAG.getNode(PPCISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
Op.getOperand(0), Op.getOperand(1)); Op.getOperand(0), Op.getOperand(1));
} }
@ -4616,7 +4615,7 @@ SDValue PPCTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
EVT CmpVT = Op.getOperand(0).getValueType(); EVT CmpVT = Op.getOperand(0).getValueType();
SDValue LHS = Op.getOperand(0), RHS = Op.getOperand(1); SDValue LHS = Op.getOperand(0), RHS = Op.getOperand(1);
SDValue TV = Op.getOperand(2), FV = Op.getOperand(3); SDValue TV = Op.getOperand(2), FV = Op.getOperand(3);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// If the RHS of the comparison is a 0.0, we don't need to do the // If the RHS of the comparison is a 0.0, we don't need to do the
// subtraction at all. // subtraction at all.
@ -4697,7 +4696,7 @@ SDValue PPCTargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
// FIXME: Split this code up when LegalizeDAGTypes lands. // FIXME: Split this code up when LegalizeDAGTypes lands.
SDValue PPCTargetLowering::LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG, SDValue PPCTargetLowering::LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG,
DebugLoc dl) const { SDLoc dl) const {
assert(Op.getOperand(0).getValueType().isFloatingPoint()); assert(Op.getOperand(0).getValueType().isFloatingPoint());
SDValue Src = Op.getOperand(0); SDValue Src = Op.getOperand(0);
if (Src.getValueType() == MVT::f32) if (Src.getValueType() == MVT::f32)
@ -4756,7 +4755,7 @@ SDValue PPCTargetLowering::LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG,
SDValue PPCTargetLowering::LowerINT_TO_FP(SDValue Op, SDValue PPCTargetLowering::LowerINT_TO_FP(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// Don't handle ppc_fp128 here; let it be lowered to a libcall. // Don't handle ppc_fp128 here; let it be lowered to a libcall.
if (Op.getValueType() != MVT::f32 && Op.getValueType() != MVT::f64) if (Op.getValueType() != MVT::f32 && Op.getValueType() != MVT::f64)
return SDValue(); return SDValue();
@ -4890,7 +4889,7 @@ SDValue PPCTargetLowering::LowerINT_TO_FP(SDValue Op,
SDValue PPCTargetLowering::LowerFLT_ROUNDS_(SDValue Op, SDValue PPCTargetLowering::LowerFLT_ROUNDS_(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
/* /*
The rounding mode is in bits 30:31 of FPSR, and has the following The rounding mode is in bits 30:31 of FPSR, and has the following
settings: settings:
@ -4956,7 +4955,7 @@ SDValue PPCTargetLowering::LowerFLT_ROUNDS_(SDValue Op,
SDValue PPCTargetLowering::LowerSHL_PARTS(SDValue Op, SelectionDAG &DAG) const { SDValue PPCTargetLowering::LowerSHL_PARTS(SDValue Op, SelectionDAG &DAG) const {
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
unsigned BitWidth = VT.getSizeInBits(); unsigned BitWidth = VT.getSizeInBits();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
assert(Op.getNumOperands() == 3 && assert(Op.getNumOperands() == 3 &&
VT == Op.getOperand(1).getValueType() && VT == Op.getOperand(1).getValueType() &&
"Unexpected SHL!"); "Unexpected SHL!");
@ -4984,7 +4983,7 @@ SDValue PPCTargetLowering::LowerSHL_PARTS(SDValue Op, SelectionDAG &DAG) const {
SDValue PPCTargetLowering::LowerSRL_PARTS(SDValue Op, SelectionDAG &DAG) const { SDValue PPCTargetLowering::LowerSRL_PARTS(SDValue Op, SelectionDAG &DAG) const {
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned BitWidth = VT.getSizeInBits(); unsigned BitWidth = VT.getSizeInBits();
assert(Op.getNumOperands() == 3 && assert(Op.getNumOperands() == 3 &&
VT == Op.getOperand(1).getValueType() && VT == Op.getOperand(1).getValueType() &&
@ -5012,7 +5011,7 @@ SDValue PPCTargetLowering::LowerSRL_PARTS(SDValue Op, SelectionDAG &DAG) const {
} }
SDValue PPCTargetLowering::LowerSRA_PARTS(SDValue Op, SelectionDAG &DAG) const { SDValue PPCTargetLowering::LowerSRA_PARTS(SDValue Op, SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
unsigned BitWidth = VT.getSizeInBits(); unsigned BitWidth = VT.getSizeInBits();
assert(Op.getNumOperands() == 3 && assert(Op.getNumOperands() == 3 &&
@ -5047,7 +5046,7 @@ SDValue PPCTargetLowering::LowerSRA_PARTS(SDValue Op, SelectionDAG &DAG) const {
/// BuildSplatI - Build a canonical splati of Val with an element size of /// BuildSplatI - Build a canonical splati of Val with an element size of
/// SplatSize. Cast the result to VT. /// SplatSize. Cast the result to VT.
static SDValue BuildSplatI(int Val, unsigned SplatSize, EVT VT, static SDValue BuildSplatI(int Val, unsigned SplatSize, EVT VT,
SelectionDAG &DAG, DebugLoc dl) { SelectionDAG &DAG, SDLoc dl) {
assert(Val >= -16 && Val <= 15 && "vsplti is out of range!"); assert(Val >= -16 && Val <= 15 && "vsplti is out of range!");
static const EVT VTys[] = { // canonical VT to use for each size. static const EVT VTys[] = { // canonical VT to use for each size.
@ -5074,7 +5073,7 @@ static SDValue BuildSplatI(int Val, unsigned SplatSize, EVT VT,
/// BuildIntrinsicOp - Return a unary operator intrinsic node with the /// BuildIntrinsicOp - Return a unary operator intrinsic node with the
/// specified intrinsic ID. /// specified intrinsic ID.
static SDValue BuildIntrinsicOp(unsigned IID, SDValue Op, static SDValue BuildIntrinsicOp(unsigned IID, SDValue Op,
SelectionDAG &DAG, DebugLoc dl, SelectionDAG &DAG, SDLoc dl,
EVT DestVT = MVT::Other) { EVT DestVT = MVT::Other) {
if (DestVT == MVT::Other) DestVT = Op.getValueType(); if (DestVT == MVT::Other) DestVT = Op.getValueType();
return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT, return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT,
@ -5084,7 +5083,7 @@ static SDValue BuildIntrinsicOp(unsigned IID, SDValue Op,
/// BuildIntrinsicOp - Return a binary operator intrinsic node with the /// BuildIntrinsicOp - Return a binary operator intrinsic node with the
/// specified intrinsic ID. /// specified intrinsic ID.
static SDValue BuildIntrinsicOp(unsigned IID, SDValue LHS, SDValue RHS, static SDValue BuildIntrinsicOp(unsigned IID, SDValue LHS, SDValue RHS,
SelectionDAG &DAG, DebugLoc dl, SelectionDAG &DAG, SDLoc dl,
EVT DestVT = MVT::Other) { EVT DestVT = MVT::Other) {
if (DestVT == MVT::Other) DestVT = LHS.getValueType(); if (DestVT == MVT::Other) DestVT = LHS.getValueType();
return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT, return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT,
@ -5095,7 +5094,7 @@ static SDValue BuildIntrinsicOp(unsigned IID, SDValue LHS, SDValue RHS,
/// specified intrinsic ID. /// specified intrinsic ID.
static SDValue BuildIntrinsicOp(unsigned IID, SDValue Op0, SDValue Op1, static SDValue BuildIntrinsicOp(unsigned IID, SDValue Op0, SDValue Op1,
SDValue Op2, SelectionDAG &DAG, SDValue Op2, SelectionDAG &DAG,
DebugLoc dl, EVT DestVT = MVT::Other) { SDLoc dl, EVT DestVT = MVT::Other) {
if (DestVT == MVT::Other) DestVT = Op0.getValueType(); if (DestVT == MVT::Other) DestVT = Op0.getValueType();
return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT, return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT,
DAG.getConstant(IID, MVT::i32), Op0, Op1, Op2); DAG.getConstant(IID, MVT::i32), Op0, Op1, Op2);
@ -5105,7 +5104,7 @@ static SDValue BuildIntrinsicOp(unsigned IID, SDValue Op0, SDValue Op1,
/// BuildVSLDOI - Return a VECTOR_SHUFFLE that is a vsldoi of the specified /// BuildVSLDOI - Return a VECTOR_SHUFFLE that is a vsldoi of the specified
/// amount. The result has the specified value type. /// amount. The result has the specified value type.
static SDValue BuildVSLDOI(SDValue LHS, SDValue RHS, unsigned Amt, static SDValue BuildVSLDOI(SDValue LHS, SDValue RHS, unsigned Amt,
EVT VT, SelectionDAG &DAG, DebugLoc dl) { EVT VT, SelectionDAG &DAG, SDLoc dl) {
// Force LHS/RHS to be the right type. // Force LHS/RHS to be the right type.
LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, LHS); LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, LHS);
RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, RHS); RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, RHS);
@ -5124,7 +5123,7 @@ static SDValue BuildVSLDOI(SDValue LHS, SDValue RHS, unsigned Amt,
// sequence of ops that should be used. // sequence of ops that should be used.
SDValue PPCTargetLowering::LowerBUILD_VECTOR(SDValue Op, SDValue PPCTargetLowering::LowerBUILD_VECTOR(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(Op.getNode()); BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(Op.getNode());
assert(BVN != 0 && "Expected a BuildVectorSDNode in LowerBUILD_VECTOR"); assert(BVN != 0 && "Expected a BuildVectorSDNode in LowerBUILD_VECTOR");
@ -5280,7 +5279,7 @@ SDValue PPCTargetLowering::LowerBUILD_VECTOR(SDValue Op,
/// the specified operations to build the shuffle. /// the specified operations to build the shuffle.
static SDValue GeneratePerfectShuffle(unsigned PFEntry, SDValue LHS, static SDValue GeneratePerfectShuffle(unsigned PFEntry, SDValue LHS,
SDValue RHS, SelectionDAG &DAG, SDValue RHS, SelectionDAG &DAG,
DebugLoc dl) { SDLoc dl) {
unsigned OpNum = (PFEntry >> 26) & 0x0F; unsigned OpNum = (PFEntry >> 26) & 0x0F;
unsigned LHSID = (PFEntry >> 13) & ((1 << 13)-1); unsigned LHSID = (PFEntry >> 13) & ((1 << 13)-1);
unsigned RHSID = (PFEntry >> 0) & ((1 << 13)-1); unsigned RHSID = (PFEntry >> 0) & ((1 << 13)-1);
@ -5359,7 +5358,7 @@ static SDValue GeneratePerfectShuffle(unsigned PFEntry, SDValue LHS,
/// lowered into a vperm. /// lowered into a vperm.
SDValue PPCTargetLowering::LowerVECTOR_SHUFFLE(SDValue Op, SDValue PPCTargetLowering::LowerVECTOR_SHUFFLE(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue V1 = Op.getOperand(0); SDValue V1 = Op.getOperand(0);
SDValue V2 = Op.getOperand(1); SDValue V2 = Op.getOperand(1);
ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op); ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(Op);
@ -5526,7 +5525,7 @@ SDValue PPCTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
// If this is a lowered altivec predicate compare, CompareOpc is set to the // If this is a lowered altivec predicate compare, CompareOpc is set to the
// opcode number of the comparison. // opcode number of the comparison.
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
int CompareOpc; int CompareOpc;
bool isDot; bool isDot;
if (!getAltivecCompareInfo(Op, CompareOpc, isDot)) if (!getAltivecCompareInfo(Op, CompareOpc, isDot))
@ -5590,7 +5589,7 @@ SDValue PPCTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
SDValue PPCTargetLowering::LowerSCALAR_TO_VECTOR(SDValue Op, SDValue PPCTargetLowering::LowerSCALAR_TO_VECTOR(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// Create a stack slot that is 16-byte aligned. // Create a stack slot that is 16-byte aligned.
MachineFrameInfo *FrameInfo = DAG.getMachineFunction().getFrameInfo(); MachineFrameInfo *FrameInfo = DAG.getMachineFunction().getFrameInfo();
int FrameIdx = FrameInfo->CreateStackObject(16, 16, false); int FrameIdx = FrameInfo->CreateStackObject(16, 16, false);
@ -5607,7 +5606,7 @@ SDValue PPCTargetLowering::LowerSCALAR_TO_VECTOR(SDValue Op,
} }
SDValue PPCTargetLowering::LowerMUL(SDValue Op, SelectionDAG &DAG) const { SDValue PPCTargetLowering::LowerMUL(SDValue Op, SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
if (Op.getValueType() == MVT::v4i32) { if (Op.getValueType() == MVT::v4i32) {
SDValue LHS = Op.getOperand(0), RHS = Op.getOperand(1); SDValue LHS = Op.getOperand(0), RHS = Op.getOperand(1);
@ -5694,7 +5693,7 @@ SDValue PPCTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const {
case ISD::SELECT_CC: return LowerSELECT_CC(Op, DAG); case ISD::SELECT_CC: return LowerSELECT_CC(Op, DAG);
case ISD::FP_TO_UINT: case ISD::FP_TO_UINT:
case ISD::FP_TO_SINT: return LowerFP_TO_INT(Op, DAG, case ISD::FP_TO_SINT: return LowerFP_TO_INT(Op, DAG,
Op.getDebugLoc()); SDLoc(Op));
case ISD::UINT_TO_FP: case ISD::UINT_TO_FP:
case ISD::SINT_TO_FP: return LowerINT_TO_FP(Op, DAG); case ISD::SINT_TO_FP: return LowerINT_TO_FP(Op, DAG);
case ISD::FLT_ROUNDS_: return LowerFLT_ROUNDS_(Op, DAG); case ISD::FLT_ROUNDS_: return LowerFLT_ROUNDS_(Op, DAG);
@ -5724,7 +5723,7 @@ void PPCTargetLowering::ReplaceNodeResults(SDNode *N,
SmallVectorImpl<SDValue>&Results, SmallVectorImpl<SDValue>&Results,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
const TargetMachine &TM = getTargetMachine(); const TargetMachine &TM = getTargetMachine();
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
switch (N->getOpcode()) { switch (N->getOpcode()) {
default: default:
llvm_unreachable("Do not know how to custom type legalize this operation!"); llvm_unreachable("Do not know how to custom type legalize this operation!");
@ -6675,7 +6674,7 @@ SDValue PPCTargetLowering::DAGCombineFastRecip(SDValue Op,
++Iterations; ++Iterations;
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue FPOne = SDValue FPOne =
DAG.getConstantFP(1.0, VT.getScalarType()); DAG.getConstantFP(1.0, VT.getScalarType());
@ -6737,7 +6736,7 @@ SDValue PPCTargetLowering::DAGCombineFastRecipFSQRT(SDValue Op,
++Iterations; ++Iterations;
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue FPThreeHalves = SDValue FPThreeHalves =
DAG.getConstantFP(1.5, VT.getScalarType()); DAG.getConstantFP(1.5, VT.getScalarType());
@ -6785,7 +6784,7 @@ SDValue PPCTargetLowering::PerformDAGCombine(SDNode *N,
DAGCombinerInfo &DCI) const { DAGCombinerInfo &DCI) const {
const TargetMachine &TM = getTargetMachine(); const TargetMachine &TM = getTargetMachine();
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
switch (N->getOpcode()) { switch (N->getOpcode()) {
default: break; default: break;
case PPCISD::SHL: case PPCISD::SHL:
@ -6826,7 +6825,7 @@ SDValue PPCTargetLowering::PerformDAGCombine(SDNode *N,
DCI); DCI);
if (RV.getNode() != 0) { if (RV.getNode() != 0) {
DCI.AddToWorklist(RV.getNode()); DCI.AddToWorklist(RV.getNode());
RV = DAG.getNode(ISD::FP_EXTEND, N->getOperand(1).getDebugLoc(), RV = DAG.getNode(ISD::FP_EXTEND, SDLoc(N->getOperand(1)),
N->getValueType(0), RV); N->getValueType(0), RV);
DCI.AddToWorklist(RV.getNode()); DCI.AddToWorklist(RV.getNode());
return DAG.getNode(ISD::FMUL, dl, N->getValueType(0), return DAG.getNode(ISD::FMUL, dl, N->getValueType(0),
@ -6839,7 +6838,7 @@ SDValue PPCTargetLowering::PerformDAGCombine(SDNode *N,
DCI); DCI);
if (RV.getNode() != 0) { if (RV.getNode() != 0) {
DCI.AddToWorklist(RV.getNode()); DCI.AddToWorklist(RV.getNode());
RV = DAG.getNode(ISD::FP_ROUND, N->getOperand(1).getDebugLoc(), RV = DAG.getNode(ISD::FP_ROUND, SDLoc(N->getOperand(1)),
N->getValueType(0), RV, N->getValueType(0), RV,
N->getOperand(1).getOperand(1)); N->getOperand(1).getOperand(1));
DCI.AddToWorklist(RV.getNode()); DCI.AddToWorklist(RV.getNode());
@ -7521,7 +7520,7 @@ SDValue PPCTargetLowering::LowerRETURNADDR(SDValue Op,
MachineFrameInfo *MFI = MF.getFrameInfo(); MachineFrameInfo *MFI = MF.getFrameInfo();
MFI->setReturnAddressIsTaken(true); MFI->setReturnAddressIsTaken(true);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue(); unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
// Make sure the function does not optimize away the store of the RA to // Make sure the function does not optimize away the store of the RA to
@ -7551,7 +7550,7 @@ SDValue PPCTargetLowering::LowerRETURNADDR(SDValue Op,
SDValue PPCTargetLowering::LowerFRAMEADDR(SDValue Op, SDValue PPCTargetLowering::LowerFRAMEADDR(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue(); unsigned Depth = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(); EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy();

28
lib/Target/PowerPC/PPCISelLowering.h
View File

@ -484,7 +484,7 @@ namespace llvm {
SDValue &LROpOut, SDValue &LROpOut,
SDValue &FPOpOut, SDValue &FPOpOut,
bool isDarwinABI, bool isDarwinABI,
DebugLoc dl) const; SDLoc dl) const;
SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const; SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const; SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) const;
@ -505,7 +505,7 @@ namespace llvm {
SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG, SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG,
const PPCSubtarget &Subtarget) const; const PPCSubtarget &Subtarget) const;
SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const; SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG, DebugLoc dl) const; SDValue LowerFP_TO_INT(SDValue Op, SelectionDAG &DAG, SDLoc dl) const;
SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) const; SDValue LowerINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerFLT_ROUNDS_(SDValue Op, SelectionDAG &DAG) const; SDValue LowerFLT_ROUNDS_(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSHL_PARTS(SDValue Op, SelectionDAG &DAG) const; SDValue LowerSHL_PARTS(SDValue Op, SelectionDAG &DAG) const;
@ -520,9 +520,9 @@ namespace llvm {
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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue FinishCall(CallingConv::ID CallConv, DebugLoc dl, bool isTailCall, SDValue FinishCall(CallingConv::ID CallConv, SDLoc dl, bool isTailCall,
bool isVarArg, bool isVarArg,
SelectionDAG &DAG, SelectionDAG &DAG,
SmallVector<std::pair<unsigned, SDValue>, 8> SmallVector<std::pair<unsigned, SDValue>, 8>
@ -537,7 +537,7 @@ namespace llvm {
LowerFormalArguments(SDValue Chain, LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
virtual SDValue virtual SDValue
@ -555,11 +555,11 @@ namespace llvm {
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const; SDLoc dl, SelectionDAG &DAG) const;
SDValue SDValue
extendArgForPPC64(ISD::ArgFlagsTy Flags, EVT ObjectVT, SelectionDAG &DAG, extendArgForPPC64(ISD::ArgFlagsTy Flags, EVT ObjectVT, SelectionDAG &DAG,
SDValue ArgVal, DebugLoc dl) const; SDValue ArgVal, SDLoc dl) const;
void void
setMinReservedArea(MachineFunction &MF, SelectionDAG &DAG, setMinReservedArea(MachineFunction &MF, SelectionDAG &DAG,
@ -570,25 +570,25 @@ namespace llvm {
LowerFormalArguments_Darwin(SDValue Chain, LowerFormalArguments_Darwin(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue SDValue
LowerFormalArguments_64SVR4(SDValue Chain, LowerFormalArguments_64SVR4(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue SDValue
LowerFormalArguments_32SVR4(SDValue Chain, LowerFormalArguments_32SVR4(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue SDValue
createMemcpyOutsideCallSeq(SDValue Arg, SDValue PtrOff, createMemcpyOutsideCallSeq(SDValue Arg, SDValue PtrOff,
SDValue CallSeqStart, ISD::ArgFlagsTy Flags, SDValue CallSeqStart, ISD::ArgFlagsTy Flags,
SelectionDAG &DAG, DebugLoc dl) const; SelectionDAG &DAG, SDLoc dl) const;
SDValue SDValue
LowerCall_Darwin(SDValue Chain, SDValue Callee, LowerCall_Darwin(SDValue Chain, SDValue Callee,
@ -597,7 +597,7 @@ namespace llvm {
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue SDValue
LowerCall_64SVR4(SDValue Chain, SDValue Callee, LowerCall_64SVR4(SDValue Chain, SDValue Callee,
@ -606,7 +606,7 @@ namespace llvm {
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue SDValue
LowerCall_32SVR4(SDValue Chain, SDValue Callee, CallingConv::ID CallConv, LowerCall_32SVR4(SDValue Chain, SDValue Callee, CallingConv::ID CallConv,
@ -614,7 +614,7 @@ namespace llvm {
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue lowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const; SDValue lowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const;

12
lib/Target/R600/AMDGPUISelLowering.cpp
View File

@ -86,7 +86,7 @@ SDValue AMDGPUTargetLowering::LowerReturn(
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc DL, SelectionDAG &DAG) const { SDLoc DL, SelectionDAG &DAG) const {
return DAG.getNode(AMDGPUISD::RET_FLAG, DL, MVT::Other, Chain); return DAG.getNode(AMDGPUISD::RET_FLAG, DL, MVT::Other, Chain);
} }
@ -117,7 +117,7 @@ SDValue AMDGPUTargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG)
SDValue AMDGPUTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op, SDValue AMDGPUTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
unsigned IntrinsicID = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue(); unsigned IntrinsicID = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
switch (IntrinsicID) { switch (IntrinsicID) {
@ -157,7 +157,7 @@ SDValue AMDGPUTargetLowering::LowerINTRINSIC_WO_CHAIN(SDValue Op,
SDValue AMDGPUTargetLowering::LowerIntrinsicIABS(SDValue Op, SDValue AMDGPUTargetLowering::LowerIntrinsicIABS(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
SDValue Neg = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, VT), SDValue Neg = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, VT),
Op.getOperand(1)); Op.getOperand(1));
@ -169,7 +169,7 @@ SDValue AMDGPUTargetLowering::LowerIntrinsicIABS(SDValue Op,
/// LRP(a, b, c) = muladd(a, b, (1 - a) * c) /// LRP(a, b, c) = muladd(a, b, (1 - a) * c)
SDValue AMDGPUTargetLowering::LowerIntrinsicLRP(SDValue Op, SDValue AMDGPUTargetLowering::LowerIntrinsicLRP(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
SDValue OneSubA = DAG.getNode(ISD::FSUB, DL, VT, SDValue OneSubA = DAG.getNode(ISD::FSUB, DL, VT,
DAG.getConstantFP(1.0f, MVT::f32), DAG.getConstantFP(1.0f, MVT::f32),
@ -184,7 +184,7 @@ SDValue AMDGPUTargetLowering::LowerIntrinsicLRP(SDValue Op,
/// \brief Generate Min/Max node /// \brief Generate Min/Max node
SDValue AMDGPUTargetLowering::LowerMinMax(SDValue Op, SDValue AMDGPUTargetLowering::LowerMinMax(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
SDValue LHS = Op.getOperand(0); SDValue LHS = Op.getOperand(0);
@ -245,7 +245,7 @@ SDValue AMDGPUTargetLowering::LowerMinMax(SDValue Op,
SDValue AMDGPUTargetLowering::LowerUDIVREM(SDValue Op, SDValue AMDGPUTargetLowering::LowerUDIVREM(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
SDValue Num = Op.getOperand(0); SDValue Num = Op.getOperand(0);

2
lib/Target/R600/AMDGPUISelLowering.h
View File

@ -49,7 +49,7 @@ public:
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc DL, SelectionDAG &DAG) const; SDLoc DL, SelectionDAG &DAG) const;
virtual SDValue LowerCall(CallLoweringInfo &CLI, virtual SDValue LowerCall(CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
CLI.Callee.dump(); CLI.Callee.dump();

4
lib/Target/R600/AMDILISelDAGToDAG.cpp
View File

@ -211,7 +211,7 @@ SDNode *AMDGPUDAGToDAGISel::Select(SDNode *N) {
const SDValue Ops[] = { RC, N->getOperand(0), SubReg0, const SDValue Ops[] = { RC, N->getOperand(0), SubReg0,
N->getOperand(1), SubReg1 }; N->getOperand(1), SubReg1 };
return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE,
N->getDebugLoc(), N->getValueType(0), Ops); SDLoc(N), N->getValueType(0), Ops);
} }
case ISD::ConstantFP: case ISD::ConstantFP:
@ -616,7 +616,7 @@ bool AMDGPUDAGToDAGISel::SelectADDRVTX_READ(SDValue Addr, SDValue &Base,
} else if ((IMMOffset = dyn_cast<ConstantSDNode>(Addr)) } else if ((IMMOffset = dyn_cast<ConstantSDNode>(Addr))
&& isInt<16>(IMMOffset->getZExtValue())) { && isInt<16>(IMMOffset->getZExtValue())) {
Base = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), Base = CurDAG->getCopyFromReg(CurDAG->getEntryNode(),
CurDAG->getEntryNode().getDebugLoc(), SDLoc(CurDAG->getEntryNode()),
AMDGPU::ZERO, MVT::i32); AMDGPU::ZERO, MVT::i32);
Offset = CurDAG->getTargetConstant(IMMOffset->getZExtValue(), MVT::i32); Offset = CurDAG->getTargetConstant(IMMOffset->getZExtValue(), MVT::i32);
return true; return true;

14
lib/Target/R600/AMDILISelLowering.cpp
View File

@ -329,7 +329,7 @@ SDValue
AMDGPUTargetLowering::LowerSIGN_EXTEND_INREG(SDValue Op, SelectionDAG &DAG) const { AMDGPUTargetLowering::LowerSIGN_EXTEND_INREG(SDValue Op, SelectionDAG &DAG) const {
SDValue Data = Op.getOperand(0); SDValue Data = Op.getOperand(0);
VTSDNode *BaseType = cast<VTSDNode>(Op.getOperand(1)); VTSDNode *BaseType = cast<VTSDNode>(Op.getOperand(1));
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT DVT = Data.getValueType(); EVT DVT = Data.getValueType();
EVT BVT = BaseType->getVT(); EVT BVT = BaseType->getVT();
unsigned baseBits = BVT.getScalarType().getSizeInBits(); unsigned baseBits = BVT.getScalarType().getSizeInBits();
@ -385,7 +385,7 @@ AMDGPUTargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) const {
SDValue Result; SDValue Result;
Result = DAG.getNode( Result = DAG.getNode(
AMDGPUISD::BRANCH_COND, AMDGPUISD::BRANCH_COND,
Op.getDebugLoc(), SDLoc(Op),
Op.getValueType(), Op.getValueType(),
Chain, Jump, Cond); Chain, Jump, Cond);
return Result; return Result;
@ -393,7 +393,7 @@ AMDGPUTargetLowering::LowerBRCOND(SDValue Op, SelectionDAG &DAG) const {
SDValue SDValue
AMDGPUTargetLowering::LowerSDIV24(SDValue Op, SelectionDAG &DAG) const { AMDGPUTargetLowering::LowerSDIV24(SDValue Op, SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT OVT = Op.getValueType(); EVT OVT = Op.getValueType();
SDValue LHS = Op.getOperand(0); SDValue LHS = Op.getOperand(0);
SDValue RHS = Op.getOperand(1); SDValue RHS = Op.getOperand(1);
@ -474,7 +474,7 @@ AMDGPUTargetLowering::LowerSDIV24(SDValue Op, SelectionDAG &DAG) const {
SDValue SDValue
AMDGPUTargetLowering::LowerSDIV32(SDValue Op, SelectionDAG &DAG) const { AMDGPUTargetLowering::LowerSDIV32(SDValue Op, SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT OVT = Op.getValueType(); EVT OVT = Op.getValueType();
SDValue LHS = Op.getOperand(0); SDValue LHS = Op.getOperand(0);
SDValue RHS = Op.getOperand(1); SDValue RHS = Op.getOperand(1);
@ -545,7 +545,7 @@ AMDGPUTargetLowering::LowerSDIV64(SDValue Op, SelectionDAG &DAG) const {
SDValue SDValue
AMDGPUTargetLowering::LowerSREM8(SDValue Op, SelectionDAG &DAG) const { AMDGPUTargetLowering::LowerSREM8(SDValue Op, SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT OVT = Op.getValueType(); EVT OVT = Op.getValueType();
MVT INTTY = MVT::i32; MVT INTTY = MVT::i32;
if (OVT == MVT::v2i8) { if (OVT == MVT::v2i8) {
@ -562,7 +562,7 @@ AMDGPUTargetLowering::LowerSREM8(SDValue Op, SelectionDAG &DAG) const {
SDValue SDValue
AMDGPUTargetLowering::LowerSREM16(SDValue Op, SelectionDAG &DAG) const { AMDGPUTargetLowering::LowerSREM16(SDValue Op, SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT OVT = Op.getValueType(); EVT OVT = Op.getValueType();
MVT INTTY = MVT::i32; MVT INTTY = MVT::i32;
if (OVT == MVT::v2i16) { if (OVT == MVT::v2i16) {
@ -579,7 +579,7 @@ AMDGPUTargetLowering::LowerSREM16(SDValue Op, SelectionDAG &DAG) const {
SDValue SDValue
AMDGPUTargetLowering::LowerSREM32(SDValue Op, SelectionDAG &DAG) const { AMDGPUTargetLowering::LowerSREM32(SDValue Op, SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT OVT = Op.getValueType(); EVT OVT = Op.getValueType();
SDValue LHS = Op.getOperand(0); SDValue LHS = Op.getOperand(0);
SDValue RHS = Op.getOperand(1); SDValue RHS = Op.getOperand(1);

34
lib/Target/R600/R600ISelLowering.cpp
View File

@ -491,7 +491,7 @@ SDValue R600TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const
int64_t RegIndex = cast<ConstantSDNode>(Op.getOperand(3))->getZExtValue(); int64_t RegIndex = cast<ConstantSDNode>(Op.getOperand(3))->getZExtValue();
unsigned Reg = AMDGPU::R600_TReg32RegClass.getRegister(RegIndex); unsigned Reg = AMDGPU::R600_TReg32RegClass.getRegister(RegIndex);
MFI->LiveOuts.push_back(Reg); MFI->LiveOuts.push_back(Reg);
return DAG.getCopyToReg(Chain, Op.getDebugLoc(), Reg, Op.getOperand(2)); return DAG.getCopyToReg(Chain, SDLoc(Op), Reg, Op.getOperand(2));
} }
case AMDGPUIntrinsic::R600_store_swizzle: { case AMDGPUIntrinsic::R600_store_swizzle: {
const SDValue Args[8] = { const SDValue Args[8] = {
@ -504,7 +504,7 @@ SDValue R600TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const
DAG.getConstant(2, MVT::i32), // SWZ_Z DAG.getConstant(2, MVT::i32), // SWZ_Z
DAG.getConstant(3, MVT::i32) // SWZ_W DAG.getConstant(3, MVT::i32) // SWZ_W
}; };
return DAG.getNode(AMDGPUISD::EXPORT, Op.getDebugLoc(), Op.getValueType(), return DAG.getNode(AMDGPUISD::EXPORT, SDLoc(Op), Op.getValueType(),
Args, 8); Args, 8);
} }
@ -518,7 +518,7 @@ SDValue R600TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const
unsigned IntrinsicID = unsigned IntrinsicID =
cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue(); cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
switch(IntrinsicID) { switch(IntrinsicID) {
default: return AMDGPUTargetLowering::LowerOperation(Op, DAG); default: return AMDGPUTargetLowering::LowerOperation(Op, DAG);
case AMDGPUIntrinsic::R600_load_input: { case AMDGPUIntrinsic::R600_load_input: {
@ -528,7 +528,7 @@ SDValue R600TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) const
MachineRegisterInfo &MRI = MF.getRegInfo(); MachineRegisterInfo &MRI = MF.getRegInfo();
MRI.addLiveIn(Reg); MRI.addLiveIn(Reg);
return DAG.getCopyFromReg(DAG.getEntryNode(), return DAG.getCopyFromReg(DAG.getEntryNode(),
DAG.getEntryNode().getDebugLoc(), Reg, VT); SDLoc(DAG.getEntryNode()), Reg, VT);
} }
case AMDGPUIntrinsic::R600_interp_input: { case AMDGPUIntrinsic::R600_interp_input: {
@ -722,7 +722,7 @@ void R600TargetLowering::ReplaceNodeResults(SDNode *N,
SDValue R600TargetLowering::LowerFPTOUINT(SDValue Op, SelectionDAG &DAG) const { SDValue R600TargetLowering::LowerFPTOUINT(SDValue Op, SelectionDAG &DAG) const {
return DAG.getNode( return DAG.getNode(
ISD::SETCC, ISD::SETCC,
Op.getDebugLoc(), SDLoc(Op),
MVT::i1, MVT::i1,
Op, DAG.getConstantFP(0.0f, MVT::f32), Op, DAG.getConstantFP(0.0f, MVT::f32),
DAG.getCondCode(ISD::SETNE) DAG.getCondCode(ISD::SETNE)
@ -730,7 +730,7 @@ SDValue R600TargetLowering::LowerFPTOUINT(SDValue Op, SelectionDAG &DAG) const {
} }
SDValue R600TargetLowering::LowerImplicitParameter(SelectionDAG &DAG, EVT VT, SDValue R600TargetLowering::LowerImplicitParameter(SelectionDAG &DAG, EVT VT,
DebugLoc DL, SDLoc DL,
unsigned DwordOffset) const { unsigned DwordOffset) const {
unsigned ByteOffset = DwordOffset * 4; unsigned ByteOffset = DwordOffset * 4;
PointerType * PtrType = PointerType::get(VT.getTypeForEVT(*DAG.getContext()), PointerType * PtrType = PointerType::get(VT.getTypeForEVT(*DAG.getContext()),
@ -770,7 +770,7 @@ bool R600TargetLowering::isZero(SDValue Op) const {
} }
SDValue R600TargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const { SDValue R600TargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
SDValue LHS = Op.getOperand(0); SDValue LHS = Op.getOperand(0);
@ -891,7 +891,7 @@ SDValue R600TargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const
SDValue R600TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const { SDValue R600TargetLowering::LowerSELECT(SDValue Op, SelectionDAG &DAG) const {
return DAG.getNode(ISD::SELECT_CC, return DAG.getNode(ISD::SELECT_CC,
Op.getDebugLoc(), SDLoc(Op),
Op.getValueType(), Op.getValueType(),
Op.getOperand(0), Op.getOperand(0),
DAG.getConstant(0, MVT::i32), DAG.getConstant(0, MVT::i32),
@ -922,7 +922,7 @@ SDValue R600TargetLowering::stackPtrToRegIndex(SDValue Ptr,
default: llvm_unreachable("Invalid stack width"); default: llvm_unreachable("Invalid stack width");
} }
return DAG.getNode(ISD::SRL, Ptr.getDebugLoc(), Ptr.getValueType(), Ptr, return DAG.getNode(ISD::SRL, SDLoc(Ptr), Ptr.getValueType(), Ptr,
DAG.getConstant(SRLPad, MVT::i32)); DAG.getConstant(SRLPad, MVT::i32));
} }
@ -956,7 +956,7 @@ void R600TargetLowering::getStackAddress(unsigned StackWidth,
} }
SDValue R600TargetLowering::LowerSTORE(SDValue Op, SelectionDAG &DAG) const { SDValue R600TargetLowering::LowerSTORE(SDValue Op, SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
StoreSDNode *StoreNode = cast<StoreSDNode>(Op); StoreSDNode *StoreNode = cast<StoreSDNode>(Op);
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Value = Op.getOperand(1); SDValue Value = Op.getOperand(1);
@ -1068,7 +1068,7 @@ ConstantAddressBlock(unsigned AddressSpace) {
SDValue R600TargetLowering::LowerLOAD(SDValue Op, SelectionDAG &DAG) const SDValue R600TargetLowering::LowerLOAD(SDValue Op, SelectionDAG &DAG) const
{ {
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
LoadSDNode *LoadNode = cast<LoadSDNode>(Op); LoadSDNode *LoadNode = cast<LoadSDNode>(Op);
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Ptr = Op.getOperand(1); SDValue Ptr = Op.getOperand(1);
@ -1170,7 +1170,7 @@ SDValue R600TargetLowering::LowerFormalArguments(
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc DL, SelectionDAG &DAG, SDLoc DL, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
unsigned ParamOffsetBytes = 36; unsigned ParamOffsetBytes = 36;
Function::const_arg_iterator FuncArg = Function::const_arg_iterator FuncArg =
@ -1219,7 +1219,7 @@ SDValue R600TargetLowering::PerformDAGCombine(SDNode *N,
case ISD::FP_ROUND: { case ISD::FP_ROUND: {
SDValue Arg = N->getOperand(0); SDValue Arg = N->getOperand(0);
if (Arg.getOpcode() == ISD::UINT_TO_FP && Arg.getValueType() == MVT::f64) { if (Arg.getOpcode() == ISD::UINT_TO_FP && Arg.getValueType() == MVT::f64) {
return DAG.getNode(ISD::UINT_TO_FP, N->getDebugLoc(), N->getValueType(0), return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), N->getValueType(0),
Arg.getOperand(0)); Arg.getOperand(0));
} }
break; break;
@ -1244,7 +1244,7 @@ SDValue R600TargetLowering::PerformDAGCombine(SDNode *N,
return SDValue(); return SDValue();
} }
return DAG.getNode(ISD::SELECT_CC, N->getDebugLoc(), N->getValueType(0), return DAG.getNode(ISD::SELECT_CC, SDLoc(N), N->getValueType(0),
SelectCC.getOperand(0), // LHS SelectCC.getOperand(0), // LHS
SelectCC.getOperand(1), // RHS SelectCC.getOperand(1), // RHS
DAG.getConstant(-1, MVT::i32), // True DAG.getConstant(-1, MVT::i32), // True
@ -1267,7 +1267,7 @@ SDValue R600TargetLowering::PerformDAGCombine(SDNode *N,
Arg.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) { Arg.getOperand(0).getOpcode() == ISD::BUILD_VECTOR) {
if (ConstantSDNode *Const = dyn_cast<ConstantSDNode>(N->getOperand(1))) { if (ConstantSDNode *Const = dyn_cast<ConstantSDNode>(N->getOperand(1))) {
unsigned Element = Const->getZExtValue(); unsigned Element = Const->getZExtValue();
return DAG.getNode(ISD::BITCAST, N->getDebugLoc(), N->getVTList(), return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getVTList(),
Arg->getOperand(0).getOperand(Element)); Arg->getOperand(0).getOperand(Element));
} }
} }
@ -1302,7 +1302,7 @@ SDValue R600TargetLowering::PerformDAGCombine(SDNode *N,
ISD::CondCode LHSCC = cast<CondCodeSDNode>(LHS.getOperand(4))->get(); ISD::CondCode LHSCC = cast<CondCodeSDNode>(LHS.getOperand(4))->get();
LHSCC = ISD::getSetCCInverse(LHSCC, LHSCC = ISD::getSetCCInverse(LHSCC,
LHS.getOperand(0).getValueType().isInteger()); LHS.getOperand(0).getValueType().isInteger());
return DAG.getSelectCC(N->getDebugLoc(), return DAG.getSelectCC(SDLoc(N),
LHS.getOperand(0), LHS.getOperand(0),
LHS.getOperand(1), LHS.getOperand(1),
LHS.getOperand(2), LHS.getOperand(2),
@ -1344,7 +1344,7 @@ SDValue R600TargetLowering::PerformDAGCombine(SDNode *N,
NewBldVec[i] = Arg.getOperand(i); NewBldVec[i] = Arg.getOperand(i);
} }
} }
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
NewArgs[1] = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v4f32, NewBldVec, 4); NewArgs[1] = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v4f32, NewBldVec, 4);
return DAG.getNode(AMDGPUISD::EXPORT, DL, N->getVTList(), NewArgs, 8); return DAG.getNode(AMDGPUISD::EXPORT, DL, N->getVTList(), NewArgs, 8);
} }

4
lib/Target/R600/R600ISelLowering.h
View File

@ -36,7 +36,7 @@ public:
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc DL, SelectionDAG &DAG, SDLoc DL, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
virtual EVT getSetCCResultType(LLVMContext &, EVT VT) const; virtual EVT getSetCCResultType(LLVMContext &, EVT VT) const;
private: private:
@ -47,7 +47,7 @@ private:
/// lowered to load instructions which retreive the values from the Vertex /// lowered to load instructions which retreive the values from the Vertex
/// Buffer. /// Buffer.
SDValue LowerImplicitParameter(SelectionDAG &DAG, EVT VT, SDValue LowerImplicitParameter(SelectionDAG &DAG, EVT VT,
DebugLoc DL, unsigned DwordOffset) const; SDLoc DL, unsigned DwordOffset) const;
void lowerImplicitParameter(MachineInstr *MI, MachineBasicBlock &BB, void lowerImplicitParameter(MachineInstr *MI, MachineBasicBlock &BB,
MachineRegisterInfo & MRI, unsigned dword_offset) const; MachineRegisterInfo & MRI, unsigned dword_offset) const;

17
lib/Target/R600/SIISelLowering.cpp
View File

@ -87,7 +87,7 @@ SDValue SITargetLowering::LowerFormalArguments(
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc DL, SelectionDAG &DAG, SDLoc DL, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
const TargetRegisterInfo *TRI = getTargetMachine().getRegisterInfo(); const TargetRegisterInfo *TRI = getTargetMachine().getRegisterInfo();
@ -265,7 +265,7 @@ static SDNode *findUser(SDValue Value, unsigned Opcode) {
SDValue SITargetLowering::LowerBRCOND(SDValue BRCOND, SDValue SITargetLowering::LowerBRCOND(SDValue BRCOND,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = BRCOND.getDebugLoc(); SDLoc DL(BRCOND);
SDNode *Intr = BRCOND.getOperand(1).getNode(); SDNode *Intr = BRCOND.getOperand(1).getNode();
SDValue Target = BRCOND.getOperand(2); SDValue Target = BRCOND.getOperand(2);
@ -345,7 +345,7 @@ SDValue SITargetLowering::LowerSTORE(SDValue Op, SelectionDAG &DAG) const {
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Value = Op.getOperand(1); SDValue Value = Op.getOperand(1);
SDValue VirtualAddress = Op.getOperand(2); SDValue VirtualAddress = Op.getOperand(2);
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
if (StoreNode->getAddressSpace() != AMDGPUAS::GLOBAL_ADDRESS) { if (StoreNode->getAddressSpace() != AMDGPUAS::GLOBAL_ADDRESS) {
return SDValue(); return SDValue();
@ -371,7 +371,7 @@ SDValue SITargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
SDValue False = Op.getOperand(3); SDValue False = Op.getOperand(3);
SDValue CC = Op.getOperand(4); SDValue CC = Op.getOperand(4);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
// Possible Min/Max pattern // Possible Min/Max pattern
SDValue MinMax = LowerMinMax(Op, DAG); SDValue MinMax = LowerMinMax(Op, DAG);
@ -390,7 +390,7 @@ SDValue SITargetLowering::LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const {
SDValue SITargetLowering::PerformDAGCombine(SDNode *N, SDValue SITargetLowering::PerformDAGCombine(SDNode *N,
DAGCombinerInfo &DCI) const { DAGCombinerInfo &DCI) const {
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc DL = N->getDebugLoc(); SDLoc DL(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
switch (N->getOpcode()) { switch (N->getOpcode()) {
@ -564,7 +564,7 @@ void SITargetLowering::ensureSRegLimit(SelectionDAG &DAG, SDValue &Operand,
// This is a conservative aproach, it is possible that we can't determine // This is a conservative aproach, it is possible that we can't determine
// the correct register class and copy too often, but better save than sorry. // the correct register class and copy too often, but better save than sorry.
SDValue RC = DAG.getTargetConstant(RegClass, MVT::i32); SDValue RC = DAG.getTargetConstant(RegClass, MVT::i32);
SDNode *Node = DAG.getMachineNode(TargetOpcode::COPY_TO_REGCLASS, DebugLoc(), SDNode *Node = DAG.getMachineNode(TargetOpcode::COPY_TO_REGCLASS, SDLoc(),
Operand.getValueType(), Operand, RC); Operand.getValueType(), Operand, RC);
Operand = SDValue(Node, 0); Operand = SDValue(Node, 0);
} }
@ -701,8 +701,7 @@ SDNode *SITargetLowering::foldOperands(MachineSDNode *Node,
Ops.push_back(Node->getOperand(i)); Ops.push_back(Node->getOperand(i));
// Create a complete new instruction // Create a complete new instruction
return DAG.getMachineNode(Desc->Opcode, Node->getDebugLoc(), return DAG.getMachineNode(Desc->Opcode, SDLoc(Node), Node->getVTList(), Ops);
Node->getVTList(), Ops);
} }
/// \brief Helper function for adjustWritemask /// \brief Helper function for adjustWritemask
@ -756,7 +755,7 @@ void SITargetLowering::adjustWritemask(MachineSDNode *&Node,
if (Writemask == (1U << Lane)) { if (Writemask == (1U << Lane)) {
SDValue RC = DAG.getTargetConstant(AMDGPU::VReg_32RegClassID, MVT::i32); SDValue RC = DAG.getTargetConstant(AMDGPU::VReg_32RegClassID, MVT::i32);
SDNode *Copy = DAG.getMachineNode(TargetOpcode::COPY_TO_REGCLASS, SDNode *Copy = DAG.getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
DebugLoc(), Users[Lane]->getValueType(0), SDLoc(), Users[Lane]->getValueType(0),
SDValue(Node, 0), RC); SDValue(Node, 0), RC);
DAG.ReplaceAllUsesWith(Users[Lane], Copy); DAG.ReplaceAllUsesWith(Users[Lane], Copy);
return; return;

2
lib/Target/R600/SIISelLowering.h
View File

@ -44,7 +44,7 @@ public:
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,
DebugLoc DL, SelectionDAG &DAG, SDLoc DL, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
virtual MachineBasicBlock * EmitInstrWithCustomInserter(MachineInstr * MI, virtual MachineBasicBlock * EmitInstrWithCustomInserter(MachineInstr * MI,

2
lib/Target/Sparc/SparcISelDAGToDAG.cpp
View File

@ -136,7 +136,7 @@ bool SparcDAGToDAGISel::SelectADDRrr(SDValue Addr, SDValue &R1, SDValue &R2) {
} }
SDNode *SparcDAGToDAGISel::Select(SDNode *N) { SDNode *SparcDAGToDAGISel::Select(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
if (N->isMachineOpcode()) if (N->isMachineOpcode())
return NULL; // Already selected. return NULL; // Already selected.

42
lib/Target/Sparc/SparcISelLowering.cpp
View File

@ -164,7 +164,7 @@ SparcTargetLowering::LowerReturn(SDValue Chain,
CallingConv::ID CallConv, bool IsVarArg, CallingConv::ID CallConv, bool IsVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc DL, SelectionDAG &DAG) const { SDLoc DL, SelectionDAG &DAG) const {
if (Subtarget->is64Bit()) if (Subtarget->is64Bit())
return LowerReturn_64(Chain, CallConv, IsVarArg, Outs, OutVals, DL, DAG); return LowerReturn_64(Chain, CallConv, IsVarArg, Outs, OutVals, DL, DAG);
return LowerReturn_32(Chain, CallConv, IsVarArg, Outs, OutVals, DL, DAG); return LowerReturn_32(Chain, CallConv, IsVarArg, Outs, OutVals, DL, DAG);
@ -175,7 +175,7 @@ SparcTargetLowering::LowerReturn_32(SDValue Chain,
CallingConv::ID CallConv, bool IsVarArg, CallingConv::ID CallConv, bool IsVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc DL, SelectionDAG &DAG) const { SDLoc DL, SelectionDAG &DAG) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
// CCValAssign - represent the assignment of the return value to locations. // CCValAssign - represent the assignment of the return value to locations.
@ -238,7 +238,7 @@ SparcTargetLowering::LowerReturn_64(SDValue Chain,
CallingConv::ID CallConv, bool IsVarArg, CallingConv::ID CallConv, bool IsVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc DL, SelectionDAG &DAG) const { SDLoc DL, SelectionDAG &DAG) const {
// CCValAssign - represent the assignment of the return value to locations. // CCValAssign - represent the assignment of the return value to locations.
SmallVector<CCValAssign, 16> RVLocs; SmallVector<CCValAssign, 16> RVLocs;
@ -314,7 +314,7 @@ LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool IsVarArg, bool IsVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc DL, SDLoc DL,
SelectionDAG &DAG, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
if (Subtarget->is64Bit()) if (Subtarget->is64Bit())
@ -332,7 +332,7 @@ LowerFormalArguments_32(SDValue Chain,
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SDLoc dl,
SelectionDAG &DAG, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
@ -532,7 +532,7 @@ LowerFormalArguments_64(SDValue Chain,
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool IsVarArg, bool IsVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc DL, SDLoc DL,
SelectionDAG &DAG, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
@ -653,7 +653,7 @@ SDValue
SparcTargetLowering::LowerCall_32(TargetLowering::CallLoweringInfo &CLI, SparcTargetLowering::LowerCall_32(TargetLowering::CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG; SelectionDAG &DAG = CLI.DAG;
DebugLoc &dl = CLI.DL; SDLoc &dl = CLI.DL;
SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs; SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
SmallVector<SDValue, 32> &OutVals = CLI.OutVals; SmallVector<SDValue, 32> &OutVals = CLI.OutVals;
SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins; SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;
@ -979,7 +979,7 @@ SDValue
SparcTargetLowering::LowerCall_64(TargetLowering::CallLoweringInfo &CLI, SparcTargetLowering::LowerCall_64(TargetLowering::CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG; SelectionDAG &DAG = CLI.DAG;
DebugLoc DL = CLI.DL; SDLoc DL = CLI.DL;
SDValue Chain = CLI.Chain; SDValue Chain = CLI.Chain;
// Analyze operands of the call, assigning locations to each operand. // Analyze operands of the call, assigning locations to each operand.
@ -1448,7 +1448,7 @@ SDValue SparcTargetLowering::withTargetFlags(SDValue Op, unsigned TF,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
if (const GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Op)) if (const GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Op))
return DAG.getTargetGlobalAddress(GA->getGlobal(), return DAG.getTargetGlobalAddress(GA->getGlobal(),
GA->getDebugLoc(), SDLoc(GA),
GA->getValueType(0), GA->getValueType(0),
GA->getOffset(), TF); GA->getOffset(), TF);
@ -1470,7 +1470,7 @@ SDValue SparcTargetLowering::withTargetFlags(SDValue Op, unsigned TF,
SDValue SparcTargetLowering::makeHiLoPair(SDValue Op, SDValue SparcTargetLowering::makeHiLoPair(SDValue Op,
unsigned HiTF, unsigned LoTF, unsigned HiTF, unsigned LoTF,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
SDValue Hi = DAG.getNode(SPISD::Hi, DL, VT, withTargetFlags(Op, HiTF, DAG)); SDValue Hi = DAG.getNode(SPISD::Hi, DL, VT, withTargetFlags(Op, HiTF, DAG));
SDValue Lo = DAG.getNode(SPISD::Lo, DL, VT, withTargetFlags(Op, LoTF, DAG)); SDValue Lo = DAG.getNode(SPISD::Lo, DL, VT, withTargetFlags(Op, LoTF, DAG));
@ -1480,7 +1480,7 @@ SDValue SparcTargetLowering::makeHiLoPair(SDValue Op,
// Build SDNodes for producing an address from a GlobalAddress, ConstantPool, // Build SDNodes for producing an address from a GlobalAddress, ConstantPool,
// or ExternalSymbol SDNode. // or ExternalSymbol SDNode.
SDValue SparcTargetLowering::makeAddress(SDValue Op, SelectionDAG &DAG) const { SDValue SparcTargetLowering::makeAddress(SDValue Op, SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
EVT VT = getPointerTy(); EVT VT = getPointerTy();
// Handle PIC mode first. // Handle PIC mode first.
@ -1529,7 +1529,7 @@ SDValue SparcTargetLowering::LowerConstantPool(SDValue Op,
} }
static SDValue LowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG) { static SDValue LowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG) {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// Convert the fp value to integer in an FP register. // Convert the fp value to integer in an FP register.
assert(Op.getValueType() == MVT::i32); assert(Op.getValueType() == MVT::i32);
Op = DAG.getNode(SPISD::FTOI, dl, MVT::f32, Op.getOperand(0)); Op = DAG.getNode(SPISD::FTOI, dl, MVT::f32, Op.getOperand(0));
@ -1537,7 +1537,7 @@ static SDValue LowerFP_TO_SINT(SDValue Op, SelectionDAG &DAG) {
} }
static SDValue LowerSINT_TO_FP(SDValue Op, SelectionDAG &DAG) { static SDValue LowerSINT_TO_FP(SDValue Op, SelectionDAG &DAG) {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
assert(Op.getOperand(0).getValueType() == MVT::i32); assert(Op.getOperand(0).getValueType() == MVT::i32);
SDValue Tmp = DAG.getNode(ISD::BITCAST, dl, MVT::f32, Op.getOperand(0)); SDValue Tmp = DAG.getNode(ISD::BITCAST, dl, MVT::f32, Op.getOperand(0));
// Convert the int value to FP in an FP register. // Convert the int value to FP in an FP register.
@ -1550,7 +1550,7 @@ static SDValue LowerBR_CC(SDValue Op, SelectionDAG &DAG) {
SDValue LHS = Op.getOperand(2); SDValue LHS = Op.getOperand(2);
SDValue RHS = Op.getOperand(3); SDValue RHS = Op.getOperand(3);
SDValue Dest = Op.getOperand(4); SDValue Dest = Op.getOperand(4);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned Opc, SPCC = ~0U; unsigned Opc, SPCC = ~0U;
// If this is a br_cc of a "setcc", and if the setcc got lowered into // If this is a br_cc of a "setcc", and if the setcc got lowered into
@ -1581,7 +1581,7 @@ static SDValue LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) {
ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get(); ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
SDValue TrueVal = Op.getOperand(2); SDValue TrueVal = Op.getOperand(2);
SDValue FalseVal = Op.getOperand(3); SDValue FalseVal = Op.getOperand(3);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned Opc, SPCC = ~0U; unsigned Opc, SPCC = ~0U;
// If this is a select_cc of a "setcc", and if the setcc got lowered into // If this is a select_cc of a "setcc", and if the setcc got lowered into
@ -1613,7 +1613,7 @@ static SDValue LowerVASTART(SDValue Op, SelectionDAG &DAG,
// vastart just stores the address of the VarArgsFrameIndex slot into the // vastart just stores the address of the VarArgsFrameIndex slot into the
// memory location argument. // memory location argument.
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue Offset = SDValue Offset =
DAG.getNode(ISD::ADD, DL, TLI.getPointerTy(), DAG.getNode(ISD::ADD, DL, TLI.getPointerTy(),
DAG.getRegister(SP::I6, TLI.getPointerTy()), DAG.getRegister(SP::I6, TLI.getPointerTy()),
@ -1630,7 +1630,7 @@ static SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) {
SDValue VAListPtr = Node->getOperand(1); SDValue VAListPtr = Node->getOperand(1);
EVT PtrVT = VAListPtr.getValueType(); EVT PtrVT = VAListPtr.getValueType();
const Value *SV = cast<SrcValueSDNode>(Node->getOperand(2))->getValue(); const Value *SV = cast<SrcValueSDNode>(Node->getOperand(2))->getValue();
DebugLoc DL = Node->getDebugLoc(); SDLoc DL(Node);
SDValue VAList = DAG.getLoad(PtrVT, DL, InChain, VAListPtr, SDValue VAList = DAG.getLoad(PtrVT, DL, InChain, VAListPtr,
MachinePointerInfo(SV), false, false, false, 0); MachinePointerInfo(SV), false, false, false, 0);
// Increment the pointer, VAList, to the next vaarg. // Increment the pointer, VAList, to the next vaarg.
@ -1649,7 +1649,7 @@ static SDValue LowerVAARG(SDValue Op, SelectionDAG &DAG) {
static SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) { static SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) {
SDValue Chain = Op.getOperand(0); // Legalize the chain. SDValue Chain = Op.getOperand(0); // Legalize the chain.
SDValue Size = Op.getOperand(1); // Legalize the size. SDValue Size = Op.getOperand(1); // Legalize the size.
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned SPReg = SP::O6; unsigned SPReg = SP::O6;
SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, MVT::i32); SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, MVT::i32);
@ -1666,7 +1666,7 @@ static SDValue LowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) {
static SDValue getFLUSHW(SDValue Op, SelectionDAG &DAG) { static SDValue getFLUSHW(SDValue Op, SelectionDAG &DAG) {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue Chain = DAG.getNode(SPISD::FLUSHW, SDValue Chain = DAG.getNode(SPISD::FLUSHW,
dl, MVT::Other, DAG.getEntryNode()); dl, MVT::Other, DAG.getEntryNode());
return Chain; return Chain;
@ -1677,7 +1677,7 @@ static SDValue LowerFRAMEADDR(SDValue Op, SelectionDAG &DAG) {
MFI->setFrameAddressIsTaken(true); MFI->setFrameAddressIsTaken(true);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned FrameReg = SP::I6; unsigned FrameReg = SP::I6;
uint64_t depth = Op.getConstantOperandVal(0); uint64_t depth = Op.getConstantOperandVal(0);
@ -1708,7 +1708,7 @@ static SDValue LowerRETURNADDR(SDValue Op, SelectionDAG &DAG) {
MFI->setReturnAddressIsTaken(true); MFI->setReturnAddressIsTaken(true);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
unsigned RetReg = SP::I7; unsigned RetReg = SP::I7;
uint64_t depth = Op.getConstantOperandVal(0); uint64_t depth = Op.getConstantOperandVal(0);

12
lib/Target/Sparc/SparcISelLowering.h
View File

@ -78,19 +78,19 @@ namespace llvm {
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue LowerFormalArguments_32(SDValue Chain, SDValue LowerFormalArguments_32(SDValue Chain,
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue LowerFormalArguments_64(SDValue Chain, SDValue LowerFormalArguments_64(SDValue Chain,
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
virtual SDValue virtual SDValue
@ -106,17 +106,17 @@ namespace llvm {
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const; SDLoc dl, SelectionDAG &DAG) const;
SDValue LowerReturn_32(SDValue Chain, SDValue LowerReturn_32(SDValue Chain,
CallingConv::ID CallConv, bool IsVarArg, CallingConv::ID CallConv, bool IsVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc DL, SelectionDAG &DAG) const; SDLoc DL, SelectionDAG &DAG) const;
SDValue LowerReturn_64(SDValue Chain, SDValue LowerReturn_64(SDValue Chain,
CallingConv::ID CallConv, bool IsVarArg, CallingConv::ID CallConv, bool IsVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc DL, SelectionDAG &DAG) const; SDLoc DL, SelectionDAG &DAG) const;
SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const; SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const; SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;

4
lib/Target/SystemZ/SystemZISelDAGToDAG.cpp
View File

@ -474,7 +474,7 @@ void SystemZDAGToDAGISel::getAddressOperands(const SystemZAddressingMode &AM,
// Truncate values from i64 to i32, for shifts. // Truncate values from i64 to i32, for shifts.
assert(VT == MVT::i32 && Base.getValueType() == MVT::i64 && assert(VT == MVT::i32 && Base.getValueType() == MVT::i64 &&
"Unexpected truncation"); "Unexpected truncation");
DebugLoc DL = Base.getDebugLoc(); SDLoc DL(Base);
SDValue Trunc = CurDAG->getNode(ISD::TRUNCATE, DL, VT, Base); SDValue Trunc = CurDAG->getNode(ISD::TRUNCATE, DL, VT, Base);
insertDAGNode(CurDAG, Base.getNode(), Trunc); insertDAGNode(CurDAG, Base.getNode(), Trunc);
Base = Trunc; Base = Trunc;
@ -522,7 +522,7 @@ SDNode *SystemZDAGToDAGISel::splitLargeImmediate(unsigned Opcode, SDNode *Node,
SDValue Op0, uint64_t UpperVal, SDValue Op0, uint64_t UpperVal,
uint64_t LowerVal) { uint64_t LowerVal) {
EVT VT = Node->getValueType(0); EVT VT = Node->getValueType(0);
DebugLoc DL = Node->getDebugLoc(); SDLoc DL(Node);
SDValue Upper = CurDAG->getConstant(UpperVal, VT); SDValue Upper = CurDAG->getConstant(UpperVal, VT);
if (Op0.getNode()) if (Op0.getNode())
Upper = CurDAG->getNode(Opcode, DL, VT, Op0, Upper); Upper = CurDAG->getNode(Opcode, DL, VT, Op0, Upper);

54
lib/Target/SystemZ/SystemZISelLowering.cpp
View File

@ -436,7 +436,7 @@ LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint,
// Value is a value that has been passed to us in the location described by VA // Value is a value that has been passed to us in the location described by VA
// (and so has type VA.getLocVT()). Convert Value to VA.getValVT(), chaining // (and so has type VA.getLocVT()). Convert Value to VA.getValVT(), chaining
// any loads onto Chain. // any loads onto Chain.
static SDValue convertLocVTToValVT(SelectionDAG &DAG, DebugLoc DL, static SDValue convertLocVTToValVT(SelectionDAG &DAG, SDLoc DL,
CCValAssign &VA, SDValue Chain, CCValAssign &VA, SDValue Chain,
SDValue Value) { SDValue Value) {
// If the argument has been promoted from a smaller type, insert an // If the argument has been promoted from a smaller type, insert an
@ -461,7 +461,7 @@ static SDValue convertLocVTToValVT(SelectionDAG &DAG, DebugLoc DL,
// Value is a value of type VA.getValVT() that we need to copy into // Value is a value of type VA.getValVT() that we need to copy into
// the location described by VA. Return a copy of Value converted to // the location described by VA. Return a copy of Value converted to
// VA.getValVT(). The caller is responsible for handling indirect values. // VA.getValVT(). The caller is responsible for handling indirect values.
static SDValue convertValVTToLocVT(SelectionDAG &DAG, DebugLoc DL, static SDValue convertValVTToLocVT(SelectionDAG &DAG, SDLoc DL,
CCValAssign &VA, SDValue Value) { CCValAssign &VA, SDValue Value) {
switch (VA.getLocInfo()) { switch (VA.getLocInfo()) {
case CCValAssign::SExt: case CCValAssign::SExt:
@ -480,7 +480,7 @@ static SDValue convertValVTToLocVT(SelectionDAG &DAG, DebugLoc DL,
SDValue SystemZTargetLowering:: SDValue SystemZTargetLowering::
LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool IsVarArg, LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool IsVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc DL, SelectionDAG &DAG, SDLoc DL, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
MachineFrameInfo *MFI = MF.getFrameInfo(); MachineFrameInfo *MFI = MF.getFrameInfo();
@ -599,7 +599,7 @@ SDValue
SystemZTargetLowering::LowerCall(CallLoweringInfo &CLI, SystemZTargetLowering::LowerCall(CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG; SelectionDAG &DAG = CLI.DAG;
DebugLoc &DL = CLI.DL; SDLoc &DL = CLI.DL;
SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs; SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
SmallVector<SDValue, 32> &OutVals = CLI.OutVals; SmallVector<SDValue, 32> &OutVals = CLI.OutVals;
SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins; SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;
@ -745,7 +745,7 @@ SystemZTargetLowering::LowerReturn(SDValue Chain,
CallingConv::ID CallConv, bool IsVarArg, CallingConv::ID CallConv, bool IsVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc DL, SelectionDAG &DAG) const { SDLoc DL, SelectionDAG &DAG) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
// Assign locations to each returned value. // Assign locations to each returned value.
@ -879,7 +879,7 @@ static void adjustSubwordCmp(SelectionDAG &DAG, bool &IsUnsigned,
ISD::LoadExtType ExtType = IsUnsigned ? ISD::ZEXTLOAD : ISD::SEXTLOAD; ISD::LoadExtType ExtType = IsUnsigned ? ISD::ZEXTLOAD : ISD::SEXTLOAD;
if (CmpOp0.getValueType() != MVT::i32 || if (CmpOp0.getValueType() != MVT::i32 ||
Load->getExtensionType() != ExtType) Load->getExtensionType() != ExtType)
CmpOp0 = DAG.getExtLoad(ExtType, Load->getDebugLoc(), MVT::i32, CmpOp0 = DAG.getExtLoad(ExtType, SDLoc(Load), MVT::i32,
Load->getChain(), Load->getBasePtr(), Load->getChain(), Load->getBasePtr(),
Load->getPointerInfo(), Load->getMemoryVT(), Load->getPointerInfo(), Load->getMemoryVT(),
Load->isVolatile(), Load->isNonTemporal(), Load->isVolatile(), Load->isNonTemporal(),
@ -949,7 +949,7 @@ static SDValue emitCmp(SelectionDAG &DAG, SDValue CmpOp0, SDValue CmpOp1,
IsUnsigned = true; IsUnsigned = true;
} }
DebugLoc DL = CmpOp0.getDebugLoc(); SDLoc DL(CmpOp0);
return DAG.getNode((IsUnsigned ? SystemZISD::UCMP : SystemZISD::CMP), return DAG.getNode((IsUnsigned ? SystemZISD::UCMP : SystemZISD::CMP),
DL, MVT::Glue, CmpOp0, CmpOp1); DL, MVT::Glue, CmpOp0, CmpOp1);
} }
@ -959,7 +959,7 @@ static SDValue emitCmp(SelectionDAG &DAG, SDValue CmpOp0, SDValue CmpOp1,
// Extend extends Op0 to a GR128, and Opcode performs the GR128 operation // Extend extends Op0 to a GR128, and Opcode performs the GR128 operation
// on the extended Op0 and (unextended) Op1. Store the even register result // on the extended Op0 and (unextended) Op1. Store the even register result
// in Even and the odd register result in Odd. // in Even and the odd register result in Odd.
static void lowerGR128Binary(SelectionDAG &DAG, DebugLoc DL, EVT VT, static void lowerGR128Binary(SelectionDAG &DAG, SDLoc DL, EVT VT,
unsigned Extend, unsigned Opcode, unsigned Extend, unsigned Opcode,
SDValue Op0, SDValue Op1, SDValue Op0, SDValue Op1,
SDValue &Even, SDValue &Odd) { SDValue &Even, SDValue &Odd) {
@ -983,7 +983,7 @@ SDValue SystemZTargetLowering::lowerBR_CC(SDValue Op, SelectionDAG &DAG) const {
SDValue CmpOp0 = Op.getOperand(2); SDValue CmpOp0 = Op.getOperand(2);
SDValue CmpOp1 = Op.getOperand(3); SDValue CmpOp1 = Op.getOperand(3);
SDValue Dest = Op.getOperand(4); SDValue Dest = Op.getOperand(4);
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
unsigned CCMask; unsigned CCMask;
SDValue Flags = emitCmp(DAG, CmpOp0, CmpOp1, CC, CCMask); SDValue Flags = emitCmp(DAG, CmpOp0, CmpOp1, CC, CCMask);
@ -998,7 +998,7 @@ SDValue SystemZTargetLowering::lowerSELECT_CC(SDValue Op,
SDValue TrueOp = Op.getOperand(2); SDValue TrueOp = Op.getOperand(2);
SDValue FalseOp = Op.getOperand(3); SDValue FalseOp = Op.getOperand(3);
ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get(); ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
unsigned CCMask; unsigned CCMask;
SDValue Flags = emitCmp(DAG, CmpOp0, CmpOp1, CC, CCMask); SDValue Flags = emitCmp(DAG, CmpOp0, CmpOp1, CC, CCMask);
@ -1015,7 +1015,7 @@ SDValue SystemZTargetLowering::lowerSELECT_CC(SDValue Op,
SDValue SystemZTargetLowering::lowerGlobalAddress(GlobalAddressSDNode *Node, SDValue SystemZTargetLowering::lowerGlobalAddress(GlobalAddressSDNode *Node,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = Node->getDebugLoc(); SDLoc DL(Node);
const GlobalValue *GV = Node->getGlobal(); const GlobalValue *GV = Node->getGlobal();
int64_t Offset = Node->getOffset(); int64_t Offset = Node->getOffset();
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
@ -1054,7 +1054,7 @@ SDValue SystemZTargetLowering::lowerGlobalAddress(GlobalAddressSDNode *Node,
SDValue SystemZTargetLowering::lowerGlobalTLSAddress(GlobalAddressSDNode *Node, SDValue SystemZTargetLowering::lowerGlobalTLSAddress(GlobalAddressSDNode *Node,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = Node->getDebugLoc(); SDLoc DL(Node);
const GlobalValue *GV = Node->getGlobal(); const GlobalValue *GV = Node->getGlobal();
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
TLSModel::Model model = TM.getTLSModel(GV); TLSModel::Model model = TM.getTLSModel(GV);
@ -1093,7 +1093,7 @@ SDValue SystemZTargetLowering::lowerGlobalTLSAddress(GlobalAddressSDNode *Node,
SDValue SystemZTargetLowering::lowerBlockAddress(BlockAddressSDNode *Node, SDValue SystemZTargetLowering::lowerBlockAddress(BlockAddressSDNode *Node,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = Node->getDebugLoc(); SDLoc DL(Node);
const BlockAddress *BA = Node->getBlockAddress(); const BlockAddress *BA = Node->getBlockAddress();
int64_t Offset = Node->getOffset(); int64_t Offset = Node->getOffset();
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
@ -1105,7 +1105,7 @@ SDValue SystemZTargetLowering::lowerBlockAddress(BlockAddressSDNode *Node,
SDValue SystemZTargetLowering::lowerJumpTable(JumpTableSDNode *JT, SDValue SystemZTargetLowering::lowerJumpTable(JumpTableSDNode *JT,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = JT->getDebugLoc(); SDLoc DL(JT);
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), PtrVT); SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), PtrVT);
@ -1115,7 +1115,7 @@ SDValue SystemZTargetLowering::lowerJumpTable(JumpTableSDNode *JT,
SDValue SystemZTargetLowering::lowerConstantPool(ConstantPoolSDNode *CP, SDValue SystemZTargetLowering::lowerConstantPool(ConstantPoolSDNode *CP,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = CP->getDebugLoc(); SDLoc DL(CP);
EVT PtrVT = getPointerTy(); EVT PtrVT = getPointerTy();
SDValue Result; SDValue Result;
@ -1132,7 +1132,7 @@ SDValue SystemZTargetLowering::lowerConstantPool(ConstantPoolSDNode *CP,
SDValue SystemZTargetLowering::lowerBITCAST(SDValue Op, SDValue SystemZTargetLowering::lowerBITCAST(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue In = Op.getOperand(0); SDValue In = Op.getOperand(0);
EVT InVT = In.getValueType(); EVT InVT = In.getValueType();
EVT ResVT = Op.getValueType(); EVT ResVT = Op.getValueType();
@ -1169,7 +1169,7 @@ SDValue SystemZTargetLowering::lowerVASTART(SDValue Op,
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Addr = Op.getOperand(1); SDValue Addr = Op.getOperand(1);
const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue(); const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
// The initial values of each field. // The initial values of each field.
const unsigned NumFields = 4; const unsigned NumFields = 4;
@ -1203,7 +1203,7 @@ SDValue SystemZTargetLowering::lowerVACOPY(SDValue Op,
SDValue SrcPtr = Op.getOperand(2); SDValue SrcPtr = Op.getOperand(2);
const Value *DstSV = cast<SrcValueSDNode>(Op.getOperand(3))->getValue(); const Value *DstSV = cast<SrcValueSDNode>(Op.getOperand(3))->getValue();
const Value *SrcSV = cast<SrcValueSDNode>(Op.getOperand(4))->getValue(); const Value *SrcSV = cast<SrcValueSDNode>(Op.getOperand(4))->getValue();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
return DAG.getMemcpy(Chain, DL, DstPtr, SrcPtr, DAG.getIntPtrConstant(32), return DAG.getMemcpy(Chain, DL, DstPtr, SrcPtr, DAG.getIntPtrConstant(32),
/*Align*/8, /*isVolatile*/false, /*AlwaysInline*/false, /*Align*/8, /*isVolatile*/false, /*AlwaysInline*/false,
@ -1214,7 +1214,7 @@ SDValue SystemZTargetLowering::
lowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const { lowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const {
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Size = Op.getOperand(1); SDValue Size = Op.getOperand(1);
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
unsigned SPReg = getStackPointerRegisterToSaveRestore(); unsigned SPReg = getStackPointerRegisterToSaveRestore();
@ -1240,7 +1240,7 @@ lowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const {
SDValue SystemZTargetLowering::lowerUMUL_LOHI(SDValue Op, SDValue SystemZTargetLowering::lowerUMUL_LOHI(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
assert(!is32Bit(VT) && "Only support 64-bit UMUL_LOHI"); assert(!is32Bit(VT) && "Only support 64-bit UMUL_LOHI");
// UMUL_LOHI64 returns the low result in the odd register and the high // UMUL_LOHI64 returns the low result in the odd register and the high
@ -1257,7 +1257,7 @@ SDValue SystemZTargetLowering::lowerSDIVREM(SDValue Op,
SDValue Op0 = Op.getOperand(0); SDValue Op0 = Op.getOperand(0);
SDValue Op1 = Op.getOperand(1); SDValue Op1 = Op.getOperand(1);
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
// We use DSGF for 32-bit division. // We use DSGF for 32-bit division.
if (is32Bit(VT)) { if (is32Bit(VT)) {
@ -1277,7 +1277,7 @@ SDValue SystemZTargetLowering::lowerSDIVREM(SDValue Op,
SDValue SystemZTargetLowering::lowerUDIVREM(SDValue Op, SDValue SystemZTargetLowering::lowerUDIVREM(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
EVT VT = Op.getValueType(); EVT VT = Op.getValueType();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
// DL(G) uses a double-width dividend, so we need to clear the even // DL(G) uses a double-width dividend, so we need to clear the even
// register in the GR128 input. The instruction returns the remainder // register in the GR128 input. The instruction returns the remainder
@ -1342,7 +1342,7 @@ SDValue SystemZTargetLowering::lowerOR(SDValue Op, SelectionDAG &DAG) const {
// low 32 bits by truncating Low to an i32 and inserting it directly // low 32 bits by truncating Low to an i32 and inserting it directly
// using a subreg. The interesting cases are those where the truncation // using a subreg. The interesting cases are those where the truncation
// can be folded. // can be folded.
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
SDValue Low32 = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, LowOp); SDValue Low32 = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, LowOp);
SDValue SubReg32 = DAG.getTargetConstant(SystemZ::subreg_32bit, MVT::i64); SDValue SubReg32 = DAG.getTargetConstant(SystemZ::subreg_32bit, MVT::i64);
SDNode *Result = DAG.getMachineNode(TargetOpcode::INSERT_SUBREG, DL, SDNode *Result = DAG.getMachineNode(TargetOpcode::INSERT_SUBREG, DL,
@ -1368,7 +1368,7 @@ SDValue SystemZTargetLowering::lowerATOMIC_LOAD(SDValue Op,
SDValue Addr = Node->getBasePtr(); SDValue Addr = Node->getBasePtr();
SDValue Src2 = Node->getVal(); SDValue Src2 = Node->getVal();
MachineMemOperand *MMO = Node->getMemOperand(); MachineMemOperand *MMO = Node->getMemOperand();
DebugLoc DL = Node->getDebugLoc(); SDLoc DL(Node);
EVT PtrVT = Addr.getValueType(); EVT PtrVT = Addr.getValueType();
// Convert atomic subtracts of constants into additions. // Convert atomic subtracts of constants into additions.
@ -1442,7 +1442,7 @@ SDValue SystemZTargetLowering::lowerATOMIC_CMP_SWAP(SDValue Op,
SDValue CmpVal = Node->getOperand(2); SDValue CmpVal = Node->getOperand(2);
SDValue SwapVal = Node->getOperand(3); SDValue SwapVal = Node->getOperand(3);
MachineMemOperand *MMO = Node->getMemOperand(); MachineMemOperand *MMO = Node->getMemOperand();
DebugLoc DL = Node->getDebugLoc(); SDLoc DL(Node);
EVT PtrVT = Addr.getValueType(); EVT PtrVT = Addr.getValueType();
// Get the address of the containing word. // Get the address of the containing word.
@ -1474,7 +1474,7 @@ SDValue SystemZTargetLowering::lowerSTACKSAVE(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
MF.getInfo<SystemZMachineFunctionInfo>()->setManipulatesSP(true); MF.getInfo<SystemZMachineFunctionInfo>()->setManipulatesSP(true);
return DAG.getCopyFromReg(Op.getOperand(0), Op.getDebugLoc(), return DAG.getCopyFromReg(Op.getOperand(0), SDLoc(Op),
SystemZ::R15D, Op.getValueType()); SystemZ::R15D, Op.getValueType());
} }
@ -1482,7 +1482,7 @@ SDValue SystemZTargetLowering::lowerSTACKRESTORE(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
MF.getInfo<SystemZMachineFunctionInfo>()->setManipulatesSP(true); MF.getInfo<SystemZMachineFunctionInfo>()->setManipulatesSP(true);
return DAG.getCopyToReg(Op.getOperand(0), Op.getDebugLoc(), return DAG.getCopyToReg(Op.getOperand(0), SDLoc(Op),
SystemZ::R15D, Op.getOperand(1)); SystemZ::R15D, Op.getOperand(1));
} }

4
lib/Target/SystemZ/SystemZISelLowering.h
View File

@ -147,7 +147,7 @@ public:
LowerFormalArguments(SDValue Chain, LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc DL, SelectionDAG &DAG, SDLoc DL, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const LLVM_OVERRIDE; SmallVectorImpl<SDValue> &InVals) const LLVM_OVERRIDE;
virtual SDValue virtual SDValue
LowerCall(CallLoweringInfo &CLI, LowerCall(CallLoweringInfo &CLI,
@ -158,7 +158,7 @@ public:
CallingConv::ID CallConv, bool IsVarArg, CallingConv::ID CallConv, bool IsVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc DL, SelectionDAG &DAG) const LLVM_OVERRIDE; SDLoc DL, SelectionDAG &DAG) const LLVM_OVERRIDE;
private: private:
const SystemZSubtarget &Subtarget; const SystemZSubtarget &Subtarget;

30
lib/Target/X86/X86ISelDAGToDAG.cpp
View File

@ -236,7 +236,7 @@ namespace {
// These are 32-bit even in 64-bit mode since RIP relative offset // These are 32-bit even in 64-bit mode since RIP relative offset
// is 32-bit. // is 32-bit.
if (AM.GV) if (AM.GV)
Disp = CurDAG->getTargetGlobalAddress(AM.GV, DebugLoc(), Disp = CurDAG->getTargetGlobalAddress(AM.GV, SDLoc(),
MVT::i32, AM.Disp, MVT::i32, AM.Disp,
AM.SymbolFlags); AM.SymbolFlags);
else if (AM.CP) else if (AM.CP)
@ -373,7 +373,7 @@ static void MoveBelowOrigChain(SelectionDAG *CurDAG, SDValue Load,
else else
Ops.push_back(Chain.getOperand(i)); Ops.push_back(Chain.getOperand(i));
SDValue NewChain = SDValue NewChain =
CurDAG->getNode(ISD::TokenFactor, Load.getDebugLoc(), CurDAG->getNode(ISD::TokenFactor, SDLoc(Load),
MVT::Other, &Ops[0], Ops.size()); MVT::Other, &Ops[0], Ops.size());
Ops.clear(); Ops.clear();
Ops.push_back(NewChain); Ops.push_back(NewChain);
@ -524,7 +524,7 @@ void X86DAGToDAGISel::PreprocessISelDAG() {
MemVT = SrcIsSSE ? SrcVT : DstVT; MemVT = SrcIsSSE ? SrcVT : DstVT;
SDValue MemTmp = CurDAG->CreateStackTemporary(MemVT); SDValue MemTmp = CurDAG->CreateStackTemporary(MemVT);
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// FIXME: optimize the case where the src/dest is a load or store? // FIXME: optimize the case where the src/dest is a load or store?
SDValue Store = CurDAG->getTruncStore(CurDAG->getEntryNode(), dl, SDValue Store = CurDAG->getTruncStore(CurDAG->getEntryNode(), dl,
@ -782,7 +782,7 @@ static bool FoldMaskAndShiftToExtract(SelectionDAG &DAG, SDValue N,
return true; return true;
EVT VT = N.getValueType(); EVT VT = N.getValueType();
DebugLoc DL = N.getDebugLoc(); SDLoc DL(N);
SDValue Eight = DAG.getConstant(8, MVT::i8); SDValue Eight = DAG.getConstant(8, MVT::i8);
SDValue NewMask = DAG.getConstant(0xff, VT); SDValue NewMask = DAG.getConstant(0xff, VT);
SDValue Srl = DAG.getNode(ISD::SRL, DL, VT, X, Eight); SDValue Srl = DAG.getNode(ISD::SRL, DL, VT, X, Eight);
@ -830,7 +830,7 @@ static bool FoldMaskedShiftToScaledMask(SelectionDAG &DAG, SDValue N,
return true; return true;
EVT VT = N.getValueType(); EVT VT = N.getValueType();
DebugLoc DL = N.getDebugLoc(); SDLoc DL(N);
SDValue NewMask = DAG.getConstant(Mask >> ShiftAmt, VT); SDValue NewMask = DAG.getConstant(Mask >> ShiftAmt, VT);
SDValue NewAnd = DAG.getNode(ISD::AND, DL, VT, X, NewMask); SDValue NewAnd = DAG.getNode(ISD::AND, DL, VT, X, NewMask);
SDValue NewShift = DAG.getNode(ISD::SHL, DL, VT, NewAnd, Shift.getOperand(1)); SDValue NewShift = DAG.getNode(ISD::SHL, DL, VT, NewAnd, Shift.getOperand(1));
@ -932,11 +932,11 @@ static bool FoldMaskAndShiftToScale(SelectionDAG &DAG, SDValue N,
if (ReplacingAnyExtend) { if (ReplacingAnyExtend) {
assert(X.getValueType() != VT); assert(X.getValueType() != VT);
// We looked through an ANY_EXTEND node, insert a ZERO_EXTEND. // We looked through an ANY_EXTEND node, insert a ZERO_EXTEND.
SDValue NewX = DAG.getNode(ISD::ZERO_EXTEND, X.getDebugLoc(), VT, X); SDValue NewX = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(X), VT, X);
InsertDAGNode(DAG, N, NewX); InsertDAGNode(DAG, N, NewX);
X = NewX; X = NewX;
} }
DebugLoc DL = N.getDebugLoc(); SDLoc DL(N);
SDValue NewSRLAmt = DAG.getConstant(ShiftAmt + AMShiftAmt, MVT::i8); SDValue NewSRLAmt = DAG.getConstant(ShiftAmt + AMShiftAmt, MVT::i8);
SDValue NewSRL = DAG.getNode(ISD::SRL, DL, VT, X, NewSRLAmt); SDValue NewSRL = DAG.getNode(ISD::SRL, DL, VT, X, NewSRLAmt);
SDValue NewSHLAmt = DAG.getConstant(AMShiftAmt, MVT::i8); SDValue NewSHLAmt = DAG.getConstant(AMShiftAmt, MVT::i8);
@ -960,7 +960,7 @@ static bool FoldMaskAndShiftToScale(SelectionDAG &DAG, SDValue N,
bool X86DAGToDAGISel::MatchAddressRecursively(SDValue N, X86ISelAddressMode &AM, bool X86DAGToDAGISel::MatchAddressRecursively(SDValue N, X86ISelAddressMode &AM,
unsigned Depth) { unsigned Depth) {
DebugLoc dl = N.getDebugLoc(); SDLoc dl(N);
DEBUG({ DEBUG({
dbgs() << "MatchAddress: "; dbgs() << "MatchAddress: ";
AM.dump(); AM.dump();
@ -1502,7 +1502,7 @@ SDNode *X86DAGToDAGISel::SelectAtomic64(SDNode *Node, unsigned Opc) {
MachineSDNode::mmo_iterator MemOp = MF->allocateMemRefsArray(1); MachineSDNode::mmo_iterator MemOp = MF->allocateMemRefsArray(1);
MemOp[0] = cast<MemSDNode>(Node)->getMemOperand(); MemOp[0] = cast<MemSDNode>(Node)->getMemOperand();
const SDValue Ops[] = { Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, In2L, In2H, Chain}; const SDValue Ops[] = { Tmp0, Tmp1, Tmp2, Tmp3, Tmp4, In2L, In2H, Chain};
SDNode *ResNode = CurDAG->getMachineNode(Opc, Node->getDebugLoc(), SDNode *ResNode = CurDAG->getMachineNode(Opc, SDLoc(Node),
MVT::i32, MVT::i32, MVT::Other, Ops); MVT::i32, MVT::i32, MVT::Other, Ops);
cast<MachineSDNode>(ResNode)->setMemRefs(MemOp, MemOp + 1); cast<MachineSDNode>(ResNode)->setMemRefs(MemOp, MemOp + 1);
return ResNode; return ResNode;
@ -1637,7 +1637,7 @@ static const uint16_t AtomicOpcTbl[AtomicOpcEnd][AtomicSzEnd] = {
// + empty, the operand is not needed any more with the new op selected. // + empty, the operand is not needed any more with the new op selected.
// + non-empty, otherwise. // + non-empty, otherwise.
static SDValue getAtomicLoadArithTargetConstant(SelectionDAG *CurDAG, static SDValue getAtomicLoadArithTargetConstant(SelectionDAG *CurDAG,
DebugLoc dl, SDLoc dl,
enum AtomicOpc &Op, EVT NVT, enum AtomicOpc &Op, EVT NVT,
SDValue Val) { SDValue Val) {
if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Val)) { if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Val)) {
@ -1689,7 +1689,7 @@ SDNode *X86DAGToDAGISel::SelectAtomicLoadArith(SDNode *Node, EVT NVT) {
if (Node->hasAnyUseOfValue(0)) if (Node->hasAnyUseOfValue(0))
return 0; return 0;
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
// Optimize common patterns for __sync_or_and_fetch and similar arith // Optimize common patterns for __sync_or_and_fetch and similar arith
// operations where the result is not used. This allows us to use the "lock" // operations where the result is not used. This allows us to use the "lock"
@ -1920,7 +1920,7 @@ static bool isLoadIncOrDecStore(StoreSDNode *StoreNode, unsigned Opc,
if (ChainCheck) if (ChainCheck)
// Make a new TokenFactor with all the other input chains except // Make a new TokenFactor with all the other input chains except
// for the load. // for the load.
InputChain = CurDAG->getNode(ISD::TokenFactor, Chain.getDebugLoc(), InputChain = CurDAG->getNode(ISD::TokenFactor, SDLoc(Chain),
MVT::Other, &ChainOps[0], ChainOps.size()); MVT::Other, &ChainOps[0], ChainOps.size());
} }
if (!ChainCheck) if (!ChainCheck)
@ -1968,7 +1968,7 @@ SDNode *X86DAGToDAGISel::SelectGather(SDNode *Node, unsigned Opc) {
SDValue Segment = CurDAG->getRegister(0, MVT::i32); SDValue Segment = CurDAG->getRegister(0, MVT::i32);
const SDValue Ops[] = { VSrc, Base, getI8Imm(Scale->getSExtValue()), VIdx, const SDValue Ops[] = { VSrc, Base, getI8Imm(Scale->getSExtValue()), VIdx,
Disp, Segment, VMask, Chain}; Disp, Segment, VMask, Chain};
SDNode *ResNode = CurDAG->getMachineNode(Opc, Node->getDebugLoc(), VTs, Ops); SDNode *ResNode = CurDAG->getMachineNode(Opc, SDLoc(Node), VTs, Ops);
// Node has 2 outputs: VDst and MVT::Other. // Node has 2 outputs: VDst and MVT::Other.
// ResNode has 3 outputs: VDst, VMask_wb, and MVT::Other. // ResNode has 3 outputs: VDst, VMask_wb, and MVT::Other.
// We replace VDst of Node with VDst of ResNode, and Other of Node with Other // We replace VDst of Node with VDst of ResNode, and Other of Node with Other
@ -1982,7 +1982,7 @@ SDNode *X86DAGToDAGISel::Select(SDNode *Node) {
EVT NVT = Node->getValueType(0); EVT NVT = Node->getValueType(0);
unsigned Opc, MOpc; unsigned Opc, MOpc;
unsigned Opcode = Node->getOpcode(); unsigned Opcode = Node->getOpcode();
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
DEBUG(dbgs() << "Selecting: "; Node->dump(CurDAG); dbgs() << '\n'); DEBUG(dbgs() << "Selecting: "; Node->dump(CurDAG); dbgs() << '\n');
@ -2666,7 +2666,7 @@ SDNode *X86DAGToDAGISel::Select(SDNode *Node) {
EVT LdVT = LoadNode->getMemoryVT(); EVT LdVT = LoadNode->getMemoryVT();
unsigned newOpc = getFusedLdStOpcode(LdVT, Opc); unsigned newOpc = getFusedLdStOpcode(LdVT, Opc);
MachineSDNode *Result = CurDAG->getMachineNode(newOpc, MachineSDNode *Result = CurDAG->getMachineNode(newOpc,
Node->getDebugLoc(), SDLoc(Node),
MVT::i32, MVT::Other, Ops); MVT::i32, MVT::Other, Ops);
Result->setMemRefs(MemOp, MemOp + 2); Result->setMemRefs(MemOp, MemOp + 2);

396
lib/Target/X86/X86ISelLowering.cpp
View File

File diff suppressed because it is too large Load Diff

18
lib/Target/X86/X86ISelLowering.h
View File

@ -760,16 +760,16 @@ namespace llvm {
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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue LowerMemArgument(SDValue Chain, SDValue LowerMemArgument(SDValue Chain,
CallingConv::ID CallConv, CallingConv::ID CallConv,
const SmallVectorImpl<ISD::InputArg> &ArgInfo, const SmallVectorImpl<ISD::InputArg> &ArgInfo,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
const CCValAssign &VA, MachineFrameInfo *MFI, const CCValAssign &VA, MachineFrameInfo *MFI,
unsigned i) const; unsigned i) const;
SDValue LowerMemOpCallTo(SDValue Chain, SDValue StackPtr, SDValue Arg, SDValue LowerMemOpCallTo(SDValue Chain, SDValue StackPtr, SDValue Arg,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
const CCValAssign &VA, const CCValAssign &VA,
ISD::ArgFlagsTy Flags) const; ISD::ArgFlagsTy Flags) const;
@ -791,7 +791,7 @@ namespace llvm {
bool IsCalleePop(bool isVarArg, CallingConv::ID CallConv) const; bool IsCalleePop(bool isVarArg, CallingConv::ID CallConv) const;
SDValue EmitTailCallLoadRetAddr(SelectionDAG &DAG, SDValue &OutRetAddr, SDValue EmitTailCallLoadRetAddr(SelectionDAG &DAG, SDValue &OutRetAddr,
SDValue Chain, bool IsTailCall, bool Is64Bit, SDValue Chain, bool IsTailCall, bool Is64Bit,
int FPDiff, DebugLoc dl) const; int FPDiff, SDLoc dl) const;
unsigned GetAlignedArgumentStackSize(unsigned StackSize, unsigned GetAlignedArgumentStackSize(unsigned StackSize,
SelectionDAG &DAG) const; SelectionDAG &DAG) const;
@ -800,7 +800,7 @@ namespace llvm {
bool isSigned, bool isSigned,
bool isReplace) const; bool isReplace) const;
SDValue LowerAsSplatVectorLoad(SDValue SrcOp, EVT VT, DebugLoc dl, SDValue LowerAsSplatVectorLoad(SDValue SrcOp, EVT VT, SDLoc dl,
SelectionDAG &DAG) const; SelectionDAG &DAG) const;
SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const; SDValue LowerBUILD_VECTOR(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const; SDValue LowerVECTOR_SHUFFLE(SDValue Op, SelectionDAG &DAG) const;
@ -808,7 +808,7 @@ namespace llvm {
SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const; SDValue LowerINSERT_VECTOR_ELT(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const; SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const; SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerGlobalAddress(const GlobalValue *GV, DebugLoc dl, SDValue LowerGlobalAddress(const GlobalValue *GV, SDLoc dl,
int64_t Offset, SelectionDAG &DAG) const; int64_t Offset, SelectionDAG &DAG) const;
SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const; SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const; SDValue LowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const;
@ -830,7 +830,7 @@ namespace llvm {
SDValue LowerFNEG(SDValue Op, SelectionDAG &DAG) const; SDValue LowerFNEG(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const; SDValue LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerToBT(SDValue And, ISD::CondCode CC, SDValue LowerToBT(SDValue And, ISD::CondCode CC,
DebugLoc dl, SelectionDAG &DAG) const; SDLoc dl, SelectionDAG &DAG) const;
SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const; SDValue LowerSETCC(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSELECT(SDValue Op, SelectionDAG &DAG) const; SDValue LowerSELECT(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerBRCOND(SDValue Op, SelectionDAG &DAG) const; SDValue LowerBRCOND(SDValue Op, SelectionDAG &DAG) const;
@ -865,7 +865,7 @@ namespace llvm {
LowerFormalArguments(SDValue Chain, LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
virtual SDValue virtual SDValue
LowerCall(CallLoweringInfo &CLI, LowerCall(CallLoweringInfo &CLI,
@ -876,7 +876,7 @@ namespace llvm {
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const; SDLoc dl, SelectionDAG &DAG) const;
virtual bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const; virtual bool isUsedByReturnOnly(SDNode *N, SDValue &Chain) const;

2
lib/Target/X86/X86InstrInfo.cpp
View File

@ -4333,7 +4333,7 @@ X86InstrInfo::unfoldMemoryOperand(SelectionDAG &DAG, SDNode *N,
std::vector<SDValue> AddrOps; std::vector<SDValue> AddrOps;
std::vector<SDValue> BeforeOps; std::vector<SDValue> BeforeOps;
std::vector<SDValue> AfterOps; std::vector<SDValue> AfterOps;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
unsigned NumOps = N->getNumOperands(); unsigned NumOps = N->getNumOperands();
for (unsigned i = 0; i != NumOps-1; ++i) { for (unsigned i = 0; i != NumOps-1; ++i) {
SDValue Op = N->getOperand(i); SDValue Op = N->getOperand(i);

4
lib/Target/X86/X86SelectionDAGInfo.cpp
View File

@ -27,7 +27,7 @@ X86SelectionDAGInfo::~X86SelectionDAGInfo() {
} }
SDValue SDValue
X86SelectionDAGInfo::EmitTargetCodeForMemset(SelectionDAG &DAG, DebugLoc dl, X86SelectionDAGInfo::EmitTargetCodeForMemset(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Chain,
SDValue Dst, SDValue Src, SDValue Dst, SDValue Src,
SDValue Size, unsigned Align, SDValue Size, unsigned Align,
@ -175,7 +175,7 @@ X86SelectionDAGInfo::EmitTargetCodeForMemset(SelectionDAG &DAG, DebugLoc dl,
} }
SDValue SDValue
X86SelectionDAGInfo::EmitTargetCodeForMemcpy(SelectionDAG &DAG, DebugLoc dl, X86SelectionDAGInfo::EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Dst, SDValue Src, SDValue Chain, SDValue Dst, SDValue Src,
SDValue Size, unsigned Align, SDValue Size, unsigned Align,
bool isVolatile, bool AlwaysInline, bool isVolatile, bool AlwaysInline,

4
lib/Target/X86/X86SelectionDAGInfo.h
View File

@ -34,7 +34,7 @@ public:
~X86SelectionDAGInfo(); ~X86SelectionDAGInfo();
virtual virtual
SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, DebugLoc dl, SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Chain,
SDValue Dst, SDValue Src, SDValue Dst, SDValue Src,
SDValue Size, unsigned Align, SDValue Size, unsigned Align,
@ -42,7 +42,7 @@ public:
MachinePointerInfo DstPtrInfo) const; MachinePointerInfo DstPtrInfo) const;
virtual virtual
SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, DebugLoc dl, SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, SDLoc dl,
SDValue Chain, SDValue Chain,
SDValue Dst, SDValue Src, SDValue Dst, SDValue Src,
SDValue Size, unsigned Align, SDValue Size, unsigned Align,

6
lib/Target/XCore/XCoreISelDAGToDAG.cpp
View File

@ -109,7 +109,7 @@ bool XCoreDAGToDAGISel::SelectADDRspii(SDValue Addr, SDValue &Base,
} }
SDNode *XCoreDAGToDAGISel::Select(SDNode *N) { SDNode *XCoreDAGToDAGISel::Select(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
switch (N->getOpcode()) { switch (N->getOpcode()) {
default: break; default: break;
case ISD::Constant: { case ISD::Constant: {
@ -204,12 +204,12 @@ replaceInChain(SelectionDAG *CurDAG, SDValue Chain, SDValue Old, SDValue New)
} }
if (!found) if (!found)
return SDValue(); return SDValue();
return CurDAG->getNode(ISD::TokenFactor, Chain->getDebugLoc(), MVT::Other, return CurDAG->getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other,
&Ops[0], Ops.size()); &Ops[0], Ops.size());
} }
SDNode *XCoreDAGToDAGISel::SelectBRIND(SDNode *N) { SDNode *XCoreDAGToDAGISel::SelectBRIND(SDNode *N) {
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// (brind (int_xcore_checkevent (addr))) // (brind (int_xcore_checkevent (addr)))
SDValue Chain = N->getOperand(0); SDValue Chain = N->getOperand(0);
SDValue Addr = N->getOperand(1); SDValue Addr = N->getOperand(1);

52
lib/Target/XCore/XCoreISelLowering.cpp
View File

@ -215,7 +215,7 @@ void XCoreTargetLowering::ReplaceNodeResults(SDNode *N,
SDValue XCoreTargetLowering:: SDValue XCoreTargetLowering::
LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const LowerSELECT_CC(SDValue Op, SelectionDAG &DAG) const
{ {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue Cond = DAG.getNode(ISD::SETCC, dl, MVT::i32, Op.getOperand(2), SDValue Cond = DAG.getNode(ISD::SETCC, dl, MVT::i32, Op.getOperand(2),
Op.getOperand(3), Op.getOperand(4)); Op.getOperand(3), Op.getOperand(4));
return DAG.getNode(ISD::SELECT, dl, MVT::i32, Cond, Op.getOperand(0), return DAG.getNode(ISD::SELECT, dl, MVT::i32, Cond, Op.getOperand(0),
@ -227,7 +227,7 @@ getGlobalAddressWrapper(SDValue GA, const GlobalValue *GV,
SelectionDAG &DAG) const SelectionDAG &DAG) const
{ {
// FIXME there is no actual debug info here // FIXME there is no actual debug info here
DebugLoc dl = GA.getDebugLoc(); SDLoc dl(GA);
const GlobalValue *UnderlyingGV = GV; const GlobalValue *UnderlyingGV = GV;
// If GV is an alias then use the aliasee to determine the wrapper type // If GV is an alias then use the aliasee to determine the wrapper type
if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(GV)) if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(GV))
@ -243,7 +243,7 @@ getGlobalAddressWrapper(SDValue GA, const GlobalValue *GV,
SDValue XCoreTargetLowering:: SDValue XCoreTargetLowering::
LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const
{ {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
const GlobalAddressSDNode *GN = cast<GlobalAddressSDNode>(Op); const GlobalAddressSDNode *GN = cast<GlobalAddressSDNode>(Op);
const GlobalValue *GV = GN->getGlobal(); const GlobalValue *GV = GN->getGlobal();
int64_t Offset = GN->getOffset(); int64_t Offset = GN->getOffset();
@ -259,7 +259,7 @@ LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const
return GA; return GA;
} }
static inline SDValue BuildGetId(SelectionDAG &DAG, DebugLoc dl) { static inline SDValue BuildGetId(SelectionDAG &DAG, SDLoc dl) {
return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::i32, return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::i32,
DAG.getConstant(Intrinsic::xcore_getid, MVT::i32)); DAG.getConstant(Intrinsic::xcore_getid, MVT::i32));
} }
@ -267,7 +267,7 @@ static inline SDValue BuildGetId(SelectionDAG &DAG, DebugLoc dl) {
SDValue XCoreTargetLowering:: SDValue XCoreTargetLowering::
LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const
{ {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress(); const BlockAddress *BA = cast<BlockAddressSDNode>(Op)->getBlockAddress();
SDValue Result = DAG.getTargetBlockAddress(BA, getPointerTy()); SDValue Result = DAG.getTargetBlockAddress(BA, getPointerTy());
@ -280,7 +280,7 @@ LowerConstantPool(SDValue Op, SelectionDAG &DAG) const
{ {
ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op); ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
// FIXME there isn't really debug info here // FIXME there isn't really debug info here
DebugLoc dl = CP->getDebugLoc(); SDLoc dl(CP);
EVT PtrVT = Op.getValueType(); EVT PtrVT = Op.getValueType();
SDValue Res; SDValue Res;
if (CP->isMachineConstantPoolEntry()) { if (CP->isMachineConstantPoolEntry()) {
@ -303,7 +303,7 @@ LowerBR_JT(SDValue Op, SelectionDAG &DAG) const
SDValue Chain = Op.getOperand(0); SDValue Chain = Op.getOperand(0);
SDValue Table = Op.getOperand(1); SDValue Table = Op.getOperand(1);
SDValue Index = Op.getOperand(2); SDValue Index = Op.getOperand(2);
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
JumpTableSDNode *JT = cast<JumpTableSDNode>(Table); JumpTableSDNode *JT = cast<JumpTableSDNode>(Table);
unsigned JTI = JT->getIndex(); unsigned JTI = JT->getIndex();
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
@ -322,7 +322,7 @@ LowerBR_JT(SDValue Op, SelectionDAG &DAG) const
} }
SDValue XCoreTargetLowering:: SDValue XCoreTargetLowering::
lowerLoadWordFromAlignedBasePlusOffset(DebugLoc DL, SDValue Chain, SDValue Base, lowerLoadWordFromAlignedBasePlusOffset(SDLoc DL, SDValue Chain, SDValue Base,
int64_t Offset, SelectionDAG &DAG) const int64_t Offset, SelectionDAG &DAG) const
{ {
if ((Offset & 0x3) == 0) { if ((Offset & 0x3) == 0) {
@ -388,7 +388,7 @@ LowerLOAD(SDValue Op, SelectionDAG &DAG) const {
SDValue Chain = LD->getChain(); SDValue Chain = LD->getChain();
SDValue BasePtr = LD->getBasePtr(); SDValue BasePtr = LD->getBasePtr();
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
if (!LD->isVolatile()) { if (!LD->isVolatile()) {
const GlobalValue *GV; const GlobalValue *GV;
@ -469,7 +469,7 @@ LowerSTORE(SDValue Op, SelectionDAG &DAG) const
SDValue Chain = ST->getChain(); SDValue Chain = ST->getChain();
SDValue BasePtr = ST->getBasePtr(); SDValue BasePtr = ST->getBasePtr();
SDValue Value = ST->getValue(); SDValue Value = ST->getValue();
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
if (ST->getAlignment() == 2) { if (ST->getAlignment() == 2) {
SDValue Low = Value; SDValue Low = Value;
@ -516,7 +516,7 @@ LowerSMUL_LOHI(SDValue Op, SelectionDAG &DAG) const
{ {
assert(Op.getValueType() == MVT::i32 && Op.getOpcode() == ISD::SMUL_LOHI && assert(Op.getValueType() == MVT::i32 && Op.getOpcode() == ISD::SMUL_LOHI &&
"Unexpected operand to lower!"); "Unexpected operand to lower!");
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue LHS = Op.getOperand(0); SDValue LHS = Op.getOperand(0);
SDValue RHS = Op.getOperand(1); SDValue RHS = Op.getOperand(1);
SDValue Zero = DAG.getConstant(0, MVT::i32); SDValue Zero = DAG.getConstant(0, MVT::i32);
@ -533,7 +533,7 @@ LowerUMUL_LOHI(SDValue Op, SelectionDAG &DAG) const
{ {
assert(Op.getValueType() == MVT::i32 && Op.getOpcode() == ISD::UMUL_LOHI && assert(Op.getValueType() == MVT::i32 && Op.getOpcode() == ISD::UMUL_LOHI &&
"Unexpected operand to lower!"); "Unexpected operand to lower!");
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
SDValue LHS = Op.getOperand(0); SDValue LHS = Op.getOperand(0);
SDValue RHS = Op.getOperand(1); SDValue RHS = Op.getOperand(1);
SDValue Zero = DAG.getConstant(0, MVT::i32); SDValue Zero = DAG.getConstant(0, MVT::i32);
@ -618,7 +618,7 @@ TryExpandADDWithMul(SDNode *N, SelectionDAG &DAG) const
} else { } else {
return SDValue(); return SDValue();
} }
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
SDValue LL, RL, AddendL, AddendH; SDValue LL, RL, AddendL, AddendH;
LL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, LL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
Mul.getOperand(0), DAG.getConstant(0, MVT::i32)); Mul.getOperand(0), DAG.getConstant(0, MVT::i32));
@ -677,7 +677,7 @@ ExpandADDSUB(SDNode *N, SelectionDAG &DAG) const
return Result; return Result;
} }
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
// Extract components // Extract components
SDValue LHSL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, SDValue LHSL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
@ -710,7 +710,7 @@ LowerVAARG(SDValue Op, SelectionDAG &DAG) const
llvm_unreachable("unimplemented"); llvm_unreachable("unimplemented");
// FIXME Arguments passed by reference need a extra dereference. // FIXME Arguments passed by reference need a extra dereference.
SDNode *Node = Op.getNode(); SDNode *Node = Op.getNode();
DebugLoc dl = Node->getDebugLoc(); SDLoc dl(Node);
const Value *V = cast<SrcValueSDNode>(Node->getOperand(2))->getValue(); const Value *V = cast<SrcValueSDNode>(Node->getOperand(2))->getValue();
EVT VT = Node->getValueType(0); EVT VT = Node->getValueType(0);
SDValue VAList = DAG.getLoad(getPointerTy(), dl, Node->getOperand(0), SDValue VAList = DAG.getLoad(getPointerTy(), dl, Node->getOperand(0),
@ -731,7 +731,7 @@ LowerVAARG(SDValue Op, SelectionDAG &DAG) const
SDValue XCoreTargetLowering:: SDValue XCoreTargetLowering::
LowerVASTART(SDValue Op, SelectionDAG &DAG) const LowerVASTART(SDValue Op, SelectionDAG &DAG) const
{ {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// vastart stores the address of the VarArgsFrameIndex slot into the // vastart stores the address of the VarArgsFrameIndex slot into the
// memory location argument // memory location argument
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
@ -743,7 +743,7 @@ LowerVASTART(SDValue Op, SelectionDAG &DAG) const
SDValue XCoreTargetLowering::LowerFRAMEADDR(SDValue Op, SDValue XCoreTargetLowering::LowerFRAMEADDR(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
// Depths > 0 not supported yet! // Depths > 0 not supported yet!
if (cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue() > 0) if (cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue() > 0)
return SDValue(); return SDValue();
@ -783,7 +783,7 @@ LowerINIT_TRAMPOLINE(SDValue Op, SelectionDAG &DAG) const {
SDValue Addr = Trmp; SDValue Addr = Trmp;
DebugLoc dl = Op.getDebugLoc(); SDLoc dl(Op);
OutChains[0] = DAG.getStore(Chain, dl, DAG.getConstant(0x0a3cd805, MVT::i32), OutChains[0] = DAG.getStore(Chain, dl, DAG.getConstant(0x0a3cd805, MVT::i32),
Addr, MachinePointerInfo(TrmpAddr), false, false, Addr, MachinePointerInfo(TrmpAddr), false, false,
0); 0);
@ -817,7 +817,7 @@ LowerINIT_TRAMPOLINE(SDValue Op, SelectionDAG &DAG) const {
SDValue XCoreTargetLowering:: SDValue XCoreTargetLowering::
LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const { LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const {
DebugLoc DL = Op.getDebugLoc(); SDLoc DL(Op);
unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue(); unsigned IntNo = cast<ConstantSDNode>(Op.getOperand(0))->getZExtValue();
switch (IntNo) { switch (IntNo) {
case Intrinsic::xcore_crc8: case Intrinsic::xcore_crc8:
@ -847,7 +847,7 @@ SDValue
XCoreTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI, XCoreTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
SelectionDAG &DAG = CLI.DAG; SelectionDAG &DAG = CLI.DAG;
DebugLoc &dl = CLI.DL; SDLoc &dl = CLI.DL;
SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs; SmallVector<ISD::OutputArg, 32> &Outs = CLI.Outs;
SmallVector<SDValue, 32> &OutVals = CLI.OutVals; SmallVector<SDValue, 32> &OutVals = CLI.OutVals;
SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins; SmallVector<ISD::InputArg, 32> &Ins = CLI.Ins;
@ -883,7 +883,7 @@ XCoreTargetLowering::LowerCCCCallTo(SDValue Chain, SDValue Callee,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
// Analyze operands of the call, assigning locations to each operand. // Analyze operands of the call, assigning locations to each operand.
@ -1006,7 +1006,7 @@ SDValue
XCoreTargetLowering::LowerCallResult(SDValue Chain, SDValue InFlag, XCoreTargetLowering::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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
// Assign locations to each value returned by this call. // Assign locations to each value returned by this call.
@ -1037,7 +1037,7 @@ XCoreTargetLowering::LowerFormalArguments(SDValue Chain,
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SDLoc dl,
SelectionDAG &DAG, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) SmallVectorImpl<SDValue> &InVals)
const { const {
@ -1062,7 +1062,7 @@ XCoreTargetLowering::LowerCCCArguments(SDValue Chain,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> const SmallVectorImpl<ISD::InputArg>
&Ins, &Ins,
DebugLoc dl, SDLoc dl,
SelectionDAG &DAG, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const { SmallVectorImpl<SDValue> &InVals) const {
MachineFunction &MF = DAG.getMachineFunction(); MachineFunction &MF = DAG.getMachineFunction();
@ -1188,7 +1188,7 @@ XCoreTargetLowering::LowerReturn(SDValue Chain,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const { SDLoc dl, SelectionDAG &DAG) const {
// CCValAssign - represent the assignment of // CCValAssign - represent the assignment of
// the return value to a location // the return value to a location
@ -1305,7 +1305,7 @@ XCoreTargetLowering::EmitInstrWithCustomInserter(MachineInstr *MI,
SDValue XCoreTargetLowering::PerformDAGCombine(SDNode *N, SDValue XCoreTargetLowering::PerformDAGCombine(SDNode *N,
DAGCombinerInfo &DCI) const { DAGCombinerInfo &DCI) const {
SelectionDAG &DAG = DCI.DAG; SelectionDAG &DAG = DCI.DAG;
DebugLoc dl = N->getDebugLoc(); SDLoc dl(N);
switch (N->getOpcode()) { switch (N->getOpcode()) {
default: break; default: break;
case XCoreISD::LADD: { case XCoreISD::LADD: {

12
lib/Target/XCore/XCoreISelLowering.h
View File

@ -115,7 +115,7 @@ namespace llvm {
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue LowerCCCCallTo(SDValue Chain, SDValue Callee, SDValue LowerCCCCallTo(SDValue Chain, SDValue Callee,
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
@ -123,17 +123,17 @@ namespace llvm {
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
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,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
SDValue getReturnAddressFrameIndex(SelectionDAG &DAG) const; SDValue getReturnAddressFrameIndex(SelectionDAG &DAG) const;
SDValue getGlobalAddressWrapper(SDValue GA, const GlobalValue *GV, SDValue getGlobalAddressWrapper(SDValue GA, const GlobalValue *GV,
SelectionDAG &DAG) const; SelectionDAG &DAG) const;
SDValue lowerLoadWordFromAlignedBasePlusOffset(DebugLoc DL, SDValue Chain, SDValue lowerLoadWordFromAlignedBasePlusOffset(SDLoc DL, SDValue Chain,
SDValue Base, int64_t Offset, SDValue Base, int64_t Offset,
SelectionDAG &DAG) const; SelectionDAG &DAG) const;
@ -177,7 +177,7 @@ namespace llvm {
CallingConv::ID CallConv, CallingConv::ID CallConv,
bool isVarArg, bool isVarArg,
const SmallVectorImpl<ISD::InputArg> &Ins, const SmallVectorImpl<ISD::InputArg> &Ins,
DebugLoc dl, SelectionDAG &DAG, SDLoc dl, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &InVals) const; SmallVectorImpl<SDValue> &InVals) const;
virtual SDValue virtual SDValue
@ -189,7 +189,7 @@ namespace llvm {
CallingConv::ID CallConv, bool isVarArg, CallingConv::ID CallConv, bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs, const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals, const SmallVectorImpl<SDValue> &OutVals,
DebugLoc dl, SelectionDAG &DAG) const; SDLoc dl, SelectionDAG &DAG) const;
virtual bool virtual bool
CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF, CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,