lib/Target/ARM/NEONPreAllocPass.cpp

   1 //===-- NEONPreAllocPass.cpp - Allocate adjacent NEON registers--*- 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 #define DEBUG_TYPE "neon-prealloc"
  11 #include "ARM.h"
  12 #include "ARMInstrInfo.h"
  13 #include "llvm/CodeGen/MachineInstr.h"
  14 #include "llvm/CodeGen/MachineInstrBuilder.h"
  15 #include "llvm/CodeGen/MachineFunctionPass.h"
  16 using namespace llvm;
  17
  18 namespace {
  19   class VISIBILITY_HIDDEN NEONPreAllocPass : public MachineFunctionPass {
  20     const TargetInstrInfo *TII;
  21
  22   public:
  23     static char ID;
  24     NEONPreAllocPass() : MachineFunctionPass(&ID) {}
  25
  26     virtual bool runOnMachineFunction(MachineFunction &MF);
  27
  28     virtual const char *getPassName() const {
  29       return "NEON register pre-allocation pass";
  30     }
  31
  32   private:
  33     bool PreAllocNEONRegisters(MachineBasicBlock &MBB);
  34   };
  35
  36   char NEONPreAllocPass::ID = 0;
  37 }
  38
  39 static bool isNEONMultiRegOp(int Opcode, unsigned &FirstOpnd, unsigned &NumRegs,
  40                              unsigned &Offset, unsigned &Stride) {
  41   // Default to unit stride with no offset.
  42   Stride = 1;
  43   Offset = 0;
  44
  45   switch (Opcode) {
  46   default:
  47     break;
  48
  49   case ARM::VLD2d8:
  50   case ARM::VLD2d16:
  51   case ARM::VLD2d32:
  52   case ARM::VLD2d64:
  53   case ARM::VLD2LNd8:
  54   case ARM::VLD2LNd16:
  55   case ARM::VLD2LNd32:
  56     FirstOpnd = 0;
  57     NumRegs = 2;
  58     return true;
  59
  60   case ARM::VLD2q8:
  61   case ARM::VLD2q16:
  62   case ARM::VLD2q32:
  63     FirstOpnd = 0;
  64     NumRegs = 4;
  65     return true;
  66
  67   case ARM::VLD3d8:
  68   case ARM::VLD3d16:
  69   case ARM::VLD3d32:
  70   case ARM::VLD3d64:
  71   case ARM::VLD3LNd8:
  72   case ARM::VLD3LNd16:
  73   case ARM::VLD3LNd32:
  74     FirstOpnd = 0;
  75     NumRegs = 3;
  76     return true;
  77
  78   case ARM::VLD3q8a:
  79   case ARM::VLD3q16a:
  80   case ARM::VLD3q32a:
  81     FirstOpnd = 0;
  82     NumRegs = 3;
  83     Offset = 0;
  84     Stride = 2;
  85     return true;
  86
  87   case ARM::VLD3q8b:
  88   case ARM::VLD3q16b:
  89   case ARM::VLD3q32b:
  90     FirstOpnd = 0;
  91     NumRegs = 3;
  92     Offset = 1;
  93     Stride = 2;
  94     return true;
  95
  96   case ARM::VLD4d8:
  97   case ARM::VLD4d16:
  98   case ARM::VLD4d32:
  99   case ARM::VLD4d64:
 100   case ARM::VLD4LNd8:
 101   case ARM::VLD4LNd16:
 102   case ARM::VLD4LNd32:
 103     FirstOpnd = 0;
 104     NumRegs = 4;
 105     return true;
 106
 107   case ARM::VLD4q8a:
 108   case ARM::VLD4q16a:
 109   case ARM::VLD4q32a:
 110     FirstOpnd = 0;
 111     NumRegs = 4;
 112     Offset = 0;
 113     Stride = 2;
 114     return true;
 115
 116   case ARM::VLD4q8b:
 117   case ARM::VLD4q16b:
 118   case ARM::VLD4q32b:
 119     FirstOpnd = 0;
 120     NumRegs = 4;
 121     Offset = 1;
 122     Stride = 2;
 123     return true;
 124
 125   case ARM::VST2d8:
 126   case ARM::VST2d16:
 127   case ARM::VST2d32:
 128   case ARM::VST2d64:
 129   case ARM::VST2LNd8:
 130   case ARM::VST2LNd16:
 131   case ARM::VST2LNd32:
 132     FirstOpnd = 3;
 133     NumRegs = 2;
 134     return true;
 135
 136   case ARM::VST2q8:
 137   case ARM::VST2q16:
 138   case ARM::VST2q32:
 139     FirstOpnd = 3;
 140     NumRegs = 4;
 141     return true;
 142
 143   case ARM::VST3d8:
 144   case ARM::VST3d16:
 145   case ARM::VST3d32:
 146   case ARM::VST3d64:
 147   case ARM::VST3LNd8:
 148   case ARM::VST3LNd16:
 149   case ARM::VST3LNd32:
 150     FirstOpnd = 3;
 151     NumRegs = 3;
 152     return true;
 153
 154   case ARM::VST3q8a:
 155   case ARM::VST3q16a:
 156   case ARM::VST3q32a:
 157     FirstOpnd = 4;
 158     NumRegs = 3;
 159     Offset = 0;
 160     Stride = 2;
 161     return true;
 162
 163   case ARM::VST3q8b:
 164   case ARM::VST3q16b:
 165   case ARM::VST3q32b:
 166     FirstOpnd = 4;
 167     NumRegs = 3;
 168     Offset = 1;
 169     Stride = 2;
 170     return true;
 171
 172   case ARM::VST4d8:
 173   case ARM::VST4d16:
 174   case ARM::VST4d32:
 175   case ARM::VST4LNd8:
 176   case ARM::VST4LNd16:
 177   case ARM::VST4LNd32:
 178     FirstOpnd = 3;
 179     NumRegs = 4;
 180     return true;
 181
 182   case ARM::VST4q8a:
 183   case ARM::VST4q16a:
 184   case ARM::VST4q32a:
 185     FirstOpnd = 4;
 186     NumRegs = 4;
 187     Offset = 0;
 188     Stride = 2;
 189     return true;
 190
 191   case ARM::VST4q8b:
 192   case ARM::VST4q16b:
 193   case ARM::VST4q32b:
 194     FirstOpnd = 4;
 195     NumRegs = 4;
 196     Offset = 1;
 197     Stride = 2;
 198     return true;
 199
 200   case ARM::VTBL2:
 201     FirstOpnd = 1;
 202     NumRegs = 2;
 203     return true;
 204
 205   case ARM::VTBL3:
 206     FirstOpnd = 1;
 207     NumRegs = 3;
 208     return true;
 209
 210   case ARM::VTBL4:
 211     FirstOpnd = 1;
 212     NumRegs = 4;
 213     return true;
 214
 215   case ARM::VTBX2:
 216     FirstOpnd = 2;
 217     NumRegs = 2;
 218     return true;
 219
 220   case ARM::VTBX3:
 221     FirstOpnd = 2;
 222     NumRegs = 3;
 223     return true;
 224
 225   case ARM::VTBX4:
 226     FirstOpnd = 2;
 227     NumRegs = 4;
 228     return true;
 229   }
 230
 231   return false;
 232 }
 233
 234 bool NEONPreAllocPass::PreAllocNEONRegisters(MachineBasicBlock &MBB) {
 235   bool Modified = false;
 236
 237   MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
 238   for (; MBBI != E; ++MBBI) {
 239     MachineInstr *MI = &*MBBI;
 240     unsigned FirstOpnd, NumRegs, Offset, Stride;
 241     if (!isNEONMultiRegOp(MI->getOpcode(), FirstOpnd, NumRegs, Offset, Stride))
 242       continue;
 243
 244     MachineBasicBlock::iterator NextI = next(MBBI);
 245     for (unsigned R = 0; R < NumRegs; ++R) {
 246       MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 247       assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
 248       unsigned VirtReg = MO.getReg();
 249       assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 250              "expected a virtual register");
 251
 252       // For now, just assign a fixed set of adjacent registers.
 253       // This leaves plenty of room for future improvements.
 254       static const unsigned NEONDRegs[] = {
 255         ARM::D0, ARM::D1, ARM::D2, ARM::D3,
 256         ARM::D4, ARM::D5, ARM::D6, ARM::D7
 257       };
 258       MO.setReg(NEONDRegs[Offset + R * Stride]);
 259
 260       if (MO.isUse()) {
 261         // Insert a copy from VirtReg.
 262         TII->copyRegToReg(MBB, MBBI, MO.getReg(), VirtReg,
 263                           ARM::DPRRegisterClass, ARM::DPRRegisterClass);
 264         if (MO.isKill()) {
 265           MachineInstr *CopyMI = prior(MBBI);
 266           CopyMI->findRegisterUseOperand(VirtReg)->setIsKill();
 267         }
 268         MO.setIsKill();
 269       } else if (MO.isDef() && !MO.isDead()) {
 270         // Add a copy to VirtReg.
 271         TII->copyRegToReg(MBB, NextI, VirtReg, MO.getReg(),
 272                           ARM::DPRRegisterClass, ARM::DPRRegisterClass);
 273       }
 274     }
 275   }
 276
 277   return Modified;
 278 }
 279
 280 bool NEONPreAllocPass::runOnMachineFunction(MachineFunction &MF) {
 281   TII = MF.getTarget().getInstrInfo();
 282
 283   bool Modified = false;
 284   for (MachineFunction::iterator MFI = MF.begin(), E = MF.end(); MFI != E;
 285        ++MFI) {
 286     MachineBasicBlock &MBB = *MFI;
 287     Modified |= PreAllocNEONRegisters(MBB);
 288   }
 289
 290   return Modified;
 291 }
 292
 293 /// createNEONPreAllocPass - returns an instance of the NEON register
 294 /// pre-allocation pass.
 295 FunctionPass *llvm::createNEONPreAllocPass() {
 296   return new NEONPreAllocPass();
 297 }