contrib/llvm/lib/Target/AArch64/AArch64LoadStoreOptimizer.cpp

   1 //=- AArch64LoadStoreOptimizer.cpp - AArch64 load/store opt. pass -*- 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 // This file contains a pass that performs load / store related peephole
  11 // optimizations. This pass should be run after register allocation.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "AArch64InstrInfo.h"
  16 #include "AArch64Subtarget.h"
  17 #include "MCTargetDesc/AArch64AddressingModes.h"
  18 #include "llvm/ADT/BitVector.h"
  19 #include "llvm/ADT/SmallVector.h"
  20 #include "llvm/ADT/Statistic.h"
  21 #include "llvm/CodeGen/MachineBasicBlock.h"
  22 #include "llvm/CodeGen/MachineFunctionPass.h"
  23 #include "llvm/CodeGen/MachineInstr.h"
  24 #include "llvm/CodeGen/MachineInstrBuilder.h"
  25 #include "llvm/Support/CommandLine.h"
  26 #include "llvm/Support/Debug.h"
  27 #include "llvm/Support/ErrorHandling.h"
  28 #include "llvm/Support/raw_ostream.h"
  29 #include "llvm/Target/TargetInstrInfo.h"
  30 #include "llvm/Target/TargetMachine.h"
  31 #include "llvm/Target/TargetRegisterInfo.h"
  32 using namespace llvm;
  33
  34 #define DEBUG_TYPE "aarch64-ldst-opt"
  35
  36 STATISTIC(NumPairCreated, "Number of load/store pair instructions generated");
  37 STATISTIC(NumPostFolded, "Number of post-index updates folded");
  38 STATISTIC(NumPreFolded, "Number of pre-index updates folded");
  39 STATISTIC(NumUnscaledPairCreated,
  40           "Number of load/store from unscaled generated");
  41 STATISTIC(NumZeroStoresPromoted, "Number of narrow zero stores promoted");
  42 STATISTIC(NumLoadsFromStoresPromoted, "Number of loads from stores promoted");
  43
  44 // The LdStLimit limits how far we search for load/store pairs.
  45 static cl::opt<unsigned> LdStLimit("aarch64-load-store-scan-limit",
  46                                    cl::init(20), cl::Hidden);
  47
  48 // The UpdateLimit limits how far we search for update instructions when we form
  49 // pre-/post-index instructions.
  50 static cl::opt<unsigned> UpdateLimit("aarch64-update-scan-limit", cl::init(100),
  51                                      cl::Hidden);
  52
  53 #define AARCH64_LOAD_STORE_OPT_NAME "AArch64 load / store optimization pass"
  54
  55 namespace {
  56
  57 typedef struct LdStPairFlags {
  58   // If a matching instruction is found, MergeForward is set to true if the
  59   // merge is to remove the first instruction and replace the second with
  60   // a pair-wise insn, and false if the reverse is true.
  61   bool MergeForward;
  62
  63   // SExtIdx gives the index of the result of the load pair that must be
  64   // extended. The value of SExtIdx assumes that the paired load produces the
  65   // value in this order: (I, returned iterator), i.e., -1 means no value has
  66   // to be extended, 0 means I, and 1 means the returned iterator.
  67   int SExtIdx;
  68
  69   LdStPairFlags() : MergeForward(false), SExtIdx(-1) {}
  70
  71   void setMergeForward(bool V = true) { MergeForward = V; }
  72   bool getMergeForward() const { return MergeForward; }
  73
  74   void setSExtIdx(int V) { SExtIdx = V; }
  75   int getSExtIdx() const { return SExtIdx; }
  76
  77 } LdStPairFlags;
  78
  79 struct AArch64LoadStoreOpt : public MachineFunctionPass {
  80   static char ID;
  81   AArch64LoadStoreOpt() : MachineFunctionPass(ID) {
  82     initializeAArch64LoadStoreOptPass(*PassRegistry::getPassRegistry());
  83   }
  84
  85   const AArch64InstrInfo *TII;
  86   const TargetRegisterInfo *TRI;
  87   const AArch64Subtarget *Subtarget;
  88
  89   // Track which registers have been modified and used.
  90   BitVector ModifiedRegs, UsedRegs;
  91
  92   // Scan the instructions looking for a load/store that can be combined
  93   // with the current instruction into a load/store pair.
  94   // Return the matching instruction if one is found, else MBB->end().
  95   MachineBasicBlock::iterator findMatchingInsn(MachineBasicBlock::iterator I,
  96                                                LdStPairFlags &Flags,
  97                                                unsigned Limit,
  98                                                bool FindNarrowMerge);
  99
 100   // Scan the instructions looking for a store that writes to the address from
 101   // which the current load instruction reads. Return true if one is found.
 102   bool findMatchingStore(MachineBasicBlock::iterator I, unsigned Limit,
 103                          MachineBasicBlock::iterator &StoreI);
 104
 105   // Merge the two instructions indicated into a wider narrow store instruction.
 106   MachineBasicBlock::iterator
 107   mergeNarrowZeroStores(MachineBasicBlock::iterator I,
 108                         MachineBasicBlock::iterator MergeMI,
 109                         const LdStPairFlags &Flags);
 110
 111   // Merge the two instructions indicated into a single pair-wise instruction.
 112   MachineBasicBlock::iterator
 113   mergePairedInsns(MachineBasicBlock::iterator I,
 114                    MachineBasicBlock::iterator Paired,
 115                    const LdStPairFlags &Flags);
 116
 117   // Promote the load that reads directly from the address stored to.
 118   MachineBasicBlock::iterator
 119   promoteLoadFromStore(MachineBasicBlock::iterator LoadI,
 120                        MachineBasicBlock::iterator StoreI);
 121
 122   // Scan the instruction list to find a base register update that can
 123   // be combined with the current instruction (a load or store) using
 124   // pre or post indexed addressing with writeback. Scan forwards.
 125   MachineBasicBlock::iterator
 126   findMatchingUpdateInsnForward(MachineBasicBlock::iterator I,
 127                                 int UnscaledOffset, unsigned Limit);
 128
 129   // Scan the instruction list to find a base register update that can
 130   // be combined with the current instruction (a load or store) using
 131   // pre or post indexed addressing with writeback. Scan backwards.
 132   MachineBasicBlock::iterator
 133   findMatchingUpdateInsnBackward(MachineBasicBlock::iterator I, unsigned Limit);
 134
 135   // Find an instruction that updates the base register of the ld/st
 136   // instruction.
 137   bool isMatchingUpdateInsn(MachineInstr &MemMI, MachineInstr &MI,
 138                             unsigned BaseReg, int Offset);
 139
 140   // Merge a pre- or post-index base register update into a ld/st instruction.
 141   MachineBasicBlock::iterator
 142   mergeUpdateInsn(MachineBasicBlock::iterator I,
 143                   MachineBasicBlock::iterator Update, bool IsPreIdx);
 144
 145   // Find and merge zero store instructions.
 146   bool tryToMergeZeroStInst(MachineBasicBlock::iterator &MBBI);
 147
 148   // Find and pair ldr/str instructions.
 149   bool tryToPairLdStInst(MachineBasicBlock::iterator &MBBI);
 150
 151   // Find and promote load instructions which read directly from store.
 152   bool tryToPromoteLoadFromStore(MachineBasicBlock::iterator &MBBI);
 153
 154   bool optimizeBlock(MachineBasicBlock &MBB, bool EnableNarrowZeroStOpt);
 155
 156   bool runOnMachineFunction(MachineFunction &Fn) override;
 157
 158   MachineFunctionProperties getRequiredProperties() const override {
 159     return MachineFunctionProperties().set(
 160         MachineFunctionProperties::Property::NoVRegs);
 161   }
 162
 163   StringRef getPassName() const override { return AARCH64_LOAD_STORE_OPT_NAME; }
 164 };
 165 char AArch64LoadStoreOpt::ID = 0;
 166 } // namespace
 167
 168 INITIALIZE_PASS(AArch64LoadStoreOpt, "aarch64-ldst-opt",
 169                 AARCH64_LOAD_STORE_OPT_NAME, false, false)
 170
 171 static bool isNarrowStore(unsigned Opc) {
 172   switch (Opc) {
 173   default:
 174     return false;
 175   case AArch64::STRBBui:
 176   case AArch64::STURBBi:
 177   case AArch64::STRHHui:
 178   case AArch64::STURHHi:
 179     return true;
 180   }
 181 }
 182
 183 // Scaling factor for unscaled load or store.
 184 static int getMemScale(MachineInstr &MI) {
 185   switch (MI.getOpcode()) {
 186   default:
 187     llvm_unreachable("Opcode has unknown scale!");
 188   case AArch64::LDRBBui:
 189   case AArch64::LDURBBi:
 190   case AArch64::LDRSBWui:
 191   case AArch64::LDURSBWi:
 192   case AArch64::STRBBui:
 193   case AArch64::STURBBi:
 194     return 1;
 195   case AArch64::LDRHHui:
 196   case AArch64::LDURHHi:
 197   case AArch64::LDRSHWui:
 198   case AArch64::LDURSHWi:
 199   case AArch64::STRHHui:
 200   case AArch64::STURHHi:
 201     return 2;
 202   case AArch64::LDRSui:
 203   case AArch64::LDURSi:
 204   case AArch64::LDRSWui:
 205   case AArch64::LDURSWi:
 206   case AArch64::LDRWui:
 207   case AArch64::LDURWi:
 208   case AArch64::STRSui:
 209   case AArch64::STURSi:
 210   case AArch64::STRWui:
 211   case AArch64::STURWi:
 212   case AArch64::LDPSi:
 213   case AArch64::LDPSWi:
 214   case AArch64::LDPWi:
 215   case AArch64::STPSi:
 216   case AArch64::STPWi:
 217     return 4;
 218   case AArch64::LDRDui:
 219   case AArch64::LDURDi:
 220   case AArch64::LDRXui:
 221   case AArch64::LDURXi:
 222   case AArch64::STRDui:
 223   case AArch64::STURDi:
 224   case AArch64::STRXui:
 225   case AArch64::STURXi:
 226   case AArch64::LDPDi:
 227   case AArch64::LDPXi:
 228   case AArch64::STPDi:
 229   case AArch64::STPXi:
 230     return 8;
 231   case AArch64::LDRQui:
 232   case AArch64::LDURQi:
 233   case AArch64::STRQui:
 234   case AArch64::STURQi:
 235   case AArch64::LDPQi:
 236   case AArch64::STPQi:
 237     return 16;
 238   }
 239 }
 240
 241 static unsigned getMatchingNonSExtOpcode(unsigned Opc,
 242                                          bool *IsValidLdStrOpc = nullptr) {
 243   if (IsValidLdStrOpc)
 244     *IsValidLdStrOpc = true;
 245   switch (Opc) {
 246   default:
 247     if (IsValidLdStrOpc)
 248       *IsValidLdStrOpc = false;
 249     return UINT_MAX;
 250   case AArch64::STRDui:
 251   case AArch64::STURDi:
 252   case AArch64::STRQui:
 253   case AArch64::STURQi:
 254   case AArch64::STRBBui:
 255   case AArch64::STURBBi:
 256   case AArch64::STRHHui:
 257   case AArch64::STURHHi:
 258   case AArch64::STRWui:
 259   case AArch64::STURWi:
 260   case AArch64::STRXui:
 261   case AArch64::STURXi:
 262   case AArch64::LDRDui:
 263   case AArch64::LDURDi:
 264   case AArch64::LDRQui:
 265   case AArch64::LDURQi:
 266   case AArch64::LDRWui:
 267   case AArch64::LDURWi:
 268   case AArch64::LDRXui:
 269   case AArch64::LDURXi:
 270   case AArch64::STRSui:
 271   case AArch64::STURSi:
 272   case AArch64::LDRSui:
 273   case AArch64::LDURSi:
 274     return Opc;
 275   case AArch64::LDRSWui:
 276     return AArch64::LDRWui;
 277   case AArch64::LDURSWi:
 278     return AArch64::LDURWi;
 279   }
 280 }
 281
 282 static unsigned getMatchingWideOpcode(unsigned Opc) {
 283   switch (Opc) {
 284   default:
 285     llvm_unreachable("Opcode has no wide equivalent!");
 286   case AArch64::STRBBui:
 287     return AArch64::STRHHui;
 288   case AArch64::STRHHui:
 289     return AArch64::STRWui;
 290   case AArch64::STURBBi:
 291     return AArch64::STURHHi;
 292   case AArch64::STURHHi:
 293     return AArch64::STURWi;
 294   case AArch64::STURWi:
 295     return AArch64::STURXi;
 296   case AArch64::STRWui:
 297     return AArch64::STRXui;
 298   }
 299 }
 300
 301 static unsigned getMatchingPairOpcode(unsigned Opc) {
 302   switch (Opc) {
 303   default:
 304     llvm_unreachable("Opcode has no pairwise equivalent!");
 305   case AArch64::STRSui:
 306   case AArch64::STURSi:
 307     return AArch64::STPSi;
 308   case AArch64::STRDui:
 309   case AArch64::STURDi:
 310     return AArch64::STPDi;
 311   case AArch64::STRQui:
 312   case AArch64::STURQi:
 313     return AArch64::STPQi;
 314   case AArch64::STRWui:
 315   case AArch64::STURWi:
 316     return AArch64::STPWi;
 317   case AArch64::STRXui:
 318   case AArch64::STURXi:
 319     return AArch64::STPXi;
 320   case AArch64::LDRSui:
 321   case AArch64::LDURSi:
 322     return AArch64::LDPSi;
 323   case AArch64::LDRDui:
 324   case AArch64::LDURDi:
 325     return AArch64::LDPDi;
 326   case AArch64::LDRQui:
 327   case AArch64::LDURQi:
 328     return AArch64::LDPQi;
 329   case AArch64::LDRWui:
 330   case AArch64::LDURWi:
 331     return AArch64::LDPWi;
 332   case AArch64::LDRXui:
 333   case AArch64::LDURXi:
 334     return AArch64::LDPXi;
 335   case AArch64::LDRSWui:
 336   case AArch64::LDURSWi:
 337     return AArch64::LDPSWi;
 338   }
 339 }
 340
 341 static unsigned isMatchingStore(MachineInstr &LoadInst,
 342                                 MachineInstr &StoreInst) {
 343   unsigned LdOpc = LoadInst.getOpcode();
 344   unsigned StOpc = StoreInst.getOpcode();
 345   switch (LdOpc) {
 346   default:
 347     llvm_unreachable("Unsupported load instruction!");
 348   case AArch64::LDRBBui:
 349     return StOpc == AArch64::STRBBui || StOpc == AArch64::STRHHui ||
 350            StOpc == AArch64::STRWui || StOpc == AArch64::STRXui;
 351   case AArch64::LDURBBi:
 352     return StOpc == AArch64::STURBBi || StOpc == AArch64::STURHHi ||
 353            StOpc == AArch64::STURWi || StOpc == AArch64::STURXi;
 354   case AArch64::LDRHHui:
 355     return StOpc == AArch64::STRHHui || StOpc == AArch64::STRWui ||
 356            StOpc == AArch64::STRXui;
 357   case AArch64::LDURHHi:
 358     return StOpc == AArch64::STURHHi || StOpc == AArch64::STURWi ||
 359            StOpc == AArch64::STURXi;
 360   case AArch64::LDRWui:
 361     return StOpc == AArch64::STRWui || StOpc == AArch64::STRXui;
 362   case AArch64::LDURWi:
 363     return StOpc == AArch64::STURWi || StOpc == AArch64::STURXi;
 364   case AArch64::LDRXui:
 365     return StOpc == AArch64::STRXui;
 366   case AArch64::LDURXi:
 367     return StOpc == AArch64::STURXi;
 368   }
 369 }
 370
 371 static unsigned getPreIndexedOpcode(unsigned Opc) {
 372   switch (Opc) {
 373   default:
 374     llvm_unreachable("Opcode has no pre-indexed equivalent!");
 375   case AArch64::STRSui:
 376     return AArch64::STRSpre;
 377   case AArch64::STRDui:
 378     return AArch64::STRDpre;
 379   case AArch64::STRQui:
 380     return AArch64::STRQpre;
 381   case AArch64::STRBBui:
 382     return AArch64::STRBBpre;
 383   case AArch64::STRHHui:
 384     return AArch64::STRHHpre;
 385   case AArch64::STRWui:
 386     return AArch64::STRWpre;
 387   case AArch64::STRXui:
 388     return AArch64::STRXpre;
 389   case AArch64::LDRSui:
 390     return AArch64::LDRSpre;
 391   case AArch64::LDRDui:
 392     return AArch64::LDRDpre;
 393   case AArch64::LDRQui:
 394     return AArch64::LDRQpre;
 395   case AArch64::LDRBBui:
 396     return AArch64::LDRBBpre;
 397   case AArch64::LDRHHui:
 398     return AArch64::LDRHHpre;
 399   case AArch64::LDRWui:
 400     return AArch64::LDRWpre;
 401   case AArch64::LDRXui:
 402     return AArch64::LDRXpre;
 403   case AArch64::LDRSWui:
 404     return AArch64::LDRSWpre;
 405   case AArch64::LDPSi:
 406     return AArch64::LDPSpre;
 407   case AArch64::LDPSWi:
 408     return AArch64::LDPSWpre;
 409   case AArch64::LDPDi:
 410     return AArch64::LDPDpre;
 411   case AArch64::LDPQi:
 412     return AArch64::LDPQpre;
 413   case AArch64::LDPWi:
 414     return AArch64::LDPWpre;
 415   case AArch64::LDPXi:
 416     return AArch64::LDPXpre;
 417   case AArch64::STPSi:
 418     return AArch64::STPSpre;
 419   case AArch64::STPDi:
 420     return AArch64::STPDpre;
 421   case AArch64::STPQi:
 422     return AArch64::STPQpre;
 423   case AArch64::STPWi:
 424     return AArch64::STPWpre;
 425   case AArch64::STPXi:
 426     return AArch64::STPXpre;
 427   }
 428 }
 429
 430 static unsigned getPostIndexedOpcode(unsigned Opc) {
 431   switch (Opc) {
 432   default:
 433     llvm_unreachable("Opcode has no post-indexed wise equivalent!");
 434   case AArch64::STRSui:
 435     return AArch64::STRSpost;
 436   case AArch64::STRDui:
 437     return AArch64::STRDpost;
 438   case AArch64::STRQui:
 439     return AArch64::STRQpost;
 440   case AArch64::STRBBui:
 441     return AArch64::STRBBpost;
 442   case AArch64::STRHHui:
 443     return AArch64::STRHHpost;
 444   case AArch64::STRWui:
 445     return AArch64::STRWpost;
 446   case AArch64::STRXui:
 447     return AArch64::STRXpost;
 448   case AArch64::LDRSui:
 449     return AArch64::LDRSpost;
 450   case AArch64::LDRDui:
 451     return AArch64::LDRDpost;
 452   case AArch64::LDRQui:
 453     return AArch64::LDRQpost;
 454   case AArch64::LDRBBui:
 455     return AArch64::LDRBBpost;
 456   case AArch64::LDRHHui:
 457     return AArch64::LDRHHpost;
 458   case AArch64::LDRWui:
 459     return AArch64::LDRWpost;
 460   case AArch64::LDRXui:
 461     return AArch64::LDRXpost;
 462   case AArch64::LDRSWui:
 463     return AArch64::LDRSWpost;
 464   case AArch64::LDPSi:
 465     return AArch64::LDPSpost;
 466   case AArch64::LDPSWi:
 467     return AArch64::LDPSWpost;
 468   case AArch64::LDPDi:
 469     return AArch64::LDPDpost;
 470   case AArch64::LDPQi:
 471     return AArch64::LDPQpost;
 472   case AArch64::LDPWi:
 473     return AArch64::LDPWpost;
 474   case AArch64::LDPXi:
 475     return AArch64::LDPXpost;
 476   case AArch64::STPSi:
 477     return AArch64::STPSpost;
 478   case AArch64::STPDi:
 479     return AArch64::STPDpost;
 480   case AArch64::STPQi:
 481     return AArch64::STPQpost;
 482   case AArch64::STPWi:
 483     return AArch64::STPWpost;
 484   case AArch64::STPXi:
 485     return AArch64::STPXpost;
 486   }
 487 }
 488
 489 static bool isPairedLdSt(const MachineInstr &MI) {
 490   switch (MI.getOpcode()) {
 491   default:
 492     return false;
 493   case AArch64::LDPSi:
 494   case AArch64::LDPSWi:
 495   case AArch64::LDPDi:
 496   case AArch64::LDPQi:
 497   case AArch64::LDPWi:
 498   case AArch64::LDPXi:
 499   case AArch64::STPSi:
 500   case AArch64::STPDi:
 501   case AArch64::STPQi:
 502   case AArch64::STPWi:
 503   case AArch64::STPXi:
 504     return true;
 505   }
 506 }
 507
 508 static const MachineOperand &getLdStRegOp(const MachineInstr &MI,
 509                                           unsigned PairedRegOp = 0) {
 510   assert(PairedRegOp < 2 && "Unexpected register operand idx.");
 511   unsigned Idx = isPairedLdSt(MI) ? PairedRegOp : 0;
 512   return MI.getOperand(Idx);
 513 }
 514
 515 static const MachineOperand &getLdStBaseOp(const MachineInstr &MI) {
 516   unsigned Idx = isPairedLdSt(MI) ? 2 : 1;
 517   return MI.getOperand(Idx);
 518 }
 519
 520 static const MachineOperand &getLdStOffsetOp(const MachineInstr &MI) {
 521   unsigned Idx = isPairedLdSt(MI) ? 3 : 2;
 522   return MI.getOperand(Idx);
 523 }
 524
 525 static bool isLdOffsetInRangeOfSt(MachineInstr &LoadInst,
 526                                   MachineInstr &StoreInst,
 527                                   const AArch64InstrInfo *TII) {
 528   assert(isMatchingStore(LoadInst, StoreInst) && "Expect only matched ld/st.");
 529   int LoadSize = getMemScale(LoadInst);
 530   int StoreSize = getMemScale(StoreInst);
 531   int UnscaledStOffset = TII->isUnscaledLdSt(StoreInst)
 532                              ? getLdStOffsetOp(StoreInst).getImm()
 533                              : getLdStOffsetOp(StoreInst).getImm() * StoreSize;
 534   int UnscaledLdOffset = TII->isUnscaledLdSt(LoadInst)
 535                              ? getLdStOffsetOp(LoadInst).getImm()
 536                              : getLdStOffsetOp(LoadInst).getImm() * LoadSize;
 537   return (UnscaledStOffset <= UnscaledLdOffset) &&
 538          (UnscaledLdOffset + LoadSize <= (UnscaledStOffset + StoreSize));
 539 }
 540
 541 static bool isPromotableZeroStoreInst(MachineInstr &MI) {
 542   unsigned Opc = MI.getOpcode();
 543   return (Opc == AArch64::STRWui || Opc == AArch64::STURWi ||
 544           isNarrowStore(Opc)) &&
 545          getLdStRegOp(MI).getReg() == AArch64::WZR;
 546 }
 547
 548 MachineBasicBlock::iterator
 549 AArch64LoadStoreOpt::mergeNarrowZeroStores(MachineBasicBlock::iterator I,
 550                                            MachineBasicBlock::iterator MergeMI,
 551                                            const LdStPairFlags &Flags) {
 552   assert(isPromotableZeroStoreInst(*I) && isPromotableZeroStoreInst(*MergeMI) &&
 553          "Expected promotable zero stores.");
 554
 555   MachineBasicBlock::iterator NextI = I;
 556   ++NextI;
 557   // If NextI is the second of the two instructions to be merged, we need
 558   // to skip one further. Either way we merge will invalidate the iterator,
 559   // and we don't need to scan the new instruction, as it's a pairwise
 560   // instruction, which we're not considering for further action anyway.
 561   if (NextI == MergeMI)
 562     ++NextI;
 563
 564   unsigned Opc = I->getOpcode();
 565   bool IsScaled = !TII->isUnscaledLdSt(Opc);
 566   int OffsetStride = IsScaled ? 1 : getMemScale(*I);
 567
 568   bool MergeForward = Flags.getMergeForward();
 569   // Insert our new paired instruction after whichever of the paired
 570   // instructions MergeForward indicates.
 571   MachineBasicBlock::iterator InsertionPoint = MergeForward ? MergeMI : I;
 572   // Also based on MergeForward is from where we copy the base register operand
 573   // so we get the flags compatible with the input code.
 574   const MachineOperand &BaseRegOp =
 575       MergeForward ? getLdStBaseOp(*MergeMI) : getLdStBaseOp(*I);
 576
 577   // Which register is Rt and which is Rt2 depends on the offset order.
 578   MachineInstr *RtMI;
 579   if (getLdStOffsetOp(*I).getImm() ==
 580       getLdStOffsetOp(*MergeMI).getImm() + OffsetStride)
 581     RtMI = &*MergeMI;
 582   else
 583     RtMI = &*I;
 584
 585   int OffsetImm = getLdStOffsetOp(*RtMI).getImm();
 586   // Change the scaled offset from small to large type.
 587   if (IsScaled) {
 588     assert(((OffsetImm & 1) == 0) && "Unexpected offset to merge");
 589     OffsetImm /= 2;
 590   }
 591
 592   // Construct the new instruction.
 593   DebugLoc DL = I->getDebugLoc();
 594   MachineBasicBlock *MBB = I->getParent();
 595   MachineInstrBuilder MIB;
 596   MIB = BuildMI(*MBB, InsertionPoint, DL, TII->get(getMatchingWideOpcode(Opc)))
 597             .addReg(isNarrowStore(Opc) ? AArch64::WZR : AArch64::XZR)
 598             .addOperand(BaseRegOp)
 599             .addImm(OffsetImm)
 600             .setMemRefs(I->mergeMemRefsWith(*MergeMI));
 601   (void)MIB;
 602
 603   DEBUG(dbgs() << "Creating wider store. Replacing instructions:\n    ");
 604   DEBUG(I->print(dbgs()));
 605   DEBUG(dbgs() << "    ");
 606   DEBUG(MergeMI->print(dbgs()));
 607   DEBUG(dbgs() << "  with instruction:\n    ");
 608   DEBUG(((MachineInstr *)MIB)->print(dbgs()));
 609   DEBUG(dbgs() << "\n");
 610
 611   // Erase the old instructions.
 612   I->eraseFromParent();
 613   MergeMI->eraseFromParent();
 614   return NextI;
 615 }
 616
 617 MachineBasicBlock::iterator
 618 AArch64LoadStoreOpt::mergePairedInsns(MachineBasicBlock::iterator I,
 619                                       MachineBasicBlock::iterator Paired,
 620                                       const LdStPairFlags &Flags) {
 621   MachineBasicBlock::iterator NextI = I;
 622   ++NextI;
 623   // If NextI is the second of the two instructions to be merged, we need
 624   // to skip one further. Either way we merge will invalidate the iterator,
 625   // and we don't need to scan the new instruction, as it's a pairwise
 626   // instruction, which we're not considering for further action anyway.
 627   if (NextI == Paired)
 628     ++NextI;
 629
 630   int SExtIdx = Flags.getSExtIdx();
 631   unsigned Opc =
 632       SExtIdx == -1 ? I->getOpcode() : getMatchingNonSExtOpcode(I->getOpcode());
 633   bool IsUnscaled = TII->isUnscaledLdSt(Opc);
 634   int OffsetStride = IsUnscaled ? getMemScale(*I) : 1;
 635
 636   bool MergeForward = Flags.getMergeForward();
 637   // Insert our new paired instruction after whichever of the paired
 638   // instructions MergeForward indicates.
 639   MachineBasicBlock::iterator InsertionPoint = MergeForward ? Paired : I;
 640   // Also based on MergeForward is from where we copy the base register operand
 641   // so we get the flags compatible with the input code.
 642   const MachineOperand &BaseRegOp =
 643       MergeForward ? getLdStBaseOp(*Paired) : getLdStBaseOp(*I);
 644
 645   int Offset = getLdStOffsetOp(*I).getImm();
 646   int PairedOffset = getLdStOffsetOp(*Paired).getImm();
 647   bool PairedIsUnscaled = TII->isUnscaledLdSt(Paired->getOpcode());
 648   if (IsUnscaled != PairedIsUnscaled) {
 649     // We're trying to pair instructions that differ in how they are scaled.  If
 650     // I is scaled then scale the offset of Paired accordingly.  Otherwise, do
 651     // the opposite (i.e., make Paired's offset unscaled).
 652     int MemSize = getMemScale(*Paired);
 653     if (PairedIsUnscaled) {
 654       // If the unscaled offset isn't a multiple of the MemSize, we can't
 655       // pair the operations together.
 656       assert(!(PairedOffset % getMemScale(*Paired)) &&
 657              "Offset should be a multiple of the stride!");
 658       PairedOffset /= MemSize;
 659     } else {
 660       PairedOffset *= MemSize;
 661     }
 662   }
 663
 664   // Which register is Rt and which is Rt2 depends on the offset order.
 665   MachineInstr *RtMI, *Rt2MI;
 666   if (Offset == PairedOffset + OffsetStride) {
 667     RtMI = &*Paired;
 668     Rt2MI = &*I;
 669     // Here we swapped the assumption made for SExtIdx.
 670     // I.e., we turn ldp I, Paired into ldp Paired, I.
 671     // Update the index accordingly.
 672     if (SExtIdx != -1)
 673       SExtIdx = (SExtIdx + 1) % 2;
 674   } else {
 675     RtMI = &*I;
 676     Rt2MI = &*Paired;
 677   }
 678   int OffsetImm = getLdStOffsetOp(*RtMI).getImm();
 679   // Scale the immediate offset, if necessary.
 680   if (TII->isUnscaledLdSt(RtMI->getOpcode())) {
 681     assert(!(OffsetImm % getMemScale(*RtMI)) &&
 682            "Unscaled offset cannot be scaled.");
 683     OffsetImm /= getMemScale(*RtMI);
 684   }
 685
 686   // Construct the new instruction.
 687   MachineInstrBuilder MIB;
 688   DebugLoc DL = I->getDebugLoc();
 689   MachineBasicBlock *MBB = I->getParent();
 690   MIB = BuildMI(*MBB, InsertionPoint, DL, TII->get(getMatchingPairOpcode(Opc)))
 691             .addOperand(getLdStRegOp(*RtMI))
 692             .addOperand(getLdStRegOp(*Rt2MI))
 693             .addOperand(BaseRegOp)
 694             .addImm(OffsetImm)
 695             .setMemRefs(I->mergeMemRefsWith(*Paired));
 696
 697   (void)MIB;
 698
 699   DEBUG(dbgs() << "Creating pair load/store. Replacing instructions:\n    ");
 700   DEBUG(I->print(dbgs()));
 701   DEBUG(dbgs() << "    ");
 702   DEBUG(Paired->print(dbgs()));
 703   DEBUG(dbgs() << "  with instruction:\n    ");
 704   if (SExtIdx != -1) {
 705     // Generate the sign extension for the proper result of the ldp.
 706     // I.e., with X1, that would be:
 707     // %W1<def> = KILL %W1, %X1<imp-def>
 708     // %X1<def> = SBFMXri %X1<kill>, 0, 31
 709     MachineOperand &DstMO = MIB->getOperand(SExtIdx);
 710     // Right now, DstMO has the extended register, since it comes from an
 711     // extended opcode.
 712     unsigned DstRegX = DstMO.getReg();
 713     // Get the W variant of that register.
 714     unsigned DstRegW = TRI->getSubReg(DstRegX, AArch64::sub_32);
 715     // Update the result of LDP to use the W instead of the X variant.
 716     DstMO.setReg(DstRegW);
 717     DEBUG(((MachineInstr *)MIB)->print(dbgs()));
 718     DEBUG(dbgs() << "\n");
 719     // Make the machine verifier happy by providing a definition for
 720     // the X register.
 721     // Insert this definition right after the generated LDP, i.e., before
 722     // InsertionPoint.
 723     MachineInstrBuilder MIBKill =
 724         BuildMI(*MBB, InsertionPoint, DL, TII->get(TargetOpcode::KILL), DstRegW)
 725             .addReg(DstRegW)
 726             .addReg(DstRegX, RegState::Define);
 727     MIBKill->getOperand(2).setImplicit();
 728     // Create the sign extension.
 729     MachineInstrBuilder MIBSXTW =
 730         BuildMI(*MBB, InsertionPoint, DL, TII->get(AArch64::SBFMXri), DstRegX)
 731             .addReg(DstRegX)
 732             .addImm(0)
 733             .addImm(31);
 734     (void)MIBSXTW;
 735     DEBUG(dbgs() << "  Extend operand:\n    ");
 736     DEBUG(((MachineInstr *)MIBSXTW)->print(dbgs()));
 737   } else {
 738     DEBUG(((MachineInstr *)MIB)->print(dbgs()));
 739   }
 740   DEBUG(dbgs() << "\n");
 741
 742   // Erase the old instructions.
 743   I->eraseFromParent();
 744   Paired->eraseFromParent();
 745
 746   return NextI;
 747 }
 748
 749 MachineBasicBlock::iterator
 750 AArch64LoadStoreOpt::promoteLoadFromStore(MachineBasicBlock::iterator LoadI,
 751                                           MachineBasicBlock::iterator StoreI) {
 752   MachineBasicBlock::iterator NextI = LoadI;
 753   ++NextI;
 754
 755   int LoadSize = getMemScale(*LoadI);
 756   int StoreSize = getMemScale(*StoreI);
 757   unsigned LdRt = getLdStRegOp(*LoadI).getReg();
 758   unsigned StRt = getLdStRegOp(*StoreI).getReg();
 759   bool IsStoreXReg = TRI->getRegClass(AArch64::GPR64RegClassID)->contains(StRt);
 760
 761   assert((IsStoreXReg ||
 762           TRI->getRegClass(AArch64::GPR32RegClassID)->contains(StRt)) &&
 763          "Unexpected RegClass");
 764
 765   MachineInstr *BitExtMI;
 766   if (LoadSize == StoreSize && (LoadSize == 4 || LoadSize == 8)) {
 767     // Remove the load, if the destination register of the loads is the same
 768     // register for stored value.
 769     if (StRt == LdRt && LoadSize == 8) {
 770       StoreI->clearRegisterKills(StRt, TRI);
 771       DEBUG(dbgs() << "Remove load instruction:\n    ");
 772       DEBUG(LoadI->print(dbgs()));
 773       DEBUG(dbgs() << "\n");
 774       LoadI->eraseFromParent();
 775       return NextI;
 776     }
 777     // Replace the load with a mov if the load and store are in the same size.
 778     BitExtMI =
 779         BuildMI(*LoadI->getParent(), LoadI, LoadI->getDebugLoc(),
 780                 TII->get(IsStoreXReg ? AArch64::ORRXrs : AArch64::ORRWrs), LdRt)
 781             .addReg(IsStoreXReg ? AArch64::XZR : AArch64::WZR)
 782             .addReg(StRt)
 783             .addImm(AArch64_AM::getShifterImm(AArch64_AM::LSL, 0));
 784   } else {
 785     // FIXME: Currently we disable this transformation in big-endian targets as
 786     // performance and correctness are verified only in little-endian.
 787     if (!Subtarget->isLittleEndian())
 788       return NextI;
 789     bool IsUnscaled = TII->isUnscaledLdSt(*LoadI);
 790     assert(IsUnscaled == TII->isUnscaledLdSt(*StoreI) &&
 791            "Unsupported ld/st match");
 792     assert(LoadSize <= StoreSize && "Invalid load size");
 793     int UnscaledLdOffset = IsUnscaled
 794                                ? getLdStOffsetOp(*LoadI).getImm()
 795                                : getLdStOffsetOp(*LoadI).getImm() * LoadSize;
 796     int UnscaledStOffset = IsUnscaled
 797                                ? getLdStOffsetOp(*StoreI).getImm()
 798                                : getLdStOffsetOp(*StoreI).getImm() * StoreSize;
 799     int Width = LoadSize * 8;
 800     int Immr = 8 * (UnscaledLdOffset - UnscaledStOffset);
 801     int Imms = Immr + Width - 1;
 802     unsigned DestReg = IsStoreXReg
 803                            ? TRI->getMatchingSuperReg(LdRt, AArch64::sub_32,
 804                                                       &AArch64::GPR64RegClass)
 805                            : LdRt;
 806
 807     assert((UnscaledLdOffset >= UnscaledStOffset &&
 808             (UnscaledLdOffset + LoadSize) <= UnscaledStOffset + StoreSize) &&
 809            "Invalid offset");
 810
 811     Immr = 8 * (UnscaledLdOffset - UnscaledStOffset);
 812     Imms = Immr + Width - 1;
 813     if (UnscaledLdOffset == UnscaledStOffset) {
 814       uint32_t AndMaskEncoded = ((IsStoreXReg ? 1 : 0) << 12) // N
 815                                 | ((Immr) << 6)               // immr
 816                                 | ((Imms) << 0)               // imms
 817           ;
 818
 819       BitExtMI =
 820           BuildMI(*LoadI->getParent(), LoadI, LoadI->getDebugLoc(),
 821                   TII->get(IsStoreXReg ? AArch64::ANDXri : AArch64::ANDWri),
 822                   DestReg)
 823               .addReg(StRt)
 824               .addImm(AndMaskEncoded);
 825     } else {
 826       BitExtMI =
 827           BuildMI(*LoadI->getParent(), LoadI, LoadI->getDebugLoc(),
 828                   TII->get(IsStoreXReg ? AArch64::UBFMXri : AArch64::UBFMWri),
 829                   DestReg)
 830               .addReg(StRt)
 831               .addImm(Immr)
 832               .addImm(Imms);
 833     }
 834   }
 835   StoreI->clearRegisterKills(StRt, TRI);
 836
 837   (void)BitExtMI;
 838
 839   DEBUG(dbgs() << "Promoting load by replacing :\n    ");
 840   DEBUG(StoreI->print(dbgs()));
 841   DEBUG(dbgs() << "    ");
 842   DEBUG(LoadI->print(dbgs()));
 843   DEBUG(dbgs() << "  with instructions:\n    ");
 844   DEBUG(StoreI->print(dbgs()));
 845   DEBUG(dbgs() << "    ");
 846   DEBUG((BitExtMI)->print(dbgs()));
 847   DEBUG(dbgs() << "\n");
 848
 849   // Erase the old instructions.
 850   LoadI->eraseFromParent();
 851   return NextI;
 852 }
 853
 854 /// trackRegDefsUses - Remember what registers the specified instruction uses
 855 /// and modifies.
 856 static void trackRegDefsUses(const MachineInstr &MI, BitVector &ModifiedRegs,
 857                              BitVector &UsedRegs,
 858                              const TargetRegisterInfo *TRI) {
 859   for (const MachineOperand &MO : MI.operands()) {
 860     if (MO.isRegMask())
 861       ModifiedRegs.setBitsNotInMask(MO.getRegMask());
 862
 863     if (!MO.isReg())
 864       continue;
 865     unsigned Reg = MO.getReg();
 866     if (!Reg)
 867       continue;
 868     if (MO.isDef()) {
 869       // WZR/XZR are not modified even when used as a destination register.
 870       if (Reg != AArch64::WZR && Reg != AArch64::XZR)
 871         for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
 872           ModifiedRegs.set(*AI);
 873     } else {
 874       assert(MO.isUse() && "Reg operand not a def and not a use?!?");
 875       for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
 876         UsedRegs.set(*AI);
 877     }
 878   }
 879 }
 880
 881 static bool inBoundsForPair(bool IsUnscaled, int Offset, int OffsetStride) {
 882   // Convert the byte-offset used by unscaled into an "element" offset used
 883   // by the scaled pair load/store instructions.
 884   if (IsUnscaled) {
 885     // If the byte-offset isn't a multiple of the stride, there's no point
 886     // trying to match it.
 887     if (Offset % OffsetStride)
 888       return false;
 889     Offset /= OffsetStride;
 890   }
 891   return Offset <= 63 && Offset >= -64;
 892 }
 893
 894 // Do alignment, specialized to power of 2 and for signed ints,
 895 // avoiding having to do a C-style cast from uint_64t to int when
 896 // using alignTo from include/llvm/Support/MathExtras.h.
 897 // FIXME: Move this function to include/MathExtras.h?
 898 static int alignTo(int Num, int PowOf2) {
 899   return (Num + PowOf2 - 1) & ~(PowOf2 - 1);
 900 }
 901
 902 static bool mayAlias(MachineInstr &MIa, MachineInstr &MIb,
 903                      const AArch64InstrInfo *TII) {
 904   // One of the instructions must modify memory.
 905   if (!MIa.mayStore() && !MIb.mayStore())
 906     return false;
 907
 908   // Both instructions must be memory operations.
 909   if (!MIa.mayLoadOrStore() && !MIb.mayLoadOrStore())
 910     return false;
 911
 912   return !TII->areMemAccessesTriviallyDisjoint(MIa, MIb);
 913 }
 914
 915 static bool mayAlias(MachineInstr &MIa,
 916                      SmallVectorImpl<MachineInstr *> &MemInsns,
 917                      const AArch64InstrInfo *TII) {
 918   for (MachineInstr *MIb : MemInsns)
 919     if (mayAlias(MIa, *MIb, TII))
 920       return true;
 921
 922   return false;
 923 }
 924
 925 bool AArch64LoadStoreOpt::findMatchingStore(
 926     MachineBasicBlock::iterator I, unsigned Limit,
 927     MachineBasicBlock::iterator &StoreI) {
 928   MachineBasicBlock::iterator B = I->getParent()->begin();
 929   MachineBasicBlock::iterator MBBI = I;
 930   MachineInstr &LoadMI = *I;
 931   unsigned BaseReg = getLdStBaseOp(LoadMI).getReg();
 932
 933   // If the load is the first instruction in the block, there's obviously
 934   // not any matching store.
 935   if (MBBI == B)
 936     return false;
 937
 938   // Track which registers have been modified and used between the first insn
 939   // and the second insn.
 940   ModifiedRegs.reset();
 941   UsedRegs.reset();
 942
 943   unsigned Count = 0;
 944   do {
 945     --MBBI;
 946     MachineInstr &MI = *MBBI;
 947
 948     // Don't count transient instructions towards the search limit since there
 949     // may be different numbers of them if e.g. debug information is present.
 950     if (!MI.isTransient())
 951       ++Count;
 952
 953     // If the load instruction reads directly from the address to which the
 954     // store instruction writes and the stored value is not modified, we can
 955     // promote the load. Since we do not handle stores with pre-/post-index,
 956     // it's unnecessary to check if BaseReg is modified by the store itself.
 957     if (MI.mayStore() && isMatchingStore(LoadMI, MI) &&
 958         BaseReg == getLdStBaseOp(MI).getReg() &&
 959         isLdOffsetInRangeOfSt(LoadMI, MI, TII) &&
 960         !ModifiedRegs[getLdStRegOp(MI).getReg()]) {
 961       StoreI = MBBI;
 962       return true;
 963     }
 964
 965     if (MI.isCall())
 966       return false;
 967
 968     // Update modified / uses register lists.
 969     trackRegDefsUses(MI, ModifiedRegs, UsedRegs, TRI);
 970
 971     // Otherwise, if the base register is modified, we have no match, so
 972     // return early.
 973     if (ModifiedRegs[BaseReg])
 974       return false;
 975
 976     // If we encounter a store aliased with the load, return early.
 977     if (MI.mayStore() && mayAlias(LoadMI, MI, TII))
 978       return false;
 979   } while (MBBI != B && Count < Limit);
 980   return false;
 981 }
 982
 983 // Returns true if FirstMI and MI are candidates for merging or pairing.
 984 // Otherwise, returns false.
 985 static bool areCandidatesToMergeOrPair(MachineInstr &FirstMI, MachineInstr &MI,
 986                                        LdStPairFlags &Flags,
 987                                        const AArch64InstrInfo *TII) {
 988   // If this is volatile or if pairing is suppressed, not a candidate.
 989   if (MI.hasOrderedMemoryRef() || TII->isLdStPairSuppressed(MI))
 990     return false;
 991
 992   // We should have already checked FirstMI for pair suppression and volatility.
 993   assert(!FirstMI.hasOrderedMemoryRef() &&
 994          !TII->isLdStPairSuppressed(FirstMI) &&
 995          "FirstMI shouldn't get here if either of these checks are true.");
 996
 997   unsigned OpcA = FirstMI.getOpcode();
 998   unsigned OpcB = MI.getOpcode();
 999
1000   // Opcodes match: nothing more to check.
1001   if (OpcA == OpcB)
1002     return true;
1003
1004   // Try to match a sign-extended load/store with a zero-extended load/store.
1005   bool IsValidLdStrOpc, PairIsValidLdStrOpc;
1006   unsigned NonSExtOpc = getMatchingNonSExtOpcode(OpcA, &IsValidLdStrOpc);
1007   assert(IsValidLdStrOpc &&
1008          "Given Opc should be a Load or Store with an immediate");
1009   // OpcA will be the first instruction in the pair.
1010   if (NonSExtOpc == getMatchingNonSExtOpcode(OpcB, &PairIsValidLdStrOpc)) {
1011     Flags.setSExtIdx(NonSExtOpc == (unsigned)OpcA ? 1 : 0);
1012     return true;
1013   }
1014
1015   // If the second instruction isn't even a mergable/pairable load/store, bail
1016   // out.
1017   if (!PairIsValidLdStrOpc)
1018     return false;
1019
1020   // FIXME: We don't support merging narrow stores with mixed scaled/unscaled
1021   // offsets.
1022   if (isNarrowStore(OpcA) || isNarrowStore(OpcB))
1023     return false;
1024
1025   // Try to match an unscaled load/store with a scaled load/store.
1026   return TII->isUnscaledLdSt(OpcA) != TII->isUnscaledLdSt(OpcB) &&
1027          getMatchingPairOpcode(OpcA) == getMatchingPairOpcode(OpcB);
1028
1029   // FIXME: Can we also match a mixed sext/zext unscaled/scaled pair?
1030 }
1031
1032 /// Scan the instructions looking for a load/store that can be combined with the
1033 /// current instruction into a wider equivalent or a load/store pair.
1034 MachineBasicBlock::iterator
1035 AArch64LoadStoreOpt::findMatchingInsn(MachineBasicBlock::iterator I,
1036                                       LdStPairFlags &Flags, unsigned Limit,
1037                                       bool FindNarrowMerge) {
1038   MachineBasicBlock::iterator E = I->getParent()->end();
1039   MachineBasicBlock::iterator MBBI = I;
1040   MachineInstr &FirstMI = *I;
1041   ++MBBI;
1042
1043   bool MayLoad = FirstMI.mayLoad();
1044   bool IsUnscaled = TII->isUnscaledLdSt(FirstMI);
1045   unsigned Reg = getLdStRegOp(FirstMI).getReg();
1046   unsigned BaseReg = getLdStBaseOp(FirstMI).getReg();
1047   int Offset = getLdStOffsetOp(FirstMI).getImm();
1048   int OffsetStride = IsUnscaled ? getMemScale(FirstMI) : 1;
1049   bool IsPromotableZeroStore = isPromotableZeroStoreInst(FirstMI);
1050
1051   // Track which registers have been modified and used between the first insn
1052   // (inclusive) and the second insn.
1053   ModifiedRegs.reset();
1054   UsedRegs.reset();
1055
1056   // Remember any instructions that read/write memory between FirstMI and MI.
1057   SmallVector<MachineInstr *, 4> MemInsns;
1058
1059   for (unsigned Count = 0; MBBI != E && Count < Limit; ++MBBI) {
1060     MachineInstr &MI = *MBBI;
1061
1062     // Don't count transient instructions towards the search limit since there
1063     // may be different numbers of them if e.g. debug information is present.
1064     if (!MI.isTransient())
1065       ++Count;
1066
1067     Flags.setSExtIdx(-1);
1068     if (areCandidatesToMergeOrPair(FirstMI, MI, Flags, TII) &&
1069         getLdStOffsetOp(MI).isImm()) {
1070       assert(MI.mayLoadOrStore() && "Expected memory operation.");
1071       // If we've found another instruction with the same opcode, check to see
1072       // if the base and offset are compatible with our starting instruction.
1073       // These instructions all have scaled immediate operands, so we just
1074       // check for +1/-1. Make sure to check the new instruction offset is
1075       // actually an immediate and not a symbolic reference destined for
1076       // a relocation.
1077       unsigned MIBaseReg = getLdStBaseOp(MI).getReg();
1078       int MIOffset = getLdStOffsetOp(MI).getImm();
1079       bool MIIsUnscaled = TII->isUnscaledLdSt(MI);
1080       if (IsUnscaled != MIIsUnscaled) {
1081         // We're trying to pair instructions that differ in how they are scaled.
1082         // If FirstMI is scaled then scale the offset of MI accordingly.
1083         // Otherwise, do the opposite (i.e., make MI's offset unscaled).
1084         int MemSize = getMemScale(MI);
1085         if (MIIsUnscaled) {
1086           // If the unscaled offset isn't a multiple of the MemSize, we can't
1087           // pair the operations together: bail and keep looking.
1088           if (MIOffset % MemSize) {
1089             trackRegDefsUses(MI, ModifiedRegs, UsedRegs, TRI);
1090             MemInsns.push_back(&MI);
1091             continue;
1092           }
1093           MIOffset /= MemSize;
1094         } else {
1095           MIOffset *= MemSize;
1096         }
1097       }
1098
1099       if (BaseReg == MIBaseReg && ((Offset == MIOffset + OffsetStride) ||
1100                                    (Offset + OffsetStride == MIOffset))) {
1101         int MinOffset = Offset < MIOffset ? Offset : MIOffset;
1102         if (FindNarrowMerge) {
1103           // If the alignment requirements of the scaled wide load/store
1104           // instruction can't express the offset of the scaled narrow input,
1105           // bail and keep looking. For promotable zero stores, allow only when
1106           // the stored value is the same (i.e., WZR).
1107           if ((!IsUnscaled && alignTo(MinOffset, 2) != MinOffset) ||
1108               (IsPromotableZeroStore && Reg != getLdStRegOp(MI).getReg())) {
1109             trackRegDefsUses(MI, ModifiedRegs, UsedRegs, TRI);
1110             MemInsns.push_back(&MI);
1111             continue;
1112           }
1113         } else {
1114           // Pairwise instructions have a 7-bit signed offset field. Single
1115           // insns have a 12-bit unsigned offset field.  If the resultant
1116           // immediate offset of merging these instructions is out of range for
1117           // a pairwise instruction, bail and keep looking.
1118           if (!inBoundsForPair(IsUnscaled, MinOffset, OffsetStride)) {
1119             trackRegDefsUses(MI, ModifiedRegs, UsedRegs, TRI);
1120             MemInsns.push_back(&MI);
1121             continue;
1122           }
1123           // If the alignment requirements of the paired (scaled) instruction
1124           // can't express the offset of the unscaled input, bail and keep
1125           // looking.
1126           if (IsUnscaled && (alignTo(MinOffset, OffsetStride) != MinOffset)) {
1127             trackRegDefsUses(MI, ModifiedRegs, UsedRegs, TRI);
1128             MemInsns.push_back(&MI);
1129             continue;
1130           }
1131         }
1132         // If the destination register of the loads is the same register, bail
1133         // and keep looking. A load-pair instruction with both destination
1134         // registers the same is UNPREDICTABLE and will result in an exception.
1135         if (MayLoad && Reg == getLdStRegOp(MI).getReg()) {
1136           trackRegDefsUses(MI, ModifiedRegs, UsedRegs, TRI);
1137           MemInsns.push_back(&MI);
1138           continue;
1139         }
1140
1141         // If the Rt of the second instruction was not modified or used between
1142         // the two instructions and none of the instructions between the second
1143         // and first alias with the second, we can combine the second into the
1144         // first.
1145         if (!ModifiedRegs[getLdStRegOp(MI).getReg()] &&
1146             !(MI.mayLoad() && UsedRegs[getLdStRegOp(MI).getReg()]) &&
1147             !mayAlias(MI, MemInsns, TII)) {
1148           Flags.setMergeForward(false);
1149           return MBBI;
1150         }
1151
1152         // Likewise, if the Rt of the first instruction is not modified or used
1153         // between the two instructions and none of the instructions between the
1154         // first and the second alias with the first, we can combine the first
1155         // into the second.
1156         if (!ModifiedRegs[getLdStRegOp(FirstMI).getReg()] &&
1157             !(MayLoad && UsedRegs[getLdStRegOp(FirstMI).getReg()]) &&
1158             !mayAlias(FirstMI, MemInsns, TII)) {
1159           Flags.setMergeForward(true);
1160           return MBBI;
1161         }
1162         // Unable to combine these instructions due to interference in between.
1163         // Keep looking.
1164       }
1165     }
1166
1167     // If the instruction wasn't a matching load or store.  Stop searching if we
1168     // encounter a call instruction that might modify memory.
1169     if (MI.isCall())
1170       return E;
1171
1172     // Update modified / uses register lists.
1173     trackRegDefsUses(MI, ModifiedRegs, UsedRegs, TRI);
1174
1175     // Otherwise, if the base register is modified, we have no match, so
1176     // return early.
1177     if (ModifiedRegs[BaseReg])
1178       return E;
1179
1180     // Update list of instructions that read/write memory.
1181     if (MI.mayLoadOrStore())
1182       MemInsns.push_back(&MI);
1183   }
1184   return E;
1185 }
1186
1187 MachineBasicBlock::iterator
1188 AArch64LoadStoreOpt::mergeUpdateInsn(MachineBasicBlock::iterator I,
1189                                      MachineBasicBlock::iterator Update,
1190                                      bool IsPreIdx) {
1191   assert((Update->getOpcode() == AArch64::ADDXri ||
1192           Update->getOpcode() == AArch64::SUBXri) &&
1193          "Unexpected base register update instruction to merge!");
1194   MachineBasicBlock::iterator NextI = I;
1195   // Return the instruction following the merged instruction, which is
1196   // the instruction following our unmerged load. Unless that's the add/sub
1197   // instruction we're merging, in which case it's the one after that.
1198   if (++NextI == Update)
1199     ++NextI;
1200
1201   int Value = Update->getOperand(2).getImm();
1202   assert(AArch64_AM::getShiftValue(Update->getOperand(3).getImm()) == 0 &&
1203          "Can't merge 1 << 12 offset into pre-/post-indexed load / store");
1204   if (Update->getOpcode() == AArch64::SUBXri)
1205     Value = -Value;
1206
1207   unsigned NewOpc = IsPreIdx ? getPreIndexedOpcode(I->getOpcode())
1208                              : getPostIndexedOpcode(I->getOpcode());
1209   MachineInstrBuilder MIB;
1210   if (!isPairedLdSt(*I)) {
1211     // Non-paired instruction.
1212     MIB = BuildMI(*I->getParent(), I, I->getDebugLoc(), TII->get(NewOpc))
1213               .addOperand(getLdStRegOp(*Update))
1214               .addOperand(getLdStRegOp(*I))
1215               .addOperand(getLdStBaseOp(*I))
1216               .addImm(Value)
1217               .setMemRefs(I->memoperands_begin(), I->memoperands_end());
1218   } else {
1219     // Paired instruction.
1220     int Scale = getMemScale(*I);
1221     MIB = BuildMI(*I->getParent(), I, I->getDebugLoc(), TII->get(NewOpc))
1222               .addOperand(getLdStRegOp(*Update))
1223               .addOperand(getLdStRegOp(*I, 0))
1224               .addOperand(getLdStRegOp(*I, 1))
1225               .addOperand(getLdStBaseOp(*I))
1226               .addImm(Value / Scale)
1227               .setMemRefs(I->memoperands_begin(), I->memoperands_end());
1228   }
1229   (void)MIB;
1230
1231   if (IsPreIdx)
1232     DEBUG(dbgs() << "Creating pre-indexed load/store.");
1233   else
1234     DEBUG(dbgs() << "Creating post-indexed load/store.");
1235   DEBUG(dbgs() << "    Replacing instructions:\n    ");
1236   DEBUG(I->print(dbgs()));
1237   DEBUG(dbgs() << "    ");
1238   DEBUG(Update->print(dbgs()));
1239   DEBUG(dbgs() << "  with instruction:\n    ");
1240   DEBUG(((MachineInstr *)MIB)->print(dbgs()));
1241   DEBUG(dbgs() << "\n");
1242
1243   // Erase the old instructions for the block.
1244   I->eraseFromParent();
1245   Update->eraseFromParent();
1246
1247   return NextI;
1248 }
1249
1250 bool AArch64LoadStoreOpt::isMatchingUpdateInsn(MachineInstr &MemMI,
1251                                                MachineInstr &MI,
1252                                                unsigned BaseReg, int Offset) {
1253   switch (MI.getOpcode()) {
1254   default:
1255     break;
1256   case AArch64::SUBXri:
1257   case AArch64::ADDXri:
1258     // Make sure it's a vanilla immediate operand, not a relocation or
1259     // anything else we can't handle.
1260     if (!MI.getOperand(2).isImm())
1261       break;
1262     // Watch out for 1 << 12 shifted value.
1263     if (AArch64_AM::getShiftValue(MI.getOperand(3).getImm()))
1264       break;
1265
1266     // The update instruction source and destination register must be the
1267     // same as the load/store base register.
1268     if (MI.getOperand(0).getReg() != BaseReg ||
1269         MI.getOperand(1).getReg() != BaseReg)
1270       break;
1271
1272     bool IsPairedInsn = isPairedLdSt(MemMI);
1273     int UpdateOffset = MI.getOperand(2).getImm();
1274     if (MI.getOpcode() == AArch64::SUBXri)
1275       UpdateOffset = -UpdateOffset;
1276
1277     // For non-paired load/store instructions, the immediate must fit in a
1278     // signed 9-bit integer.
1279     if (!IsPairedInsn && (UpdateOffset > 255 || UpdateOffset < -256))
1280       break;
1281
1282     // For paired load/store instructions, the immediate must be a multiple of
1283     // the scaling factor.  The scaled offset must also fit into a signed 7-bit
1284     // integer.
1285     if (IsPairedInsn) {
1286       int Scale = getMemScale(MemMI);
1287       if (UpdateOffset % Scale != 0)
1288         break;
1289
1290       int ScaledOffset = UpdateOffset / Scale;
1291       if (ScaledOffset > 63 || ScaledOffset < -64)
1292         break;
1293     }
1294
1295     // If we have a non-zero Offset, we check that it matches the amount
1296     // we're adding to the register.
1297     if (!Offset || Offset == UpdateOffset)
1298       return true;
1299     break;
1300   }
1301   return false;
1302 }
1303
1304 MachineBasicBlock::iterator AArch64LoadStoreOpt::findMatchingUpdateInsnForward(
1305     MachineBasicBlock::iterator I, int UnscaledOffset, unsigned Limit) {
1306   MachineBasicBlock::iterator E = I->getParent()->end();
1307   MachineInstr &MemMI = *I;
1308   MachineBasicBlock::iterator MBBI = I;
1309
1310   unsigned BaseReg = getLdStBaseOp(MemMI).getReg();
1311   int MIUnscaledOffset = getLdStOffsetOp(MemMI).getImm() * getMemScale(MemMI);
1312
1313   // Scan forward looking for post-index opportunities.  Updating instructions
1314   // can't be formed if the memory instruction doesn't have the offset we're
1315   // looking for.
1316   if (MIUnscaledOffset != UnscaledOffset)
1317     return E;
1318
1319   // If the base register overlaps a destination register, we can't
1320   // merge the update.
1321   bool IsPairedInsn = isPairedLdSt(MemMI);
1322   for (unsigned i = 0, e = IsPairedInsn ? 2 : 1; i != e; ++i) {
1323     unsigned DestReg = getLdStRegOp(MemMI, i).getReg();
1324     if (DestReg == BaseReg || TRI->isSubRegister(BaseReg, DestReg))
1325       return E;
1326   }
1327
1328   // Track which registers have been modified and used between the first insn
1329   // (inclusive) and the second insn.
1330   ModifiedRegs.reset();
1331   UsedRegs.reset();
1332   ++MBBI;
1333   for (unsigned Count = 0; MBBI != E && Count < Limit; ++MBBI) {
1334     MachineInstr &MI = *MBBI;
1335
1336     // Don't count transient instructions towards the search limit since there
1337     // may be different numbers of them if e.g. debug information is present.
1338     if (!MI.isTransient())
1339       ++Count;
1340
1341     // If we found a match, return it.
1342     if (isMatchingUpdateInsn(*I, MI, BaseReg, UnscaledOffset))
1343       return MBBI;
1344
1345     // Update the status of what the instruction clobbered and used.
1346     trackRegDefsUses(MI, ModifiedRegs, UsedRegs, TRI);
1347
1348     // Otherwise, if the base register is used or modified, we have no match, so
1349     // return early.
1350     if (ModifiedRegs[BaseReg] || UsedRegs[BaseReg])
1351       return E;
1352   }
1353   return E;
1354 }
1355
1356 MachineBasicBlock::iterator AArch64LoadStoreOpt::findMatchingUpdateInsnBackward(
1357     MachineBasicBlock::iterator I, unsigned Limit) {
1358   MachineBasicBlock::iterator B = I->getParent()->begin();
1359   MachineBasicBlock::iterator E = I->getParent()->end();
1360   MachineInstr &MemMI = *I;
1361   MachineBasicBlock::iterator MBBI = I;
1362
1363   unsigned BaseReg = getLdStBaseOp(MemMI).getReg();
1364   int Offset = getLdStOffsetOp(MemMI).getImm();
1365
1366   // If the load/store is the first instruction in the block, there's obviously
1367   // not any matching update. Ditto if the memory offset isn't zero.
1368   if (MBBI == B || Offset != 0)
1369     return E;
1370   // If the base register overlaps a destination register, we can't
1371   // merge the update.
1372   bool IsPairedInsn = isPairedLdSt(MemMI);
1373   for (unsigned i = 0, e = IsPairedInsn ? 2 : 1; i != e; ++i) {
1374     unsigned DestReg = getLdStRegOp(MemMI, i).getReg();
1375     if (DestReg == BaseReg || TRI->isSubRegister(BaseReg, DestReg))
1376       return E;
1377   }
1378
1379   // Track which registers have been modified and used between the first insn
1380   // (inclusive) and the second insn.
1381   ModifiedRegs.reset();
1382   UsedRegs.reset();
1383   unsigned Count = 0;
1384   do {
1385     --MBBI;
1386     MachineInstr &MI = *MBBI;
1387
1388     // Don't count transient instructions towards the search limit since there
1389     // may be different numbers of them if e.g. debug information is present.
1390     if (!MI.isTransient())
1391       ++Count;
1392
1393     // If we found a match, return it.
1394     if (isMatchingUpdateInsn(*I, MI, BaseReg, Offset))
1395       return MBBI;
1396
1397     // Update the status of what the instruction clobbered and used.
1398     trackRegDefsUses(MI, ModifiedRegs, UsedRegs, TRI);
1399
1400     // Otherwise, if the base register is used or modified, we have no match, so
1401     // return early.
1402     if (ModifiedRegs[BaseReg] || UsedRegs[BaseReg])
1403       return E;
1404   } while (MBBI != B && Count < Limit);
1405   return E;
1406 }
1407
1408 bool AArch64LoadStoreOpt::tryToPromoteLoadFromStore(
1409     MachineBasicBlock::iterator &MBBI) {
1410   MachineInstr &MI = *MBBI;
1411   // If this is a volatile load, don't mess with it.
1412   if (MI.hasOrderedMemoryRef())
1413     return false;
1414
1415   // Make sure this is a reg+imm.
1416   // FIXME: It is possible to extend it to handle reg+reg cases.
1417   if (!getLdStOffsetOp(MI).isImm())
1418     return false;
1419
1420   // Look backward up to LdStLimit instructions.
1421   MachineBasicBlock::iterator StoreI;
1422   if (findMatchingStore(MBBI, LdStLimit, StoreI)) {
1423     ++NumLoadsFromStoresPromoted;
1424     // Promote the load. Keeping the iterator straight is a
1425     // pain, so we let the merge routine tell us what the next instruction
1426     // is after it's done mucking about.
1427     MBBI = promoteLoadFromStore(MBBI, StoreI);
1428     return true;
1429   }
1430   return false;
1431 }
1432
1433 // Merge adjacent zero stores into a wider store.
1434 bool AArch64LoadStoreOpt::tryToMergeZeroStInst(
1435     MachineBasicBlock::iterator &MBBI) {
1436   assert(isPromotableZeroStoreInst(*MBBI) && "Expected narrow store.");
1437   MachineInstr &MI = *MBBI;
1438   MachineBasicBlock::iterator E = MI.getParent()->end();
1439
1440   if (!TII->isCandidateToMergeOrPair(MI))
1441     return false;
1442
1443   // Look ahead up to LdStLimit instructions for a mergable instruction.
1444   LdStPairFlags Flags;
1445   MachineBasicBlock::iterator MergeMI =
1446       findMatchingInsn(MBBI, Flags, LdStLimit, /* FindNarrowMerge = */ true);
1447   if (MergeMI != E) {
1448     ++NumZeroStoresPromoted;
1449
1450     // Keeping the iterator straight is a pain, so we let the merge routine tell
1451     // us what the next instruction is after it's done mucking about.
1452     MBBI = mergeNarrowZeroStores(MBBI, MergeMI, Flags);
1453     return true;
1454   }
1455   return false;
1456 }
1457
1458 // Find loads and stores that can be merged into a single load or store pair
1459 // instruction.
1460 bool AArch64LoadStoreOpt::tryToPairLdStInst(MachineBasicBlock::iterator &MBBI) {
1461   MachineInstr &MI = *MBBI;
1462   MachineBasicBlock::iterator E = MI.getParent()->end();
1463
1464   if (!TII->isCandidateToMergeOrPair(MI))
1465     return false;
1466
1467   // Early exit if the offset is not possible to match. (6 bits of positive
1468   // range, plus allow an extra one in case we find a later insn that matches
1469   // with Offset-1)
1470   bool IsUnscaled = TII->isUnscaledLdSt(MI);
1471   int Offset = getLdStOffsetOp(MI).getImm();
1472   int OffsetStride = IsUnscaled ? getMemScale(MI) : 1;
1473   // Allow one more for offset.
1474   if (Offset > 0)
1475     Offset -= OffsetStride;
1476   if (!inBoundsForPair(IsUnscaled, Offset, OffsetStride))
1477     return false;
1478
1479   // Look ahead up to LdStLimit instructions for a pairable instruction.
1480   LdStPairFlags Flags;
1481   MachineBasicBlock::iterator Paired =
1482       findMatchingInsn(MBBI, Flags, LdStLimit, /* FindNarrowMerge = */ false);
1483   if (Paired != E) {
1484     ++NumPairCreated;
1485     if (TII->isUnscaledLdSt(MI))
1486       ++NumUnscaledPairCreated;
1487     // Keeping the iterator straight is a pain, so we let the merge routine tell
1488     // us what the next instruction is after it's done mucking about.
1489     MBBI = mergePairedInsns(MBBI, Paired, Flags);
1490     return true;
1491   }
1492   return false;
1493 }
1494
1495 bool AArch64LoadStoreOpt::optimizeBlock(MachineBasicBlock &MBB,
1496                                         bool EnableNarrowZeroStOpt) {
1497   bool Modified = false;
1498   // Four tranformations to do here:
1499   // 1) Find loads that directly read from stores and promote them by
1500   //    replacing with mov instructions. If the store is wider than the load,
1501   //    the load will be replaced with a bitfield extract.
1502   //      e.g.,
1503   //        str w1, [x0, #4]
1504   //        ldrh w2, [x0, #6]
1505   //        ; becomes
1506   //        str w1, [x0, #4]
1507   //        lsr w2, w1, #16
1508   for (MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
1509        MBBI != E;) {
1510     MachineInstr &MI = *MBBI;
1511     switch (MI.getOpcode()) {
1512     default:
1513       // Just move on to the next instruction.
1514       ++MBBI;
1515       break;
1516     // Scaled instructions.
1517     case AArch64::LDRBBui:
1518     case AArch64::LDRHHui:
1519     case AArch64::LDRWui:
1520     case AArch64::LDRXui:
1521     // Unscaled instructions.
1522     case AArch64::LDURBBi:
1523     case AArch64::LDURHHi:
1524     case AArch64::LDURWi:
1525     case AArch64::LDURXi: {
1526       if (tryToPromoteLoadFromStore(MBBI)) {
1527         Modified = true;
1528         break;
1529       }
1530       ++MBBI;
1531       break;
1532     }
1533     }
1534   }
1535   // 2) Merge adjacent zero stores into a wider store.
1536   //      e.g.,
1537   //        strh wzr, [x0]
1538   //        strh wzr, [x0, #2]
1539   //        ; becomes
1540   //        str wzr, [x0]
1541   //      e.g.,
1542   //        str wzr, [x0]
1543   //        str wzr, [x0, #4]
1544   //        ; becomes
1545   //        str xzr, [x0]
1546   for (MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
1547        EnableNarrowZeroStOpt && MBBI != E;) {
1548     if (isPromotableZeroStoreInst(*MBBI)) {
1549       if (tryToMergeZeroStInst(MBBI)) {
1550         Modified = true;
1551       } else
1552         ++MBBI;
1553     } else
1554       ++MBBI;
1555   }
1556
1557   // 3) Find loads and stores that can be merged into a single load or store
1558   //    pair instruction.
1559   //      e.g.,
1560   //        ldr x0, [x2]
1561   //        ldr x1, [x2, #8]
1562   //        ; becomes
1563   //        ldp x0, x1, [x2]
1564   for (MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
1565        MBBI != E;) {
1566     if (TII->isPairableLdStInst(*MBBI) && tryToPairLdStInst(MBBI))
1567       Modified = true;
1568     else
1569       ++MBBI;
1570   }
1571   // 4) Find base register updates that can be merged into the load or store
1572   //    as a base-reg writeback.
1573   //      e.g.,
1574   //        ldr x0, [x2]
1575   //        add x2, x2, #4
1576   //        ; becomes
1577   //        ldr x0, [x2], #4
1578   for (MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
1579        MBBI != E;) {
1580     MachineInstr &MI = *MBBI;
1581     // Do update merging. It's simpler to keep this separate from the above
1582     // switchs, though not strictly necessary.
1583     unsigned Opc = MI.getOpcode();
1584     switch (Opc) {
1585     default:
1586       // Just move on to the next instruction.
1587       ++MBBI;
1588       break;
1589     // Scaled instructions.
1590     case AArch64::STRSui:
1591     case AArch64::STRDui:
1592     case AArch64::STRQui:
1593     case AArch64::STRXui:
1594     case AArch64::STRWui:
1595     case AArch64::STRHHui:
1596     case AArch64::STRBBui:
1597     case AArch64::LDRSui:
1598     case AArch64::LDRDui:
1599     case AArch64::LDRQui:
1600     case AArch64::LDRXui:
1601     case AArch64::LDRWui:
1602     case AArch64::LDRHHui:
1603     case AArch64::LDRBBui:
1604     // Unscaled instructions.
1605     case AArch64::STURSi:
1606     case AArch64::STURDi:
1607     case AArch64::STURQi:
1608     case AArch64::STURWi:
1609     case AArch64::STURXi:
1610     case AArch64::LDURSi:
1611     case AArch64::LDURDi:
1612     case AArch64::LDURQi:
1613     case AArch64::LDURWi:
1614     case AArch64::LDURXi:
1615     // Paired instructions.
1616     case AArch64::LDPSi:
1617     case AArch64::LDPSWi:
1618     case AArch64::LDPDi:
1619     case AArch64::LDPQi:
1620     case AArch64::LDPWi:
1621     case AArch64::LDPXi:
1622     case AArch64::STPSi:
1623     case AArch64::STPDi:
1624     case AArch64::STPQi:
1625     case AArch64::STPWi:
1626     case AArch64::STPXi: {
1627       // Make sure this is a reg+imm (as opposed to an address reloc).
1628       if (!getLdStOffsetOp(MI).isImm()) {
1629         ++MBBI;
1630         break;
1631       }
1632       // Look forward to try to form a post-index instruction. For example,
1633       // ldr x0, [x20]
1634       // add x20, x20, #32
1635       //   merged into:
1636       // ldr x0, [x20], #32
1637       MachineBasicBlock::iterator Update =
1638           findMatchingUpdateInsnForward(MBBI, 0, UpdateLimit);
1639       if (Update != E) {
1640         // Merge the update into the ld/st.
1641         MBBI = mergeUpdateInsn(MBBI, Update, /*IsPreIdx=*/false);
1642         Modified = true;
1643         ++NumPostFolded;
1644         break;
1645       }
1646       // Don't know how to handle pre/post-index versions, so move to the next
1647       // instruction.
1648       if (TII->isUnscaledLdSt(Opc)) {
1649         ++MBBI;
1650         break;
1651       }
1652
1653       // Look back to try to find a pre-index instruction. For example,
1654       // add x0, x0, #8
1655       // ldr x1, [x0]
1656       //   merged into:
1657       // ldr x1, [x0, #8]!
1658       Update = findMatchingUpdateInsnBackward(MBBI, UpdateLimit);
1659       if (Update != E) {
1660         // Merge the update into the ld/st.
1661         MBBI = mergeUpdateInsn(MBBI, Update, /*IsPreIdx=*/true);
1662         Modified = true;
1663         ++NumPreFolded;
1664         break;
1665       }
1666       // The immediate in the load/store is scaled by the size of the memory
1667       // operation. The immediate in the add we're looking for,
1668       // however, is not, so adjust here.
1669       int UnscaledOffset = getLdStOffsetOp(MI).getImm() * getMemScale(MI);
1670
1671       // Look forward to try to find a post-index instruction. For example,
1672       // ldr x1, [x0, #64]
1673       // add x0, x0, #64
1674       //   merged into:
1675       // ldr x1, [x0, #64]!
1676       Update = findMatchingUpdateInsnForward(MBBI, UnscaledOffset, UpdateLimit);
1677       if (Update != E) {
1678         // Merge the update into the ld/st.
1679         MBBI = mergeUpdateInsn(MBBI, Update, /*IsPreIdx=*/true);
1680         Modified = true;
1681         ++NumPreFolded;
1682         break;
1683       }
1684
1685       // Nothing found. Just move to the next instruction.
1686       ++MBBI;
1687       break;
1688     }
1689     }
1690   }
1691
1692   return Modified;
1693 }
1694
1695 bool AArch64LoadStoreOpt::runOnMachineFunction(MachineFunction &Fn) {
1696   if (skipFunction(*Fn.getFunction()))
1697     return false;
1698
1699   Subtarget = &static_cast<const AArch64Subtarget &>(Fn.getSubtarget());
1700   TII = static_cast<const AArch64InstrInfo *>(Subtarget->getInstrInfo());
1701   TRI = Subtarget->getRegisterInfo();
1702
1703   // Resize the modified and used register bitfield trackers.  We do this once
1704   // per function and then clear the bitfield each time we optimize a load or
1705   // store.
1706   ModifiedRegs.resize(TRI->getNumRegs());
1707   UsedRegs.resize(TRI->getNumRegs());
1708
1709   bool Modified = false;
1710   bool enableNarrowZeroStOpt = !Subtarget->requiresStrictAlign();
1711   for (auto &MBB : Fn)
1712     Modified |= optimizeBlock(MBB, enableNarrowZeroStOpt);
1713
1714   return Modified;
1715 }
1716
1717 // FIXME: Do we need/want a pre-alloc pass like ARM has to try to keep loads and
1718 // stores near one another?  Note: The pre-RA instruction scheduler already has
1719 // hooks to try and schedule pairable loads/stores together to improve pairing
1720 // opportunities.  Thus, pre-RA pairing pass may not be worth the effort.
1721
1722 // FIXME: When pairing store instructions it's very possible for this pass to
1723 // hoist a store with a KILL marker above another use (without a KILL marker).
1724 // The resulting IR is invalid, but nothing uses the KILL markers after this
1725 // pass, so it's never caused a problem in practice.
1726
1727 /// createAArch64LoadStoreOptimizationPass - returns an instance of the
1728 /// load / store optimization pass.
1729 FunctionPass *llvm::createAArch64LoadStoreOptimizationPass() {
1730   return new AArch64LoadStoreOpt();
1731 }