LCOV - code coverage report
Current view: top level - build-llvm/lib/Target/BPF - BPFGenAsmMatcher.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 135 210 64.3 %
Date: 2018-05-20 00:06:23 Functions: 6 7 85.7 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13