6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-28 06:32:09 +00:00
Code Issues Projects Releases Wiki Activity

Change ConstantPoolSDNode to actually hold the Constant itself instead of

Browse Source 
putting it into the constant pool.  This allows the isel machinery to
create constants that it will end up deciding are not needed, without them
ending up in the resultant function constant pool.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23081 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2005-08-26 17:15:30 +00:00
parent 95e0682a42
commit 5839bf2b3b
11 changed files with 59 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -100,8 +100,8 @@ public:
SDOperand getTargetGlobalAddress(const GlobalValue *GV, MVT::ValueType VT); SDOperand getTargetGlobalAddress(const GlobalValue *GV, MVT::ValueType VT);
SDOperand getFrameIndex(int FI, MVT::ValueType VT); SDOperand getFrameIndex(int FI, MVT::ValueType VT);
SDOperand getTargetFrameIndex(int FI, MVT::ValueType VT); SDOperand getTargetFrameIndex(int FI, MVT::ValueType VT);
SDOperand getConstantPool(unsigned CPIdx, MVT::ValueType VT); SDOperand getConstantPool(Constant *C, MVT::ValueType VT);
SDOperand getTargetConstantPool(unsigned CPIdx, MVT::ValueType VT); SDOperand getTargetConstantPool(Constant *C, MVT::ValueType VT);
SDOperand getBasicBlock(MachineBasicBlock *MBB); SDOperand getBasicBlock(MachineBasicBlock *MBB);
SDOperand getExternalSymbol(const char *Sym, MVT::ValueType VT); SDOperand getExternalSymbol(const char *Sym, MVT::ValueType VT);
SDOperand getValueType(MVT::ValueType); SDOperand getValueType(MVT::ValueType);
@ -320,7 +320,8 @@ private:
std::map<std::pair<uint64_t, MVT::ValueType>, SDNode*> TargetConstants; std::map<std::pair<uint64_t, MVT::ValueType>, SDNode*> TargetConstants;
std::map<std::pair<uint64_t, MVT::ValueType>, SDNode*> ConstantFPs; std::map<std::pair<uint64_t, MVT::ValueType>, SDNode*> ConstantFPs;
std::map<int, SDNode*> FrameIndices, TargetFrameIndices; std::map<int, SDNode*> FrameIndices, TargetFrameIndices;
std::map<unsigned, SDNode*> ConstantPoolIndices, TargetConstantPoolIndices; std::map<Constant *, SDNode*> ConstantPoolIndices;
std::map<Constant *, SDNode*> TargetConstantPoolIndices;
std::map<MachineBasicBlock *, SDNode*> BBNodes; std::map<MachineBasicBlock *, SDNode*> BBNodes;
std::vector<SDNode*> ValueTypeNodes; std::vector<SDNode*> ValueTypeNodes;
std::map<std::string, SDNode*> ExternalSymbols; std::map<std::string, SDNode*> ExternalSymbols;

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

@ -828,15 +828,15 @@ public:
}; };
class ConstantPoolSDNode : public SDNode { class ConstantPoolSDNode : public SDNode {
unsigned CPI; Constant *C;
protected: protected:
friend class SelectionDAG; friend class SelectionDAG;
ConstantPoolSDNode(unsigned cpi, MVT::ValueType VT, bool isTarget) ConstantPoolSDNode(Constant *c, MVT::ValueType VT, bool isTarget)
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, VT), : SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, VT),
CPI(cpi) {} C(c) {}
public: public:
unsigned getIndex() const { return CPI; } Constant *get() const { return C; }
static bool classof(const ConstantPoolSDNode *) { return true; } static bool classof(const ConstantPoolSDNode *) { return true; }
static bool classof(const SDNode *N) { static bool classof(const SDNode *N) {

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

@ -12,7 +12,6 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/CodeGen/SelectionDAG.h" #include "llvm/CodeGen/SelectionDAG.h"
#include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/Support/MathExtras.h" #include "llvm/Support/MathExtras.h"
@ -248,9 +247,7 @@ SDOperand SelectionDAGLegalize::ExpandLegalINT_TO_FP(bool isSigned,
if (TLI.isLittleEndian()) FF <<= 32; if (TLI.isLittleEndian()) FF <<= 32;
static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF);
MachineConstantPool *CP = DAG.getMachineFunction().getConstantPool(); SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy());
SDOperand CPIdx = DAG.getConstantPool(CP->getConstantPoolIndex(FudgeFactor),
TLI.getPointerTy());
CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset);
SDOperand FudgeInReg; SDOperand FudgeInReg;
if (DestVT == MVT::f32) if (DestVT == MVT::f32)
@ -529,8 +526,6 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
if (!isLegal) { if (!isLegal) {
// Otherwise we need to spill the constant to memory. // Otherwise we need to spill the constant to memory.
MachineConstantPool *CP = DAG.getMachineFunction().getConstantPool();
bool Extend = false; bool Extend = false;
// If a FP immediate is precise when represented as a float, we put it // If a FP immediate is precise when represented as a float, we put it
@ -549,8 +544,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
Extend = true; Extend = true;
} }
SDOperand CPIdx = DAG.getConstantPool(CP->getConstantPoolIndex(LLVMC), SDOperand CPIdx = DAG.getConstantPool(LLVMC, TLI.getPointerTy());
TLI.getPointerTy());
if (Extend) { if (Extend) {
Result = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(), Result = DAG.getExtLoad(ISD::EXTLOAD, MVT::f64, DAG.getEntryNode(),
CPIdx, DAG.getSrcValue(NULL), MVT::f32); CPIdx, DAG.getSrcValue(NULL), MVT::f32);
@ -2751,9 +2745,7 @@ ExpandIntToFP(bool isSigned, MVT::ValueType DestTy, SDOperand Source) {
if (TLI.isLittleEndian()) FF <<= 32; if (TLI.isLittleEndian()) FF <<= 32;
static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF); static Constant *FudgeFactor = ConstantUInt::get(Type::ULongTy, FF);
MachineConstantPool *CP = DAG.getMachineFunction().getConstantPool(); SDOperand CPIdx = DAG.getConstantPool(FudgeFactor, TLI.getPointerTy());
SDOperand CPIdx = DAG.getConstantPool(CP->getConstantPoolIndex(FudgeFactor),
TLI.getPointerTy());
CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset); CPIdx = DAG.getNode(ISD::ADD, TLI.getPointerTy(), CPIdx, CstOffset);
SDOperand FudgeInReg; SDOperand FudgeInReg;
if (DestTy == MVT::f32) if (DestTy == MVT::f32)

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

@ -13,6 +13,7 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DEBUG_TYPE "sched" #define DEBUG_TYPE "sched"
#include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/SelectionDAGISel.h" #include "llvm/CodeGen/SelectionDAGISel.h"
#include "llvm/CodeGen/SelectionDAG.h" #include "llvm/CodeGen/SelectionDAG.h"
@ -38,12 +39,14 @@ namespace {
const TargetInstrInfo &TII; const TargetInstrInfo &TII;
const MRegisterInfo &MRI; const MRegisterInfo &MRI;
SSARegMap *RegMap; SSARegMap *RegMap;
MachineConstantPool *ConstPool;
std::map<SDNode *, unsigned> EmittedOps; std::map<SDNode *, unsigned> EmittedOps;
public: public:
SimpleSched(SelectionDAG &D, MachineBasicBlock *bb) SimpleSched(SelectionDAG &D, MachineBasicBlock *bb)
: DAG(D), BB(bb), TM(D.getTarget()), TII(*TM.getInstrInfo()), : DAG(D), BB(bb), TM(D.getTarget()), TII(*TM.getInstrInfo()),
MRI(*TM.getRegisterInfo()), RegMap(BB->getParent()->getSSARegMap()) { MRI(*TM.getRegisterInfo()), RegMap(BB->getParent()->getSSARegMap()),
ConstPool(BB->getParent()->getConstantPool()) {
assert(&TII && "Target doesn't provide instr info?"); assert(&TII && "Target doesn't provide instr info?");
assert(&MRI && "Target doesn't provide register info?"); assert(&MRI && "Target doesn't provide register info?");
} }
@ -148,7 +151,8 @@ unsigned SimpleSched::Emit(SDOperand Op) {
MI->addFrameIndexOperand(FI->getIndex()); MI->addFrameIndexOperand(FI->getIndex());
} else if (ConstantPoolSDNode *CP = } else if (ConstantPoolSDNode *CP =
dyn_cast<ConstantPoolSDNode>(Op.getOperand(i))) { dyn_cast<ConstantPoolSDNode>(Op.getOperand(i))) {
MI->addConstantPoolIndexOperand(CP->getIndex()); unsigned Idx = ConstPool->getConstantPoolIndex(CP->get());
MI->addConstantPoolIndexOperand(Idx);
} else if (ExternalSymbolSDNode *ES = } else if (ExternalSymbolSDNode *ES =
dyn_cast<ExternalSymbolSDNode>(Op.getOperand(i))) { dyn_cast<ExternalSymbolSDNode>(Op.getOperand(i))) {
MI->addExternalSymbolOperand(ES->getSymbol(), false); MI->addExternalSymbolOperand(ES->getSymbol(), false);

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

@ -265,10 +265,10 @@ void SelectionDAG::RemoveNodeFromCSEMaps(SDNode *N) {
TargetFrameIndices.erase(cast<FrameIndexSDNode>(N)->getIndex()); TargetFrameIndices.erase(cast<FrameIndexSDNode>(N)->getIndex());
break; break;
case ISD::ConstantPool: case ISD::ConstantPool:
ConstantPoolIndices.erase(cast<ConstantPoolSDNode>(N)->getIndex()); ConstantPoolIndices.erase(cast<ConstantPoolSDNode>(N)->get());
break; break;
case ISD::TargetConstantPool: case ISD::TargetConstantPool:
TargetConstantPoolIndices.erase(cast<ConstantPoolSDNode>(N)->getIndex()); TargetConstantPoolIndices.erase(cast<ConstantPoolSDNode>(N)->get());
break; break;
case ISD::BasicBlock: case ISD::BasicBlock:
BBNodes.erase(cast<BasicBlockSDNode>(N)->getBasicBlock()); BBNodes.erase(cast<BasicBlockSDNode>(N)->getBasicBlock());
@ -452,19 +452,18 @@ SDOperand SelectionDAG::getTargetFrameIndex(int FI, MVT::ValueType VT) {
return SDOperand(N, 0); return SDOperand(N, 0);
} }
SDOperand SelectionDAG::getConstantPool(unsigned CPIdx, MVT::ValueType VT) { SDOperand SelectionDAG::getConstantPool(Constant *C, MVT::ValueType VT) {
SDNode *N = ConstantPoolIndices[CPIdx]; SDNode *&N = ConstantPoolIndices[C];
if (N) return SDOperand(N, 0); if (N) return SDOperand(N, 0);
N = new ConstantPoolSDNode(CPIdx, VT, false); N = new ConstantPoolSDNode(C, VT, false);
AllNodes.push_back(N); AllNodes.push_back(N);
return SDOperand(N, 0); return SDOperand(N, 0);
} }
SDOperand SelectionDAG::getTargetConstantPool(unsigned CPIdx, SDOperand SelectionDAG::getTargetConstantPool(Constant *C, MVT::ValueType VT) {
MVT::ValueType VT) { SDNode *&N = TargetConstantPoolIndices[C];
SDNode *N = TargetConstantPoolIndices[CPIdx];
if (N) return SDOperand(N, 0); if (N) return SDOperand(N, 0);
N = new ConstantPoolSDNode(CPIdx, VT, true); N = new ConstantPoolSDNode(C, VT, true);
AllNodes.push_back(N); AllNodes.push_back(N);
return SDOperand(N, 0); return SDOperand(N, 0);
} }
@ -2134,8 +2133,8 @@ const char *SDNode::getOperationName(const SelectionDAG *G) const {
case ISD::BasicBlock: return "BasicBlock"; case ISD::BasicBlock: return "BasicBlock";
case ISD::Register: return "Register"; case ISD::Register: return "Register";
case ISD::ExternalSymbol: return "ExternalSymbol"; case ISD::ExternalSymbol: return "ExternalSymbol";
case ISD::ConstantPool: return "ConstantPoolIndex"; case ISD::ConstantPool: return "ConstantPool";
case ISD::TargetConstantPool: return "TargetConstantPoolIndex"; case ISD::TargetConstantPool: return "TargetConstantPool";
case ISD::CopyToReg: return "CopyToReg"; case ISD::CopyToReg: return "CopyToReg";
case ISD::CopyFromReg: return "CopyFromReg"; case ISD::CopyFromReg: return "CopyFromReg";
case ISD::ImplicitDef: return "ImplicitDef"; case ISD::ImplicitDef: return "ImplicitDef";
@ -2287,7 +2286,7 @@ void SDNode::dump(const SelectionDAG *G) const {
} else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(this)) { } else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(this)) {
std::cerr << "<" << FIDN->getIndex() << ">"; std::cerr << "<" << FIDN->getIndex() << ">";
} else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(this)){ } else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(this)){
std::cerr << "<" << CP->getIndex() << ">"; std::cerr << "<" << *CP->get() << ">";
} else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(this)) { } else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(this)) {
std::cerr << "<"; std::cerr << "<";
const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock(); const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();

6
lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp
View File

@ -11,11 +11,12 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Constants.h"
#include "llvm/Function.h"
#include "llvm/CodeGen/SelectionDAG.h" #include "llvm/CodeGen/SelectionDAG.h"
#include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineFunction.h"
#include "llvm/Target/MRegisterInfo.h" #include "llvm/Target/MRegisterInfo.h"
#include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetMachine.h"
#include "llvm/Function.h"
#include "llvm/Support/GraphWriter.h" #include "llvm/Support/GraphWriter.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/Config/config.h" #include "llvm/Config/config.h"
@ -67,7 +68,8 @@ std::string DOTGraphTraits<SelectionDAG*>::getNodeLabel(const SDNode *Node,
} else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(Node)) { } else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(Node)) {
Op += " " + itostr(FIDN->getIndex()); Op += " " + itostr(FIDN->getIndex());
} else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Node)){ } else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Node)){
Op += "<" + utostr(CP->getIndex()) + ">"; if (ConstantFP *CFP = dyn_cast<ConstantFP>(CP->get()))
Op += "<" + ftostr(CFP->getValue()) + ">";
} else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(Node)) { } else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(Node)) {
Op = "BB: "; Op = "BB: ";
const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock(); const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();

9
lib/Target/Alpha/AlphaISelPattern.cpp
View File

@ -1216,7 +1216,8 @@ unsigned AlphaISel::SelectExpr(SDOperand N) {
return Result; return Result;
case ISD::ConstantPool: case ISD::ConstantPool:
Tmp1 = cast<ConstantPoolSDNode>(N)->getIndex(); Tmp1 = BB->getParent()->getConstantPool()->
getConstantPoolIndex(cast<ConstantPoolSDNode>(N)->get());
AlphaLowering.restoreGP(BB); AlphaLowering.restoreGP(BB);
Tmp2 = MakeReg(MVT::i64); Tmp2 = MakeReg(MVT::i64);
BuildMI(BB, Alpha::LDAHr, 2, Tmp2).addConstantPoolIndex(Tmp1) BuildMI(BB, Alpha::LDAHr, 2, Tmp2).addConstantPoolIndex(Tmp1)
@ -1285,16 +1286,18 @@ unsigned AlphaISel::SelectExpr(SDOperand N) {
.addGlobalAddress(GASD->getGlobal()).addReg(Tmp1); .addGlobalAddress(GASD->getGlobal()).addReg(Tmp1);
} else if (ConstantPoolSDNode *CP = } else if (ConstantPoolSDNode *CP =
dyn_cast<ConstantPoolSDNode>(Address)) { dyn_cast<ConstantPoolSDNode>(Address)) {
unsigned CPIdx = BB->getParent()->getConstantPool()->
getConstantPoolIndex(CP->get());
AlphaLowering.restoreGP(BB); AlphaLowering.restoreGP(BB);
has_sym = true; has_sym = true;
Tmp1 = MakeReg(MVT::i64); Tmp1 = MakeReg(MVT::i64);
BuildMI(BB, Alpha::LDAHr, 2, Tmp1).addConstantPoolIndex(CP->getIndex()) BuildMI(BB, Alpha::LDAHr, 2, Tmp1).addConstantPoolIndex(CPIdx)
.addReg(Alpha::R29); .addReg(Alpha::R29);
if (EnableAlphaLSMark) if (EnableAlphaLSMark)
BuildMI(BB, Alpha::MEMLABEL, 4).addImm(i).addImm(j).addImm(k) BuildMI(BB, Alpha::MEMLABEL, 4).addImm(i).addImm(j).addImm(k)
.addImm(getUID()); .addImm(getUID());
BuildMI(BB, GetRelVersion(Opc), 2, Result) BuildMI(BB, GetRelVersion(Opc), 2, Result)
.addConstantPoolIndex(CP->getIndex()).addReg(Tmp1); .addConstantPoolIndex(CPIdx).addReg(Tmp1);
} else if(Address.getOpcode() == ISD::FrameIndex) { } else if(Address.getOpcode() == ISD::FrameIndex) {
if (EnableAlphaLSMark) if (EnableAlphaLSMark)
BuildMI(BB, Alpha::MEMLABEL, 4).addImm(i).addImm(j).addImm(k) BuildMI(BB, Alpha::MEMLABEL, 4).addImm(i).addImm(j).addImm(k)

7
lib/Target/IA64/IA64ISelPattern.cpp
View File

@ -956,7 +956,8 @@ unsigned ISel::SelectExpr(SDOperand N) {
} }
case ISD::ConstantPool: { case ISD::ConstantPool: {
Tmp1 = cast<ConstantPoolSDNode>(N)->getIndex(); Tmp1 = BB->getParent()->getConstantPool()->
getConstantPoolIndex(cast<ConstantPoolSDNode>(N)->get());
IA64Lowering.restoreGP(BB); // FIXME: do i really need this? IA64Lowering.restoreGP(BB); // FIXME: do i really need this?
BuildMI(BB, IA64::ADD, 2, Result).addConstantPoolIndex(Tmp1) BuildMI(BB, IA64::ADD, 2, Result).addConstantPoolIndex(Tmp1)
.addReg(IA64::r1); .addReg(IA64::r1);
@ -1974,10 +1975,12 @@ pC = pA OR pB
BuildMI(BB, IA64::CMPNE, 2, Result).addReg(dummy3).addReg(IA64::r0); BuildMI(BB, IA64::CMPNE, 2, Result).addReg(dummy3).addReg(IA64::r0);
} }
} else if(ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Address)) { } else if(ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Address)) {
unsigned CPIdx = BB->getParent()->getConstantPool()->
getConstantPoolIndex(cast<ConstantPoolSDNode>(N)->get());
Select(Chain); Select(Chain);
IA64Lowering.restoreGP(BB); IA64Lowering.restoreGP(BB);
unsigned dummy = MakeReg(MVT::i64); unsigned dummy = MakeReg(MVT::i64);
BuildMI(BB, IA64::ADD, 2, dummy).addConstantPoolIndex(CP->getIndex()) BuildMI(BB, IA64::ADD, 2, dummy).addConstantPoolIndex(CPIdx)
.addReg(IA64::r1); // CPI+GP .addReg(IA64::r1); // CPI+GP
if(!isBool) if(!isBool)
BuildMI(BB, Opc, 1, Result).addReg(dummy); BuildMI(BB, Opc, 1, Result).addReg(dummy);

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

@ -15,7 +15,6 @@
#include "PowerPC.h" #include "PowerPC.h"
#include "PPC32TargetMachine.h" #include "PPC32TargetMachine.h"
#include "PPC32ISelLowering.h" #include "PPC32ISelLowering.h"
#include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/CodeGen/MachineInstrBuilder.h" #include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/SSARegMap.h" #include "llvm/CodeGen/SSARegMap.h"
@ -696,11 +695,9 @@ SDOperand PPC32DAGToDAGISel::Select(SDOperand Op) {
break; break;
} }
case ISD::ConstantFP: { // FIXME: this should get sucked into the legalizer case ISD::ConstantFP: { // FIXME: this should get sucked into the legalizer
MachineConstantPool *CP = CurDAG->getMachineFunction().getConstantPool();
Constant *CFP = ConstantFP::get(Type::FloatTy, Constant *CFP = ConstantFP::get(Type::FloatTy,
cast<ConstantFPSDNode>(N)->getValue()); cast<ConstantFPSDNode>(N)->getValue());
SDOperand CPN = CurDAG->getConstantPool(CP->getConstantPoolIndex(CFP), SDOperand CPN = CurDAG->getConstantPool(CFP, MVT::i32);
MVT::i32);
SDOperand Tmp; SDOperand Tmp;
if (PICEnabled) if (PICEnabled)
Tmp = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(),CPN); Tmp = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(),CPN);
@ -723,8 +720,8 @@ SDOperand PPC32DAGToDAGISel::Select(SDOperand Op) {
break; break;
} }
case ISD::ConstantPool: { case ISD::ConstantPool: {
unsigned CPIIdx = cast<ConstantPoolSDNode>(N)->getIndex(); Constant *C = cast<ConstantPoolSDNode>(N)->get();
SDOperand Tmp, CPI = CurDAG->getTargetConstantPool(CPIIdx, MVT::i32); SDOperand Tmp, CPI = CurDAG->getTargetConstantPool(C, MVT::i32);
if (PICEnabled) if (PICEnabled)
Tmp = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(),CPI); Tmp = CurDAG->getTargetNode(PPC::ADDIS, MVT::i32, getGlobalBaseReg(),CPI);
else else

6
lib/Target/PowerPC/PPCISelPattern.cpp
View File

@ -866,7 +866,8 @@ unsigned ISel::SelectExpr(SDOperand N, bool Recording) {
return Result; return Result;
case ISD::ConstantPool: case ISD::ConstantPool:
Tmp1 = cast<ConstantPoolSDNode>(N)->getIndex(); Tmp1 = BB->getParent()->getConstantPool()->
getConstantPoolIndex(cast<ConstantPoolSDNode>(N)->get());
Tmp2 = MakeIntReg(); Tmp2 = MakeIntReg();
if (PICEnabled) if (PICEnabled)
BuildMI(BB, PPC::ADDIS, 2, Tmp2).addReg(getGlobalBaseReg()) BuildMI(BB, PPC::ADDIS, 2, Tmp2).addReg(getGlobalBaseReg())
@ -927,7 +928,8 @@ unsigned ISel::SelectExpr(SDOperand N, bool Recording) {
if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Address)) { if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Address)) {
Tmp1 = MakeIntReg(); Tmp1 = MakeIntReg();
int CPI = CP->getIndex(); unsigned CPI = BB->getParent()->getConstantPool()->
getConstantPoolIndex(CP->get());
if (PICEnabled) if (PICEnabled)
BuildMI(BB, PPC::ADDIS, 2, Tmp1).addReg(getGlobalBaseReg()) BuildMI(BB, PPC::ADDIS, 2, Tmp1).addReg(getGlobalBaseReg())
.addConstantPoolIndex(CPI); .addConstantPoolIndex(CPI);

13
lib/Target/X86/X86ISelPattern.cpp
View File

@ -2329,7 +2329,8 @@ unsigned ISel::SelectExpr(SDOperand N) {
addFrameReference(BuildMI(BB, X86::LEA32r, 4, Result), (int)Tmp1); addFrameReference(BuildMI(BB, X86::LEA32r, 4, Result), (int)Tmp1);
return Result; return Result;
case ISD::ConstantPool: case ISD::ConstantPool:
Tmp1 = cast<ConstantPoolSDNode>(N)->getIndex(); Tmp1 = BB->getParent()->getConstantPool()->
getConstantPoolIndex(cast<ConstantPoolSDNode>(N)->get());
addConstantPoolReference(BuildMI(BB, X86::LEA32r, 4, Result), Tmp1); addConstantPoolReference(BuildMI(BB, X86::LEA32r, 4, Result), Tmp1);
return Result; return Result;
case ISD::ConstantFP: case ISD::ConstantFP:
@ -3317,8 +3318,10 @@ unsigned ISel::SelectExpr(SDOperand N) {
} }
if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(N.getOperand(1))){ if (ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(N.getOperand(1))){
unsigned CPIdx = BB->getParent()->getConstantPool()->
getConstantPoolIndex(CP->get());
Select(N.getOperand(0)); Select(N.getOperand(0));
addConstantPoolReference(BuildMI(BB, Opc, 4, Result), CP->getIndex()); addConstantPoolReference(BuildMI(BB, Opc, 4, Result), CPIdx);
} else { } else {
X86AddressMode AM; X86AddressMode AM;
@ -3370,8 +3373,10 @@ unsigned ISel::SelectExpr(SDOperand N) {
if (Node->getValueType(0) == MVT::f64) { if (Node->getValueType(0) == MVT::f64) {
assert(cast<VTSDNode>(Node->getOperand(3))->getVT() == MVT::f32 && assert(cast<VTSDNode>(Node->getOperand(3))->getVT() == MVT::f32 &&
"Bad EXTLOAD!"); "Bad EXTLOAD!");
addConstantPoolReference(BuildMI(BB, X86::FLD32m, 4, Result), unsigned CPIdx = BB->getParent()->getConstantPool()->
CP->getIndex()); getConstantPoolIndex(cast<ConstantPoolSDNode>(N)->get());
addConstantPoolReference(BuildMI(BB, X86::FLD32m, 4, Result), CPIdx);
return Result; return Result;
} }