LLVM API Documentation

NEONPreAllocPass.cpp

Go to the documentation of this file.
00001 //===-- NEONPreAllocPass.cpp - Allocate adjacent NEON registers--*- C++ -*-===//
00002 //
00003 //                     The LLVM Compiler Infrastructure
00004 //
00005 // This file is distributed under the University of Illinois Open Source
00006 // License. See LICENSE.TXT for details.
00007 //
00008 //===----------------------------------------------------------------------===//
00009 
00010 #define DEBUG_TYPE "neon-prealloc"
00011 #include "ARM.h"
00012 #include "ARMInstrInfo.h"
00013 #include "llvm/CodeGen/MachineInstr.h"
00014 #include "llvm/CodeGen/MachineInstrBuilder.h"
00015 #include "llvm/CodeGen/MachineFunctionPass.h"
00016 using namespace llvm;
00017 
00018 namespace {
00019   class VISIBILITY_HIDDEN NEONPreAllocPass : public MachineFunctionPass {
00020     const TargetInstrInfo *TII;
00021 
00022   public:
00023     static char ID;
00024     NEONPreAllocPass() : MachineFunctionPass(&ID) {}
00025 
00026     virtual bool runOnMachineFunction(MachineFunction &MF);
00027 
00028     virtual const char *getPassName() const {
00029       return "NEON register pre-allocation pass";
00030     }
00031 
00032   private:
00033     bool PreAllocNEONRegisters(MachineBasicBlock &MBB);
00034   };
00035 
00036   char NEONPreAllocPass::ID = 0;
00037 }
00038 
00039 static bool isNEONMultiRegOp(int Opcode, unsigned &FirstOpnd,
00040                              unsigned &NumRegs) {
00041   switch (Opcode) {
00042   default:
00043     break;
00044 
00045   case ARM::VLD2d8:
00046   case ARM::VLD2d16:
00047   case ARM::VLD2d32:
00048     FirstOpnd = 0;
00049     NumRegs = 2;
00050     return true;
00051 
00052   case ARM::VLD3d8:
00053   case ARM::VLD3d16:
00054   case ARM::VLD3d32:
00055     FirstOpnd = 0;
00056     NumRegs = 3;
00057     return true;
00058 
00059   case ARM::VLD4d8:
00060   case ARM::VLD4d16:
00061   case ARM::VLD4d32:
00062     FirstOpnd = 0;
00063     NumRegs = 4;
00064     return true;
00065 
00066   case ARM::VST2d8:
00067   case ARM::VST2d16:
00068   case ARM::VST2d32:
00069     FirstOpnd = 3;
00070     NumRegs = 2;
00071     return true;
00072 
00073   case ARM::VST3d8:
00074   case ARM::VST3d16:
00075   case ARM::VST3d32:
00076     FirstOpnd = 3;
00077     NumRegs = 3;
00078     return true;
00079 
00080   case ARM::VST4d8:
00081   case ARM::VST4d16:
00082   case ARM::VST4d32:
00083     FirstOpnd = 3;
00084     NumRegs = 4;
00085     return true;
00086 
00087   case ARM::VTBL2:
00088     FirstOpnd = 1;
00089     NumRegs = 2;
00090     return true;
00091 
00092   case ARM::VTBL3:
00093     FirstOpnd = 1;
00094     NumRegs = 3;
00095     return true;
00096 
00097   case ARM::VTBL4:
00098     FirstOpnd = 1;
00099     NumRegs = 4;
00100     return true;
00101 
00102   case ARM::VTBX2:
00103     FirstOpnd = 2;
00104     NumRegs = 2;
00105     return true;
00106 
00107   case ARM::VTBX3:
00108     FirstOpnd = 2;
00109     NumRegs = 3;
00110     return true;
00111 
00112   case ARM::VTBX4:
00113     FirstOpnd = 2;
00114     NumRegs = 4;
00115     return true;
00116   }
00117 
00118   return false;
00119 }
00120 
00121 bool NEONPreAllocPass::PreAllocNEONRegisters(MachineBasicBlock &MBB) {
00122   bool Modified = false;
00123 
00124   MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
00125   for (; MBBI != E; ++MBBI) {
00126     MachineInstr *MI = &*MBBI;
00127     unsigned FirstOpnd, NumRegs;
00128     if (!isNEONMultiRegOp(MI->getOpcode(), FirstOpnd, NumRegs))
00129       continue;
00130 
00131     MachineBasicBlock::iterator NextI = next(MBBI);
00132     for (unsigned R = 0; R < NumRegs; ++R) {
00133       MachineOperand &MO = MI->getOperand(FirstOpnd + R);
00134       assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
00135       unsigned VirtReg = MO.getReg();
00136       assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
00137              "expected a virtual register");
00138 
00139       // For now, just assign a fixed set of adjacent registers.
00140       // This leaves plenty of room for future improvements.
00141       static const unsigned NEONDRegs[] = {
00142         ARM::D0, ARM::D1, ARM::D2, ARM::D3
00143       };
00144       MO.setReg(NEONDRegs[R]);
00145 
00146       if (MO.isUse()) {
00147         // Insert a copy from VirtReg.
00148         AddDefaultPred(BuildMI(MBB, MBBI, MI->getDebugLoc(),
00149                                TII->get(ARM::FCPYD), MO.getReg())
00150                        .addReg(VirtReg));
00151         if (MO.isKill()) {
00152           MachineInstr *CopyMI = prior(MBBI);
00153           CopyMI->findRegisterUseOperand(VirtReg)->setIsKill();
00154         }
00155         MO.setIsKill();
00156       } else if (MO.isDef() && !MO.isDead()) {
00157         // Add a copy to VirtReg.
00158         AddDefaultPred(BuildMI(MBB, NextI, MI->getDebugLoc(),
00159                                TII->get(ARM::FCPYD), VirtReg)
00160                        .addReg(MO.getReg()));
00161       }
00162     }
00163   }
00164 
00165   return Modified;
00166 }
00167 
00168 bool NEONPreAllocPass::runOnMachineFunction(MachineFunction &MF) {
00169   TII = MF.getTarget().getInstrInfo();
00170 
00171   bool Modified = false;
00172   for (MachineFunction::iterator MFI = MF.begin(), E = MF.end(); MFI != E;
00173        ++MFI) {
00174     MachineBasicBlock &MBB = *MFI;
00175     Modified |= PreAllocNEONRegisters(MBB);
00176   }
00177 
00178   return Modified;
00179 }
00180 
00181 /// createNEONPreAllocPass - returns an instance of the NEON register
00182 /// pre-allocation pass.
00183 FunctionPass *llvm::createNEONPreAllocPass() {
00184   return new NEONPreAllocPass();
00185 }