1Pull in r200960 from upstream llvm trunk (by Venkatraman Govindaraju): 2 3 [Sparc] Use SparcMCExpr::VariantKind itself as MachineOperand's target flags. 4 5Introduced here: http://svnweb.freebsd.org/changeset/base/262261 6 7Index: lib/Target/Sparc/SparcISelLowering.cpp 8=================================================================== 9--- lib/Target/Sparc/SparcISelLowering.cpp 10+++ lib/Target/Sparc/SparcISelLowering.cpp 11@@ -13,11 +13,11 @@ 12 //===----------------------------------------------------------------------===// 13 14 #include "SparcISelLowering.h" 15+#include "MCTargetDesc/SparcMCExpr.h" 16 #include "SparcMachineFunctionInfo.h" 17 #include "SparcRegisterInfo.h" 18 #include "SparcTargetMachine.h" 19 #include "SparcTargetObjectFile.h" 20-#include "MCTargetDesc/SparcBaseInfo.h" 21 #include "llvm/CodeGen/CallingConvLower.h" 22 #include "llvm/CodeGen/MachineFrameInfo.h" 23 #include "llvm/CodeGen/MachineFunction.h" 24@@ -1796,7 +1796,8 @@ SDValue SparcTargetLowering::makeAddress(SDValue O 25 // Handle PIC mode first. 26 if (getTargetMachine().getRelocationModel() == Reloc::PIC_) { 27 // This is the pic32 code model, the GOT is known to be smaller than 4GB. 28- SDValue HiLo = makeHiLoPair(Op, SPII::MO_HI, SPII::MO_LO, DAG); 29+ SDValue HiLo = makeHiLoPair(Op, SparcMCExpr::VK_Sparc_HI, 30+ SparcMCExpr::VK_Sparc_LO, DAG); 31 SDValue GlobalBase = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, VT); 32 SDValue AbsAddr = DAG.getNode(ISD::ADD, DL, VT, GlobalBase, HiLo); 33 // GLOBAL_BASE_REG codegen'ed with call. Inform MFI that this 34@@ -1813,20 +1814,24 @@ SDValue SparcTargetLowering::makeAddress(SDValue O 35 llvm_unreachable("Unsupported absolute code model"); 36 case CodeModel::Small: 37 // abs32. 38- return makeHiLoPair(Op, SPII::MO_HI, SPII::MO_LO, DAG); 39+ return makeHiLoPair(Op, SparcMCExpr::VK_Sparc_HI, 40+ SparcMCExpr::VK_Sparc_LO, DAG); 41 case CodeModel::Medium: { 42 // abs44. 43- SDValue H44 = makeHiLoPair(Op, SPII::MO_H44, SPII::MO_M44, DAG); 44+ SDValue H44 = makeHiLoPair(Op, SparcMCExpr::VK_Sparc_H44, 45+ SparcMCExpr::VK_Sparc_M44, DAG); 46 H44 = DAG.getNode(ISD::SHL, DL, VT, H44, DAG.getConstant(12, MVT::i32)); 47- SDValue L44 = withTargetFlags(Op, SPII::MO_L44, DAG); 48+ SDValue L44 = withTargetFlags(Op, SparcMCExpr::VK_Sparc_L44, DAG); 49 L44 = DAG.getNode(SPISD::Lo, DL, VT, L44); 50 return DAG.getNode(ISD::ADD, DL, VT, H44, L44); 51 } 52 case CodeModel::Large: { 53 // abs64. 54- SDValue Hi = makeHiLoPair(Op, SPII::MO_HH, SPII::MO_HM, DAG); 55+ SDValue Hi = makeHiLoPair(Op, SparcMCExpr::VK_Sparc_HH, 56+ SparcMCExpr::VK_Sparc_HM, DAG); 57 Hi = DAG.getNode(ISD::SHL, DL, VT, Hi, DAG.getConstant(32, MVT::i32)); 58- SDValue Lo = makeHiLoPair(Op, SPII::MO_HI, SPII::MO_LO, DAG); 59+ SDValue Lo = makeHiLoPair(Op, SparcMCExpr::VK_Sparc_HI, 60+ SparcMCExpr::VK_Sparc_LO, DAG); 61 return DAG.getNode(ISD::ADD, DL, VT, Hi, Lo); 62 } 63 } 64@@ -1858,14 +1863,18 @@ SDValue SparcTargetLowering::LowerGlobalTLSAddress 65 TLSModel::Model model = getTargetMachine().getTLSModel(GV); 66 67 if (model == TLSModel::GeneralDynamic || model == TLSModel::LocalDynamic) { 68- unsigned HiTF = ((model == TLSModel::GeneralDynamic)? SPII::MO_TLS_GD_HI22 69- : SPII::MO_TLS_LDM_HI22); 70- unsigned LoTF = ((model == TLSModel::GeneralDynamic)? SPII::MO_TLS_GD_LO10 71- : SPII::MO_TLS_LDM_LO10); 72- unsigned addTF = ((model == TLSModel::GeneralDynamic)? SPII::MO_TLS_GD_ADD 73- : SPII::MO_TLS_LDM_ADD); 74- unsigned callTF = ((model == TLSModel::GeneralDynamic)? SPII::MO_TLS_GD_CALL 75- : SPII::MO_TLS_LDM_CALL); 76+ unsigned HiTF = ((model == TLSModel::GeneralDynamic) 77+ ? SparcMCExpr::VK_Sparc_TLS_GD_HI22 78+ : SparcMCExpr::VK_Sparc_TLS_LDM_HI22); 79+ unsigned LoTF = ((model == TLSModel::GeneralDynamic) 80+ ? SparcMCExpr::VK_Sparc_TLS_GD_LO10 81+ : SparcMCExpr::VK_Sparc_TLS_LDM_LO10); 82+ unsigned addTF = ((model == TLSModel::GeneralDynamic) 83+ ? SparcMCExpr::VK_Sparc_TLS_GD_ADD 84+ : SparcMCExpr::VK_Sparc_TLS_LDM_ADD); 85+ unsigned callTF = ((model == TLSModel::GeneralDynamic) 86+ ? SparcMCExpr::VK_Sparc_TLS_GD_CALL 87+ : SparcMCExpr::VK_Sparc_TLS_LDM_CALL); 88 89 SDValue HiLo = makeHiLoPair(Op, HiTF, LoTF, DAG); 90 SDValue Base = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, PtrVT); 91@@ -1903,17 +1912,17 @@ SDValue SparcTargetLowering::LowerGlobalTLSAddress 92 return Ret; 93 94 SDValue Hi = DAG.getNode(SPISD::Hi, DL, PtrVT, 95- withTargetFlags(Op, SPII::MO_TLS_LDO_HIX22, DAG)); 96+ withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_HIX22, DAG)); 97 SDValue Lo = DAG.getNode(SPISD::Lo, DL, PtrVT, 98- withTargetFlags(Op, SPII::MO_TLS_LDO_LOX10, DAG)); 99+ withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_LOX10, DAG)); 100 HiLo = DAG.getNode(ISD::XOR, DL, PtrVT, Hi, Lo); 101 return DAG.getNode(SPISD::TLS_ADD, DL, PtrVT, Ret, HiLo, 102- withTargetFlags(Op, SPII::MO_TLS_LDO_ADD, DAG)); 103+ withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LDO_ADD, DAG)); 104 } 105 106 if (model == TLSModel::InitialExec) { 107- unsigned ldTF = ((PtrVT == MVT::i64)? SPII::MO_TLS_IE_LDX 108- : SPII::MO_TLS_IE_LD); 109+ unsigned ldTF = ((PtrVT == MVT::i64)? SparcMCExpr::VK_Sparc_TLS_IE_LDX 110+ : SparcMCExpr::VK_Sparc_TLS_IE_LD); 111 112 SDValue Base = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, PtrVT); 113 114@@ -1923,7 +1932,8 @@ SDValue SparcTargetLowering::LowerGlobalTLSAddress 115 MFI->setHasCalls(true); 116 117 SDValue TGA = makeHiLoPair(Op, 118- SPII::MO_TLS_IE_HI22, SPII::MO_TLS_IE_LO10, DAG); 119+ SparcMCExpr::VK_Sparc_TLS_IE_HI22, 120+ SparcMCExpr::VK_Sparc_TLS_IE_LO10, DAG); 121 SDValue Ptr = DAG.getNode(ISD::ADD, DL, PtrVT, Base, TGA); 122 SDValue Offset = DAG.getNode(SPISD::TLS_LD, 123 DL, PtrVT, Ptr, 124@@ -1930,14 +1940,15 @@ SDValue SparcTargetLowering::LowerGlobalTLSAddress 125 withTargetFlags(Op, ldTF, DAG)); 126 return DAG.getNode(SPISD::TLS_ADD, DL, PtrVT, 127 DAG.getRegister(SP::G7, PtrVT), Offset, 128- withTargetFlags(Op, SPII::MO_TLS_IE_ADD, DAG)); 129+ withTargetFlags(Op, 130+ SparcMCExpr::VK_Sparc_TLS_IE_ADD, DAG)); 131 } 132 133 assert(model == TLSModel::LocalExec); 134 SDValue Hi = DAG.getNode(SPISD::Hi, DL, PtrVT, 135- withTargetFlags(Op, SPII::MO_TLS_LE_HIX22, DAG)); 136+ withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LE_HIX22, DAG)); 137 SDValue Lo = DAG.getNode(SPISD::Lo, DL, PtrVT, 138- withTargetFlags(Op, SPII::MO_TLS_LE_LOX10, DAG)); 139+ withTargetFlags(Op, SparcMCExpr::VK_Sparc_TLS_LE_LOX10, DAG)); 140 SDValue Offset = DAG.getNode(ISD::XOR, DL, PtrVT, Hi, Lo); 141 142 return DAG.getNode(ISD::ADD, DL, PtrVT, 143Index: lib/Target/Sparc/SparcCodeEmitter.cpp 144=================================================================== 145--- lib/Target/Sparc/SparcCodeEmitter.cpp 146+++ lib/Target/Sparc/SparcCodeEmitter.cpp 147@@ -14,7 +14,7 @@ 148 149 #define DEBUG_TYPE "jit" 150 #include "Sparc.h" 151-#include "MCTargetDesc/SparcBaseInfo.h" 152+#include "MCTargetDesc/SparcMCExpr.h" 153 #include "SparcRelocations.h" 154 #include "SparcTargetMachine.h" 155 #include "llvm/ADT/Statistic.h" 156@@ -204,14 +204,14 @@ unsigned SparcCodeEmitter::getRelocation(const Mac 157 unsigned TF = MO.getTargetFlags(); 158 switch (TF) { 159 default: 160- case SPII::MO_NO_FLAG: break; 161- case SPII::MO_LO: return SP::reloc_sparc_lo; 162- case SPII::MO_HI: return SP::reloc_sparc_hi; 163- case SPII::MO_H44: return SP::reloc_sparc_h44; 164- case SPII::MO_M44: return SP::reloc_sparc_m44; 165- case SPII::MO_L44: return SP::reloc_sparc_l44; 166- case SPII::MO_HH: return SP::reloc_sparc_hh; 167- case SPII::MO_HM: return SP::reloc_sparc_hm; 168+ case SparcMCExpr::VK_Sparc_None: break; 169+ case SparcMCExpr::VK_Sparc_LO: return SP::reloc_sparc_lo; 170+ case SparcMCExpr::VK_Sparc_HI: return SP::reloc_sparc_hi; 171+ case SparcMCExpr::VK_Sparc_H44: return SP::reloc_sparc_h44; 172+ case SparcMCExpr::VK_Sparc_M44: return SP::reloc_sparc_m44; 173+ case SparcMCExpr::VK_Sparc_L44: return SP::reloc_sparc_l44; 174+ case SparcMCExpr::VK_Sparc_HH: return SP::reloc_sparc_hh; 175+ case SparcMCExpr::VK_Sparc_HM: return SP::reloc_sparc_hm; 176 } 177 178 unsigned Opc = MI.getOpcode(); 179Index: lib/Target/Sparc/SparcMCInstLower.cpp 180=================================================================== 181--- lib/Target/Sparc/SparcMCInstLower.cpp 182+++ lib/Target/Sparc/SparcMCInstLower.cpp 183@@ -13,7 +13,6 @@ 184 //===----------------------------------------------------------------------===// 185 186 #include "Sparc.h" 187-#include "MCTargetDesc/SparcBaseInfo.h" 188 #include "MCTargetDesc/SparcMCExpr.h" 189 #include "llvm/CodeGen/AsmPrinter.h" 190 #include "llvm/CodeGen/MachineFunction.h" 191@@ -33,41 +32,10 @@ static MCOperand LowerSymbolOperand(const MachineI 192 const MachineOperand &MO, 193 AsmPrinter &AP) { 194 195- SparcMCExpr::VariantKind Kind; 196+ SparcMCExpr::VariantKind Kind = 197+ (SparcMCExpr::VariantKind)MO.getTargetFlags(); 198 const MCSymbol *Symbol = 0; 199 200- unsigned TF = MO.getTargetFlags(); 201- 202- switch(TF) { 203- default: llvm_unreachable("Unknown target flags on operand"); 204- case SPII::MO_NO_FLAG: Kind = SparcMCExpr::VK_Sparc_None; break; 205- case SPII::MO_LO: Kind = SparcMCExpr::VK_Sparc_LO; break; 206- case SPII::MO_HI: Kind = SparcMCExpr::VK_Sparc_HI; break; 207- case SPII::MO_H44: Kind = SparcMCExpr::VK_Sparc_H44; break; 208- case SPII::MO_M44: Kind = SparcMCExpr::VK_Sparc_M44; break; 209- case SPII::MO_L44: Kind = SparcMCExpr::VK_Sparc_L44; break; 210- case SPII::MO_HH: Kind = SparcMCExpr::VK_Sparc_HH; break; 211- case SPII::MO_HM: Kind = SparcMCExpr::VK_Sparc_HM; break; 212- case SPII::MO_TLS_GD_HI22: Kind = SparcMCExpr::VK_Sparc_TLS_GD_HI22; break; 213- case SPII::MO_TLS_GD_LO10: Kind = SparcMCExpr::VK_Sparc_TLS_GD_LO10; break; 214- case SPII::MO_TLS_GD_ADD: Kind = SparcMCExpr::VK_Sparc_TLS_GD_ADD; break; 215- case SPII::MO_TLS_GD_CALL: Kind = SparcMCExpr::VK_Sparc_TLS_GD_CALL; break; 216- case SPII::MO_TLS_LDM_HI22: Kind = SparcMCExpr::VK_Sparc_TLS_LDM_HI22; break; 217- case SPII::MO_TLS_LDM_LO10: Kind = SparcMCExpr::VK_Sparc_TLS_LDM_LO10; break; 218- case SPII::MO_TLS_LDM_ADD: Kind = SparcMCExpr::VK_Sparc_TLS_LDM_ADD; break; 219- case SPII::MO_TLS_LDM_CALL: Kind = SparcMCExpr::VK_Sparc_TLS_LDM_CALL; break; 220- case SPII::MO_TLS_LDO_HIX22:Kind = SparcMCExpr::VK_Sparc_TLS_LDO_HIX22; break; 221- case SPII::MO_TLS_LDO_LOX10:Kind = SparcMCExpr::VK_Sparc_TLS_LDO_LOX10; break; 222- case SPII::MO_TLS_LDO_ADD: Kind = SparcMCExpr::VK_Sparc_TLS_LDO_ADD; break; 223- case SPII::MO_TLS_IE_HI22: Kind = SparcMCExpr::VK_Sparc_TLS_IE_HI22; break; 224- case SPII::MO_TLS_IE_LO10: Kind = SparcMCExpr::VK_Sparc_TLS_IE_LO10; break; 225- case SPII::MO_TLS_IE_LD: Kind = SparcMCExpr::VK_Sparc_TLS_IE_LD; break; 226- case SPII::MO_TLS_IE_LDX: Kind = SparcMCExpr::VK_Sparc_TLS_IE_LDX; break; 227- case SPII::MO_TLS_IE_ADD: Kind = SparcMCExpr::VK_Sparc_TLS_IE_ADD; break; 228- case SPII::MO_TLS_LE_HIX22: Kind = SparcMCExpr::VK_Sparc_TLS_LE_HIX22; break; 229- case SPII::MO_TLS_LE_LOX10: Kind = SparcMCExpr::VK_Sparc_TLS_LE_LOX10; break; 230- } 231- 232 switch(MO.getType()) { 233 default: llvm_unreachable("Unknown type in LowerSymbolOperand"); 234 case MachineOperand::MO_MachineBasicBlock: 235Index: lib/Target/Sparc/SparcAsmPrinter.cpp 236=================================================================== 237--- lib/Target/Sparc/SparcAsmPrinter.cpp 238+++ lib/Target/Sparc/SparcAsmPrinter.cpp 239@@ -18,7 +18,6 @@ 240 #include "SparcTargetMachine.h" 241 #include "SparcTargetStreamer.h" 242 #include "InstPrinter/SparcInstPrinter.h" 243-#include "MCTargetDesc/SparcBaseInfo.h" 244 #include "MCTargetDesc/SparcMCExpr.h" 245 #include "llvm/ADT/SmallString.h" 246 #include "llvm/CodeGen/AsmPrinter.h" 247@@ -287,83 +286,60 @@ void SparcAsmPrinter::EmitFunctionBodyStart() { 248 void SparcAsmPrinter::printOperand(const MachineInstr *MI, int opNum, 249 raw_ostream &O) { 250 const MachineOperand &MO = MI->getOperand (opNum); 251- unsigned TF = MO.getTargetFlags(); 252+ SparcMCExpr::VariantKind TF = (SparcMCExpr::VariantKind) MO.getTargetFlags(); 253+ 254 #ifndef NDEBUG 255 // Verify the target flags. 256 if (MO.isGlobal() || MO.isSymbol() || MO.isCPI()) { 257 if (MI->getOpcode() == SP::CALL) 258- assert(TF == SPII::MO_NO_FLAG && 259+ assert(TF == SparcMCExpr::VK_Sparc_None && 260 "Cannot handle target flags on call address"); 261 else if (MI->getOpcode() == SP::SETHIi || MI->getOpcode() == SP::SETHIXi) 262- assert((TF == SPII::MO_HI || TF == SPII::MO_H44 || TF == SPII::MO_HH 263- || TF == SPII::MO_TLS_GD_HI22 264- || TF == SPII::MO_TLS_LDM_HI22 265- || TF == SPII::MO_TLS_LDO_HIX22 266- || TF == SPII::MO_TLS_IE_HI22 267- || TF == SPII::MO_TLS_LE_HIX22) && 268+ assert((TF == SparcMCExpr::VK_Sparc_HI 269+ || TF == SparcMCExpr::VK_Sparc_H44 270+ || TF == SparcMCExpr::VK_Sparc_HH 271+ || TF == SparcMCExpr::VK_Sparc_TLS_GD_HI22 272+ || TF == SparcMCExpr::VK_Sparc_TLS_LDM_HI22 273+ || TF == SparcMCExpr::VK_Sparc_TLS_LDO_HIX22 274+ || TF == SparcMCExpr::VK_Sparc_TLS_IE_HI22 275+ || TF == SparcMCExpr::VK_Sparc_TLS_LE_HIX22) && 276 "Invalid target flags for address operand on sethi"); 277 else if (MI->getOpcode() == SP::TLS_CALL) 278- assert((TF == SPII::MO_NO_FLAG 279- || TF == SPII::MO_TLS_GD_CALL 280- || TF == SPII::MO_TLS_LDM_CALL) && 281+ assert((TF == SparcMCExpr::VK_Sparc_None 282+ || TF == SparcMCExpr::VK_Sparc_TLS_GD_CALL 283+ || TF == SparcMCExpr::VK_Sparc_TLS_LDM_CALL) && 284 "Cannot handle target flags on tls call address"); 285 else if (MI->getOpcode() == SP::TLS_ADDrr) 286- assert((TF == SPII::MO_TLS_GD_ADD || TF == SPII::MO_TLS_LDM_ADD 287- || TF == SPII::MO_TLS_LDO_ADD || TF == SPII::MO_TLS_IE_ADD) && 288+ assert((TF == SparcMCExpr::VK_Sparc_TLS_GD_ADD 289+ || TF == SparcMCExpr::VK_Sparc_TLS_LDM_ADD 290+ || TF == SparcMCExpr::VK_Sparc_TLS_LDO_ADD 291+ || TF == SparcMCExpr::VK_Sparc_TLS_IE_ADD) && 292 "Cannot handle target flags on add for TLS"); 293 else if (MI->getOpcode() == SP::TLS_LDrr) 294- assert(TF == SPII::MO_TLS_IE_LD && 295+ assert(TF == SparcMCExpr::VK_Sparc_TLS_IE_LD && 296 "Cannot handle target flags on ld for TLS"); 297 else if (MI->getOpcode() == SP::TLS_LDXrr) 298- assert(TF == SPII::MO_TLS_IE_LDX && 299+ assert(TF == SparcMCExpr::VK_Sparc_TLS_IE_LDX && 300 "Cannot handle target flags on ldx for TLS"); 301 else if (MI->getOpcode() == SP::XORri || MI->getOpcode() == SP::XORXri) 302- assert((TF == SPII::MO_TLS_LDO_LOX10 || TF == SPII::MO_TLS_LE_LOX10) && 303+ assert((TF == SparcMCExpr::VK_Sparc_TLS_LDO_LOX10 304+ || TF == SparcMCExpr::VK_Sparc_TLS_LE_LOX10) && 305 "Cannot handle target flags on xor for TLS"); 306 else 307- assert((TF == SPII::MO_LO || TF == SPII::MO_M44 || TF == SPII::MO_L44 308- || TF == SPII::MO_HM 309- || TF == SPII::MO_TLS_GD_LO10 310- || TF == SPII::MO_TLS_LDM_LO10 311- || TF == SPII::MO_TLS_IE_LO10 ) && 312+ assert((TF == SparcMCExpr::VK_Sparc_LO 313+ || TF == SparcMCExpr::VK_Sparc_M44 314+ || TF == SparcMCExpr::VK_Sparc_L44 315+ || TF == SparcMCExpr::VK_Sparc_HM 316+ || TF == SparcMCExpr::VK_Sparc_TLS_GD_LO10 317+ || TF == SparcMCExpr::VK_Sparc_TLS_LDM_LO10 318+ || TF == SparcMCExpr::VK_Sparc_TLS_IE_LO10 ) && 319 "Invalid target flags for small address operand"); 320 } 321 #endif 322 323- bool CloseParen = true; 324- switch (TF) { 325- default: 326- llvm_unreachable("Unknown target flags on operand"); 327- case SPII::MO_NO_FLAG: 328- CloseParen = false; 329- break; 330- case SPII::MO_LO: O << "%lo("; break; 331- case SPII::MO_HI: O << "%hi("; break; 332- case SPII::MO_H44: O << "%h44("; break; 333- case SPII::MO_M44: O << "%m44("; break; 334- case SPII::MO_L44: O << "%l44("; break; 335- case SPII::MO_HH: O << "%hh("; break; 336- case SPII::MO_HM: O << "%hm("; break; 337- case SPII::MO_TLS_GD_HI22: O << "%tgd_hi22("; break; 338- case SPII::MO_TLS_GD_LO10: O << "%tgd_lo10("; break; 339- case SPII::MO_TLS_GD_ADD: O << "%tgd_add("; break; 340- case SPII::MO_TLS_GD_CALL: O << "%tgd_call("; break; 341- case SPII::MO_TLS_LDM_HI22: O << "%tldm_hi22("; break; 342- case SPII::MO_TLS_LDM_LO10: O << "%tldm_lo10("; break; 343- case SPII::MO_TLS_LDM_ADD: O << "%tldm_add("; break; 344- case SPII::MO_TLS_LDM_CALL: O << "%tldm_call("; break; 345- case SPII::MO_TLS_LDO_HIX22: O << "%tldo_hix22("; break; 346- case SPII::MO_TLS_LDO_LOX10: O << "%tldo_lox10("; break; 347- case SPII::MO_TLS_LDO_ADD: O << "%tldo_add("; break; 348- case SPII::MO_TLS_IE_HI22: O << "%tie_hi22("; break; 349- case SPII::MO_TLS_IE_LO10: O << "%tie_lo10("; break; 350- case SPII::MO_TLS_IE_LD: O << "%tie_ld("; break; 351- case SPII::MO_TLS_IE_LDX: O << "%tie_ldx("; break; 352- case SPII::MO_TLS_IE_ADD: O << "%tie_add("; break; 353- case SPII::MO_TLS_LE_HIX22: O << "%tle_hix22("; break; 354- case SPII::MO_TLS_LE_LOX10: O << "%tle_lox10("; break; 355- } 356 357+ bool CloseParen = SparcMCExpr::printVariantKind(O, TF); 358+ 359 switch (MO.getType()) { 360 case MachineOperand::MO_Register: 361 O << "%" << StringRef(getRegisterName(MO.getReg())).lower(); 362Index: lib/Target/Sparc/InstPrinter/SparcInstPrinter.cpp 363=================================================================== 364--- lib/Target/Sparc/InstPrinter/SparcInstPrinter.cpp 365+++ lib/Target/Sparc/InstPrinter/SparcInstPrinter.cpp 366@@ -15,7 +15,6 @@ 367 #include "SparcInstPrinter.h" 368 369 #include "Sparc.h" 370-#include "MCTargetDesc/SparcBaseInfo.h" 371 #include "llvm/MC/MCExpr.h" 372 #include "llvm/MC/MCInst.h" 373 #include "llvm/MC/MCSymbol.h" 374Index: lib/Target/Sparc/MCTargetDesc/SparcBaseInfo.h 375=================================================================== 376--- lib/Target/Sparc/MCTargetDesc/SparcBaseInfo.h 377+++ lib/Target/Sparc/MCTargetDesc/SparcBaseInfo.h 378@@ -1,82 +0,0 @@ 379-//===-- SparcBaseInfo.h - Top level definitions for Sparc ---- --*- C++ -*-===// 380-// 381-// The LLVM Compiler Infrastructure 382-// 383-// This file is distributed under the University of Illinois Open Source 384-// License. See LICENSE.TXT for details. 385-// 386-//===----------------------------------------------------------------------===// 387-// 388-// This file contains small standalone helper functions and enum definitions 389-// for the Sparc target useful for the compiler back-end and the MC libraries. 390-// As such, it deliberately does not include references to LLVM core code gen 391-// types, passes, etc.. 392-// 393-//===----------------------------------------------------------------------===// 394- 395-#ifndef SPARCBASEINFO_H 396-#define SPARCBASEINFO_H 397- 398-namespace llvm { 399- 400-/// SPII - This namespace holds target specific flags for instruction info. 401-namespace SPII { 402- 403-/// Target Operand Flags. Sparc specific TargetFlags for MachineOperands and 404-/// SDNodes. 405-enum TOF { 406- MO_NO_FLAG, 407- 408- // Extract the low 10 bits of an address. 409- // Assembler: %lo(addr) 410- MO_LO, 411- 412- // Extract bits 31-10 of an address. Only for sethi. 413- // Assembler: %hi(addr) or %lm(addr) 414- MO_HI, 415- 416- // Extract bits 43-22 of an adress. Only for sethi. 417- // Assembler: %h44(addr) 418- MO_H44, 419- 420- // Extract bits 21-12 of an address. 421- // Assembler: %m44(addr) 422- MO_M44, 423- 424- // Extract bits 11-0 of an address. 425- // Assembler: %l44(addr) 426- MO_L44, 427- 428- // Extract bits 63-42 of an address. Only for sethi. 429- // Assembler: %hh(addr) 430- MO_HH, 431- 432- // Extract bits 41-32 of an address. 433- // Assembler: %hm(addr) 434- MO_HM, 435- 436- // TargetFlags for Thread Local Storage. 437- MO_TLS_GD_HI22, 438- MO_TLS_GD_LO10, 439- MO_TLS_GD_ADD, 440- MO_TLS_GD_CALL, 441- MO_TLS_LDM_HI22, 442- MO_TLS_LDM_LO10, 443- MO_TLS_LDM_ADD, 444- MO_TLS_LDM_CALL, 445- MO_TLS_LDO_HIX22, 446- MO_TLS_LDO_LOX10, 447- MO_TLS_LDO_ADD, 448- MO_TLS_IE_HI22, 449- MO_TLS_IE_LO10, 450- MO_TLS_IE_LD, 451- MO_TLS_IE_LDX, 452- MO_TLS_IE_ADD, 453- MO_TLS_LE_HIX22, 454- MO_TLS_LE_LOX10 455-}; 456- 457-} // end namespace SPII 458-} // end namespace llvm 459- 460-#endif 461Index: lib/Target/Sparc/MCTargetDesc/SparcMCExpr.cpp 462=================================================================== 463--- lib/Target/Sparc/MCTargetDesc/SparcMCExpr.cpp 464+++ lib/Target/Sparc/MCTargetDesc/SparcMCExpr.cpp 465@@ -29,8 +29,21 @@ SparcMCExpr::Create(VariantKind Kind, const MCExpr 466 } 467 468 469+ 470 void SparcMCExpr::PrintImpl(raw_ostream &OS) const 471 { 472+ 473+ bool closeParen = printVariantKind(OS, Kind); 474+ 475+ const MCExpr *Expr = getSubExpr(); 476+ Expr->print(OS); 477+ 478+ if (closeParen) 479+ OS << ')'; 480+} 481+ 482+bool SparcMCExpr::printVariantKind(raw_ostream &OS, VariantKind Kind) 483+{ 484 bool closeParen = true; 485 switch (Kind) { 486 case VK_Sparc_None: closeParen = false; break; 487@@ -61,11 +74,7 @@ void SparcMCExpr::PrintImpl(raw_ostream &OS) const 488 case VK_Sparc_TLS_LE_HIX22: OS << "%tle_hix22("; break; 489 case VK_Sparc_TLS_LE_LOX10: OS << "%tle_lox10("; break; 490 } 491- 492- const MCExpr *Expr = getSubExpr(); 493- Expr->print(OS); 494- if (closeParen) 495- OS << ')'; 496+ return closeParen; 497 } 498 499 SparcMCExpr::VariantKind SparcMCExpr::parseVariantKind(StringRef name) 500Index: lib/Target/Sparc/MCTargetDesc/SparcMCExpr.h 501=================================================================== 502--- lib/Target/Sparc/MCTargetDesc/SparcMCExpr.h 503+++ lib/Target/Sparc/MCTargetDesc/SparcMCExpr.h 504@@ -93,7 +93,7 @@ class SparcMCExpr : public MCTargetExpr { 505 static bool classof(const SparcMCExpr *) { return true; } 506 507 static VariantKind parseVariantKind(StringRef name); 508- 509+ static bool printVariantKind(raw_ostream &OS, VariantKind Kind); 510 }; 511 512 } // end namespace llvm. 513