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/GlobalISel/InstructionSelectorImpl.h"
  19 #include "llvm/CodeGen/MachineConstantPool.h"
  20 #include "llvm/CodeGen/MachineRegisterInfo.h"
  21 #include "llvm/Support/Debug.h"
  22
  23 #define DEBUG_TYPE "arm-isel"
  24
  25 using namespace llvm;
  26
  27 namespace {
  28
  29 #define GET_GLOBALISEL_PREDICATE_BITSET
  30 #include "ARMGenGlobalISel.inc"
  31 #undef GET_GLOBALISEL_PREDICATE_BITSET
  32
  33 class ARMInstructionSelector : public InstructionSelector {
  34 public:
  35   ARMInstructionSelector(const ARMBaseTargetMachine &TM, const ARMSubtarget &STI,
  36                          const ARMRegisterBankInfo &RBI);
  37
  38   bool select(MachineInstr &I, CodeGenCoverage &CoverageInfo) const override;
  39   static const char *getName() { return DEBUG_TYPE; }
  40
  41 private:
  42   bool selectImpl(MachineInstr &I, CodeGenCoverage &CoverageInfo) const;
  43
  44   struct CmpConstants;
  45   struct InsertInfo;
  46
  47   bool selectCmp(CmpConstants Helper, MachineInstrBuilder &MIB,
  48                  MachineRegisterInfo &MRI) const;
  49
  50   // Helper for inserting a comparison sequence that sets \p ResReg to either 1
  51   // if \p LHSReg and \p RHSReg are in the relationship defined by \p Cond, or
  52   // \p PrevRes otherwise. In essence, it computes PrevRes OR (LHS Cond RHS).
  53   bool insertComparison(CmpConstants Helper, InsertInfo I, unsigned ResReg,
  54                         ARMCC::CondCodes Cond, unsigned LHSReg, unsigned RHSReg,
  55                         unsigned PrevRes) const;
  56
  57   // Set \p DestReg to \p Constant.
  58   void putConstant(InsertInfo I, unsigned DestReg, unsigned Constant) const;
  59
  60   bool selectGlobal(MachineInstrBuilder &MIB, MachineRegisterInfo &MRI) const;
  61   bool selectSelect(MachineInstrBuilder &MIB, MachineRegisterInfo &MRI) const;
  62   bool selectShift(unsigned ShiftOpc, MachineInstrBuilder &MIB) const;
  63
  64   // Check if the types match and both operands have the expected size and
  65   // register bank.
  66   bool validOpRegPair(MachineRegisterInfo &MRI, unsigned LHS, unsigned RHS,
  67                       unsigned ExpectedSize, unsigned ExpectedRegBankID) const;
  68
  69   // Check if the register has the expected size and register bank.
  70   bool validReg(MachineRegisterInfo &MRI, unsigned Reg, unsigned ExpectedSize,
  71                 unsigned ExpectedRegBankID) const;
  72
  73   const ARMBaseInstrInfo &TII;
  74   const ARMBaseRegisterInfo &TRI;
  75   const ARMBaseTargetMachine &TM;
  76   const ARMRegisterBankInfo &RBI;
  77   const ARMSubtarget &STI;
  78
  79 #define GET_GLOBALISEL_PREDICATES_DECL
  80 #include "ARMGenGlobalISel.inc"
  81 #undef GET_GLOBALISEL_PREDICATES_DECL
  82
  83 // We declare the temporaries used by selectImpl() in the class to minimize the
  84 // cost of constructing placeholder values.
  85 #define GET_GLOBALISEL_TEMPORARIES_DECL
  86 #include "ARMGenGlobalISel.inc"
  87 #undef GET_GLOBALISEL_TEMPORARIES_DECL
  88 };
  89 } // end anonymous namespace
  90
  91 namespace llvm {
  92 InstructionSelector *
  93 createARMInstructionSelector(const ARMBaseTargetMachine &TM,
  94                              const ARMSubtarget &STI,
  95                              const ARMRegisterBankInfo &RBI) {
  96   return new ARMInstructionSelector(TM, STI, RBI);
  97 }
  98 }
  99
 100 const unsigned zero_reg = 0;
 101
 102 #define GET_GLOBALISEL_IMPL
 103 #include "ARMGenGlobalISel.inc"
 104 #undef GET_GLOBALISEL_IMPL
 105
 106 ARMInstructionSelector::ARMInstructionSelector(const ARMBaseTargetMachine &TM,
 107                                                const ARMSubtarget &STI,
 108                                                const ARMRegisterBankInfo &RBI)
 109     : InstructionSelector(), TII(*STI.getInstrInfo()),
 110       TRI(*STI.getRegisterInfo()), TM(TM), RBI(RBI), STI(STI),
 111 #define GET_GLOBALISEL_PREDICATES_INIT
 112 #include "ARMGenGlobalISel.inc"
 113 #undef GET_GLOBALISEL_PREDICATES_INIT
 114 #define GET_GLOBALISEL_TEMPORARIES_INIT
 115 #include "ARMGenGlobalISel.inc"
 116 #undef GET_GLOBALISEL_TEMPORARIES_INIT
 117 {
 118 }
 119
 120 static bool selectCopy(MachineInstr &I, const TargetInstrInfo &TII,
 121                        MachineRegisterInfo &MRI, const TargetRegisterInfo &TRI,
 122                        const RegisterBankInfo &RBI) {
 123   unsigned DstReg = I.getOperand(0).getReg();
 124   if (TargetRegisterInfo::isPhysicalRegister(DstReg))
 125     return true;
 126
 127   const RegisterBank *RegBank = RBI.getRegBank(DstReg, MRI, TRI);
 128   (void)RegBank;
 129   assert(RegBank && "Can't get reg bank for virtual register");
 130
 131   const unsigned DstSize = MRI.getType(DstReg).getSizeInBits();
 132   assert((RegBank->getID() == ARM::GPRRegBankID ||
 133           RegBank->getID() == ARM::FPRRegBankID) &&
 134          "Unsupported reg bank");
 135
 136   const TargetRegisterClass *RC = &ARM::GPRRegClass;
 137
 138   if (RegBank->getID() == ARM::FPRRegBankID) {
 139     if (DstSize == 32)
 140       RC = &ARM::SPRRegClass;
 141     else if (DstSize == 64)
 142       RC = &ARM::DPRRegClass;
 143     else
 144       llvm_unreachable("Unsupported destination size");
 145   }
 146
 147   // No need to constrain SrcReg. It will get constrained when
 148   // we hit another of its uses or its defs.
 149   // Copies do not have constraints.
 150   if (!RBI.constrainGenericRegister(DstReg, *RC, MRI)) {
 151     DEBUG(dbgs() << "Failed to constrain " << TII.getName(I.getOpcode())
 152                  << " operand\n");
 153     return false;
 154   }
 155   return true;
 156 }
 157
 158 static bool selectMergeValues(MachineInstrBuilder &MIB,
 159                               const ARMBaseInstrInfo &TII,
 160                               MachineRegisterInfo &MRI,
 161                               const TargetRegisterInfo &TRI,
 162                               const RegisterBankInfo &RBI) {
 163   assert(TII.getSubtarget().hasVFP2() && "Can't select merge without VFP");
 164
 165   // We only support G_MERGE_VALUES as a way to stick together two scalar GPRs
 166   // into one DPR.
 167   unsigned VReg0 = MIB->getOperand(0).getReg();
 168   (void)VReg0;
 169   assert(MRI.getType(VReg0).getSizeInBits() == 64 &&
 170          RBI.getRegBank(VReg0, MRI, TRI)->getID() == ARM::FPRRegBankID &&
 171          "Unsupported operand for G_MERGE_VALUES");
 172   unsigned VReg1 = MIB->getOperand(1).getReg();
 173   (void)VReg1;
 174   assert(MRI.getType(VReg1).getSizeInBits() == 32 &&
 175          RBI.getRegBank(VReg1, MRI, TRI)->getID() == ARM::GPRRegBankID &&
 176          "Unsupported operand for G_MERGE_VALUES");
 177   unsigned VReg2 = MIB->getOperand(2).getReg();
 178   (void)VReg2;
 179   assert(MRI.getType(VReg2).getSizeInBits() == 32 &&
 180          RBI.getRegBank(VReg2, MRI, TRI)->getID() == ARM::GPRRegBankID &&
 181          "Unsupported operand for G_MERGE_VALUES");
 182
 183   MIB->setDesc(TII.get(ARM::VMOVDRR));
 184   MIB.add(predOps(ARMCC::AL));
 185
 186   return true;
 187 }
 188
 189 static bool selectUnmergeValues(MachineInstrBuilder &MIB,
 190                                 const ARMBaseInstrInfo &TII,
 191                                 MachineRegisterInfo &MRI,
 192                                 const TargetRegisterInfo &TRI,
 193                                 const RegisterBankInfo &RBI) {
 194   assert(TII.getSubtarget().hasVFP2() && "Can't select unmerge without VFP");
 195
 196   // We only support G_UNMERGE_VALUES as a way to break up one DPR into two
 197   // GPRs.
 198   unsigned VReg0 = MIB->getOperand(0).getReg();
 199   (void)VReg0;
 200   assert(MRI.getType(VReg0).getSizeInBits() == 32 &&
 201          RBI.getRegBank(VReg0, MRI, TRI)->getID() == ARM::GPRRegBankID &&
 202          "Unsupported operand for G_UNMERGE_VALUES");
 203   unsigned VReg1 = MIB->getOperand(1).getReg();
 204   (void)VReg1;
 205   assert(MRI.getType(VReg1).getSizeInBits() == 32 &&
 206          RBI.getRegBank(VReg1, MRI, TRI)->getID() == ARM::GPRRegBankID &&
 207          "Unsupported operand for G_UNMERGE_VALUES");
 208   unsigned VReg2 = MIB->getOperand(2).getReg();
 209   (void)VReg2;
 210   assert(MRI.getType(VReg2).getSizeInBits() == 64 &&
 211          RBI.getRegBank(VReg2, MRI, TRI)->getID() == ARM::FPRRegBankID &&
 212          "Unsupported operand for G_UNMERGE_VALUES");
 213
 214   MIB->setDesc(TII.get(ARM::VMOVRRD));
 215   MIB.add(predOps(ARMCC::AL));
 216
 217   return true;
 218 }
 219
 220 /// Select the opcode for simple extensions (that translate to a single SXT/UXT
 221 /// instruction). Extension operations more complicated than that should not
 222 /// invoke this. Returns the original opcode if it doesn't know how to select a
 223 /// better one.
 224 static unsigned selectSimpleExtOpc(unsigned Opc, unsigned Size) {
 225   using namespace TargetOpcode;
 226
 227   if (Size != 8 && Size != 16)
 228     return Opc;
 229
 230   if (Opc == G_SEXT)
 231     return Size == 8 ? ARM::SXTB : ARM::SXTH;
 232
 233   if (Opc == G_ZEXT)
 234     return Size == 8 ? ARM::UXTB : ARM::UXTH;
 235
 236   return Opc;
 237 }
 238
 239 /// Select the opcode for simple loads and stores. For types smaller than 32
 240 /// bits, the value will be zero extended. Returns the original opcode if it
 241 /// doesn't know how to select a better one.
 242 static unsigned selectLoadStoreOpCode(unsigned Opc, unsigned RegBank,
 243                                       unsigned Size) {
 244   bool isStore = Opc == TargetOpcode::G_STORE;
 245
 246   if (RegBank == ARM::GPRRegBankID) {
 247     switch (Size) {
 248     case 1:
 249     case 8:
 250       return isStore ? ARM::STRBi12 : ARM::LDRBi12;
 251     case 16:
 252       return isStore ? ARM::STRH : ARM::LDRH;
 253     case 32:
 254       return isStore ? ARM::STRi12 : ARM::LDRi12;
 255     default:
 256       return Opc;
 257     }
 258   }
 259
 260   if (RegBank == ARM::FPRRegBankID) {
 261     switch (Size) {
 262     case 32:
 263       return isStore ? ARM::VSTRS : ARM::VLDRS;
 264     case 64:
 265       return isStore ? ARM::VSTRD : ARM::VLDRD;
 266     default:
 267       return Opc;
 268     }
 269   }
 270
 271   return Opc;
 272 }
 273
 274 // When lowering comparisons, we sometimes need to perform two compares instead
 275 // of just one. Get the condition codes for both comparisons. If only one is
 276 // needed, the second member of the pair is ARMCC::AL.
 277 static std::pair<ARMCC::CondCodes, ARMCC::CondCodes>
 278 getComparePreds(CmpInst::Predicate Pred) {
 279   std::pair<ARMCC::CondCodes, ARMCC::CondCodes> Preds = {ARMCC::AL, ARMCC::AL};
 280   switch (Pred) {
 281   case CmpInst::FCMP_ONE:
 282     Preds = {ARMCC::GT, ARMCC::MI};
 283     break;
 284   case CmpInst::FCMP_UEQ:
 285     Preds = {ARMCC::EQ, ARMCC::VS};
 286     break;
 287   case CmpInst::ICMP_EQ:
 288   case CmpInst::FCMP_OEQ:
 289     Preds.first = ARMCC::EQ;
 290     break;
 291   case CmpInst::ICMP_SGT:
 292   case CmpInst::FCMP_OGT:
 293     Preds.first = ARMCC::GT;
 294     break;
 295   case CmpInst::ICMP_SGE:
 296   case CmpInst::FCMP_OGE:
 297     Preds.first = ARMCC::GE;
 298     break;
 299   case CmpInst::ICMP_UGT:
 300   case CmpInst::FCMP_UGT:
 301     Preds.first = ARMCC::HI;
 302     break;
 303   case CmpInst::FCMP_OLT:
 304     Preds.first = ARMCC::MI;
 305     break;
 306   case CmpInst::ICMP_ULE:
 307   case CmpInst::FCMP_OLE:
 308     Preds.first = ARMCC::LS;
 309     break;
 310   case CmpInst::FCMP_ORD:
 311     Preds.first = ARMCC::VC;
 312     break;
 313   case CmpInst::FCMP_UNO:
 314     Preds.first = ARMCC::VS;
 315     break;
 316   case CmpInst::FCMP_UGE:
 317     Preds.first = ARMCC::PL;
 318     break;
 319   case CmpInst::ICMP_SLT:
 320   case CmpInst::FCMP_ULT:
 321     Preds.first = ARMCC::LT;
 322     break;
 323   case CmpInst::ICMP_SLE:
 324   case CmpInst::FCMP_ULE:
 325     Preds.first = ARMCC::LE;
 326     break;
 327   case CmpInst::FCMP_UNE:
 328   case CmpInst::ICMP_NE:
 329     Preds.first = ARMCC::NE;
 330     break;
 331   case CmpInst::ICMP_UGE:
 332     Preds.first = ARMCC::HS;
 333     break;
 334   case CmpInst::ICMP_ULT:
 335     Preds.first = ARMCC::LO;
 336     break;
 337   default:
 338     break;
 339   }
 340   assert(Preds.first != ARMCC::AL && "No comparisons needed?");
 341   return Preds;
 342 }
 343
 344 struct ARMInstructionSelector::CmpConstants {
 345   CmpConstants(unsigned CmpOpcode, unsigned FlagsOpcode, unsigned OpRegBank,
 346                unsigned OpSize)
 347       : ComparisonOpcode(CmpOpcode), ReadFlagsOpcode(FlagsOpcode),
 348         OperandRegBankID(OpRegBank), OperandSize(OpSize) {}
 349
 350   // The opcode used for performing the comparison.
 351   const unsigned ComparisonOpcode;
 352
 353   // The opcode used for reading the flags set by the comparison. May be
 354   // ARM::INSTRUCTION_LIST_END if we don't need to read the flags.
 355   const unsigned ReadFlagsOpcode;
 356
 357   // The assumed register bank ID for the operands.
 358   const unsigned OperandRegBankID;
 359
 360   // The assumed size in bits for the operands.
 361   const unsigned OperandSize;
 362 };
 363
 364 struct ARMInstructionSelector::InsertInfo {
 365   InsertInfo(MachineInstrBuilder &MIB)
 366       : MBB(*MIB->getParent()), InsertBefore(std::next(MIB->getIterator())),
 367         DbgLoc(MIB->getDebugLoc()) {}
 368
 369   MachineBasicBlock &MBB;
 370   const MachineBasicBlock::instr_iterator InsertBefore;
 371   const DebugLoc &DbgLoc;
 372 };
 373
 374 void ARMInstructionSelector::putConstant(InsertInfo I, unsigned DestReg,
 375                                          unsigned Constant) const {
 376   (void)BuildMI(I.MBB, I.InsertBefore, I.DbgLoc, TII.get(ARM::MOVi))
 377       .addDef(DestReg)
 378       .addImm(Constant)
 379       .add(predOps(ARMCC::AL))
 380       .add(condCodeOp());
 381 }
 382
 383 bool ARMInstructionSelector::validOpRegPair(MachineRegisterInfo &MRI,
 384                                             unsigned LHSReg, unsigned RHSReg,
 385                                             unsigned ExpectedSize,
 386                                             unsigned ExpectedRegBankID) const {
 387   return MRI.getType(LHSReg) == MRI.getType(RHSReg) &&
 388          validReg(MRI, LHSReg, ExpectedSize, ExpectedRegBankID) &&
 389          validReg(MRI, RHSReg, ExpectedSize, ExpectedRegBankID);
 390 }
 391
 392 bool ARMInstructionSelector::validReg(MachineRegisterInfo &MRI, unsigned Reg,
 393                                       unsigned ExpectedSize,
 394                                       unsigned ExpectedRegBankID) const {
 395   if (MRI.getType(Reg).getSizeInBits() != ExpectedSize) {
 396     DEBUG(dbgs() << "Unexpected size for register");
 397     return false;
 398   }
 399
 400   if (RBI.getRegBank(Reg, MRI, TRI)->getID() != ExpectedRegBankID) {
 401     DEBUG(dbgs() << "Unexpected register bank for register");
 402     return false;
 403   }
 404
 405   return true;
 406 }
 407
 408 bool ARMInstructionSelector::selectCmp(CmpConstants Helper,
 409                                        MachineInstrBuilder &MIB,
 410                                        MachineRegisterInfo &MRI) const {
 411   const InsertInfo I(MIB);
 412
 413   auto ResReg = MIB->getOperand(0).getReg();
 414   if (!validReg(MRI, ResReg, 1, ARM::GPRRegBankID))
 415     return false;
 416
 417   auto Cond =
 418       static_cast<CmpInst::Predicate>(MIB->getOperand(1).getPredicate());
 419   if (Cond == CmpInst::FCMP_TRUE || Cond == CmpInst::FCMP_FALSE) {
 420     putConstant(I, ResReg, Cond == CmpInst::FCMP_TRUE ? 1 : 0);
 421     MIB->eraseFromParent();
 422     return true;
 423   }
 424
 425   auto LHSReg = MIB->getOperand(2).getReg();
 426   auto RHSReg = MIB->getOperand(3).getReg();
 427   if (!validOpRegPair(MRI, LHSReg, RHSReg, Helper.OperandSize,
 428                       Helper.OperandRegBankID))
 429     return false;
 430
 431   auto ARMConds = getComparePreds(Cond);
 432   auto ZeroReg = MRI.createVirtualRegister(&ARM::GPRRegClass);
 433   putConstant(I, ZeroReg, 0);
 434
 435   if (ARMConds.second == ARMCC::AL) {
 436     // Simple case, we only need one comparison and we're done.
 437     if (!insertComparison(Helper, I, ResReg, ARMConds.first, LHSReg, RHSReg,
 438                           ZeroReg))
 439       return false;
 440   } else {
 441     // Not so simple, we need two successive comparisons.
 442     auto IntermediateRes = MRI.createVirtualRegister(&ARM::GPRRegClass);
 443     if (!insertComparison(Helper, I, IntermediateRes, ARMConds.first, LHSReg,
 444                           RHSReg, ZeroReg))
 445       return false;
 446     if (!insertComparison(Helper, I, ResReg, ARMConds.second, LHSReg, RHSReg,
 447                           IntermediateRes))
 448       return false;
 449   }
 450
 451   MIB->eraseFromParent();
 452   return true;
 453 }
 454
 455 bool ARMInstructionSelector::insertComparison(CmpConstants Helper, InsertInfo I,
 456                                               unsigned ResReg,
 457                                               ARMCC::CondCodes Cond,
 458                                               unsigned LHSReg, unsigned RHSReg,
 459                                               unsigned PrevRes) const {
 460   // Perform the comparison.
 461   auto CmpI =
 462       BuildMI(I.MBB, I.InsertBefore, I.DbgLoc, TII.get(Helper.ComparisonOpcode))
 463           .addUse(LHSReg)
 464           .addUse(RHSReg)
 465           .add(predOps(ARMCC::AL));
 466   if (!constrainSelectedInstRegOperands(*CmpI, TII, TRI, RBI))
 467     return false;
 468
 469   // Read the comparison flags (if necessary).
 470   if (Helper.ReadFlagsOpcode != ARM::INSTRUCTION_LIST_END) {
 471     auto ReadI = BuildMI(I.MBB, I.InsertBefore, I.DbgLoc,
 472                          TII.get(Helper.ReadFlagsOpcode))
 473                      .add(predOps(ARMCC::AL));
 474     if (!constrainSelectedInstRegOperands(*ReadI, TII, TRI, RBI))
 475       return false;
 476   }
 477
 478   // Select either 1 or the previous result based on the value of the flags.
 479   auto Mov1I = BuildMI(I.MBB, I.InsertBefore, I.DbgLoc, TII.get(ARM::MOVCCi))
 480                    .addDef(ResReg)
 481                    .addUse(PrevRes)
 482                    .addImm(1)
 483                    .add(predOps(Cond, ARM::CPSR));
 484   if (!constrainSelectedInstRegOperands(*Mov1I, TII, TRI, RBI))
 485     return false;
 486
 487   return true;
 488 }
 489
 490 bool ARMInstructionSelector::selectGlobal(MachineInstrBuilder &MIB,
 491                                           MachineRegisterInfo &MRI) const {
 492   if ((STI.isROPI() || STI.isRWPI()) && !STI.isTargetELF()) {
 493     DEBUG(dbgs() << "ROPI and RWPI only supported for ELF\n");
 494     return false;
 495   }
 496
 497   auto GV = MIB->getOperand(1).getGlobal();
 498   if (GV->isThreadLocal()) {
 499     DEBUG(dbgs() << "TLS variables not supported yet\n");
 500     return false;
 501   }
 502
 503   auto &MBB = *MIB->getParent();
 504   auto &MF = *MBB.getParent();
 505
 506   bool UseMovt = STI.useMovt(MF);
 507
 508   unsigned Size = TM.getPointerSize();
 509   unsigned Alignment = 4;
 510
 511   auto addOpsForConstantPoolLoad = [&MF, Alignment,
 512                                     Size](MachineInstrBuilder &MIB,
 513                                           const GlobalValue *GV, bool IsSBREL) {
 514     assert(MIB->getOpcode() == ARM::LDRi12 && "Unsupported instruction");
 515     auto ConstPool = MF.getConstantPool();
 516     auto CPIndex =
 517         // For SB relative entries we need a target-specific constant pool.
 518         // Otherwise, just use a regular constant pool entry.
 519         IsSBREL
 520             ? ConstPool->getConstantPoolIndex(
 521                   ARMConstantPoolConstant::Create(GV, ARMCP::SBREL), Alignment)
 522             : ConstPool->getConstantPoolIndex(GV, Alignment);
 523     MIB.addConstantPoolIndex(CPIndex, /*Offset*/ 0, /*TargetFlags*/ 0)
 524         .addMemOperand(
 525             MF.getMachineMemOperand(MachinePointerInfo::getConstantPool(MF),
 526                                     MachineMemOperand::MOLoad, Size, Alignment))
 527         .addImm(0)
 528         .add(predOps(ARMCC::AL));
 529   };
 530
 531   if (TM.isPositionIndependent()) {
 532     bool Indirect = STI.isGVIndirectSymbol(GV);
 533     // FIXME: Taking advantage of MOVT for ELF is pretty involved, so we don't
 534     // support it yet. See PR28229.
 535     unsigned Opc =
 536         UseMovt && !STI.isTargetELF()
 537             ? (Indirect ? ARM::MOV_ga_pcrel_ldr : ARM::MOV_ga_pcrel)
 538             : (Indirect ? ARM::LDRLIT_ga_pcrel_ldr : ARM::LDRLIT_ga_pcrel);
 539     MIB->setDesc(TII.get(Opc));
 540
 541     int TargetFlags = ARMII::MO_NO_FLAG;
 542     if (STI.isTargetDarwin())
 543       TargetFlags |= ARMII::MO_NONLAZY;
 544     if (STI.isGVInGOT(GV))
 545       TargetFlags |= ARMII::MO_GOT;
 546     MIB->getOperand(1).setTargetFlags(TargetFlags);
 547
 548     if (Indirect)
 549       MIB.addMemOperand(MF.getMachineMemOperand(
 550           MachinePointerInfo::getGOT(MF), MachineMemOperand::MOLoad,
 551           TM.getPointerSize(), Alignment));
 552
 553     return constrainSelectedInstRegOperands(*MIB, TII, TRI, RBI);
 554   }
 555
 556   bool isReadOnly = STI.getTargetLowering()->isReadOnly(GV);
 557   if (STI.isROPI() && isReadOnly) {
 558     unsigned Opc = UseMovt ? ARM::MOV_ga_pcrel : ARM::LDRLIT_ga_pcrel;
 559     MIB->setDesc(TII.get(Opc));
 560     return constrainSelectedInstRegOperands(*MIB, TII, TRI, RBI);
 561   }
 562   if (STI.isRWPI() && !isReadOnly) {
 563     auto Offset = MRI.createVirtualRegister(&ARM::GPRRegClass);
 564     MachineInstrBuilder OffsetMIB;
 565     if (UseMovt) {
 566       OffsetMIB = BuildMI(MBB, *MIB, MIB->getDebugLoc(),
 567                           TII.get(ARM::MOVi32imm), Offset);
 568       OffsetMIB.addGlobalAddress(GV, /*Offset*/ 0, ARMII::MO_SBREL);
 569     } else {
 570       // Load the offset from the constant pool.
 571       OffsetMIB =
 572           BuildMI(MBB, *MIB, MIB->getDebugLoc(), TII.get(ARM::LDRi12), Offset);
 573       addOpsForConstantPoolLoad(OffsetMIB, GV, /*IsSBREL*/ true);
 574     }
 575     if (!constrainSelectedInstRegOperands(*OffsetMIB, TII, TRI, RBI))
 576       return false;
 577
 578     // Add the offset to the SB register.
 579     MIB->setDesc(TII.get(ARM::ADDrr));
 580     MIB->RemoveOperand(1);
 581     MIB.addReg(ARM::R9) // FIXME: don't hardcode R9
 582         .addReg(Offset)
 583         .add(predOps(ARMCC::AL))
 584         .add(condCodeOp());
 585
 586     return constrainSelectedInstRegOperands(*MIB, TII, TRI, RBI);
 587   }
 588
 589   if (STI.isTargetELF()) {
 590     if (UseMovt) {
 591       MIB->setDesc(TII.get(ARM::MOVi32imm));
 592     } else {
 593       // Load the global's address from the constant pool.
 594       MIB->setDesc(TII.get(ARM::LDRi12));
 595       MIB->RemoveOperand(1);
 596       addOpsForConstantPoolLoad(MIB, GV, /*IsSBREL*/ false);
 597     }
 598   } else if (STI.isTargetMachO()) {
 599     if (UseMovt)
 600       MIB->setDesc(TII.get(ARM::MOVi32imm));
 601     else
 602       MIB->setDesc(TII.get(ARM::LDRLIT_ga_abs));
 603   } else {
 604     DEBUG(dbgs() << "Object format not supported yet\n");
 605     return false;
 606   }
 607
 608   return constrainSelectedInstRegOperands(*MIB, TII, TRI, RBI);
 609 }
 610
 611 bool ARMInstructionSelector::selectSelect(MachineInstrBuilder &MIB,
 612                                           MachineRegisterInfo &MRI) const {
 613   auto &MBB = *MIB->getParent();
 614   auto InsertBefore = std::next(MIB->getIterator());
 615   auto &DbgLoc = MIB->getDebugLoc();
 616
 617   // Compare the condition to 0.
 618   auto CondReg = MIB->getOperand(1).getReg();
 619   assert(validReg(MRI, CondReg, 1, ARM::GPRRegBankID) &&
 620          "Unsupported types for select operation");
 621   auto CmpI = BuildMI(MBB, InsertBefore, DbgLoc, TII.get(ARM::CMPri))
 622                   .addUse(CondReg)
 623                   .addImm(0)
 624                   .add(predOps(ARMCC::AL));
 625   if (!constrainSelectedInstRegOperands(*CmpI, TII, TRI, RBI))
 626     return false;
 627
 628   // Move a value into the result register based on the result of the
 629   // comparison.
 630   auto ResReg = MIB->getOperand(0).getReg();
 631   auto TrueReg = MIB->getOperand(2).getReg();
 632   auto FalseReg = MIB->getOperand(3).getReg();
 633   assert(validOpRegPair(MRI, ResReg, TrueReg, 32, ARM::GPRRegBankID) &&
 634          validOpRegPair(MRI, TrueReg, FalseReg, 32, ARM::GPRRegBankID) &&
 635          "Unsupported types for select operation");
 636   auto Mov1I = BuildMI(MBB, InsertBefore, DbgLoc, TII.get(ARM::MOVCCr))
 637                    .addDef(ResReg)
 638                    .addUse(TrueReg)
 639                    .addUse(FalseReg)
 640                    .add(predOps(ARMCC::EQ, ARM::CPSR));
 641   if (!constrainSelectedInstRegOperands(*Mov1I, TII, TRI, RBI))
 642     return false;
 643
 644   MIB->eraseFromParent();
 645   return true;
 646 }
 647
 648 bool ARMInstructionSelector::selectShift(unsigned ShiftOpc,
 649                                          MachineInstrBuilder &MIB) const {
 650   MIB->setDesc(TII.get(ARM::MOVsr));
 651   MIB.addImm(ShiftOpc);
 652   MIB.add(predOps(ARMCC::AL)).add(condCodeOp());
 653   return constrainSelectedInstRegOperands(*MIB, TII, TRI, RBI);
 654 }
 655
 656 bool ARMInstructionSelector::select(MachineInstr &I,
 657                                     CodeGenCoverage &CoverageInfo) const {
 658   assert(I.getParent() && "Instruction should be in a basic block!");
 659   assert(I.getParent()->getParent() && "Instruction should be in a function!");
 660
 661   auto &MBB = *I.getParent();
 662   auto &MF = *MBB.getParent();
 663   auto &MRI = MF.getRegInfo();
 664
 665   if (!isPreISelGenericOpcode(I.getOpcode())) {
 666     if (I.isCopy())
 667       return selectCopy(I, TII, MRI, TRI, RBI);
 668
 669     return true;
 670   }
 671
 672   using namespace TargetOpcode;
 673   if (I.getOpcode() == G_CONSTANT) {
 674     // Pointer constants should be treated the same as 32-bit integer constants.
 675     // Change the type and let TableGen handle it.
 676     unsigned ResultReg = I.getOperand(0).getReg();
 677     LLT Ty = MRI.getType(ResultReg);
 678     if (Ty.isPointer())
 679       MRI.setType(ResultReg, LLT::scalar(32));
 680   }
 681
 682   if (selectImpl(I, CoverageInfo))
 683     return true;
 684
 685   MachineInstrBuilder MIB{MF, I};
 686   bool isSExt = false;
 687
 688   switch (I.getOpcode()) {
 689   case G_SEXT:
 690     isSExt = true;
 691     LLVM_FALLTHROUGH;
 692   case G_ZEXT: {
 693     LLT DstTy = MRI.getType(I.getOperand(0).getReg());
 694     // FIXME: Smaller destination sizes coming soon!
 695     if (DstTy.getSizeInBits() != 32) {
 696       DEBUG(dbgs() << "Unsupported destination size for extension");
 697       return false;
 698     }
 699
 700     LLT SrcTy = MRI.getType(I.getOperand(1).getReg());
 701     unsigned SrcSize = SrcTy.getSizeInBits();
 702     switch (SrcSize) {
 703     case 1: {
 704       // ZExt boils down to & 0x1; for SExt we also subtract that from 0
 705       I.setDesc(TII.get(ARM::ANDri));
 706       MIB.addImm(1).add(predOps(ARMCC::AL)).add(condCodeOp());
 707
 708       if (isSExt) {
 709         unsigned SExtResult = I.getOperand(0).getReg();
 710
 711         // Use a new virtual register for the result of the AND
 712         unsigned AndResult = MRI.createVirtualRegister(&ARM::GPRRegClass);
 713         I.getOperand(0).setReg(AndResult);
 714
 715         auto InsertBefore = std::next(I.getIterator());
 716         auto SubI =
 717             BuildMI(MBB, InsertBefore, I.getDebugLoc(), TII.get(ARM::RSBri))
 718                 .addDef(SExtResult)
 719                 .addUse(AndResult)
 720                 .addImm(0)
 721                 .add(predOps(ARMCC::AL))
 722                 .add(condCodeOp());
 723         if (!constrainSelectedInstRegOperands(*SubI, TII, TRI, RBI))
 724           return false;
 725       }
 726       break;
 727     }
 728     case 8:
 729     case 16: {
 730       unsigned NewOpc = selectSimpleExtOpc(I.getOpcode(), SrcSize);
 731       if (NewOpc == I.getOpcode())
 732         return false;
 733       I.setDesc(TII.get(NewOpc));
 734       MIB.addImm(0).add(predOps(ARMCC::AL));
 735       break;
 736     }
 737     default:
 738       DEBUG(dbgs() << "Unsupported source size for extension");
 739       return false;
 740     }
 741     break;
 742   }
 743   case G_ANYEXT:
 744   case G_TRUNC: {
 745     // The high bits are undefined, so there's nothing special to do, just
 746     // treat it as a copy.
 747     auto SrcReg = I.getOperand(1).getReg();
 748     auto DstReg = I.getOperand(0).getReg();
 749
 750     const auto &SrcRegBank = *RBI.getRegBank(SrcReg, MRI, TRI);
 751     const auto &DstRegBank = *RBI.getRegBank(DstReg, MRI, TRI);
 752
 753     if (SrcRegBank.getID() == ARM::FPRRegBankID) {
 754       // This should only happen in the obscure case where we have put a 64-bit
 755       // integer into a D register. Get it out of there and keep only the
 756       // interesting part.
 757       assert(I.getOpcode() == G_TRUNC && "Unsupported operand for G_ANYEXT");
 758       assert(DstRegBank.getID() == ARM::GPRRegBankID &&
 759              "Unsupported combination of register banks");
 760       assert(MRI.getType(SrcReg).getSizeInBits() == 64 && "Unsupported size");
 761       assert(MRI.getType(DstReg).getSizeInBits() <= 32 && "Unsupported size");
 762
 763       unsigned IgnoredBits = MRI.createVirtualRegister(&ARM::GPRRegClass);
 764       auto InsertBefore = std::next(I.getIterator());
 765       auto MovI =
 766           BuildMI(MBB, InsertBefore, I.getDebugLoc(), TII.get(ARM::VMOVRRD))
 767               .addDef(DstReg)
 768               .addDef(IgnoredBits)
 769               .addUse(SrcReg)
 770               .add(predOps(ARMCC::AL));
 771       if (!constrainSelectedInstRegOperands(*MovI, TII, TRI, RBI))
 772         return false;
 773
 774       MIB->eraseFromParent();
 775       return true;
 776     }
 777
 778     if (SrcRegBank.getID() != DstRegBank.getID()) {
 779       DEBUG(dbgs() << "G_TRUNC/G_ANYEXT operands on different register banks\n");
 780       return false;
 781     }
 782
 783     if (SrcRegBank.getID() != ARM::GPRRegBankID) {
 784       DEBUG(dbgs() << "G_TRUNC/G_ANYEXT on non-GPR not supported yet\n");
 785       return false;
 786     }
 787
 788     I.setDesc(TII.get(COPY));
 789     return selectCopy(I, TII, MRI, TRI, RBI);
 790   }
 791   case G_INTTOPTR:
 792   case G_PTRTOINT: {
 793     auto SrcReg = I.getOperand(1).getReg();
 794     auto DstReg = I.getOperand(0).getReg();
 795
 796     const auto &SrcRegBank = *RBI.getRegBank(SrcReg, MRI, TRI);
 797     const auto &DstRegBank = *RBI.getRegBank(DstReg, MRI, TRI);
 798
 799     if (SrcRegBank.getID() != DstRegBank.getID()) {
 800       DEBUG(dbgs()
 801             << "G_INTTOPTR/G_PTRTOINT operands on different register banks\n");
 802       return false;
 803     }
 804
 805     if (SrcRegBank.getID() != ARM::GPRRegBankID) {
 806       DEBUG(dbgs() << "G_INTTOPTR/G_PTRTOINT on non-GPR not supported yet\n");
 807       return false;
 808     }
 809
 810     I.setDesc(TII.get(COPY));
 811     return selectCopy(I, TII, MRI, TRI, RBI);
 812   }
 813   case G_SELECT:
 814     return selectSelect(MIB, MRI);
 815   case G_ICMP: {
 816     CmpConstants Helper(ARM::CMPrr, ARM::INSTRUCTION_LIST_END,
 817                         ARM::GPRRegBankID, 32);
 818     return selectCmp(Helper, MIB, MRI);
 819   }
 820   case G_FCMP: {
 821     assert(STI.hasVFP2() && "Can't select fcmp without VFP");
 822
 823     unsigned OpReg = I.getOperand(2).getReg();
 824     unsigned Size = MRI.getType(OpReg).getSizeInBits();
 825
 826     if (Size == 64 && STI.isFPOnlySP()) {
 827       DEBUG(dbgs() << "Subtarget only supports single precision");
 828       return false;
 829     }
 830     if (Size != 32 && Size != 64) {
 831       DEBUG(dbgs() << "Unsupported size for G_FCMP operand");
 832       return false;
 833     }
 834
 835     CmpConstants Helper(Size == 32 ? ARM::VCMPS : ARM::VCMPD, ARM::FMSTAT,
 836                         ARM::FPRRegBankID, Size);
 837     return selectCmp(Helper, MIB, MRI);
 838   }
 839   case G_LSHR:
 840     return selectShift(ARM_AM::ShiftOpc::lsr, MIB);
 841   case G_ASHR:
 842     return selectShift(ARM_AM::ShiftOpc::asr, MIB);
 843   case G_SHL: {
 844     return selectShift(ARM_AM::ShiftOpc::lsl, MIB);
 845   }
 846   case G_GEP:
 847     I.setDesc(TII.get(ARM::ADDrr));
 848     MIB.add(predOps(ARMCC::AL)).add(condCodeOp());
 849     break;
 850   case G_FRAME_INDEX:
 851     // Add 0 to the given frame index and hope it will eventually be folded into
 852     // the user(s).
 853     I.setDesc(TII.get(ARM::ADDri));
 854     MIB.addImm(0).add(predOps(ARMCC::AL)).add(condCodeOp());
 855     break;
 856   case G_GLOBAL_VALUE:
 857     return selectGlobal(MIB, MRI);
 858   case G_STORE:
 859   case G_LOAD: {
 860     const auto &MemOp = **I.memoperands_begin();
 861     if (MemOp.getOrdering() != AtomicOrdering::NotAtomic) {
 862       DEBUG(dbgs() << "Atomic load/store not supported yet\n");
 863       return false;
 864     }
 865
 866     unsigned Reg = I.getOperand(0).getReg();
 867     unsigned RegBank = RBI.getRegBank(Reg, MRI, TRI)->getID();
 868
 869     LLT ValTy = MRI.getType(Reg);
 870     const auto ValSize = ValTy.getSizeInBits();
 871
 872     assert((ValSize != 64 || STI.hasVFP2()) &&
 873            "Don't know how to load/store 64-bit value without VFP");
 874
 875     const auto NewOpc = selectLoadStoreOpCode(I.getOpcode(), RegBank, ValSize);
 876     if (NewOpc == G_LOAD || NewOpc == G_STORE)
 877       return false;
 878
 879     I.setDesc(TII.get(NewOpc));
 880
 881     if (NewOpc == ARM::LDRH || NewOpc == ARM::STRH)
 882       // LDRH has a funny addressing mode (there's already a FIXME for it).
 883       MIB.addReg(0);
 884     MIB.addImm(0).add(predOps(ARMCC::AL));
 885     break;
 886   }
 887   case G_MERGE_VALUES: {
 888     if (!selectMergeValues(MIB, TII, MRI, TRI, RBI))
 889       return false;
 890     break;
 891   }
 892   case G_UNMERGE_VALUES: {
 893     if (!selectUnmergeValues(MIB, TII, MRI, TRI, RBI))
 894       return false;
 895     break;
 896   }
 897   case G_BRCOND: {
 898     if (!validReg(MRI, I.getOperand(0).getReg(), 1, ARM::GPRRegBankID)) {
 899       DEBUG(dbgs() << "Unsupported condition register for G_BRCOND");
 900       return false;
 901     }
 902
 903     // Set the flags.
 904     auto Test = BuildMI(*I.getParent(), I, I.getDebugLoc(), TII.get(ARM::TSTri))
 905                     .addReg(I.getOperand(0).getReg())
 906                     .addImm(1)
 907                     .add(predOps(ARMCC::AL));
 908     if (!constrainSelectedInstRegOperands(*Test, TII, TRI, RBI))
 909       return false;
 910
 911     // Branch conditionally.
 912     auto Branch = BuildMI(*I.getParent(), I, I.getDebugLoc(), TII.get(ARM::Bcc))
 913                       .add(I.getOperand(1))
 914                       .add(predOps(ARMCC::NE, ARM::CPSR));
 915     if (!constrainSelectedInstRegOperands(*Branch, TII, TRI, RBI))
 916       return false;
 917     I.eraseFromParent();
 918     return true;
 919   }
 920   default:
 921     return false;
 922   }
 923
 924   return constrainSelectedInstRegOperands(I, TII, TRI, RBI);
 925 }