lib/Target/ARM/ARMExpandPseudoInsts.cpp

   1 //===-- ARMExpandPseudoInsts.cpp - Expand pseudo instructions -----*- C++ -*-=//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains a pass that expand pseudo instructions into target
  11 // instructions to allow proper scheduling, if-conversion, and other late
  12 // optimizations. This pass should be run after register allocation but before
  13 // post- regalloc scheduling pass.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #define DEBUG_TYPE "arm-pseudo"
  18 #include "ARM.h"
  19 #include "ARMBaseInstrInfo.h"
  20 #include "llvm/CodeGen/MachineFunctionPass.h"
  21 #include "llvm/CodeGen/MachineInstrBuilder.h"
  22 #include "llvm/Target/TargetRegisterInfo.h"
  23 using namespace llvm;
  24
  25 namespace {
  26   class ARMExpandPseudo : public MachineFunctionPass {
  27     // Constants for register spacing in NEON load/store instructions.
  28     enum NEONRegSpacing {
  29       SingleSpc,
  30       EvenDblSpc,
  31       OddDblSpc
  32     };
  33
  34   public:
  35     static char ID;
  36     ARMExpandPseudo() : MachineFunctionPass(ID) {}
  37
  38     const TargetInstrInfo *TII;
  39     const TargetRegisterInfo *TRI;
  40
  41     virtual bool runOnMachineFunction(MachineFunction &Fn);
  42
  43     virtual const char *getPassName() const {
  44       return "ARM pseudo instruction expansion pass";
  45     }
  46
  47   private:
  48     void TransferImpOps(MachineInstr &OldMI,
  49                         MachineInstrBuilder &UseMI, MachineInstrBuilder &DefMI);
  50     bool ExpandMBB(MachineBasicBlock &MBB);
  51     void ExpandVLD(MachineBasicBlock::iterator &MBBI, unsigned Opc,
  52                    bool hasWriteBack, NEONRegSpacing RegSpc, unsigned NumRegs);
  53     void ExpandVST(MachineBasicBlock::iterator &MBBI, unsigned Opc,
  54                    bool hasWriteBack, NEONRegSpacing RegSpc, unsigned NumRegs);
  55   };
  56   char ARMExpandPseudo::ID = 0;
  57 }
  58
  59 /// TransferImpOps - Transfer implicit operands on the pseudo instruction to
  60 /// the instructions created from the expansion.
  61 void ARMExpandPseudo::TransferImpOps(MachineInstr &OldMI,
  62                                      MachineInstrBuilder &UseMI,
  63                                      MachineInstrBuilder &DefMI) {
  64   const TargetInstrDesc &Desc = OldMI.getDesc();
  65   for (unsigned i = Desc.getNumOperands(), e = OldMI.getNumOperands();
  66        i != e; ++i) {
  67     const MachineOperand &MO = OldMI.getOperand(i);
  68     assert(MO.isReg() && MO.getReg());
  69     if (MO.isUse())
  70       UseMI.addReg(MO.getReg(), getKillRegState(MO.isKill()));
  71     else
  72       DefMI.addReg(MO.getReg(),
  73                    getDefRegState(true) | getDeadRegState(MO.isDead()));
  74   }
  75 }
  76
  77 /// ExpandVLD - Translate VLD pseudo instructions with Q, QQ or QQQQ register
  78 /// operands to real VLD instructions with D register operands.
  79 void ARMExpandPseudo::ExpandVLD(MachineBasicBlock::iterator &MBBI,
  80                                 unsigned Opc, bool hasWriteBack,
  81                                 NEONRegSpacing RegSpc, unsigned NumRegs) {
  82   MachineInstr &MI = *MBBI;
  83   MachineBasicBlock &MBB = *MI.getParent();
  84
  85   MachineInstrBuilder MIB = BuildMI(MBB, MBBI, MI.getDebugLoc(), TII->get(Opc));
  86   unsigned OpIdx = 0;
  87
  88   bool DstIsDead = MI.getOperand(OpIdx).isDead();
  89   unsigned DstReg = MI.getOperand(OpIdx++).getReg();
  90   unsigned D0, D1, D2, D3;
  91   if (RegSpc == SingleSpc) {
  92     D0 = TRI->getSubReg(DstReg, ARM::dsub_0);
  93     D1 = TRI->getSubReg(DstReg, ARM::dsub_1);
  94     D2 = TRI->getSubReg(DstReg, ARM::dsub_2);
  95     D3 = TRI->getSubReg(DstReg, ARM::dsub_3);
  96   } else if (RegSpc == EvenDblSpc) {
  97     D0 = TRI->getSubReg(DstReg, ARM::dsub_0);
  98     D1 = TRI->getSubReg(DstReg, ARM::dsub_2);
  99     D2 = TRI->getSubReg(DstReg, ARM::dsub_4);
 100     D3 = TRI->getSubReg(DstReg, ARM::dsub_6);
 101   } else {
 102     assert(RegSpc == OddDblSpc && "unknown register spacing for VLD");
 103     D0 = TRI->getSubReg(DstReg, ARM::dsub_1);
 104     D1 = TRI->getSubReg(DstReg, ARM::dsub_3);
 105     D2 = TRI->getSubReg(DstReg, ARM::dsub_5);
 106     D3 = TRI->getSubReg(DstReg, ARM::dsub_7);
 107   }
 108   MIB.addReg(D0, RegState::Define | getDeadRegState(DstIsDead))
 109     .addReg(D1, RegState::Define | getDeadRegState(DstIsDead));
 110   if (NumRegs > 2)
 111     MIB.addReg(D2, RegState::Define | getDeadRegState(DstIsDead));
 112   if (NumRegs > 3)
 113     MIB.addReg(D3, RegState::Define | getDeadRegState(DstIsDead));
 114
 115   if (hasWriteBack) {
 116     bool WBIsDead = MI.getOperand(OpIdx).isDead();
 117     unsigned WBReg = MI.getOperand(OpIdx++).getReg();
 118     MIB.addReg(WBReg, RegState::Define | getDeadRegState(WBIsDead));
 119   }
 120   // Copy the addrmode6 operands.
 121   bool AddrIsKill = MI.getOperand(OpIdx).isKill();
 122   MIB.addReg(MI.getOperand(OpIdx++).getReg(), getKillRegState(AddrIsKill));
 123   MIB.addImm(MI.getOperand(OpIdx++).getImm());
 124   if (hasWriteBack) {
 125     // Copy the am6offset operand.
 126     bool OffsetIsKill = MI.getOperand(OpIdx).isKill();
 127     MIB.addReg(MI.getOperand(OpIdx++).getReg(), getKillRegState(OffsetIsKill));
 128   }
 129
 130   MIB = AddDefaultPred(MIB);
 131   TransferImpOps(MI, MIB, MIB);
 132   // For an instruction writing the odd subregs, add an implicit use of the
 133   // super-register because the even subregs were loaded separately.
 134   if (RegSpc == OddDblSpc)
 135     MIB.addReg(DstReg, RegState::Implicit);
 136   // Add an implicit def for the super-register.
 137   MIB.addReg(DstReg, RegState::ImplicitDefine | getDeadRegState(DstIsDead));
 138   MI.eraseFromParent();
 139 }
 140
 141 /// ExpandVST - Translate VST pseudo instructions with Q, QQ or QQQQ register
 142 /// operands to real VST instructions with D register operands.
 143 void ARMExpandPseudo::ExpandVST(MachineBasicBlock::iterator &MBBI,
 144                                 unsigned Opc, bool hasWriteBack,
 145                                 NEONRegSpacing RegSpc, unsigned NumRegs) {
 146   MachineInstr &MI = *MBBI;
 147   MachineBasicBlock &MBB = *MI.getParent();
 148
 149   MachineInstrBuilder MIB = BuildMI(MBB, MBBI, MI.getDebugLoc(), TII->get(Opc));
 150   unsigned OpIdx = 0;
 151   if (hasWriteBack) {
 152     bool DstIsDead = MI.getOperand(OpIdx).isDead();
 153     unsigned DstReg = MI.getOperand(OpIdx++).getReg();
 154     MIB.addReg(DstReg, RegState::Define | getDeadRegState(DstIsDead));
 155   }
 156   // Copy the addrmode6 operands.
 157   bool AddrIsKill = MI.getOperand(OpIdx).isKill();
 158   MIB.addReg(MI.getOperand(OpIdx++).getReg(), getKillRegState(AddrIsKill));
 159   MIB.addImm(MI.getOperand(OpIdx++).getImm());
 160   if (hasWriteBack) {
 161     // Copy the am6offset operand.
 162     bool OffsetIsKill = MI.getOperand(OpIdx).isKill();
 163     MIB.addReg(MI.getOperand(OpIdx++).getReg(), getKillRegState(OffsetIsKill));
 164   }
 165
 166   bool SrcIsKill = MI.getOperand(OpIdx).isKill();
 167   unsigned SrcReg = MI.getOperand(OpIdx).getReg();
 168   unsigned D0, D1, D2, D3;
 169   if (RegSpc == SingleSpc) {
 170     D0 = TRI->getSubReg(SrcReg, ARM::dsub_0);
 171     D1 = TRI->getSubReg(SrcReg, ARM::dsub_1);
 172     D2 = TRI->getSubReg(SrcReg, ARM::dsub_2);
 173     D3 = TRI->getSubReg(SrcReg, ARM::dsub_3);
 174   } else if (RegSpc == EvenDblSpc) {
 175     D0 = TRI->getSubReg(SrcReg, ARM::dsub_0);
 176     D1 = TRI->getSubReg(SrcReg, ARM::dsub_2);
 177     D2 = TRI->getSubReg(SrcReg, ARM::dsub_4);
 178     D3 = TRI->getSubReg(SrcReg, ARM::dsub_6);
 179   } else {
 180     assert(RegSpc == OddDblSpc && "unknown register spacing for VST");
 181     D0 = TRI->getSubReg(SrcReg, ARM::dsub_1);
 182     D1 = TRI->getSubReg(SrcReg, ARM::dsub_3);
 183     D2 = TRI->getSubReg(SrcReg, ARM::dsub_5);
 184     D3 = TRI->getSubReg(SrcReg, ARM::dsub_7);
 185   }
 186
 187   MIB.addReg(D0).addReg(D1);
 188   if (NumRegs > 2)
 189     MIB.addReg(D2);
 190   if (NumRegs > 3)
 191     MIB.addReg(D3);
 192   MIB = AddDefaultPred(MIB);
 193   TransferImpOps(MI, MIB, MIB);
 194   if (SrcIsKill)
 195     // Add an implicit kill for the super-reg.
 196     (*MIB).addRegisterKilled(SrcReg, TRI, true);
 197   MI.eraseFromParent();
 198 }
 199
 200 bool ARMExpandPseudo::ExpandMBB(MachineBasicBlock &MBB) {
 201   bool Modified = false;
 202
 203   MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
 204   while (MBBI != E) {
 205     MachineInstr &MI = *MBBI;
 206     MachineBasicBlock::iterator NMBBI = llvm::next(MBBI);
 207
 208     bool ModifiedOp = true;
 209     unsigned Opcode = MI.getOpcode();
 210     switch (Opcode) {
 211     default:
 212       ModifiedOp = false;
 213       break;
 214
 215     case ARM::tLDRpci_pic:
 216     case ARM::t2LDRpci_pic: {
 217       unsigned NewLdOpc = (Opcode == ARM::tLDRpci_pic)
 218         ? ARM::tLDRpci : ARM::t2LDRpci;
 219       unsigned DstReg = MI.getOperand(0).getReg();
 220       bool DstIsDead = MI.getOperand(0).isDead();
 221       MachineInstrBuilder MIB1 =
 222         AddDefaultPred(BuildMI(MBB, MBBI, MI.getDebugLoc(),
 223                                TII->get(NewLdOpc), DstReg)
 224                        .addOperand(MI.getOperand(1)));
 225       (*MIB1).setMemRefs(MI.memoperands_begin(), MI.memoperands_end());
 226       MachineInstrBuilder MIB2 = BuildMI(MBB, MBBI, MI.getDebugLoc(),
 227                                          TII->get(ARM::tPICADD))
 228         .addReg(DstReg, getDefRegState(true) | getDeadRegState(DstIsDead))
 229         .addReg(DstReg)
 230         .addOperand(MI.getOperand(2));
 231       TransferImpOps(MI, MIB1, MIB2);
 232       MI.eraseFromParent();
 233       break;
 234     }
 235
 236     case ARM::MOVi32imm:
 237     case ARM::t2MOVi32imm: {
 238       unsigned PredReg = 0;
 239       ARMCC::CondCodes Pred = llvm::getInstrPredicate(&MI, PredReg);
 240       unsigned DstReg = MI.getOperand(0).getReg();
 241       bool DstIsDead = MI.getOperand(0).isDead();
 242       const MachineOperand &MO = MI.getOperand(1);
 243       MachineInstrBuilder LO16, HI16;
 244
 245       LO16 = BuildMI(MBB, MBBI, MI.getDebugLoc(),
 246                      TII->get(Opcode == ARM::MOVi32imm ?
 247                               ARM::MOVi16 : ARM::t2MOVi16),
 248                      DstReg);
 249       HI16 = BuildMI(MBB, MBBI, MI.getDebugLoc(),
 250                      TII->get(Opcode == ARM::MOVi32imm ?
 251                               ARM::MOVTi16 : ARM::t2MOVTi16))
 252         .addReg(DstReg, getDefRegState(true) | getDeadRegState(DstIsDead))
 253         .addReg(DstReg);
 254
 255       if (MO.isImm()) {
 256         unsigned Imm = MO.getImm();
 257         unsigned Lo16 = Imm & 0xffff;
 258         unsigned Hi16 = (Imm >> 16) & 0xffff;
 259         LO16 = LO16.addImm(Lo16);
 260         HI16 = HI16.addImm(Hi16);
 261       } else {
 262         const GlobalValue *GV = MO.getGlobal();
 263         unsigned TF = MO.getTargetFlags();
 264         LO16 = LO16.addGlobalAddress(GV, MO.getOffset(), TF | ARMII::MO_LO16);
 265         HI16 = HI16.addGlobalAddress(GV, MO.getOffset(), TF | ARMII::MO_HI16);
 266       }
 267       (*LO16).setMemRefs(MI.memoperands_begin(), MI.memoperands_end());
 268       (*HI16).setMemRefs(MI.memoperands_begin(), MI.memoperands_end());
 269       LO16.addImm(Pred).addReg(PredReg);
 270       HI16.addImm(Pred).addReg(PredReg);
 271       TransferImpOps(MI, LO16, HI16);
 272       MI.eraseFromParent();
 273       break;
 274     }
 275
 276     case ARM::VMOVQQ: {
 277       unsigned DstReg = MI.getOperand(0).getReg();
 278       bool DstIsDead = MI.getOperand(0).isDead();
 279       unsigned EvenDst = TRI->getSubReg(DstReg, ARM::qsub_0);
 280       unsigned OddDst  = TRI->getSubReg(DstReg, ARM::qsub_1);
 281       unsigned SrcReg = MI.getOperand(1).getReg();
 282       bool SrcIsKill = MI.getOperand(1).isKill();
 283       unsigned EvenSrc = TRI->getSubReg(SrcReg, ARM::qsub_0);
 284       unsigned OddSrc  = TRI->getSubReg(SrcReg, ARM::qsub_1);
 285       MachineInstrBuilder Even =
 286         AddDefaultPred(BuildMI(MBB, MBBI, MI.getDebugLoc(),
 287                                TII->get(ARM::VMOVQ))
 288                      .addReg(EvenDst,
 289                              getDefRegState(true) | getDeadRegState(DstIsDead))
 290                      .addReg(EvenSrc, getKillRegState(SrcIsKill)));
 291       MachineInstrBuilder Odd =
 292         AddDefaultPred(BuildMI(MBB, MBBI, MI.getDebugLoc(),
 293                                TII->get(ARM::VMOVQ))
 294                      .addReg(OddDst,
 295                              getDefRegState(true) | getDeadRegState(DstIsDead))
 296                      .addReg(OddSrc, getKillRegState(SrcIsKill)));
 297       TransferImpOps(MI, Even, Odd);
 298       MI.eraseFromParent();
 299     }
 300
 301     case ARM::VLD1q8Pseudo:
 302       ExpandVLD(MBBI, ARM::VLD1q8, false, SingleSpc, 2); break;
 303     case ARM::VLD1q16Pseudo:
 304       ExpandVLD(MBBI, ARM::VLD1q16, false, SingleSpc, 2); break;
 305     case ARM::VLD1q32Pseudo:
 306       ExpandVLD(MBBI, ARM::VLD1q32, false, SingleSpc, 2); break;
 307     case ARM::VLD1q64Pseudo:
 308       ExpandVLD(MBBI, ARM::VLD1q64, false, SingleSpc, 2); break;
 309     case ARM::VLD1q8Pseudo_UPD:
 310       ExpandVLD(MBBI, ARM::VLD1q8, true, SingleSpc, 2); break;
 311     case ARM::VLD1q16Pseudo_UPD:
 312       ExpandVLD(MBBI, ARM::VLD1q16, true, SingleSpc, 2); break;
 313     case ARM::VLD1q32Pseudo_UPD:
 314       ExpandVLD(MBBI, ARM::VLD1q32, true, SingleSpc, 2); break;
 315     case ARM::VLD1q64Pseudo_UPD:
 316       ExpandVLD(MBBI, ARM::VLD1q64, true, SingleSpc, 2); break;
 317
 318     case ARM::VLD2d8Pseudo:
 319       ExpandVLD(MBBI, ARM::VLD2d8, false, SingleSpc, 2); break;
 320     case ARM::VLD2d16Pseudo:
 321       ExpandVLD(MBBI, ARM::VLD2d16, false, SingleSpc, 2); break;
 322     case ARM::VLD2d32Pseudo:
 323       ExpandVLD(MBBI, ARM::VLD2d32, false, SingleSpc, 2); break;
 324     case ARM::VLD2q8Pseudo:
 325       ExpandVLD(MBBI, ARM::VLD2q8, false, SingleSpc, 4); break;
 326     case ARM::VLD2q16Pseudo:
 327       ExpandVLD(MBBI, ARM::VLD2q16, false, SingleSpc, 4); break;
 328     case ARM::VLD2q32Pseudo:
 329       ExpandVLD(MBBI, ARM::VLD2q32, false, SingleSpc, 4); break;
 330     case ARM::VLD2d8Pseudo_UPD:
 331       ExpandVLD(MBBI, ARM::VLD2d8, true, SingleSpc, 2); break;
 332     case ARM::VLD2d16Pseudo_UPD:
 333       ExpandVLD(MBBI, ARM::VLD2d16, true, SingleSpc, 2); break;
 334     case ARM::VLD2d32Pseudo_UPD:
 335       ExpandVLD(MBBI, ARM::VLD2d32, true, SingleSpc, 2); break;
 336     case ARM::VLD2q8Pseudo_UPD:
 337       ExpandVLD(MBBI, ARM::VLD2q8, true, SingleSpc, 4); break;
 338     case ARM::VLD2q16Pseudo_UPD:
 339       ExpandVLD(MBBI, ARM::VLD2q16, true, SingleSpc, 4); break;
 340     case ARM::VLD2q32Pseudo_UPD:
 341       ExpandVLD(MBBI, ARM::VLD2q32, true, SingleSpc, 4); break;
 342
 343     case ARM::VLD3d8Pseudo:
 344       ExpandVLD(MBBI, ARM::VLD3d8, false, SingleSpc, 3); break;
 345     case ARM::VLD3d16Pseudo:
 346       ExpandVLD(MBBI, ARM::VLD3d16, false, SingleSpc, 3); break;
 347     case ARM::VLD3d32Pseudo:
 348       ExpandVLD(MBBI, ARM::VLD3d32, false, SingleSpc, 3); break;
 349     case ARM::VLD1d64TPseudo:
 350       ExpandVLD(MBBI, ARM::VLD1d64T, false, SingleSpc, 3); break;
 351     case ARM::VLD3d8Pseudo_UPD:
 352       ExpandVLD(MBBI, ARM::VLD3d8_UPD, true, SingleSpc, 3); break;
 353     case ARM::VLD3d16Pseudo_UPD:
 354       ExpandVLD(MBBI, ARM::VLD3d16_UPD, true, SingleSpc, 3); break;
 355     case ARM::VLD3d32Pseudo_UPD:
 356       ExpandVLD(MBBI, ARM::VLD3d32_UPD, true, SingleSpc, 3); break;
 357     case ARM::VLD1d64TPseudo_UPD:
 358       ExpandVLD(MBBI, ARM::VLD1d64T_UPD, true, SingleSpc, 3); break;
 359     case ARM::VLD3q8Pseudo_UPD:
 360       ExpandVLD(MBBI, ARM::VLD3q8_UPD, true, EvenDblSpc, 3); break;
 361     case ARM::VLD3q16Pseudo_UPD:
 362       ExpandVLD(MBBI, ARM::VLD3q16_UPD, true, EvenDblSpc, 3); break;
 363     case ARM::VLD3q32Pseudo_UPD:
 364       ExpandVLD(MBBI, ARM::VLD3q32_UPD, true, EvenDblSpc, 3); break;
 365     case ARM::VLD3q8oddPseudo_UPD:
 366       ExpandVLD(MBBI, ARM::VLD3q8_UPD, true, OddDblSpc, 3); break;
 367     case ARM::VLD3q16oddPseudo_UPD:
 368       ExpandVLD(MBBI, ARM::VLD3q16_UPD, true, OddDblSpc, 3); break;
 369     case ARM::VLD3q32oddPseudo_UPD:
 370       ExpandVLD(MBBI, ARM::VLD3q32_UPD, true, OddDblSpc, 3); break;
 371
 372     case ARM::VLD4d8Pseudo:
 373       ExpandVLD(MBBI, ARM::VLD4d8, false, SingleSpc, 4); break;
 374     case ARM::VLD4d16Pseudo:
 375       ExpandVLD(MBBI, ARM::VLD4d16, false, SingleSpc, 4); break;
 376     case ARM::VLD4d32Pseudo:
 377       ExpandVLD(MBBI, ARM::VLD4d32, false, SingleSpc, 4); break;
 378     case ARM::VLD1d64QPseudo:
 379       ExpandVLD(MBBI, ARM::VLD1d64Q, false, SingleSpc, 4); break;
 380     case ARM::VLD4d8Pseudo_UPD:
 381       ExpandVLD(MBBI, ARM::VLD4d8_UPD, true, SingleSpc, 4); break;
 382     case ARM::VLD4d16Pseudo_UPD:
 383       ExpandVLD(MBBI, ARM::VLD4d16_UPD, true, SingleSpc, 4); break;
 384     case ARM::VLD4d32Pseudo_UPD:
 385       ExpandVLD(MBBI, ARM::VLD4d32_UPD, true, SingleSpc, 4); break;
 386     case ARM::VLD1d64QPseudo_UPD:
 387       ExpandVLD(MBBI, ARM::VLD1d64Q_UPD, true, SingleSpc, 4); break;
 388     case ARM::VLD4q8Pseudo_UPD:
 389       ExpandVLD(MBBI, ARM::VLD4q8_UPD, true, EvenDblSpc, 4); break;
 390     case ARM::VLD4q16Pseudo_UPD:
 391       ExpandVLD(MBBI, ARM::VLD4q16_UPD, true, EvenDblSpc, 4); break;
 392     case ARM::VLD4q32Pseudo_UPD:
 393       ExpandVLD(MBBI, ARM::VLD4q32_UPD, true, EvenDblSpc, 4); break;
 394     case ARM::VLD4q8oddPseudo_UPD:
 395       ExpandVLD(MBBI, ARM::VLD4q8_UPD, true, OddDblSpc, 4); break;
 396     case ARM::VLD4q16oddPseudo_UPD:
 397       ExpandVLD(MBBI, ARM::VLD4q16_UPD, true, OddDblSpc, 4); break;
 398     case ARM::VLD4q32oddPseudo_UPD:
 399       ExpandVLD(MBBI, ARM::VLD4q32_UPD, true, OddDblSpc, 4); break;
 400
 401     case ARM::VST1q8Pseudo:
 402       ExpandVST(MBBI, ARM::VST1q8, false, SingleSpc, 2); break;
 403     case ARM::VST1q16Pseudo:
 404       ExpandVST(MBBI, ARM::VST1q16, false, SingleSpc, 2); break;
 405     case ARM::VST1q32Pseudo:
 406       ExpandVST(MBBI, ARM::VST1q32, false, SingleSpc, 2); break;
 407     case ARM::VST1q64Pseudo:
 408       ExpandVST(MBBI, ARM::VST1q64, false, SingleSpc, 2); break;
 409     case ARM::VST1q8Pseudo_UPD:
 410       ExpandVST(MBBI, ARM::VST1q8_UPD, true, SingleSpc, 2); break;
 411     case ARM::VST1q16Pseudo_UPD:
 412       ExpandVST(MBBI, ARM::VST1q16_UPD, true, SingleSpc, 2); break;
 413     case ARM::VST1q32Pseudo_UPD:
 414       ExpandVST(MBBI, ARM::VST1q32_UPD, true, SingleSpc, 2); break;
 415     case ARM::VST1q64Pseudo_UPD:
 416       ExpandVST(MBBI, ARM::VST1q64_UPD, true, SingleSpc, 2); break;
 417
 418     case ARM::VST2d8Pseudo:
 419       ExpandVST(MBBI, ARM::VST2d8, false, SingleSpc, 2); break;
 420     case ARM::VST2d16Pseudo:
 421       ExpandVST(MBBI, ARM::VST2d16, false, SingleSpc, 2); break;
 422     case ARM::VST2d32Pseudo:
 423       ExpandVST(MBBI, ARM::VST2d32, false, SingleSpc, 2); break;
 424     case ARM::VST2q8Pseudo:
 425       ExpandVST(MBBI, ARM::VST2q8, false, SingleSpc, 4); break;
 426     case ARM::VST2q16Pseudo:
 427       ExpandVST(MBBI, ARM::VST2q16, false, SingleSpc, 4); break;
 428     case ARM::VST2q32Pseudo:
 429       ExpandVST(MBBI, ARM::VST2q32, false, SingleSpc, 4); break;
 430     case ARM::VST2d8Pseudo_UPD:
 431       ExpandVST(MBBI, ARM::VST2d8_UPD, true, SingleSpc, 2); break;
 432     case ARM::VST2d16Pseudo_UPD:
 433       ExpandVST(MBBI, ARM::VST2d16_UPD, true, SingleSpc, 2); break;
 434     case ARM::VST2d32Pseudo_UPD:
 435       ExpandVST(MBBI, ARM::VST2d32_UPD, true, SingleSpc, 2); break;
 436     case ARM::VST2q8Pseudo_UPD:
 437       ExpandVST(MBBI, ARM::VST2q8_UPD, true, SingleSpc, 4); break;
 438     case ARM::VST2q16Pseudo_UPD:
 439       ExpandVST(MBBI, ARM::VST2q16_UPD, true, SingleSpc, 4); break;
 440     case ARM::VST2q32Pseudo_UPD:
 441       ExpandVST(MBBI, ARM::VST2q32_UPD, true, SingleSpc, 4); break;
 442
 443     case ARM::VST3d8Pseudo:
 444       ExpandVST(MBBI, ARM::VST3d8, false, SingleSpc, 3); break;
 445     case ARM::VST3d16Pseudo:
 446       ExpandVST(MBBI, ARM::VST3d16, false, SingleSpc, 3); break;
 447     case ARM::VST3d32Pseudo:
 448       ExpandVST(MBBI, ARM::VST3d32, false, SingleSpc, 3); break;
 449     case ARM::VST1d64TPseudo:
 450       ExpandVST(MBBI, ARM::VST1d64T, false, SingleSpc, 3); break;
 451     case ARM::VST3d8Pseudo_UPD:
 452       ExpandVST(MBBI, ARM::VST3d8_UPD, true, SingleSpc, 3); break;
 453     case ARM::VST3d16Pseudo_UPD:
 454       ExpandVST(MBBI, ARM::VST3d16_UPD, true, SingleSpc, 3); break;
 455     case ARM::VST3d32Pseudo_UPD:
 456       ExpandVST(MBBI, ARM::VST3d32_UPD, true, SingleSpc, 3); break;
 457     case ARM::VST1d64TPseudo_UPD:
 458       ExpandVST(MBBI, ARM::VST1d64T_UPD, true, SingleSpc, 3); break;
 459     case ARM::VST3q8Pseudo_UPD:
 460       ExpandVST(MBBI, ARM::VST3q8_UPD, true, EvenDblSpc, 3); break;
 461     case ARM::VST3q16Pseudo_UPD:
 462       ExpandVST(MBBI, ARM::VST3q16_UPD, true, EvenDblSpc, 3); break;
 463     case ARM::VST3q32Pseudo_UPD:
 464       ExpandVST(MBBI, ARM::VST3q32_UPD, true, EvenDblSpc, 3); break;
 465     case ARM::VST3q8oddPseudo_UPD:
 466       ExpandVST(MBBI, ARM::VST3q8_UPD, true, OddDblSpc, 3); break;
 467     case ARM::VST3q16oddPseudo_UPD:
 468       ExpandVST(MBBI, ARM::VST3q16_UPD, true, OddDblSpc, 3); break;
 469     case ARM::VST3q32oddPseudo_UPD:
 470       ExpandVST(MBBI, ARM::VST3q32_UPD, true, OddDblSpc, 3); break;
 471
 472     case ARM::VST4d8Pseudo:
 473       ExpandVST(MBBI, ARM::VST4d8, false, SingleSpc, 4); break;
 474     case ARM::VST4d16Pseudo:
 475       ExpandVST(MBBI, ARM::VST4d16, false, SingleSpc, 4); break;
 476     case ARM::VST4d32Pseudo:
 477       ExpandVST(MBBI, ARM::VST4d32, false, SingleSpc, 4); break;
 478     case ARM::VST1d64QPseudo:
 479       ExpandVST(MBBI, ARM::VST1d64Q, false, SingleSpc, 4); break;
 480     case ARM::VST4d8Pseudo_UPD:
 481       ExpandVST(MBBI, ARM::VST4d8_UPD, true, SingleSpc, 4); break;
 482     case ARM::VST4d16Pseudo_UPD:
 483       ExpandVST(MBBI, ARM::VST4d16_UPD, true, SingleSpc, 4); break;
 484     case ARM::VST4d32Pseudo_UPD:
 485       ExpandVST(MBBI, ARM::VST4d32_UPD, true, SingleSpc, 4); break;
 486     case ARM::VST1d64QPseudo_UPD:
 487       ExpandVST(MBBI, ARM::VST1d64Q_UPD, true, SingleSpc, 4); break;
 488     case ARM::VST4q8Pseudo_UPD:
 489       ExpandVST(MBBI, ARM::VST4q8_UPD, true, EvenDblSpc, 4); break;
 490     case ARM::VST4q16Pseudo_UPD:
 491       ExpandVST(MBBI, ARM::VST4q16_UPD, true, EvenDblSpc, 4); break;
 492     case ARM::VST4q32Pseudo_UPD:
 493       ExpandVST(MBBI, ARM::VST4q32_UPD, true, EvenDblSpc, 4); break;
 494     case ARM::VST4q8oddPseudo_UPD:
 495       ExpandVST(MBBI, ARM::VST4q8_UPD, true, OddDblSpc, 4); break;
 496     case ARM::VST4q16oddPseudo_UPD:
 497       ExpandVST(MBBI, ARM::VST4q16_UPD, true, OddDblSpc, 4); break;
 498     case ARM::VST4q32oddPseudo_UPD:
 499       ExpandVST(MBBI, ARM::VST4q32_UPD, true, OddDblSpc, 4); break;
 500     }
 501
 502     if (ModifiedOp)
 503       Modified = true;
 504     MBBI = NMBBI;
 505   }
 506
 507   return Modified;
 508 }
 509
 510 bool ARMExpandPseudo::runOnMachineFunction(MachineFunction &MF) {
 511   TII = MF.getTarget().getInstrInfo();
 512   TRI = MF.getTarget().getRegisterInfo();
 513
 514   bool Modified = false;
 515   for (MachineFunction::iterator MFI = MF.begin(), E = MF.end(); MFI != E;
 516        ++MFI)
 517     Modified |= ExpandMBB(*MFI);
 518   return Modified;
 519 }
 520
 521 /// createARMExpandPseudoPass - returns an instance of the pseudo instruction
 522 /// expansion pass.
 523 FunctionPass *llvm::createARMExpandPseudoPass() {
 524   return new ARMExpandPseudo();
 525 }