Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/clang-build/lib/Target/BPF/BPFGenAsmMatcher.inc
Line
Count
Source (jump to first uncovered line)
1
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2
|*                                                                            *|
3
|* Assembly Matcher Source Fragment                                           *|
4
|*                                                                            *|
5
|* Automatically generated file, do not edit!                                 *|
6
|*                                                                            *|
7
\*===----------------------------------------------------------------------===*/
8
9
10
#ifdef GET_ASSEMBLER_HEADER
11
#undef GET_ASSEMBLER_HEADER
12
  // This should be included into the middle of the declaration of
13
  // your subclasses implementation of MCTargetAsmParser.
14
  FeatureBitset ComputeAvailableFeatures(const FeatureBitset& FB) const;
15
  void convertToMCInst(unsigned Kind, MCInst &Inst, unsigned Opcode,
16
                       const OperandVector &Operands);
17
  void convertToMapAndConstraints(unsigned Kind,
18
                           const OperandVector &Operands) override;
19
  unsigned MatchInstructionImpl(const OperandVector &Operands,
20
                                MCInst &Inst,
21
                                uint64_t &ErrorInfo,
22
                                FeatureBitset &MissingFeatures,
23
                                bool matchingInlineAsm,
24
                                unsigned VariantID = 0);
25
  unsigned MatchInstructionImpl(const OperandVector &Operands,
26
                                MCInst &Inst,
27
                                uint64_t &ErrorInfo,
28
                                bool matchingInlineAsm,
29
121
                                unsigned VariantID = 0) {
30
121
    FeatureBitset MissingFeatures;
31
121
    return MatchInstructionImpl(Operands, Inst, ErrorInfo, MissingFeatures,
32
121
                                matchingInlineAsm, VariantID);
33
121
  }
34
35
#endif // GET_ASSEMBLER_HEADER_INFO
36
37
38
#ifdef GET_OPERAND_DIAGNOSTIC_TYPES
39
#undef GET_OPERAND_DIAGNOSTIC_TYPES
40
41
#endif // GET_OPERAND_DIAGNOSTIC_TYPES
42
43
44
#ifdef GET_REGISTER_MATCHER
45
#undef GET_REGISTER_MATCHER
46
47
// Bits for subtarget features that participate in instruction matching.
48
enum SubtargetFeatureBits : uint8_t {
49
};
50
51
280
static unsigned MatchRegisterName(StringRef Name) {
52
280
  switch (Name.size()) {
53
280
  
default: break55
;
54
280
  case 2:  // 20 strings to match.
55
215
    switch (Name[0]) {
56
215
    
default: break40
;
57
215
    case 'r':  // 10 strings to match.
58
106
      switch (Name[1]) {
59
106
      
default: break0
;
60
106
      case '0':  // 1 string to match.
61
16
        return 1;  // "r0"
62
106
      case '1':  // 1 string to match.
63
13
        return 2;  // "r1"
64
106
      case '2':  // 1 string to match.
65
17
        return 3;  // "r2"
66
106
      case '3':  // 1 string to match.
67
11
        return 4;  // "r3"
68
106
      case '4':  // 1 string to match.
69
6
        return 5;  // "r4"
70
106
      case '5':  // 1 string to match.
71
7
        return 6;  // "r5"
72
106
      case '6':  // 1 string to match.
73
7
        return 7;  // "r6"
74
106
      case '7':  // 1 string to match.
75
8
        return 8;  // "r7"
76
106
      case '8':  // 1 string to match.
77
8
        return 9;  // "r8"
78
106
      case '9':  // 1 string to match.
79
13
        return 10;  // "r9"
80
0
      }
81
0
      break;
82
69
    case 'w':  // 10 strings to match.
83
69
      switch (Name[1]) {
84
69
      
default: break0
;
85
69
      case '0':  // 1 string to match.
86
5
        return 13;  // "w0"
87
69
      case '1':  // 1 string to match.
88
8
        return 14;  // "w1"
89
69
      case '2':  // 1 string to match.
90
6
        return 15;  // "w2"
91
69
      case '3':  // 1 string to match.
92
6
        return 16;  // "w3"
93
69
      case '4':  // 1 string to match.
94
6
        return 17;  // "w4"
95
69
      case '5':  // 1 string to match.
96
7
        return 18;  // "w5"
97
69
      case '6':  // 1 string to match.
98
7
        return 19;  // "w6"
99
69
      case '7':  // 1 string to match.
100
8
        return 20;  // "w7"
101
69
      case '8':  // 1 string to match.
102
7
        return 21;  // "w8"
103
69
      case '9':  // 1 string to match.
104
9
        return 22;  // "w9"
105
0
      }
106
0
      break;
107
40
    }
108
40
    break;
109
40
  case 3:  // 4 strings to match.
110
10
    switch (Name[0]) {
111
10
    
default: break0
;
112
10
    case 'r':  // 2 strings to match.
113
6
      if (Name[1] != '1')
114
0
        break;
115
6
      switch (Name[2]) {
116
6
      
default: break0
;
117
6
      case '0':  // 1 string to match.
118
6
        return 11;  // "r10"
119
6
      case '1':  // 1 string to match.
120
0
        return 12;  // "r11"
121
0
      }
122
0
      break;
123
4
    case 'w':  // 2 strings to match.
124
4
      if (Name[1] != '1')
125
0
        break;
126
4
      switch (Name[2]) {
127
4
      
default: break0
;
128
4
      case '0':  // 1 string to match.
129
4
        return 23;  // "w10"
130
4
      case '1':  // 1 string to match.
131
0
        return 24;  // "w11"
132
0
      }
133
0
      break;
134
0
    }
135
0
    break;
136
95
  }
137
95
  return 0;
138
95
}
139
140
#endif // GET_REGISTER_MATCHER
141
142
143
#ifdef GET_SUBTARGET_FEATURE_NAME
144
#undef GET_SUBTARGET_FEATURE_NAME
145
146
// User-level names for subtarget features that participate in
147
// instruction matching.
148
static const char *getSubtargetFeatureName(uint64_t Val) {
149
  return "(unknown)";
150
}
151
152
#endif // GET_SUBTARGET_FEATURE_NAME
153
154
155
#ifdef GET_MATCHER_IMPLEMENTATION
156
#undef GET_MATCHER_IMPLEMENTATION
157
158
enum {
159
  Tie0_0_0,
160
  Tie0_0_3,
161
  Tie0_12_12,
162
};
163
164
static const uint8_t TiedAsmOperandTable[][3] = {
165
  /* Tie0_0_0 */ { 0, 0, 0 },
166
  /* Tie0_0_3 */ { 0, 0, 3 },
167
  /* Tie0_12_12 */ { 0, 12, 12 },
168
};
169
170
namespace {
171
enum OperatorConversionKind {
172
  CVT_Done,
173
  CVT_Reg,
174
  CVT_Tied,
175
  CVT_95_Reg,
176
  CVT_95_addImmOperands,
177
  CVT_imm_95_0,
178
  CVT_NUM_CONVERTERS
179
};
180
181
enum InstructionConversionKind {
182
  Convert__Reg1_0__Reg1_2,
183
  Convert__Reg1_0__Imm1_2,
184
  Convert__Reg1_0__Tie0_0_0__Reg1_3,
185
  Convert__Reg1_0__Tie0_0_0__Imm1_3,
186
  Convert__Reg1_0__Tie0_0_3,
187
  Convert__Reg1_0__Tie0_0_0__Reg1_4,
188
  Convert__Reg1_0__Tie0_0_0__Imm1_4,
189
  Convert__Reg1_0__Tie0_0_0__Reg1_5,
190
  Convert__Reg1_0__Tie0_0_0__Imm1_5,
191
  Convert__Reg1_0__Reg1_8__Imm1_9,
192
  Convert__Reg1_10__Reg1_6__Imm1_7,
193
  Convert__Imm1_1,
194
  Convert_NoOperands,
195
  Convert__Reg1_1__Reg1_3__Imm1_5,
196
  Convert__Reg1_1__Imm1_3__Imm1_5,
197
  Convert__Reg1_1__Reg1_4__Imm1_6,
198
  Convert__Reg1_1__Imm1_4__Imm1_6,
199
  Convert__Reg1_1__Reg1_5__Imm1_7,
200
  Convert__Reg1_1__Imm1_5__Imm1_7,
201
  Convert__Reg1_1__Imm1_2__Imm1_3,
202
  Convert__Reg1_1__Reg1_2__Imm1_3,
203
  Convert__Reg1_12__Reg1_7__Imm1_8__Tie0_12_12,
204
  Convert__imm_95_0__Reg1_9,
205
  Convert__imm_95_0__Imm1_9,
206
  CVT_NUM_SIGNATURES
207
};
208
209
} // end anonymous namespace
210
211
static const uint8_t ConversionTable[CVT_NUM_SIGNATURES][9] = {
212
  // Convert__Reg1_0__Reg1_2
213
  { CVT_95_Reg, 0, CVT_95_Reg, 2, CVT_Done },
214
  // Convert__Reg1_0__Imm1_2
215
  { CVT_95_Reg, 0, CVT_95_addImmOperands, 2, CVT_Done },
216
  // Convert__Reg1_0__Tie0_0_0__Reg1_3
217
  { CVT_95_Reg, 0, CVT_Tied, Tie0_0_0, CVT_95_Reg, 3, CVT_Done },
218
  // Convert__Reg1_0__Tie0_0_0__Imm1_3
219
  { CVT_95_Reg, 0, CVT_Tied, Tie0_0_0, CVT_95_addImmOperands, 3, CVT_Done },
220
  // Convert__Reg1_0__Tie0_0_3
221
  { CVT_95_Reg, 0, CVT_Tied, Tie0_0_3, CVT_Done },
222
  // Convert__Reg1_0__Tie0_0_0__Reg1_4
223
  { CVT_95_Reg, 0, CVT_Tied, Tie0_0_0, CVT_95_Reg, 4, CVT_Done },
224
  // Convert__Reg1_0__Tie0_0_0__Imm1_4
225
  { CVT_95_Reg, 0, CVT_Tied, Tie0_0_0, CVT_95_addImmOperands, 4, CVT_Done },
226
  // Convert__Reg1_0__Tie0_0_0__Reg1_5
227
  { CVT_95_Reg, 0, CVT_Tied, Tie0_0_0, CVT_95_Reg, 5, CVT_Done },
228
  // Convert__Reg1_0__Tie0_0_0__Imm1_5
229
  { CVT_95_Reg, 0, CVT_Tied, Tie0_0_0, CVT_95_addImmOperands, 5, CVT_Done },
230
  // Convert__Reg1_0__Reg1_8__Imm1_9
231
  { CVT_95_Reg, 0, CVT_95_Reg, 8, CVT_95_addImmOperands, 9, CVT_Done },
232
  // Convert__Reg1_10__Reg1_6__Imm1_7
233
  { CVT_95_Reg, 10, CVT_95_Reg, 6, CVT_95_addImmOperands, 7, CVT_Done },
234
  // Convert__Imm1_1
235
  { CVT_95_addImmOperands, 1, CVT_Done },
236
  // Convert_NoOperands
237
  { CVT_Done },
238
  // Convert__Reg1_1__Reg1_3__Imm1_5
239
  { CVT_95_Reg, 1, CVT_95_Reg, 3, CVT_95_addImmOperands, 5, CVT_Done },
240
  // Convert__Reg1_1__Imm1_3__Imm1_5
241
  { CVT_95_Reg, 1, CVT_95_addImmOperands, 3, CVT_95_addImmOperands, 5, CVT_Done },
242
  // Convert__Reg1_1__Reg1_4__Imm1_6
243
  { CVT_95_Reg, 1, CVT_95_Reg, 4, CVT_95_addImmOperands, 6, CVT_Done },
244
  // Convert__Reg1_1__Imm1_4__Imm1_6
245
  { CVT_95_Reg, 1, CVT_95_addImmOperands, 4, CVT_95_addImmOperands, 6, CVT_Done },
246
  // Convert__Reg1_1__Reg1_5__Imm1_7
247
  { CVT_95_Reg, 1, CVT_95_Reg, 5, CVT_95_addImmOperands, 7, CVT_Done },
248
  // Convert__Reg1_1__Imm1_5__Imm1_7
249
  { CVT_95_Reg, 1, CVT_95_addImmOperands, 5, CVT_95_addImmOperands, 7, CVT_Done },
250
  // Convert__Reg1_1__Imm1_2__Imm1_3
251
  { CVT_95_Reg, 1, CVT_95_addImmOperands, 2, CVT_95_addImmOperands, 3, CVT_Done },
252
  // Convert__Reg1_1__Reg1_2__Imm1_3
253
  { CVT_95_Reg, 1, CVT_95_Reg, 2, CVT_95_addImmOperands, 3, CVT_Done },
254
  // Convert__Reg1_12__Reg1_7__Imm1_8__Tie0_12_12
255
  { CVT_95_Reg, 12, CVT_95_Reg, 7, CVT_95_addImmOperands, 8, CVT_Tied, Tie0_12_12, CVT_Done },
256
  // Convert__imm_95_0__Reg1_9
257
  { CVT_imm_95_0, 0, CVT_95_Reg, 9, CVT_Done },
258
  // Convert__imm_95_0__Imm1_9
259
  { CVT_imm_95_0, 0, CVT_95_addImmOperands, 9, CVT_Done },
260
};
261
262
void BPFAsmParser::
263
convertToMCInst(unsigned Kind, MCInst &Inst, unsigned Opcode,
264
121
                const OperandVector &Operands) {
265
121
  assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
266
121
  const uint8_t *Converter = ConversionTable[Kind];
267
121
  unsigned OpIdx;
268
121
  Inst.setOpcode(Opcode);
269
459
  for (const uint8_t *p = Converter; *p; 
p+= 2338
) {
270
338
    OpIdx = *(p + 1);
271
338
    switch (*p) {
272
338
    
default: 0
llvm_unreachable0
("invalid conversion entry!");
273
338
    case CVT_Reg:
274
0
      static_cast<BPFOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
275
0
      break;
276
338
    case CVT_Tied: {
277
48
      assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
278
48
                          std::begin(TiedAsmOperandTable)) &&
279
48
             "Tied operand not found");
280
48
      unsigned TiedResOpnd = TiedAsmOperandTable[OpIdx][0];
281
48
      if (TiedResOpnd != (uint8_t) -1)
282
48
        Inst.addOperand(Inst.getOperand(TiedResOpnd));
283
48
      break;
284
338
    }
285
338
    case CVT_95_Reg:
286
174
      static_cast<BPFOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
287
174
      break;
288
338
    case CVT_95_addImmOperands:
289
110
      static_cast<BPFOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
290
110
      break;
291
338
    case CVT_imm_95_0:
292
6
      Inst.addOperand(MCOperand::createImm(0));
293
6
      break;
294
338
    }
295
338
  }
296
121
}
297
298
void BPFAsmParser::
299
convertToMapAndConstraints(unsigned Kind,
300
0
                           const OperandVector &Operands) {
301
0
  assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
302
0
  unsigned NumMCOperands = 0;
303
0
  const uint8_t *Converter = ConversionTable[Kind];
304
0
  for (const uint8_t *p = Converter; *p; p+= 2) {
305
0
    switch (*p) {
306
0
    default: llvm_unreachable("invalid conversion entry!");
307
0
    case CVT_Reg:
308
0
      Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
309
0
      Operands[*(p + 1)]->setConstraint("r");
310
0
      ++NumMCOperands;
311
0
      break;
312
0
    case CVT_Tied:
313
0
      ++NumMCOperands;
314
0
      break;
315
0
    case CVT_95_Reg:
316
0
      Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
317
0
      Operands[*(p + 1)]->setConstraint("r");
318
0
      NumMCOperands += 1;
319
0
      break;
320
0
    case CVT_95_addImmOperands:
321
0
      Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
322
0
      Operands[*(p + 1)]->setConstraint("m");
323
0
      NumMCOperands += 1;
324
0
      break;
325
0
    case CVT_imm_95_0:
326
0
      Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
327
0
      Operands[*(p + 1)]->setConstraint("");
328
0
      ++NumMCOperands;
329
0
      break;
330
0
    }
331
0
  }
332
0
}
333
334
namespace {
335
336
/// MatchClassKind - The kinds of classes which participate in
337
/// instruction matching.
338
enum MatchClassKind {
339
  InvalidMatchClass = 0,
340
  OptionalMatchClass = 1,
341
  MCK__EXCLAIM_, // '!'
342
  MCK__38_, // '&'
343
  MCK__40_, // '('
344
  MCK__41_, // ')'
345
  MCK__STAR_, // '*'
346
  MCK__43_, // '+'
347
  MCK__MINUS_, // '-'
348
  MCK__47_, // '/'
349
  MCK__LT_, // '<'
350
  MCK__61_, // '='
351
  MCK__GT_, // '>'
352
  MCK__91_, // '['
353
  MCK__93_, // ']'
354
  MCK__94_, // '^'
355
  MCK_be16, // 'be16'
356
  MCK_be32, // 'be32'
357
  MCK_be64, // 'be64'
358
  MCK_call, // 'call'
359
  MCK_callx, // 'callx'
360
  MCK_exit, // 'exit'
361
  MCK_goto, // 'goto'
362
  MCK_if, // 'if'
363
  MCK_ld_95_pseudo, // 'ld_pseudo'
364
  MCK_le16, // 'le16'
365
  MCK_le32, // 'le32'
366
  MCK_le64, // 'le64'
367
  MCK_lea, // 'lea'
368
  MCK_ll, // 'll'
369
  MCK_lock, // 'lock'
370
  MCK_nop, // 'nop'
371
  MCK_s, // 's'
372
  MCK_skb, // 'skb'
373
  MCK_u16, // 'u16'
374
  MCK_u32, // 'u32'
375
  MCK_u64, // 'u64'
376
  MCK_u8, // 'u8'
377
  MCK__124_, // '|'
378
  MCK_LAST_TOKEN = MCK__124_,
379
  MCK_R0, // register class 'R0'
380
  MCK_GPR, // register class 'GPR'
381
  MCK_GPR32, // register class 'GPR32'
382
  MCK_LAST_REGISTER = MCK_GPR32,
383
  MCK_Imm, // user defined class 'ImmAsmOperand'
384
  NumMatchClassKinds
385
};
386
387
}
388
389
1.87k
static unsigned getDiagKindFromRegisterClass(MatchClassKind RegisterClass) {
390
1.87k
  return MCTargetAsmParser::Match_InvalidOperand;
391
1.87k
}
392
393
2.34k
static MatchClassKind matchTokenString(StringRef Name) {
394
2.34k
  switch (Name.size()) {
395
2.34k
  
default: break0
;
396
2.34k
  case 1:  // 16 strings to match.
397
2.17k
    switch (Name[0]) {
398
2.17k
    
default: break0
;
399
2.17k
    case '!':  // 1 string to match.
400
22
      return MCK__EXCLAIM_;  // "!"
401
2.17k
    case '&':  // 1 string to match.
402
14
      return MCK__38_;  // "&"
403
2.17k
    case '(':  // 1 string to match.
404
116
      return MCK__40_;  // "("
405
2.17k
    case ')':  // 1 string to match.
406
57
      return MCK__41_;  // ")"
407
2.17k
    case '*':  // 1 string to match.
408
198
      return MCK__STAR_;  // "*"
409
2.17k
    case '+':  // 1 string to match.
410
34
      return MCK__43_;  // "+"
411
2.17k
    case '-':  // 1 string to match.
412
40
      return MCK__MINUS_;  // "-"
413
2.17k
    case '/':  // 1 string to match.
414
46
      return MCK__47_;  // "/"
415
2.17k
    case '<':  // 1 string to match.
416
158
      return MCK__LT_;  // "<"
417
2.17k
    case '=':  // 1 string to match.
418
739
      return MCK__61_;  // "="
419
2.17k
    case '>':  // 1 string to match.
420
218
      return MCK__GT_;  // ">"
421
2.17k
    case '[':  // 1 string to match.
422
9
      return MCK__91_;  // "["
423
2.17k
    case ']':  // 1 string to match.
424
6
      return MCK__93_;  // "]"
425
2.17k
    case '^':  // 1 string to match.
426
72
      return MCK__94_;  // "^"
427
2.17k
    case 's':  // 1 string to match.
428
368
      return MCK_s;  // "s"
429
2.17k
    case '|':  // 1 string to match.
430
80
      return MCK__124_;  // "|"
431
0
    }
432
0
    break;
433
43
  case 2:  // 3 strings to match.
434
43
    switch (Name[0]) {
435
43
    
default: break0
;
436
43
    case 'i':  // 1 string to match.
437
0
      if (Name[1] != 'f')
438
0
        break;
439
0
      return MCK_if;   // "if"
440
4
    case 'l':  // 1 string to match.
441
4
      if (Name[1] != 'l')
442
0
        break;
443
4
      return MCK_ll;   // "ll"
444
39
    case 'u':  // 1 string to match.
445
39
      if (Name[1] != '8')
446
0
        break;
447
39
      return MCK_u8;  // "u8"
448
0
    }
449
0
    break;
450
71
  case 3:  // 6 strings to match.
451
71
    switch (Name[0]) {
452
71
    
default: break0
;
453
71
    case 'l':  // 1 string to match.
454
0
      if (memcmp(Name.data()+1, "ea", 2) != 0)
455
0
        break;
456
0
      return MCK_lea;  // "lea"
457
0
    case 'n':  // 1 string to match.
458
0
      if (memcmp(Name.data()+1, "op", 2) != 0)
459
0
        break;
460
0
      return MCK_nop;  // "nop"
461
15
    case 's':  // 1 string to match.
462
15
      if (memcmp(Name.data()+1, "kb", 2) != 0)
463
0
        break;
464
15
      return MCK_skb;  // "skb"
465
56
    case 'u':  // 3 strings to match.
466
56
      switch (Name[1]) {
467
56
      
default: break0
;
468
56
      case '1':  // 1 string to match.
469
16
        if (Name[2] != '6')
470
0
          break;
471
16
        return MCK_u16;  // "u16"
472
29
      case '3':  // 1 string to match.
473
29
        if (Name[2] != '2')
474
0
          break;
475
29
        return MCK_u32;  // "u32"
476
29
      case '6':  // 1 string to match.
477
11
        if (Name[2] != '4')
478
0
          break;
479
11
        return MCK_u64;  // "u64"
480
0
      }
481
0
      break;
482
0
    }
483
0
    break;
484
49
  case 4:  // 10 strings to match.
485
49
    switch (Name[0]) {
486
49
    
default: break0
;
487
49
    case 'b':  // 3 strings to match.
488
9
      if (Name[1] != 'e')
489
0
        break;
490
9
      switch (Name[2]) {
491
9
      
default: break0
;
492
9
      case '1':  // 1 string to match.
493
2
        if (Name[3] != '6')
494
0
          break;
495
2
        return MCK_be16;   // "be16"
496
3
      case '3':  // 1 string to match.
497
3
        if (Name[3] != '2')
498
0
          break;
499
3
        return MCK_be32;   // "be32"
500
4
      case '6':  // 1 string to match.
501
4
        if (Name[3] != '4')
502
0
          break;
503
4
        return MCK_be64;  // "be64"
504
0
      }
505
0
      break;
506
0
    case 'c':  // 1 string to match.
507
0
      if (memcmp(Name.data()+1, "all", 3) != 0)
508
0
        break;
509
0
      return MCK_call;   // "call"
510
0
    case 'e':  // 1 string to match.
511
0
      if (memcmp(Name.data()+1, "xit", 3) != 0)
512
0
        break;
513
0
      return MCK_exit;   // "exit"
514
40
    case 'g':  // 1 string to match.
515
40
      if (memcmp(Name.data()+1, "oto", 3) != 0)
516
0
        break;
517
40
      return MCK_goto;   // "goto"
518
40
    case 'l':  // 4 strings to match.
519
0
      switch (Name[1]) {
520
0
      default: break;
521
0
      case 'e':  // 3 strings to match.
522
0
        switch (Name[2]) {
523
0
        default: break;
524
0
        case '1':  // 1 string to match.
525
0
          if (Name[3] != '6')
526
0
            break;
527
0
          return MCK_le16;   // "le16"
528
0
        case '3':  // 1 string to match.
529
0
          if (Name[3] != '2')
530
0
            break;
531
0
          return MCK_le32;   // "le32"
532
0
        case '6':  // 1 string to match.
533
0
          if (Name[3] != '4')
534
0
            break;
535
0
          return MCK_le64;  // "le64"
536
0
        }
537
0
        break;
538
0
      case 'o':  // 1 string to match.
539
0
        if (memcmp(Name.data()+2, "ck", 2) != 0)
540
0
          break;
541
0
        return MCK_lock;  // "lock"
542
0
      }
543
0
      break;
544
0
    }
545
0
    break;
546
0
  case 5:  // 1 string to match.
547
0
    if (memcmp(Name.data()+0, "callx", 5) != 0)
548
0
      break;
549
0
    return MCK_callx;  // "callx"
550
0
  case 9:  // 1 string to match.
551
0
    if (memcmp(Name.data()+0, "ld_pseudo", 9) != 0)
552
0
      break;
553
0
    return MCK_ld_95_pseudo;  // "ld_pseudo"
554
0
  }
555
0
  return InvalidMatchClass;
556
0
}
557
558
/// isSubclass - Compute whether \p A is a subclass of \p B.
559
9.11k
static bool isSubclass(MatchClassKind A, MatchClassKind B) {
560
9.11k
  if (A == B)
561
2.42k
    return true;
562
6.68k
563
6.68k
  switch (A) {
564
6.68k
  default:
565
5.93k
    return false;
566
6.68k
567
6.68k
  case MCK_R0:
568
755
    return B == MCK_GPR;
569
6.68k
  }
570
6.68k
}
571
572
6.08k
static unsigned validateOperandClass(MCParsedAsmOperand &GOp, MatchClassKind Kind) {
573
6.08k
  BPFOperand &Operand = (BPFOperand&)GOp;
574
6.08k
  if (Kind == InvalidMatchClass)
575
4
    return MCTargetAsmParser::Match_InvalidOperand;
576
6.08k
577
6.08k
  if (Operand.isToken() && 
Kind <= MCK_LAST_TOKEN2.41k
)
578
2.34k
    return isSubclass(matchTokenString(Operand.getToken()), Kind) ?
579
988
             MCTargetAsmParser::Match_Success :
580
2.34k
             
MCTargetAsmParser::Match_InvalidOperand1.35k
;
581
3.74k
582
3.74k
  switch (Kind) {
583
3.74k
  
default: break3.58k
;
584
3.74k
  // 'Imm' class
585
3.74k
  case MCK_Imm: {
586
162
    DiagnosticPredicate DP(Operand.isImm());
587
162
    if (DP.isMatch())
588
118
      return MCTargetAsmParser::Match_Success;
589
44
    break;
590
44
    }
591
3.62k
  } // end switch (Kind)
592
3.62k
593
3.62k
  if (Operand.isReg()) {
594
3.47k
    MatchClassKind OpKind;
595
3.47k
    switch (Operand.getReg()) {
596
3.47k
    
default: OpKind = InvalidMatchClass; break0
;
597
3.47k
    
case BPF::W0: OpKind = MCK_GPR32; break115
;
598
3.47k
    
case BPF::R0: OpKind = MCK_R0; break776
;
599
3.47k
    
case BPF::W1: OpKind = MCK_GPR32; break122
;
600
3.47k
    
case BPF::R1: OpKind = MCK_GPR; break55
;
601
3.47k
    
case BPF::W2: OpKind = MCK_GPR32; break116
;
602
3.47k
    
case BPF::R2: OpKind = MCK_GPR; break91
;
603
3.47k
    
case BPF::W3: OpKind = MCK_GPR32; break116
;
604
3.47k
    
case BPF::R3: OpKind = MCK_GPR; break70
;
605
3.47k
    
case BPF::W4: OpKind = MCK_GPR32; break146
;
606
3.47k
    
case BPF::R4: OpKind = MCK_GPR; break92
;
607
3.47k
    
case BPF::W5: OpKind = MCK_GPR32; break196
;
608
3.47k
    
case BPF::R5: OpKind = MCK_GPR; break141
;
609
3.47k
    
case BPF::W6: OpKind = MCK_GPR32; break164
;
610
3.47k
    
case BPF::R6: OpKind = MCK_GPR; break144
;
611
3.47k
    
case BPF::W7: OpKind = MCK_GPR32; break207
;
612
3.47k
    
case BPF::R7: OpKind = MCK_GPR; break170
;
613
3.47k
    
case BPF::W8: OpKind = MCK_GPR32; break140
;
614
3.47k
    
case BPF::R8: OpKind = MCK_GPR; break141
;
615
3.47k
    
case BPF::W9: OpKind = MCK_GPR32; break92
;
616
3.47k
    
case BPF::R9: OpKind = MCK_GPR; break164
;
617
3.47k
    
case BPF::W10: OpKind = MCK_GPR32; break107
;
618
3.47k
    
case BPF::R10: OpKind = MCK_GPR; break105
;
619
3.47k
    
case BPF::W11: OpKind = MCK_GPR32; break0
;
620
3.47k
    
case BPF::R11: OpKind = MCK_GPR; break0
;
621
3.47k
    }
622
3.47k
    return isSubclass(OpKind, Kind) ? 
(unsigned)MCTargetAsmParser::Match_Success1.68k
:
623
3.47k
                                      
getDiagKindFromRegisterClass(Kind)1.78k
;
624
3.47k
  }
625
157
626
157
  if (Kind > MCK_LAST_TOKEN && 
Kind <= MCK_LAST_REGISTER129
)
627
85
    return getDiagKindFromRegisterClass(Kind);
628
72
629
72
  return MCTargetAsmParser::Match_InvalidOperand;
630
72
}
631
632
#ifndef NDEBUG
633
const char *getMatchClassName(MatchClassKind Kind) {
634
  switch (Kind) {
635
  case InvalidMatchClass: return "InvalidMatchClass";
636
  case OptionalMatchClass: return "OptionalMatchClass";
637
  case MCK__EXCLAIM_: return "MCK__EXCLAIM_";
638
  case MCK__38_: return "MCK__38_";
639
  case MCK__40_: return "MCK__40_";
640
  case MCK__41_: return "MCK__41_";
641
  case MCK__STAR_: return "MCK__STAR_";
642
  case MCK__43_: return "MCK__43_";
643
  case MCK__MINUS_: return "MCK__MINUS_";
644
  case MCK__47_: return "MCK__47_";
645
  case MCK__LT_: return "MCK__LT_";
646
  case MCK__61_: return "MCK__61_";
647
  case MCK__GT_: return "MCK__GT_";
648
  case MCK__91_: return "MCK__91_";
649
  case MCK__93_: return "MCK__93_";
650
  case MCK__94_: return "MCK__94_";
651
  case MCK_be16: return "MCK_be16";
652
  case MCK_be32: return "MCK_be32";
653
  case MCK_be64: return "MCK_be64";
654
  case MCK_call: return "MCK_call";
655
  case MCK_callx: return "MCK_callx";
656
  case MCK_exit: return "MCK_exit";
657
  case MCK_goto: return "MCK_goto";
658
  case MCK_if: return "MCK_if";
659
  case MCK_ld_95_pseudo: return "MCK_ld_95_pseudo";
660
  case MCK_le16: return "MCK_le16";
661
  case MCK_le32: return "MCK_le32";
662
  case MCK_le64: return "MCK_le64";
663
  case MCK_lea: return "MCK_lea";
664
  case MCK_ll: return "MCK_ll";
665
  case MCK_lock: return "MCK_lock";
666
  case MCK_nop: return "MCK_nop";
667
  case MCK_s: return "MCK_s";
668
  case MCK_skb: return "MCK_skb";
669
  case MCK_u16: return "MCK_u16";
670
  case MCK_u32: return "MCK_u32";
671
  case MCK_u64: return "MCK_u64";
672
  case MCK_u8: return "MCK_u8";
673
  case MCK__124_: return "MCK__124_";
674
  case MCK_R0: return "MCK_R0";
675
  case MCK_GPR: return "MCK_GPR";
676
  case MCK_GPR32: return "MCK_GPR32";
677
  case MCK_Imm: return "MCK_Imm";
678
  case NumMatchClassKinds: return "NumMatchClassKinds";
679
  }
680
  llvm_unreachable("unhandled MatchClassKind!");
681
}
682
683
#endif // NDEBUG
684
FeatureBitset BPFAsmParser::
685
3
ComputeAvailableFeatures(const FeatureBitset& FB) const {
686
3
  FeatureBitset Features;
687
3
  return Features;
688
3
}
689
690
static bool checkAsmTiedOperandConstraints(const BPFAsmParser&AsmParser,
691
                               unsigned Kind,
692
                               const OperandVector &Operands,
693
121
                               uint64_t &ErrorInfo) {
694
121
  assert(Kind < CVT_NUM_SIGNATURES && "Invalid signature!");
695
121
  const uint8_t *Converter = ConversionTable[Kind];
696
459
  for (const uint8_t *p = Converter; *p; 
p+= 2338
) {
697
338
    switch (*p) {
698
338
    case CVT_Tied: {
699
48
      unsigned OpIdx = *(p+1);
700
48
      assert(OpIdx < (size_t)(std::end(TiedAsmOperandTable) -
701
48
                              std::begin(TiedAsmOperandTable)) &&
702
48
             "Tied operand not found");
703
48
      unsigned OpndNum1 = TiedAsmOperandTable[OpIdx][1];
704
48
      unsigned OpndNum2 = TiedAsmOperandTable[OpIdx][2];
705
48
      if (OpndNum1 != OpndNum2) {
706
5
        auto &SrcOp1 = Operands[OpndNum1];
707
5
        auto &SrcOp2 = Operands[OpndNum2];
708
5
        if (SrcOp1->isReg() && SrcOp2->isReg()) {
709
5
          if (!AsmParser.regsEqual(*SrcOp1, *SrcOp2)) {
710
0
            ErrorInfo = OpndNum2;
711
0
            return false;
712
0
          }
713
48
        }
714
5
      }
715
48
      break;
716
48
    }
717
290
    default:
718
290
      break;
719
338
    }
720
338
  }
721
121
  return true;
722
121
}
723
724
static const char *const MnemonicTable =
725
    "\000\001*\004call\005callx\004exit\004goto\002if\tld_pseudo\003lea\004l"
726
    "ock\003nop\002r0";
727
728
// Feature bitsets.
729
enum : uint8_t {
730
  AMFBS_None,
731
};
732
733
const static FeatureBitset FeatureBitsets[] {
734
  {}, // AMFBS_None
735
};
736
737
namespace {
738
  struct MatchEntry {
739
    uint8_t Mnemonic;
740
    uint16_t Opcode;
741
    uint8_t ConvertFn;
742
    uint8_t RequiredFeaturesIdx;
743
    uint8_t Classes[13];
744
685
    StringRef getMnemonic() const {
745
685
      return StringRef(MnemonicTable + Mnemonic + 1,
746
685
                       MnemonicTable[Mnemonic]);
747
685
    }
748
  };
749
750
  // Predicate for searching for an opcode.
751
  struct LessOpcode {
752
371
    bool operator()(const MatchEntry &LHS, StringRef RHS) {
753
371
      return LHS.getMnemonic() < RHS;
754
371
    }
755
314
    bool operator()(StringRef LHS, const MatchEntry &RHS) {
756
314
      return LHS < RHS.getMnemonic();
757
314
    }
758
0
    bool operator()(const MatchEntry &LHS, const MatchEntry &RHS) {
759
0
      return LHS.getMnemonic() < RHS.getMnemonic();
760
0
    }
761
  };
762
} // end anonymous namespace.
763
764
static const MatchEntry MatchTable0[] = {
765
  { 0 /*  */, BPF::MOV_rr, Convert__Reg1_0__Reg1_2, AMFBS_None, { MCK_GPR, MCK__61_, MCK_GPR }, },
766
  { 0 /*  */, BPF::MOV_ri, Convert__Reg1_0__Imm1_2, AMFBS_None, { MCK_GPR, MCK__61_, MCK_Imm }, },
767
  { 0 /*  */, BPF::MOV_rr_32, Convert__Reg1_0__Reg1_2, AMFBS_None, { MCK_GPR32, MCK__61_, MCK_GPR32 }, },
768
  { 0 /*  */, BPF::MOV_ri_32, Convert__Reg1_0__Imm1_2, AMFBS_None, { MCK_GPR32, MCK__61_, MCK_Imm }, },
769
  { 0 /*  */, BPF::AND_rr, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR, MCK__38_, MCK__61_, MCK_GPR }, },
770
  { 0 /*  */, BPF::AND_ri, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR, MCK__38_, MCK__61_, MCK_Imm }, },
771
  { 0 /*  */, BPF::MUL_rr, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR, MCK__STAR_, MCK__61_, MCK_GPR }, },
772
  { 0 /*  */, BPF::MUL_ri, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR, MCK__STAR_, MCK__61_, MCK_Imm }, },
773
  { 0 /*  */, BPF::ADD_rr, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR, MCK__43_, MCK__61_, MCK_GPR }, },
774
  { 0 /*  */, BPF::ADD_ri, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR, MCK__43_, MCK__61_, MCK_Imm }, },
775
  { 0 /*  */, BPF::SUB_rr, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR, MCK__MINUS_, MCK__61_, MCK_GPR }, },
776
  { 0 /*  */, BPF::SUB_ri, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR, MCK__MINUS_, MCK__61_, MCK_Imm }, },
777
  { 0 /*  */, BPF::DIV_rr, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR, MCK__47_, MCK__61_, MCK_GPR }, },
778
  { 0 /*  */, BPF::DIV_ri, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR, MCK__47_, MCK__61_, MCK_Imm }, },
779
  { 0 /*  */, BPF::NEG_64, Convert__Reg1_0__Tie0_0_3, AMFBS_None, { MCK_GPR, MCK__61_, MCK__MINUS_, MCK_GPR }, },
780
  { 0 /*  */, BPF::BE16, Convert__Reg1_0__Tie0_0_3, AMFBS_None, { MCK_GPR, MCK__61_, MCK_be16, MCK_GPR }, },
781
  { 0 /*  */, BPF::BE32, Convert__Reg1_0__Tie0_0_3, AMFBS_None, { MCK_GPR, MCK__61_, MCK_be32, MCK_GPR }, },
782
  { 0 /*  */, BPF::BE64, Convert__Reg1_0__Tie0_0_3, AMFBS_None, { MCK_GPR, MCK__61_, MCK_be64, MCK_GPR }, },
783
  { 0 /*  */, BPF::LE16, Convert__Reg1_0__Tie0_0_3, AMFBS_None, { MCK_GPR, MCK__61_, MCK_le16, MCK_GPR }, },
784
  { 0 /*  */, BPF::LE32, Convert__Reg1_0__Tie0_0_3, AMFBS_None, { MCK_GPR, MCK__61_, MCK_le32, MCK_GPR }, },
785
  { 0 /*  */, BPF::LE64, Convert__Reg1_0__Tie0_0_3, AMFBS_None, { MCK_GPR, MCK__61_, MCK_le64, MCK_GPR }, },
786
  { 0 /*  */, BPF::LD_imm64, Convert__Reg1_0__Imm1_2, AMFBS_None, { MCK_GPR, MCK__61_, MCK_Imm, MCK_ll }, },
787
  { 0 /*  */, BPF::XOR_rr, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR, MCK__94_, MCK__61_, MCK_GPR }, },
788
  { 0 /*  */, BPF::XOR_ri, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR, MCK__94_, MCK__61_, MCK_Imm }, },
789
  { 0 /*  */, BPF::OR_rr, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR, MCK__124_, MCK__61_, MCK_GPR }, },
790
  { 0 /*  */, BPF::OR_ri, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR, MCK__124_, MCK__61_, MCK_Imm }, },
791
  { 0 /*  */, BPF::AND_rr_32, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR32, MCK__38_, MCK__61_, MCK_GPR32 }, },
792
  { 0 /*  */, BPF::AND_ri_32, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR32, MCK__38_, MCK__61_, MCK_Imm }, },
793
  { 0 /*  */, BPF::MUL_rr_32, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR32, MCK__STAR_, MCK__61_, MCK_GPR32 }, },
794
  { 0 /*  */, BPF::MUL_ri_32, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR32, MCK__STAR_, MCK__61_, MCK_Imm }, },
795
  { 0 /*  */, BPF::ADD_rr_32, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR32, MCK__43_, MCK__61_, MCK_GPR32 }, },
796
  { 0 /*  */, BPF::ADD_ri_32, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR32, MCK__43_, MCK__61_, MCK_Imm }, },
797
  { 0 /*  */, BPF::SUB_rr_32, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR32, MCK__MINUS_, MCK__61_, MCK_GPR32 }, },
798
  { 0 /*  */, BPF::SUB_ri_32, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR32, MCK__MINUS_, MCK__61_, MCK_Imm }, },
799
  { 0 /*  */, BPF::DIV_rr_32, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR32, MCK__47_, MCK__61_, MCK_GPR32 }, },
800
  { 0 /*  */, BPF::DIV_ri_32, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR32, MCK__47_, MCK__61_, MCK_Imm }, },
801
  { 0 /*  */, BPF::NEG_32, Convert__Reg1_0__Tie0_0_3, AMFBS_None, { MCK_GPR32, MCK__61_, MCK__MINUS_, MCK_GPR32 }, },
802
  { 0 /*  */, BPF::XOR_rr_32, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR32, MCK__94_, MCK__61_, MCK_GPR32 }, },
803
  { 0 /*  */, BPF::XOR_ri_32, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR32, MCK__94_, MCK__61_, MCK_Imm }, },
804
  { 0 /*  */, BPF::OR_rr_32, Convert__Reg1_0__Tie0_0_0__Reg1_3, AMFBS_None, { MCK_GPR32, MCK__124_, MCK__61_, MCK_GPR32 }, },
805
  { 0 /*  */, BPF::OR_ri_32, Convert__Reg1_0__Tie0_0_0__Imm1_3, AMFBS_None, { MCK_GPR32, MCK__124_, MCK__61_, MCK_Imm }, },
806
  { 0 /*  */, BPF::SLL_rr, Convert__Reg1_0__Tie0_0_0__Reg1_4, AMFBS_None, { MCK_GPR, MCK__LT_, MCK__LT_, MCK__61_, MCK_GPR }, },
807
  { 0 /*  */, BPF::SLL_ri, Convert__Reg1_0__Tie0_0_0__Imm1_4, AMFBS_None, { MCK_GPR, MCK__LT_, MCK__LT_, MCK__61_, MCK_Imm }, },
808
  { 0 /*  */, BPF::SRL_rr, Convert__Reg1_0__Tie0_0_0__Reg1_4, AMFBS_None, { MCK_GPR, MCK__GT_, MCK__GT_, MCK__61_, MCK_GPR }, },
809
  { 0 /*  */, BPF::SRL_ri, Convert__Reg1_0__Tie0_0_0__Imm1_4, AMFBS_None, { MCK_GPR, MCK__GT_, MCK__GT_, MCK__61_, MCK_Imm }, },
810
  { 0 /*  */, BPF::SLL_rr_32, Convert__Reg1_0__Tie0_0_0__Reg1_4, AMFBS_None, { MCK_GPR32, MCK__LT_, MCK__LT_, MCK__61_, MCK_GPR32 }, },
811
  { 0 /*  */, BPF::SLL_ri_32, Convert__Reg1_0__Tie0_0_0__Imm1_4, AMFBS_None, { MCK_GPR32, MCK__LT_, MCK__LT_, MCK__61_, MCK_Imm }, },
812
  { 0 /*  */, BPF::SRL_rr_32, Convert__Reg1_0__Tie0_0_0__Reg1_4, AMFBS_None, { MCK_GPR32, MCK__GT_, MCK__GT_, MCK__61_, MCK_GPR32 }, },
813
  { 0 /*  */, BPF::SRL_ri_32, Convert__Reg1_0__Tie0_0_0__Imm1_4, AMFBS_None, { MCK_GPR32, MCK__GT_, MCK__GT_, MCK__61_, MCK_Imm }, },
814
  { 0 /*  */, BPF::SRA_rr, Convert__Reg1_0__Tie0_0_0__Reg1_5, AMFBS_None, { MCK_GPR, MCK_s, MCK__GT_, MCK__GT_, MCK__61_, MCK_GPR }, },
815
  { 0 /*  */, BPF::SRA_ri, Convert__Reg1_0__Tie0_0_0__Imm1_5, AMFBS_None, { MCK_GPR, MCK_s, MCK__GT_, MCK__GT_, MCK__61_, MCK_Imm }, },
816
  { 0 /*  */, BPF::SRA_rr_32, Convert__Reg1_0__Tie0_0_0__Reg1_5, AMFBS_None, { MCK_GPR32, MCK_s, MCK__GT_, MCK__GT_, MCK__61_, MCK_GPR32 }, },
817
  { 0 /*  */, BPF::SRA_ri_32, Convert__Reg1_0__Tie0_0_0__Imm1_5, AMFBS_None, { MCK_GPR32, MCK_s, MCK__GT_, MCK__GT_, MCK__61_, MCK_Imm }, },
818
  { 0 /*  */, BPF::LDH, Convert__Reg1_0__Reg1_8__Imm1_9, AMFBS_None, { MCK_GPR, MCK__61_, MCK__STAR_, MCK__40_, MCK_u16, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_ }, },
819
  { 0 /*  */, BPF::LDW, Convert__Reg1_0__Reg1_8__Imm1_9, AMFBS_None, { MCK_GPR, MCK__61_, MCK__STAR_, MCK__40_, MCK_u32, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_ }, },
820
  { 0 /*  */, BPF::LDD, Convert__Reg1_0__Reg1_8__Imm1_9, AMFBS_None, { MCK_GPR, MCK__61_, MCK__STAR_, MCK__40_, MCK_u64, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_ }, },
821
  { 0 /*  */, BPF::LDB, Convert__Reg1_0__Reg1_8__Imm1_9, AMFBS_None, { MCK_GPR, MCK__61_, MCK__STAR_, MCK__40_, MCK_u8, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_ }, },
822
  { 0 /*  */, BPF::LDH32, Convert__Reg1_0__Reg1_8__Imm1_9, AMFBS_None, { MCK_GPR32, MCK__61_, MCK__STAR_, MCK__40_, MCK_u16, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_ }, },
823
  { 0 /*  */, BPF::LDW32, Convert__Reg1_0__Reg1_8__Imm1_9, AMFBS_None, { MCK_GPR32, MCK__61_, MCK__STAR_, MCK__40_, MCK_u32, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_ }, },
824
  { 0 /*  */, BPF::LDB32, Convert__Reg1_0__Reg1_8__Imm1_9, AMFBS_None, { MCK_GPR32, MCK__61_, MCK__STAR_, MCK__40_, MCK_u8, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_ }, },
825
  { 1 /* * */, BPF::STH, Convert__Reg1_10__Reg1_6__Imm1_7, AMFBS_None, { MCK__STAR_, MCK__40_, MCK_u16, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_, MCK__61_, MCK_GPR }, },
826
  { 1 /* * */, BPF::STH32, Convert__Reg1_10__Reg1_6__Imm1_7, AMFBS_None, { MCK__STAR_, MCK__40_, MCK_u16, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_, MCK__61_, MCK_GPR32 }, },
827
  { 1 /* * */, BPF::STW, Convert__Reg1_10__Reg1_6__Imm1_7, AMFBS_None, { MCK__STAR_, MCK__40_, MCK_u32, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_, MCK__61_, MCK_GPR }, },
828
  { 1 /* * */, BPF::STW32, Convert__Reg1_10__Reg1_6__Imm1_7, AMFBS_None, { MCK__STAR_, MCK__40_, MCK_u32, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_, MCK__61_, MCK_GPR32 }, },
829
  { 1 /* * */, BPF::STD, Convert__Reg1_10__Reg1_6__Imm1_7, AMFBS_None, { MCK__STAR_, MCK__40_, MCK_u64, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_, MCK__61_, MCK_GPR }, },
830
  { 1 /* * */, BPF::STB, Convert__Reg1_10__Reg1_6__Imm1_7, AMFBS_None, { MCK__STAR_, MCK__40_, MCK_u8, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_, MCK__61_, MCK_GPR }, },
831
  { 1 /* * */, BPF::STB32, Convert__Reg1_10__Reg1_6__Imm1_7, AMFBS_None, { MCK__STAR_, MCK__40_, MCK_u8, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_, MCK__61_, MCK_GPR32 }, },
832
  { 3 /* call */, BPF::JAL, Convert__Imm1_1, AMFBS_None, { MCK_call, MCK_Imm }, },
833
  { 8 /* callx */, BPF::JALX, Convert__Imm1_1, AMFBS_None, { MCK_callx, MCK_Imm }, },
834
  { 14 /* exit */, BPF::RET, Convert_NoOperands, AMFBS_None, { MCK_exit }, },
835
  { 19 /* goto */, BPF::JMP, Convert__Imm1_1, AMFBS_None, { MCK_goto, MCK_Imm }, },
836
  { 24 /* if */, BPF::JULT_rr, Convert__Reg1_1__Reg1_3__Imm1_5, AMFBS_None, { MCK_if, MCK_GPR, MCK__LT_, MCK_GPR, MCK_goto, MCK_Imm }, },
837
  { 24 /* if */, BPF::JULT_ri, Convert__Reg1_1__Imm1_3__Imm1_5, AMFBS_None, { MCK_if, MCK_GPR, MCK__LT_, MCK_Imm, MCK_goto, MCK_Imm }, },
838
  { 24 /* if */, BPF::JUGT_rr, Convert__Reg1_1__Reg1_3__Imm1_5, AMFBS_None, { MCK_if, MCK_GPR, MCK__GT_, MCK_GPR, MCK_goto, MCK_Imm }, },
839
  { 24 /* if */, BPF::JUGT_ri, Convert__Reg1_1__Imm1_3__Imm1_5, AMFBS_None, { MCK_if, MCK_GPR, MCK__GT_, MCK_Imm, MCK_goto, MCK_Imm }, },
840
  { 24 /* if */, BPF::JULT_rr_32, Convert__Reg1_1__Reg1_3__Imm1_5, AMFBS_None, { MCK_if, MCK_GPR32, MCK__LT_, MCK_GPR32, MCK_goto, MCK_Imm }, },
841
  { 24 /* if */, BPF::JULT_ri_32, Convert__Reg1_1__Imm1_3__Imm1_5, AMFBS_None, { MCK_if, MCK_GPR32, MCK__LT_, MCK_Imm, MCK_goto, MCK_Imm }, },
842
  { 24 /* if */, BPF::JUGT_rr_32, Convert__Reg1_1__Reg1_3__Imm1_5, AMFBS_None, { MCK_if, MCK_GPR32, MCK__GT_, MCK_GPR32, MCK_goto, MCK_Imm }, },
843
  { 24 /* if */, BPF::JUGT_ri_32, Convert__Reg1_1__Imm1_3__Imm1_5, AMFBS_None, { MCK_if, MCK_GPR32, MCK__GT_, MCK_Imm, MCK_goto, MCK_Imm }, },
844
  { 24 /* if */, BPF::JNE_rr, Convert__Reg1_1__Reg1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR, MCK__EXCLAIM_, MCK__61_, MCK_GPR, MCK_goto, MCK_Imm }, },
845
  { 24 /* if */, BPF::JNE_ri, Convert__Reg1_1__Imm1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR, MCK__EXCLAIM_, MCK__61_, MCK_Imm, MCK_goto, MCK_Imm }, },
846
  { 24 /* if */, BPF::JULE_rr, Convert__Reg1_1__Reg1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR, MCK__LT_, MCK__61_, MCK_GPR, MCK_goto, MCK_Imm }, },
847
  { 24 /* if */, BPF::JULE_ri, Convert__Reg1_1__Imm1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR, MCK__LT_, MCK__61_, MCK_Imm, MCK_goto, MCK_Imm }, },
848
  { 24 /* if */, BPF::JEQ_rr, Convert__Reg1_1__Reg1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR, MCK__61_, MCK__61_, MCK_GPR, MCK_goto, MCK_Imm }, },
849
  { 24 /* if */, BPF::JEQ_ri, Convert__Reg1_1__Imm1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR, MCK__61_, MCK__61_, MCK_Imm, MCK_goto, MCK_Imm }, },
850
  { 24 /* if */, BPF::JUGE_rr, Convert__Reg1_1__Reg1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR, MCK__GT_, MCK__61_, MCK_GPR, MCK_goto, MCK_Imm }, },
851
  { 24 /* if */, BPF::JUGE_ri, Convert__Reg1_1__Imm1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR, MCK__GT_, MCK__61_, MCK_Imm, MCK_goto, MCK_Imm }, },
852
  { 24 /* if */, BPF::JSLT_rr, Convert__Reg1_1__Reg1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR, MCK_s, MCK__LT_, MCK_GPR, MCK_goto, MCK_Imm }, },
853
  { 24 /* if */, BPF::JSLT_ri, Convert__Reg1_1__Imm1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR, MCK_s, MCK__LT_, MCK_Imm, MCK_goto, MCK_Imm }, },
854
  { 24 /* if */, BPF::JSGT_rr, Convert__Reg1_1__Reg1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR, MCK_s, MCK__GT_, MCK_GPR, MCK_goto, MCK_Imm }, },
855
  { 24 /* if */, BPF::JSGT_ri, Convert__Reg1_1__Imm1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR, MCK_s, MCK__GT_, MCK_Imm, MCK_goto, MCK_Imm }, },
856
  { 24 /* if */, BPF::JNE_rr_32, Convert__Reg1_1__Reg1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR32, MCK__EXCLAIM_, MCK__61_, MCK_GPR32, MCK_goto, MCK_Imm }, },
857
  { 24 /* if */, BPF::JNE_ri_32, Convert__Reg1_1__Imm1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR32, MCK__EXCLAIM_, MCK__61_, MCK_Imm, MCK_goto, MCK_Imm }, },
858
  { 24 /* if */, BPF::JULE_rr_32, Convert__Reg1_1__Reg1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR32, MCK__LT_, MCK__61_, MCK_GPR32, MCK_goto, MCK_Imm }, },
859
  { 24 /* if */, BPF::JULE_ri_32, Convert__Reg1_1__Imm1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR32, MCK__LT_, MCK__61_, MCK_Imm, MCK_goto, MCK_Imm }, },
860
  { 24 /* if */, BPF::JEQ_rr_32, Convert__Reg1_1__Reg1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR32, MCK__61_, MCK__61_, MCK_GPR32, MCK_goto, MCK_Imm }, },
861
  { 24 /* if */, BPF::JEQ_ri_32, Convert__Reg1_1__Imm1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR32, MCK__61_, MCK__61_, MCK_Imm, MCK_goto, MCK_Imm }, },
862
  { 24 /* if */, BPF::JUGE_rr_32, Convert__Reg1_1__Reg1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR32, MCK__GT_, MCK__61_, MCK_GPR32, MCK_goto, MCK_Imm }, },
863
  { 24 /* if */, BPF::JUGE_ri_32, Convert__Reg1_1__Imm1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR32, MCK__GT_, MCK__61_, MCK_Imm, MCK_goto, MCK_Imm }, },
864
  { 24 /* if */, BPF::JSLT_rr_32, Convert__Reg1_1__Reg1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR32, MCK_s, MCK__LT_, MCK_GPR32, MCK_goto, MCK_Imm }, },
865
  { 24 /* if */, BPF::JSLT_ri_32, Convert__Reg1_1__Imm1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR32, MCK_s, MCK__LT_, MCK_Imm, MCK_goto, MCK_Imm }, },
866
  { 24 /* if */, BPF::JSGT_rr_32, Convert__Reg1_1__Reg1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR32, MCK_s, MCK__GT_, MCK_GPR32, MCK_goto, MCK_Imm }, },
867
  { 24 /* if */, BPF::JSGT_ri_32, Convert__Reg1_1__Imm1_4__Imm1_6, AMFBS_None, { MCK_if, MCK_GPR32, MCK_s, MCK__GT_, MCK_Imm, MCK_goto, MCK_Imm }, },
868
  { 24 /* if */, BPF::JSLE_rr, Convert__Reg1_1__Reg1_5__Imm1_7, AMFBS_None, { MCK_if, MCK_GPR, MCK_s, MCK__LT_, MCK__61_, MCK_GPR, MCK_goto, MCK_Imm }, },
869
  { 24 /* if */, BPF::JSLE_ri, Convert__Reg1_1__Imm1_5__Imm1_7, AMFBS_None, { MCK_if, MCK_GPR, MCK_s, MCK__LT_, MCK__61_, MCK_Imm, MCK_goto, MCK_Imm }, },
870
  { 24 /* if */, BPF::JSGE_rr, Convert__Reg1_1__Reg1_5__Imm1_7, AMFBS_None, { MCK_if, MCK_GPR, MCK_s, MCK__GT_, MCK__61_, MCK_GPR, MCK_goto, MCK_Imm }, },
871
  { 24 /* if */, BPF::JSGE_ri, Convert__Reg1_1__Imm1_5__Imm1_7, AMFBS_None, { MCK_if, MCK_GPR, MCK_s, MCK__GT_, MCK__61_, MCK_Imm, MCK_goto, MCK_Imm }, },
872
  { 24 /* if */, BPF::JSLE_rr_32, Convert__Reg1_1__Reg1_5__Imm1_7, AMFBS_None, { MCK_if, MCK_GPR32, MCK_s, MCK__LT_, MCK__61_, MCK_GPR32, MCK_goto, MCK_Imm }, },
873
  { 24 /* if */, BPF::JSLE_ri_32, Convert__Reg1_1__Imm1_5__Imm1_7, AMFBS_None, { MCK_if, MCK_GPR32, MCK_s, MCK__LT_, MCK__61_, MCK_Imm, MCK_goto, MCK_Imm }, },
874
  { 24 /* if */, BPF::JSGE_rr_32, Convert__Reg1_1__Reg1_5__Imm1_7, AMFBS_None, { MCK_if, MCK_GPR32, MCK_s, MCK__GT_, MCK__61_, MCK_GPR32, MCK_goto, MCK_Imm }, },
875
  { 24 /* if */, BPF::JSGE_ri_32, Convert__Reg1_1__Imm1_5__Imm1_7, AMFBS_None, { MCK_if, MCK_GPR32, MCK_s, MCK__GT_, MCK__61_, MCK_Imm, MCK_goto, MCK_Imm }, },
876
  { 27 /* ld_pseudo */, BPF::LD_pseudo, Convert__Reg1_1__Imm1_2__Imm1_3, AMFBS_None, { MCK_ld_95_pseudo, MCK_GPR, MCK_Imm, MCK_Imm }, },
877
  { 37 /* lea */, BPF::FI_ri, Convert__Reg1_1__Reg1_2__Imm1_3, AMFBS_None, { MCK_lea, MCK_GPR, MCK_GPR, MCK_Imm }, },
878
  { 41 /* lock */, BPF::XADDW, Convert__Reg1_12__Reg1_7__Imm1_8__Tie0_12_12, AMFBS_None, { MCK_lock, MCK__STAR_, MCK__40_, MCK_u32, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_, MCK__43_, MCK__61_, MCK_GPR }, },
879
  { 41 /* lock */, BPF::XADDW32, Convert__Reg1_12__Reg1_7__Imm1_8__Tie0_12_12, AMFBS_None, { MCK_lock, MCK__STAR_, MCK__40_, MCK_u32, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_, MCK__43_, MCK__61_, MCK_GPR32 }, },
880
  { 41 /* lock */, BPF::XADDD, Convert__Reg1_12__Reg1_7__Imm1_8__Tie0_12_12, AMFBS_None, { MCK_lock, MCK__STAR_, MCK__40_, MCK_u64, MCK__STAR_, MCK__41_, MCK__40_, MCK_GPR, MCK_Imm, MCK__41_, MCK__43_, MCK__61_, MCK_GPR }, },
881
  { 46 /* nop */, BPF::NOP, Convert__Imm1_1, AMFBS_None, { MCK_nop, MCK_Imm }, },
882
  { 50 /* r0 */, BPF::LD_IND_H, Convert__imm_95_0__Reg1_9, AMFBS_None, { MCK_R0, MCK__61_, MCK__STAR_, MCK__40_, MCK_u16, MCK__STAR_, MCK__41_, MCK_skb, MCK__91_, MCK_GPR, MCK__93_ }, },
883
  { 50 /* r0 */, BPF::LD_ABS_H, Convert__imm_95_0__Imm1_9, AMFBS_None, { MCK_R0, MCK__61_, MCK__STAR_, MCK__40_, MCK_u16, MCK__STAR_, MCK__41_, MCK_skb, MCK__91_, MCK_Imm, MCK__93_ }, },
884
  { 50 /* r0 */, BPF::LD_IND_W, Convert__imm_95_0__Reg1_9, AMFBS_None, { MCK_R0, MCK__61_, MCK__STAR_, MCK__40_, MCK_u32, MCK__STAR_, MCK__41_, MCK_skb, MCK__91_, MCK_GPR, MCK__93_ }, },
885
  { 50 /* r0 */, BPF::LD_ABS_W, Convert__imm_95_0__Imm1_9, AMFBS_None, { MCK_R0, MCK__61_, MCK__STAR_, MCK__40_, MCK_u32, MCK__STAR_, MCK__41_, MCK_skb, MCK__91_, MCK_Imm, MCK__93_ }, },
886
  { 50 /* r0 */, BPF::LD_IND_B, Convert__imm_95_0__Reg1_9, AMFBS_None, { MCK_R0, MCK__61_, MCK__STAR_, MCK__40_, MCK_u8, MCK__STAR_, MCK__41_, MCK_skb, MCK__91_, MCK_GPR, MCK__93_ }, },
887
  { 50 /* r0 */, BPF::LD_ABS_B, Convert__imm_95_0__Imm1_9, AMFBS_None, { MCK_R0, MCK__61_, MCK__STAR_, MCK__40_, MCK_u8, MCK__STAR_, MCK__41_, MCK_skb, MCK__91_, MCK_Imm, MCK__93_ }, },
888
};
889
890
#include "llvm/Support/Debug.h"
891
#include "llvm/Support/Format.h"
892
893
unsigned BPFAsmParser::
894
MatchInstructionImpl(const OperandVector &Operands,
895
                     MCInst &Inst,
896
                     uint64_t &ErrorInfo,
897
                     FeatureBitset &MissingFeatures,
898
121
                     bool matchingInlineAsm, unsigned VariantID) {
899
121
  // Eliminate obvious mismatches.
900
121
  if (Operands.size() > 13) {
901
0
    ErrorInfo = 13;
902
0
    return Match_InvalidOperand;
903
0
  }
904
121
905
121
  // Get the current feature set.
906
121
  const FeatureBitset &AvailableFeatures = getAvailableFeatures();
907
121
908
121
  // Get the instruction mnemonic, which is the first token.
909
121
  StringRef Mnemonic;
910
121
  if (Operands[0]->isToken())
911
53
    Mnemonic = ((BPFOperand&)*Operands[0]).getToken();
912
121
913
121
  // Some state to try to produce better error messages.
914
121
  bool HadMatchOtherThanFeatures = false;
915
121
  bool HadMatchOtherThanPredicate = false;
916
121
  unsigned RetCode = Match_InvalidOperand;
917
121
  MissingFeatures.set();
918
121
  // Set ErrorInfo to the operand that mismatches if it is
919
121
  // wrong for all instances of the instruction.
920
121
  ErrorInfo = ~0ULL;
921
121
  // Find the appropriate table for this asm variant.
922
121
  const MatchEntry *Start, *End;
923
121
  switch (VariantID) {
924
121
  
default: 0
llvm_unreachable0
("invalid variant!");
925
121
  case 0: Start = std::begin(MatchTable0); End = std::end(MatchTable0); break;
926
121
  }
927
121
  // Search the table.
928
121
  auto MnemonicRange = std::make_pair(Start, End);
929
121
  unsigned SIndex = Mnemonic.empty() ? 
068
:
153
;
930
121
  if (!Mnemonic.empty())
931
53
    MnemonicRange = std::equal_range(Start, End, Mnemonic.lower(), LessOpcode());
932
121
933
121
  DEBUG_WITH_TYPE("asm-matcher", dbgs() << "AsmMatcher: found " <<
934
121
  std::distance(MnemonicRange.first, MnemonicRange.second) << 
935
121
  " encodings with mnemonic '" << Mnemonic << "'\n");
936
121
937
121
  // Return a more specific error code if no mnemonics match.
938
121
  if (MnemonicRange.first == MnemonicRange.second)
939
0
    return Match_MnemonicFail;
940
121
941
121
  for (const MatchEntry *it = MnemonicRange.first, *ie = MnemonicRange.second;
942
3.42k
       it != ie; 
++it3.30k
) {
943
3.42k
    const FeatureBitset &RequiredFeatures = FeatureBitsets[it->RequiredFeaturesIdx];
944
3.42k
    bool HasRequiredFeatures =
945
3.42k
      (AvailableFeatures & RequiredFeatures) == RequiredFeatures;
946
3.42k
    DEBUG_WITH_TYPE("asm-matcher", dbgs() << "Trying to match opcode "
947
3.42k
                                          << MII.getName(it->Opcode) << "\n");
948
3.42k
    bool OperandsValid = true;
949
6.21k
    for (unsigned FormalIdx = SIndex, ActualIdx = SIndex; FormalIdx != 13; 
++FormalIdx2.78k
) {
950
6.20k
      auto Formal = static_cast<MatchClassKind>(it->Classes[FormalIdx]);
951
6.20k
      DEBUG_WITH_TYPE("asm-matcher",
952
6.20k
                      dbgs() << "  Matching formal operand class " << getMatchClassName(Formal)
953
6.20k
                             << " against actual operand at index " << ActualIdx);
954
6.20k
      if (ActualIdx < Operands.size())
955
6.20k
        
DEBUG_WITH_TYPE6.08k
("asm-matcher", dbgs() << " (";
956
6.20k
                        Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
957
6.20k
      else
958
6.20k
        
DEBUG_WITH_TYPE118
("asm-matcher", dbgs() << ": ");
959
6.20k
      if (ActualIdx >= Operands.size()) {
960
118
        DEBUG_WITH_TYPE("asm-matcher", dbgs() << "actual operand index out of range ");
961
118
        OperandsValid = (Formal == InvalidMatchClass) || 
isSubclass(Formal, OptionalMatchClass)0
;
962
118
        if (!OperandsValid) 
ErrorInfo = ActualIdx0
;
963
118
        break;
964
118
      }
965
6.08k
      MCParsedAsmOperand &Actual = *Operands[ActualIdx];
966
6.08k
      unsigned Diag = validateOperandClass(Actual, Formal);
967
6.08k
      if (Diag == Match_Success) {
968
2.78k
        DEBUG_WITH_TYPE("asm-matcher",
969
2.78k
                        dbgs() << "match success using generic matcher\n");
970
2.78k
        ++ActualIdx;
971
2.78k
        continue;
972
2.78k
      }
973
3.30k
      // If the generic handler indicates an invalid operand
974
3.30k
      // failure, check for a special case.
975
3.30k
      if (Diag != Match_Success) {
976
3.30k
        unsigned TargetDiag = validateTargetOperandClass(Actual, Formal);
977
3.30k
        if (TargetDiag == Match_Success) {
978
0
          DEBUG_WITH_TYPE("asm-matcher",
979
0
                          dbgs() << "match success using target matcher\n");
980
0
          ++ActualIdx;
981
0
          continue;
982
0
        }
983
3.30k
        // If the target matcher returned a specific error code use
984
3.30k
        // that, else use the one from the generic matcher.
985
3.30k
        if (TargetDiag != Match_InvalidOperand && 
HasRequiredFeatures0
)
986
0
          Diag = TargetDiag;
987
3.30k
      }
988
3.30k
      // If current formal operand wasn't matched and it is optional
989
3.30k
      // then try to match next formal operand
990
3.30k
      if (Diag == Match_InvalidOperand && isSubclass(Formal, OptionalMatchClass)) {
991
0
        DEBUG_WITH_TYPE("asm-matcher", dbgs() << "ignoring optional operand\n");
992
0
        continue;
993
0
      }
994
3.30k
      // If this operand is broken for all of the instances of this
995
3.30k
      // mnemonic, keep track of it so we can report loc info.
996
3.30k
      // If we already had a match that only failed due to a
997
3.30k
      // target predicate, that diagnostic is preferred.
998
3.30k
      if (!HadMatchOtherThanPredicate &&
999
3.30k
          (it == MnemonicRange.first || 
ErrorInfo <= ActualIdx3.18k
)) {
1000
1.19k
        if (HasRequiredFeatures && (ErrorInfo != ActualIdx || 
Diag != Match_InvalidOperand954
))
1001
241
          RetCode = Diag;
1002
1.19k
        ErrorInfo = ActualIdx;
1003
1.19k
      }
1004
3.30k
      // Otherwise, just reject this instance of the mnemonic.
1005
3.30k
      OperandsValid = false;
1006
3.30k
      break;
1007
3.30k
    }
1008
3.42k
1009
3.42k
    if (!OperandsValid) {
1010
3.30k
      DEBUG_WITH_TYPE("asm-matcher", dbgs() << "Opcode result: multiple "
1011
3.30k
                                               "operand mismatches, ignoring "
1012
3.30k
                                               "this opcode\n");
1013
3.30k
      continue;
1014
3.30k
    }
1015
121
    if (!HasRequiredFeatures) {
1016
0
      HadMatchOtherThanFeatures = true;
1017
0
      FeatureBitset NewMissingFeatures = RequiredFeatures & ~AvailableFeatures;
1018
0
      DEBUG_WITH_TYPE("asm-matcher", dbgs() << "Missing target features:";
1019
0
                       for (unsigned I = 0, E = NewMissingFeatures.size(); I != E; ++I)
1020
0
                         if (NewMissingFeatures[I])
1021
0
                           dbgs() << ' ' << I;
1022
0
                       dbgs() << "\n");
1023
0
      if (NewMissingFeatures.count() <=
1024
0
          MissingFeatures.count())
1025
0
        MissingFeatures = NewMissingFeatures;
1026
0
      continue;
1027
0
    }
1028
121
1029
121
    Inst.clear();
1030
121
1031
121
    Inst.setOpcode(it->Opcode);
1032
121
    // We have a potential match but have not rendered the operands.
1033
121
    // Check the target predicate to handle any context sensitive
1034
121
    // constraints.
1035
121
    // For example, Ties that are referenced multiple times must be
1036
121
    // checked here to ensure the input is the same for each match
1037
121
    // constraints. If we leave it any later the ties will have been
1038
121
    // canonicalized
1039
121
    unsigned MatchResult;
1040
121
    if ((MatchResult = checkEarlyTargetMatchPredicate(Inst, Operands)) != Match_Success) {
1041
0
      Inst.clear();
1042
0
      DEBUG_WITH_TYPE(
1043
0
          "asm-matcher",
1044
0
          dbgs() << "Early target match predicate failed with diag code "
1045
0
                 << MatchResult << "\n");
1046
0
      RetCode = MatchResult;
1047
0
      HadMatchOtherThanPredicate = true;
1048
0
      continue;
1049
0
    }
1050
121
1051
121
    if (matchingInlineAsm) {
1052
0
      convertToMapAndConstraints(it->ConvertFn, Operands);
1053
0
      if (!checkAsmTiedOperandConstraints(*this, it->ConvertFn, Operands, ErrorInfo))
1054
0
        return Match_InvalidTiedOperand;
1055
0
1056
0
      return Match_Success;
1057
0
    }
1058
121
1059
121
    // We have selected a definite instruction, convert the parsed
1060
121
    // operands into the appropriate MCInst.
1061
121
    convertToMCInst(it->ConvertFn, Inst, it->Opcode, Operands);
1062
121
1063
121
    // We have a potential match. Check the target predicate to
1064
121
    // handle any context sensitive constraints.
1065
121
    if ((MatchResult = checkTargetMatchPredicate(Inst)) != Match_Success) {
1066
0
      DEBUG_WITH_TYPE("asm-matcher",
1067
0
                      dbgs() << "Target match predicate failed with diag code "
1068
0
                             << MatchResult << "\n");
1069
0
      Inst.clear();
1070
0
      RetCode = MatchResult;
1071
0
      HadMatchOtherThanPredicate = true;
1072
0
      continue;
1073
0
    }
1074
121
1075
121
    if (!checkAsmTiedOperandConstraints(*this, it->ConvertFn, Operands, ErrorInfo))
1076
0
      return Match_InvalidTiedOperand;
1077
121
1078
121
    DEBUG_WITH_TYPE(
1079
121
        "asm-matcher",
1080
121
        dbgs() << "Opcode result: complete match, selecting this opcode\n");
1081
121
    return Match_Success;
1082
121
  }
1083
121
1084
121
  // Okay, we had no match.  Try to return a useful error code.
1085
121
  
if (0
HadMatchOtherThanPredicate0
||
!HadMatchOtherThanFeatures0
)
1086
0
    return RetCode;
1087
0
1088
0
  ErrorInfo = 0;
1089
0
  return Match_MissingFeature;
1090
0
}
1091
1092
#endif // GET_MATCHER_IMPLEMENTATION
1093
1094
1095
#ifdef GET_MNEMONIC_SPELL_CHECKER
1096
#undef GET_MNEMONIC_SPELL_CHECKER
1097
1098
static std::string BPFMnemonicSpellCheck(StringRef S, const FeatureBitset &FBS, unsigned VariantID) {
1099
  const unsigned MaxEditDist = 2;
1100
  std::vector<StringRef> Candidates;
1101
  StringRef Prev = "";
1102
1103
  // Find the appropriate table for this asm variant.
1104
  const MatchEntry *Start, *End;
1105
  switch (VariantID) {
1106
  default: llvm_unreachable("invalid variant!");
1107
  case 0: Start = std::begin(MatchTable0); End = std::end(MatchTable0); break;
1108
  }
1109
1110
  for (auto I = Start; I < End; I++) {
1111
    // Ignore unsupported instructions.
1112
    const FeatureBitset &RequiredFeatures = FeatureBitsets[I->RequiredFeaturesIdx];
1113
    if ((FBS & RequiredFeatures) != RequiredFeatures)
1114
      continue;
1115
1116
    StringRef T = I->getMnemonic();
1117
    // Avoid recomputing the edit distance for the same string.
1118
    if (T.equals(Prev))
1119
      continue;
1120
1121
    Prev = T;
1122
    unsigned Dist = S.edit_distance(T, false, MaxEditDist);
1123
    if (Dist <= MaxEditDist)
1124
      Candidates.push_back(T);
1125
  }
1126
1127
  if (Candidates.empty())
1128
    return "";
1129
1130
  std::string Res = ", did you mean: ";
1131
  unsigned i = 0;
1132
  for( ; i < Candidates.size() - 1; i++)
1133
    Res += Candidates[i].str() + ", ";
1134
  return Res + Candidates[i].str() + "?";
1135
}
1136
1137
#endif // GET_MNEMONIC_SPELL_CHECKER
1138