1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Assembly Matcher Source Fragment *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* From: MSP430.td *|
7|* *|
8\*===----------------------------------------------------------------------===*/
9
10
11#ifdef GET_ASSEMBLER_HEADER
12#undef GET_ASSEMBLER_HEADER
13 // This should be included into the middle of the declaration of
14 // your subclasses implementation of MCTargetAsmParser.
15 FeatureBitset ComputeAvailableFeatures(const FeatureBitset &FB) const;
16 void convertToMCInst(unsigned Kind, MCInst &Inst, unsigned Opcode,
17 const OperandVector &Operands);
18 void convertToMapAndConstraints(unsigned Kind,
19 const OperandVector &Operands) override;
20 unsigned MatchInstructionImpl(const OperandVector &Operands,
21 MCInst &Inst,
22 uint64_t &ErrorInfo,
23 FeatureBitset &MissingFeatures,
24 bool matchingInlineAsm,
25 unsigned VariantID = 0);
26 unsigned MatchInstructionImpl(const OperandVector &Operands,
27 MCInst &Inst,
28 uint64_t &ErrorInfo,
29 bool matchingInlineAsm,
30 unsigned VariantID = 0) {
31 FeatureBitset MissingFeatures;
32 return MatchInstructionImpl(Operands, Inst, ErrorInfo, MissingFeatures,
33 matchingInlineAsm, VariantID);
34 }
35
36#endif // GET_ASSEMBLER_HEADER
37
38
39#ifdef GET_OPERAND_DIAGNOSTIC_TYPES
40#undef GET_OPERAND_DIAGNOSTIC_TYPES
41
42#endif // GET_OPERAND_DIAGNOSTIC_TYPES
43
44
45#ifdef GET_REGISTER_MATCHER
46#undef GET_REGISTER_MATCHER
47
48// Bits for subtarget features that participate in instruction matching.
49enum SubtargetFeatureBits : uint8_t {
50};
51
52[[maybe_unused]] static MCRegister MatchRegisterName(StringRef Name) {
53 switch (Name.size()) {
54 default: break;
55 case 2: // 20 strings to match.
56 if (Name[0] != 'r')
57 break;
58 switch (Name[1]) {
59 default: break;
60 case '0': // 2 strings to match.
61 return MSP430::PC; // "r0"
62 case '1': // 2 strings to match.
63 return MSP430::SP; // "r1"
64 case '2': // 2 strings to match.
65 return MSP430::SR; // "r2"
66 case '3': // 2 strings to match.
67 return MSP430::CG; // "r3"
68 case '4': // 2 strings to match.
69 return MSP430::R4; // "r4"
70 case '5': // 2 strings to match.
71 return MSP430::R5; // "r5"
72 case '6': // 2 strings to match.
73 return MSP430::R6; // "r6"
74 case '7': // 2 strings to match.
75 return MSP430::R7; // "r7"
76 case '8': // 2 strings to match.
77 return MSP430::R8; // "r8"
78 case '9': // 2 strings to match.
79 return MSP430::R9; // "r9"
80 }
81 break;
82 case 3: // 12 strings to match.
83 if (memcmp(Name.data()+0, "r1", 2) != 0)
84 break;
85 switch (Name[2]) {
86 default: break;
87 case '0': // 2 strings to match.
88 return MSP430::R10; // "r10"
89 case '1': // 2 strings to match.
90 return MSP430::R11; // "r11"
91 case '2': // 2 strings to match.
92 return MSP430::R12; // "r12"
93 case '3': // 2 strings to match.
94 return MSP430::R13; // "r13"
95 case '4': // 2 strings to match.
96 return MSP430::R14; // "r14"
97 case '5': // 2 strings to match.
98 return MSP430::R15; // "r15"
99 }
100 break;
101 }
102 return MSP430::NoRegister;
103}
104
105[[maybe_unused]] static MCRegister MatchRegisterAltName(StringRef Name) {
106 switch (Name.size()) {
107 default: break;
108 case 2: // 10 strings to match.
109 switch (Name[0]) {
110 default: break;
111 case 'c': // 2 strings to match.
112 if (Name[1] != 'g')
113 break;
114 return MSP430::CG; // "cg"
115 case 'f': // 2 strings to match.
116 if (Name[1] != 'p')
117 break;
118 return MSP430::R4; // "fp"
119 case 'p': // 2 strings to match.
120 if (Name[1] != 'c')
121 break;
122 return MSP430::PC; // "pc"
123 case 's': // 4 strings to match.
124 switch (Name[1]) {
125 default: break;
126 case 'p': // 2 strings to match.
127 return MSP430::SP; // "sp"
128 case 'r': // 2 strings to match.
129 return MSP430::SR; // "sr"
130 }
131 break;
132 }
133 break;
134 }
135 return MSP430::NoRegister;
136}
137
138#endif // GET_REGISTER_MATCHER
139
140
141#ifdef GET_SUBTARGET_FEATURE_NAME
142#undef GET_SUBTARGET_FEATURE_NAME
143
144// User-level names for subtarget features that participate in
145// instruction matching.
146static const char *getSubtargetFeatureName(uint64_t Val) {
147 return "(unknown)";
148}
149
150#endif // GET_SUBTARGET_FEATURE_NAME
151
152
153#ifdef GET_MATCHER_IMPLEMENTATION
154#undef GET_MATCHER_IMPLEMENTATION
155
156enum {
157 Tie0_1_1,
158 Tie1_1_1,
159};
160
161static const uint8_t TiedAsmOperandTable[][3] = {
162 /* Tie0_1_1 */ { 0, 1, 1 },
163 /* Tie1_1_1 */ { 1, 1, 1 },
164};
165
166namespace {
167enum OperatorConversionKind {
168 CVT_Done,
169 CVT_Reg,
170 CVT_Tied,
171 CVT_95_Reg,
172 CVT_imm_95_0,
173 CVT_95_addMemOperands,
174 CVT_95_convertToGR8,
175 CVT_95_addImmOperands,
176 CVT_95_addRegOperands,
177 CVT_regSR,
178 CVT_imm_95_1,
179 CVT_imm_95_4,
180 CVT_imm_95_2,
181 CVT_imm_95_8,
182 CVT_imm_95__MINUS_1,
183 CVT_regCG,
184 CVT_NUM_CONVERTERS
185};
186
187enum InstructionConversionKind {
188 Convert__Reg1_0__Tie0_1_1__imm_95_0,
189 Convert__Mem2_0__imm_95_0,
190 Convert__GR81_0__Tie0_1_1__imm_95_0,
191 Convert__Reg1_1__Tie0_1_1__Reg1_0,
192 Convert__Mem2_1__Reg1_0,
193 Convert__Reg1_1__Tie0_1_1__CGImm1_0,
194 Convert__Mem2_1__CGImm1_0,
195 Convert__Reg1_1__Tie0_1_1__Imm1_0,
196 Convert__Mem2_1__Imm1_0,
197 Convert__Reg1_1__Tie0_1_1__IndReg1_0,
198 Convert__Mem2_1__IndReg1_0,
199 Convert__Reg1_1__Tie0_1_1__Mem2_0,
200 Convert__Mem2_1__Mem2_0,
201 Convert__Reg1_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1,
202 Convert__Mem2_1__PostIndReg1_0,
203 Convert__GR81_1__Tie0_1_1__GR81_0,
204 Convert__Mem2_1__GR81_0,
205 Convert__GR81_1__Tie0_1_1__CGImm1_0,
206 Convert__GR81_1__Tie0_1_1__Imm1_0,
207 Convert__GR81_1__Tie0_1_1__IndReg1_0,
208 Convert__GR81_1__Tie0_1_1__Mem2_0,
209 Convert__GR81_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1,
210 Convert__Reg1_1__Reg1_0,
211 Convert__Reg1_1__CGImm1_0,
212 Convert__Reg1_1__Imm1_0,
213 Convert__Reg1_1__IndReg1_0,
214 Convert__Reg1_1__Mem2_0,
215 Convert__Reg1_1__PostIndReg1_0,
216 Convert__GR81_1__GR81_0,
217 Convert__GR81_1__CGImm1_0,
218 Convert__GR81_1__Imm1_0,
219 Convert__GR81_1__IndReg1_0,
220 Convert__GR81_1__Mem2_0,
221 Convert__GR81_1__PostIndReg1_0,
222 Convert__Reg1_0,
223 Convert__Imm1_0,
224 Convert__Mem2_0,
225 Convert__IndReg1_0,
226 Convert__PostIndReg1_0,
227 Convert__Reg1_0__imm_95_0,
228 Convert__GR81_0__imm_95_0,
229 Convert__regSR__Tie0_1_1__imm_95_1,
230 Convert__regSR__Tie0_1_1__imm_95_4,
231 Convert__regSR__Tie0_1_1__imm_95_2,
232 Convert__Reg1_0__Tie0_1_1__imm_95_1,
233 Convert__Mem2_0__imm_95_1,
234 Convert__GR81_0__Tie0_1_1__imm_95_1,
235 Convert__Reg1_0__Tie0_1_1__imm_95_2,
236 Convert__Mem2_0__imm_95_2,
237 Convert__GR81_0__Tie0_1_1__imm_95_2,
238 Convert__regSR__Tie0_1_1__imm_95_8,
239 Convert__Reg1_0__Tie0_1_1__imm_95__MINUS_1,
240 Convert__Mem2_0__imm_95__MINUS_1,
241 Convert__GR81_0__Tie0_1_1__imm_95__MINUS_1,
242 Convert__Imm1_1__Imm1_0,
243 Convert__Reg1_1__PostIndReg1_0__Tie1_1_1,
244 Convert__GR81_1__PostIndReg1_0__Tie1_1_1,
245 Convert__regCG__imm_95_0,
246 Convert__CGImm1_0,
247 Convert__GR81_0,
248 Convert_NoOperands,
249 Convert__Reg1_0__Tie0_1_1__Reg1_0,
250 Convert__Mem2_0__Mem2_0,
251 Convert__GR81_0__Tie0_1_1__GR81_0,
252 Convert__Reg1_0__Tie0_1_1,
253 Convert__GR81_0__Tie0_1_1,
254 CVT_NUM_SIGNATURES
255};
256
257} // end anonymous namespace
258
259static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][9] = {
260 // Convert__Reg1_0__Tie0_1_1__imm_95_0
261 { CVT_95_Reg, 1, CVT_Tied, Tie0_1_1, CVT_imm_95_0, 0, CVT_Done },
262 // Convert__Mem2_0__imm_95_0
263 { CVT_95_addMemOperands, 1, CVT_imm_95_0, 0, CVT_Done },
264 // Convert__GR81_0__Tie0_1_1__imm_95_0
265 { CVT_95_convertToGR8, 1, CVT_Tied, Tie0_1_1, CVT_imm_95_0, 0, CVT_Done },
266 // Convert__Reg1_1__Tie0_1_1__Reg1_0
267 { CVT_95_Reg, 2, CVT_Tied, Tie0_1_1, CVT_95_Reg, 1, CVT_Done },
268 // Convert__Mem2_1__Reg1_0
269 { CVT_95_addMemOperands, 2, CVT_95_Reg, 1, CVT_Done },
270 // Convert__Reg1_1__Tie0_1_1__CGImm1_0
271 { CVT_95_Reg, 2, CVT_Tied, Tie0_1_1, CVT_95_addImmOperands, 1, CVT_Done },
272 // Convert__Mem2_1__CGImm1_0
273 { CVT_95_addMemOperands, 2, CVT_95_addImmOperands, 1, CVT_Done },
274 // Convert__Reg1_1__Tie0_1_1__Imm1_0
275 { CVT_95_Reg, 2, CVT_Tied, Tie0_1_1, CVT_95_addImmOperands, 1, CVT_Done },
276 // Convert__Mem2_1__Imm1_0
277 { CVT_95_addMemOperands, 2, CVT_95_addImmOperands, 1, CVT_Done },
278 // Convert__Reg1_1__Tie0_1_1__IndReg1_0
279 { CVT_95_Reg, 2, CVT_Tied, Tie0_1_1, CVT_95_addRegOperands, 1, CVT_Done },
280 // Convert__Mem2_1__IndReg1_0
281 { CVT_95_addMemOperands, 2, CVT_95_addRegOperands, 1, CVT_Done },
282 // Convert__Reg1_1__Tie0_1_1__Mem2_0
283 { CVT_95_Reg, 2, CVT_Tied, Tie0_1_1, CVT_95_addMemOperands, 1, CVT_Done },
284 // Convert__Mem2_1__Mem2_0
285 { CVT_95_addMemOperands, 2, CVT_95_addMemOperands, 1, CVT_Done },
286 // Convert__Reg1_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1
287 { CVT_95_Reg, 2, CVT_95_addRegOperands, 1, CVT_Tied, Tie0_1_1, CVT_Tied, Tie1_1_1, CVT_Done },
288 // Convert__Mem2_1__PostIndReg1_0
289 { CVT_95_addMemOperands, 2, CVT_95_addRegOperands, 1, CVT_Done },
290 // Convert__GR81_1__Tie0_1_1__GR81_0
291 { CVT_95_convertToGR8, 2, CVT_Tied, Tie0_1_1, CVT_95_convertToGR8, 1, CVT_Done },
292 // Convert__Mem2_1__GR81_0
293 { CVT_95_addMemOperands, 2, CVT_95_convertToGR8, 1, CVT_Done },
294 // Convert__GR81_1__Tie0_1_1__CGImm1_0
295 { CVT_95_convertToGR8, 2, CVT_Tied, Tie0_1_1, CVT_95_addImmOperands, 1, CVT_Done },
296 // Convert__GR81_1__Tie0_1_1__Imm1_0
297 { CVT_95_convertToGR8, 2, CVT_Tied, Tie0_1_1, CVT_95_addImmOperands, 1, CVT_Done },
298 // Convert__GR81_1__Tie0_1_1__IndReg1_0
299 { CVT_95_convertToGR8, 2, CVT_Tied, Tie0_1_1, CVT_95_addRegOperands, 1, CVT_Done },
300 // Convert__GR81_1__Tie0_1_1__Mem2_0
301 { CVT_95_convertToGR8, 2, CVT_Tied, Tie0_1_1, CVT_95_addMemOperands, 1, CVT_Done },
302 // Convert__GR81_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1
303 { CVT_95_convertToGR8, 2, CVT_95_addRegOperands, 1, CVT_Tied, Tie0_1_1, CVT_Tied, Tie1_1_1, CVT_Done },
304 // Convert__Reg1_1__Reg1_0
305 { CVT_95_Reg, 2, CVT_95_Reg, 1, CVT_Done },
306 // Convert__Reg1_1__CGImm1_0
307 { CVT_95_Reg, 2, CVT_95_addImmOperands, 1, CVT_Done },
308 // Convert__Reg1_1__Imm1_0
309 { CVT_95_Reg, 2, CVT_95_addImmOperands, 1, CVT_Done },
310 // Convert__Reg1_1__IndReg1_0
311 { CVT_95_Reg, 2, CVT_95_addRegOperands, 1, CVT_Done },
312 // Convert__Reg1_1__Mem2_0
313 { CVT_95_Reg, 2, CVT_95_addMemOperands, 1, CVT_Done },
314 // Convert__Reg1_1__PostIndReg1_0
315 { CVT_95_Reg, 2, CVT_95_addRegOperands, 1, CVT_Done },
316 // Convert__GR81_1__GR81_0
317 { CVT_95_convertToGR8, 2, CVT_95_convertToGR8, 1, CVT_Done },
318 // Convert__GR81_1__CGImm1_0
319 { CVT_95_convertToGR8, 2, CVT_95_addImmOperands, 1, CVT_Done },
320 // Convert__GR81_1__Imm1_0
321 { CVT_95_convertToGR8, 2, CVT_95_addImmOperands, 1, CVT_Done },
322 // Convert__GR81_1__IndReg1_0
323 { CVT_95_convertToGR8, 2, CVT_95_addRegOperands, 1, CVT_Done },
324 // Convert__GR81_1__Mem2_0
325 { CVT_95_convertToGR8, 2, CVT_95_addMemOperands, 1, CVT_Done },
326 // Convert__GR81_1__PostIndReg1_0
327 { CVT_95_convertToGR8, 2, CVT_95_addRegOperands, 1, CVT_Done },
328 // Convert__Reg1_0
329 { CVT_95_Reg, 1, CVT_Done },
330 // Convert__Imm1_0
331 { CVT_95_addImmOperands, 1, CVT_Done },
332 // Convert__Mem2_0
333 { CVT_95_addMemOperands, 1, CVT_Done },
334 // Convert__IndReg1_0
335 { CVT_95_addRegOperands, 1, CVT_Done },
336 // Convert__PostIndReg1_0
337 { CVT_95_addRegOperands, 1, CVT_Done },
338 // Convert__Reg1_0__imm_95_0
339 { CVT_95_Reg, 1, CVT_imm_95_0, 0, CVT_Done },
340 // Convert__GR81_0__imm_95_0
341 { CVT_95_convertToGR8, 1, CVT_imm_95_0, 0, CVT_Done },
342 // Convert__regSR__Tie0_1_1__imm_95_1
343 { CVT_regSR, 0, CVT_Tied, Tie0_1_1, CVT_imm_95_1, 0, CVT_Done },
344 // Convert__regSR__Tie0_1_1__imm_95_4
345 { CVT_regSR, 0, CVT_Tied, Tie0_1_1, CVT_imm_95_4, 0, CVT_Done },
346 // Convert__regSR__Tie0_1_1__imm_95_2
347 { CVT_regSR, 0, CVT_Tied, Tie0_1_1, CVT_imm_95_2, 0, CVT_Done },
348 // Convert__Reg1_0__Tie0_1_1__imm_95_1
349 { CVT_95_Reg, 1, CVT_Tied, Tie0_1_1, CVT_imm_95_1, 0, CVT_Done },
350 // Convert__Mem2_0__imm_95_1
351 { CVT_95_addMemOperands, 1, CVT_imm_95_1, 0, CVT_Done },
352 // Convert__GR81_0__Tie0_1_1__imm_95_1
353 { CVT_95_convertToGR8, 1, CVT_Tied, Tie0_1_1, CVT_imm_95_1, 0, CVT_Done },
354 // Convert__Reg1_0__Tie0_1_1__imm_95_2
355 { CVT_95_Reg, 1, CVT_Tied, Tie0_1_1, CVT_imm_95_2, 0, CVT_Done },
356 // Convert__Mem2_0__imm_95_2
357 { CVT_95_addMemOperands, 1, CVT_imm_95_2, 0, CVT_Done },
358 // Convert__GR81_0__Tie0_1_1__imm_95_2
359 { CVT_95_convertToGR8, 1, CVT_Tied, Tie0_1_1, CVT_imm_95_2, 0, CVT_Done },
360 // Convert__regSR__Tie0_1_1__imm_95_8
361 { CVT_regSR, 0, CVT_Tied, Tie0_1_1, CVT_imm_95_8, 0, CVT_Done },
362 // Convert__Reg1_0__Tie0_1_1__imm_95__MINUS_1
363 { CVT_95_Reg, 1, CVT_Tied, Tie0_1_1, CVT_imm_95__MINUS_1, 0, CVT_Done },
364 // Convert__Mem2_0__imm_95__MINUS_1
365 { CVT_95_addMemOperands, 1, CVT_imm_95__MINUS_1, 0, CVT_Done },
366 // Convert__GR81_0__Tie0_1_1__imm_95__MINUS_1
367 { CVT_95_convertToGR8, 1, CVT_Tied, Tie0_1_1, CVT_imm_95__MINUS_1, 0, CVT_Done },
368 // Convert__Imm1_1__Imm1_0
369 { CVT_95_addImmOperands, 2, CVT_95_addImmOperands, 1, CVT_Done },
370 // Convert__Reg1_1__PostIndReg1_0__Tie1_1_1
371 { CVT_95_Reg, 2, CVT_95_addRegOperands, 1, CVT_Tied, Tie1_1_1, CVT_Done },
372 // Convert__GR81_1__PostIndReg1_0__Tie1_1_1
373 { CVT_95_convertToGR8, 2, CVT_95_addRegOperands, 1, CVT_Tied, Tie1_1_1, CVT_Done },
374 // Convert__regCG__imm_95_0
375 { CVT_regCG, 0, CVT_imm_95_0, 0, CVT_Done },
376 // Convert__CGImm1_0
377 { CVT_95_addImmOperands, 1, CVT_Done },
378 // Convert__GR81_0
379 { CVT_95_convertToGR8, 1, CVT_Done },
380 // Convert_NoOperands
381 { CVT_Done },
382 // Convert__Reg1_0__Tie0_1_1__Reg1_0
383 { CVT_95_Reg, 1, CVT_Tied, Tie0_1_1, CVT_95_Reg, 1, CVT_Done },
384 // Convert__Mem2_0__Mem2_0
385 { CVT_95_addMemOperands, 1, CVT_95_addMemOperands, 1, CVT_Done },
386 // Convert__GR81_0__Tie0_1_1__GR81_0
387 { CVT_95_convertToGR8, 1, CVT_Tied, Tie0_1_1, CVT_95_convertToGR8, 1, CVT_Done },
388 // Convert__Reg1_0__Tie0_1_1
389 { CVT_95_Reg, 1, CVT_Tied, Tie0_1_1, CVT_Done },
390 // Convert__GR81_0__Tie0_1_1
391 { CVT_95_convertToGR8, 1, CVT_Tied, Tie0_1_1, CVT_Done },
392};
393
394static MCRegister convertToGR8(MCRegister Reg) {
395 switch (Reg.id()) {
396 case MSP430::CG: return MSP430::CGB;
397 case MSP430::PC: return MSP430::PCB;
398 case MSP430::SP: return MSP430::SPB;
399 case MSP430::SR: return MSP430::SRB;
400 case MSP430::R4: return MSP430::R4B;
401 case MSP430::R5: return MSP430::R5B;
402 case MSP430::R6: return MSP430::R6B;
403 case MSP430::R7: return MSP430::R7B;
404 case MSP430::R8: return MSP430::R8B;
405 case MSP430::R9: return MSP430::R9B;
406 case MSP430::R10: return MSP430::R10B;
407 case MSP430::R11: return MSP430::R11B;
408 case MSP430::R12: return MSP430::R12B;
409 case MSP430::R13: return MSP430::R13B;
410 case MSP430::R14: return MSP430::R14B;
411 case MSP430::R15: return MSP430::R15B;
412 default: llvm_unreachable("unexpected register");
413 }
414}
415
416void MSP430AsmParser::
417convertToMCInst(unsigned Kind, MCInst &Inst, unsigned Opcode,
418 const OperandVector &Operands) {
419 assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
420 const uint8_t *Converter = ConversionTable[Kind];
421 Inst.setOpcode(Opcode);
422 for (const uint8_t *p = Converter; *p; p += 2) {
423 unsigned OpIdx = *(p + 1);
424 switch (*p) {
425 default: llvm_unreachable("invalid conversion entry!");
426 case CVT_Reg:
427 static_cast<MSP430Operand &>(*Operands[OpIdx]).addRegOperands(Inst, 1);
428 break;
429 case CVT_Tied: {
430 assert(*(p + 1) < (size_t)(std::end(TiedAsmOperandTable) -
431 std::begin(TiedAsmOperandTable)) &&
432 "Tied operand not found");
433 unsigned TiedResOpnd = TiedAsmOperandTable[*(p + 1)][0];
434 if (TiedResOpnd != (uint8_t)-1)
435 Inst.addOperand(Inst.getOperand(TiedResOpnd));
436 break;
437 }
438 case CVT_95_Reg:
439 static_cast<MSP430Operand &>(*Operands[OpIdx]).addRegOperands(Inst, 1);
440 break;
441 case CVT_imm_95_0:
442 Inst.addOperand(MCOperand::createImm(0));
443 break;
444 case CVT_95_addMemOperands:
445 static_cast<MSP430Operand &>(*Operands[OpIdx]).addMemOperands(Inst, 2);
446 break;
447 case CVT_95_convertToGR8: {
448 MCRegister Reg = Operands[OpIdx]->getReg();
449 if (!getMSP430MCRegisterClass(MSP430::GR8RegClassID).contains(Reg))
450 Reg = convertToGR8(Reg);
451 Inst.addOperand(MCOperand::createReg(Reg));
452 break;
453 }
454 case CVT_95_addImmOperands:
455 static_cast<MSP430Operand &>(*Operands[OpIdx]).addImmOperands(Inst, 1);
456 break;
457 case CVT_95_addRegOperands:
458 static_cast<MSP430Operand &>(*Operands[OpIdx]).addRegOperands(Inst, 1);
459 break;
460 case CVT_regSR:
461 Inst.addOperand(MCOperand::createReg(MSP430::SR));
462 break;
463 case CVT_imm_95_1:
464 Inst.addOperand(MCOperand::createImm(1));
465 break;
466 case CVT_imm_95_4:
467 Inst.addOperand(MCOperand::createImm(4));
468 break;
469 case CVT_imm_95_2:
470 Inst.addOperand(MCOperand::createImm(2));
471 break;
472 case CVT_imm_95_8:
473 Inst.addOperand(MCOperand::createImm(8));
474 break;
475 case CVT_imm_95__MINUS_1:
476 Inst.addOperand(MCOperand::createImm(-1));
477 break;
478 case CVT_regCG:
479 Inst.addOperand(MCOperand::createReg(MSP430::CG));
480 break;
481 }
482 }
483}
484
485void MSP430AsmParser::
486convertToMapAndConstraints(unsigned Kind,
487 const OperandVector &Operands) {
488 assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
489 unsigned NumMCOperands = 0;
490 const uint8_t *Converter = ConversionTable[Kind];
491 for (const uint8_t *p = Converter; *p; p += 2) {
492 switch (*p) {
493 default: llvm_unreachable("invalid conversion entry!");
494 case CVT_Reg:
495 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
496 Operands[*(p + 1)]->setConstraint("r");
497 ++NumMCOperands;
498 break;
499 case CVT_Tied:
500 ++NumMCOperands;
501 break;
502 case CVT_95_Reg:
503 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
504 Operands[*(p + 1)]->setConstraint("r");
505 NumMCOperands += 1;
506 break;
507 case CVT_imm_95_0:
508 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
509 Operands[*(p + 1)]->setConstraint("");
510 ++NumMCOperands;
511 break;
512 case CVT_95_addMemOperands:
513 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
514 Operands[*(p + 1)]->setConstraint("m");
515 NumMCOperands += 2;
516 break;
517 case CVT_95_convertToGR8:
518 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
519 Operands[*(p + 1)]->setConstraint("r");
520 NumMCOperands += 1;
521 break;
522 case CVT_95_addImmOperands:
523 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
524 Operands[*(p + 1)]->setConstraint("m");
525 NumMCOperands += 1;
526 break;
527 case CVT_95_addRegOperands:
528 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
529 Operands[*(p + 1)]->setConstraint("m");
530 NumMCOperands += 1;
531 break;
532 case CVT_regSR:
533 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
534 Operands[*(p + 1)]->setConstraint("m");
535 ++NumMCOperands;
536 break;
537 case CVT_imm_95_1:
538 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
539 Operands[*(p + 1)]->setConstraint("");
540 ++NumMCOperands;
541 break;
542 case CVT_imm_95_4:
543 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
544 Operands[*(p + 1)]->setConstraint("");
545 ++NumMCOperands;
546 break;
547 case CVT_imm_95_2:
548 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
549 Operands[*(p + 1)]->setConstraint("");
550 ++NumMCOperands;
551 break;
552 case CVT_imm_95_8:
553 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
554 Operands[*(p + 1)]->setConstraint("");
555 ++NumMCOperands;
556 break;
557 case CVT_imm_95__MINUS_1:
558 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
559 Operands[*(p + 1)]->setConstraint("");
560 ++NumMCOperands;
561 break;
562 case CVT_regCG:
563 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
564 Operands[*(p + 1)]->setConstraint("m");
565 ++NumMCOperands;
566 break;
567 }
568 }
569}
570
571namespace {
572
573/// MatchClassKind - The kinds of classes which participate in
574/// instruction matching.
575enum MatchClassKind {
576 InvalidMatchClass = 0,
577 OptionalMatchClass = 1,
578 MCK_LAST_TOKEN = OptionalMatchClass,
579 MCK_GR16, // register class 'GR16'
580 MCK_GR8, // register class 'GR8'
581 MCK_LAST_REGISTER = MCK_GR8,
582 MCK_CGImm, // user defined class 'CGImmAsmOperand'
583 MCK_Imm, // user defined class 'ImmAsmOperand'
584 MCK_IndReg, // user defined class 'IndRegAsmOperand'
585 MCK_Mem, // user defined class 'MemAsmOperand'
586 MCK_PostIndReg, // user defined class 'PostIndRegAsmOperand'
587 NumMatchClassKinds
588};
589
590} // end anonymous namespace
591
592static unsigned getDiagKindFromRegisterClass(MatchClassKind RegisterClass) {
593 return MCTargetAsmParser::Match_InvalidOperand;
594}
595
596[[maybe_unused]] static const MCRegisterClass *getRegClassFromMatchKind(MatchClassKind Kind) {
597 switch (Kind) {
598 case MCK_GR16:
599 return &getMSP430MCRegisterClass(MSP430::GR16RegClassID);
600 case MCK_GR8:
601 return &getMSP430MCRegisterClass(MSP430::GR8RegClassID);
602 default:
603 return nullptr;
604 }
605}
606
607static MatchClassKind matchTokenString(StringRef Name) {
608 return InvalidMatchClass;
609}
610
611/// isSubclass - Compute whether \p A is a subclass of \p B.
612static bool isSubclass(MatchClassKind A, MatchClassKind B) {
613 if (A == B)
614 return true;
615
616 [[maybe_unused]] static constexpr struct {
617 uint32_t Offset;
618 uint16_t Start;
619 uint16_t Length;
620 } Table[] = {
621 {0, 0, 0},
622 {0, 0, 0},
623 {0, 3, 1},
624 {1, 0, 0},
625 {1, 0, 0},
626 {1, 0, 0},
627 {1, 0, 0},
628 {1, 0, 0},
629 {1, 0, 0},
630 };
631
632 static constexpr uint8_t Data[] = {
633 0x01,
634 };
635
636 auto &Entry = Table[A];
637 unsigned Idx = B - Entry.Start;
638 if (Idx >= Entry.Length)
639 return false;
640 Idx += Entry.Offset;
641 return (Data[Idx / 8] >> (Idx % 8)) & 1;
642}
643
644static unsigned validateOperandClass(MCParsedAsmOperand &GOp, MatchClassKind Kind, const MCSubtargetInfo &STI) {
645 MSP430Operand &Operand = (MSP430Operand &)GOp;
646 if (Kind == InvalidMatchClass)
647 return MCTargetAsmParser::Match_InvalidOperand;
648
649 if (Kind <= MCK_LAST_TOKEN) {
650 if (Operand.isToken() &&
651 isSubclass(matchTokenString(Operand.getToken()), Kind))
652 return MCTargetAsmParser::Match_Success;
653 return MCTargetAsmParser::Match_InvalidOperand;
654 }
655
656 switch (Kind) {
657 default: break;
658 case MCK_CGImm: {
659 DiagnosticPredicate DP(Operand.isCGImm());
660 if (DP.isMatch())
661 return MCTargetAsmParser::Match_Success;
662 break;
663 }
664 case MCK_Imm: {
665 DiagnosticPredicate DP(Operand.isImm());
666 if (DP.isMatch())
667 return MCTargetAsmParser::Match_Success;
668 break;
669 }
670 case MCK_IndReg: {
671 DiagnosticPredicate DP(Operand.isIndReg());
672 if (DP.isMatch())
673 return MCTargetAsmParser::Match_Success;
674 break;
675 }
676 case MCK_Mem: {
677 DiagnosticPredicate DP(Operand.isMem());
678 if (DP.isMatch())
679 return MCTargetAsmParser::Match_Success;
680 break;
681 }
682 case MCK_PostIndReg: {
683 DiagnosticPredicate DP(Operand.isPostIndReg());
684 if (DP.isMatch())
685 return MCTargetAsmParser::Match_Success;
686 break;
687 }
688 } // end switch (Kind)
689
690 if (Operand.isReg()) {
691 static constexpr uint16_t Table[MSP430::NUM_TARGET_REGS] = {
692 InvalidMatchClass,
693 MCK_GR16,
694 MCK_GR8,
695 MCK_GR16,
696 MCK_GR8,
697 MCK_GR16,
698 MCK_GR8,
699 MCK_GR16,
700 MCK_GR8,
701 MCK_GR16,
702 MCK_GR16,
703 MCK_GR16,
704 MCK_GR16,
705 MCK_GR16,
706 MCK_GR16,
707 MCK_GR16,
708 MCK_GR16,
709 MCK_GR16,
710 MCK_GR16,
711 MCK_GR16,
712 MCK_GR16,
713 MCK_GR8,
714 MCK_GR8,
715 MCK_GR8,
716 MCK_GR8,
717 MCK_GR8,
718 MCK_GR8,
719 MCK_GR8,
720 MCK_GR8,
721 MCK_GR8,
722 MCK_GR8,
723 MCK_GR8,
724 MCK_GR8,
725 };
726
727 MCRegister Reg = Operand.getReg();
728 MatchClassKind OpKind = Reg.isPhysical() ? (MatchClassKind)Table[Reg.id()] : InvalidMatchClass;
729 return isSubclass(OpKind, Kind) ? (unsigned)MCTargetAsmParser::Match_Success :
730 getDiagKindFromRegisterClass(Kind);
731 }
732
733 if (Kind > MCK_LAST_TOKEN && Kind <= MCK_LAST_REGISTER)
734 return getDiagKindFromRegisterClass(Kind);
735
736 return MCTargetAsmParser::Match_InvalidOperand;
737}
738
739#ifndef NDEBUG
740const char *getMatchClassName(MatchClassKind Kind) {
741 switch (Kind) {
742 case InvalidMatchClass: return "InvalidMatchClass";
743 case OptionalMatchClass: return "OptionalMatchClass";
744 case MCK_GR16: return "MCK_GR16";
745 case MCK_GR8: return "MCK_GR8";
746 case MCK_CGImm: return "MCK_CGImm";
747 case MCK_Imm: return "MCK_Imm";
748 case MCK_IndReg: return "MCK_IndReg";
749 case MCK_Mem: return "MCK_Mem";
750 case MCK_PostIndReg: return "MCK_PostIndReg";
751 case NumMatchClassKinds: return "NumMatchClassKinds";
752 }
753 llvm_unreachable("unhandled MatchClassKind!");
754}
755
756#endif // NDEBUG
757FeatureBitset MSP430AsmParser::
758ComputeAvailableFeatures(const FeatureBitset &FB) const {
759 FeatureBitset Features;
760 return Features;
761}
762
763static bool checkAsmTiedOperandConstraints(const MSP430AsmParser&AsmParser,
764 unsigned Kind, const OperandVector &Operands,
765 uint64_t &ErrorInfo) {
766 assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
767 const uint8_t *Converter = ConversionTable[Kind];
768 for (const uint8_t *p = Converter; *p; p += 2) {
769 switch (*p) {
770 case CVT_Tied: {
771 unsigned OpIdx = *(p + 1);
772 assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
773 std::begin(TiedAsmOperandTable)) &&
774 "Tied operand not found");
775 unsigned OpndNum1 = TiedAsmOperandTable[OpIdx][1];
776 unsigned OpndNum2 = TiedAsmOperandTable[OpIdx][2];
777 if (OpndNum1 != OpndNum2) {
778 auto &SrcOp1 = Operands[OpndNum1];
779 auto &SrcOp2 = Operands[OpndNum2];
780 if (!AsmParser.areEqualRegs(*SrcOp1, *SrcOp2)) {
781 ErrorInfo = OpndNum2;
782 return false;
783 }
784 }
785 break;
786 }
787 default:
788 break;
789 }
790 }
791 return true;
792}
793
794static const char MnemonicTable[] =
795 "\003adc\005adc.b\003add\005add.b\004addc\006addc.b\003and\005and.b\003b"
796 "ic\005bic.b\003bis\005bis.b\003bit\005bit.b\002br\004call\003clr\005clr"
797 ".b\004clrc\004clrn\004clrz\003cmp\005cmp.b\004dadc\006dadc.b\004dadd\006"
798 "dadd.b\003dec\005dec.b\004decd\006decd.b\004dint\004eint\003inc\005inc."
799 "b\004incd\006incd.b\003inv\005inv.b\001j\003jmp\003mov\005mov.b\003nop\003"
800 "pop\004push\006push.b\003ret\004reti\003rla\005rla.b\003rlc\005rlc.b\003"
801 "rra\005rra.b\003rrc\005rrc.b\003sbc\005sbc.b\004setc\004setn\004setz\003"
802 "sub\005sub.b\004subc\006subc.b\004swpb\003sxt\003tst\005tst.b\003xor\005"
803 "xor.b";
804
805// Feature bitsets.
806enum : uint8_t {
807 AMFBS_None,
808};
809
810static constexpr FeatureBitset FeatureBitsets[] = {
811 {}, // AMFBS_None
812};
813
814namespace {
815 struct MatchEntry {
816 uint16_t Mnemonic;
817 uint32_t Opcode;
818 uint8_t ConvertFn;
819 uint8_t RequiredFeaturesIdx;
820 uint8_t Classes[2];
821 StringRef getMnemonic() const {
822 return StringRef(MnemonicTable + Mnemonic + 1,
823 MnemonicTable[Mnemonic]);
824 }
825 };
826
827 // Predicate for searching for an opcode.
828 struct LessOpcode {
829 bool operator()(const MatchEntry &LHS, StringRef RHS) {
830 return LHS.getMnemonic() < RHS;
831 }
832 bool operator()(StringRef LHS, const MatchEntry &RHS) {
833 return LHS < RHS.getMnemonic();
834 }
835 bool operator()(const MatchEntry &LHS, const MatchEntry &RHS) {
836 return LHS.getMnemonic() < RHS.getMnemonic();
837 }
838 };
839} // end anonymous namespace
840
841static const MatchEntry MatchTable0[] = {
842 { 0 /* adc */, MSP430::ADDC16rc, Convert__Reg1_0__Tie0_1_1__imm_95_0, AMFBS_None, { MCK_GR16 }, },
843 { 0 /* adc */, MSP430::ADDC16mc, Convert__Mem2_0__imm_95_0, AMFBS_None, { MCK_Mem }, },
844 { 4 /* adc.b */, MSP430::ADDC8rc, Convert__GR81_0__Tie0_1_1__imm_95_0, AMFBS_None, { MCK_GR8 }, },
845 { 4 /* adc.b */, MSP430::ADDC8mc, Convert__Mem2_0__imm_95_0, AMFBS_None, { MCK_Mem }, },
846 { 10 /* add */, MSP430::ADD16rr, Convert__Reg1_1__Tie0_1_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_GR16 }, },
847 { 10 /* add */, MSP430::ADD16mr, Convert__Mem2_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_Mem }, },
848 { 10 /* add */, MSP430::ADD16rc, Convert__Reg1_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR16 }, },
849 { 10 /* add */, MSP430::ADD16mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
850 { 10 /* add */, MSP430::ADD16ri, Convert__Reg1_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR16 }, },
851 { 10 /* add */, MSP430::ADD16mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
852 { 10 /* add */, MSP430::ADD16rn, Convert__Reg1_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR16 }, },
853 { 10 /* add */, MSP430::ADD16mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
854 { 10 /* add */, MSP430::ADD16rm, Convert__Reg1_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR16 }, },
855 { 10 /* add */, MSP430::ADD16mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
856 { 10 /* add */, MSP430::ADD16rp, Convert__Reg1_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR16 }, },
857 { 10 /* add */, MSP430::ADD16mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
858 { 14 /* add.b */, MSP430::ADD8rr, Convert__GR81_1__Tie0_1_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_GR8 }, },
859 { 14 /* add.b */, MSP430::ADD8mr, Convert__Mem2_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_Mem }, },
860 { 14 /* add.b */, MSP430::ADD8rc, Convert__GR81_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR8 }, },
861 { 14 /* add.b */, MSP430::ADD8mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
862 { 14 /* add.b */, MSP430::ADD8ri, Convert__GR81_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR8 }, },
863 { 14 /* add.b */, MSP430::ADD8mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
864 { 14 /* add.b */, MSP430::ADD8rn, Convert__GR81_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR8 }, },
865 { 14 /* add.b */, MSP430::ADD8mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
866 { 14 /* add.b */, MSP430::ADD8rm, Convert__GR81_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR8 }, },
867 { 14 /* add.b */, MSP430::ADD8mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
868 { 14 /* add.b */, MSP430::ADD8rp, Convert__GR81_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR8 }, },
869 { 14 /* add.b */, MSP430::ADD8mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
870 { 20 /* addc */, MSP430::ADDC16rr, Convert__Reg1_1__Tie0_1_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_GR16 }, },
871 { 20 /* addc */, MSP430::ADDC16mr, Convert__Mem2_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_Mem }, },
872 { 20 /* addc */, MSP430::ADDC16rc, Convert__Reg1_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR16 }, },
873 { 20 /* addc */, MSP430::ADDC16mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
874 { 20 /* addc */, MSP430::ADDC16ri, Convert__Reg1_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR16 }, },
875 { 20 /* addc */, MSP430::ADDC16mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
876 { 20 /* addc */, MSP430::ADDC16rn, Convert__Reg1_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR16 }, },
877 { 20 /* addc */, MSP430::ADDC16mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
878 { 20 /* addc */, MSP430::ADDC16rm, Convert__Reg1_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR16 }, },
879 { 20 /* addc */, MSP430::ADDC16mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
880 { 20 /* addc */, MSP430::ADDC16rp, Convert__Reg1_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR16 }, },
881 { 20 /* addc */, MSP430::ADDC16mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
882 { 25 /* addc.b */, MSP430::ADDC8rr, Convert__GR81_1__Tie0_1_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_GR8 }, },
883 { 25 /* addc.b */, MSP430::ADDC8mr, Convert__Mem2_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_Mem }, },
884 { 25 /* addc.b */, MSP430::ADDC8rc, Convert__GR81_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR8 }, },
885 { 25 /* addc.b */, MSP430::ADDC8mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
886 { 25 /* addc.b */, MSP430::ADDC8ri, Convert__GR81_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR8 }, },
887 { 25 /* addc.b */, MSP430::ADDC8mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
888 { 25 /* addc.b */, MSP430::ADDC8rn, Convert__GR81_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR8 }, },
889 { 25 /* addc.b */, MSP430::ADDC8mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
890 { 25 /* addc.b */, MSP430::ADDC8rm, Convert__GR81_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR8 }, },
891 { 25 /* addc.b */, MSP430::ADDC8mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
892 { 25 /* addc.b */, MSP430::ADDC8rp, Convert__GR81_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR8 }, },
893 { 25 /* addc.b */, MSP430::ADDC8mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
894 { 32 /* and */, MSP430::AND16rr, Convert__Reg1_1__Tie0_1_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_GR16 }, },
895 { 32 /* and */, MSP430::AND16mr, Convert__Mem2_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_Mem }, },
896 { 32 /* and */, MSP430::AND16rc, Convert__Reg1_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR16 }, },
897 { 32 /* and */, MSP430::AND16mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
898 { 32 /* and */, MSP430::AND16ri, Convert__Reg1_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR16 }, },
899 { 32 /* and */, MSP430::AND16mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
900 { 32 /* and */, MSP430::AND16rn, Convert__Reg1_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR16 }, },
901 { 32 /* and */, MSP430::AND16mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
902 { 32 /* and */, MSP430::AND16rm, Convert__Reg1_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR16 }, },
903 { 32 /* and */, MSP430::AND16mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
904 { 32 /* and */, MSP430::AND16rp, Convert__Reg1_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR16 }, },
905 { 32 /* and */, MSP430::AND16mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
906 { 36 /* and.b */, MSP430::AND8rr, Convert__GR81_1__Tie0_1_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_GR8 }, },
907 { 36 /* and.b */, MSP430::AND8mr, Convert__Mem2_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_Mem }, },
908 { 36 /* and.b */, MSP430::AND8rc, Convert__GR81_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR8 }, },
909 { 36 /* and.b */, MSP430::AND8mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
910 { 36 /* and.b */, MSP430::AND8ri, Convert__GR81_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR8 }, },
911 { 36 /* and.b */, MSP430::AND8mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
912 { 36 /* and.b */, MSP430::AND8rn, Convert__GR81_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR8 }, },
913 { 36 /* and.b */, MSP430::AND8mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
914 { 36 /* and.b */, MSP430::AND8rm, Convert__GR81_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR8 }, },
915 { 36 /* and.b */, MSP430::AND8mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
916 { 36 /* and.b */, MSP430::AND8rp, Convert__GR81_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR8 }, },
917 { 36 /* and.b */, MSP430::AND8mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
918 { 42 /* bic */, MSP430::BIC16rr, Convert__Reg1_1__Tie0_1_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_GR16 }, },
919 { 42 /* bic */, MSP430::BIC16mr, Convert__Mem2_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_Mem }, },
920 { 42 /* bic */, MSP430::BIC16rc, Convert__Reg1_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR16 }, },
921 { 42 /* bic */, MSP430::BIC16mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
922 { 42 /* bic */, MSP430::BIC16ri, Convert__Reg1_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR16 }, },
923 { 42 /* bic */, MSP430::BIC16mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
924 { 42 /* bic */, MSP430::BIC16rn, Convert__Reg1_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR16 }, },
925 { 42 /* bic */, MSP430::BIC16mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
926 { 42 /* bic */, MSP430::BIC16rm, Convert__Reg1_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR16 }, },
927 { 42 /* bic */, MSP430::BIC16mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
928 { 42 /* bic */, MSP430::BIC16rp, Convert__Reg1_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR16 }, },
929 { 42 /* bic */, MSP430::BIC16mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
930 { 46 /* bic.b */, MSP430::BIC8rr, Convert__GR81_1__Tie0_1_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_GR8 }, },
931 { 46 /* bic.b */, MSP430::BIC8mr, Convert__Mem2_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_Mem }, },
932 { 46 /* bic.b */, MSP430::BIC8rc, Convert__GR81_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR8 }, },
933 { 46 /* bic.b */, MSP430::BIC8mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
934 { 46 /* bic.b */, MSP430::BIC8ri, Convert__GR81_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR8 }, },
935 { 46 /* bic.b */, MSP430::BIC8mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
936 { 46 /* bic.b */, MSP430::BIC8rn, Convert__GR81_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR8 }, },
937 { 46 /* bic.b */, MSP430::BIC8mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
938 { 46 /* bic.b */, MSP430::BIC8rm, Convert__GR81_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR8 }, },
939 { 46 /* bic.b */, MSP430::BIC8mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
940 { 46 /* bic.b */, MSP430::BIC8rp, Convert__GR81_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR8 }, },
941 { 46 /* bic.b */, MSP430::BIC8mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
942 { 52 /* bis */, MSP430::BIS16rr, Convert__Reg1_1__Tie0_1_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_GR16 }, },
943 { 52 /* bis */, MSP430::BIS16mr, Convert__Mem2_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_Mem }, },
944 { 52 /* bis */, MSP430::BIS16rc, Convert__Reg1_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR16 }, },
945 { 52 /* bis */, MSP430::BIS16mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
946 { 52 /* bis */, MSP430::BIS16ri, Convert__Reg1_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR16 }, },
947 { 52 /* bis */, MSP430::BIS16mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
948 { 52 /* bis */, MSP430::BIS16rn, Convert__Reg1_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR16 }, },
949 { 52 /* bis */, MSP430::BIS16mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
950 { 52 /* bis */, MSP430::BIS16rm, Convert__Reg1_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR16 }, },
951 { 52 /* bis */, MSP430::BIS16mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
952 { 52 /* bis */, MSP430::BIS16rp, Convert__Reg1_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR16 }, },
953 { 52 /* bis */, MSP430::BIS16mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
954 { 56 /* bis.b */, MSP430::BIS8rr, Convert__GR81_1__Tie0_1_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_GR8 }, },
955 { 56 /* bis.b */, MSP430::BIS8mr, Convert__Mem2_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_Mem }, },
956 { 56 /* bis.b */, MSP430::BIS8rc, Convert__GR81_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR8 }, },
957 { 56 /* bis.b */, MSP430::BIS8mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
958 { 56 /* bis.b */, MSP430::BIS8ri, Convert__GR81_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR8 }, },
959 { 56 /* bis.b */, MSP430::BIS8mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
960 { 56 /* bis.b */, MSP430::BIS8rn, Convert__GR81_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR8 }, },
961 { 56 /* bis.b */, MSP430::BIS8mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
962 { 56 /* bis.b */, MSP430::BIS8rm, Convert__GR81_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR8 }, },
963 { 56 /* bis.b */, MSP430::BIS8mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
964 { 56 /* bis.b */, MSP430::BIS8rp, Convert__GR81_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR8 }, },
965 { 56 /* bis.b */, MSP430::BIS8mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
966 { 62 /* bit */, MSP430::BIT16rr, Convert__Reg1_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_GR16 }, },
967 { 62 /* bit */, MSP430::BIT16mr, Convert__Mem2_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_Mem }, },
968 { 62 /* bit */, MSP430::BIT16rc, Convert__Reg1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR16 }, },
969 { 62 /* bit */, MSP430::BIT16mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
970 { 62 /* bit */, MSP430::BIT16ri, Convert__Reg1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR16 }, },
971 { 62 /* bit */, MSP430::BIT16mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
972 { 62 /* bit */, MSP430::BIT16rn, Convert__Reg1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR16 }, },
973 { 62 /* bit */, MSP430::BIT16mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
974 { 62 /* bit */, MSP430::BIT16rm, Convert__Reg1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR16 }, },
975 { 62 /* bit */, MSP430::BIT16mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
976 { 62 /* bit */, MSP430::BIT16rp, Convert__Reg1_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_GR16 }, },
977 { 62 /* bit */, MSP430::BIT16mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
978 { 66 /* bit.b */, MSP430::BIT8rr, Convert__GR81_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_GR8 }, },
979 { 66 /* bit.b */, MSP430::BIT8mr, Convert__Mem2_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_Mem }, },
980 { 66 /* bit.b */, MSP430::BIT8rc, Convert__GR81_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR8 }, },
981 { 66 /* bit.b */, MSP430::BIT8mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
982 { 66 /* bit.b */, MSP430::BIT8ri, Convert__GR81_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR8 }, },
983 { 66 /* bit.b */, MSP430::BIT8mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
984 { 66 /* bit.b */, MSP430::BIT8rn, Convert__GR81_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR8 }, },
985 { 66 /* bit.b */, MSP430::BIT8mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
986 { 66 /* bit.b */, MSP430::BIT8rm, Convert__GR81_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR8 }, },
987 { 66 /* bit.b */, MSP430::BIT8mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
988 { 66 /* bit.b */, MSP430::BIT8rp, Convert__GR81_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_GR8 }, },
989 { 66 /* bit.b */, MSP430::BIT8mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
990 { 72 /* br */, MSP430::Br, Convert__Reg1_0, AMFBS_None, { MCK_GR16 }, },
991 { 72 /* br */, MSP430::Bi, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
992 { 72 /* br */, MSP430::Bm, Convert__Mem2_0, AMFBS_None, { MCK_Mem }, },
993 { 75 /* call */, MSP430::CALLr, Convert__Reg1_0, AMFBS_None, { MCK_GR16 }, },
994 { 75 /* call */, MSP430::CALLi, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
995 { 75 /* call */, MSP430::CALLn, Convert__IndReg1_0, AMFBS_None, { MCK_IndReg }, },
996 { 75 /* call */, MSP430::CALLm, Convert__Mem2_0, AMFBS_None, { MCK_Mem }, },
997 { 75 /* call */, MSP430::CALLp, Convert__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg }, },
998 { 80 /* clr */, MSP430::MOV16rc, Convert__Reg1_0__imm_95_0, AMFBS_None, { MCK_GR16 }, },
999 { 80 /* clr */, MSP430::MOV16mc, Convert__Mem2_0__imm_95_0, AMFBS_None, { MCK_Mem }, },
1000 { 84 /* clr.b */, MSP430::MOV8rc, Convert__GR81_0__imm_95_0, AMFBS_None, { MCK_GR8 }, },
1001 { 84 /* clr.b */, MSP430::MOV8mc, Convert__Mem2_0__imm_95_0, AMFBS_None, { MCK_Mem }, },
1002 { 90 /* clrc */, MSP430::BIC16rc, Convert__regSR__Tie0_1_1__imm_95_1, AMFBS_None, { }, },
1003 { 95 /* clrn */, MSP430::BIC16rc, Convert__regSR__Tie0_1_1__imm_95_4, AMFBS_None, { }, },
1004 { 100 /* clrz */, MSP430::BIC16rc, Convert__regSR__Tie0_1_1__imm_95_2, AMFBS_None, { }, },
1005 { 105 /* cmp */, MSP430::CMP16rr, Convert__Reg1_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_GR16 }, },
1006 { 105 /* cmp */, MSP430::CMP16mr, Convert__Mem2_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_Mem }, },
1007 { 105 /* cmp */, MSP430::CMP16rc, Convert__Reg1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR16 }, },
1008 { 105 /* cmp */, MSP430::CMP16mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
1009 { 105 /* cmp */, MSP430::CMP16ri, Convert__Reg1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR16 }, },
1010 { 105 /* cmp */, MSP430::CMP16mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
1011 { 105 /* cmp */, MSP430::CMP16rn, Convert__Reg1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR16 }, },
1012 { 105 /* cmp */, MSP430::CMP16mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
1013 { 105 /* cmp */, MSP430::CMP16rm, Convert__Reg1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR16 }, },
1014 { 105 /* cmp */, MSP430::CMP16mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
1015 { 105 /* cmp */, MSP430::CMP16rp, Convert__Reg1_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_GR16 }, },
1016 { 105 /* cmp */, MSP430::CMP16mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
1017 { 109 /* cmp.b */, MSP430::CMP8rr, Convert__GR81_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_GR8 }, },
1018 { 109 /* cmp.b */, MSP430::CMP8mr, Convert__Mem2_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_Mem }, },
1019 { 109 /* cmp.b */, MSP430::CMP8rc, Convert__GR81_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR8 }, },
1020 { 109 /* cmp.b */, MSP430::CMP8mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
1021 { 109 /* cmp.b */, MSP430::CMP8ri, Convert__GR81_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR8 }, },
1022 { 109 /* cmp.b */, MSP430::CMP8mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
1023 { 109 /* cmp.b */, MSP430::CMP8rn, Convert__GR81_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR8 }, },
1024 { 109 /* cmp.b */, MSP430::CMP8mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
1025 { 109 /* cmp.b */, MSP430::CMP8rm, Convert__GR81_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR8 }, },
1026 { 109 /* cmp.b */, MSP430::CMP8mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
1027 { 109 /* cmp.b */, MSP430::CMP8rp, Convert__GR81_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_GR8 }, },
1028 { 109 /* cmp.b */, MSP430::CMP8mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
1029 { 115 /* dadc */, MSP430::DADD16rc, Convert__Reg1_0__Tie0_1_1__imm_95_0, AMFBS_None, { MCK_GR16 }, },
1030 { 115 /* dadc */, MSP430::DADD16mc, Convert__Mem2_0__imm_95_0, AMFBS_None, { MCK_Mem }, },
1031 { 120 /* dadc.b */, MSP430::DADD8rc, Convert__GR81_0__Tie0_1_1__imm_95_0, AMFBS_None, { MCK_GR8 }, },
1032 { 120 /* dadc.b */, MSP430::DADD8mc, Convert__Mem2_0__imm_95_0, AMFBS_None, { MCK_Mem }, },
1033 { 127 /* dadd */, MSP430::DADD16rr, Convert__Reg1_1__Tie0_1_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_GR16 }, },
1034 { 127 /* dadd */, MSP430::DADD16mr, Convert__Mem2_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_Mem }, },
1035 { 127 /* dadd */, MSP430::DADD16rc, Convert__Reg1_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR16 }, },
1036 { 127 /* dadd */, MSP430::DADD16mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
1037 { 127 /* dadd */, MSP430::DADD16ri, Convert__Reg1_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR16 }, },
1038 { 127 /* dadd */, MSP430::DADD16mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
1039 { 127 /* dadd */, MSP430::DADD16rn, Convert__Reg1_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR16 }, },
1040 { 127 /* dadd */, MSP430::DADD16mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
1041 { 127 /* dadd */, MSP430::DADD16rm, Convert__Reg1_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR16 }, },
1042 { 127 /* dadd */, MSP430::DADD16mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
1043 { 127 /* dadd */, MSP430::DADD16rp, Convert__Reg1_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR16 }, },
1044 { 127 /* dadd */, MSP430::DADD16mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
1045 { 132 /* dadd.b */, MSP430::DADD8rr, Convert__GR81_1__Tie0_1_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_GR8 }, },
1046 { 132 /* dadd.b */, MSP430::DADD8mr, Convert__Mem2_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_Mem }, },
1047 { 132 /* dadd.b */, MSP430::DADD8rc, Convert__GR81_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR8 }, },
1048 { 132 /* dadd.b */, MSP430::DADD8mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
1049 { 132 /* dadd.b */, MSP430::DADD8ri, Convert__GR81_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR8 }, },
1050 { 132 /* dadd.b */, MSP430::DADD8mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
1051 { 132 /* dadd.b */, MSP430::DADD8rn, Convert__GR81_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR8 }, },
1052 { 132 /* dadd.b */, MSP430::DADD8mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
1053 { 132 /* dadd.b */, MSP430::DADD8rm, Convert__GR81_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR8 }, },
1054 { 132 /* dadd.b */, MSP430::DADD8mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
1055 { 132 /* dadd.b */, MSP430::DADD8rp, Convert__GR81_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR8 }, },
1056 { 132 /* dadd.b */, MSP430::DADD8mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
1057 { 139 /* dec */, MSP430::SUB16rc, Convert__Reg1_0__Tie0_1_1__imm_95_1, AMFBS_None, { MCK_GR16 }, },
1058 { 139 /* dec */, MSP430::SUB16mc, Convert__Mem2_0__imm_95_1, AMFBS_None, { MCK_Mem }, },
1059 { 143 /* dec.b */, MSP430::SUB8rc, Convert__GR81_0__Tie0_1_1__imm_95_1, AMFBS_None, { MCK_GR8 }, },
1060 { 143 /* dec.b */, MSP430::SUB8mc, Convert__Mem2_0__imm_95_1, AMFBS_None, { MCK_Mem }, },
1061 { 149 /* decd */, MSP430::SUB16rc, Convert__Reg1_0__Tie0_1_1__imm_95_2, AMFBS_None, { MCK_GR16 }, },
1062 { 149 /* decd */, MSP430::SUB16mc, Convert__Mem2_0__imm_95_2, AMFBS_None, { MCK_Mem }, },
1063 { 154 /* decd.b */, MSP430::SUB8rc, Convert__GR81_0__Tie0_1_1__imm_95_2, AMFBS_None, { MCK_GR8 }, },
1064 { 154 /* decd.b */, MSP430::SUB8mc, Convert__Mem2_0__imm_95_2, AMFBS_None, { MCK_Mem }, },
1065 { 161 /* dint */, MSP430::BIC16rc, Convert__regSR__Tie0_1_1__imm_95_8, AMFBS_None, { }, },
1066 { 166 /* eint */, MSP430::BIS16rc, Convert__regSR__Tie0_1_1__imm_95_8, AMFBS_None, { }, },
1067 { 171 /* inc */, MSP430::ADD16rc, Convert__Reg1_0__Tie0_1_1__imm_95_1, AMFBS_None, { MCK_GR16 }, },
1068 { 171 /* inc */, MSP430::ADD16mc, Convert__Mem2_0__imm_95_1, AMFBS_None, { MCK_Mem }, },
1069 { 175 /* inc.b */, MSP430::ADD8rc, Convert__GR81_0__Tie0_1_1__imm_95_1, AMFBS_None, { MCK_GR8 }, },
1070 { 175 /* inc.b */, MSP430::ADD8mc, Convert__Mem2_0__imm_95_1, AMFBS_None, { MCK_Mem }, },
1071 { 181 /* incd */, MSP430::ADD16rc, Convert__Reg1_0__Tie0_1_1__imm_95_2, AMFBS_None, { MCK_GR16 }, },
1072 { 181 /* incd */, MSP430::ADD16mc, Convert__Mem2_0__imm_95_2, AMFBS_None, { MCK_Mem }, },
1073 { 186 /* incd.b */, MSP430::ADD8rc, Convert__GR81_0__Tie0_1_1__imm_95_2, AMFBS_None, { MCK_GR8 }, },
1074 { 186 /* incd.b */, MSP430::ADD8mc, Convert__Mem2_0__imm_95_2, AMFBS_None, { MCK_Mem }, },
1075 { 193 /* inv */, MSP430::XOR16rc, Convert__Reg1_0__Tie0_1_1__imm_95__MINUS_1, AMFBS_None, { MCK_GR16 }, },
1076 { 193 /* inv */, MSP430::XOR16mc, Convert__Mem2_0__imm_95__MINUS_1, AMFBS_None, { MCK_Mem }, },
1077 { 197 /* inv.b */, MSP430::XOR8rc, Convert__GR81_0__Tie0_1_1__imm_95__MINUS_1, AMFBS_None, { MCK_GR8 }, },
1078 { 197 /* inv.b */, MSP430::XOR8mc, Convert__Mem2_0__imm_95__MINUS_1, AMFBS_None, { MCK_Mem }, },
1079 { 203 /* j */, MSP430::JCC, Convert__Imm1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Imm }, },
1080 { 205 /* jmp */, MSP430::JMP, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1081 { 209 /* mov */, MSP430::MOV16rr, Convert__Reg1_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_GR16 }, },
1082 { 209 /* mov */, MSP430::MOV16mr, Convert__Mem2_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_Mem }, },
1083 { 209 /* mov */, MSP430::MOV16rc, Convert__Reg1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR16 }, },
1084 { 209 /* mov */, MSP430::MOV16mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
1085 { 209 /* mov */, MSP430::MOV16ri, Convert__Reg1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR16 }, },
1086 { 209 /* mov */, MSP430::MOV16mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
1087 { 209 /* mov */, MSP430::MOV16rn, Convert__Reg1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR16 }, },
1088 { 209 /* mov */, MSP430::MOV16mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
1089 { 209 /* mov */, MSP430::MOV16rm, Convert__Reg1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR16 }, },
1090 { 209 /* mov */, MSP430::MOV16mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
1091 { 209 /* mov */, MSP430::MOV16rp, Convert__Reg1_1__PostIndReg1_0__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR16 }, },
1092 { 213 /* mov.b */, MSP430::MOV8rr, Convert__GR81_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_GR8 }, },
1093 { 213 /* mov.b */, MSP430::MOV8mr, Convert__Mem2_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_Mem }, },
1094 { 213 /* mov.b */, MSP430::MOV8rc, Convert__GR81_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR8 }, },
1095 { 213 /* mov.b */, MSP430::MOV8mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
1096 { 213 /* mov.b */, MSP430::MOV8ri, Convert__GR81_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR8 }, },
1097 { 213 /* mov.b */, MSP430::MOV8mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
1098 { 213 /* mov.b */, MSP430::MOV8rn, Convert__GR81_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR8 }, },
1099 { 213 /* mov.b */, MSP430::MOV8mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
1100 { 213 /* mov.b */, MSP430::MOV8rm, Convert__GR81_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR8 }, },
1101 { 213 /* mov.b */, MSP430::MOV8mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
1102 { 213 /* mov.b */, MSP430::MOV8rp, Convert__GR81_1__PostIndReg1_0__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR8 }, },
1103 { 219 /* nop */, MSP430::MOV16rc, Convert__regCG__imm_95_0, AMFBS_None, { }, },
1104 { 223 /* pop */, MSP430::POP16r, Convert__Reg1_0, AMFBS_None, { MCK_GR16 }, },
1105 { 227 /* push */, MSP430::PUSH16r, Convert__Reg1_0, AMFBS_None, { MCK_GR16 }, },
1106 { 227 /* push */, MSP430::PUSH16c, Convert__CGImm1_0, AMFBS_None, { MCK_CGImm }, },
1107 { 227 /* push */, MSP430::PUSH16i, Convert__Imm1_0, AMFBS_None, { MCK_Imm }, },
1108 { 232 /* push.b */, MSP430::PUSH8r, Convert__GR81_0, AMFBS_None, { MCK_GR8 }, },
1109 { 239 /* ret */, MSP430::RET, Convert_NoOperands, AMFBS_None, { }, },
1110 { 243 /* reti */, MSP430::RETI, Convert_NoOperands, AMFBS_None, { }, },
1111 { 248 /* rla */, MSP430::ADD16rr, Convert__Reg1_0__Tie0_1_1__Reg1_0, AMFBS_None, { MCK_GR16 }, },
1112 { 248 /* rla */, MSP430::ADD16mm, Convert__Mem2_0__Mem2_0, AMFBS_None, { MCK_Mem }, },
1113 { 252 /* rla.b */, MSP430::ADD8rr, Convert__GR81_0__Tie0_1_1__GR81_0, AMFBS_None, { MCK_GR8 }, },
1114 { 252 /* rla.b */, MSP430::ADD8mm, Convert__Mem2_0__Mem2_0, AMFBS_None, { MCK_Mem }, },
1115 { 258 /* rlc */, MSP430::ADDC16rr, Convert__Reg1_0__Tie0_1_1__Reg1_0, AMFBS_None, { MCK_GR16 }, },
1116 { 258 /* rlc */, MSP430::ADDC16mm, Convert__Mem2_0__Mem2_0, AMFBS_None, { MCK_Mem }, },
1117 { 262 /* rlc.b */, MSP430::ADDC8rr, Convert__GR81_0__Tie0_1_1__GR81_0, AMFBS_None, { MCK_GR8 }, },
1118 { 262 /* rlc.b */, MSP430::ADDC8mm, Convert__Mem2_0__Mem2_0, AMFBS_None, { MCK_Mem }, },
1119 { 268 /* rra */, MSP430::RRA16r, Convert__Reg1_0__Tie0_1_1, AMFBS_None, { MCK_GR16 }, },
1120 { 268 /* rra */, MSP430::RRA16n, Convert__IndReg1_0, AMFBS_None, { MCK_IndReg }, },
1121 { 268 /* rra */, MSP430::RRA16m, Convert__Mem2_0, AMFBS_None, { MCK_Mem }, },
1122 { 268 /* rra */, MSP430::RRA16p, Convert__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg }, },
1123 { 272 /* rra.b */, MSP430::RRA8r, Convert__GR81_0__Tie0_1_1, AMFBS_None, { MCK_GR8 }, },
1124 { 272 /* rra.b */, MSP430::RRA8n, Convert__IndReg1_0, AMFBS_None, { MCK_IndReg }, },
1125 { 272 /* rra.b */, MSP430::RRA8m, Convert__Mem2_0, AMFBS_None, { MCK_Mem }, },
1126 { 272 /* rra.b */, MSP430::RRA8p, Convert__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg }, },
1127 { 278 /* rrc */, MSP430::RRC16r, Convert__Reg1_0__Tie0_1_1, AMFBS_None, { MCK_GR16 }, },
1128 { 278 /* rrc */, MSP430::RRC16n, Convert__IndReg1_0, AMFBS_None, { MCK_IndReg }, },
1129 { 278 /* rrc */, MSP430::RRC16m, Convert__Mem2_0, AMFBS_None, { MCK_Mem }, },
1130 { 278 /* rrc */, MSP430::RRC16p, Convert__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg }, },
1131 { 282 /* rrc.b */, MSP430::RRC8r, Convert__GR81_0__Tie0_1_1, AMFBS_None, { MCK_GR8 }, },
1132 { 282 /* rrc.b */, MSP430::RRC8n, Convert__IndReg1_0, AMFBS_None, { MCK_IndReg }, },
1133 { 282 /* rrc.b */, MSP430::RRC8m, Convert__Mem2_0, AMFBS_None, { MCK_Mem }, },
1134 { 282 /* rrc.b */, MSP430::RRC8p, Convert__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg }, },
1135 { 288 /* sbc */, MSP430::SUBC16rc, Convert__Reg1_0__Tie0_1_1__imm_95_0, AMFBS_None, { MCK_GR16 }, },
1136 { 288 /* sbc */, MSP430::SUBC16mc, Convert__Mem2_0__imm_95_0, AMFBS_None, { MCK_Mem }, },
1137 { 292 /* sbc.b */, MSP430::SUBC8rc, Convert__GR81_0__Tie0_1_1__imm_95_0, AMFBS_None, { MCK_GR8 }, },
1138 { 292 /* sbc.b */, MSP430::SUBC8mc, Convert__Mem2_0__imm_95_0, AMFBS_None, { MCK_Mem }, },
1139 { 298 /* setc */, MSP430::BIS16rc, Convert__regSR__Tie0_1_1__imm_95_1, AMFBS_None, { }, },
1140 { 303 /* setn */, MSP430::BIS16rc, Convert__regSR__Tie0_1_1__imm_95_4, AMFBS_None, { }, },
1141 { 308 /* setz */, MSP430::BIS16rc, Convert__regSR__Tie0_1_1__imm_95_2, AMFBS_None, { }, },
1142 { 313 /* sub */, MSP430::SUB16rr, Convert__Reg1_1__Tie0_1_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_GR16 }, },
1143 { 313 /* sub */, MSP430::SUB16mr, Convert__Mem2_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_Mem }, },
1144 { 313 /* sub */, MSP430::SUB16rc, Convert__Reg1_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR16 }, },
1145 { 313 /* sub */, MSP430::SUB16mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
1146 { 313 /* sub */, MSP430::SUB16ri, Convert__Reg1_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR16 }, },
1147 { 313 /* sub */, MSP430::SUB16mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
1148 { 313 /* sub */, MSP430::SUB16rn, Convert__Reg1_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR16 }, },
1149 { 313 /* sub */, MSP430::SUB16mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
1150 { 313 /* sub */, MSP430::SUB16rm, Convert__Reg1_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR16 }, },
1151 { 313 /* sub */, MSP430::SUB16mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
1152 { 313 /* sub */, MSP430::SUB16rp, Convert__Reg1_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR16 }, },
1153 { 313 /* sub */, MSP430::SUB16mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
1154 { 317 /* sub.b */, MSP430::SUB8rr, Convert__GR81_1__Tie0_1_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_GR8 }, },
1155 { 317 /* sub.b */, MSP430::SUB8mr, Convert__Mem2_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_Mem }, },
1156 { 317 /* sub.b */, MSP430::SUB8rc, Convert__GR81_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR8 }, },
1157 { 317 /* sub.b */, MSP430::SUB8mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
1158 { 317 /* sub.b */, MSP430::SUB8ri, Convert__GR81_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR8 }, },
1159 { 317 /* sub.b */, MSP430::SUB8mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
1160 { 317 /* sub.b */, MSP430::SUB8rn, Convert__GR81_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR8 }, },
1161 { 317 /* sub.b */, MSP430::SUB8mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
1162 { 317 /* sub.b */, MSP430::SUB8rm, Convert__GR81_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR8 }, },
1163 { 317 /* sub.b */, MSP430::SUB8mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
1164 { 317 /* sub.b */, MSP430::SUB8rp, Convert__GR81_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR8 }, },
1165 { 317 /* sub.b */, MSP430::SUB8mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
1166 { 323 /* subc */, MSP430::SUBC16rr, Convert__Reg1_1__Tie0_1_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_GR16 }, },
1167 { 323 /* subc */, MSP430::SUBC16mr, Convert__Mem2_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_Mem }, },
1168 { 323 /* subc */, MSP430::SUBC16rc, Convert__Reg1_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR16 }, },
1169 { 323 /* subc */, MSP430::SUBC16mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
1170 { 323 /* subc */, MSP430::SUBC16ri, Convert__Reg1_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR16 }, },
1171 { 323 /* subc */, MSP430::SUBC16mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
1172 { 323 /* subc */, MSP430::SUBC16rn, Convert__Reg1_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR16 }, },
1173 { 323 /* subc */, MSP430::SUBC16mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
1174 { 323 /* subc */, MSP430::SUBC16rm, Convert__Reg1_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR16 }, },
1175 { 323 /* subc */, MSP430::SUBC16mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
1176 { 323 /* subc */, MSP430::SUBC16rp, Convert__Reg1_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR16 }, },
1177 { 323 /* subc */, MSP430::SUBC16mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
1178 { 328 /* subc.b */, MSP430::SUBC8rr, Convert__GR81_1__Tie0_1_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_GR8 }, },
1179 { 328 /* subc.b */, MSP430::SUBC8mr, Convert__Mem2_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_Mem }, },
1180 { 328 /* subc.b */, MSP430::SUBC8rc, Convert__GR81_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR8 }, },
1181 { 328 /* subc.b */, MSP430::SUBC8mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
1182 { 328 /* subc.b */, MSP430::SUBC8ri, Convert__GR81_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR8 }, },
1183 { 328 /* subc.b */, MSP430::SUBC8mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
1184 { 328 /* subc.b */, MSP430::SUBC8rn, Convert__GR81_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR8 }, },
1185 { 328 /* subc.b */, MSP430::SUBC8mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
1186 { 328 /* subc.b */, MSP430::SUBC8rm, Convert__GR81_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR8 }, },
1187 { 328 /* subc.b */, MSP430::SUBC8mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
1188 { 328 /* subc.b */, MSP430::SUBC8rp, Convert__GR81_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR8 }, },
1189 { 328 /* subc.b */, MSP430::SUBC8mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
1190 { 335 /* swpb */, MSP430::SWPB16r, Convert__Reg1_0__Tie0_1_1, AMFBS_None, { MCK_GR16 }, },
1191 { 335 /* swpb */, MSP430::SWPB16n, Convert__IndReg1_0, AMFBS_None, { MCK_IndReg }, },
1192 { 335 /* swpb */, MSP430::SWPB16m, Convert__Mem2_0, AMFBS_None, { MCK_Mem }, },
1193 { 335 /* swpb */, MSP430::SWPB16p, Convert__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg }, },
1194 { 340 /* sxt */, MSP430::SEXT16r, Convert__Reg1_0__Tie0_1_1, AMFBS_None, { MCK_GR16 }, },
1195 { 340 /* sxt */, MSP430::SEXT16n, Convert__IndReg1_0, AMFBS_None, { MCK_IndReg }, },
1196 { 340 /* sxt */, MSP430::SEXT16m, Convert__Mem2_0, AMFBS_None, { MCK_Mem }, },
1197 { 340 /* sxt */, MSP430::SEXT16p, Convert__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg }, },
1198 { 344 /* tst */, MSP430::CMP16rc, Convert__Reg1_0__imm_95_0, AMFBS_None, { MCK_GR16 }, },
1199 { 344 /* tst */, MSP430::CMP16mc, Convert__Mem2_0__imm_95_0, AMFBS_None, { MCK_Mem }, },
1200 { 348 /* tst.b */, MSP430::CMP8rc, Convert__GR81_0__imm_95_0, AMFBS_None, { MCK_GR8 }, },
1201 { 348 /* tst.b */, MSP430::CMP8mc, Convert__Mem2_0__imm_95_0, AMFBS_None, { MCK_Mem }, },
1202 { 354 /* xor */, MSP430::XOR16rr, Convert__Reg1_1__Tie0_1_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_GR16 }, },
1203 { 354 /* xor */, MSP430::XOR16mr, Convert__Mem2_1__Reg1_0, AMFBS_None, { MCK_GR16, MCK_Mem }, },
1204 { 354 /* xor */, MSP430::XOR16rc, Convert__Reg1_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR16 }, },
1205 { 354 /* xor */, MSP430::XOR16mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
1206 { 354 /* xor */, MSP430::XOR16ri, Convert__Reg1_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR16 }, },
1207 { 354 /* xor */, MSP430::XOR16mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
1208 { 354 /* xor */, MSP430::XOR16rn, Convert__Reg1_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR16 }, },
1209 { 354 /* xor */, MSP430::XOR16mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
1210 { 354 /* xor */, MSP430::XOR16rm, Convert__Reg1_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR16 }, },
1211 { 354 /* xor */, MSP430::XOR16mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
1212 { 354 /* xor */, MSP430::XOR16rp, Convert__Reg1_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR16 }, },
1213 { 354 /* xor */, MSP430::XOR16mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
1214 { 358 /* xor.b */, MSP430::XOR8rr, Convert__GR81_1__Tie0_1_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_GR8 }, },
1215 { 358 /* xor.b */, MSP430::XOR8mr, Convert__Mem2_1__GR81_0, AMFBS_None, { MCK_GR8, MCK_Mem }, },
1216 { 358 /* xor.b */, MSP430::XOR8rc, Convert__GR81_1__Tie0_1_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_GR8 }, },
1217 { 358 /* xor.b */, MSP430::XOR8mc, Convert__Mem2_1__CGImm1_0, AMFBS_None, { MCK_CGImm, MCK_Mem }, },
1218 { 358 /* xor.b */, MSP430::XOR8ri, Convert__GR81_1__Tie0_1_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_GR8 }, },
1219 { 358 /* xor.b */, MSP430::XOR8mi, Convert__Mem2_1__Imm1_0, AMFBS_None, { MCK_Imm, MCK_Mem }, },
1220 { 358 /* xor.b */, MSP430::XOR8rn, Convert__GR81_1__Tie0_1_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_GR8 }, },
1221 { 358 /* xor.b */, MSP430::XOR8mn, Convert__Mem2_1__IndReg1_0, AMFBS_None, { MCK_IndReg, MCK_Mem }, },
1222 { 358 /* xor.b */, MSP430::XOR8rm, Convert__GR81_1__Tie0_1_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_GR8 }, },
1223 { 358 /* xor.b */, MSP430::XOR8mm, Convert__Mem2_1__Mem2_0, AMFBS_None, { MCK_Mem, MCK_Mem }, },
1224 { 358 /* xor.b */, MSP430::XOR8rp, Convert__GR81_1__PostIndReg1_0__Tie0_1_1__Tie1_1_1, AMFBS_None, { MCK_PostIndReg, MCK_GR8 }, },
1225 { 358 /* xor.b */, MSP430::XOR8mp, Convert__Mem2_1__PostIndReg1_0, AMFBS_None, { MCK_PostIndReg, MCK_Mem }, },
1226};
1227
1228#include "llvm/Support/Debug.h"
1229#include "llvm/Support/Format.h"
1230
1231unsigned MSP430AsmParser::
1232MatchInstructionImpl(const OperandVector &Operands,
1233 MCInst &Inst,
1234 uint64_t &ErrorInfo,
1235 FeatureBitset &MissingFeatures,
1236 bool matchingInlineAsm, unsigned VariantID) {
1237 // Eliminate obvious mismatches.
1238 if (Operands.size() > 3) {
1239 ErrorInfo = 3;
1240 return Match_InvalidOperand;
1241 }
1242
1243 // Get the current feature set.
1244 const FeatureBitset &AvailableFeatures = getAvailableFeatures();
1245
1246 // Get the instruction mnemonic, which is the first token.
1247 StringRef Mnemonic = ((MSP430Operand &)*Operands[0]).getToken();
1248
1249 // Some state to try to produce better error messages.
1250 bool HadMatchOtherThanFeatures = false;
1251 bool HadMatchOtherThanPredicate = false;
1252 unsigned RetCode = Match_InvalidOperand;
1253 MissingFeatures.set();
1254 // Set ErrorInfo to the operand that mismatches if it is
1255 // wrong for all instances of the instruction.
1256 ErrorInfo = ~0ULL;
1257 // Find the appropriate table for this asm variant.
1258 const MatchEntry *Start, *End;
1259 switch (VariantID) {
1260 default: llvm_unreachable("invalid variant!");
1261 case 0: Start = std::begin(MatchTable0); End = std::end(MatchTable0); break;
1262 }
1263 // Search the table.
1264 auto MnemonicRange = std::equal_range(Start, End, Mnemonic, LessOpcode());
1265
1266 DEBUG_WITH_TYPE("asm-matcher", dbgs() << "AsmMatcher: found " <<
1267 std::distance(MnemonicRange.first, MnemonicRange.second) <<
1268 " encodings with mnemonic '" << Mnemonic << "'\n");
1269
1270 // Return a more specific error code if no mnemonics match.
1271 if (MnemonicRange.first == MnemonicRange.second)
1272 return Match_MnemonicFail;
1273
1274 for (const MatchEntry *it = MnemonicRange.first, *ie = MnemonicRange.second;
1275 it != ie; ++it) {
1276 const FeatureBitset &RequiredFeatures = FeatureBitsets[it->RequiredFeaturesIdx];
1277 bool HasRequiredFeatures =
1278 (AvailableFeatures & RequiredFeatures) == RequiredFeatures;
1279 DEBUG_WITH_TYPE("asm-matcher", dbgs() << "Trying to match opcode "
1280 << MII.getName(it->Opcode) << "\n");
1281 // equal_range guarantees that instruction mnemonic matches.
1282 assert(Mnemonic == it->getMnemonic());
1283 bool OperandsValid = true;
1284 unsigned ActualIdx = 1;
1285 for (unsigned FormalIdx = 0; FormalIdx != 2; ++FormalIdx) {
1286 auto Formal = static_cast<MatchClassKind>(it->Classes[FormalIdx]);
1287 DEBUG_WITH_TYPE("asm-matcher",
1288 dbgs() << " Matching formal operand class " << getMatchClassName(Formal)
1289 << " against actual operand at index " << ActualIdx);
1290 if (ActualIdx < Operands.size())
1291 DEBUG_WITH_TYPE("asm-matcher", dbgs() << " (";
1292 Operands[ActualIdx]->print(dbgs(), getContext().getAsmInfo()); dbgs() << "): ");
1293 else
1294 DEBUG_WITH_TYPE("asm-matcher", dbgs() << ": ");
1295 if (ActualIdx >= Operands.size()) {
1296 DEBUG_WITH_TYPE("asm-matcher", dbgs() << "actual operand index out of range\n");
1297 if (Formal == InvalidMatchClass) {
1298 break;
1299 }
1300 if (isSubclass(Formal, OptionalMatchClass)) {
1301 continue;
1302 }
1303 OperandsValid = false;
1304 ErrorInfo = ActualIdx;
1305 break;
1306 }
1307 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
1308 unsigned Diag = validateOperandClass(Actual, Formal, *STI);
1309 if (Diag == Match_Success) {
1310 DEBUG_WITH_TYPE("asm-matcher",
1311 dbgs() << "match success using generic matcher\n");
1312 ++ActualIdx;
1313 continue;
1314 }
1315 // If the generic handler indicates an invalid operand
1316 // failure, check for a special case.
1317 if (Diag != Match_Success) {
1318 unsigned TargetDiag = validateTargetOperandClass(Actual, Formal);
1319 if (TargetDiag == Match_Success) {
1320 DEBUG_WITH_TYPE("asm-matcher",
1321 dbgs() << "match success using target matcher\n");
1322 ++ActualIdx;
1323 continue;
1324 }
1325 // If the target matcher returned a specific error code use
1326 // that, else use the one from the generic matcher.
1327 if (TargetDiag != Match_InvalidOperand && HasRequiredFeatures)
1328 Diag = TargetDiag;
1329 }
1330 // If current formal operand wasn't matched and it is optional
1331 // then try to match next formal operand
1332 if (Diag == Match_InvalidOperand && isSubclass(Formal, OptionalMatchClass)) {
1333 DEBUG_WITH_TYPE("asm-matcher", dbgs() << "ignoring optional operand\n");
1334 continue;
1335 }
1336 // If this operand is broken for all of the instances of this
1337 // mnemonic, keep track of it so we can report loc info.
1338 // If we already had a match that only failed due to a
1339 // target predicate, that diagnostic is preferred.
1340 if (!HadMatchOtherThanPredicate &&
1341 (it == MnemonicRange.first || ErrorInfo <= ActualIdx)) {
1342 if (HasRequiredFeatures && (ErrorInfo != ActualIdx || Diag != Match_InvalidOperand))
1343 RetCode = Diag;
1344 ErrorInfo = ActualIdx;
1345 }
1346 // Otherwise, just reject this instance of the mnemonic.
1347 OperandsValid = false;
1348 break;
1349 }
1350
1351 if (!OperandsValid) {
1352 DEBUG_WITH_TYPE("asm-matcher", dbgs() << "Opcode result: multiple "
1353 "operand mismatches, ignoring "
1354 "this opcode\n");
1355 continue;
1356 }
1357 if (!HasRequiredFeatures) {
1358 HadMatchOtherThanFeatures = true;
1359 FeatureBitset NewMissingFeatures = RequiredFeatures & ~AvailableFeatures;
1360 DEBUG_WITH_TYPE("asm-matcher", dbgs() << "Missing target features:";
1361 for (unsigned I = 0, E = NewMissingFeatures.size(); I != E; ++I)
1362 if (NewMissingFeatures[I])
1363 dbgs() << ' ' << I;
1364 dbgs() << "\n");
1365 if (NewMissingFeatures.count() <=
1366 MissingFeatures.count())
1367 MissingFeatures = NewMissingFeatures;
1368 continue;
1369 }
1370
1371 Inst.clear();
1372
1373 Inst.setOpcode(it->Opcode);
1374 // We have a potential match but have not rendered the operands.
1375 // Check the target predicate to handle any context sensitive
1376 // constraints.
1377 // For example, Ties that are referenced multiple times must be
1378 // checked here to ensure the input is the same for each match
1379 // constraints. If we leave it any later the ties will have been
1380 // canonicalized
1381 unsigned MatchResult;
1382 if ((MatchResult = checkEarlyTargetMatchPredicate(Inst, Operands)) != Match_Success) {
1383 Inst.clear();
1384 DEBUG_WITH_TYPE(
1385 "asm-matcher",
1386 dbgs() << "Early target match predicate failed with diag code "
1387 << MatchResult << "\n");
1388 RetCode = MatchResult;
1389 HadMatchOtherThanPredicate = true;
1390 continue;
1391 }
1392
1393 if (matchingInlineAsm) {
1394 convertToMapAndConstraints(it->ConvertFn, Operands);
1395 if (!checkAsmTiedOperandConstraints(*this, it->ConvertFn, Operands,
1396 ErrorInfo))
1397 return Match_InvalidTiedOperand;
1398
1399 return Match_Success;
1400 }
1401
1402 // We have selected a definite instruction, convert the parsed
1403 // operands into the appropriate MCInst.
1404 convertToMCInst(it->ConvertFn, Inst, it->Opcode, Operands);
1405
1406 // We have a potential match. Check the target predicate to
1407 // handle any context sensitive constraints.
1408 if ((MatchResult = checkTargetMatchPredicate(Inst)) != Match_Success) {
1409 DEBUG_WITH_TYPE("asm-matcher",
1410 dbgs() << "Target match predicate failed with diag code "
1411 << MatchResult << "\n");
1412 Inst.clear();
1413 RetCode = MatchResult;
1414 HadMatchOtherThanPredicate = true;
1415 continue;
1416 }
1417
1418 if (!checkAsmTiedOperandConstraints(*this, it->ConvertFn, Operands,
1419 ErrorInfo))
1420 return Match_InvalidTiedOperand;
1421
1422 DEBUG_WITH_TYPE(
1423 "asm-matcher",
1424 dbgs() << "Opcode result: complete match, selecting this opcode\n");
1425 return Match_Success;
1426 }
1427
1428 // Okay, we had no match. Try to return a useful error code.
1429 if (HadMatchOtherThanPredicate || !HadMatchOtherThanFeatures)
1430 return RetCode;
1431
1432 ErrorInfo = 0;
1433 return Match_MissingFeature;
1434}
1435
1436#endif // GET_MATCHER_IMPLEMENTATION
1437
1438
1439#ifdef GET_MNEMONIC_SPELL_CHECKER
1440#undef GET_MNEMONIC_SPELL_CHECKER
1441
1442static std::string MSP430MnemonicSpellCheck(StringRef S, const FeatureBitset &FBS, unsigned VariantID) {
1443 const unsigned MaxEditDist = 2;
1444 std::vector<StringRef> Candidates;
1445 StringRef Prev = "";
1446
1447 // Find the appropriate table for this asm variant.
1448 const MatchEntry *Start, *End;
1449 switch (VariantID) {
1450 default: llvm_unreachable("invalid variant!");
1451 case 0: Start = std::begin(MatchTable0); End = std::end(MatchTable0); break;
1452 }
1453
1454 for (auto I = Start; I < End; I++) {
1455 // Ignore unsupported instructions.
1456 const FeatureBitset &RequiredFeatures = FeatureBitsets[I->RequiredFeaturesIdx];
1457 if ((FBS & RequiredFeatures) != RequiredFeatures)
1458 continue;
1459
1460 StringRef T = I->getMnemonic();
1461 // Avoid recomputing the edit distance for the same string.
1462 if (T == Prev)
1463 continue;
1464
1465 Prev = T;
1466 unsigned Dist = S.edit_distance(T, false, MaxEditDist);
1467 if (Dist <= MaxEditDist)
1468 Candidates.push_back(T);
1469 }
1470
1471 if (Candidates.empty())
1472 return "";
1473
1474 std::string Res = ", did you mean: ";
1475 unsigned i = 0;
1476 for (; i < Candidates.size() - 1; i++)
1477 Res += Candidates[i].str() + ", ";
1478 return Res + Candidates[i].str() + "?";
1479}
1480
1481#endif // GET_MNEMONIC_SPELL_CHECKER
1482
1483
1484#ifdef GET_MNEMONIC_CHECKER
1485#undef GET_MNEMONIC_CHECKER
1486
1487static bool MSP430CheckMnemonic(StringRef Mnemonic,
1488 const FeatureBitset &AvailableFeatures,
1489 unsigned VariantID) {
1490 // Find the appropriate table for this asm variant.
1491 const MatchEntry *Start, *End;
1492 switch (VariantID) {
1493 default: llvm_unreachable("invalid variant!");
1494 case 0: Start = std::begin(MatchTable0); End = std::end(MatchTable0); break;
1495 }
1496
1497 // Search the table.
1498 auto MnemonicRange = std::equal_range(Start, End, Mnemonic, LessOpcode());
1499
1500 if (MnemonicRange.first == MnemonicRange.second)
1501 return false;
1502
1503 for (const MatchEntry *it = MnemonicRange.first, *ie = MnemonicRange.second;
1504 it != ie; ++it) {
1505 const FeatureBitset &RequiredFeatures =
1506 FeatureBitsets[it->RequiredFeaturesIdx];
1507 if ((AvailableFeatures & RequiredFeatures) == RequiredFeatures)
1508 return true;
1509 }
1510 return false;
1511}
1512
1513#endif // GET_MNEMONIC_CHECKER
1514
1515