LLVM API Documentation
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 }