1 //===-- SystemZAsmParser.cpp - Parse SystemZ assembly instructions --------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "MCTargetDesc/SystemZMCTargetDesc.h"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/MC/MCContext.h"
13 #include "llvm/MC/MCExpr.h"
14 #include "llvm/MC/MCInst.h"
15 #include "llvm/MC/MCInstBuilder.h"
16 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
17 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
18 #include "llvm/MC/MCStreamer.h"
19 #include "llvm/MC/MCSubtargetInfo.h"
20 #include "llvm/Support/TargetRegistry.h"
21 
22 using namespace llvm;
23 
24 // Return true if Expr is in the range [MinValue, MaxValue].
25 static bool inRange(const MCExpr *Expr, int64_t MinValue, int64_t MaxValue) {
26   if (auto *CE = dyn_cast<MCConstantExpr>(Expr)) {
27     int64_t Value = CE->getValue();
28     return Value >= MinValue && Value <= MaxValue;
29   }
30   return false;
31 }
32 
33 namespace {
34 enum RegisterKind {
35   GR32Reg,
36   GRH32Reg,
37   GR64Reg,
38   GR128Reg,
39   ADDR32Reg,
40   ADDR64Reg,
41   FP32Reg,
42   FP64Reg,
43   FP128Reg,
44   VR32Reg,
45   VR64Reg,
46   VR128Reg
47 };
48 
49 enum MemoryKind {
50   BDMem,
51   BDXMem,
52   BDLMem,
53   BDVMem
54 };
55 
56 class SystemZOperand : public MCParsedAsmOperand {
57 public:
58 private:
59   enum OperandKind {
60     KindInvalid,
61     KindToken,
62     KindReg,
63     KindAccessReg,
64     KindImm,
65     KindImmTLS,
66     KindMem
67   };
68 
69   OperandKind Kind;
70   SMLoc StartLoc, EndLoc;
71 
72   // A string of length Length, starting at Data.
73   struct TokenOp {
74     const char *Data;
75     unsigned Length;
76   };
77 
78   // LLVM register Num, which has kind Kind.  In some ways it might be
79   // easier for this class to have a register bank (general, floating-point
80   // or access) and a raw register number (0-15).  This would postpone the
81   // interpretation of the operand to the add*() methods and avoid the need
82   // for context-dependent parsing.  However, we do things the current way
83   // because of the virtual getReg() method, which needs to distinguish
84   // between (say) %r0 used as a single register and %r0 used as a pair.
85   // Context-dependent parsing can also give us slightly better error
86   // messages when invalid pairs like %r1 are used.
87   struct RegOp {
88     RegisterKind Kind;
89     unsigned Num;
90   };
91 
92   // Base + Disp + Index, where Base and Index are LLVM registers or 0.
93   // MemKind says what type of memory this is and RegKind says what type
94   // the base register has (ADDR32Reg or ADDR64Reg).  Length is the operand
95   // length for D(L,B)-style operands, otherwise it is null.
96   struct MemOp {
97     unsigned Base : 12;
98     unsigned Index : 12;
99     unsigned MemKind : 4;
100     unsigned RegKind : 4;
101     const MCExpr *Disp;
102     const MCExpr *Length;
103   };
104 
105   // Imm is an immediate operand, and Sym is an optional TLS symbol
106   // for use with a __tls_get_offset marker relocation.
107   struct ImmTLSOp {
108     const MCExpr *Imm;
109     const MCExpr *Sym;
110   };
111 
112   union {
113     TokenOp Token;
114     RegOp Reg;
115     unsigned AccessReg;
116     const MCExpr *Imm;
117     ImmTLSOp ImmTLS;
118     MemOp Mem;
119   };
120 
121   void addExpr(MCInst &Inst, const MCExpr *Expr) const {
122     // Add as immediates when possible.  Null MCExpr = 0.
123     if (!Expr)
124       Inst.addOperand(MCOperand::createImm(0));
125     else if (auto *CE = dyn_cast<MCConstantExpr>(Expr))
126       Inst.addOperand(MCOperand::createImm(CE->getValue()));
127     else
128       Inst.addOperand(MCOperand::createExpr(Expr));
129   }
130 
131 public:
132   SystemZOperand(OperandKind kind, SMLoc startLoc, SMLoc endLoc)
133       : Kind(kind), StartLoc(startLoc), EndLoc(endLoc) {}
134 
135   // Create particular kinds of operand.
136   static std::unique_ptr<SystemZOperand> createInvalid(SMLoc StartLoc,
137                                                        SMLoc EndLoc) {
138     return make_unique<SystemZOperand>(KindInvalid, StartLoc, EndLoc);
139   }
140   static std::unique_ptr<SystemZOperand> createToken(StringRef Str, SMLoc Loc) {
141     auto Op = make_unique<SystemZOperand>(KindToken, Loc, Loc);
142     Op->Token.Data = Str.data();
143     Op->Token.Length = Str.size();
144     return Op;
145   }
146   static std::unique_ptr<SystemZOperand>
147   createReg(RegisterKind Kind, unsigned Num, SMLoc StartLoc, SMLoc EndLoc) {
148     auto Op = make_unique<SystemZOperand>(KindReg, StartLoc, EndLoc);
149     Op->Reg.Kind = Kind;
150     Op->Reg.Num = Num;
151     return Op;
152   }
153   static std::unique_ptr<SystemZOperand>
154   createAccessReg(unsigned Num, SMLoc StartLoc, SMLoc EndLoc) {
155     auto Op = make_unique<SystemZOperand>(KindAccessReg, StartLoc, EndLoc);
156     Op->AccessReg = Num;
157     return Op;
158   }
159   static std::unique_ptr<SystemZOperand>
160   createImm(const MCExpr *Expr, SMLoc StartLoc, SMLoc EndLoc) {
161     auto Op = make_unique<SystemZOperand>(KindImm, StartLoc, EndLoc);
162     Op->Imm = Expr;
163     return Op;
164   }
165   static std::unique_ptr<SystemZOperand>
166   createMem(MemoryKind MemKind, RegisterKind RegKind, unsigned Base,
167             const MCExpr *Disp, unsigned Index, const MCExpr *Length,
168             SMLoc StartLoc, SMLoc EndLoc) {
169     auto Op = make_unique<SystemZOperand>(KindMem, StartLoc, EndLoc);
170     Op->Mem.MemKind = MemKind;
171     Op->Mem.RegKind = RegKind;
172     Op->Mem.Base = Base;
173     Op->Mem.Index = Index;
174     Op->Mem.Disp = Disp;
175     Op->Mem.Length = Length;
176     return Op;
177   }
178   static std::unique_ptr<SystemZOperand>
179   createImmTLS(const MCExpr *Imm, const MCExpr *Sym,
180                SMLoc StartLoc, SMLoc EndLoc) {
181     auto Op = make_unique<SystemZOperand>(KindImmTLS, StartLoc, EndLoc);
182     Op->ImmTLS.Imm = Imm;
183     Op->ImmTLS.Sym = Sym;
184     return Op;
185   }
186 
187   // Token operands
188   bool isToken() const override {
189     return Kind == KindToken;
190   }
191   StringRef getToken() const {
192     assert(Kind == KindToken && "Not a token");
193     return StringRef(Token.Data, Token.Length);
194   }
195 
196   // Register operands.
197   bool isReg() const override {
198     return Kind == KindReg;
199   }
200   bool isReg(RegisterKind RegKind) const {
201     return Kind == KindReg && Reg.Kind == RegKind;
202   }
203   unsigned getReg() const override {
204     assert(Kind == KindReg && "Not a register");
205     return Reg.Num;
206   }
207 
208   // Access register operands.  Access registers aren't exposed to LLVM
209   // as registers.
210   bool isAccessReg() const {
211     return Kind == KindAccessReg;
212   }
213 
214   // Immediate operands.
215   bool isImm() const override {
216     return Kind == KindImm;
217   }
218   bool isImm(int64_t MinValue, int64_t MaxValue) const {
219     return Kind == KindImm && inRange(Imm, MinValue, MaxValue);
220   }
221   const MCExpr *getImm() const {
222     assert(Kind == KindImm && "Not an immediate");
223     return Imm;
224   }
225 
226   // Immediate operands with optional TLS symbol.
227   bool isImmTLS() const {
228     return Kind == KindImmTLS;
229   }
230 
231   // Memory operands.
232   bool isMem() const override {
233     return Kind == KindMem;
234   }
235   bool isMem(MemoryKind MemKind) const {
236     return (Kind == KindMem &&
237             (Mem.MemKind == MemKind ||
238              // A BDMem can be treated as a BDXMem in which the index
239              // register field is 0.
240              (Mem.MemKind == BDMem && MemKind == BDXMem)));
241   }
242   bool isMem(MemoryKind MemKind, RegisterKind RegKind) const {
243     return isMem(MemKind) && Mem.RegKind == RegKind;
244   }
245   bool isMemDisp12(MemoryKind MemKind, RegisterKind RegKind) const {
246     return isMem(MemKind, RegKind) && inRange(Mem.Disp, 0, 0xfff);
247   }
248   bool isMemDisp20(MemoryKind MemKind, RegisterKind RegKind) const {
249     return isMem(MemKind, RegKind) && inRange(Mem.Disp, -524288, 524287);
250   }
251   bool isMemDisp12Len8(RegisterKind RegKind) const {
252     return isMemDisp12(BDLMem, RegKind) && inRange(Mem.Length, 1, 0x100);
253   }
254   void addBDVAddrOperands(MCInst &Inst, unsigned N) const {
255     assert(N == 3 && "Invalid number of operands");
256     assert(isMem(BDVMem) && "Invalid operand type");
257     Inst.addOperand(MCOperand::createReg(Mem.Base));
258     addExpr(Inst, Mem.Disp);
259     Inst.addOperand(MCOperand::createReg(Mem.Index));
260   }
261 
262   // Override MCParsedAsmOperand.
263   SMLoc getStartLoc() const override { return StartLoc; }
264   SMLoc getEndLoc() const override { return EndLoc; }
265   void print(raw_ostream &OS) const override;
266 
267   // Used by the TableGen code to add particular types of operand
268   // to an instruction.
269   void addRegOperands(MCInst &Inst, unsigned N) const {
270     assert(N == 1 && "Invalid number of operands");
271     Inst.addOperand(MCOperand::createReg(getReg()));
272   }
273   void addAccessRegOperands(MCInst &Inst, unsigned N) const {
274     assert(N == 1 && "Invalid number of operands");
275     assert(Kind == KindAccessReg && "Invalid operand type");
276     Inst.addOperand(MCOperand::createImm(AccessReg));
277   }
278   void addImmOperands(MCInst &Inst, unsigned N) const {
279     assert(N == 1 && "Invalid number of operands");
280     addExpr(Inst, getImm());
281   }
282   void addBDAddrOperands(MCInst &Inst, unsigned N) const {
283     assert(N == 2 && "Invalid number of operands");
284     assert(isMem(BDMem) && "Invalid operand type");
285     Inst.addOperand(MCOperand::createReg(Mem.Base));
286     addExpr(Inst, Mem.Disp);
287   }
288   void addBDXAddrOperands(MCInst &Inst, unsigned N) const {
289     assert(N == 3 && "Invalid number of operands");
290     assert(isMem(BDXMem) && "Invalid operand type");
291     Inst.addOperand(MCOperand::createReg(Mem.Base));
292     addExpr(Inst, Mem.Disp);
293     Inst.addOperand(MCOperand::createReg(Mem.Index));
294   }
295   void addBDLAddrOperands(MCInst &Inst, unsigned N) const {
296     assert(N == 3 && "Invalid number of operands");
297     assert(isMem(BDLMem) && "Invalid operand type");
298     Inst.addOperand(MCOperand::createReg(Mem.Base));
299     addExpr(Inst, Mem.Disp);
300     addExpr(Inst, Mem.Length);
301   }
302   void addImmTLSOperands(MCInst &Inst, unsigned N) const {
303     assert(N == 2 && "Invalid number of operands");
304     assert(Kind == KindImmTLS && "Invalid operand type");
305     addExpr(Inst, ImmTLS.Imm);
306     if (ImmTLS.Sym)
307       addExpr(Inst, ImmTLS.Sym);
308   }
309 
310   // Used by the TableGen code to check for particular operand types.
311   bool isGR32() const { return isReg(GR32Reg); }
312   bool isGRH32() const { return isReg(GRH32Reg); }
313   bool isGRX32() const { return false; }
314   bool isGR64() const { return isReg(GR64Reg); }
315   bool isGR128() const { return isReg(GR128Reg); }
316   bool isADDR32() const { return isReg(ADDR32Reg); }
317   bool isADDR64() const { return isReg(ADDR64Reg); }
318   bool isADDR128() const { return false; }
319   bool isFP32() const { return isReg(FP32Reg); }
320   bool isFP64() const { return isReg(FP64Reg); }
321   bool isFP128() const { return isReg(FP128Reg); }
322   bool isVR32() const { return isReg(VR32Reg); }
323   bool isVR64() const { return isReg(VR64Reg); }
324   bool isVF128() const { return false; }
325   bool isVR128() const { return isReg(VR128Reg); }
326   bool isAnyReg() const { return (isReg() || isImm(0, 15)); }
327   bool isBDAddr32Disp12() const { return isMemDisp12(BDMem, ADDR32Reg); }
328   bool isBDAddr32Disp20() const { return isMemDisp20(BDMem, ADDR32Reg); }
329   bool isBDAddr64Disp12() const { return isMemDisp12(BDMem, ADDR64Reg); }
330   bool isBDAddr64Disp20() const { return isMemDisp20(BDMem, ADDR64Reg); }
331   bool isBDXAddr64Disp12() const { return isMemDisp12(BDXMem, ADDR64Reg); }
332   bool isBDXAddr64Disp20() const { return isMemDisp20(BDXMem, ADDR64Reg); }
333   bool isBDLAddr64Disp12Len8() const { return isMemDisp12Len8(ADDR64Reg); }
334   bool isBDVAddr64Disp12() const { return isMemDisp12(BDVMem, ADDR64Reg); }
335   bool isU1Imm() const { return isImm(0, 1); }
336   bool isU2Imm() const { return isImm(0, 3); }
337   bool isU3Imm() const { return isImm(0, 7); }
338   bool isU4Imm() const { return isImm(0, 15); }
339   bool isU6Imm() const { return isImm(0, 63); }
340   bool isU8Imm() const { return isImm(0, 255); }
341   bool isS8Imm() const { return isImm(-128, 127); }
342   bool isU12Imm() const { return isImm(0, 4095); }
343   bool isU16Imm() const { return isImm(0, 65535); }
344   bool isS16Imm() const { return isImm(-32768, 32767); }
345   bool isU32Imm() const { return isImm(0, (1LL << 32) - 1); }
346   bool isS32Imm() const { return isImm(-(1LL << 31), (1LL << 31) - 1); }
347   bool isU48Imm() const { return isImm(0, (1LL << 48) - 1); }
348 };
349 
350 class SystemZAsmParser : public MCTargetAsmParser {
351 #define GET_ASSEMBLER_HEADER
352 #include "SystemZGenAsmMatcher.inc"
353 
354 private:
355   MCAsmParser &Parser;
356   enum RegisterGroup {
357     RegGR,
358     RegFP,
359     RegV,
360     RegAccess
361   };
362   struct Register {
363     RegisterGroup Group;
364     unsigned Num;
365     SMLoc StartLoc, EndLoc;
366   };
367 
368   bool parseRegister(Register &Reg);
369 
370   bool parseRegister(Register &Reg, RegisterGroup Group, const unsigned *Regs,
371                      bool IsAddress = false);
372 
373   OperandMatchResultTy parseRegister(OperandVector &Operands,
374                                      RegisterGroup Group, const unsigned *Regs,
375                                      RegisterKind Kind);
376 
377   OperandMatchResultTy parseAnyRegister(OperandVector &Operands);
378 
379   bool parseAddress(unsigned &Base, const MCExpr *&Disp,
380                     unsigned &Index, bool &IsVector, const MCExpr *&Length,
381                     const unsigned *Regs, RegisterKind RegKind);
382 
383   bool ParseDirectiveInsn(SMLoc L);
384 
385   OperandMatchResultTy parseAddress(OperandVector &Operands,
386                                     MemoryKind MemKind, const unsigned *Regs,
387                                     RegisterKind RegKind);
388 
389   OperandMatchResultTy parsePCRel(OperandVector &Operands, int64_t MinVal,
390                                   int64_t MaxVal, bool AllowTLS);
391 
392   bool parseOperand(OperandVector &Operands, StringRef Mnemonic);
393 
394 public:
395   SystemZAsmParser(const MCSubtargetInfo &sti, MCAsmParser &parser,
396                    const MCInstrInfo &MII,
397                    const MCTargetOptions &Options)
398     : MCTargetAsmParser(Options, sti), Parser(parser) {
399     MCAsmParserExtension::Initialize(Parser);
400 
401     // Alias the .word directive to .short.
402     parser.addAliasForDirective(".word", ".short");
403 
404     // Initialize the set of available features.
405     setAvailableFeatures(ComputeAvailableFeatures(getSTI().getFeatureBits()));
406   }
407 
408   // Override MCTargetAsmParser.
409   bool ParseDirective(AsmToken DirectiveID) override;
410   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
411   bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
412                         SMLoc NameLoc, OperandVector &Operands) override;
413   bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
414                                OperandVector &Operands, MCStreamer &Out,
415                                uint64_t &ErrorInfo,
416                                bool MatchingInlineAsm) override;
417 
418   // Used by the TableGen code to parse particular operand types.
419   OperandMatchResultTy parseGR32(OperandVector &Operands) {
420     return parseRegister(Operands, RegGR, SystemZMC::GR32Regs, GR32Reg);
421   }
422   OperandMatchResultTy parseGRH32(OperandVector &Operands) {
423     return parseRegister(Operands, RegGR, SystemZMC::GRH32Regs, GRH32Reg);
424   }
425   OperandMatchResultTy parseGRX32(OperandVector &Operands) {
426     llvm_unreachable("GRX32 should only be used for pseudo instructions");
427   }
428   OperandMatchResultTy parseGR64(OperandVector &Operands) {
429     return parseRegister(Operands, RegGR, SystemZMC::GR64Regs, GR64Reg);
430   }
431   OperandMatchResultTy parseGR128(OperandVector &Operands) {
432     return parseRegister(Operands, RegGR, SystemZMC::GR128Regs, GR128Reg);
433   }
434   OperandMatchResultTy parseADDR32(OperandVector &Operands) {
435     return parseRegister(Operands, RegGR, SystemZMC::GR32Regs, ADDR32Reg);
436   }
437   OperandMatchResultTy parseADDR64(OperandVector &Operands) {
438     return parseRegister(Operands, RegGR, SystemZMC::GR64Regs, ADDR64Reg);
439   }
440   OperandMatchResultTy parseADDR128(OperandVector &Operands) {
441     llvm_unreachable("Shouldn't be used as an operand");
442   }
443   OperandMatchResultTy parseFP32(OperandVector &Operands) {
444     return parseRegister(Operands, RegFP, SystemZMC::FP32Regs, FP32Reg);
445   }
446   OperandMatchResultTy parseFP64(OperandVector &Operands) {
447     return parseRegister(Operands, RegFP, SystemZMC::FP64Regs, FP64Reg);
448   }
449   OperandMatchResultTy parseFP128(OperandVector &Operands) {
450     return parseRegister(Operands, RegFP, SystemZMC::FP128Regs, FP128Reg);
451   }
452   OperandMatchResultTy parseVR32(OperandVector &Operands) {
453     return parseRegister(Operands, RegV, SystemZMC::VR32Regs, VR32Reg);
454   }
455   OperandMatchResultTy parseVR64(OperandVector &Operands) {
456     return parseRegister(Operands, RegV, SystemZMC::VR64Regs, VR64Reg);
457   }
458   OperandMatchResultTy parseVF128(OperandVector &Operands) {
459     llvm_unreachable("Shouldn't be used as an operand");
460   }
461   OperandMatchResultTy parseVR128(OperandVector &Operands) {
462     return parseRegister(Operands, RegV, SystemZMC::VR128Regs, VR128Reg);
463   }
464   OperandMatchResultTy parseAnyReg(OperandVector &Operands) {
465     return parseAnyRegister(Operands);
466   }
467   OperandMatchResultTy parseBDAddr32(OperandVector &Operands) {
468     return parseAddress(Operands, BDMem, SystemZMC::GR32Regs, ADDR32Reg);
469   }
470   OperandMatchResultTy parseBDAddr64(OperandVector &Operands) {
471     return parseAddress(Operands, BDMem, SystemZMC::GR64Regs, ADDR64Reg);
472   }
473   OperandMatchResultTy parseBDXAddr64(OperandVector &Operands) {
474     return parseAddress(Operands, BDXMem, SystemZMC::GR64Regs, ADDR64Reg);
475   }
476   OperandMatchResultTy parseBDLAddr64(OperandVector &Operands) {
477     return parseAddress(Operands, BDLMem, SystemZMC::GR64Regs, ADDR64Reg);
478   }
479   OperandMatchResultTy parseBDVAddr64(OperandVector &Operands) {
480     return parseAddress(Operands, BDVMem, SystemZMC::GR64Regs, ADDR64Reg);
481   }
482   OperandMatchResultTy parseAccessReg(OperandVector &Operands);
483   OperandMatchResultTy parsePCRel16(OperandVector &Operands) {
484     return parsePCRel(Operands, -(1LL << 16), (1LL << 16) - 1, false);
485   }
486   OperandMatchResultTy parsePCRel32(OperandVector &Operands) {
487     return parsePCRel(Operands, -(1LL << 32), (1LL << 32) - 1, false);
488   }
489   OperandMatchResultTy parsePCRelTLS16(OperandVector &Operands) {
490     return parsePCRel(Operands, -(1LL << 16), (1LL << 16) - 1, true);
491   }
492   OperandMatchResultTy parsePCRelTLS32(OperandVector &Operands) {
493     return parsePCRel(Operands, -(1LL << 32), (1LL << 32) - 1, true);
494   }
495 };
496 } // end anonymous namespace
497 
498 #define GET_REGISTER_MATCHER
499 #define GET_SUBTARGET_FEATURE_NAME
500 #define GET_MATCHER_IMPLEMENTATION
501 #include "SystemZGenAsmMatcher.inc"
502 
503 // Used for the .insn directives; contains information needed to parse the
504 // operands in the directive.
505 struct InsnMatchEntry {
506   StringRef Format;
507   uint64_t Opcode;
508   int32_t NumOperands;
509   MatchClassKind OperandKinds[5];
510 };
511 
512 // For equal_range comparison.
513 struct CompareInsn {
514   bool operator() (const InsnMatchEntry &LHS, StringRef RHS) {
515     return LHS.Format < RHS;
516   }
517   bool operator() (StringRef LHS, const InsnMatchEntry &RHS) {
518     return LHS < RHS.Format;
519   }
520   bool operator() (const InsnMatchEntry &LHS, const InsnMatchEntry &RHS) {
521     return LHS.Format < RHS.Format;
522   }
523 };
524 
525 // Table initializing information for parsing the .insn directive.
526 static struct InsnMatchEntry InsnMatchTable[] = {
527   /* Format, Opcode, NumOperands, OperandKinds */
528   { "e", SystemZ::InsnE, 1,
529     { MCK_U16Imm } },
530   { "ri", SystemZ::InsnRI, 3,
531     { MCK_U32Imm, MCK_AnyReg, MCK_S16Imm } },
532   { "rie", SystemZ::InsnRIE, 4,
533     { MCK_U48Imm, MCK_AnyReg, MCK_AnyReg, MCK_PCRel16 } },
534   { "ril", SystemZ::InsnRIL, 3,
535     { MCK_U48Imm, MCK_AnyReg, MCK_PCRel32 } },
536   { "rilu", SystemZ::InsnRILU, 3,
537     { MCK_U48Imm, MCK_AnyReg, MCK_U32Imm } },
538   { "ris", SystemZ::InsnRIS, 5,
539     { MCK_U48Imm, MCK_AnyReg, MCK_S8Imm, MCK_U4Imm, MCK_BDAddr64Disp12 } },
540   { "rr", SystemZ::InsnRR, 3,
541     { MCK_U16Imm, MCK_AnyReg, MCK_AnyReg } },
542   { "rre", SystemZ::InsnRRE, 3,
543     { MCK_U32Imm, MCK_AnyReg, MCK_AnyReg } },
544   { "rrf", SystemZ::InsnRRF, 5,
545     { MCK_U32Imm, MCK_AnyReg, MCK_AnyReg, MCK_AnyReg, MCK_U4Imm } },
546   { "rrs", SystemZ::InsnRRS, 5,
547     { MCK_U48Imm, MCK_AnyReg, MCK_AnyReg, MCK_U4Imm, MCK_BDAddr64Disp12 } },
548   { "rs", SystemZ::InsnRS, 4,
549     { MCK_U32Imm, MCK_AnyReg, MCK_AnyReg, MCK_BDAddr64Disp12 } },
550   { "rse", SystemZ::InsnRSE, 4,
551     { MCK_U48Imm, MCK_AnyReg, MCK_AnyReg, MCK_BDAddr64Disp12 } },
552   { "rsi", SystemZ::InsnRSI, 4,
553     { MCK_U48Imm, MCK_AnyReg, MCK_AnyReg, MCK_PCRel16 } },
554   { "rsy", SystemZ::InsnRSY, 4,
555     { MCK_U48Imm, MCK_AnyReg, MCK_AnyReg, MCK_BDAddr64Disp20 } },
556   { "rx", SystemZ::InsnRX, 3,
557     { MCK_U32Imm, MCK_AnyReg, MCK_BDXAddr64Disp12 } },
558   { "rxe", SystemZ::InsnRXE, 3,
559     { MCK_U48Imm, MCK_AnyReg, MCK_BDXAddr64Disp12 } },
560   { "rxf", SystemZ::InsnRXF, 4,
561     { MCK_U48Imm, MCK_AnyReg, MCK_AnyReg, MCK_BDXAddr64Disp12 } },
562   { "rxy", SystemZ::InsnRXY, 3,
563     { MCK_U48Imm, MCK_AnyReg, MCK_BDXAddr64Disp20 } },
564   { "s", SystemZ::InsnS, 2,
565     { MCK_U32Imm, MCK_BDAddr64Disp12 } },
566   { "si", SystemZ::InsnSI, 3,
567     { MCK_U32Imm, MCK_BDAddr64Disp12, MCK_S8Imm } },
568   { "sil", SystemZ::InsnSIL, 3,
569     { MCK_U48Imm, MCK_BDAddr64Disp12, MCK_U16Imm } },
570   { "siy", SystemZ::InsnSIY, 3,
571     { MCK_U48Imm, MCK_BDAddr64Disp20, MCK_U8Imm } },
572   { "ss", SystemZ::InsnSS, 4,
573     { MCK_U48Imm, MCK_BDXAddr64Disp12, MCK_BDAddr64Disp12, MCK_AnyReg } },
574   { "sse", SystemZ::InsnSSE, 3,
575     { MCK_U48Imm, MCK_BDAddr64Disp12, MCK_BDAddr64Disp12 } },
576   { "ssf", SystemZ::InsnSSF, 4,
577     { MCK_U48Imm, MCK_BDAddr64Disp12, MCK_BDAddr64Disp12, MCK_AnyReg } }
578 };
579 
580 void SystemZOperand::print(raw_ostream &OS) const {
581   llvm_unreachable("Not implemented");
582 }
583 
584 // Parse one register of the form %<prefix><number>.
585 bool SystemZAsmParser::parseRegister(Register &Reg) {
586   Reg.StartLoc = Parser.getTok().getLoc();
587 
588   // Eat the % prefix.
589   if (Parser.getTok().isNot(AsmToken::Percent))
590     return Error(Parser.getTok().getLoc(), "register expected");
591   Parser.Lex();
592 
593   // Expect a register name.
594   if (Parser.getTok().isNot(AsmToken::Identifier))
595     return Error(Reg.StartLoc, "invalid register");
596 
597   // Check that there's a prefix.
598   StringRef Name = Parser.getTok().getString();
599   if (Name.size() < 2)
600     return Error(Reg.StartLoc, "invalid register");
601   char Prefix = Name[0];
602 
603   // Treat the rest of the register name as a register number.
604   if (Name.substr(1).getAsInteger(10, Reg.Num))
605     return Error(Reg.StartLoc, "invalid register");
606 
607   // Look for valid combinations of prefix and number.
608   if (Prefix == 'r' && Reg.Num < 16)
609     Reg.Group = RegGR;
610   else if (Prefix == 'f' && Reg.Num < 16)
611     Reg.Group = RegFP;
612   else if (Prefix == 'v' && Reg.Num < 32)
613     Reg.Group = RegV;
614   else if (Prefix == 'a' && Reg.Num < 16)
615     Reg.Group = RegAccess;
616   else
617     return Error(Reg.StartLoc, "invalid register");
618 
619   Reg.EndLoc = Parser.getTok().getLoc();
620   Parser.Lex();
621   return false;
622 }
623 
624 // Parse a register of group Group.  If Regs is nonnull, use it to map
625 // the raw register number to LLVM numbering, with zero entries
626 // indicating an invalid register.  IsAddress says whether the
627 // register appears in an address context. Allow FP Group if expecting
628 // RegV Group, since the f-prefix yields the FP group even while used
629 // with vector instructions.
630 bool SystemZAsmParser::parseRegister(Register &Reg, RegisterGroup Group,
631                                      const unsigned *Regs, bool IsAddress) {
632   if (parseRegister(Reg))
633     return true;
634   if (Reg.Group != Group && !(Reg.Group == RegFP && Group == RegV))
635     return Error(Reg.StartLoc, "invalid operand for instruction");
636   if (Regs && Regs[Reg.Num] == 0)
637     return Error(Reg.StartLoc, "invalid register pair");
638   if (Reg.Num == 0 && IsAddress)
639     return Error(Reg.StartLoc, "%r0 used in an address");
640   if (Regs)
641     Reg.Num = Regs[Reg.Num];
642   return false;
643 }
644 
645 // Parse a register and add it to Operands.  The other arguments are as above.
646 SystemZAsmParser::OperandMatchResultTy
647 SystemZAsmParser::parseRegister(OperandVector &Operands, RegisterGroup Group,
648                                 const unsigned *Regs, RegisterKind Kind) {
649   if (Parser.getTok().isNot(AsmToken::Percent))
650     return MatchOperand_NoMatch;
651 
652   Register Reg;
653   bool IsAddress = (Kind == ADDR32Reg || Kind == ADDR64Reg);
654   if (parseRegister(Reg, Group, Regs, IsAddress))
655     return MatchOperand_ParseFail;
656 
657   Operands.push_back(SystemZOperand::createReg(Kind, Reg.Num,
658                                                Reg.StartLoc, Reg.EndLoc));
659   return MatchOperand_Success;
660 }
661 
662 // Parse any type of register (including integers) and add it to Operands.
663 SystemZAsmParser::OperandMatchResultTy
664 SystemZAsmParser::parseAnyRegister(OperandVector &Operands) {
665   // Handle integer values.
666   if (Parser.getTok().is(AsmToken::Integer)) {
667     const MCExpr *Register;
668     SMLoc StartLoc = Parser.getTok().getLoc();
669     if (Parser.parseExpression(Register))
670       return MatchOperand_ParseFail;
671 
672     if (auto *CE = dyn_cast<MCConstantExpr>(Register)) {
673       int64_t Value = CE->getValue();
674       if (Value < 0 || Value > 15) {
675         Error(StartLoc, "invalid register");
676         return MatchOperand_ParseFail;
677       }
678     }
679 
680     SMLoc EndLoc =
681       SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
682 
683     Operands.push_back(SystemZOperand::createImm(Register, StartLoc, EndLoc));
684   }
685   else {
686     Register Reg;
687     if (parseRegister(Reg))
688       return MatchOperand_ParseFail;
689 
690     // Map to the correct register kind.
691     RegisterKind Kind;
692     unsigned RegNo;
693     if (Reg.Group == RegGR) {
694       Kind = GR64Reg;
695       RegNo = SystemZMC::GR64Regs[Reg.Num];
696     }
697     else if (Reg.Group == RegFP) {
698       Kind = FP64Reg;
699       RegNo = SystemZMC::FP64Regs[Reg.Num];
700     }
701     else if (Reg.Group == RegV) {
702       Kind = VR128Reg;
703       RegNo = SystemZMC::VR128Regs[Reg.Num];
704     }
705     else {
706       return MatchOperand_ParseFail;
707     }
708 
709     Operands.push_back(SystemZOperand::createReg(Kind, RegNo,
710                                                  Reg.StartLoc, Reg.EndLoc));
711   }
712   return MatchOperand_Success;
713 }
714 
715 // Parse a memory operand into Base, Disp, Index and Length.
716 // Regs maps asm register numbers to LLVM register numbers and RegKind
717 // says what kind of address register we're using (ADDR32Reg or ADDR64Reg).
718 bool SystemZAsmParser::parseAddress(unsigned &Base, const MCExpr *&Disp,
719                                     unsigned &Index, bool &IsVector,
720                                     const MCExpr *&Length, const unsigned *Regs,
721                                     RegisterKind RegKind) {
722   // Parse the displacement, which must always be present.
723   if (getParser().parseExpression(Disp))
724     return true;
725 
726   // Parse the optional base and index.
727   Index = 0;
728   Base = 0;
729   IsVector = false;
730   Length = nullptr;
731   if (getLexer().is(AsmToken::LParen)) {
732     Parser.Lex();
733 
734     if (getLexer().is(AsmToken::Percent)) {
735       // Parse the first register and decide whether it's a base or an index.
736       Register Reg;
737       if (parseRegister(Reg))
738         return true;
739       if (Reg.Group == RegV) {
740         // A vector index register.  The base register is optional.
741         IsVector = true;
742         Index = SystemZMC::VR128Regs[Reg.Num];
743       } else if (Reg.Group == RegGR) {
744         if (Reg.Num == 0)
745           return Error(Reg.StartLoc, "%r0 used in an address");
746         // If the are two registers, the first one is the index and the
747         // second is the base.
748         if (getLexer().is(AsmToken::Comma))
749           Index = Regs[Reg.Num];
750         else
751           Base = Regs[Reg.Num];
752       } else
753         return Error(Reg.StartLoc, "invalid address register");
754     } else {
755       // Parse the length.
756       if (getParser().parseExpression(Length))
757         return true;
758     }
759 
760     // Check whether there's a second register.  It's the base if so.
761     if (getLexer().is(AsmToken::Comma)) {
762       Parser.Lex();
763       Register Reg;
764       if (parseRegister(Reg, RegGR, Regs, RegKind))
765         return true;
766       Base = Reg.Num;
767     }
768 
769     // Consume the closing bracket.
770     if (getLexer().isNot(AsmToken::RParen))
771       return Error(Parser.getTok().getLoc(), "unexpected token in address");
772     Parser.Lex();
773   }
774   return false;
775 }
776 
777 // Parse a memory operand and add it to Operands.  The other arguments
778 // are as above.
779 SystemZAsmParser::OperandMatchResultTy
780 SystemZAsmParser::parseAddress(OperandVector &Operands, MemoryKind MemKind,
781                                const unsigned *Regs, RegisterKind RegKind) {
782   SMLoc StartLoc = Parser.getTok().getLoc();
783   unsigned Base, Index;
784   bool IsVector;
785   const MCExpr *Disp;
786   const MCExpr *Length;
787   if (parseAddress(Base, Disp, Index, IsVector, Length, Regs, RegKind))
788     return MatchOperand_ParseFail;
789 
790   if (IsVector && MemKind != BDVMem) {
791     Error(StartLoc, "invalid use of vector addressing");
792     return MatchOperand_ParseFail;
793   }
794 
795   if (!IsVector && MemKind == BDVMem) {
796     Error(StartLoc, "vector index required in address");
797     return MatchOperand_ParseFail;
798   }
799 
800   if (Index && MemKind != BDXMem && MemKind != BDVMem) {
801     Error(StartLoc, "invalid use of indexed addressing");
802     return MatchOperand_ParseFail;
803   }
804 
805   if (Length && MemKind != BDLMem) {
806     Error(StartLoc, "invalid use of length addressing");
807     return MatchOperand_ParseFail;
808   }
809 
810   if (!Length && MemKind == BDLMem) {
811     Error(StartLoc, "missing length in address");
812     return MatchOperand_ParseFail;
813   }
814 
815   SMLoc EndLoc =
816     SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
817   Operands.push_back(SystemZOperand::createMem(MemKind, RegKind, Base, Disp,
818                                                Index, Length, StartLoc,
819                                                EndLoc));
820   return MatchOperand_Success;
821 }
822 
823 bool SystemZAsmParser::ParseDirective(AsmToken DirectiveID) {
824   StringRef IDVal = DirectiveID.getIdentifier();
825 
826   if (IDVal == ".insn")
827     return ParseDirectiveInsn(DirectiveID.getLoc());
828 
829   return true;
830 }
831 
832 /// ParseDirectiveInsn
833 /// ::= .insn [ format, encoding, (operands (, operands)*) ]
834 bool SystemZAsmParser::ParseDirectiveInsn(SMLoc L) {
835   MCAsmParser &Parser = getParser();
836 
837   // Expect instruction format as identifier.
838   StringRef Format;
839   SMLoc ErrorLoc = Parser.getTok().getLoc();
840   if (Parser.parseIdentifier(Format))
841     return Error(ErrorLoc, "expected instruction format");
842 
843   SmallVector<std::unique_ptr<MCParsedAsmOperand>, 8> Operands;
844 
845   // Find entry for this format in InsnMatchTable.
846   auto EntryRange =
847     std::equal_range(std::begin(InsnMatchTable), std::end(InsnMatchTable),
848                      Format, CompareInsn());
849 
850   // If first == second, couldn't find a match in the table.
851   if (EntryRange.first == EntryRange.second)
852     return Error(ErrorLoc, "unrecognized format");
853 
854   struct InsnMatchEntry *Entry = EntryRange.first;
855 
856   // Format should match from equal_range.
857   assert(Entry->Format == Format);
858 
859   // Parse the following operands using the table's information.
860   for (int i = 0; i < Entry->NumOperands; i++) {
861     MatchClassKind Kind = Entry->OperandKinds[i];
862 
863     SMLoc StartLoc = Parser.getTok().getLoc();
864 
865     // Always expect commas as separators for operands.
866     if (getLexer().isNot(AsmToken::Comma))
867       return Error(StartLoc, "unexpected token in directive");
868     Lex();
869 
870     // Parse operands.
871     OperandMatchResultTy ResTy;
872     if (Kind == MCK_AnyReg)
873       ResTy = parseAnyReg(Operands);
874     else if (Kind == MCK_BDXAddr64Disp12 || Kind == MCK_BDXAddr64Disp20)
875       ResTy = parseBDXAddr64(Operands);
876     else if (Kind == MCK_BDAddr64Disp12 || Kind == MCK_BDAddr64Disp20)
877       ResTy = parseBDAddr64(Operands);
878     else if (Kind == MCK_PCRel32)
879       ResTy = parsePCRel32(Operands);
880     else if (Kind == MCK_PCRel16)
881       ResTy = parsePCRel16(Operands);
882     else {
883       // Only remaining operand kind is an immediate.
884       const MCExpr *Expr;
885       SMLoc StartLoc = Parser.getTok().getLoc();
886 
887       // Expect immediate expression.
888       if (Parser.parseExpression(Expr))
889         return Error(StartLoc, "unexpected token in directive");
890 
891       SMLoc EndLoc =
892         SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
893 
894       Operands.push_back(SystemZOperand::createImm(Expr, StartLoc, EndLoc));
895       ResTy = MatchOperand_Success;
896     }
897 
898     if (ResTy != MatchOperand_Success)
899       return true;
900   }
901 
902   // Build the instruction with the parsed operands.
903   MCInst Inst = MCInstBuilder(Entry->Opcode);
904 
905   for (size_t i = 0; i < Operands.size(); i++) {
906     MCParsedAsmOperand &Operand = *Operands[i];
907     MatchClassKind Kind = Entry->OperandKinds[i];
908 
909     // Verify operand.
910     unsigned Res = validateOperandClass(Operand, Kind);
911     if (Res != Match_Success)
912       return Error(Operand.getStartLoc(), "unexpected operand type");
913 
914     // Add operands to instruction.
915     SystemZOperand &ZOperand = static_cast<SystemZOperand &>(Operand);
916     if (ZOperand.isReg())
917       ZOperand.addRegOperands(Inst, 1);
918     else if (ZOperand.isMem(BDMem))
919       ZOperand.addBDAddrOperands(Inst, 2);
920     else if (ZOperand.isMem(BDXMem))
921       ZOperand.addBDXAddrOperands(Inst, 3);
922     else if (ZOperand.isImm())
923       ZOperand.addImmOperands(Inst, 1);
924     else
925       llvm_unreachable("unexpected operand type");
926   }
927 
928   // Emit as a regular instruction.
929   Parser.getStreamer().EmitInstruction(Inst, getSTI());
930 
931   return false;
932 }
933 
934 bool SystemZAsmParser::ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
935                                      SMLoc &EndLoc) {
936   Register Reg;
937   if (parseRegister(Reg))
938     return true;
939   if (Reg.Group == RegGR)
940     RegNo = SystemZMC::GR64Regs[Reg.Num];
941   else if (Reg.Group == RegFP)
942     RegNo = SystemZMC::FP64Regs[Reg.Num];
943   else if (Reg.Group == RegV)
944     RegNo = SystemZMC::VR128Regs[Reg.Num];
945   else
946     // FIXME: Access registers aren't modelled as LLVM registers yet.
947     return Error(Reg.StartLoc, "invalid operand for instruction");
948   StartLoc = Reg.StartLoc;
949   EndLoc = Reg.EndLoc;
950   return false;
951 }
952 
953 bool SystemZAsmParser::ParseInstruction(ParseInstructionInfo &Info,
954                                         StringRef Name, SMLoc NameLoc,
955                                         OperandVector &Operands) {
956   Operands.push_back(SystemZOperand::createToken(Name, NameLoc));
957 
958   // Read the remaining operands.
959   if (getLexer().isNot(AsmToken::EndOfStatement)) {
960     // Read the first operand.
961     if (parseOperand(Operands, Name)) {
962       return true;
963     }
964 
965     // Read any subsequent operands.
966     while (getLexer().is(AsmToken::Comma)) {
967       Parser.Lex();
968       if (parseOperand(Operands, Name)) {
969         return true;
970       }
971     }
972     if (getLexer().isNot(AsmToken::EndOfStatement)) {
973       SMLoc Loc = getLexer().getLoc();
974       return Error(Loc, "unexpected token in argument list");
975     }
976   }
977 
978   // Consume the EndOfStatement.
979   Parser.Lex();
980   return false;
981 }
982 
983 bool SystemZAsmParser::parseOperand(OperandVector &Operands,
984                                     StringRef Mnemonic) {
985   // Check if the current operand has a custom associated parser, if so, try to
986   // custom parse the operand, or fallback to the general approach.
987   OperandMatchResultTy ResTy = MatchOperandParserImpl(Operands, Mnemonic);
988   if (ResTy == MatchOperand_Success)
989     return false;
990 
991   // If there wasn't a custom match, try the generic matcher below. Otherwise,
992   // there was a match, but an error occurred, in which case, just return that
993   // the operand parsing failed.
994   if (ResTy == MatchOperand_ParseFail)
995     return true;
996 
997   // Check for a register.  All real register operands should have used
998   // a context-dependent parse routine, which gives the required register
999   // class.  The code is here to mop up other cases, like those where
1000   // the instruction isn't recognized.
1001   if (Parser.getTok().is(AsmToken::Percent)) {
1002     Register Reg;
1003     if (parseRegister(Reg))
1004       return true;
1005     Operands.push_back(SystemZOperand::createInvalid(Reg.StartLoc, Reg.EndLoc));
1006     return false;
1007   }
1008 
1009   // The only other type of operand is an immediate or address.  As above,
1010   // real address operands should have used a context-dependent parse routine,
1011   // so we treat any plain expression as an immediate.
1012   SMLoc StartLoc = Parser.getTok().getLoc();
1013   unsigned Base, Index;
1014   bool IsVector;
1015   const MCExpr *Expr, *Length;
1016   if (parseAddress(Base, Expr, Index, IsVector, Length, SystemZMC::GR64Regs,
1017                    ADDR64Reg))
1018     return true;
1019 
1020   SMLoc EndLoc =
1021     SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1022   if (Base || Index || Length)
1023     Operands.push_back(SystemZOperand::createInvalid(StartLoc, EndLoc));
1024   else
1025     Operands.push_back(SystemZOperand::createImm(Expr, StartLoc, EndLoc));
1026   return false;
1027 }
1028 
1029 bool SystemZAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
1030                                                OperandVector &Operands,
1031                                                MCStreamer &Out,
1032                                                uint64_t &ErrorInfo,
1033                                                bool MatchingInlineAsm) {
1034   MCInst Inst;
1035   unsigned MatchResult;
1036 
1037   MatchResult = MatchInstructionImpl(Operands, Inst, ErrorInfo,
1038                                      MatchingInlineAsm);
1039   switch (MatchResult) {
1040   case Match_Success:
1041     Inst.setLoc(IDLoc);
1042     Out.EmitInstruction(Inst, getSTI());
1043     return false;
1044 
1045   case Match_MissingFeature: {
1046     assert(ErrorInfo && "Unknown missing feature!");
1047     // Special case the error message for the very common case where only
1048     // a single subtarget feature is missing
1049     std::string Msg = "instruction requires:";
1050     uint64_t Mask = 1;
1051     for (unsigned I = 0; I < sizeof(ErrorInfo) * 8 - 1; ++I) {
1052       if (ErrorInfo & Mask) {
1053         Msg += " ";
1054         Msg += getSubtargetFeatureName(ErrorInfo & Mask);
1055       }
1056       Mask <<= 1;
1057     }
1058     return Error(IDLoc, Msg);
1059   }
1060 
1061   case Match_InvalidOperand: {
1062     SMLoc ErrorLoc = IDLoc;
1063     if (ErrorInfo != ~0ULL) {
1064       if (ErrorInfo >= Operands.size())
1065         return Error(IDLoc, "too few operands for instruction");
1066 
1067       ErrorLoc = ((SystemZOperand &)*Operands[ErrorInfo]).getStartLoc();
1068       if (ErrorLoc == SMLoc())
1069         ErrorLoc = IDLoc;
1070     }
1071     return Error(ErrorLoc, "invalid operand for instruction");
1072   }
1073 
1074   case Match_MnemonicFail:
1075     return Error(IDLoc, "invalid instruction");
1076   }
1077 
1078   llvm_unreachable("Unexpected match type");
1079 }
1080 
1081 SystemZAsmParser::OperandMatchResultTy
1082 SystemZAsmParser::parseAccessReg(OperandVector &Operands) {
1083   if (Parser.getTok().isNot(AsmToken::Percent))
1084     return MatchOperand_NoMatch;
1085 
1086   Register Reg;
1087   if (parseRegister(Reg, RegAccess, nullptr))
1088     return MatchOperand_ParseFail;
1089 
1090   Operands.push_back(SystemZOperand::createAccessReg(Reg.Num,
1091                                                      Reg.StartLoc,
1092                                                      Reg.EndLoc));
1093   return MatchOperand_Success;
1094 }
1095 
1096 SystemZAsmParser::OperandMatchResultTy
1097 SystemZAsmParser::parsePCRel(OperandVector &Operands, int64_t MinVal,
1098                              int64_t MaxVal, bool AllowTLS) {
1099   MCContext &Ctx = getContext();
1100   MCStreamer &Out = getStreamer();
1101   const MCExpr *Expr;
1102   SMLoc StartLoc = Parser.getTok().getLoc();
1103   if (getParser().parseExpression(Expr))
1104     return MatchOperand_NoMatch;
1105 
1106   // For consistency with the GNU assembler, treat immediates as offsets
1107   // from ".".
1108   if (auto *CE = dyn_cast<MCConstantExpr>(Expr)) {
1109     int64_t Value = CE->getValue();
1110     if ((Value & 1) || Value < MinVal || Value > MaxVal) {
1111       Error(StartLoc, "offset out of range");
1112       return MatchOperand_ParseFail;
1113     }
1114     MCSymbol *Sym = Ctx.createTempSymbol();
1115     Out.EmitLabel(Sym);
1116     const MCExpr *Base = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None,
1117                                                  Ctx);
1118     Expr = Value == 0 ? Base : MCBinaryExpr::createAdd(Base, Expr, Ctx);
1119   }
1120 
1121   // Optionally match :tls_gdcall: or :tls_ldcall: followed by a TLS symbol.
1122   const MCExpr *Sym = nullptr;
1123   if (AllowTLS && getLexer().is(AsmToken::Colon)) {
1124     Parser.Lex();
1125 
1126     if (Parser.getTok().isNot(AsmToken::Identifier)) {
1127       Error(Parser.getTok().getLoc(), "unexpected token");
1128       return MatchOperand_ParseFail;
1129     }
1130 
1131     MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;
1132     StringRef Name = Parser.getTok().getString();
1133     if (Name == "tls_gdcall")
1134       Kind = MCSymbolRefExpr::VK_TLSGD;
1135     else if (Name == "tls_ldcall")
1136       Kind = MCSymbolRefExpr::VK_TLSLDM;
1137     else {
1138       Error(Parser.getTok().getLoc(), "unknown TLS tag");
1139       return MatchOperand_ParseFail;
1140     }
1141     Parser.Lex();
1142 
1143     if (Parser.getTok().isNot(AsmToken::Colon)) {
1144       Error(Parser.getTok().getLoc(), "unexpected token");
1145       return MatchOperand_ParseFail;
1146     }
1147     Parser.Lex();
1148 
1149     if (Parser.getTok().isNot(AsmToken::Identifier)) {
1150       Error(Parser.getTok().getLoc(), "unexpected token");
1151       return MatchOperand_ParseFail;
1152     }
1153 
1154     StringRef Identifier = Parser.getTok().getString();
1155     Sym = MCSymbolRefExpr::create(Ctx.getOrCreateSymbol(Identifier),
1156                                   Kind, Ctx);
1157     Parser.Lex();
1158   }
1159 
1160   SMLoc EndLoc =
1161     SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
1162 
1163   if (AllowTLS)
1164     Operands.push_back(SystemZOperand::createImmTLS(Expr, Sym,
1165                                                     StartLoc, EndLoc));
1166   else
1167     Operands.push_back(SystemZOperand::createImm(Expr, StartLoc, EndLoc));
1168 
1169   return MatchOperand_Success;
1170 }
1171 
1172 // Force static initialization.
1173 extern "C" void LLVMInitializeSystemZAsmParser() {
1174   RegisterMCAsmParser<SystemZAsmParser> X(getTheSystemZTarget());
1175 }
1176