fix some assumptions that pointers can only be 32-bits. With this, we can

now compile:

static unsigned long X;
void test1() {
  X = 0;
}

into:

_test1:
        lis r2, ha16(_X)
        li r3, 0
        stw r3, lo16(_X)(r2)
        blr

Totally amazing :)


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@28839 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 35 insertions, 32 deletions

diff --git a/lib/Target/PowerPC/PPCISelLowering.cpp b/lib/Target/PowerPC/PPCISelLowering.cpp
index ff42fa0212..2022c68662 100644
--- a/lib/Target/PowerPC/PPCISelLowering.cpp
+++ b/lib/Target/PowerPC/PPCISelLowering.cpp
@@ -128,7 +128,10 @@ PPCTargetLowering::PPCTargetLowering(TargetMachine &TM)
   setOperationAction(ISD::GlobalAddress, MVT::i32, Custom);
   setOperationAction(ISD::ConstantPool,  MVT::i32, Custom);
   setOperationAction(ISD::JumpTable,     MVT::i32, Custom);
-
+  setOperationAction(ISD::GlobalAddress, MVT::i64, Custom);
+  setOperationAction(ISD::ConstantPool,  MVT::i64, Custom);
+  setOperationAction(ISD::JumpTable,     MVT::i64, Custom);
+  
   // RET must be custom lowered, to meet ABI requirements
   setOperationAction(ISD::RET               , MVT::Other, Custom);
   
@@ -583,94 +586,94 @@ SDOperand PPC::get_VSPLTI_elt(SDNode *N, unsigned ByteSize, SelectionDAG &DAG) {
 //===----------------------------------------------------------------------===//
 
 static SDOperand LowerConstantPool(SDOperand Op, SelectionDAG &DAG) {
+  MVT::ValueType PtrVT = Op.getValueType();
   ConstantPoolSDNode *CP = cast<ConstantPoolSDNode>(Op);
   Constant *C = CP->get();
-  SDOperand CPI = DAG.getTargetConstantPool(C, MVT::i32, CP->getAlignment());
-  SDOperand Zero = DAG.getConstant(0, MVT::i32);
+  SDOperand CPI = DAG.getTargetConstantPool(C, PtrVT, CP->getAlignment());
+  SDOperand Zero = DAG.getConstant(0, PtrVT);
 
   const TargetMachine &TM = DAG.getTarget();
   
+  SDOperand Hi = DAG.getNode(PPCISD::Hi, PtrVT, CPI, Zero);
+  SDOperand Lo = DAG.getNode(PPCISD::Lo, PtrVT, CPI, Zero);
+
   // If this is a non-darwin platform, we don't support non-static relo models
   // yet.
   if (TM.getRelocationModel() == Reloc::Static ||
       !TM.getSubtarget<PPCSubtarget>().isDarwin()) {
     // Generate non-pic code that has direct accesses to the constant pool.
     // The address of the global is just (hi(&g)+lo(&g)).
-    SDOperand Hi = DAG.getNode(PPCISD::Hi, MVT::i32, CPI, Zero);
-    SDOperand Lo = DAG.getNode(PPCISD::Lo, MVT::i32, CPI, Zero);
-    return DAG.getNode(ISD::ADD, MVT::i32, Hi, Lo);
+    return DAG.getNode(ISD::ADD, PtrVT, Hi, Lo);
   }
   
-  SDOperand Hi = DAG.getNode(PPCISD::Hi, MVT::i32, CPI, Zero);
   if (TM.getRelocationModel() == Reloc::PIC) {
     // With PIC, the first instruction is actually "GR+hi(&G)".
-    Hi = DAG.getNode(ISD::ADD, MVT::i32,
-                     DAG.getNode(PPCISD::GlobalBaseReg, MVT::i32), Hi);
+    Hi = DAG.getNode(ISD::ADD, PtrVT,
+                     DAG.getNode(PPCISD::GlobalBaseReg, PtrVT), Hi);
   }
   
-  SDOperand Lo = DAG.getNode(PPCISD::Lo, MVT::i32, CPI, Zero);
-  Lo = DAG.getNode(ISD::ADD, MVT::i32, Hi, Lo);
+  Lo = DAG.getNode(ISD::ADD, PtrVT, Hi, Lo);
   return Lo;
 }
 
 static SDOperand LowerJumpTable(SDOperand Op, SelectionDAG &DAG) {
+  MVT::ValueType PtrVT = Op.getValueType();
   JumpTableSDNode *JT = cast<JumpTableSDNode>(Op);
-  SDOperand JTI = DAG.getTargetJumpTable(JT->getIndex(), MVT::i32);
-  SDOperand Zero = DAG.getConstant(0, MVT::i32);
+  SDOperand JTI = DAG.getTargetJumpTable(JT->getIndex(), PtrVT);
+  SDOperand Zero = DAG.getConstant(0, PtrVT);
   
   const TargetMachine &TM = DAG.getTarget();
-  
+
+  SDOperand Hi = DAG.getNode(PPCISD::Hi, PtrVT, JTI, Zero);
+  SDOperand Lo = DAG.getNode(PPCISD::Lo, PtrVT, JTI, Zero);
+
   // If this is a non-darwin platform, we don't support non-static relo models
   // yet.
   if (TM.getRelocationModel() == Reloc::Static ||
       !TM.getSubtarget<PPCSubtarget>().isDarwin()) {
     // Generate non-pic code that has direct accesses to the constant pool.
     // The address of the global is just (hi(&g)+lo(&g)).
-    SDOperand Hi = DAG.getNode(PPCISD::Hi, MVT::i32, JTI, Zero);
-    SDOperand Lo = DAG.getNode(PPCISD::Lo, MVT::i32, JTI, Zero);
-    return DAG.getNode(ISD::ADD, MVT::i32, Hi, Lo);
+    return DAG.getNode(ISD::ADD, PtrVT, Hi, Lo);
   }
   
-  SDOperand Hi = DAG.getNode(PPCISD::Hi, MVT::i32, JTI, Zero);
   if (TM.getRelocationModel() == Reloc::PIC) {
     // With PIC, the first instruction is actually "GR+hi(&G)".
-    Hi = DAG.getNode(ISD::ADD, MVT::i32,
+    Hi = DAG.getNode(ISD::ADD, PtrVT,
                      DAG.getNode(PPCISD::GlobalBaseReg, MVT::i32), Hi);
   }
   
-  SDOperand Lo = DAG.getNode(PPCISD::Lo, MVT::i32, JTI, Zero);
-  Lo = DAG.getNode(ISD::ADD, MVT::i32, Hi, Lo);
+  Lo = DAG.getNode(ISD::ADD, PtrVT, Hi, Lo);
   return Lo;
 }
 
 static SDOperand LowerGlobalAddress(SDOperand Op, SelectionDAG &DAG) {
+  MVT::ValueType PtrVT = Op.getValueType();
   GlobalAddressSDNode *GSDN = cast<GlobalAddressSDNode>(Op);
   GlobalValue *GV = GSDN->getGlobal();
-  SDOperand GA = DAG.getTargetGlobalAddress(GV, MVT::i32, GSDN->getOffset());
-  SDOperand Zero = DAG.getConstant(0, MVT::i32);
+  SDOperand GA = DAG.getTargetGlobalAddress(GV, PtrVT, GSDN->getOffset());
+  SDOperand Zero = DAG.getConstant(0, PtrVT);
   
   const TargetMachine &TM = DAG.getTarget();
 
+  SDOperand Hi = DAG.getNode(PPCISD::Hi, PtrVT, GA, Zero);
+  SDOperand Lo = DAG.getNode(PPCISD::Lo, PtrVT, GA, Zero);
+
   // If this is a non-darwin platform, we don't support non-static relo models
   // yet.
   if (TM.getRelocationModel() == Reloc::Static ||
       !TM.getSubtarget<PPCSubtarget>().isDarwin()) {
     // Generate non-pic code that has direct accesses to globals.
     // The address of the global is just (hi(&g)+lo(&g)).
-    SDOperand Hi = DAG.getNode(PPCISD::Hi, MVT::i32, GA, Zero);
-    SDOperand Lo = DAG.getNode(PPCISD::Lo, MVT::i32, GA, Zero);
-    return DAG.getNode(ISD::ADD, MVT::i32, Hi, Lo);
+    return DAG.getNode(ISD::ADD, PtrVT, Hi, Lo);
   }
   
-  SDOperand Hi = DAG.getNode(PPCISD::Hi, MVT::i32, GA, Zero);
   if (TM.getRelocationModel() == Reloc::PIC) {
     // With PIC, the first instruction is actually "GR+hi(&G)".
-    Hi = DAG.getNode(ISD::ADD, MVT::i32,
-                     DAG.getNode(PPCISD::GlobalBaseReg, MVT::i32), Hi);
+    Hi = DAG.getNode(ISD::ADD, PtrVT,
+                     DAG.getNode(PPCISD::GlobalBaseReg, PtrVT), Hi);
   }
   
-  SDOperand Lo = DAG.getNode(PPCISD::Lo, MVT::i32, GA, Zero);
-  Lo = DAG.getNode(ISD::ADD, MVT::i32, Hi, Lo);
+  Lo = DAG.getNode(ISD::ADD, PtrVT, Hi, Lo);
   
   if (!GV->hasWeakLinkage() && !GV->hasLinkOnceLinkage() &&
       (!GV->isExternal() || GV->hasNotBeenReadFromBytecode()))
@@ -678,7 +681,7 @@ static SDOperand LowerGlobalAddress(SDOperand Op, SelectionDAG &DAG) {
   
   // If the global is weak or external, we have to go through the lazy
   // resolution stub.
-  return DAG.getLoad(MVT::i32, DAG.getEntryNode(), Lo, DAG.getSrcValue(0));
+  return DAG.getLoad(PtrVT, DAG.getEntryNode(), Lo, DAG.getSrcValue(0));
 }
 
 static SDOperand LowerSETCC(SDOperand Op, SelectionDAG &DAG) {