LCOV - code coverage report
Current view: top level - build-llvm/lib/Target/ARM - ARMGenMCPseudoLowering.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 293 326 89.9 %
Date: 2017-09-14 15:23:50 Functions: 1 1 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
       2             : |*                                                                            *|
       3             : |* Pseudo-instruction MC lowering Source Fragment                             *|
       4             : |*                                                                            *|
       5             : |* Automatically generated file, do not edit!                                 *|
       6             : |*                                                                            *|
       7             : \*===----------------------------------------------------------------------===*/
       8             : 
       9      124017 : bool ARMAsmPrinter::
      10             : emitPseudoExpansionLowering(MCStreamer &OutStreamer,
      11             :                             const MachineInstr *MI) {
      12      248034 :   switch (MI->getOpcode()) {
      13             :     default: return false;
      14         216 :     case ARM::B: {
      15         432 :       MCInst TmpInst;
      16         216 :       MCOperand MCOp;
      17         432 :       TmpInst.setOpcode(ARM::Bcc);
      18             :       // Operand: target
      19         216 :       lowerOperand(MI->getOperand(0), MCOp);
      20         216 :       TmpInst.addOperand(MCOp);
      21             :       // Operand: p
      22         432 :       TmpInst.addOperand(MCOperand::createImm(14));
      23         432 :       TmpInst.addOperand(MCOperand::createReg(0));
      24         216 :       EmitToStreamer(OutStreamer, TmpInst);
      25             :       break;
      26             :     }
      27        1363 :     case ARM::LDMIA_RET: {
      28        2726 :       MCInst TmpInst;
      29        1363 :       MCOperand MCOp;
      30        2726 :       TmpInst.setOpcode(ARM::LDMIA_UPD);
      31             :       // Operand: wb
      32        1363 :       lowerOperand(MI->getOperand(0), MCOp);
      33        1363 :       TmpInst.addOperand(MCOp);
      34             :       // Operand: Rn
      35        2726 :       lowerOperand(MI->getOperand(1), MCOp);
      36        1363 :       TmpInst.addOperand(MCOp);
      37             :       // Operand: p
      38        2726 :       lowerOperand(MI->getOperand(2), MCOp);
      39        1363 :       TmpInst.addOperand(MCOp);
      40        2726 :       lowerOperand(MI->getOperand(3), MCOp);
      41        1363 :       TmpInst.addOperand(MCOp);
      42             :       // Operand: regs
      43        2726 :       lowerOperand(MI->getOperand(4), MCOp);
      44        1363 :       TmpInst.addOperand(MCOp);
      45             :       // variable_ops
      46        5210 :       for (unsigned i = 5, e = MI->getNumOperands(); i != e; ++i)
      47        7694 :         if (lowerOperand(MI->getOperand(i), MCOp))
      48             :           TmpInst.addOperand(MCOp);
      49        1363 :       EmitToStreamer(OutStreamer, TmpInst);
      50             :       break;
      51             :     }
      52          26 :     case ARM::MLAv5: {
      53          52 :       MCInst TmpInst;
      54          26 :       MCOperand MCOp;
      55          52 :       TmpInst.setOpcode(ARM::MLA);
      56             :       // Operand: Rd
      57          26 :       lowerOperand(MI->getOperand(0), MCOp);
      58          26 :       TmpInst.addOperand(MCOp);
      59             :       // Operand: Rn
      60          52 :       lowerOperand(MI->getOperand(1), MCOp);
      61          26 :       TmpInst.addOperand(MCOp);
      62             :       // Operand: Rm
      63          52 :       lowerOperand(MI->getOperand(2), MCOp);
      64          26 :       TmpInst.addOperand(MCOp);
      65             :       // Operand: Ra
      66          52 :       lowerOperand(MI->getOperand(3), MCOp);
      67          26 :       TmpInst.addOperand(MCOp);
      68             :       // Operand: p
      69          52 :       lowerOperand(MI->getOperand(4), MCOp);
      70          26 :       TmpInst.addOperand(MCOp);
      71          52 :       lowerOperand(MI->getOperand(5), MCOp);
      72          26 :       TmpInst.addOperand(MCOp);
      73             :       // Operand: s
      74          52 :       lowerOperand(MI->getOperand(6), MCOp);
      75          26 :       TmpInst.addOperand(MCOp);
      76          26 :       EmitToStreamer(OutStreamer, TmpInst);
      77             :       break;
      78             :     }
      79           0 :     case ARM::MOVPCRX: {
      80           0 :       MCInst TmpInst;
      81           0 :       MCOperand MCOp;
      82           0 :       TmpInst.setOpcode(ARM::MOVr);
      83             :       // Operand: Rd
      84           0 :       TmpInst.addOperand(MCOperand::createReg(ARM::PC));
      85             :       // Operand: Rm
      86           0 :       lowerOperand(MI->getOperand(0), MCOp);
      87           0 :       TmpInst.addOperand(MCOp);
      88             :       // Operand: p
      89           0 :       TmpInst.addOperand(MCOperand::createImm(14));
      90           0 :       TmpInst.addOperand(MCOperand::createReg(0));
      91             :       // Operand: s
      92           0 :       TmpInst.addOperand(MCOperand::createReg(0));
      93           0 :       EmitToStreamer(OutStreamer, TmpInst);
      94             :       break;
      95             :     }
      96          51 :     case ARM::MULv5: {
      97         102 :       MCInst TmpInst;
      98          51 :       MCOperand MCOp;
      99         102 :       TmpInst.setOpcode(ARM::MUL);
     100             :       // Operand: Rd
     101          51 :       lowerOperand(MI->getOperand(0), MCOp);
     102          51 :       TmpInst.addOperand(MCOp);
     103             :       // Operand: Rn
     104         102 :       lowerOperand(MI->getOperand(1), MCOp);
     105          51 :       TmpInst.addOperand(MCOp);
     106             :       // Operand: Rm
     107         102 :       lowerOperand(MI->getOperand(2), MCOp);
     108          51 :       TmpInst.addOperand(MCOp);
     109             :       // Operand: p
     110         102 :       lowerOperand(MI->getOperand(3), MCOp);
     111          51 :       TmpInst.addOperand(MCOp);
     112         102 :       lowerOperand(MI->getOperand(4), MCOp);
     113          51 :       TmpInst.addOperand(MCOp);
     114             :       // Operand: s
     115         102 :       lowerOperand(MI->getOperand(5), MCOp);
     116          51 :       TmpInst.addOperand(MCOp);
     117          51 :       EmitToStreamer(OutStreamer, TmpInst);
     118             :       break;
     119             :     }
     120           9 :     case ARM::SMLALv5: {
     121          18 :       MCInst TmpInst;
     122           9 :       MCOperand MCOp;
     123          18 :       TmpInst.setOpcode(ARM::SMLAL);
     124             :       // Operand: RdLo
     125           9 :       lowerOperand(MI->getOperand(0), MCOp);
     126           9 :       TmpInst.addOperand(MCOp);
     127             :       // Operand: RdHi
     128          18 :       lowerOperand(MI->getOperand(1), MCOp);
     129           9 :       TmpInst.addOperand(MCOp);
     130             :       // Operand: Rn
     131          18 :       lowerOperand(MI->getOperand(2), MCOp);
     132           9 :       TmpInst.addOperand(MCOp);
     133             :       // Operand: Rm
     134          18 :       lowerOperand(MI->getOperand(3), MCOp);
     135           9 :       TmpInst.addOperand(MCOp);
     136             :       // Operand: RLo
     137          18 :       lowerOperand(MI->getOperand(4), MCOp);
     138           9 :       TmpInst.addOperand(MCOp);
     139             :       // Operand: RHi
     140          18 :       lowerOperand(MI->getOperand(5), MCOp);
     141           9 :       TmpInst.addOperand(MCOp);
     142             :       // Operand: p
     143          18 :       lowerOperand(MI->getOperand(6), MCOp);
     144           9 :       TmpInst.addOperand(MCOp);
     145          18 :       lowerOperand(MI->getOperand(7), MCOp);
     146           9 :       TmpInst.addOperand(MCOp);
     147             :       // Operand: s
     148          18 :       lowerOperand(MI->getOperand(8), MCOp);
     149           9 :       TmpInst.addOperand(MCOp);
     150           9 :       EmitToStreamer(OutStreamer, TmpInst);
     151             :       break;
     152             :     }
     153          29 :     case ARM::SMULLv5: {
     154          58 :       MCInst TmpInst;
     155          29 :       MCOperand MCOp;
     156          58 :       TmpInst.setOpcode(ARM::SMULL);
     157             :       // Operand: RdLo
     158          29 :       lowerOperand(MI->getOperand(0), MCOp);
     159          29 :       TmpInst.addOperand(MCOp);
     160             :       // Operand: RdHi
     161          58 :       lowerOperand(MI->getOperand(1), MCOp);
     162          29 :       TmpInst.addOperand(MCOp);
     163             :       // Operand: Rn
     164          58 :       lowerOperand(MI->getOperand(2), MCOp);
     165          29 :       TmpInst.addOperand(MCOp);
     166             :       // Operand: Rm
     167          58 :       lowerOperand(MI->getOperand(3), MCOp);
     168          29 :       TmpInst.addOperand(MCOp);
     169             :       // Operand: p
     170          58 :       lowerOperand(MI->getOperand(4), MCOp);
     171          29 :       TmpInst.addOperand(MCOp);
     172          58 :       lowerOperand(MI->getOperand(5), MCOp);
     173          29 :       TmpInst.addOperand(MCOp);
     174             :       // Operand: s
     175          58 :       lowerOperand(MI->getOperand(6), MCOp);
     176          29 :       TmpInst.addOperand(MCOp);
     177          29 :       EmitToStreamer(OutStreamer, TmpInst);
     178             :       break;
     179             :     }
     180         181 :     case ARM::TAILJMPd: {
     181         362 :       MCInst TmpInst;
     182         181 :       MCOperand MCOp;
     183         362 :       TmpInst.setOpcode(ARM::Bcc);
     184             :       // Operand: target
     185         181 :       lowerOperand(MI->getOperand(0), MCOp);
     186         181 :       TmpInst.addOperand(MCOp);
     187             :       // Operand: p
     188         362 :       TmpInst.addOperand(MCOperand::createImm(14));
     189         362 :       TmpInst.addOperand(MCOperand::createReg(0));
     190         181 :       EmitToStreamer(OutStreamer, TmpInst);
     191             :       break;
     192             :     }
     193           6 :     case ARM::TAILJMPr: {
     194          12 :       MCInst TmpInst;
     195           6 :       MCOperand MCOp;
     196          12 :       TmpInst.setOpcode(ARM::BX);
     197             :       // Operand: dst
     198           6 :       lowerOperand(MI->getOperand(0), MCOp);
     199           6 :       TmpInst.addOperand(MCOp);
     200           6 :       EmitToStreamer(OutStreamer, TmpInst);
     201             :       break;
     202             :     }
     203           3 :     case ARM::TAILJMPr4: {
     204           6 :       MCInst TmpInst;
     205           3 :       MCOperand MCOp;
     206           6 :       TmpInst.setOpcode(ARM::MOVr);
     207             :       // Operand: Rd
     208           6 :       TmpInst.addOperand(MCOperand::createReg(ARM::PC));
     209             :       // Operand: Rm
     210           3 :       lowerOperand(MI->getOperand(0), MCOp);
     211           3 :       TmpInst.addOperand(MCOp);
     212             :       // Operand: p
     213           6 :       TmpInst.addOperand(MCOperand::createImm(14));
     214           6 :       TmpInst.addOperand(MCOperand::createReg(0));
     215             :       // Operand: s
     216           6 :       TmpInst.addOperand(MCOperand::createReg(0));
     217           3 :       EmitToStreamer(OutStreamer, TmpInst);
     218             :       break;
     219             :     }
     220          12 :     case ARM::UMLALv5: {
     221          24 :       MCInst TmpInst;
     222          12 :       MCOperand MCOp;
     223          24 :       TmpInst.setOpcode(ARM::UMLAL);
     224             :       // Operand: RdLo
     225          12 :       lowerOperand(MI->getOperand(0), MCOp);
     226          12 :       TmpInst.addOperand(MCOp);
     227             :       // Operand: RdHi
     228          24 :       lowerOperand(MI->getOperand(1), MCOp);
     229          12 :       TmpInst.addOperand(MCOp);
     230             :       // Operand: Rn
     231          24 :       lowerOperand(MI->getOperand(2), MCOp);
     232          12 :       TmpInst.addOperand(MCOp);
     233             :       // Operand: Rm
     234          24 :       lowerOperand(MI->getOperand(3), MCOp);
     235          12 :       TmpInst.addOperand(MCOp);
     236             :       // Operand: RLo
     237          24 :       lowerOperand(MI->getOperand(4), MCOp);
     238          12 :       TmpInst.addOperand(MCOp);
     239             :       // Operand: RHi
     240          24 :       lowerOperand(MI->getOperand(5), MCOp);
     241          12 :       TmpInst.addOperand(MCOp);
     242             :       // Operand: p
     243          24 :       lowerOperand(MI->getOperand(6), MCOp);
     244          12 :       TmpInst.addOperand(MCOp);
     245          24 :       lowerOperand(MI->getOperand(7), MCOp);
     246          12 :       TmpInst.addOperand(MCOp);
     247             :       // Operand: s
     248          24 :       lowerOperand(MI->getOperand(8), MCOp);
     249          12 :       TmpInst.addOperand(MCOp);
     250          12 :       EmitToStreamer(OutStreamer, TmpInst);
     251             :       break;
     252             :     }
     253          20 :     case ARM::UMULLv5: {
     254          40 :       MCInst TmpInst;
     255          20 :       MCOperand MCOp;
     256          40 :       TmpInst.setOpcode(ARM::UMULL);
     257             :       // Operand: RdLo
     258          20 :       lowerOperand(MI->getOperand(0), MCOp);
     259          20 :       TmpInst.addOperand(MCOp);
     260             :       // Operand: RdHi
     261          40 :       lowerOperand(MI->getOperand(1), MCOp);
     262          20 :       TmpInst.addOperand(MCOp);
     263             :       // Operand: Rn
     264          40 :       lowerOperand(MI->getOperand(2), MCOp);
     265          20 :       TmpInst.addOperand(MCOp);
     266             :       // Operand: Rm
     267          40 :       lowerOperand(MI->getOperand(3), MCOp);
     268          20 :       TmpInst.addOperand(MCOp);
     269             :       // Operand: p
     270          40 :       lowerOperand(MI->getOperand(4), MCOp);
     271          20 :       TmpInst.addOperand(MCOp);
     272          40 :       lowerOperand(MI->getOperand(5), MCOp);
     273          20 :       TmpInst.addOperand(MCOp);
     274             :       // Operand: s
     275          40 :       lowerOperand(MI->getOperand(6), MCOp);
     276          20 :       TmpInst.addOperand(MCOp);
     277          20 :       EmitToStreamer(OutStreamer, TmpInst);
     278             :       break;
     279             :     }
     280           2 :     case ARM::VMOVD0: {
     281           4 :       MCInst TmpInst;
     282           2 :       MCOperand MCOp;
     283           4 :       TmpInst.setOpcode(ARM::VMOVv2i32);
     284             :       // Operand: Vd
     285           2 :       lowerOperand(MI->getOperand(0), MCOp);
     286           2 :       TmpInst.addOperand(MCOp);
     287             :       // Operand: SIMM
     288           4 :       TmpInst.addOperand(MCOperand::createImm(0));
     289             :       // Operand: p
     290           4 :       TmpInst.addOperand(MCOperand::createImm(14));
     291           4 :       TmpInst.addOperand(MCOperand::createReg(0));
     292           2 :       EmitToStreamer(OutStreamer, TmpInst);
     293             :       break;
     294             :     }
     295           2 :     case ARM::VMOVQ0: {
     296           4 :       MCInst TmpInst;
     297           2 :       MCOperand MCOp;
     298           4 :       TmpInst.setOpcode(ARM::VMOVv4i32);
     299             :       // Operand: Vd
     300           2 :       lowerOperand(MI->getOperand(0), MCOp);
     301           2 :       TmpInst.addOperand(MCOp);
     302             :       // Operand: SIMM
     303           4 :       TmpInst.addOperand(MCOperand::createImm(0));
     304             :       // Operand: p
     305           4 :       TmpInst.addOperand(MCOperand::createImm(14));
     306           4 :       TmpInst.addOperand(MCOperand::createReg(0));
     307           2 :       EmitToStreamer(OutStreamer, TmpInst);
     308             :       break;
     309             :     }
     310         110 :     case ARM::t2LDMIA_RET: {
     311         220 :       MCInst TmpInst;
     312         110 :       MCOperand MCOp;
     313         220 :       TmpInst.setOpcode(ARM::t2LDMIA_UPD);
     314             :       // Operand: wb
     315         110 :       lowerOperand(MI->getOperand(0), MCOp);
     316         110 :       TmpInst.addOperand(MCOp);
     317             :       // Operand: Rn
     318         220 :       lowerOperand(MI->getOperand(1), MCOp);
     319         110 :       TmpInst.addOperand(MCOp);
     320             :       // Operand: p
     321         220 :       lowerOperand(MI->getOperand(2), MCOp);
     322         110 :       TmpInst.addOperand(MCOp);
     323         220 :       lowerOperand(MI->getOperand(3), MCOp);
     324         110 :       TmpInst.addOperand(MCOp);
     325             :       // Operand: regs
     326         220 :       lowerOperand(MI->getOperand(4), MCOp);
     327         110 :       TmpInst.addOperand(MCOp);
     328             :       // variable_ops
     329         580 :       for (unsigned i = 5, e = MI->getNumOperands(); i != e; ++i)
     330         940 :         if (lowerOperand(MI->getOperand(i), MCOp))
     331             :           TmpInst.addOperand(MCOp);
     332         110 :       EmitToStreamer(OutStreamer, TmpInst);
     333             :       break;
     334             :     }
     335          20 :     case ARM::tBRIND: {
     336          40 :       MCInst TmpInst;
     337          20 :       MCOperand MCOp;
     338          40 :       TmpInst.setOpcode(ARM::tMOVr);
     339             :       // Operand: Rd
     340          40 :       TmpInst.addOperand(MCOperand::createReg(ARM::PC));
     341             :       // Operand: Rm
     342          20 :       lowerOperand(MI->getOperand(0), MCOp);
     343          20 :       TmpInst.addOperand(MCOp);
     344             :       // Operand: p
     345          40 :       lowerOperand(MI->getOperand(1), MCOp);
     346          20 :       TmpInst.addOperand(MCOp);
     347          40 :       lowerOperand(MI->getOperand(2), MCOp);
     348          20 :       TmpInst.addOperand(MCOp);
     349          20 :       EmitToStreamer(OutStreamer, TmpInst);
     350             :       break;
     351             :     }
     352        3187 :     case ARM::tBX_RET: {
     353        6374 :       MCInst TmpInst;
     354        3187 :       MCOperand MCOp;
     355        6374 :       TmpInst.setOpcode(ARM::tBX);
     356             :       // Operand: Rm
     357        6374 :       TmpInst.addOperand(MCOperand::createReg(ARM::LR));
     358             :       // Operand: p
     359        3187 :       lowerOperand(MI->getOperand(0), MCOp);
     360        3187 :       TmpInst.addOperand(MCOp);
     361        6374 :       lowerOperand(MI->getOperand(1), MCOp);
     362        3187 :       TmpInst.addOperand(MCOp);
     363        3187 :       EmitToStreamer(OutStreamer, TmpInst);
     364             :       break;
     365             :     }
     366           0 :     case ARM::tBX_RET_vararg: {
     367           0 :       MCInst TmpInst;
     368           0 :       MCOperand MCOp;
     369           0 :       TmpInst.setOpcode(ARM::tBX);
     370             :       // Operand: Rm
     371           0 :       lowerOperand(MI->getOperand(0), MCOp);
     372           0 :       TmpInst.addOperand(MCOp);
     373             :       // Operand: p
     374           0 :       lowerOperand(MI->getOperand(1), MCOp);
     375           0 :       TmpInst.addOperand(MCOp);
     376           0 :       lowerOperand(MI->getOperand(2), MCOp);
     377           0 :       TmpInst.addOperand(MCOp);
     378           0 :       EmitToStreamer(OutStreamer, TmpInst);
     379             :       break;
     380             :     }
     381           0 :     case ARM::tBfar: {
     382           0 :       MCInst TmpInst;
     383           0 :       MCOperand MCOp;
     384           0 :       TmpInst.setOpcode(ARM::tBL);
     385             :       // Operand: p
     386           0 :       lowerOperand(MI->getOperand(1), MCOp);
     387           0 :       TmpInst.addOperand(MCOp);
     388           0 :       lowerOperand(MI->getOperand(2), MCOp);
     389           0 :       TmpInst.addOperand(MCOp);
     390             :       // Operand: func
     391           0 :       lowerOperand(MI->getOperand(0), MCOp);
     392           0 :       TmpInst.addOperand(MCOp);
     393           0 :       EmitToStreamer(OutStreamer, TmpInst);
     394             :       break;
     395             :     }
     396          42 :     case ARM::tLDMIA_UPD: {
     397          84 :       MCInst TmpInst;
     398          42 :       MCOperand MCOp;
     399          84 :       TmpInst.setOpcode(ARM::tLDMIA);
     400             :       // Operand: Rn
     401          84 :       lowerOperand(MI->getOperand(1), MCOp);
     402          42 :       TmpInst.addOperand(MCOp);
     403             :       // Operand: p
     404          84 :       lowerOperand(MI->getOperand(2), MCOp);
     405          42 :       TmpInst.addOperand(MCOp);
     406          84 :       lowerOperand(MI->getOperand(3), MCOp);
     407          42 :       TmpInst.addOperand(MCOp);
     408             :       // Operand: regs
     409          84 :       lowerOperand(MI->getOperand(4), MCOp);
     410          42 :       TmpInst.addOperand(MCOp);
     411             :       // variable_ops
     412         128 :       for (unsigned i = 5, e = MI->getNumOperands(); i != e; ++i)
     413         172 :         if (lowerOperand(MI->getOperand(i), MCOp))
     414             :           TmpInst.addOperand(MCOp);
     415          42 :       EmitToStreamer(OutStreamer, TmpInst);
     416             :       break;
     417             :     }
     418        1297 :     case ARM::tPOP_RET: {
     419        2594 :       MCInst TmpInst;
     420        1297 :       MCOperand MCOp;
     421        2594 :       TmpInst.setOpcode(ARM::tPOP);
     422             :       // Operand: p
     423        1297 :       lowerOperand(MI->getOperand(0), MCOp);
     424        1297 :       TmpInst.addOperand(MCOp);
     425        2594 :       lowerOperand(MI->getOperand(1), MCOp);
     426        1297 :       TmpInst.addOperand(MCOp);
     427             :       // Operand: regs
     428        2594 :       lowerOperand(MI->getOperand(2), MCOp);
     429        1297 :       TmpInst.addOperand(MCOp);
     430             :       // variable_ops
     431        5202 :       for (unsigned i = 3, e = MI->getNumOperands(); i != e; ++i)
     432        7810 :         if (lowerOperand(MI->getOperand(i), MCOp))
     433             :           TmpInst.addOperand(MCOp);
     434        1297 :       EmitToStreamer(OutStreamer, TmpInst);
     435             :       break;
     436             :     }
     437          65 :     case ARM::tTAILJMPd: {
     438         130 :       MCInst TmpInst;
     439          65 :       MCOperand MCOp;
     440         130 :       TmpInst.setOpcode(ARM::t2B);
     441             :       // Operand: target
     442          65 :       lowerOperand(MI->getOperand(0), MCOp);
     443          65 :       TmpInst.addOperand(MCOp);
     444             :       // Operand: p
     445         130 :       lowerOperand(MI->getOperand(1), MCOp);
     446          65 :       TmpInst.addOperand(MCOp);
     447         130 :       lowerOperand(MI->getOperand(2), MCOp);
     448          65 :       TmpInst.addOperand(MCOp);
     449          65 :       EmitToStreamer(OutStreamer, TmpInst);
     450             :       break;
     451             :     }
     452         244 :     case ARM::tTAILJMPdND: {
     453         488 :       MCInst TmpInst;
     454         244 :       MCOperand MCOp;
     455         488 :       TmpInst.setOpcode(ARM::tB);
     456             :       // Operand: target
     457         244 :       lowerOperand(MI->getOperand(0), MCOp);
     458         244 :       TmpInst.addOperand(MCOp);
     459             :       // Operand: p
     460         488 :       lowerOperand(MI->getOperand(1), MCOp);
     461         244 :       TmpInst.addOperand(MCOp);
     462         488 :       lowerOperand(MI->getOperand(2), MCOp);
     463         244 :       TmpInst.addOperand(MCOp);
     464         244 :       EmitToStreamer(OutStreamer, TmpInst);
     465             :       break;
     466             :     }
     467           7 :     case ARM::tTAILJMPr: {
     468          14 :       MCInst TmpInst;
     469           7 :       MCOperand MCOp;
     470          14 :       TmpInst.setOpcode(ARM::tBX);
     471             :       // Operand: Rm
     472           7 :       lowerOperand(MI->getOperand(0), MCOp);
     473           7 :       TmpInst.addOperand(MCOp);
     474             :       // Operand: p
     475          14 :       TmpInst.addOperand(MCOperand::createImm(14));
     476          14 :       TmpInst.addOperand(MCOperand::createReg(0));
     477           7 :       EmitToStreamer(OutStreamer, TmpInst);
     478             :       break;
     479             :     }
     480             :   }
     481             :   return true;
     482             : }
     483             : 

Generated by: LCOV version 1.13