1 Pull in r200960 from upstream llvm trunk (by Venkatraman Govindaraju):
3 [Sparc] Use SparcMCExpr::VariantKind itself as MachineOperand's target flags.
5 Introduced here: http://svnweb.freebsd.org/changeset/base/262261
7 Index: lib/Target/Sparc/SparcISelLowering.cpp
8 ===================================================================
9 --- lib/Target/Sparc/SparcISelLowering.cpp
10 +++ lib/Target/Sparc/SparcISelLowering.cpp
12 //===----------------------------------------------------------------------===//
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:
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: {
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);
52 case CodeModel::Large: {
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);
64 @@ -1858,14 +1863,18 @@ SDValue SparcTargetLowering::LowerGlobalTLSAddress
65 TLSModel::Model model = getTargetMachine().getTLSModel(GV);
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);
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
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));
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);
112 SDValue Base = DAG.getNode(SPISD::GLOBAL_BASE_REG, DL, PtrVT);
114 @@ -1923,7 +1932,8 @@ SDValue SparcTargetLowering::LowerGlobalTLSAddress
115 MFI->setHasCalls(true);
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,
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));
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);
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
149 #define DEBUG_TYPE "jit"
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();
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;
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
184 //===----------------------------------------------------------------------===//
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,
195 - SparcMCExpr::VariantKind Kind;
196 + SparcMCExpr::VariantKind Kind =
197 + (SparcMCExpr::VariantKind)MO.getTargetFlags();
198 const MCSymbol *Symbol = 0;
200 - unsigned TF = MO.getTargetFlags();
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;
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
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,
250 const MachineOperand &MO = MI->getOperand (opNum);
251 - unsigned TF = MO.getTargetFlags();
252 + SparcMCExpr::VariantKind TF = (SparcMCExpr::VariantKind) MO.getTargetFlags();
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");
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");
323 - bool CloseParen = true;
326 - llvm_unreachable("Unknown target flags on operand");
327 - case SPII::MO_NO_FLAG:
328 - CloseParen = false;
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;
357 + bool CloseParen = SparcMCExpr::printVariantKind(O, TF);
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
367 #include "SparcInstPrinter.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
379 -//===-- SparcBaseInfo.h - Top level definitions for Sparc ---- --*- C++ -*-===//
381 -// The LLVM Compiler Infrastructure
383 -// This file is distributed under the University of Illinois Open Source
384 -// License. See LICENSE.TXT for details.
386 -//===----------------------------------------------------------------------===//
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..
393 -//===----------------------------------------------------------------------===//
395 -#ifndef SPARCBASEINFO_H
396 -#define SPARCBASEINFO_H
400 -/// SPII - This namespace holds target specific flags for instruction info.
403 -/// Target Operand Flags. Sparc specific TargetFlags for MachineOperands and
408 - // Extract the low 10 bits of an address.
409 - // Assembler: %lo(addr)
412 - // Extract bits 31-10 of an address. Only for sethi.
413 - // Assembler: %hi(addr) or %lm(addr)
416 - // Extract bits 43-22 of an adress. Only for sethi.
417 - // Assembler: %h44(addr)
420 - // Extract bits 21-12 of an address.
421 - // Assembler: %m44(addr)
424 - // Extract bits 11-0 of an address.
425 - // Assembler: %l44(addr)
428 - // Extract bits 63-42 of an address. Only for sethi.
429 - // Assembler: %hh(addr)
432 - // Extract bits 41-32 of an address.
433 - // Assembler: %hm(addr)
436 - // TargetFlags for Thread Local Storage.
457 -} // end namespace SPII
458 -} // end namespace llvm
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
470 void SparcMCExpr::PrintImpl(raw_ostream &OS) const
473 + bool closeParen = printVariantKind(OS, Kind);
475 + const MCExpr *Expr = getSubExpr();
482 +bool SparcMCExpr::printVariantKind(raw_ostream &OS, VariantKind Kind)
484 bool closeParen = true;
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;
492 - const MCExpr *Expr = getSubExpr();
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; }
507 static VariantKind parseVariantKind(StringRef name);
509 + static bool printVariantKind(raw_ostream &OS, VariantKind Kind);
512 } // end namespace llvm.