contrib/llvm/patches/patch-r262261-llvm-r200960-sparc.diff

   1 Pull in r200960 from upstream llvm trunk (by Venkatraman Govindaraju):
   2
   3   [Sparc] Use SparcMCExpr::VariantKind itself as MachineOperand's target flags.
   4
   5 Introduced here: http://svnweb.freebsd.org/changeset/base/262261
   6
   7 Index: 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,
 143 Index: 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();
 179 Index: 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:
 235 Index: 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();
 362 Index: 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"
 374 Index: 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
 461 Index: 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)
 500 Index: 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.