LCOV - code coverage report
Current view: top level - build-llvm/lib/Target/Mips - MipsGenMCPseudoLowering.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 478 492 97.2 %
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      118798 : bool MipsAsmPrinter::
      10             : emitPseudoExpansionLowering(MCStreamer &OutStreamer,
      11             :                             const MachineInstr *MI) {
      12      237596 :   switch (MI->getOpcode()) {
      13             :     default: return false;
      14           6 :     case Mips::AND_V_D_PSEUDO: {
      15          12 :       MCInst TmpInst;
      16           6 :       MCOperand MCOp;
      17          12 :       TmpInst.setOpcode(Mips::AND_V);
      18             :       // Operand: wd
      19          12 :       lowerOperand(MI->getOperand(0), MCOp);
      20           6 :       TmpInst.addOperand(MCOp);
      21             :       // Operand: ws
      22          18 :       lowerOperand(MI->getOperand(1), MCOp);
      23           6 :       TmpInst.addOperand(MCOp);
      24             :       // Operand: wt
      25          18 :       lowerOperand(MI->getOperand(2), MCOp);
      26           6 :       TmpInst.addOperand(MCOp);
      27           6 :       EmitToStreamer(OutStreamer, TmpInst);
      28             :       break;
      29             :     }
      30           6 :     case Mips::AND_V_H_PSEUDO: {
      31          12 :       MCInst TmpInst;
      32           6 :       MCOperand MCOp;
      33          12 :       TmpInst.setOpcode(Mips::AND_V);
      34             :       // Operand: wd
      35          12 :       lowerOperand(MI->getOperand(0), MCOp);
      36           6 :       TmpInst.addOperand(MCOp);
      37             :       // Operand: ws
      38          18 :       lowerOperand(MI->getOperand(1), MCOp);
      39           6 :       TmpInst.addOperand(MCOp);
      40             :       // Operand: wt
      41          18 :       lowerOperand(MI->getOperand(2), MCOp);
      42           6 :       TmpInst.addOperand(MCOp);
      43           6 :       EmitToStreamer(OutStreamer, TmpInst);
      44             :       break;
      45             :     }
      46          10 :     case Mips::AND_V_W_PSEUDO: {
      47          20 :       MCInst TmpInst;
      48          10 :       MCOperand MCOp;
      49          20 :       TmpInst.setOpcode(Mips::AND_V);
      50             :       // Operand: wd
      51          20 :       lowerOperand(MI->getOperand(0), MCOp);
      52          10 :       TmpInst.addOperand(MCOp);
      53             :       // Operand: ws
      54          30 :       lowerOperand(MI->getOperand(1), MCOp);
      55          10 :       TmpInst.addOperand(MCOp);
      56             :       // Operand: wt
      57          30 :       lowerOperand(MI->getOperand(2), MCOp);
      58          10 :       TmpInst.addOperand(MCOp);
      59          10 :       EmitToStreamer(OutStreamer, TmpInst);
      60             :       break;
      61             :     }
      62          27 :     case Mips::B: {
      63          54 :       MCInst TmpInst;
      64          27 :       MCOperand MCOp;
      65          54 :       TmpInst.setOpcode(Mips::BEQ);
      66             :       // Operand: rs
      67          54 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
      68             :       // Operand: rt
      69          54 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
      70             :       // Operand: offset
      71          54 :       lowerOperand(MI->getOperand(0), MCOp);
      72          27 :       TmpInst.addOperand(MCOp);
      73          27 :       EmitToStreamer(OutStreamer, TmpInst);
      74             :       break;
      75             :     }
      76           5 :     case Mips::BAL_BR: {
      77          10 :       MCInst TmpInst;
      78           5 :       MCOperand MCOp;
      79          10 :       TmpInst.setOpcode(Mips::BGEZAL);
      80             :       // Operand: rs
      81          10 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
      82             :       // Operand: offset
      83          10 :       lowerOperand(MI->getOperand(0), MCOp);
      84           5 :       TmpInst.addOperand(MCOp);
      85           5 :       EmitToStreamer(OutStreamer, TmpInst);
      86             :       break;
      87             :     }
      88          10 :     case Mips::BSEL_D_PSEUDO: {
      89          20 :       MCInst TmpInst;
      90          10 :       MCOperand MCOp;
      91          20 :       TmpInst.setOpcode(Mips::BSEL_V);
      92             :       // Operand: wd
      93          20 :       lowerOperand(MI->getOperand(0), MCOp);
      94          10 :       TmpInst.addOperand(MCOp);
      95             :       // Operand: wd_in
      96          30 :       lowerOperand(MI->getOperand(1), MCOp);
      97          10 :       TmpInst.addOperand(MCOp);
      98             :       // Operand: ws
      99          30 :       lowerOperand(MI->getOperand(2), MCOp);
     100          10 :       TmpInst.addOperand(MCOp);
     101             :       // Operand: wt
     102          30 :       lowerOperand(MI->getOperand(3), MCOp);
     103          10 :       TmpInst.addOperand(MCOp);
     104          10 :       EmitToStreamer(OutStreamer, TmpInst);
     105             :       break;
     106             :     }
     107           4 :     case Mips::BSEL_FD_PSEUDO: {
     108           8 :       MCInst TmpInst;
     109           4 :       MCOperand MCOp;
     110           8 :       TmpInst.setOpcode(Mips::BSEL_V);
     111             :       // Operand: wd
     112           8 :       lowerOperand(MI->getOperand(0), MCOp);
     113           4 :       TmpInst.addOperand(MCOp);
     114             :       // Operand: wd_in
     115          12 :       lowerOperand(MI->getOperand(1), MCOp);
     116           4 :       TmpInst.addOperand(MCOp);
     117             :       // Operand: ws
     118          12 :       lowerOperand(MI->getOperand(2), MCOp);
     119           4 :       TmpInst.addOperand(MCOp);
     120             :       // Operand: wt
     121          12 :       lowerOperand(MI->getOperand(3), MCOp);
     122           4 :       TmpInst.addOperand(MCOp);
     123           4 :       EmitToStreamer(OutStreamer, TmpInst);
     124             :       break;
     125             :     }
     126           8 :     case Mips::BSEL_FW_PSEUDO: {
     127          16 :       MCInst TmpInst;
     128           8 :       MCOperand MCOp;
     129          16 :       TmpInst.setOpcode(Mips::BSEL_V);
     130             :       // Operand: wd
     131          16 :       lowerOperand(MI->getOperand(0), MCOp);
     132           8 :       TmpInst.addOperand(MCOp);
     133             :       // Operand: wd_in
     134          24 :       lowerOperand(MI->getOperand(1), MCOp);
     135           8 :       TmpInst.addOperand(MCOp);
     136             :       // Operand: ws
     137          24 :       lowerOperand(MI->getOperand(2), MCOp);
     138           8 :       TmpInst.addOperand(MCOp);
     139             :       // Operand: wt
     140          24 :       lowerOperand(MI->getOperand(3), MCOp);
     141           8 :       TmpInst.addOperand(MCOp);
     142           8 :       EmitToStreamer(OutStreamer, TmpInst);
     143             :       break;
     144             :     }
     145          10 :     case Mips::BSEL_H_PSEUDO: {
     146          20 :       MCInst TmpInst;
     147          10 :       MCOperand MCOp;
     148          20 :       TmpInst.setOpcode(Mips::BSEL_V);
     149             :       // Operand: wd
     150          20 :       lowerOperand(MI->getOperand(0), MCOp);
     151          10 :       TmpInst.addOperand(MCOp);
     152             :       // Operand: wd_in
     153          30 :       lowerOperand(MI->getOperand(1), MCOp);
     154          10 :       TmpInst.addOperand(MCOp);
     155             :       // Operand: ws
     156          30 :       lowerOperand(MI->getOperand(2), MCOp);
     157          10 :       TmpInst.addOperand(MCOp);
     158             :       // Operand: wt
     159          30 :       lowerOperand(MI->getOperand(3), MCOp);
     160          10 :       TmpInst.addOperand(MCOp);
     161          10 :       EmitToStreamer(OutStreamer, TmpInst);
     162             :       break;
     163             :     }
     164          10 :     case Mips::BSEL_W_PSEUDO: {
     165          10 :       MCInst TmpInst;
     166          10 :       MCOperand MCOp;
     167          10 :       TmpInst.setOpcode(Mips::BSEL_V);
     168             :       // Operand: wd
     169          20 :       lowerOperand(MI->getOperand(0), MCOp);
     170          10 :       TmpInst.addOperand(MCOp);
     171             :       // Operand: wd_in
     172          30 :       lowerOperand(MI->getOperand(1), MCOp);
     173          10 :       TmpInst.addOperand(MCOp);
     174             :       // Operand: ws
     175          30 :       lowerOperand(MI->getOperand(2), MCOp);
     176          10 :       TmpInst.addOperand(MCOp);
     177             :       // Operand: wt
     178          30 :       lowerOperand(MI->getOperand(3), MCOp);
     179          10 :       TmpInst.addOperand(MCOp);
     180          10 :       EmitToStreamer(OutStreamer, TmpInst);
     181             :       break;
     182             :     }
     183           2 :     case Mips::FABS_D: {
     184           4 :       MCInst TmpInst;
     185           2 :       MCOperand MCOp;
     186           4 :       TmpInst.setOpcode(Mips::FMAX_A_D);
     187             :       // Operand: wd
     188           4 :       lowerOperand(MI->getOperand(0), MCOp);
     189           2 :       TmpInst.addOperand(MCOp);
     190             :       // Operand: ws
     191           6 :       lowerOperand(MI->getOperand(1), MCOp);
     192           2 :       TmpInst.addOperand(MCOp);
     193             :       // Operand: wt
     194           6 :       lowerOperand(MI->getOperand(1), MCOp);
     195           2 :       TmpInst.addOperand(MCOp);
     196           2 :       EmitToStreamer(OutStreamer, TmpInst);
     197             :       break;
     198             :     }
     199           2 :     case Mips::FABS_W: {
     200           4 :       MCInst TmpInst;
     201           2 :       MCOperand MCOp;
     202           4 :       TmpInst.setOpcode(Mips::FMAX_A_W);
     203             :       // Operand: wd
     204           4 :       lowerOperand(MI->getOperand(0), MCOp);
     205           2 :       TmpInst.addOperand(MCOp);
     206             :       // Operand: ws
     207           6 :       lowerOperand(MI->getOperand(1), MCOp);
     208           2 :       TmpInst.addOperand(MCOp);
     209             :       // Operand: wt
     210           6 :       lowerOperand(MI->getOperand(1), MCOp);
     211           2 :       TmpInst.addOperand(MCOp);
     212           2 :       EmitToStreamer(OutStreamer, TmpInst);
     213             :       break;
     214             :     }
     215         450 :     case Mips::JALR64Pseudo: {
     216         900 :       MCInst TmpInst;
     217         450 :       MCOperand MCOp;
     218         900 :       TmpInst.setOpcode(Mips::JALR);
     219             :       // Operand: rd
     220         900 :       TmpInst.addOperand(MCOperand::createReg(Mips::RA));
     221             :       // Operand: rs
     222         900 :       lowerOperand(MI->getOperand(0), MCOp);
     223         450 :       TmpInst.addOperand(MCOp);
     224         450 :       EmitToStreamer(OutStreamer, TmpInst);
     225             :       break;
     226             :     }
     227         476 :     case Mips::JALRPseudo: {
     228         952 :       MCInst TmpInst;
     229         476 :       MCOperand MCOp;
     230         952 :       TmpInst.setOpcode(Mips::JALR);
     231             :       // Operand: rd
     232         952 :       TmpInst.addOperand(MCOperand::createReg(Mips::RA));
     233             :       // Operand: rs
     234         952 :       lowerOperand(MI->getOperand(0), MCOp);
     235         476 :       TmpInst.addOperand(MCOp);
     236         476 :       EmitToStreamer(OutStreamer, TmpInst);
     237             :       break;
     238             :     }
     239        2904 :     case Mips::NOP: {
     240        5808 :       MCInst TmpInst;
     241        2904 :       MCOperand MCOp;
     242        5808 :       TmpInst.setOpcode(Mips::SLL);
     243             :       // Operand: rd
     244        5808 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
     245             :       // Operand: rt
     246        5808 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
     247             :       // Operand: shamt
     248        5808 :       TmpInst.addOperand(MCOperand::createImm(0));
     249        2904 :       EmitToStreamer(OutStreamer, TmpInst);
     250             :       break;
     251             :     }
     252           4 :     case Mips::NOR_V_D_PSEUDO: {
     253           8 :       MCInst TmpInst;
     254           4 :       MCOperand MCOp;
     255           8 :       TmpInst.setOpcode(Mips::NOR_V);
     256             :       // Operand: wd
     257           8 :       lowerOperand(MI->getOperand(0), MCOp);
     258           4 :       TmpInst.addOperand(MCOp);
     259             :       // Operand: ws
     260          12 :       lowerOperand(MI->getOperand(1), MCOp);
     261           4 :       TmpInst.addOperand(MCOp);
     262             :       // Operand: wt
     263          12 :       lowerOperand(MI->getOperand(2), MCOp);
     264           4 :       TmpInst.addOperand(MCOp);
     265           4 :       EmitToStreamer(OutStreamer, TmpInst);
     266             :       break;
     267             :     }
     268           4 :     case Mips::NOR_V_H_PSEUDO: {
     269           8 :       MCInst TmpInst;
     270           4 :       MCOperand MCOp;
     271           8 :       TmpInst.setOpcode(Mips::NOR_V);
     272             :       // Operand: wd
     273           8 :       lowerOperand(MI->getOperand(0), MCOp);
     274           4 :       TmpInst.addOperand(MCOp);
     275             :       // Operand: ws
     276          12 :       lowerOperand(MI->getOperand(1), MCOp);
     277           4 :       TmpInst.addOperand(MCOp);
     278             :       // Operand: wt
     279          12 :       lowerOperand(MI->getOperand(2), MCOp);
     280           4 :       TmpInst.addOperand(MCOp);
     281           4 :       EmitToStreamer(OutStreamer, TmpInst);
     282             :       break;
     283             :     }
     284           4 :     case Mips::NOR_V_W_PSEUDO: {
     285           8 :       MCInst TmpInst;
     286           4 :       MCOperand MCOp;
     287           8 :       TmpInst.setOpcode(Mips::NOR_V);
     288             :       // Operand: wd
     289           8 :       lowerOperand(MI->getOperand(0), MCOp);
     290           4 :       TmpInst.addOperand(MCOp);
     291             :       // Operand: ws
     292          12 :       lowerOperand(MI->getOperand(1), MCOp);
     293           4 :       TmpInst.addOperand(MCOp);
     294             :       // Operand: wt
     295          12 :       lowerOperand(MI->getOperand(2), MCOp);
     296           4 :       TmpInst.addOperand(MCOp);
     297           4 :       EmitToStreamer(OutStreamer, TmpInst);
     298             :       break;
     299             :     }
     300           6 :     case Mips::OR_V_D_PSEUDO: {
     301          12 :       MCInst TmpInst;
     302           6 :       MCOperand MCOp;
     303          12 :       TmpInst.setOpcode(Mips::OR_V);
     304             :       // Operand: wd
     305          12 :       lowerOperand(MI->getOperand(0), MCOp);
     306           6 :       TmpInst.addOperand(MCOp);
     307             :       // Operand: ws
     308          18 :       lowerOperand(MI->getOperand(1), MCOp);
     309           6 :       TmpInst.addOperand(MCOp);
     310             :       // Operand: wt
     311          18 :       lowerOperand(MI->getOperand(2), MCOp);
     312           6 :       TmpInst.addOperand(MCOp);
     313           6 :       EmitToStreamer(OutStreamer, TmpInst);
     314             :       break;
     315             :     }
     316           6 :     case Mips::OR_V_H_PSEUDO: {
     317          12 :       MCInst TmpInst;
     318           6 :       MCOperand MCOp;
     319          12 :       TmpInst.setOpcode(Mips::OR_V);
     320             :       // Operand: wd
     321          12 :       lowerOperand(MI->getOperand(0), MCOp);
     322           6 :       TmpInst.addOperand(MCOp);
     323             :       // Operand: ws
     324          18 :       lowerOperand(MI->getOperand(1), MCOp);
     325           6 :       TmpInst.addOperand(MCOp);
     326             :       // Operand: wt
     327          18 :       lowerOperand(MI->getOperand(2), MCOp);
     328           6 :       TmpInst.addOperand(MCOp);
     329           6 :       EmitToStreamer(OutStreamer, TmpInst);
     330             :       break;
     331             :     }
     332           6 :     case Mips::OR_V_W_PSEUDO: {
     333          12 :       MCInst TmpInst;
     334           6 :       MCOperand MCOp;
     335          12 :       TmpInst.setOpcode(Mips::OR_V);
     336             :       // Operand: wd
     337          12 :       lowerOperand(MI->getOperand(0), MCOp);
     338           6 :       TmpInst.addOperand(MCOp);
     339             :       // Operand: ws
     340          18 :       lowerOperand(MI->getOperand(1), MCOp);
     341           6 :       TmpInst.addOperand(MCOp);
     342             :       // Operand: wt
     343          18 :       lowerOperand(MI->getOperand(2), MCOp);
     344           6 :       TmpInst.addOperand(MCOp);
     345           6 :       EmitToStreamer(OutStreamer, TmpInst);
     346             :       break;
     347             :     }
     348           4 :     case Mips::PseudoCMPU_EQ_QB: {
     349           8 :       MCInst TmpInst;
     350           4 :       MCOperand MCOp;
     351           8 :       TmpInst.setOpcode(Mips::CMPU_EQ_QB);
     352             :       // Operand: rs
     353          12 :       lowerOperand(MI->getOperand(1), MCOp);
     354           4 :       TmpInst.addOperand(MCOp);
     355             :       // Operand: rt
     356          12 :       lowerOperand(MI->getOperand(2), MCOp);
     357           4 :       TmpInst.addOperand(MCOp);
     358           4 :       EmitToStreamer(OutStreamer, TmpInst);
     359             :       break;
     360             :     }
     361           4 :     case Mips::PseudoCMPU_LE_QB: {
     362           8 :       MCInst TmpInst;
     363           4 :       MCOperand MCOp;
     364           8 :       TmpInst.setOpcode(Mips::CMPU_LE_QB);
     365             :       // Operand: rs
     366          12 :       lowerOperand(MI->getOperand(1), MCOp);
     367           4 :       TmpInst.addOperand(MCOp);
     368             :       // Operand: rt
     369          12 :       lowerOperand(MI->getOperand(2), MCOp);
     370           4 :       TmpInst.addOperand(MCOp);
     371           4 :       EmitToStreamer(OutStreamer, TmpInst);
     372             :       break;
     373             :     }
     374           4 :     case Mips::PseudoCMPU_LT_QB: {
     375           8 :       MCInst TmpInst;
     376           4 :       MCOperand MCOp;
     377           8 :       TmpInst.setOpcode(Mips::CMPU_LT_QB);
     378             :       // Operand: rs
     379          12 :       lowerOperand(MI->getOperand(1), MCOp);
     380           4 :       TmpInst.addOperand(MCOp);
     381             :       // Operand: rt
     382          12 :       lowerOperand(MI->getOperand(2), MCOp);
     383           4 :       TmpInst.addOperand(MCOp);
     384           4 :       EmitToStreamer(OutStreamer, TmpInst);
     385             :       break;
     386             :     }
     387           4 :     case Mips::PseudoCMP_EQ_PH: {
     388           8 :       MCInst TmpInst;
     389           4 :       MCOperand MCOp;
     390           8 :       TmpInst.setOpcode(Mips::CMP_EQ_PH);
     391             :       // Operand: rs
     392          12 :       lowerOperand(MI->getOperand(1), MCOp);
     393           4 :       TmpInst.addOperand(MCOp);
     394             :       // Operand: rt
     395          12 :       lowerOperand(MI->getOperand(2), MCOp);
     396           4 :       TmpInst.addOperand(MCOp);
     397           4 :       EmitToStreamer(OutStreamer, TmpInst);
     398             :       break;
     399             :     }
     400           4 :     case Mips::PseudoCMP_LE_PH: {
     401           8 :       MCInst TmpInst;
     402           4 :       MCOperand MCOp;
     403           8 :       TmpInst.setOpcode(Mips::CMP_LE_PH);
     404             :       // Operand: rs
     405          12 :       lowerOperand(MI->getOperand(1), MCOp);
     406           4 :       TmpInst.addOperand(MCOp);
     407             :       // Operand: rt
     408          12 :       lowerOperand(MI->getOperand(2), MCOp);
     409           4 :       TmpInst.addOperand(MCOp);
     410           4 :       EmitToStreamer(OutStreamer, TmpInst);
     411             :       break;
     412             :     }
     413           5 :     case Mips::PseudoCMP_LT_PH: {
     414          10 :       MCInst TmpInst;
     415           5 :       MCOperand MCOp;
     416          10 :       TmpInst.setOpcode(Mips::CMP_LT_PH);
     417             :       // Operand: rs
     418          15 :       lowerOperand(MI->getOperand(1), MCOp);
     419           5 :       TmpInst.addOperand(MCOp);
     420             :       // Operand: rt
     421          15 :       lowerOperand(MI->getOperand(2), MCOp);
     422           5 :       TmpInst.addOperand(MCOp);
     423           5 :       EmitToStreamer(OutStreamer, TmpInst);
     424             :       break;
     425             :     }
     426          50 :     case Mips::PseudoDMULT: {
     427         100 :       MCInst TmpInst;
     428          50 :       MCOperand MCOp;
     429         100 :       TmpInst.setOpcode(Mips::DMULT);
     430             :       // Operand: rs
     431         150 :       lowerOperand(MI->getOperand(1), MCOp);
     432          50 :       TmpInst.addOperand(MCOp);
     433             :       // Operand: rt
     434         150 :       lowerOperand(MI->getOperand(2), MCOp);
     435          50 :       TmpInst.addOperand(MCOp);
     436          50 :       EmitToStreamer(OutStreamer, TmpInst);
     437             :       break;
     438             :     }
     439           5 :     case Mips::PseudoDMULTu: {
     440          10 :       MCInst TmpInst;
     441           5 :       MCOperand MCOp;
     442          10 :       TmpInst.setOpcode(Mips::DMULTu);
     443             :       // Operand: rs
     444          15 :       lowerOperand(MI->getOperand(1), MCOp);
     445           5 :       TmpInst.addOperand(MCOp);
     446             :       // Operand: rt
     447          15 :       lowerOperand(MI->getOperand(2), MCOp);
     448           5 :       TmpInst.addOperand(MCOp);
     449           5 :       EmitToStreamer(OutStreamer, TmpInst);
     450             :       break;
     451             :     }
     452          36 :     case Mips::PseudoDSDIV: {
     453          72 :       MCInst TmpInst;
     454          36 :       MCOperand MCOp;
     455          72 :       TmpInst.setOpcode(Mips::DSDIV);
     456             :       // Operand: rs
     457         108 :       lowerOperand(MI->getOperand(1), MCOp);
     458          36 :       TmpInst.addOperand(MCOp);
     459             :       // Operand: rt
     460         108 :       lowerOperand(MI->getOperand(2), MCOp);
     461          36 :       TmpInst.addOperand(MCOp);
     462          36 :       EmitToStreamer(OutStreamer, TmpInst);
     463             :       break;
     464             :     }
     465          36 :     case Mips::PseudoDUDIV: {
     466          72 :       MCInst TmpInst;
     467          36 :       MCOperand MCOp;
     468          72 :       TmpInst.setOpcode(Mips::DUDIV);
     469             :       // Operand: rs
     470         108 :       lowerOperand(MI->getOperand(1), MCOp);
     471          36 :       TmpInst.addOperand(MCOp);
     472             :       // Operand: rt
     473         108 :       lowerOperand(MI->getOperand(2), MCOp);
     474          36 :       TmpInst.addOperand(MCOp);
     475          36 :       EmitToStreamer(OutStreamer, TmpInst);
     476             :       break;
     477             :     }
     478           4 :     case Mips::PseudoMADD: {
     479           8 :       MCInst TmpInst;
     480           4 :       MCOperand MCOp;
     481           8 :       TmpInst.setOpcode(Mips::MADD);
     482             :       // Operand: rs
     483          12 :       lowerOperand(MI->getOperand(1), MCOp);
     484           4 :       TmpInst.addOperand(MCOp);
     485             :       // Operand: rt
     486          12 :       lowerOperand(MI->getOperand(2), MCOp);
     487           4 :       TmpInst.addOperand(MCOp);
     488           4 :       EmitToStreamer(OutStreamer, TmpInst);
     489             :       break;
     490             :     }
     491           2 :     case Mips::PseudoMADDU: {
     492           4 :       MCInst TmpInst;
     493           2 :       MCOperand MCOp;
     494           4 :       TmpInst.setOpcode(Mips::MADDU);
     495             :       // Operand: rs
     496           6 :       lowerOperand(MI->getOperand(1), MCOp);
     497           2 :       TmpInst.addOperand(MCOp);
     498             :       // Operand: rt
     499           6 :       lowerOperand(MI->getOperand(2), MCOp);
     500           2 :       TmpInst.addOperand(MCOp);
     501           2 :       EmitToStreamer(OutStreamer, TmpInst);
     502             :       break;
     503             :     }
     504           4 :     case Mips::PseudoMSUB: {
     505           8 :       MCInst TmpInst;
     506           4 :       MCOperand MCOp;
     507           8 :       TmpInst.setOpcode(Mips::MSUB);
     508             :       // Operand: rs
     509          12 :       lowerOperand(MI->getOperand(1), MCOp);
     510           4 :       TmpInst.addOperand(MCOp);
     511             :       // Operand: rt
     512          12 :       lowerOperand(MI->getOperand(2), MCOp);
     513           4 :       TmpInst.addOperand(MCOp);
     514           4 :       EmitToStreamer(OutStreamer, TmpInst);
     515             :       break;
     516             :     }
     517           2 :     case Mips::PseudoMSUBU: {
     518           4 :       MCInst TmpInst;
     519           2 :       MCOperand MCOp;
     520           4 :       TmpInst.setOpcode(Mips::MSUBU);
     521             :       // Operand: rs
     522           6 :       lowerOperand(MI->getOperand(1), MCOp);
     523           2 :       TmpInst.addOperand(MCOp);
     524             :       // Operand: rt
     525           6 :       lowerOperand(MI->getOperand(2), MCOp);
     526           2 :       TmpInst.addOperand(MCOp);
     527           2 :       EmitToStreamer(OutStreamer, TmpInst);
     528             :       break;
     529             :     }
     530          12 :     case Mips::PseudoMULT: {
     531          24 :       MCInst TmpInst;
     532          12 :       MCOperand MCOp;
     533          24 :       TmpInst.setOpcode(Mips::MULT);
     534             :       // Operand: rs
     535          36 :       lowerOperand(MI->getOperand(1), MCOp);
     536          12 :       TmpInst.addOperand(MCOp);
     537             :       // Operand: rt
     538          36 :       lowerOperand(MI->getOperand(2), MCOp);
     539          12 :       TmpInst.addOperand(MCOp);
     540          12 :       EmitToStreamer(OutStreamer, TmpInst);
     541             :       break;
     542             :     }
     543           6 :     case Mips::PseudoMULTu: {
     544          12 :       MCInst TmpInst;
     545           6 :       MCOperand MCOp;
     546          12 :       TmpInst.setOpcode(Mips::MULTu);
     547             :       // Operand: rs
     548          18 :       lowerOperand(MI->getOperand(1), MCOp);
     549           6 :       TmpInst.addOperand(MCOp);
     550             :       // Operand: rt
     551          18 :       lowerOperand(MI->getOperand(2), MCOp);
     552           6 :       TmpInst.addOperand(MCOp);
     553           6 :       EmitToStreamer(OutStreamer, TmpInst);
     554             :       break;
     555             :     }
     556          14 :     case Mips::PseudoPICK_PH: {
     557          28 :       MCInst TmpInst;
     558          14 :       MCOperand MCOp;
     559          28 :       TmpInst.setOpcode(Mips::PICK_PH);
     560             :       // Operand: rd
     561          28 :       lowerOperand(MI->getOperand(0), MCOp);
     562          14 :       TmpInst.addOperand(MCOp);
     563             :       // Operand: rs
     564          42 :       lowerOperand(MI->getOperand(2), MCOp);
     565          14 :       TmpInst.addOperand(MCOp);
     566             :       // Operand: rt
     567          42 :       lowerOperand(MI->getOperand(3), MCOp);
     568          14 :       TmpInst.addOperand(MCOp);
     569          14 :       EmitToStreamer(OutStreamer, TmpInst);
     570             :       break;
     571             :     }
     572          12 :     case Mips::PseudoPICK_QB: {
     573          24 :       MCInst TmpInst;
     574          12 :       MCOperand MCOp;
     575          24 :       TmpInst.setOpcode(Mips::PICK_QB);
     576             :       // Operand: rd
     577          24 :       lowerOperand(MI->getOperand(0), MCOp);
     578          12 :       TmpInst.addOperand(MCOp);
     579             :       // Operand: rs
     580          36 :       lowerOperand(MI->getOperand(2), MCOp);
     581          12 :       TmpInst.addOperand(MCOp);
     582             :       // Operand: rt
     583          36 :       lowerOperand(MI->getOperand(3), MCOp);
     584          12 :       TmpInst.addOperand(MCOp);
     585          12 :       EmitToStreamer(OutStreamer, TmpInst);
     586             :       break;
     587             :     }
     588         124 :     case Mips::PseudoSDIV: {
     589         248 :       MCInst TmpInst;
     590         124 :       MCOperand MCOp;
     591         248 :       TmpInst.setOpcode(Mips::SDIV);
     592             :       // Operand: rs
     593         372 :       lowerOperand(MI->getOperand(1), MCOp);
     594         124 :       TmpInst.addOperand(MCOp);
     595             :       // Operand: rt
     596         372 :       lowerOperand(MI->getOperand(2), MCOp);
     597         124 :       TmpInst.addOperand(MCOp);
     598         124 :       EmitToStreamer(OutStreamer, TmpInst);
     599             :       break;
     600             :     }
     601         122 :     case Mips::PseudoUDIV: {
     602         244 :       MCInst TmpInst;
     603         122 :       MCOperand MCOp;
     604         244 :       TmpInst.setOpcode(Mips::UDIV);
     605             :       // Operand: rs
     606         366 :       lowerOperand(MI->getOperand(1), MCOp);
     607         122 :       TmpInst.addOperand(MCOp);
     608             :       // Operand: rt
     609         366 :       lowerOperand(MI->getOperand(2), MCOp);
     610         122 :       TmpInst.addOperand(MCOp);
     611         122 :       EmitToStreamer(OutStreamer, TmpInst);
     612             :       break;
     613             :     }
     614           8 :     case Mips::SDIV_MM_Pseudo: {
     615          16 :       MCInst TmpInst;
     616           8 :       MCOperand MCOp;
     617          16 :       TmpInst.setOpcode(Mips::SDIV_MM);
     618             :       // Operand: rs
     619          24 :       lowerOperand(MI->getOperand(1), MCOp);
     620           8 :       TmpInst.addOperand(MCOp);
     621             :       // Operand: rt
     622          24 :       lowerOperand(MI->getOperand(2), MCOp);
     623           8 :       TmpInst.addOperand(MCOp);
     624           8 :       EmitToStreamer(OutStreamer, TmpInst);
     625             :       break;
     626             :     }
     627          23 :     case Mips::TAILCALL: {
     628          46 :       MCInst TmpInst;
     629          23 :       MCOperand MCOp;
     630          46 :       TmpInst.setOpcode(Mips::J);
     631             :       // Operand: target
     632          46 :       lowerOperand(MI->getOperand(0), MCOp);
     633          23 :       TmpInst.addOperand(MCOp);
     634          23 :       EmitToStreamer(OutStreamer, TmpInst);
     635             :       break;
     636             :     }
     637           0 :     case Mips::TAILCALL_MM: {
     638           0 :       MCInst TmpInst;
     639           0 :       MCOperand MCOp;
     640           0 :       TmpInst.setOpcode(Mips::J_MM);
     641             :       // Operand: target
     642           0 :       lowerOperand(MI->getOperand(0), MCOp);
     643           0 :       TmpInst.addOperand(MCOp);
     644           0 :       EmitToStreamer(OutStreamer, TmpInst);
     645             :       break;
     646             :     }
     647           0 :     case Mips::TAILCALL_MMR6: {
     648           0 :       MCInst TmpInst;
     649           0 :       MCOperand MCOp;
     650           0 :       TmpInst.setOpcode(Mips::BC_MMR6);
     651             :       // Operand: offset
     652           0 :       lowerOperand(MI->getOperand(0), MCOp);
     653           0 :       TmpInst.addOperand(MCOp);
     654           0 :       EmitToStreamer(OutStreamer, TmpInst);
     655             :       break;
     656             :     }
     657           1 :     case Mips::TRAP: {
     658           2 :       MCInst TmpInst;
     659           1 :       MCOperand MCOp;
     660           2 :       TmpInst.setOpcode(Mips::BREAK);
     661             :       // Operand: code_1
     662           2 :       TmpInst.addOperand(MCOperand::createImm(0));
     663             :       // Operand: code_2
     664           2 :       TmpInst.addOperand(MCOperand::createImm(0));
     665           1 :       EmitToStreamer(OutStreamer, TmpInst);
     666             :       break;
     667             :     }
     668           8 :     case Mips::UDIV_MM_Pseudo: {
     669          16 :       MCInst TmpInst;
     670           8 :       MCOperand MCOp;
     671          16 :       TmpInst.setOpcode(Mips::UDIV_MM);
     672             :       // Operand: rs
     673          24 :       lowerOperand(MI->getOperand(1), MCOp);
     674           8 :       TmpInst.addOperand(MCOp);
     675             :       // Operand: rt
     676          24 :       lowerOperand(MI->getOperand(2), MCOp);
     677           8 :       TmpInst.addOperand(MCOp);
     678           8 :       EmitToStreamer(OutStreamer, TmpInst);
     679             :       break;
     680             :     }
     681          12 :     case Mips::XOR_V_D_PSEUDO: {
     682          24 :       MCInst TmpInst;
     683          12 :       MCOperand MCOp;
     684          24 :       TmpInst.setOpcode(Mips::XOR_V);
     685             :       // Operand: wd
     686          24 :       lowerOperand(MI->getOperand(0), MCOp);
     687          12 :       TmpInst.addOperand(MCOp);
     688             :       // Operand: ws
     689          36 :       lowerOperand(MI->getOperand(1), MCOp);
     690          12 :       TmpInst.addOperand(MCOp);
     691             :       // Operand: wt
     692          36 :       lowerOperand(MI->getOperand(2), MCOp);
     693          12 :       TmpInst.addOperand(MCOp);
     694          12 :       EmitToStreamer(OutStreamer, TmpInst);
     695             :       break;
     696             :     }
     697           8 :     case Mips::XOR_V_H_PSEUDO: {
     698          16 :       MCInst TmpInst;
     699           8 :       MCOperand MCOp;
     700          16 :       TmpInst.setOpcode(Mips::XOR_V);
     701             :       // Operand: wd
     702          16 :       lowerOperand(MI->getOperand(0), MCOp);
     703           8 :       TmpInst.addOperand(MCOp);
     704             :       // Operand: ws
     705          24 :       lowerOperand(MI->getOperand(1), MCOp);
     706           8 :       TmpInst.addOperand(MCOp);
     707             :       // Operand: wt
     708          24 :       lowerOperand(MI->getOperand(2), MCOp);
     709           8 :       TmpInst.addOperand(MCOp);
     710           8 :       EmitToStreamer(OutStreamer, TmpInst);
     711             :       break;
     712             :     }
     713           8 :     case Mips::XOR_V_W_PSEUDO: {
     714          16 :       MCInst TmpInst;
     715           8 :       MCOperand MCOp;
     716          16 :       TmpInst.setOpcode(Mips::XOR_V);
     717             :       // Operand: wd
     718          16 :       lowerOperand(MI->getOperand(0), MCOp);
     719           8 :       TmpInst.addOperand(MCOp);
     720             :       // Operand: ws
     721          24 :       lowerOperand(MI->getOperand(1), MCOp);
     722           8 :       TmpInst.addOperand(MCOp);
     723             :       // Operand: wt
     724          24 :       lowerOperand(MI->getOperand(2), MCOp);
     725           8 :       TmpInst.addOperand(MCOp);
     726           8 :       EmitToStreamer(OutStreamer, TmpInst);
     727             :       break;
     728             :     }
     729             :   }
     730             :   return true;
     731             : }
     732             : 

Generated by: LCOV version 1.13