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: 232 255 91.0 %
Date: 2018-09-23 13:06:45 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      124949 : bool MipsAsmPrinter::
      10             : emitPseudoExpansionLowering(MCStreamer &OutStreamer,
      11             :                             const MachineInstr *MI) {
      12      249898 :   switch (MI->getOpcode()) {
      13             :     default: return false;
      14             :     case Mips::AND_V_D_PSEUDO: {
      15             :       MCInst TmpInst;
      16             :       MCOperand MCOp;
      17             :       TmpInst.setOpcode(Mips::AND_V);
      18             :       // Operand: wd
      19           6 :       lowerOperand(MI->getOperand(0), MCOp);
      20             :       TmpInst.addOperand(MCOp);
      21             :       // Operand: ws
      22           6 :       lowerOperand(MI->getOperand(1), MCOp);
      23             :       TmpInst.addOperand(MCOp);
      24             :       // Operand: wt
      25           6 :       lowerOperand(MI->getOperand(2), MCOp);
      26             :       TmpInst.addOperand(MCOp);
      27           6 :       EmitToStreamer(OutStreamer, TmpInst);
      28             :       break;
      29             :     }
      30             :     case Mips::AND_V_H_PSEUDO: {
      31             :       MCInst TmpInst;
      32             :       MCOperand MCOp;
      33             :       TmpInst.setOpcode(Mips::AND_V);
      34             :       // Operand: wd
      35           6 :       lowerOperand(MI->getOperand(0), MCOp);
      36             :       TmpInst.addOperand(MCOp);
      37             :       // Operand: ws
      38           6 :       lowerOperand(MI->getOperand(1), MCOp);
      39             :       TmpInst.addOperand(MCOp);
      40             :       // Operand: wt
      41           6 :       lowerOperand(MI->getOperand(2), MCOp);
      42             :       TmpInst.addOperand(MCOp);
      43           6 :       EmitToStreamer(OutStreamer, TmpInst);
      44             :       break;
      45             :     }
      46             :     case Mips::AND_V_W_PSEUDO: {
      47             :       MCInst TmpInst;
      48             :       MCOperand MCOp;
      49             :       TmpInst.setOpcode(Mips::AND_V);
      50             :       // Operand: wd
      51           6 :       lowerOperand(MI->getOperand(0), MCOp);
      52             :       TmpInst.addOperand(MCOp);
      53             :       // Operand: ws
      54           6 :       lowerOperand(MI->getOperand(1), MCOp);
      55             :       TmpInst.addOperand(MCOp);
      56             :       // Operand: wt
      57           6 :       lowerOperand(MI->getOperand(2), MCOp);
      58             :       TmpInst.addOperand(MCOp);
      59           6 :       EmitToStreamer(OutStreamer, TmpInst);
      60             :       break;
      61             :     }
      62             :     case Mips::B: {
      63             :       MCInst TmpInst;
      64             :       MCOperand MCOp;
      65             :       TmpInst.setOpcode(Mips::BEQ);
      66             :       // Operand: rs
      67          56 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
      68             :       // Operand: rt
      69          56 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
      70             :       // Operand: offset
      71          56 :       lowerOperand(MI->getOperand(0), MCOp);
      72             :       TmpInst.addOperand(MCOp);
      73          56 :       EmitToStreamer(OutStreamer, TmpInst);
      74             :       break;
      75             :     }
      76             :     case Mips::BAL_BR: {
      77             :       MCInst TmpInst;
      78             :       MCOperand MCOp;
      79             :       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             :       TmpInst.addOperand(MCOp);
      85          10 :       EmitToStreamer(OutStreamer, TmpInst);
      86             :       break;
      87             :     }
      88             :     case Mips::BAL_BR_MM: {
      89             :       MCInst TmpInst;
      90             :       MCOperand MCOp;
      91             :       TmpInst.setOpcode(Mips::BGEZAL_MM);
      92             :       // Operand: rs
      93           6 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
      94             :       // Operand: offset
      95           6 :       lowerOperand(MI->getOperand(0), MCOp);
      96             :       TmpInst.addOperand(MCOp);
      97           6 :       EmitToStreamer(OutStreamer, TmpInst);
      98             :       break;
      99             :     }
     100             :     case Mips::BSEL_D_PSEUDO: {
     101             :       MCInst TmpInst;
     102             :       MCOperand MCOp;
     103             :       TmpInst.setOpcode(Mips::BSEL_V);
     104             :       // Operand: wd
     105          10 :       lowerOperand(MI->getOperand(0), MCOp);
     106             :       TmpInst.addOperand(MCOp);
     107             :       // Operand: wd_in
     108          10 :       lowerOperand(MI->getOperand(1), MCOp);
     109             :       TmpInst.addOperand(MCOp);
     110             :       // Operand: ws
     111          10 :       lowerOperand(MI->getOperand(2), MCOp);
     112             :       TmpInst.addOperand(MCOp);
     113             :       // Operand: wt
     114          10 :       lowerOperand(MI->getOperand(3), MCOp);
     115             :       TmpInst.addOperand(MCOp);
     116          10 :       EmitToStreamer(OutStreamer, TmpInst);
     117             :       break;
     118             :     }
     119             :     case Mips::BSEL_FD_PSEUDO: {
     120             :       MCInst TmpInst;
     121             :       MCOperand MCOp;
     122             :       TmpInst.setOpcode(Mips::BSEL_V);
     123             :       // Operand: wd
     124           4 :       lowerOperand(MI->getOperand(0), MCOp);
     125             :       TmpInst.addOperand(MCOp);
     126             :       // Operand: wd_in
     127           4 :       lowerOperand(MI->getOperand(1), MCOp);
     128             :       TmpInst.addOperand(MCOp);
     129             :       // Operand: ws
     130           4 :       lowerOperand(MI->getOperand(2), MCOp);
     131             :       TmpInst.addOperand(MCOp);
     132             :       // Operand: wt
     133           4 :       lowerOperand(MI->getOperand(3), MCOp);
     134             :       TmpInst.addOperand(MCOp);
     135           4 :       EmitToStreamer(OutStreamer, TmpInst);
     136             :       break;
     137             :     }
     138             :     case Mips::BSEL_FW_PSEUDO: {
     139             :       MCInst TmpInst;
     140             :       MCOperand MCOp;
     141             :       TmpInst.setOpcode(Mips::BSEL_V);
     142             :       // Operand: wd
     143           8 :       lowerOperand(MI->getOperand(0), MCOp);
     144             :       TmpInst.addOperand(MCOp);
     145             :       // Operand: wd_in
     146           8 :       lowerOperand(MI->getOperand(1), MCOp);
     147             :       TmpInst.addOperand(MCOp);
     148             :       // Operand: ws
     149           8 :       lowerOperand(MI->getOperand(2), MCOp);
     150             :       TmpInst.addOperand(MCOp);
     151             :       // Operand: wt
     152           8 :       lowerOperand(MI->getOperand(3), MCOp);
     153             :       TmpInst.addOperand(MCOp);
     154           8 :       EmitToStreamer(OutStreamer, TmpInst);
     155             :       break;
     156             :     }
     157             :     case Mips::BSEL_H_PSEUDO: {
     158             :       MCInst TmpInst;
     159             :       MCOperand MCOp;
     160             :       TmpInst.setOpcode(Mips::BSEL_V);
     161             :       // Operand: wd
     162          10 :       lowerOperand(MI->getOperand(0), MCOp);
     163             :       TmpInst.addOperand(MCOp);
     164             :       // Operand: wd_in
     165          10 :       lowerOperand(MI->getOperand(1), MCOp);
     166             :       TmpInst.addOperand(MCOp);
     167             :       // Operand: ws
     168          10 :       lowerOperand(MI->getOperand(2), MCOp);
     169             :       TmpInst.addOperand(MCOp);
     170             :       // Operand: wt
     171          10 :       lowerOperand(MI->getOperand(3), MCOp);
     172             :       TmpInst.addOperand(MCOp);
     173          10 :       EmitToStreamer(OutStreamer, TmpInst);
     174             :       break;
     175             :     }
     176             :     case Mips::BSEL_W_PSEUDO: {
     177             :       MCInst TmpInst;
     178             :       MCOperand MCOp;
     179             :       TmpInst.setOpcode(Mips::BSEL_V);
     180             :       // Operand: wd
     181          10 :       lowerOperand(MI->getOperand(0), MCOp);
     182             :       TmpInst.addOperand(MCOp);
     183             :       // Operand: wd_in
     184          10 :       lowerOperand(MI->getOperand(1), MCOp);
     185             :       TmpInst.addOperand(MCOp);
     186             :       // Operand: ws
     187          10 :       lowerOperand(MI->getOperand(2), MCOp);
     188             :       TmpInst.addOperand(MCOp);
     189             :       // Operand: wt
     190          10 :       lowerOperand(MI->getOperand(3), MCOp);
     191             :       TmpInst.addOperand(MCOp);
     192          10 :       EmitToStreamer(OutStreamer, TmpInst);
     193             :       break;
     194             :     }
     195             :     case Mips::B_MM: {
     196             :       MCInst TmpInst;
     197             :       MCOperand MCOp;
     198             :       TmpInst.setOpcode(Mips::BEQ_MM);
     199             :       // Operand: rs
     200           4 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
     201             :       // Operand: rt
     202           4 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
     203             :       // Operand: offset
     204           4 :       lowerOperand(MI->getOperand(0), MCOp);
     205             :       TmpInst.addOperand(MCOp);
     206           4 :       EmitToStreamer(OutStreamer, TmpInst);
     207             :       break;
     208             :     }
     209             :     case Mips::FABS_D: {
     210             :       MCInst TmpInst;
     211             :       MCOperand MCOp;
     212             :       TmpInst.setOpcode(Mips::FMAX_A_D);
     213             :       // Operand: wd
     214           2 :       lowerOperand(MI->getOperand(0), MCOp);
     215             :       TmpInst.addOperand(MCOp);
     216             :       // Operand: ws
     217           2 :       lowerOperand(MI->getOperand(1), MCOp);
     218             :       TmpInst.addOperand(MCOp);
     219             :       // Operand: wt
     220           2 :       lowerOperand(MI->getOperand(1), MCOp);
     221             :       TmpInst.addOperand(MCOp);
     222           2 :       EmitToStreamer(OutStreamer, TmpInst);
     223             :       break;
     224             :     }
     225             :     case Mips::FABS_W: {
     226             :       MCInst TmpInst;
     227             :       MCOperand MCOp;
     228             :       TmpInst.setOpcode(Mips::FMAX_A_W);
     229             :       // Operand: wd
     230           2 :       lowerOperand(MI->getOperand(0), MCOp);
     231             :       TmpInst.addOperand(MCOp);
     232             :       // Operand: ws
     233           2 :       lowerOperand(MI->getOperand(1), MCOp);
     234             :       TmpInst.addOperand(MCOp);
     235             :       // Operand: wt
     236           2 :       lowerOperand(MI->getOperand(1), MCOp);
     237             :       TmpInst.addOperand(MCOp);
     238           2 :       EmitToStreamer(OutStreamer, TmpInst);
     239             :       break;
     240             :     }
     241             :     case Mips::JALR64Pseudo: {
     242             :       MCInst TmpInst;
     243             :       MCOperand MCOp;
     244             :       TmpInst.setOpcode(Mips::JALR);
     245             :       // Operand: rd
     246         453 :       TmpInst.addOperand(MCOperand::createReg(Mips::RA));
     247             :       // Operand: rs
     248         453 :       lowerOperand(MI->getOperand(0), MCOp);
     249             :       TmpInst.addOperand(MCOp);
     250         453 :       EmitToStreamer(OutStreamer, TmpInst);
     251             :       break;
     252             :     }
     253             :     case Mips::JALRHB64Pseudo: {
     254             :       MCInst TmpInst;
     255             :       MCOperand MCOp;
     256             :       TmpInst.setOpcode(Mips::JALR_HB64);
     257             :       // Operand: rd
     258           6 :       TmpInst.addOperand(MCOperand::createReg(Mips::RA_64));
     259             :       // Operand: rs
     260           6 :       lowerOperand(MI->getOperand(0), MCOp);
     261             :       TmpInst.addOperand(MCOp);
     262           6 :       EmitToStreamer(OutStreamer, TmpInst);
     263             :       break;
     264             :     }
     265             :     case Mips::JALRHBPseudo: {
     266             :       MCInst TmpInst;
     267             :       MCOperand MCOp;
     268             :       TmpInst.setOpcode(Mips::JALR_HB);
     269             :       // Operand: rd
     270           8 :       TmpInst.addOperand(MCOperand::createReg(Mips::RA));
     271             :       // Operand: rs
     272           8 :       lowerOperand(MI->getOperand(0), MCOp);
     273             :       TmpInst.addOperand(MCOp);
     274           8 :       EmitToStreamer(OutStreamer, TmpInst);
     275             :       break;
     276             :     }
     277             :     case Mips::JALRPseudo: {
     278             :       MCInst TmpInst;
     279             :       MCOperand MCOp;
     280             :       TmpInst.setOpcode(Mips::JALR);
     281             :       // Operand: rd
     282         501 :       TmpInst.addOperand(MCOperand::createReg(Mips::RA));
     283             :       // Operand: rs
     284         501 :       lowerOperand(MI->getOperand(0), MCOp);
     285             :       TmpInst.addOperand(MCOp);
     286         501 :       EmitToStreamer(OutStreamer, TmpInst);
     287             :       break;
     288             :     }
     289             :     case Mips::NOP: {
     290             :       MCInst TmpInst;
     291             :       MCOperand MCOp;
     292             :       TmpInst.setOpcode(Mips::SLL);
     293             :       // Operand: rd
     294        3516 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
     295             :       // Operand: rt
     296        3516 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
     297             :       // Operand: shamt
     298        3516 :       TmpInst.addOperand(MCOperand::createImm(0));
     299        3516 :       EmitToStreamer(OutStreamer, TmpInst);
     300             :       break;
     301             :     }
     302             :     case Mips::NOR_V_D_PSEUDO: {
     303             :       MCInst TmpInst;
     304             :       MCOperand MCOp;
     305             :       TmpInst.setOpcode(Mips::NOR_V);
     306             :       // Operand: wd
     307           4 :       lowerOperand(MI->getOperand(0), MCOp);
     308             :       TmpInst.addOperand(MCOp);
     309             :       // Operand: ws
     310           4 :       lowerOperand(MI->getOperand(1), MCOp);
     311             :       TmpInst.addOperand(MCOp);
     312             :       // Operand: wt
     313           4 :       lowerOperand(MI->getOperand(2), MCOp);
     314             :       TmpInst.addOperand(MCOp);
     315           4 :       EmitToStreamer(OutStreamer, TmpInst);
     316             :       break;
     317             :     }
     318             :     case Mips::NOR_V_H_PSEUDO: {
     319             :       MCInst TmpInst;
     320             :       MCOperand MCOp;
     321             :       TmpInst.setOpcode(Mips::NOR_V);
     322             :       // Operand: wd
     323           4 :       lowerOperand(MI->getOperand(0), MCOp);
     324             :       TmpInst.addOperand(MCOp);
     325             :       // Operand: ws
     326           4 :       lowerOperand(MI->getOperand(1), MCOp);
     327             :       TmpInst.addOperand(MCOp);
     328             :       // Operand: wt
     329           4 :       lowerOperand(MI->getOperand(2), MCOp);
     330             :       TmpInst.addOperand(MCOp);
     331           4 :       EmitToStreamer(OutStreamer, TmpInst);
     332             :       break;
     333             :     }
     334             :     case Mips::NOR_V_W_PSEUDO: {
     335             :       MCInst TmpInst;
     336             :       MCOperand MCOp;
     337             :       TmpInst.setOpcode(Mips::NOR_V);
     338             :       // Operand: wd
     339           4 :       lowerOperand(MI->getOperand(0), MCOp);
     340             :       TmpInst.addOperand(MCOp);
     341             :       // Operand: ws
     342           4 :       lowerOperand(MI->getOperand(1), MCOp);
     343             :       TmpInst.addOperand(MCOp);
     344             :       // Operand: wt
     345           4 :       lowerOperand(MI->getOperand(2), MCOp);
     346             :       TmpInst.addOperand(MCOp);
     347           4 :       EmitToStreamer(OutStreamer, TmpInst);
     348             :       break;
     349             :     }
     350             :     case Mips::OR_V_D_PSEUDO: {
     351             :       MCInst TmpInst;
     352             :       MCOperand MCOp;
     353             :       TmpInst.setOpcode(Mips::OR_V);
     354             :       // Operand: wd
     355           6 :       lowerOperand(MI->getOperand(0), MCOp);
     356             :       TmpInst.addOperand(MCOp);
     357             :       // Operand: ws
     358           6 :       lowerOperand(MI->getOperand(1), MCOp);
     359             :       TmpInst.addOperand(MCOp);
     360             :       // Operand: wt
     361           6 :       lowerOperand(MI->getOperand(2), MCOp);
     362             :       TmpInst.addOperand(MCOp);
     363           6 :       EmitToStreamer(OutStreamer, TmpInst);
     364             :       break;
     365             :     }
     366             :     case Mips::OR_V_H_PSEUDO: {
     367             :       MCInst TmpInst;
     368             :       MCOperand MCOp;
     369             :       TmpInst.setOpcode(Mips::OR_V);
     370             :       // Operand: wd
     371           6 :       lowerOperand(MI->getOperand(0), MCOp);
     372             :       TmpInst.addOperand(MCOp);
     373             :       // Operand: ws
     374           6 :       lowerOperand(MI->getOperand(1), MCOp);
     375             :       TmpInst.addOperand(MCOp);
     376             :       // Operand: wt
     377           6 :       lowerOperand(MI->getOperand(2), MCOp);
     378             :       TmpInst.addOperand(MCOp);
     379           6 :       EmitToStreamer(OutStreamer, TmpInst);
     380             :       break;
     381             :     }
     382             :     case Mips::OR_V_W_PSEUDO: {
     383             :       MCInst TmpInst;
     384             :       MCOperand MCOp;
     385             :       TmpInst.setOpcode(Mips::OR_V);
     386             :       // Operand: wd
     387           6 :       lowerOperand(MI->getOperand(0), MCOp);
     388             :       TmpInst.addOperand(MCOp);
     389             :       // Operand: ws
     390           6 :       lowerOperand(MI->getOperand(1), MCOp);
     391             :       TmpInst.addOperand(MCOp);
     392             :       // Operand: wt
     393           6 :       lowerOperand(MI->getOperand(2), MCOp);
     394             :       TmpInst.addOperand(MCOp);
     395           6 :       EmitToStreamer(OutStreamer, TmpInst);
     396             :       break;
     397             :     }
     398             :     case Mips::PseudoCMPU_EQ_QB: {
     399             :       MCInst TmpInst;
     400             :       MCOperand MCOp;
     401             :       TmpInst.setOpcode(Mips::CMPU_EQ_QB);
     402             :       // Operand: rs
     403           4 :       lowerOperand(MI->getOperand(1), MCOp);
     404             :       TmpInst.addOperand(MCOp);
     405             :       // Operand: rt
     406           4 :       lowerOperand(MI->getOperand(2), MCOp);
     407             :       TmpInst.addOperand(MCOp);
     408           4 :       EmitToStreamer(OutStreamer, TmpInst);
     409             :       break;
     410             :     }
     411             :     case Mips::PseudoCMPU_LE_QB: {
     412             :       MCInst TmpInst;
     413             :       MCOperand MCOp;
     414             :       TmpInst.setOpcode(Mips::CMPU_LE_QB);
     415             :       // Operand: rs
     416           8 :       lowerOperand(MI->getOperand(1), MCOp);
     417             :       TmpInst.addOperand(MCOp);
     418             :       // Operand: rt
     419           4 :       lowerOperand(MI->getOperand(2), MCOp);
     420             :       TmpInst.addOperand(MCOp);
     421           4 :       EmitToStreamer(OutStreamer, TmpInst);
     422             :       break;
     423             :     }
     424             :     case Mips::PseudoCMPU_LT_QB: {
     425             :       MCInst TmpInst;
     426             :       MCOperand MCOp;
     427             :       TmpInst.setOpcode(Mips::CMPU_LT_QB);
     428             :       // Operand: rs
     429           4 :       lowerOperand(MI->getOperand(1), MCOp);
     430             :       TmpInst.addOperand(MCOp);
     431             :       // Operand: rt
     432           4 :       lowerOperand(MI->getOperand(2), MCOp);
     433             :       TmpInst.addOperand(MCOp);
     434           4 :       EmitToStreamer(OutStreamer, TmpInst);
     435             :       break;
     436             :     }
     437             :     case Mips::PseudoCMP_EQ_PH: {
     438             :       MCInst TmpInst;
     439             :       MCOperand MCOp;
     440             :       TmpInst.setOpcode(Mips::CMP_EQ_PH);
     441             :       // Operand: rs
     442           4 :       lowerOperand(MI->getOperand(1), MCOp);
     443             :       TmpInst.addOperand(MCOp);
     444             :       // Operand: rt
     445           4 :       lowerOperand(MI->getOperand(2), MCOp);
     446             :       TmpInst.addOperand(MCOp);
     447           4 :       EmitToStreamer(OutStreamer, TmpInst);
     448             :       break;
     449             :     }
     450             :     case Mips::PseudoCMP_LE_PH: {
     451             :       MCInst TmpInst;
     452             :       MCOperand MCOp;
     453             :       TmpInst.setOpcode(Mips::CMP_LE_PH);
     454             :       // Operand: rs
     455           4 :       lowerOperand(MI->getOperand(1), MCOp);
     456             :       TmpInst.addOperand(MCOp);
     457             :       // Operand: rt
     458           4 :       lowerOperand(MI->getOperand(2), MCOp);
     459             :       TmpInst.addOperand(MCOp);
     460           4 :       EmitToStreamer(OutStreamer, TmpInst);
     461             :       break;
     462             :     }
     463             :     case Mips::PseudoCMP_LT_PH: {
     464             :       MCInst TmpInst;
     465             :       MCOperand MCOp;
     466             :       TmpInst.setOpcode(Mips::CMP_LT_PH);
     467             :       // Operand: rs
     468           5 :       lowerOperand(MI->getOperand(1), MCOp);
     469             :       TmpInst.addOperand(MCOp);
     470             :       // Operand: rt
     471           5 :       lowerOperand(MI->getOperand(2), MCOp);
     472             :       TmpInst.addOperand(MCOp);
     473           5 :       EmitToStreamer(OutStreamer, TmpInst);
     474             :       break;
     475             :     }
     476             :     case Mips::PseudoDMULT: {
     477             :       MCInst TmpInst;
     478             :       MCOperand MCOp;
     479             :       TmpInst.setOpcode(Mips::DMULT);
     480             :       // Operand: rs
     481          54 :       lowerOperand(MI->getOperand(1), MCOp);
     482             :       TmpInst.addOperand(MCOp);
     483             :       // Operand: rt
     484          54 :       lowerOperand(MI->getOperand(2), MCOp);
     485             :       TmpInst.addOperand(MCOp);
     486          54 :       EmitToStreamer(OutStreamer, TmpInst);
     487             :       break;
     488             :     }
     489             :     case Mips::PseudoDMULTu: {
     490             :       MCInst TmpInst;
     491             :       MCOperand MCOp;
     492             :       TmpInst.setOpcode(Mips::DMULTu);
     493             :       // Operand: rs
     494           5 :       lowerOperand(MI->getOperand(1), MCOp);
     495             :       TmpInst.addOperand(MCOp);
     496             :       // Operand: rt
     497           5 :       lowerOperand(MI->getOperand(2), MCOp);
     498             :       TmpInst.addOperand(MCOp);
     499           5 :       EmitToStreamer(OutStreamer, TmpInst);
     500             :       break;
     501             :     }
     502             :     case Mips::PseudoDSDIV: {
     503             :       MCInst TmpInst;
     504             :       MCOperand MCOp;
     505             :       TmpInst.setOpcode(Mips::DSDIV);
     506             :       // Operand: rs
     507          36 :       lowerOperand(MI->getOperand(1), MCOp);
     508             :       TmpInst.addOperand(MCOp);
     509             :       // Operand: rt
     510          36 :       lowerOperand(MI->getOperand(2), MCOp);
     511             :       TmpInst.addOperand(MCOp);
     512          36 :       EmitToStreamer(OutStreamer, TmpInst);
     513             :       break;
     514             :     }
     515             :     case Mips::PseudoDUDIV: {
     516             :       MCInst TmpInst;
     517             :       MCOperand MCOp;
     518             :       TmpInst.setOpcode(Mips::DUDIV);
     519             :       // Operand: rs
     520          36 :       lowerOperand(MI->getOperand(1), MCOp);
     521             :       TmpInst.addOperand(MCOp);
     522             :       // Operand: rt
     523          36 :       lowerOperand(MI->getOperand(2), MCOp);
     524             :       TmpInst.addOperand(MCOp);
     525          36 :       EmitToStreamer(OutStreamer, TmpInst);
     526             :       break;
     527             :     }
     528             :     case Mips::PseudoIndirectBranch: {
     529             :       MCInst TmpInst;
     530             :       MCOperand MCOp;
     531             :       TmpInst.setOpcode(Mips::JR);
     532             :       // Operand: rs
     533          16 :       lowerOperand(MI->getOperand(0), MCOp);
     534             :       TmpInst.addOperand(MCOp);
     535          16 :       EmitToStreamer(OutStreamer, TmpInst);
     536             :       break;
     537             :     }
     538             :     case Mips::PseudoIndirectBranch64: {
     539             :       MCInst TmpInst;
     540             :       MCOperand MCOp;
     541             :       TmpInst.setOpcode(Mips::JR64);
     542             :       // Operand: rs
     543          13 :       lowerOperand(MI->getOperand(0), MCOp);
     544             :       TmpInst.addOperand(MCOp);
     545          13 :       EmitToStreamer(OutStreamer, TmpInst);
     546             :       break;
     547             :     }
     548             :     case Mips::PseudoIndirectBranch64R6: {
     549             :       MCInst TmpInst;
     550             :       MCOperand MCOp;
     551             :       TmpInst.setOpcode(Mips::JALR64);
     552             :       // Operand: rd
     553           0 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO_64));
     554             :       // Operand: rs
     555           0 :       lowerOperand(MI->getOperand(0), MCOp);
     556             :       TmpInst.addOperand(MCOp);
     557           0 :       EmitToStreamer(OutStreamer, TmpInst);
     558             :       break;
     559             :     }
     560             :     case Mips::PseudoIndirectBranchR6: {
     561             :       MCInst TmpInst;
     562             :       MCOperand MCOp;
     563             :       TmpInst.setOpcode(Mips::JALR);
     564             :       // Operand: rd
     565           0 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
     566             :       // Operand: rs
     567           0 :       lowerOperand(MI->getOperand(0), MCOp);
     568             :       TmpInst.addOperand(MCOp);
     569           0 :       EmitToStreamer(OutStreamer, TmpInst);
     570             :       break;
     571             :     }
     572             :     case Mips::PseudoIndirectBranch_MM: {
     573             :       MCInst TmpInst;
     574             :       MCOperand MCOp;
     575             :       TmpInst.setOpcode(Mips::JR_MM);
     576             :       // Operand: rs
     577           1 :       lowerOperand(MI->getOperand(0), MCOp);
     578             :       TmpInst.addOperand(MCOp);
     579           1 :       EmitToStreamer(OutStreamer, TmpInst);
     580             :       break;
     581             :     }
     582             :     case Mips::PseudoIndirectBranch_MMR6: {
     583             :       MCInst TmpInst;
     584             :       MCOperand MCOp;
     585             :       TmpInst.setOpcode(Mips::JRC16_MMR6);
     586             :       // Operand: rs
     587           0 :       lowerOperand(MI->getOperand(0), MCOp);
     588             :       TmpInst.addOperand(MCOp);
     589           0 :       EmitToStreamer(OutStreamer, TmpInst);
     590             :       break;
     591             :     }
     592             :     case Mips::PseudoIndirectHazardBranch: {
     593             :       MCInst TmpInst;
     594             :       MCOperand MCOp;
     595             :       TmpInst.setOpcode(Mips::JR_HB);
     596             :       // Operand: rs
     597           2 :       lowerOperand(MI->getOperand(0), MCOp);
     598             :       TmpInst.addOperand(MCOp);
     599           2 :       EmitToStreamer(OutStreamer, TmpInst);
     600             :       break;
     601             :     }
     602             :     case Mips::PseudoIndirectHazardBranch64: {
     603             :       MCInst TmpInst;
     604             :       MCOperand MCOp;
     605             :       TmpInst.setOpcode(Mips::JR_HB64);
     606             :       // Operand: rs
     607           2 :       lowerOperand(MI->getOperand(0), MCOp);
     608             :       TmpInst.addOperand(MCOp);
     609           2 :       EmitToStreamer(OutStreamer, TmpInst);
     610             :       break;
     611             :     }
     612             :     case Mips::PseudoIndrectHazardBranch64R6: {
     613             :       MCInst TmpInst;
     614             :       MCOperand MCOp;
     615             :       TmpInst.setOpcode(Mips::JR_HB64_R6);
     616             :       // Operand: rs
     617           2 :       lowerOperand(MI->getOperand(0), MCOp);
     618             :       TmpInst.addOperand(MCOp);
     619           2 :       EmitToStreamer(OutStreamer, TmpInst);
     620             :       break;
     621             :     }
     622             :     case Mips::PseudoIndrectHazardBranchR6: {
     623             :       MCInst TmpInst;
     624             :       MCOperand MCOp;
     625             :       TmpInst.setOpcode(Mips::JR_HB_R6);
     626             :       // Operand: rs
     627           2 :       lowerOperand(MI->getOperand(0), MCOp);
     628             :       TmpInst.addOperand(MCOp);
     629           2 :       EmitToStreamer(OutStreamer, TmpInst);
     630             :       break;
     631             :     }
     632             :     case Mips::PseudoMADD: {
     633             :       MCInst TmpInst;
     634             :       MCOperand MCOp;
     635             :       TmpInst.setOpcode(Mips::MADD);
     636             :       // Operand: rs
     637           4 :       lowerOperand(MI->getOperand(1), MCOp);
     638             :       TmpInst.addOperand(MCOp);
     639             :       // Operand: rt
     640           4 :       lowerOperand(MI->getOperand(2), MCOp);
     641             :       TmpInst.addOperand(MCOp);
     642           4 :       EmitToStreamer(OutStreamer, TmpInst);
     643             :       break;
     644             :     }
     645             :     case Mips::PseudoMADDU: {
     646             :       MCInst TmpInst;
     647             :       MCOperand MCOp;
     648             :       TmpInst.setOpcode(Mips::MADDU);
     649             :       // Operand: rs
     650           2 :       lowerOperand(MI->getOperand(1), MCOp);
     651             :       TmpInst.addOperand(MCOp);
     652             :       // Operand: rt
     653           2 :       lowerOperand(MI->getOperand(2), MCOp);
     654             :       TmpInst.addOperand(MCOp);
     655           2 :       EmitToStreamer(OutStreamer, TmpInst);
     656             :       break;
     657             :     }
     658             :     case Mips::PseudoMADDU_MM: {
     659             :       MCInst TmpInst;
     660             :       MCOperand MCOp;
     661             :       TmpInst.setOpcode(Mips::MADDU);
     662             :       // Operand: rs
     663           0 :       lowerOperand(MI->getOperand(1), MCOp);
     664             :       TmpInst.addOperand(MCOp);
     665             :       // Operand: rt
     666           0 :       lowerOperand(MI->getOperand(2), MCOp);
     667             :       TmpInst.addOperand(MCOp);
     668           0 :       EmitToStreamer(OutStreamer, TmpInst);
     669             :       break;
     670             :     }
     671             :     case Mips::PseudoMADD_MM: {
     672             :       MCInst TmpInst;
     673             :       MCOperand MCOp;
     674             :       TmpInst.setOpcode(Mips::MADD);
     675             :       // Operand: rs
     676           0 :       lowerOperand(MI->getOperand(1), MCOp);
     677             :       TmpInst.addOperand(MCOp);
     678             :       // Operand: rt
     679           0 :       lowerOperand(MI->getOperand(2), MCOp);
     680             :       TmpInst.addOperand(MCOp);
     681           0 :       EmitToStreamer(OutStreamer, TmpInst);
     682             :       break;
     683             :     }
     684             :     case Mips::PseudoMSUB: {
     685             :       MCInst TmpInst;
     686             :       MCOperand MCOp;
     687             :       TmpInst.setOpcode(Mips::MSUB);
     688             :       // Operand: rs
     689           4 :       lowerOperand(MI->getOperand(1), MCOp);
     690             :       TmpInst.addOperand(MCOp);
     691             :       // Operand: rt
     692           4 :       lowerOperand(MI->getOperand(2), MCOp);
     693             :       TmpInst.addOperand(MCOp);
     694           4 :       EmitToStreamer(OutStreamer, TmpInst);
     695             :       break;
     696             :     }
     697             :     case Mips::PseudoMSUBU: {
     698             :       MCInst TmpInst;
     699             :       MCOperand MCOp;
     700             :       TmpInst.setOpcode(Mips::MSUBU);
     701             :       // Operand: rs
     702           2 :       lowerOperand(MI->getOperand(1), MCOp);
     703             :       TmpInst.addOperand(MCOp);
     704             :       // Operand: rt
     705           2 :       lowerOperand(MI->getOperand(2), MCOp);
     706             :       TmpInst.addOperand(MCOp);
     707           2 :       EmitToStreamer(OutStreamer, TmpInst);
     708             :       break;
     709             :     }
     710             :     case Mips::PseudoMSUBU_MM: {
     711             :       MCInst TmpInst;
     712             :       MCOperand MCOp;
     713             :       TmpInst.setOpcode(Mips::MSUBU);
     714             :       // Operand: rs
     715           0 :       lowerOperand(MI->getOperand(1), MCOp);
     716             :       TmpInst.addOperand(MCOp);
     717             :       // Operand: rt
     718           0 :       lowerOperand(MI->getOperand(2), MCOp);
     719             :       TmpInst.addOperand(MCOp);
     720           0 :       EmitToStreamer(OutStreamer, TmpInst);
     721             :       break;
     722             :     }
     723             :     case Mips::PseudoMSUB_MM: {
     724             :       MCInst TmpInst;
     725             :       MCOperand MCOp;
     726             :       TmpInst.setOpcode(Mips::MSUB);
     727             :       // Operand: rs
     728           0 :       lowerOperand(MI->getOperand(1), MCOp);
     729             :       TmpInst.addOperand(MCOp);
     730             :       // Operand: rt
     731           0 :       lowerOperand(MI->getOperand(2), MCOp);
     732             :       TmpInst.addOperand(MCOp);
     733           0 :       EmitToStreamer(OutStreamer, TmpInst);
     734             :       break;
     735             :     }
     736             :     case Mips::PseudoMULT: {
     737             :       MCInst TmpInst;
     738             :       MCOperand MCOp;
     739             :       TmpInst.setOpcode(Mips::MULT);
     740             :       // Operand: rs
     741          11 :       lowerOperand(MI->getOperand(1), MCOp);
     742             :       TmpInst.addOperand(MCOp);
     743             :       // Operand: rt
     744          11 :       lowerOperand(MI->getOperand(2), MCOp);
     745             :       TmpInst.addOperand(MCOp);
     746          11 :       EmitToStreamer(OutStreamer, TmpInst);
     747             :       break;
     748             :     }
     749             :     case Mips::PseudoMULT_MM: {
     750             :       MCInst TmpInst;
     751             :       MCOperand MCOp;
     752             :       TmpInst.setOpcode(Mips::MULT);
     753             :       // Operand: rs
     754           0 :       lowerOperand(MI->getOperand(1), MCOp);
     755             :       TmpInst.addOperand(MCOp);
     756             :       // Operand: rt
     757           0 :       lowerOperand(MI->getOperand(2), MCOp);
     758             :       TmpInst.addOperand(MCOp);
     759           0 :       EmitToStreamer(OutStreamer, TmpInst);
     760             :       break;
     761             :     }
     762             :     case Mips::PseudoMULTu: {
     763             :       MCInst TmpInst;
     764             :       MCOperand MCOp;
     765             :       TmpInst.setOpcode(Mips::MULTu);
     766             :       // Operand: rs
     767           8 :       lowerOperand(MI->getOperand(1), MCOp);
     768             :       TmpInst.addOperand(MCOp);
     769             :       // Operand: rt
     770           8 :       lowerOperand(MI->getOperand(2), MCOp);
     771             :       TmpInst.addOperand(MCOp);
     772           8 :       EmitToStreamer(OutStreamer, TmpInst);
     773             :       break;
     774             :     }
     775             :     case Mips::PseudoMULTu_MM: {
     776             :       MCInst TmpInst;
     777             :       MCOperand MCOp;
     778             :       TmpInst.setOpcode(Mips::MULTu);
     779             :       // Operand: rs
     780           1 :       lowerOperand(MI->getOperand(1), MCOp);
     781             :       TmpInst.addOperand(MCOp);
     782             :       // Operand: rt
     783           1 :       lowerOperand(MI->getOperand(2), MCOp);
     784             :       TmpInst.addOperand(MCOp);
     785           1 :       EmitToStreamer(OutStreamer, TmpInst);
     786             :       break;
     787             :     }
     788             :     case Mips::PseudoPICK_PH: {
     789             :       MCInst TmpInst;
     790             :       MCOperand MCOp;
     791             :       TmpInst.setOpcode(Mips::PICK_PH);
     792             :       // Operand: rd
     793          14 :       lowerOperand(MI->getOperand(0), MCOp);
     794             :       TmpInst.addOperand(MCOp);
     795             :       // Operand: rs
     796          14 :       lowerOperand(MI->getOperand(2), MCOp);
     797             :       TmpInst.addOperand(MCOp);
     798             :       // Operand: rt
     799          14 :       lowerOperand(MI->getOperand(3), MCOp);
     800             :       TmpInst.addOperand(MCOp);
     801          14 :       EmitToStreamer(OutStreamer, TmpInst);
     802             :       break;
     803             :     }
     804             :     case Mips::PseudoPICK_QB: {
     805             :       MCInst TmpInst;
     806             :       MCOperand MCOp;
     807             :       TmpInst.setOpcode(Mips::PICK_QB);
     808             :       // Operand: rd
     809          12 :       lowerOperand(MI->getOperand(0), MCOp);
     810             :       TmpInst.addOperand(MCOp);
     811             :       // Operand: rs
     812          12 :       lowerOperand(MI->getOperand(2), MCOp);
     813             :       TmpInst.addOperand(MCOp);
     814             :       // Operand: rt
     815          12 :       lowerOperand(MI->getOperand(3), MCOp);
     816             :       TmpInst.addOperand(MCOp);
     817          12 :       EmitToStreamer(OutStreamer, TmpInst);
     818             :       break;
     819             :     }
     820             :     case Mips::PseudoSDIV: {
     821             :       MCInst TmpInst;
     822             :       MCOperand MCOp;
     823             :       TmpInst.setOpcode(Mips::SDIV);
     824             :       // Operand: rs
     825         124 :       lowerOperand(MI->getOperand(1), MCOp);
     826             :       TmpInst.addOperand(MCOp);
     827             :       // Operand: rt
     828         124 :       lowerOperand(MI->getOperand(2), MCOp);
     829             :       TmpInst.addOperand(MCOp);
     830         124 :       EmitToStreamer(OutStreamer, TmpInst);
     831             :       break;
     832             :     }
     833             :     case Mips::PseudoUDIV: {
     834             :       MCInst TmpInst;
     835             :       MCOperand MCOp;
     836             :       TmpInst.setOpcode(Mips::UDIV);
     837             :       // Operand: rs
     838         122 :       lowerOperand(MI->getOperand(1), MCOp);
     839             :       TmpInst.addOperand(MCOp);
     840             :       // Operand: rt
     841         122 :       lowerOperand(MI->getOperand(2), MCOp);
     842             :       TmpInst.addOperand(MCOp);
     843         122 :       EmitToStreamer(OutStreamer, TmpInst);
     844             :       break;
     845             :     }
     846             :     case Mips::SDIV_MM_Pseudo: {
     847             :       MCInst TmpInst;
     848             :       MCOperand MCOp;
     849             :       TmpInst.setOpcode(Mips::SDIV_MM);
     850             :       // Operand: rs
     851           8 :       lowerOperand(MI->getOperand(1), MCOp);
     852             :       TmpInst.addOperand(MCOp);
     853             :       // Operand: rt
     854           8 :       lowerOperand(MI->getOperand(2), MCOp);
     855             :       TmpInst.addOperand(MCOp);
     856           8 :       EmitToStreamer(OutStreamer, TmpInst);
     857             :       break;
     858             :     }
     859             :     case Mips::TAILCALL: {
     860             :       MCInst TmpInst;
     861             :       MCOperand MCOp;
     862             :       TmpInst.setOpcode(Mips::J);
     863             :       // Operand: target
     864          13 :       lowerOperand(MI->getOperand(0), MCOp);
     865             :       TmpInst.addOperand(MCOp);
     866          13 :       EmitToStreamer(OutStreamer, TmpInst);
     867             :       break;
     868             :     }
     869             :     case Mips::TAILCALL64R6REG: {
     870             :       MCInst TmpInst;
     871             :       MCOperand MCOp;
     872             :       TmpInst.setOpcode(Mips::JALR64);
     873             :       // Operand: rd
     874           1 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO_64));
     875             :       // Operand: rs
     876           1 :       lowerOperand(MI->getOperand(0), MCOp);
     877             :       TmpInst.addOperand(MCOp);
     878           1 :       EmitToStreamer(OutStreamer, TmpInst);
     879             :       break;
     880             :     }
     881             :     case Mips::TAILCALLHB64R6REG: {
     882             :       MCInst TmpInst;
     883             :       MCOperand MCOp;
     884             :       TmpInst.setOpcode(Mips::JR_HB64_R6);
     885             :       // Operand: rs
     886           2 :       lowerOperand(MI->getOperand(0), MCOp);
     887             :       TmpInst.addOperand(MCOp);
     888           2 :       EmitToStreamer(OutStreamer, TmpInst);
     889             :       break;
     890             :     }
     891             :     case Mips::TAILCALLHBR6REG: {
     892             :       MCInst TmpInst;
     893             :       MCOperand MCOp;
     894             :       TmpInst.setOpcode(Mips::JR_HB_R6);
     895             :       // Operand: rs
     896           2 :       lowerOperand(MI->getOperand(0), MCOp);
     897             :       TmpInst.addOperand(MCOp);
     898           2 :       EmitToStreamer(OutStreamer, TmpInst);
     899             :       break;
     900             :     }
     901             :     case Mips::TAILCALLR6REG: {
     902             :       MCInst TmpInst;
     903             :       MCOperand MCOp;
     904             :       TmpInst.setOpcode(Mips::JALR);
     905             :       // Operand: rd
     906           1 :       TmpInst.addOperand(MCOperand::createReg(Mips::ZERO));
     907             :       // Operand: rs
     908           1 :       lowerOperand(MI->getOperand(0), MCOp);
     909             :       TmpInst.addOperand(MCOp);
     910           1 :       EmitToStreamer(OutStreamer, TmpInst);
     911             :       break;
     912             :     }
     913             :     case Mips::TAILCALLREG: {
     914             :       MCInst TmpInst;
     915             :       MCOperand MCOp;
     916             :       TmpInst.setOpcode(Mips::JR);
     917             :       // Operand: rs
     918          48 :       lowerOperand(MI->getOperand(0), MCOp);
     919             :       TmpInst.addOperand(MCOp);
     920          48 :       EmitToStreamer(OutStreamer, TmpInst);
     921             :       break;
     922             :     }
     923             :     case Mips::TAILCALLREG64: {
     924             :       MCInst TmpInst;
     925             :       MCOperand MCOp;
     926             :       TmpInst.setOpcode(Mips::JR64);
     927             :       // Operand: rs
     928          49 :       lowerOperand(MI->getOperand(0), MCOp);
     929             :       TmpInst.addOperand(MCOp);
     930          49 :       EmitToStreamer(OutStreamer, TmpInst);
     931             :       break;
     932             :     }
     933             :     case Mips::TAILCALLREGHB: {
     934             :       MCInst TmpInst;
     935             :       MCOperand MCOp;
     936             :       TmpInst.setOpcode(Mips::JR_HB);
     937             :       // Operand: rs
     938           2 :       lowerOperand(MI->getOperand(0), MCOp);
     939             :       TmpInst.addOperand(MCOp);
     940           2 :       EmitToStreamer(OutStreamer, TmpInst);
     941             :       break;
     942             :     }
     943             :     case Mips::TAILCALLREGHB64: {
     944             :       MCInst TmpInst;
     945             :       MCOperand MCOp;
     946             :       TmpInst.setOpcode(Mips::JR_HB64);
     947             :       // Operand: rs
     948           2 :       lowerOperand(MI->getOperand(0), MCOp);
     949             :       TmpInst.addOperand(MCOp);
     950           2 :       EmitToStreamer(OutStreamer, TmpInst);
     951             :       break;
     952             :     }
     953             :     case Mips::TAILCALLREG_MM: {
     954             :       MCInst TmpInst;
     955             :       MCOperand MCOp;
     956             :       TmpInst.setOpcode(Mips::JRC16_MM);
     957             :       // Operand: rs
     958           4 :       lowerOperand(MI->getOperand(0), MCOp);
     959             :       TmpInst.addOperand(MCOp);
     960           4 :       EmitToStreamer(OutStreamer, TmpInst);
     961             :       break;
     962             :     }
     963             :     case Mips::TAILCALLREG_MMR6: {
     964             :       MCInst TmpInst;
     965             :       MCOperand MCOp;
     966             :       TmpInst.setOpcode(Mips::JRC16_MM);
     967             :       // Operand: rs
     968           3 :       lowerOperand(MI->getOperand(0), MCOp);
     969             :       TmpInst.addOperand(MCOp);
     970           3 :       EmitToStreamer(OutStreamer, TmpInst);
     971             :       break;
     972             :     }
     973             :     case Mips::TAILCALL_MM: {
     974             :       MCInst TmpInst;
     975             :       MCOperand MCOp;
     976             :       TmpInst.setOpcode(Mips::J_MM);
     977             :       // Operand: target
     978           4 :       lowerOperand(MI->getOperand(0), MCOp);
     979             :       TmpInst.addOperand(MCOp);
     980           4 :       EmitToStreamer(OutStreamer, TmpInst);
     981             :       break;
     982             :     }
     983             :     case Mips::TAILCALL_MMR6: {
     984             :       MCInst TmpInst;
     985             :       MCOperand MCOp;
     986             :       TmpInst.setOpcode(Mips::BC_MMR6);
     987             :       // Operand: offset
     988           3 :       lowerOperand(MI->getOperand(0), MCOp);
     989             :       TmpInst.addOperand(MCOp);
     990           3 :       EmitToStreamer(OutStreamer, TmpInst);
     991             :       break;
     992             :     }
     993             :     case Mips::TRAP: {
     994             :       MCInst TmpInst;
     995             :       MCOperand MCOp;
     996             :       TmpInst.setOpcode(Mips::BREAK);
     997             :       // Operand: code_1
     998           3 :       TmpInst.addOperand(MCOperand::createImm(0));
     999             :       // Operand: code_2
    1000           3 :       TmpInst.addOperand(MCOperand::createImm(0));
    1001           3 :       EmitToStreamer(OutStreamer, TmpInst);
    1002             :       break;
    1003             :     }
    1004             :     case Mips::TRAP_MM: {
    1005             :       MCInst TmpInst;
    1006             :       MCOperand MCOp;
    1007             :       TmpInst.setOpcode(Mips::BREAK_MM);
    1008             :       // Operand: code_1
    1009           2 :       TmpInst.addOperand(MCOperand::createImm(0));
    1010             :       // Operand: code_2
    1011           2 :       TmpInst.addOperand(MCOperand::createImm(0));
    1012           2 :       EmitToStreamer(OutStreamer, TmpInst);
    1013             :       break;
    1014             :     }
    1015             :     case Mips::UDIV_MM_Pseudo: {
    1016             :       MCInst TmpInst;
    1017             :       MCOperand MCOp;
    1018             :       TmpInst.setOpcode(Mips::UDIV_MM);
    1019             :       // Operand: rs
    1020           8 :       lowerOperand(MI->getOperand(1), MCOp);
    1021             :       TmpInst.addOperand(MCOp);
    1022             :       // Operand: rt
    1023           8 :       lowerOperand(MI->getOperand(2), MCOp);
    1024             :       TmpInst.addOperand(MCOp);
    1025           8 :       EmitToStreamer(OutStreamer, TmpInst);
    1026             :       break;
    1027             :     }
    1028             :     case Mips::XOR_V_D_PSEUDO: {
    1029             :       MCInst TmpInst;
    1030             :       MCOperand MCOp;
    1031             :       TmpInst.setOpcode(Mips::XOR_V);
    1032             :       // Operand: wd
    1033          12 :       lowerOperand(MI->getOperand(0), MCOp);
    1034             :       TmpInst.addOperand(MCOp);
    1035             :       // Operand: ws
    1036          12 :       lowerOperand(MI->getOperand(1), MCOp);
    1037             :       TmpInst.addOperand(MCOp);
    1038             :       // Operand: wt
    1039          12 :       lowerOperand(MI->getOperand(2), MCOp);
    1040             :       TmpInst.addOperand(MCOp);
    1041          12 :       EmitToStreamer(OutStreamer, TmpInst);
    1042             :       break;
    1043             :     }
    1044             :     case Mips::XOR_V_H_PSEUDO: {
    1045             :       MCInst TmpInst;
    1046             :       MCOperand MCOp;
    1047             :       TmpInst.setOpcode(Mips::XOR_V);
    1048             :       // Operand: wd
    1049           8 :       lowerOperand(MI->getOperand(0), MCOp);
    1050             :       TmpInst.addOperand(MCOp);
    1051             :       // Operand: ws
    1052           8 :       lowerOperand(MI->getOperand(1), MCOp);
    1053             :       TmpInst.addOperand(MCOp);
    1054             :       // Operand: wt
    1055           8 :       lowerOperand(MI->getOperand(2), MCOp);
    1056             :       TmpInst.addOperand(MCOp);
    1057           8 :       EmitToStreamer(OutStreamer, TmpInst);
    1058             :       break;
    1059             :     }
    1060             :     case Mips::XOR_V_W_PSEUDO: {
    1061             :       MCInst TmpInst;
    1062             :       MCOperand MCOp;
    1063             :       TmpInst.setOpcode(Mips::XOR_V);
    1064             :       // Operand: wd
    1065           8 :       lowerOperand(MI->getOperand(0), MCOp);
    1066             :       TmpInst.addOperand(MCOp);
    1067             :       // Operand: ws
    1068           8 :       lowerOperand(MI->getOperand(1), MCOp);
    1069             :       TmpInst.addOperand(MCOp);
    1070             :       // Operand: wt
    1071           8 :       lowerOperand(MI->getOperand(2), MCOp);
    1072             :       TmpInst.addOperand(MCOp);
    1073           8 :       EmitToStreamer(OutStreamer, TmpInst);
    1074             :       break;
    1075             :     }
    1076             :   }
    1077             :   return true;
    1078             : }
    1079             : 

Generated by: LCOV version 1.13