contrib/llvm/lib/Target/ARM/ARMInstructionSelector.cpp

   1 //===- ARMInstructionSelector.cpp ----------------------------*- 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 /// \file
  10 /// This file implements the targeting of the InstructionSelector class for ARM.
  11 /// \todo This should be generated by TableGen.
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ARMRegisterBankInfo.h"
  15 #include "ARMSubtarget.h"
  16 #include "ARMTargetMachine.h"
  17 #include "llvm/CodeGen/GlobalISel/InstructionSelector.h"
  18 #include "llvm/CodeGen/MachineRegisterInfo.h"
  19 #include "llvm/Support/Debug.h"
  20
  21 #define DEBUG_TYPE "arm-isel"
  22
  23 using namespace llvm;
  24
  25 #ifndef LLVM_BUILD_GLOBAL_ISEL
  26 #error "You shouldn't build this"
  27 #endif
  28
  29 namespace {
  30
  31 #define GET_GLOBALISEL_PREDICATE_BITSET
  32 #include "ARMGenGlobalISel.inc"
  33 #undef GET_GLOBALISEL_PREDICATE_BITSET
  34
  35 class ARMInstructionSelector : public InstructionSelector {
  36 public:
  37   ARMInstructionSelector(const ARMBaseTargetMachine &TM, const ARMSubtarget &STI,
  38                          const ARMRegisterBankInfo &RBI);
  39
  40   bool select(MachineInstr &I) const override;
  41
  42 private:
  43   bool selectImpl(MachineInstr &I) const;
  44
  45   const ARMBaseInstrInfo &TII;
  46   const ARMBaseRegisterInfo &TRI;
  47   const ARMBaseTargetMachine &TM;
  48   const ARMRegisterBankInfo &RBI;
  49   const ARMSubtarget &STI;
  50
  51 #define GET_GLOBALISEL_PREDICATES_DECL
  52 #include "ARMGenGlobalISel.inc"
  53 #undef GET_GLOBALISEL_PREDICATES_DECL
  54
  55 // We declare the temporaries used by selectImpl() in the class to minimize the
  56 // cost of constructing placeholder values.
  57 #define GET_GLOBALISEL_TEMPORARIES_DECL
  58 #include "ARMGenGlobalISel.inc"
  59 #undef GET_GLOBALISEL_TEMPORARIES_DECL
  60 };
  61 } // end anonymous namespace
  62
  63 namespace llvm {
  64 InstructionSelector *
  65 createARMInstructionSelector(const ARMBaseTargetMachine &TM,
  66                              const ARMSubtarget &STI,
  67                              const ARMRegisterBankInfo &RBI) {
  68   return new ARMInstructionSelector(TM, STI, RBI);
  69 }
  70 }
  71
  72 unsigned zero_reg = 0;
  73
  74 #define GET_GLOBALISEL_IMPL
  75 #include "ARMGenGlobalISel.inc"
  76 #undef GET_GLOBALISEL_IMPL
  77
  78 ARMInstructionSelector::ARMInstructionSelector(const ARMBaseTargetMachine &TM,
  79                                                const ARMSubtarget &STI,
  80                                                const ARMRegisterBankInfo &RBI)
  81     : InstructionSelector(), TII(*STI.getInstrInfo()),
  82       TRI(*STI.getRegisterInfo()), TM(TM), RBI(RBI), STI(STI),
  83 #define GET_GLOBALISEL_PREDICATES_INIT
  84 #include "ARMGenGlobalISel.inc"
  85 #undef GET_GLOBALISEL_PREDICATES_INIT
  86 #define GET_GLOBALISEL_TEMPORARIES_INIT
  87 #include "ARMGenGlobalISel.inc"
  88 #undef GET_GLOBALISEL_TEMPORARIES_INIT
  89 {
  90 }
  91
  92 static bool selectCopy(MachineInstr &I, const TargetInstrInfo &TII,
  93                        MachineRegisterInfo &MRI, const TargetRegisterInfo &TRI,
  94                        const RegisterBankInfo &RBI) {
  95   unsigned DstReg = I.getOperand(0).getReg();
  96   if (TargetRegisterInfo::isPhysicalRegister(DstReg))
  97     return true;
  98
  99   const RegisterBank *RegBank = RBI.getRegBank(DstReg, MRI, TRI);
 100   (void)RegBank;
 101   assert(RegBank && "Can't get reg bank for virtual register");
 102
 103   const unsigned DstSize = MRI.getType(DstReg).getSizeInBits();
 104   assert((RegBank->getID() == ARM::GPRRegBankID ||
 105           RegBank->getID() == ARM::FPRRegBankID) &&
 106          "Unsupported reg bank");
 107
 108   const TargetRegisterClass *RC = &ARM::GPRRegClass;
 109
 110   if (RegBank->getID() == ARM::FPRRegBankID) {
 111     if (DstSize == 32)
 112       RC = &ARM::SPRRegClass;
 113     else if (DstSize == 64)
 114       RC = &ARM::DPRRegClass;
 115     else
 116       llvm_unreachable("Unsupported destination size");
 117   }
 118
 119   // No need to constrain SrcReg. It will get constrained when
 120   // we hit another of its uses or its defs.
 121   // Copies do not have constraints.
 122   if (!RBI.constrainGenericRegister(DstReg, *RC, MRI)) {
 123     DEBUG(dbgs() << "Failed to constrain " << TII.getName(I.getOpcode())
 124                  << " operand\n");
 125     return false;
 126   }
 127   return true;
 128 }
 129
 130 static bool selectMergeValues(MachineInstrBuilder &MIB,
 131                               const ARMBaseInstrInfo &TII,
 132                               MachineRegisterInfo &MRI,
 133                               const TargetRegisterInfo &TRI,
 134                               const RegisterBankInfo &RBI) {
 135   assert(TII.getSubtarget().hasVFP2() && "Can't select merge without VFP");
 136
 137   // We only support G_MERGE_VALUES as a way to stick together two scalar GPRs
 138   // into one DPR.
 139   unsigned VReg0 = MIB->getOperand(0).getReg();
 140   (void)VReg0;
 141   assert(MRI.getType(VReg0).getSizeInBits() == 64 &&
 142          RBI.getRegBank(VReg0, MRI, TRI)->getID() == ARM::FPRRegBankID &&
 143          "Unsupported operand for G_MERGE_VALUES");
 144   unsigned VReg1 = MIB->getOperand(1).getReg();
 145   (void)VReg1;
 146   assert(MRI.getType(VReg1).getSizeInBits() == 32 &&
 147          RBI.getRegBank(VReg1, MRI, TRI)->getID() == ARM::GPRRegBankID &&
 148          "Unsupported operand for G_MERGE_VALUES");
 149   unsigned VReg2 = MIB->getOperand(2).getReg();
 150   (void)VReg2;
 151   assert(MRI.getType(VReg2).getSizeInBits() == 32 &&
 152          RBI.getRegBank(VReg2, MRI, TRI)->getID() == ARM::GPRRegBankID &&
 153          "Unsupported operand for G_MERGE_VALUES");
 154
 155   MIB->setDesc(TII.get(ARM::VMOVDRR));
 156   MIB.add(predOps(ARMCC::AL));
 157
 158   return true;
 159 }
 160
 161 static bool selectUnmergeValues(MachineInstrBuilder &MIB,
 162                                 const ARMBaseInstrInfo &TII,
 163                                 MachineRegisterInfo &MRI,
 164                                 const TargetRegisterInfo &TRI,
 165                                 const RegisterBankInfo &RBI) {
 166   assert(TII.getSubtarget().hasVFP2() && "Can't select unmerge without VFP");
 167
 168   // We only support G_UNMERGE_VALUES as a way to break up one DPR into two
 169   // GPRs.
 170   unsigned VReg0 = MIB->getOperand(0).getReg();
 171   (void)VReg0;
 172   assert(MRI.getType(VReg0).getSizeInBits() == 32 &&
 173          RBI.getRegBank(VReg0, MRI, TRI)->getID() == ARM::GPRRegBankID &&
 174          "Unsupported operand for G_UNMERGE_VALUES");
 175   unsigned VReg1 = MIB->getOperand(1).getReg();
 176   (void)VReg1;
 177   assert(MRI.getType(VReg1).getSizeInBits() == 32 &&
 178          RBI.getRegBank(VReg1, MRI, TRI)->getID() == ARM::GPRRegBankID &&
 179          "Unsupported operand for G_UNMERGE_VALUES");
 180   unsigned VReg2 = MIB->getOperand(2).getReg();
 181   (void)VReg2;
 182   assert(MRI.getType(VReg2).getSizeInBits() == 64 &&
 183          RBI.getRegBank(VReg2, MRI, TRI)->getID() == ARM::FPRRegBankID &&
 184          "Unsupported operand for G_UNMERGE_VALUES");
 185
 186   MIB->setDesc(TII.get(ARM::VMOVRRD));
 187   MIB.add(predOps(ARMCC::AL));
 188
 189   return true;
 190 }
 191
 192 /// Select the opcode for simple extensions (that translate to a single SXT/UXT
 193 /// instruction). Extension operations more complicated than that should not
 194 /// invoke this. Returns the original opcode if it doesn't know how to select a
 195 /// better one.
 196 static unsigned selectSimpleExtOpc(unsigned Opc, unsigned Size) {
 197   using namespace TargetOpcode;
 198
 199   if (Size != 8 && Size != 16)
 200     return Opc;
 201
 202   if (Opc == G_SEXT)
 203     return Size == 8 ? ARM::SXTB : ARM::SXTH;
 204
 205   if (Opc == G_ZEXT)
 206     return Size == 8 ? ARM::UXTB : ARM::UXTH;
 207
 208   return Opc;
 209 }
 210
 211 /// Select the opcode for simple loads and stores. For types smaller than 32
 212 /// bits, the value will be zero extended. Returns the original opcode if it
 213 /// doesn't know how to select a better one.
 214 static unsigned selectLoadStoreOpCode(unsigned Opc, unsigned RegBank,
 215                                       unsigned Size) {
 216   bool isStore = Opc == TargetOpcode::G_STORE;
 217
 218   if (RegBank == ARM::GPRRegBankID) {
 219     switch (Size) {
 220     case 1:
 221     case 8:
 222       return isStore ? ARM::STRBi12 : ARM::LDRBi12;
 223     case 16:
 224       return isStore ? ARM::STRH : ARM::LDRH;
 225     case 32:
 226       return isStore ? ARM::STRi12 : ARM::LDRi12;
 227     default:
 228       return Opc;
 229     }
 230   }
 231
 232   if (RegBank == ARM::FPRRegBankID) {
 233     switch (Size) {
 234     case 32:
 235       return isStore ? ARM::VSTRS : ARM::VLDRS;
 236     case 64:
 237       return isStore ? ARM::VSTRD : ARM::VLDRD;
 238     default:
 239       return Opc;
 240     }
 241   }
 242
 243   return Opc;
 244 }
 245
 246 bool ARMInstructionSelector::select(MachineInstr &I) const {
 247   assert(I.getParent() && "Instruction should be in a basic block!");
 248   assert(I.getParent()->getParent() && "Instruction should be in a function!");
 249
 250   auto &MBB = *I.getParent();
 251   auto &MF = *MBB.getParent();
 252   auto &MRI = MF.getRegInfo();
 253
 254   if (!isPreISelGenericOpcode(I.getOpcode())) {
 255     if (I.isCopy())
 256       return selectCopy(I, TII, MRI, TRI, RBI);
 257
 258     return true;
 259   }
 260
 261   if (selectImpl(I))
 262     return true;
 263
 264   MachineInstrBuilder MIB{MF, I};
 265   bool isSExt = false;
 266
 267   using namespace TargetOpcode;
 268   switch (I.getOpcode()) {
 269   case G_SEXT:
 270     isSExt = true;
 271     LLVM_FALLTHROUGH;
 272   case G_ZEXT: {
 273     LLT DstTy = MRI.getType(I.getOperand(0).getReg());
 274     // FIXME: Smaller destination sizes coming soon!
 275     if (DstTy.getSizeInBits() != 32) {
 276       DEBUG(dbgs() << "Unsupported destination size for extension");
 277       return false;
 278     }
 279
 280     LLT SrcTy = MRI.getType(I.getOperand(1).getReg());
 281     unsigned SrcSize = SrcTy.getSizeInBits();
 282     switch (SrcSize) {
 283     case 1: {
 284       // ZExt boils down to & 0x1; for SExt we also subtract that from 0
 285       I.setDesc(TII.get(ARM::ANDri));
 286       MIB.addImm(1).add(predOps(ARMCC::AL)).add(condCodeOp());
 287
 288       if (isSExt) {
 289         unsigned SExtResult = I.getOperand(0).getReg();
 290
 291         // Use a new virtual register for the result of the AND
 292         unsigned AndResult = MRI.createVirtualRegister(&ARM::GPRRegClass);
 293         I.getOperand(0).setReg(AndResult);
 294
 295         auto InsertBefore = std::next(I.getIterator());
 296         auto SubI =
 297             BuildMI(MBB, InsertBefore, I.getDebugLoc(), TII.get(ARM::RSBri))
 298                 .addDef(SExtResult)
 299                 .addUse(AndResult)
 300                 .addImm(0)
 301                 .add(predOps(ARMCC::AL))
 302                 .add(condCodeOp());
 303         if (!constrainSelectedInstRegOperands(*SubI, TII, TRI, RBI))
 304           return false;
 305       }
 306       break;
 307     }
 308     case 8:
 309     case 16: {
 310       unsigned NewOpc = selectSimpleExtOpc(I.getOpcode(), SrcSize);
 311       if (NewOpc == I.getOpcode())
 312         return false;
 313       I.setDesc(TII.get(NewOpc));
 314       MIB.addImm(0).add(predOps(ARMCC::AL));
 315       break;
 316     }
 317     default:
 318       DEBUG(dbgs() << "Unsupported source size for extension");
 319       return false;
 320     }
 321     break;
 322   }
 323   case G_ANYEXT:
 324   case G_TRUNC: {
 325     // The high bits are undefined, so there's nothing special to do, just
 326     // treat it as a copy.
 327     auto SrcReg = I.getOperand(1).getReg();
 328     auto DstReg = I.getOperand(0).getReg();
 329
 330     const auto &SrcRegBank = *RBI.getRegBank(SrcReg, MRI, TRI);
 331     const auto &DstRegBank = *RBI.getRegBank(DstReg, MRI, TRI);
 332
 333     if (SrcRegBank.getID() != DstRegBank.getID()) {
 334       DEBUG(dbgs() << "G_TRUNC/G_ANYEXT operands on different register banks\n");
 335       return false;
 336     }
 337
 338     if (SrcRegBank.getID() != ARM::GPRRegBankID) {
 339       DEBUG(dbgs() << "G_TRUNC/G_ANYEXT on non-GPR not supported yet\n");
 340       return false;
 341     }
 342
 343     I.setDesc(TII.get(COPY));
 344     return selectCopy(I, TII, MRI, TRI, RBI);
 345   }
 346   case G_GEP:
 347     I.setDesc(TII.get(ARM::ADDrr));
 348     MIB.add(predOps(ARMCC::AL)).add(condCodeOp());
 349     break;
 350   case G_FRAME_INDEX:
 351     // Add 0 to the given frame index and hope it will eventually be folded into
 352     // the user(s).
 353     I.setDesc(TII.get(ARM::ADDri));
 354     MIB.addImm(0).add(predOps(ARMCC::AL)).add(condCodeOp());
 355     break;
 356   case G_CONSTANT: {
 357     unsigned Reg = I.getOperand(0).getReg();
 358     if (MRI.getType(Reg).getSizeInBits() != 32)
 359       return false;
 360
 361     assert(RBI.getRegBank(Reg, MRI, TRI)->getID() == ARM::GPRRegBankID &&
 362            "Expected constant to live in a GPR");
 363     I.setDesc(TII.get(ARM::MOVi));
 364     MIB.add(predOps(ARMCC::AL)).add(condCodeOp());
 365
 366     auto &Val = I.getOperand(1);
 367     if (Val.isCImm()) {
 368       if (Val.getCImm()->getBitWidth() > 32)
 369         return false;
 370       Val.ChangeToImmediate(Val.getCImm()->getZExtValue());
 371     }
 372
 373     if (!Val.isImm()) {
 374       return false;
 375     }
 376
 377     break;
 378   }
 379   case G_STORE:
 380   case G_LOAD: {
 381     const auto &MemOp = **I.memoperands_begin();
 382     if (MemOp.getOrdering() != AtomicOrdering::NotAtomic) {
 383       DEBUG(dbgs() << "Atomic load/store not supported yet\n");
 384       return false;
 385     }
 386
 387     unsigned Reg = I.getOperand(0).getReg();
 388     unsigned RegBank = RBI.getRegBank(Reg, MRI, TRI)->getID();
 389
 390     LLT ValTy = MRI.getType(Reg);
 391     const auto ValSize = ValTy.getSizeInBits();
 392
 393     assert((ValSize != 64 || TII.getSubtarget().hasVFP2()) &&
 394            "Don't know how to load/store 64-bit value without VFP");
 395
 396     const auto NewOpc = selectLoadStoreOpCode(I.getOpcode(), RegBank, ValSize);
 397     if (NewOpc == G_LOAD || NewOpc == G_STORE)
 398       return false;
 399
 400     I.setDesc(TII.get(NewOpc));
 401
 402     if (NewOpc == ARM::LDRH || NewOpc == ARM::STRH)
 403       // LDRH has a funny addressing mode (there's already a FIXME for it).
 404       MIB.addReg(0);
 405     MIB.addImm(0).add(predOps(ARMCC::AL));
 406     break;
 407   }
 408   case G_MERGE_VALUES: {
 409     if (!selectMergeValues(MIB, TII, MRI, TRI, RBI))
 410       return false;
 411     break;
 412   }
 413   case G_UNMERGE_VALUES: {
 414     if (!selectUnmergeValues(MIB, TII, MRI, TRI, RBI))
 415       return false;
 416     break;
 417   }
 418   default:
 419     return false;
 420   }
 421
 422   return constrainSelectedInstRegOperands(I, TII, TRI, RBI);
 423 }