1263320SdimPull in r200960 from upstream llvm trunk (by Venkatraman Govindaraju): 2263320Sdim 3263320Sdim [Sparc] Use SparcMCExpr::VariantKind itself as MachineOperand's target flags. 4263320Sdim 5269012SemasteIntroduced here: http://svnweb.freebsd.org/changeset/base/262261 6263320Sdim 7263320SdimIndex: lib/Target/Sparc/SparcISelLowering.cpp 8263320Sdim=================================================================== 9263320Sdim--- lib/Target/Sparc/SparcISelLowering.cpp 10263320Sdim+++ lib/Target/Sparc/SparcISelLowering.cpp 11263320Sdim@@ -13,11 +13,11 @@ 12263320Sdim //===----------------------------------------------------------------------===// 13263320Sdim 14263320Sdim #include "SparcISelLowering.h" 15263320Sdim+#include "MCTargetDesc/SparcMCExpr.h" 16263320Sdim #include "SparcMachineFunctionInfo.h" 17263320Sdim #include "SparcRegisterInfo.h" 18263320Sdim #include "SparcTargetMachine.h" 19263320Sdim #include "SparcTargetObjectFile.h" 20263320Sdim-#include "MCTargetDesc/SparcBaseInfo.h" 21263320Sdim #include "llvm/CodeGen/CallingConvLower.h" 22263320Sdim #include "llvm/CodeGen/MachineFrameInfo.h" 23263320Sdim #include "llvm/CodeGen/MachineFunction.h" 24263320Sdim@@ -1796,7 +1796,8 @@ SDValue SparcTargetLowering::makeAddress(SDValue O 25263320Sdim // Handle PIC mode first. 26263320Sdim if (getTargetMachine().getRelocationModel() == Reloc::PIC_) { 27263320Sdim // This is the pic32 code model, the GOT is known to be smaller than 4GB. 28263320Sdim- SDValue HiLo = makeHiLoPair(Op, SPII::MO_HI, SPII::MO_LO, DAG); 29263320Sdim+ SDValue HiLo = makeHiLoPair(Op, SparcMCExpr::VK_Sparc_HI, 30263320Sdim+ SparcMCExpr::VK_Sparc_LO, DAG); 31263320Sdim SDValue GlobalBase = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, VT); 32263320Sdim SDValue AbsAddr = DAG.getNode(ISD::ADD, DL, VT, GlobalBase, HiLo); 33263320Sdim // GLOBAL_BASE_REG codegen'ed with call. Inform MFI that this 34263320Sdim@@ -1813,20 +1814,24 @@ SDValue SparcTargetLowering::makeAddress(SDValue O 35263320Sdim llvm_unreachable("Unsupported absolute code model"); 36263320Sdim case CodeModel::Small: 37263320Sdim // abs32. 38263320Sdim- return makeHiLoPair(Op, SPII::MO_HI, SPII::MO_LO, DAG); 39263320Sdim+ return makeHiLoPair(Op, SparcMCExpr::VK_Sparc_HI, 40263320Sdim+ SparcMCExpr::VK_Sparc_LO, DAG); 41263320Sdim case CodeModel::Medium: { 42263320Sdim // abs44. 43263320Sdim- SDValue H44 = makeHiLoPair(Op, SPII::MO_H44, SPII::MO_M44, DAG); 44263320Sdim+ SDValue H44 = makeHiLoPair(Op, SparcMCExpr::VK_Sparc_H44, 45263320Sdim+ SparcMCExpr::VK_Sparc_M44, DAG); 46263320Sdim H44 = DAG.getNode(ISD::SHL, DL, VT, H44, DAG.getConstant(12, MVT::i32)); 47263320Sdim- SDValue L44 = withTargetFlags(Op, SPII::MO_L44, DAG); 48263320Sdim+ SDValue L44 = withTargetFlags(Op, SparcMCExpr::VK_Sparc_L44, DAG); 49263320Sdim L44 = DAG.getNode(SPISD::Lo, DL, VT, L44); 50263320Sdim return DAG.getNode(ISD::ADD, DL, VT, H44, L44); 51263320Sdim } 52263320Sdim case CodeModel::Large: { 53263320Sdim // abs64. 54263320Sdim- SDValue Hi = makeHiLoPair(Op, SPII::MO_HH, SPII::MO_HM, DAG); 55263320Sdim+ SDValue Hi = makeHiLoPair(Op, SparcMCExpr::VK_Sparc_HH, 56263320Sdim+ SparcMCExpr::VK_Sparc_HM, DAG); 57263320Sdim Hi = DAG.getNode(ISD::SHL, DL, VT, Hi, DAG.getConstant(32, MVT::i32)); 58263320Sdim- SDValue Lo = makeHiLoPair(Op, SPII::MO_HI, SPII::MO_LO, DAG); 59263320Sdim+ SDValue Lo = makeHiLoPair(Op, SparcMCExpr::VK_Sparc_HI, 60263320Sdim+ SparcMCExpr::VK_Sparc_LO, DAG); 61263320Sdim return DAG.getNode(ISD::ADD, DL, VT, Hi, Lo); 62263320Sdim } 63263320Sdim } 64263320Sdim@@ -1858,14 +1863,18 @@ SDValue SparcTargetLowering::LowerGlobalTLSAddress 65263320Sdim TLSModel::Model model = getTargetMachine().getTLSModel(GV); 66263320Sdim 67263320Sdim if (model == TLSModel::GeneralDynamic || model == TLSModel::LocalDynamic) { 68263320Sdim- unsigned HiTF = ((model == TLSModel::GeneralDynamic)? SPII::MO_TLS_GD_HI22 69263320Sdim- : SPII::MO_TLS_LDM_HI22); 70263320Sdim- unsigned LoTF = ((model == TLSModel::GeneralDynamic)? SPII::MO_TLS_GD_LO10 71263320Sdim- : SPII::MO_TLS_LDM_LO10); 72263320Sdim- unsigned addTF = ((model == TLSModel::GeneralDynamic)? SPII::MO_TLS_GD_ADD 73263320Sdim- : SPII::MO_TLS_LDM_ADD); 74263320Sdim- unsigned callTF = ((model == TLSModel::GeneralDynamic)? SPII::MO_TLS_GD_CALL 75263320Sdim- : SPII::MO_TLS_LDM_CALL); 76263320Sdim+ unsigned HiTF = ((model == TLSModel::GeneralDynamic) 77263320Sdim+ ? SparcMCExpr::VK_Sparc_TLS_GD_HI22 78263320Sdim+ : SparcMCExpr::VK_Sparc_TLS_LDM_HI22); 79263320Sdim+ unsigned LoTF = ((model == TLSModel::GeneralDynamic) 80263320Sdim+ ? SparcMCExpr::VK_Sparc_TLS_GD_LO10 81263320Sdim+ : SparcMCExpr::VK_Sparc_TLS_LDM_LO10); 82263320Sdim+ unsigned addTF = ((model == TLSModel::GeneralDynamic) 83263320Sdim+ ? SparcMCExpr::VK_Sparc_TLS_GD_ADD 84263320Sdim+ : SparcMCExpr::VK_Sparc_TLS_LDM_ADD); 85263320Sdim+ unsigned callTF = ((model == TLSModel::GeneralDynamic) 86263320Sdim+ ? SparcMCExpr::VK_Sparc_TLS_GD_CALL 87263320Sdim+ : SparcMCExpr::VK_Sparc_TLS_LDM_CALL); 88263320Sdim 89263320Sdim SDValue HiLo = makeHiLoPair(Op, HiTF, LoTF, DAG); 90263320Sdim SDValue Base = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, PtrVT); 91263320Sdim@@ -1903,17 +1912,17 @@ SDValue SparcTargetLowering::LowerGlobalTLSAddress 92263320Sdim return Ret; 93263320Sdim 94263320Sdim SDValue Hi = DAG.getNode(SPISD::Hi, DL, PtrVT, 95263320Sdim- withTargetFlags(Op, SPII::MO_TLS_LDO_HIX22, DAG)); 96263320Sdim+ withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_HIX22, DAG)); 97263320Sdim SDValue Lo = DAG.getNode(SPISD::Lo, DL, PtrVT, 98263320Sdim- withTargetFlags(Op, SPII::MO_TLS_LDO_LOX10, DAG)); 99263320Sdim+ withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_LOX10, DAG)); 100263320Sdim HiLo = DAG.getNode(ISD::XOR, DL, PtrVT, Hi, Lo); 101263320Sdim return DAG.getNode(SPISD::TLS_ADD, DL, PtrVT, Ret, HiLo, 102263320Sdim- withTargetFlags(Op, SPII::MO_TLS_LDO_ADD, DAG)); 103263320Sdim+ withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_ADD, DAG)); 104263320Sdim } 105263320Sdim 106263320Sdim if (model == TLSModel::InitialExec) { 107263320Sdim- unsigned ldTF = ((PtrVT == MVT::i64)? SPII::MO_TLS_IE_LDX 108263320Sdim- : SPII::MO_TLS_IE_LD); 109263320Sdim+ unsigned ldTF = ((PtrVT == MVT::i64)? SparcMCExpr::VK_Sparc_TLS_IE_LDX 110263320Sdim+ : SparcMCExpr::VK_Sparc_TLS_IE_LD); 111263320Sdim 112263320Sdim SDValue Base = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, PtrVT); 113263320Sdim 114263320Sdim@@ -1923,7 +1932,8 @@ SDValue SparcTargetLowering::LowerGlobalTLSAddress 115263320Sdim MFI->setHasCalls(true); 116263320Sdim 117263320Sdim SDValue TGA = makeHiLoPair(Op, 118263320Sdim- SPII::MO_TLS_IE_HI22, SPII::MO_TLS_IE_LO10, DAG); 119263320Sdim+ SparcMCExpr::VK_Sparc_TLS_IE_HI22, 120263320Sdim+ SparcMCExpr::VK_Sparc_TLS_IE_LO10, DAG); 121263320Sdim SDValue Ptr = DAG.getNode(ISD::ADD, DL, PtrVT, Base, TGA); 122263320Sdim SDValue Offset = DAG.getNode(SPISD::TLS_LD, 123263320Sdim DL, PtrVT, Ptr, 124263320Sdim@@ -1930,14 +1940,15 @@ SDValue SparcTargetLowering::LowerGlobalTLSAddress 125263320Sdim withTargetFlags(Op, ldTF, DAG)); 126263320Sdim return DAG.getNode(SPISD::TLS_ADD, DL, PtrVT, 127263320Sdim DAG.getRegister(SP::G7, PtrVT), Offset, 128263320Sdim- withTargetFlags(Op, SPII::MO_TLS_IE_ADD, DAG)); 129263320Sdim+ withTargetFlags(Op, 130263320Sdim+ SparcMCExpr::VK_Sparc_TLS_IE_ADD, DAG)); 131263320Sdim } 132263320Sdim 133263320Sdim assert(model == TLSModel::LocalExec); 134263320Sdim SDValue Hi = DAG.getNode(SPISD::Hi, DL, PtrVT, 135263320Sdim- withTargetFlags(Op, SPII::MO_TLS_LE_HIX22, DAG)); 136263320Sdim+ withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LE_HIX22, DAG)); 137263320Sdim SDValue Lo = DAG.getNode(SPISD::Lo, DL, PtrVT, 138263320Sdim- withTargetFlags(Op, SPII::MO_TLS_LE_LOX10, DAG)); 139263320Sdim+ withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LE_LOX10, DAG)); 140263320Sdim SDValue Offset = DAG.getNode(ISD::XOR, DL, PtrVT, Hi, Lo); 141263320Sdim 142263320Sdim return DAG.getNode(ISD::ADD, DL, PtrVT, 143263320SdimIndex: lib/Target/Sparc/SparcCodeEmitter.cpp 144263320Sdim=================================================================== 145263320Sdim--- lib/Target/Sparc/SparcCodeEmitter.cpp 146263320Sdim+++ lib/Target/Sparc/SparcCodeEmitter.cpp 147263320Sdim@@ -14,7 +14,7 @@ 148263320Sdim 149263320Sdim #define DEBUG_TYPE "jit" 150263320Sdim #include "Sparc.h" 151263320Sdim-#include "MCTargetDesc/SparcBaseInfo.h" 152263320Sdim+#include "MCTargetDesc/SparcMCExpr.h" 153263320Sdim #include "SparcRelocations.h" 154263320Sdim #include "SparcTargetMachine.h" 155263320Sdim #include "llvm/ADT/Statistic.h" 156263320Sdim@@ -204,14 +204,14 @@ unsigned SparcCodeEmitter::getRelocation(const Mac 157263320Sdim unsigned TF = MO.getTargetFlags(); 158263320Sdim switch (TF) { 159263320Sdim default: 160263320Sdim- case SPII::MO_NO_FLAG: break; 161263320Sdim- case SPII::MO_LO: return SP::reloc_sparc_lo; 162263320Sdim- case SPII::MO_HI: return SP::reloc_sparc_hi; 163263320Sdim- case SPII::MO_H44: return SP::reloc_sparc_h44; 164263320Sdim- case SPII::MO_M44: return SP::reloc_sparc_m44; 165263320Sdim- case SPII::MO_L44: return SP::reloc_sparc_l44; 166263320Sdim- case SPII::MO_HH: return SP::reloc_sparc_hh; 167263320Sdim- case SPII::MO_HM: return SP::reloc_sparc_hm; 168263320Sdim+ case SparcMCExpr::VK_Sparc_None: break; 169263320Sdim+ case SparcMCExpr::VK_Sparc_LO: return SP::reloc_sparc_lo; 170263320Sdim+ case SparcMCExpr::VK_Sparc_HI: return SP::reloc_sparc_hi; 171263320Sdim+ case SparcMCExpr::VK_Sparc_H44: return SP::reloc_sparc_h44; 172263320Sdim+ case SparcMCExpr::VK_Sparc_M44: return SP::reloc_sparc_m44; 173263320Sdim+ case SparcMCExpr::VK_Sparc_L44: return SP::reloc_sparc_l44; 174263320Sdim+ case SparcMCExpr::VK_Sparc_HH: return SP::reloc_sparc_hh; 175263320Sdim+ case SparcMCExpr::VK_Sparc_HM: return SP::reloc_sparc_hm; 176263320Sdim } 177263320Sdim 178263320Sdim unsigned Opc = MI.getOpcode(); 179263320SdimIndex: lib/Target/Sparc/SparcMCInstLower.cpp 180263320Sdim=================================================================== 181263320Sdim--- lib/Target/Sparc/SparcMCInstLower.cpp 182263320Sdim+++ lib/Target/Sparc/SparcMCInstLower.cpp 183263320Sdim@@ -13,7 +13,6 @@ 184263320Sdim //===----------------------------------------------------------------------===// 185263320Sdim 186263320Sdim #include "Sparc.h" 187263320Sdim-#include "MCTargetDesc/SparcBaseInfo.h" 188263320Sdim #include "MCTargetDesc/SparcMCExpr.h" 189263320Sdim #include "llvm/CodeGen/AsmPrinter.h" 190263320Sdim #include "llvm/CodeGen/MachineFunction.h" 191263320Sdim@@ -33,41 +32,10 @@ static MCOperand LowerSymbolOperand(const MachineI 192263320Sdim const MachineOperand &MO, 193263320Sdim AsmPrinter &AP) { 194263320Sdim 195263320Sdim- SparcMCExpr::VariantKind Kind; 196263320Sdim+ SparcMCExpr::VariantKind Kind = 197263320Sdim+ (SparcMCExpr::VariantKind)MO.getTargetFlags(); 198263320Sdim const MCSymbol *Symbol = 0; 199263320Sdim 200263320Sdim- unsigned TF = MO.getTargetFlags(); 201263320Sdim- 202263320Sdim- switch(TF) { 203263320Sdim- default: llvm_unreachable("Unknown target flags on operand"); 204263320Sdim- case SPII::MO_NO_FLAG: Kind = SparcMCExpr::VK_Sparc_None; break; 205263320Sdim- case SPII::MO_LO: Kind = SparcMCExpr::VK_Sparc_LO; break; 206263320Sdim- case SPII::MO_HI: Kind = SparcMCExpr::VK_Sparc_HI; break; 207263320Sdim- case SPII::MO_H44: Kind = SparcMCExpr::VK_Sparc_H44; break; 208263320Sdim- case SPII::MO_M44: Kind = SparcMCExpr::VK_Sparc_M44; break; 209263320Sdim- case SPII::MO_L44: Kind = SparcMCExpr::VK_Sparc_L44; break; 210263320Sdim- case SPII::MO_HH: Kind = SparcMCExpr::VK_Sparc_HH; break; 211263320Sdim- case SPII::MO_HM: Kind = SparcMCExpr::VK_Sparc_HM; break; 212263320Sdim- case SPII::MO_TLS_GD_HI22: Kind = SparcMCExpr::VK_Sparc_TLS_GD_HI22; break; 213263320Sdim- case SPII::MO_TLS_GD_LO10: Kind = SparcMCExpr::VK_Sparc_TLS_GD_LO10; break; 214263320Sdim- case SPII::MO_TLS_GD_ADD: Kind = SparcMCExpr::VK_Sparc_TLS_GD_ADD; break; 215263320Sdim- case SPII::MO_TLS_GD_CALL: Kind = SparcMCExpr::VK_Sparc_TLS_GD_CALL; break; 216263320Sdim- case SPII::MO_TLS_LDM_HI22: Kind = SparcMCExpr::VK_Sparc_TLS_LDM_HI22; break; 217263320Sdim- case SPII::MO_TLS_LDM_LO10: Kind = SparcMCExpr::VK_Sparc_TLS_LDM_LO10; break; 218263320Sdim- case SPII::MO_TLS_LDM_ADD: Kind = SparcMCExpr::VK_Sparc_TLS_LDM_ADD; break; 219263320Sdim- case SPII::MO_TLS_LDM_CALL: Kind = SparcMCExpr::VK_Sparc_TLS_LDM_CALL; break; 220263320Sdim- case SPII::MO_TLS_LDO_HIX22:Kind = SparcMCExpr::VK_Sparc_TLS_LDO_HIX22; break; 221263320Sdim- case SPII::MO_TLS_LDO_LOX10:Kind = SparcMCExpr::VK_Sparc_TLS_LDO_LOX10; break; 222263320Sdim- case SPII::MO_TLS_LDO_ADD: Kind = SparcMCExpr::VK_Sparc_TLS_LDO_ADD; break; 223263320Sdim- case SPII::MO_TLS_IE_HI22: Kind = SparcMCExpr::VK_Sparc_TLS_IE_HI22; break; 224263320Sdim- case SPII::MO_TLS_IE_LO10: Kind = SparcMCExpr::VK_Sparc_TLS_IE_LO10; break; 225263320Sdim- case SPII::MO_TLS_IE_LD: Kind = SparcMCExpr::VK_Sparc_TLS_IE_LD; break; 226263320Sdim- case SPII::MO_TLS_IE_LDX: Kind = SparcMCExpr::VK_Sparc_TLS_IE_LDX; break; 227263320Sdim- case SPII::MO_TLS_IE_ADD: Kind = SparcMCExpr::VK_Sparc_TLS_IE_ADD; break; 228263320Sdim- case SPII::MO_TLS_LE_HIX22: Kind = SparcMCExpr::VK_Sparc_TLS_LE_HIX22; break; 229263320Sdim- case SPII::MO_TLS_LE_LOX10: Kind = SparcMCExpr::VK_Sparc_TLS_LE_LOX10; break; 230263320Sdim- } 231263320Sdim- 232263320Sdim switch(MO.getType()) { 233263320Sdim default: llvm_unreachable("Unknown type in LowerSymbolOperand"); 234263320Sdim case MachineOperand::MO_MachineBasicBlock: 235263320SdimIndex: lib/Target/Sparc/SparcAsmPrinter.cpp 236263320Sdim=================================================================== 237263320Sdim--- lib/Target/Sparc/SparcAsmPrinter.cpp 238263320Sdim+++ lib/Target/Sparc/SparcAsmPrinter.cpp 239263320Sdim@@ -18,7 +18,6 @@ 240263320Sdim #include "SparcTargetMachine.h" 241263320Sdim #include "SparcTargetStreamer.h" 242263320Sdim #include "InstPrinter/SparcInstPrinter.h" 243263320Sdim-#include "MCTargetDesc/SparcBaseInfo.h" 244263320Sdim #include "MCTargetDesc/SparcMCExpr.h" 245263320Sdim #include "llvm/ADT/SmallString.h" 246263320Sdim #include "llvm/CodeGen/AsmPrinter.h" 247263320Sdim@@ -287,83 +286,60 @@ void SparcAsmPrinter::EmitFunctionBodyStart() { 248263320Sdim void SparcAsmPrinter::printOperand(const MachineInstr *MI, int opNum, 249263320Sdim raw_ostream &O) { 250263320Sdim const MachineOperand &MO = MI->getOperand (opNum); 251263320Sdim- unsigned TF = MO.getTargetFlags(); 252263320Sdim+ SparcMCExpr::VariantKind TF = (SparcMCExpr::VariantKind) MO.getTargetFlags(); 253263320Sdim+ 254263320Sdim #ifndef NDEBUG 255263320Sdim // Verify the target flags. 256263320Sdim if (MO.isGlobal() || MO.isSymbol() || MO.isCPI()) { 257263320Sdim if (MI->getOpcode() == SP::CALL) 258263320Sdim- assert(TF == SPII::MO_NO_FLAG && 259263320Sdim+ assert(TF == SparcMCExpr::VK_Sparc_None && 260263320Sdim "Cannot handle target flags on call address"); 261263320Sdim else if (MI->getOpcode() == SP::SETHIi || MI->getOpcode() == SP::SETHIXi) 262263320Sdim- assert((TF == SPII::MO_HI || TF == SPII::MO_H44 || TF == SPII::MO_HH 263263320Sdim- || TF == SPII::MO_TLS_GD_HI22 264263320Sdim- || TF == SPII::MO_TLS_LDM_HI22 265263320Sdim- || TF == SPII::MO_TLS_LDO_HIX22 266263320Sdim- || TF == SPII::MO_TLS_IE_HI22 267263320Sdim- || TF == SPII::MO_TLS_LE_HIX22) && 268263320Sdim+ assert((TF == SparcMCExpr::VK_Sparc_HI 269263320Sdim+ || TF == SparcMCExpr::VK_Sparc_H44 270263320Sdim+ || TF == SparcMCExpr::VK_Sparc_HH 271263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_GD_HI22 272263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_LDM_HI22 273263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_LDO_HIX22 274263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_IE_HI22 275263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_LE_HIX22) && 276263320Sdim "Invalid target flags for address operand on sethi"); 277263320Sdim else if (MI->getOpcode() == SP::TLS_CALL) 278263320Sdim- assert((TF == SPII::MO_NO_FLAG 279263320Sdim- || TF == SPII::MO_TLS_GD_CALL 280263320Sdim- || TF == SPII::MO_TLS_LDM_CALL) && 281263320Sdim+ assert((TF == SparcMCExpr::VK_Sparc_None 282263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_GD_CALL 283263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_LDM_CALL) && 284263320Sdim "Cannot handle target flags on tls call address"); 285263320Sdim else if (MI->getOpcode() == SP::TLS_ADDrr) 286263320Sdim- assert((TF == SPII::MO_TLS_GD_ADD || TF == SPII::MO_TLS_LDM_ADD 287263320Sdim- || TF == SPII::MO_TLS_LDO_ADD || TF == SPII::MO_TLS_IE_ADD) && 288263320Sdim+ assert((TF == SparcMCExpr::VK_Sparc_TLS_GD_ADD 289263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_LDM_ADD 290263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_LDO_ADD 291263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_IE_ADD) && 292263320Sdim "Cannot handle target flags on add for TLS"); 293263320Sdim else if (MI->getOpcode() == SP::TLS_LDrr) 294263320Sdim- assert(TF == SPII::MO_TLS_IE_LD && 295263320Sdim+ assert(TF == SparcMCExpr::VK_Sparc_TLS_IE_LD && 296263320Sdim "Cannot handle target flags on ld for TLS"); 297263320Sdim else if (MI->getOpcode() == SP::TLS_LDXrr) 298263320Sdim- assert(TF == SPII::MO_TLS_IE_LDX && 299263320Sdim+ assert(TF == SparcMCExpr::VK_Sparc_TLS_IE_LDX && 300263320Sdim "Cannot handle target flags on ldx for TLS"); 301263320Sdim else if (MI->getOpcode() == SP::XORri || MI->getOpcode() == SP::XORXri) 302263320Sdim- assert((TF == SPII::MO_TLS_LDO_LOX10 || TF == SPII::MO_TLS_LE_LOX10) && 303263320Sdim+ assert((TF == SparcMCExpr::VK_Sparc_TLS_LDO_LOX10 304263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_LE_LOX10) && 305263320Sdim "Cannot handle target flags on xor for TLS"); 306263320Sdim else 307263320Sdim- assert((TF == SPII::MO_LO || TF == SPII::MO_M44 || TF == SPII::MO_L44 308263320Sdim- || TF == SPII::MO_HM 309263320Sdim- || TF == SPII::MO_TLS_GD_LO10 310263320Sdim- || TF == SPII::MO_TLS_LDM_LO10 311263320Sdim- || TF == SPII::MO_TLS_IE_LO10 ) && 312263320Sdim+ assert((TF == SparcMCExpr::VK_Sparc_LO 313263320Sdim+ || TF == SparcMCExpr::VK_Sparc_M44 314263320Sdim+ || TF == SparcMCExpr::VK_Sparc_L44 315263320Sdim+ || TF == SparcMCExpr::VK_Sparc_HM 316263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_GD_LO10 317263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_LDM_LO10 318263320Sdim+ || TF == SparcMCExpr::VK_Sparc_TLS_IE_LO10 ) && 319263320Sdim "Invalid target flags for small address operand"); 320263320Sdim } 321263320Sdim #endif 322263320Sdim 323263320Sdim- bool CloseParen = true; 324263320Sdim- switch (TF) { 325263320Sdim- default: 326263320Sdim- llvm_unreachable("Unknown target flags on operand"); 327263320Sdim- case SPII::MO_NO_FLAG: 328263320Sdim- CloseParen = false; 329263320Sdim- break; 330263320Sdim- case SPII::MO_LO: O << "%lo("; break; 331263320Sdim- case SPII::MO_HI: O << "%hi("; break; 332263320Sdim- case SPII::MO_H44: O << "%h44("; break; 333263320Sdim- case SPII::MO_M44: O << "%m44("; break; 334263320Sdim- case SPII::MO_L44: O << "%l44("; break; 335263320Sdim- case SPII::MO_HH: O << "%hh("; break; 336263320Sdim- case SPII::MO_HM: O << "%hm("; break; 337263320Sdim- case SPII::MO_TLS_GD_HI22: O << "%tgd_hi22("; break; 338263320Sdim- case SPII::MO_TLS_GD_LO10: O << "%tgd_lo10("; break; 339263320Sdim- case SPII::MO_TLS_GD_ADD: O << "%tgd_add("; break; 340263320Sdim- case SPII::MO_TLS_GD_CALL: O << "%tgd_call("; break; 341263320Sdim- case SPII::MO_TLS_LDM_HI22: O << "%tldm_hi22("; break; 342263320Sdim- case SPII::MO_TLS_LDM_LO10: O << "%tldm_lo10("; break; 343263320Sdim- case SPII::MO_TLS_LDM_ADD: O << "%tldm_add("; break; 344263320Sdim- case SPII::MO_TLS_LDM_CALL: O << "%tldm_call("; break; 345263320Sdim- case SPII::MO_TLS_LDO_HIX22: O << "%tldo_hix22("; break; 346263320Sdim- case SPII::MO_TLS_LDO_LOX10: O << "%tldo_lox10("; break; 347263320Sdim- case SPII::MO_TLS_LDO_ADD: O << "%tldo_add("; break; 348263320Sdim- case SPII::MO_TLS_IE_HI22: O << "%tie_hi22("; break; 349263320Sdim- case SPII::MO_TLS_IE_LO10: O << "%tie_lo10("; break; 350263320Sdim- case SPII::MO_TLS_IE_LD: O << "%tie_ld("; break; 351263320Sdim- case SPII::MO_TLS_IE_LDX: O << "%tie_ldx("; break; 352263320Sdim- case SPII::MO_TLS_IE_ADD: O << "%tie_add("; break; 353263320Sdim- case SPII::MO_TLS_LE_HIX22: O << "%tle_hix22("; break; 354263320Sdim- case SPII::MO_TLS_LE_LOX10: O << "%tle_lox10("; break; 355263320Sdim- } 356263320Sdim 357263320Sdim+ bool CloseParen = SparcMCExpr::printVariantKind(O, TF); 358263320Sdim+ 359263320Sdim switch (MO.getType()) { 360263320Sdim case MachineOperand::MO_Register: 361263320Sdim O << "%" << StringRef(getRegisterName(MO.getReg())).lower(); 362263320SdimIndex: lib/Target/Sparc/InstPrinter/SparcInstPrinter.cpp 363263320Sdim=================================================================== 364263320Sdim--- lib/Target/Sparc/InstPrinter/SparcInstPrinter.cpp 365263320Sdim+++ lib/Target/Sparc/InstPrinter/SparcInstPrinter.cpp 366263320Sdim@@ -15,7 +15,6 @@ 367263320Sdim #include "SparcInstPrinter.h" 368263320Sdim 369263320Sdim #include "Sparc.h" 370263320Sdim-#include "MCTargetDesc/SparcBaseInfo.h" 371263320Sdim #include "llvm/MC/MCExpr.h" 372263320Sdim #include "llvm/MC/MCInst.h" 373263320Sdim #include "llvm/MC/MCSymbol.h" 374263320SdimIndex: lib/Target/Sparc/MCTargetDesc/SparcBaseInfo.h 375263320Sdim=================================================================== 376263320Sdim--- lib/Target/Sparc/MCTargetDesc/SparcBaseInfo.h 377263320Sdim+++ lib/Target/Sparc/MCTargetDesc/SparcBaseInfo.h 378263320Sdim@@ -1,82 +0,0 @@ 379263320Sdim-//===-- SparcBaseInfo.h - Top level definitions for Sparc ---- --*- C++ -*-===// 380263320Sdim-// 381263320Sdim-// The LLVM Compiler Infrastructure 382263320Sdim-// 383263320Sdim-// This file is distributed under the University of Illinois Open Source 384263320Sdim-// License. See LICENSE.TXT for details. 385263320Sdim-// 386263320Sdim-//===----------------------------------------------------------------------===// 387263320Sdim-// 388263320Sdim-// This file contains small standalone helper functions and enum definitions 389263320Sdim-// for the Sparc target useful for the compiler back-end and the MC libraries. 390263320Sdim-// As such, it deliberately does not include references to LLVM core code gen 391263320Sdim-// types, passes, etc.. 392263320Sdim-// 393263320Sdim-//===----------------------------------------------------------------------===// 394263320Sdim- 395263320Sdim-#ifndef SPARCBASEINFO_H 396263320Sdim-#define SPARCBASEINFO_H 397263320Sdim- 398263320Sdim-namespace llvm { 399263320Sdim- 400263320Sdim-/// SPII - This namespace holds target specific flags for instruction info. 401263320Sdim-namespace SPII { 402263320Sdim- 403263320Sdim-/// Target Operand Flags. Sparc specific TargetFlags for MachineOperands and 404263320Sdim-/// SDNodes. 405263320Sdim-enum TOF { 406263320Sdim- MO_NO_FLAG, 407263320Sdim- 408263320Sdim- // Extract the low 10 bits of an address. 409263320Sdim- // Assembler: %lo(addr) 410263320Sdim- MO_LO, 411263320Sdim- 412263320Sdim- // Extract bits 31-10 of an address. Only for sethi. 413263320Sdim- // Assembler: %hi(addr) or %lm(addr) 414263320Sdim- MO_HI, 415263320Sdim- 416263320Sdim- // Extract bits 43-22 of an adress. Only for sethi. 417263320Sdim- // Assembler: %h44(addr) 418263320Sdim- MO_H44, 419263320Sdim- 420263320Sdim- // Extract bits 21-12 of an address. 421263320Sdim- // Assembler: %m44(addr) 422263320Sdim- MO_M44, 423263320Sdim- 424263320Sdim- // Extract bits 11-0 of an address. 425263320Sdim- // Assembler: %l44(addr) 426263320Sdim- MO_L44, 427263320Sdim- 428263320Sdim- // Extract bits 63-42 of an address. Only for sethi. 429263320Sdim- // Assembler: %hh(addr) 430263320Sdim- MO_HH, 431263320Sdim- 432263320Sdim- // Extract bits 41-32 of an address. 433263320Sdim- // Assembler: %hm(addr) 434263320Sdim- MO_HM, 435263320Sdim- 436263320Sdim- // TargetFlags for Thread Local Storage. 437263320Sdim- MO_TLS_GD_HI22, 438263320Sdim- MO_TLS_GD_LO10, 439263320Sdim- MO_TLS_GD_ADD, 440263320Sdim- MO_TLS_GD_CALL, 441263320Sdim- MO_TLS_LDM_HI22, 442263320Sdim- MO_TLS_LDM_LO10, 443263320Sdim- MO_TLS_LDM_ADD, 444263320Sdim- MO_TLS_LDM_CALL, 445263320Sdim- MO_TLS_LDO_HIX22, 446263320Sdim- MO_TLS_LDO_LOX10, 447263320Sdim- MO_TLS_LDO_ADD, 448263320Sdim- MO_TLS_IE_HI22, 449263320Sdim- MO_TLS_IE_LO10, 450263320Sdim- MO_TLS_IE_LD, 451263320Sdim- MO_TLS_IE_LDX, 452263320Sdim- MO_TLS_IE_ADD, 453263320Sdim- MO_TLS_LE_HIX22, 454263320Sdim- MO_TLS_LE_LOX10 455263320Sdim-}; 456263320Sdim- 457263320Sdim-} // end namespace SPII 458263320Sdim-} // end namespace llvm 459263320Sdim- 460263320Sdim-#endif 461263320SdimIndex: lib/Target/Sparc/MCTargetDesc/SparcMCExpr.cpp 462263320Sdim=================================================================== 463263320Sdim--- lib/Target/Sparc/MCTargetDesc/SparcMCExpr.cpp 464263320Sdim+++ lib/Target/Sparc/MCTargetDesc/SparcMCExpr.cpp 465263320Sdim@@ -29,8 +29,21 @@ SparcMCExpr::Create(VariantKind Kind, const MCExpr 466263320Sdim } 467263320Sdim 468263320Sdim 469263320Sdim+ 470263320Sdim void SparcMCExpr::PrintImpl(raw_ostream &OS) const 471263320Sdim { 472263320Sdim+ 473263320Sdim+ bool closeParen = printVariantKind(OS, Kind); 474263320Sdim+ 475263320Sdim+ const MCExpr *Expr = getSubExpr(); 476263320Sdim+ Expr->print(OS); 477263320Sdim+ 478263320Sdim+ if (closeParen) 479263320Sdim+ OS << ')'; 480263320Sdim+} 481263320Sdim+ 482263320Sdim+bool SparcMCExpr::printVariantKind(raw_ostream &OS, VariantKind Kind) 483263320Sdim+{ 484263320Sdim bool closeParen = true; 485263320Sdim switch (Kind) { 486263320Sdim case VK_Sparc_None: closeParen = false; break; 487263320Sdim@@ -61,11 +74,7 @@ void SparcMCExpr::PrintImpl(raw_ostream &OS) const 488263320Sdim case VK_Sparc_TLS_LE_HIX22: OS << "%tle_hix22("; break; 489263320Sdim case VK_Sparc_TLS_LE_LOX10: OS << "%tle_lox10("; break; 490263320Sdim } 491263320Sdim- 492263320Sdim- const MCExpr *Expr = getSubExpr(); 493263320Sdim- Expr->print(OS); 494263320Sdim- if (closeParen) 495263320Sdim- OS << ')'; 496263320Sdim+ return closeParen; 497263320Sdim } 498263320Sdim 499263320Sdim SparcMCExpr::VariantKind SparcMCExpr::parseVariantKind(StringRef name) 500263320SdimIndex: lib/Target/Sparc/MCTargetDesc/SparcMCExpr.h 501263320Sdim=================================================================== 502263320Sdim--- lib/Target/Sparc/MCTargetDesc/SparcMCExpr.h 503263320Sdim+++ lib/Target/Sparc/MCTargetDesc/SparcMCExpr.h 504263320Sdim@@ -93,7 +93,7 @@ class SparcMCExpr : public MCTargetExpr { 505263320Sdim static bool classof(const SparcMCExpr *) { return true; } 506263320Sdim 507263320Sdim static VariantKind parseVariantKind(StringRef name); 508263320Sdim- 509263320Sdim+ static bool printVariantKind(raw_ostream &OS, VariantKind Kind); 510263320Sdim }; 511263320Sdim 512263320Sdim } // end namespace llvm. 513