[RISCV] Add pre-emit pass to make more instructions compressible

[lewis-revill]

Summary

When optimizing for size, this pass searches for instructions that are
prevented from being compressed by one of the following:

1. The use of a single uncompressed register.
2. A base register + offset where the offset is too large to be compressed and the base register may or may not already be compressed.

In the first case, if there is a compressed register available, then the
uncompressed register is copied to the compressed register and its uses
replaced. This is only done if there are enough uses that code size
would be improved.

In the second case, if a compressed register is available, then the
original base register is copied and adjusted such that:

new_base_register = base_register + adjustment
base_register + large_offset = new_base_register + small_offset

and the uses of the base register are replaced with the new base
register. Again this is only done if there are enough uses for code size
to be improved.

This pass was authored by Lewis Revill, with large offset optimization
added by Craig Blackmore.

[jrtc27]

llvm/test/CodeGen/RISCV/compress-instrs.ll

1 ↗

(On Diff #307605)

This should be a MIR test running just the new pass so it's less fragile (and can also test more interesting cases where it's hard to coerce CodeGen into creating uncompressible instructions)

[frasercrmck]

llvm/lib/Target/RISCV/RISCVCompressInstrs.cpp

214 ↗

(On Diff #307605)

Is this a strict enough check for "definition"? What about super- and sub-registers or clobbers? Would MI.modifiesRegister work better (and be simpler)?

262 ↗

(On Diff #307605)

Same question about defined...ness here.

278 ↗

(On Diff #307605)

Nit: redundant parens.

[craigblackmore]

Updated to address feedback from @jrtc27 and @frasercrmck and fix lint warnings.

[craigblackmore]

llvm/lib/Target/RISCV/RISCVCompressInstrs.cpp

214 ↗

(On Diff #307605)

Thanks, MI.modifiesRegister is better and makes this check much simpler.

262 ↗

(On Diff #307605)

At the moment isDef is sufficient as we are only expecting LW or SW. Given we are post regalloc, that means only physical integer registers (which do not have subregisters). I have added an assert so that it is clear we are only expecting LW or SW and a comment to say that the definedness check may need to be strengthened if the pass is extended to support more instructions.

llvm/test/CodeGen/RISCV/compress-instrs.ll

1 ↗

(On Diff #307605)

Thanks, I have replaced this with a MIR test.

[jrtc27]

llvm/test/CodeGen/RISCV/compress-instrs.mir

2 ↗

(On Diff #311259)

Please indent continuation lines with an additional 4 spaces.

[jrtc27]

llvm/test/CodeGen/RISCV/compress-instrs.mir

2 ↗

(On Diff #311259)

Or maybe the style is just 2. For | it seems to be generally 2, but for arguments that wrap it seems to be any of 2, 3 or 4 depending on where you look.

[craigblackmore]

Indented continuation lines in the MIR test. I couldn't see a consistent style, so opted for an indent of 2.

[craigblackmore]

Ping.

[craig.topper]

llvm/lib/Target/RISCV/CMakeLists.txt

26

I think these were in alphabetical order

llvm/lib/Target/RISCV/RISCVCompressInstrs.cpp

201 ↗

(On Diff #312419)

Use SmallVectorImpl so you don't need to repeat the 8 from the caller.

[craigblackmore]

Addressed comments from @craig.topper.

[jrtc27]

Some comments about current hard-coded assumptions. Whilst only supporting LW/SW at the moment is fine, I don't think it's a good idea to have such assumptions embedded in the design; instead it should be approximately general enough that other widths and types can be added at a later date without overhauling its core (i.e. just adding some more cases). Though at that point you might as well just support LD/SD and FLW/FSW/FLD/FSD given it'd then be trivial...

llvm/lib/Target/RISCV/RISCVCompressInstrs.cpp

99 ↗

(On Diff #317371)

Compute this based on the size of the register being loaded/stored, as this approach does not generalise.

104 ↗

(On Diff #317371)

You'll need the type here.

141 ↗

(On Diff #317371)

Ditto; compute this based on the size of the register.

189 ↗

(On Diff #317371)

NoRegister

244 ↗

(On Diff #317371)

You need the type of the register (int or float) in order to support compressing floating-point loads/stores (and so we can support capabilities in our downstream CHERI fork, both for the base and for the source/destination).

[craigblackmore]

Removed hard-coded assumptions noted by @jrtc27 and rebased. Thank you for the review and apologies for the delay in updating the patch.

[asb]

This looks good to me - many thanks for the contribution.

@jrtc27 - are you happy your comments were all addressed?

[jrtc27]

I don't understand why this is still limited to just LW and SW; you have all the bits for dealing with the differing immediate shifts already so it should be ~no effort to add LD and SD on top, and floating-point variants are just supporting additional register classes for the source and destination, some of which you again already have code for.

llvm/lib/Target/RISCV/RISCVCompressInstrs.cpp

108 ↗

(On Diff #379935)

Comment says bytes, this is bits

124 ↗

(On Diff #379935)

This is just 31 * width_in_bytes (or 31 << log2(width_in_bytes))

133 ↗

(On Diff #379935)

If this returned log2(bytes) (or you could compute it, but every user of the function is happy with log2(bytes)) then this is just

return isUIntN(6 + log2(bytes), Offset) && (Offset % (UINT64_C(1) << log2(bytes)) == 0);

(inlining a non-templated version of isShiftedUInt, since we don't seem to have an isShiftedUIntN in MathExtras.h, though perhaps it'd be better to just add it). Ditto for compressibleOffset just with 5 not 6.

163 ↗

(On Diff #379935)

You don't need the parens

214 ↗

(On Diff #379935)

There's a lot of duplicated code between loads and stores

[craigblackmore]

Add support for LD/SD/FLW/FLD/FSW/FSD and address other inline comments from @jrtc27.

[jrtc27]

llvm/lib/Target/RISCV/RISCVCompressInstrs.cpp

181 ↗

(On Diff #388866)

Stray semicolon

189 ↗

(On Diff #388866)

Can also be scaled by 8 for double-sized quantities (and 16 for us downstream). The scaling isn't really relevant here, just that it has a larger immediate (and no source/destination register restriction, as you already note).

194 ↗

(On Diff #388866)

Not rs2 in the case of loads, so I guess SrcDest or something?

202 ↗

(On Diff #388866)

I think this would be more helpful if it then went on to say what it actually did for stores

205 ↗

(On Diff #388866)

How often is storing an address to itself at offset 0 actually hit?..

206 ↗

(On Diff #388866)

I can't obviously see tests that exercise this?

llvm/test/CodeGen/RISCV/compress-instrs-i32-f-d.mir

1 ↗

(On Diff #388866)

These will need +f and +d given you use F[LS][WD]

32 ↗

(On Diff #388866)

Why null for all of these? That seems like a bad idea...

80 ↗

(On Diff #388866)

This would be better as an offset to a real pointer, not a horrible inttoptr of a constant

[jrtc27]

llvm/lib/Target/RISCV/RISCVCompressInstrs.cpp

1 ↗

(On Diff #388866)

File name is also misleading. Makes it sound like where instruction compression happens, but it's not, it's a transformation to make the instructions more amenable to compression, at the expense (in most cases) of instruction count.

219 ↗

(On Diff #388866)

You can get the MBB from the MI, otherwise you risk passing the wrong MBB

297 ↗

(On Diff #388866)

What if you hit a def of the new register?

347 ↗

(On Diff #388866)

What about when Imm is 0 and all uses can be updated?

355 ↗

(On Diff #388866)

Is it ever possible for this to return false on anything other than the final MI? Shouldn't analyzeCompressibleUses have stopped on such an instruction?

[craig.topper]

llvm/lib/Target/RISCV/RISCVCompressInstrs.cpp

77 ↗

(On Diff #388866)

This is also misleading like the filename.

100 ↗

(On Diff #388866)

There's little reason for this to return uint8_t. Just use unsigned.

139 ↗

(On Diff #388866)

Why do we need to compressibleOffset? Wouldn't the Offset & ~compressedLDSTOffsetMask(Opcode) return 0 for the same cases?

146 ↗

(On Diff #388866)

Function name should start with a verb action so isCompressedReg

153 ↗

(On Diff #388866)

isCompressibleLoad

159 ↗

(On Diff #388866)

isCompressibleStore

246 ↗

(On Diff #388866)

There should be a comma after instruction.

247 ↗

(On Diff #388866)

Comma after compressed

[craigblackmore]

Thank you for the reviews. I have updated based on the feedback and rebased.

[jrtc27]

llvm/lib/Target/RISCV/RISCVMakeCompressible.cpp

146

You don't want to be transforming FLW on RV64, that's reused for the LD encodings (ditto stores)

164

Weird spacing

llvm/test/CodeGen/RISCV/make-compressible-i32-f-d.mir

1

The names for these are a bit dodgy IMO in that they encode far too much about the specific instruction sets used, so changing that requires changing the name. Maybe make-compressible.mir and the RV64-only one to be make-compressible-rv64.mir? Or split fp out from i32 into its own file?

42

Please don't, ptrtoint is a terrible thing... store %p itself to a bitcasted %p

[craigblackmore]

llvm/lib/Target/RISCV/RISCVCompressInstrs.cpp

206 ↗

(On Diff #388866)

I have added tests for this now.

297 ↗

(On Diff #388866)

I have added a comment about this.

// The new register was scavenged for the range of instructions that are
// being updated, therefore it should not be defined within this range
// except possibly in the final instruction.

347 ↗

(On Diff #388866)

I have added a TODO to possibly update all uses in the future.

355 ↗

(On Diff #388866)

I have removed the check of the return value and removed the bool from updateOperands since it is no longer used.

[craigblackmore]

Address latest review.

• No longer transforming FLW/FSW on 64-bit.
• Fixed weird spacing.
• Renamed test files.
• Used bitcast instead of ptrtoint.

[asb]

Any thoughts from anyone on whether this should be turned on at Oz only? It can certainly increase the number of instructions executed.

[craigblackmore]

Enable at -Oz instead of -Os.

[luismarques]

Do you have an example of a benchmark or some other codebase where this pass makes a difference? I tested this in 3 different places and there were no changes at all.

[luismarques]

In D92105#3413974, @luismarques wrote:

I tested this in 3 different places and there were no changes at all.

Actually, in OpenTitan I see up to 0.5% code size gains (60 bytes) in the best case.

[craigblackmore]

The pass saves 456 bytes (0.76%) on a proprietary application.

[luismarques]

If no one has additional concerns I think this could be merged.
Thanks for the info regarding the code size gains.

[asb]

@craigblackmore: could you please take a look at compiling complex-2.c from the GCC torture suite with this patch. I'm getting incorrect output for RV32IMAFDC at Oz:

./output_rv32imafdc_ilp32_Oz/complex-2.s:16:7: error: invalid operand for instruction
        addi    fa0, ft0, 0
                ^
./output_rv32imafdc_ilp32_Oz/complex-2.s:18:7: error: invalid operand for instruction
        addi    fa1, ft1, 0
                ^

[lewis-revill]

Rebased including an update from using isShiftedUIntN to the templated replacement isShiftedUInt<N, S>. Addressed the issue of inserting incorrect instructions to copy FP registers to compressible FP registers by using FSGNJ_S and FSGNJ_D instead. We note that we can't have an additional offset to adjust the resulting register by if it is an FP register.

[reames]

Drive by review. I'm mostly using this as an exercise to get familiar with the code and the target, so please don't consider any of my comments blocking.

llvm/lib/Target/RISCV/RISCVMakeCompressible.cpp

101

I would expect us to have a means for querying the width of a load/store somewhere, and for this to simply be the log of an existing utility. I haven't dug around, but are you sure that doesn't exist?

127

Don't we have a means already for computing max offset representable in the addressing of an instruction? I'd expect us to,

306

It's not clear me to me why the last instruction has to be a load as this assert would seem to imply. Could we instead directly assert this is the last instruction somehow?

321

While this is a size opt, I'd expect improving code density to outweigh the effect of an extra register move and/or add. We should measure, but this might be useful even for O2.

344

The algorithm here appears to be O(N^2). Can we do better here?

[lewis-revill]

In D92105#3474670, @reames wrote:

Drive by review. I'm mostly using this as an exercise to get familiar with the code and the target, so please don't consider any of my comments blocking.

Thanks very much for the review

llvm/lib/Target/RISCV/RISCVMakeCompressible.cpp

101

I've had a brief look, and it seems to me the only existing way would be to use MI.memoperands_begin()->getSize(). Doesn't seem to be anything simple in TargetInstrInfo.h that we can use/override either to get this functionality.

127

No, every place which would need to check this just repeats the same logic since it's so simple.

306

We only look at loads and stores for compressibility, and as such if we see a compressible instruction which also defines the register we know it is a compressible load. We also know that since we stop when we see the next definition of the register we are looking at, but only after we've checked the defining instruction for compressibility. So the only way we are looking at a definition is if it's the final instruction.

321

Until recently this was enabled at -Os but changed to -Oz due to the increase in number of instructions executed. I suggest keeping at -Oz and changing this later if there is a motivation for it.

344

Hmm, I guess there'd be a way to accumulate the ranges that we're interested in as we go through in one iteration - though I think this would be far more difficult to implement and you might end up with issues to do with looking at instructions which are yet to be updated and making incorrect conclusions (I don't see any cause for that at a first glance but it's always possible).

[JunningWu]

In D92105#3419257, @craigblackmore wrote:

The pass saves 456 bytes (0.76%) on a proprietary application.

The pass saves 160 bytes (0.101%) on a proprietary application, from 157974 bytes-->157814 bytes.

[asb]

At the last sync-up call, @reames I believe said he had no further blocking comments (thanks for the review on this Philip). I think we're good to land this Lewis if you're happy with the current code.

[lewis-revill]

Rebased prior to commit

[iiiyours]

This comment was removed by iiiyours.

llvm/lib/Target/RISCV/CMakeLists.txt

 tablegen(LLVM RISCVGenSearchableTables.inc -gen-searchable-tables)
 tablegen(LLVM RISCVGenSubtargetInfo.inc -gen-subtarget)
 
 add_public_tablegen_target(RISCVCommonTableGen)
 
 add_llvm_target(RISCVCodeGen
   RISCVAsmPrinter.cpp
   RISCVCallLowering.cpp
+  RISCVMakeCompressible.cpp
   RISCVExpandAtomicPseudoInsts.cpp
   RISCVExpandPseudoInsts.cpp
   RISCVFrameLowering.cpp
   RISCVGatherScatterLowering.cpp
   RISCVInsertVSETVLI.cpp
   RISCVInstrInfo.cpp
   RISCVInstructionSelector.cpp
   RISCVISelDAGToDAG.cpp
   RISCVISelLowering.cpp
   RISCVLegalizerInfo.cpp

llvm/lib/Target/RISCV/RISCV.h

 
 bool lowerRISCVMachineInstrToMCInst(const MachineInstr *MI, MCInst &OutMI,
                                     AsmPrinter &AP);
 bool LowerRISCVMachineOperandToMCOperand(const MachineOperand &MO,
                                          MCOperand &MCOp, const AsmPrinter &AP);
 
 FunctionPass *createRISCVISelDag(RISCVTargetMachine &TM);
 
+FunctionPass *createRISCVMakeCompressibleOptPass();
+void initializeRISCVMakeCompressibleOptPass(PassRegistry &);
+
 FunctionPass *createRISCVGatherScatterLoweringPass();
 void initializeRISCVGatherScatterLoweringPass(PassRegistry &);
 
 FunctionPass *createRISCVSExtWRemovalPass();
 void initializeRISCVSExtWRemovalPass(PassRegistry &);
 
 FunctionPass *createRISCVMergeBaseOffsetOptPass();
 void initializeRISCVMergeBaseOffsetOptPass(PassRegistry &);

llvm/lib/Target/RISCV/RISCVMakeCompressible.cpp

+//===-- RISCVMakeCompressible.cpp - Make more instructions compressible ---===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass searches for instructions that are prevented from being compressed
+// by one of the following:
+//
+//   1. The use of a single uncompressed register.
+//   2. A base register + offset where the offset is too large to be compressed
+//   and the base register may or may not be compressed.
+//
+//
+// For case 1, if a compressed register is available, then the uncompressed
+// register is copied to the compressed register and its uses are replaced.
+//
+// For example, storing zero uses the uncompressible zero register:
+//   sw zero, 0(a0)   # if zero
+//   sw zero, 8(a0)   # if zero
+//   sw zero, 4(a0)   # if zero
+//   sw zero, 24(a0)   # if zero
+//
+// If a compressed register (e.g. a1) is available, the above can be transformed
+// to the following to improve code size:
+//   li a1, 0
+//   c.sw a1, 0(a0)
+//   c.sw a1, 8(a0)
+//   c.sw a1, 4(a0)
+//   c.sw a1, 24(a0)
+//
+//
+// For case 2, if a compressed register is available, then the original base
+// is copied and adjusted such that:
+//
+//   new_base_register = base_register + adjustment
+//   base_register + large_offset = new_base_register + small_offset
+//
+// For example, the following offsets are too large for c.sw:
+//   lui a2, 983065
+//   sw  a1, -236(a2)
+//   sw  a1, -240(a2)
+//   sw  a1, -244(a2)
+//   sw  a1, -248(a2)
+//   sw  a1, -252(a2)
+//   sw  a0, -256(a2)
+//
+// If a compressed register is available (e.g. a3), a new base could be created
+// such that the addresses can accessed with a compressible offset, thus
+// improving code size:
+//   lui a2, 983065
+//   addi  a3, a2, -256
+//   c.sw  a1, 20(a3)
+//   c.sw  a1, 16(a3)
+//   c.sw  a1, 12(a3)
+//   c.sw  a1, 8(a3)
+//   c.sw  a1, 4(a3)
+//   c.sw  a0, 0(a3)
+//
+//
+// This optimization is only applied if there are enough uses of the copied
+// register for code size to be reduced.
+//
+//===----------------------------------------------------------------------===//
+
+#include "RISCV.h"
+#include "RISCVSubtarget.h"
+#include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/RegisterScavenging.h"
+#include "llvm/MC/TargetRegistry.h"
+#include "llvm/Support/Debug.h"
+
+using namespace llvm;
+
+#define DEBUG_TYPE "riscv-make-compressible"
+#define RISCV_COMPRESS_INSTRS_NAME "RISCV Make Compressible"
+
+namespace {
+
+struct RISCVMakeCompressibleOpt : public MachineFunctionPass {
+  static char ID;
+
+  bool runOnMachineFunction(MachineFunction &Fn) override;
+
+  RISCVMakeCompressibleOpt() : MachineFunctionPass(ID) {
+    initializeRISCVMakeCompressibleOptPass(*PassRegistry::getPassRegistry());
+  }
+
+  StringRef getPassName() const override { return RISCV_COMPRESS_INSTRS_NAME; }
+};
+} // namespace
+
+char RISCVMakeCompressibleOpt::ID = 0;
+INITIALIZE_PASS(RISCVMakeCompressibleOpt, "riscv-make-compressible",
+                RISCV_COMPRESS_INSTRS_NAME, false, false)
+
+// Return log2(widthInBytes) of load/store done by Opcode.
+static unsigned log2LdstWidth(unsigned Opcode) {
+  switch (Opcode) {
+  default:
+    llvm_unreachable("Unexpected opcode");
+  case RISCV::LW:
+  case RISCV::SW:
+  case RISCV::FLW:
+  case RISCV::FSW:
+    return 2;
+  case RISCV::LD:
+  case RISCV::SD:
+  case RISCV::FLD:
+  case RISCV::FSD:
+    return 3;
+  }
+}
+
+// Return a mask for the offset bits of a non-stack-pointer based compressed
+// load/store.
+static uint8_t compressedLDSTOffsetMask(unsigned Opcode) {
+  return 0x1f << log2LdstWidth(Opcode);
+}
+
+// Return true if Offset fits within a compressed stack-pointer based
+// load/store.
+static bool compressibleSPOffset(int64_t Offset, unsigned Opcode) {
+  return isShiftedUIntN(6, log2LdstWidth(Opcode), Offset);
+}
+
+// Given an offset for a load/store, return the adjustment required to the base
+// register such that the address can be accessed with a compressible offset.
+// This will return 0 if the offset is already compressible.
+static int64_t getBaseAdjustForCompression(int64_t Offset, unsigned Opcode) {
+  // Return the excess bits that do not fit in a compressible offset.
+  return Offset & ~compressedLDSTOffsetMask(Opcode);
+}
+
+// Return true if Reg is in a compressed register class.
+static bool isCompressedReg(Register Reg) {
+  return RISCV::GPRCRegClass.contains(Reg) ||
+         RISCV::FPR32CRegClass.contains(Reg) ||
+         RISCV::FPR64CRegClass.contains(Reg);
+}
+
+// Return true if Opcode is a load for which there exists a compressed version.
+static bool isCompressibleLoad(const unsigned Opcode) {
+  return Opcode == RISCV::LW || Opcode == RISCV::FLW || Opcode == RISCV::LD ||
+         Opcode == RISCV::FLD;
+}
+
+// Return true if Opcode is a store for which there exists a compressed version.
+static bool isCompressibleStore(const unsigned Opcode) {
+  return Opcode == RISCV::SW || Opcode == RISCV::FSW || Opcode == RISCV::SD ||
+         Opcode == RISCV::FSD;
+}
+
+// Find a single register and/or large offset which, if compressible, would
+// allow the given instruction to be compressed.
+//
+// Possible return values:
+//   {Reg, 0} - Uncompressed Reg needs replacing with a compressed register.
+//   {Reg, N} - Reg needs replacing with a compressed register and N needs
+//              adding to the new register. (Reg may be compressed or
+//              uncompressed).
+//   {RISCV::NoRegister, 0}  - No suitable optimization found for this
+//                            instruction.
+static RegImmPair getRegImmPairPreventingCompression(const MachineInstr &MI) {
+  const unsigned Opcode = MI.getOpcode();
+
+  if (isCompressibleLoad(Opcode) || isCompressibleStore(Opcode)) {
+    const MachineOperand &MOImm = MI.getOperand(2);
+    if (!MOImm.isImm())
+      return RegImmPair(RISCV::NoRegister, 0);
+
+    int64_t Offset = MOImm.getImm();
+    int64_t NewBaseAdjust = getBaseAdjustForCompression(Offset, Opcode);
+    Register Base = MI.getOperand(1).getReg();
+
+    // Memory accesses via the stack pointer do not have a requirement for
+    // either of the registers to be compressible and can take a larger offset.
+    if (RISCV::SPRegClass.contains(Base)) {
+      if (!compressibleSPOffset(Offset, Opcode) && NewBaseAdjust)
+        return RegImmPair(Base, NewBaseAdjust);
+    } else {
+      Register SrcDest = MI.getOperand(0).getReg();
+      bool SrcDestCompressed = isCompressedReg(SrcDest);
+      bool BaseCompressed = isCompressedReg(Base);
+
+      // If only Base and/or offset prevent compression, then return Base and
+      // any adjustment required to make the offset compressible.
+      if ((!BaseCompressed || NewBaseAdjust) && SrcDestCompressed)
+        return RegImmPair(Base, NewBaseAdjust);
+
+      // For loads, we can only change the base register since dest is defined
+      // rather than used.
+      //
+      // For stores, we can change SrcDest (and Base if SrcDest == Base) but
+      // cannot resolve an uncompressible offset in this case.
+      if (isCompressibleStore(Opcode)) {
+        if (!SrcDestCompressed && (BaseCompressed || SrcDest == Base) &&
+            !NewBaseAdjust)
+          return RegImmPair(SrcDest, NewBaseAdjust);
+      }
+    }
+  }
+  return RegImmPair(RISCV::NoRegister, 0);
+}
+
+// Check all uses after FirstMI of the given register, keeping a vector of
+// instructions that would be compressible if the given register (and offset if
+// applicable) were compressible.
+//
+// If there are enough uses for this optimization to improve code size and a
+// compressed register is available, return that compressed register.
+static Register analyzeCompressibleUses(MachineInstr &FirstMI,
+                                        RegImmPair RegImm,
+                                        SmallVectorImpl<MachineInstr *> &MIs) {
+  MachineBasicBlock &MBB = *FirstMI.getParent();
+  const TargetRegisterInfo *TRI =
+      MBB.getParent()->getSubtarget().getRegisterInfo();
+
+  RegScavenger RS;
+  RS.enterBasicBlock(MBB);
+
+  for (MachineBasicBlock::instr_iterator I = FirstMI.getIterator(),
+                                         E = MBB.instr_end();
+       I != E; ++I) {
+    MachineInstr &MI = *I;
+
+    // Determine if this is an instruction which would benefit from using the
+    // new register.
+    RegImmPair CandidateRegImm = getRegImmPairPreventingCompression(MI);
+    if (CandidateRegImm.Reg == RegImm.Reg &&
+        CandidateRegImm.Imm == RegImm.Imm) {
+      // Advance tracking since the value in the new register must be live for
+      // this instruction too.
+      RS.forward(I);
+
+      MIs.push_back(&MI);
+    }
+
+    // If RegImm.Reg is modified by this instruction, then we cannot optimize
+    // past this instruction. If the register is already compressed, then it may
+    // possible to optimize a large offset in the current instruction - this
+    // will have been detected by the preceeding call to
+    // getRegImmPairPreventingCompression.
+    if (MI.modifiesRegister(RegImm.Reg, TRI))
+      break;
+  }
+
+  // Adjusting the base costs one new uncompressed addi and therefore three uses
+  // are required for a code size reduction. If no base adjustment is required,
+  // then copying the register costs one new c.mv (or c.li Rd, 0 for "copying"
+  // the zero register) and therefore two uses are required for a code size
+  // reduction.
+  if (MIs.size() < 2 || (RegImm.Imm != 0 && MIs.size() < 3))
+    return RISCV::NoRegister;
+
+  // Find a compressible register which will be available from the first
+  // instruction we care about to the last.
+  const TargetRegisterClass *RCToScavenge;
+
+  // Work out the compressed register class from which to scavenge.
+  if (RISCV::GPRRegClass.contains(RegImm.Reg))
+    RCToScavenge = &RISCV::GPRCRegClass;
+  else if (RISCV::FPR32RegClass.contains(RegImm.Reg))
+    RCToScavenge = &RISCV::FPR32CRegClass;
+  else if (RISCV::FPR64RegClass.contains(RegImm.Reg))
+    RCToScavenge = &RISCV::FPR64CRegClass;
+  else
+    return RISCV::NoRegister;
+
+  return RS.scavengeRegisterBackwards(*RCToScavenge, FirstMI.getIterator(),
+                                      /*RestoreAfter=*/false, /*SPAdj=*/0,
+                                      /*AllowSpill=*/false);
+}
+
+// Update uses of the old register in the given instruction to the new register.
+static void updateOperands(MachineInstr &MI, RegImmPair OldRegImm,
+                           Register NewReg) {
+  unsigned Opcode = MI.getOpcode();
+
+  // If this pass is extended to support more instructions, the check for
+  // definedness may need to be strengthened.
+  assert((isCompressibleLoad(Opcode) || isCompressibleStore(Opcode)) &&
+         "Unsupported instruction for this optimization.");
+
+  // Update registers
+  for (MachineOperand &MO : MI.operands())
+    if (MO.isReg() && MO.getReg() == OldRegImm.Reg) {
+      // Do not update operands that define the old register.
+      //
+      // The new register was scavenged for the range of instructions that are
+      // being updated, therefore it should not be defined within this range
+      // except possibly in the final instruction.
+      if (MO.isDef()) {
+        assert(isCompressibleLoad(Opcode));
+        continue;
+      }
+      // Update reg
+      MO.setReg(NewReg);
+    }
+
+  // Update offset
+  MachineOperand &MOImm = MI.getOperand(2);
+  int64_t NewOffset = MOImm.getImm() & compressedLDSTOffsetMask(Opcode);
+  MOImm.setImm(NewOffset);
+}
+
+bool RISCVMakeCompressibleOpt::runOnMachineFunction(MachineFunction &Fn) {
+  // This is a size optimization.
+  if (skipFunction(Fn.getFunction()) || !Fn.getFunction().hasOptSize())
+    return false;
+
+  const RISCVSubtarget &STI = Fn.getSubtarget<RISCVSubtarget>();
+  const RISCVInstrInfo &TII = *STI.getInstrInfo();
+
+  // This optimization only makes sense if compressed instructions are emitted.
+  if (!STI.hasStdExtC())
+    return false;
+
+  for (MachineBasicBlock &MBB : Fn) {
+    LLVM_DEBUG(dbgs() << "MBB: " << MBB.getName() << "\n");
+    for (MachineInstr &MI : MBB) {
+      // Determine if this instruction would otherwise be compressed if not for
+      // an uncompressible register or offset.
+      RegImmPair RegImm = getRegImmPairPreventingCompression(MI);
+      if (!RegImm.Reg && RegImm.Imm == 0)
+        continue;
+
+      // Determine if there is a set of instructions for which replacing this
+      // register with a compressed register (and compressible offset if
+      // applicable) is possible and will allow compression.
+      SmallVector<MachineInstr *, 8> MIs;
+      Register NewReg = analyzeCompressibleUses(MI, RegImm, MIs);
+      if (!NewReg)
+        continue;
+
+      assert(isInt<12>(RegImm.Imm));
+      BuildMI(MBB, MI, MI.getDebugLoc(), TII.get(RISCV::ADDI), NewReg)
+          .addReg(RegImm.Reg)
+          .addImm(RegImm.Imm);
+
+      // Update the set of instructions to use the compressed register and
+      // compressible offset instead. These instructions should now be
+      // compressible.
+      // TODO: Update all uses if RegImm.Imm == 0? Not just those that are
+      // expected to become compressible.
+      for (MachineInstr *UpdateMI : MIs)
+        updateOperands(*UpdateMI, RegImm, NewReg);
+    }
+  }
+  return true;
+}
+
+/// Returns an instance of the Make Compressible Optimization pass.
+FunctionPass *llvm::createRISCVMakeCompressibleOptPass() {
+  return new RISCVMakeCompressibleOpt();
+}

llvm/lib/Target/RISCV/RISCVTargetMachine.cpp

static cl::opt<bool> EnableRedundantCopyElimination(
     cl::desc("Enable the redundant copy elimination pass"), cl::init(true),
     cl::Hidden);
 
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeRISCVTarget() {
   RegisterTargetMachine<RISCVTargetMachine> X(getTheRISCV32Target());
   RegisterTargetMachine<RISCVTargetMachine> Y(getTheRISCV64Target());
   auto *PR = PassRegistry::getPassRegistry();
   initializeGlobalISel(*PR);
+  initializeRISCVMakeCompressibleOptPass(*PR);
   initializeRISCVGatherScatterLoweringPass(*PR);
   initializeRISCVMergeBaseOffsetOptPass(*PR);
   initializeRISCVSExtWRemovalPass(*PR);
   initializeRISCVExpandPseudoPass(*PR);
   initializeRISCVInsertVSETVLIPass(*PR);
 }
 
 static StringRef computeDataLayout(const Triple &TT) {

 
 bool RISCVPassConfig::addGlobalInstructionSelect() {
   addPass(new InstructionSelect(getOptLevel()));
   return false;
 }
 
 void RISCVPassConfig::addPreSched2() {}
 
-void RISCVPassConfig::addPreEmitPass() { addPass(&BranchRelaxationPassID); }
+void RISCVPassConfig::addPreEmitPass() {
+  addPass(&BranchRelaxationPassID);
+  addPass(createRISCVMakeCompressibleOptPass());
+}
 
 void RISCVPassConfig::addPreEmitPass2() {
   addPass(createRISCVExpandPseudoPass());
   // Schedule the expansion of AMOs at the last possible moment, avoiding the
   // possibility for other passes to break the requirements for forward
   // progress in the LR/SC block.
   addPass(createRISCVExpandAtomicPseudoPass());
 }

llvm/test/CodeGen/RISCV/make-compressible-i32-f-d.mir

+# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
+# RUN: llc -o - %s -mtriple=riscv32 -mattr=+c,+f,+d -simplify-mir \
+# RUN:   -run-pass=riscv-make-compressible | FileCheck --check-prefix=RV32 %s
+# RUN: llc -o - %s -mtriple=riscv64 -mattr=+c,+f,+d -simplify-mir \
+# RUN:   -run-pass=riscv-make-compressible | FileCheck --check-prefix=RV64 %s
+--- |
+
+  define void @store_common_value(i32* %a, i32* %b, i32* %c) #0 {
+  entry:
+    store i32 0, i32* %a, align 4
+    store i32 0, i32* %b, align 4
+    store i32 0, i32* %c, align 4
+    ret void
+  }
+
+  define void @store_common_value_float(float* %a, float* %b, float* %c, float %d, float %e, float %f, float %g, float %h, float %i, float %j) #0 {
+  entry:
+    store float %j, float* %a, align 4
+    store float %j, float* %b, align 4
+    store float %j, float* %c, align 4
+    ret void
+  }
+
+  define void @store_common_value_double(double* %a, double* %b, double* %c, double %d, double %e, double %f, double %g, double %h, double %i, double %j) #0 {
+  entry:
+    store double %j, double* %a, align 8
+    store double %j, double* %b, align 8
+    store double %j, double* %c, align 8
+    ret void
+  }
+
+  define void @store_common_ptr(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32* %p) #0 {
+  entry:
+    store volatile i32 1, i32* %p, align 4
+    store volatile i32 3, i32* %p, align 4
+    store volatile i32 5, i32* %p, align 4
+    ret void
+  }
+
+  define void @store_common_ptr_self(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32* %p) #0 {
+  entry:
+    %g = ptrtoint i32* %p to i32
+    store volatile i32 1, i32* %p, align 4
+    store volatile i32 3, i32* %p, align 4
+    store volatile i32 %g, i32* %p, align 4
+    ret void
+  }
+
+  define void @store_common_ptr_float(float %a, float %b, float %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %h, i32 %i, float* %p) #0 {
+  entry:
+    store volatile float %a, float* %p, align 4
+    store volatile float %b, float* %p, align 4
+    store volatile float %c, float* %p, align 4
+    ret void
+  }
+
+  define void @store_common_ptr_double(double %a, double %b, double %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %h, i32 %i, double* %p) #0 {
+  entry:
+    store volatile double %a, double* %p, align 8
+    store volatile double %b, double* %p, align 8
+    store volatile double %c, double* %p, align 8
+    ret void
+  }
+
+  define void @load_common_ptr(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32* %p) #0 {
+  entry:
+    %g = load volatile i32, i32* %p, align 4
+    %h = load volatile i32, i32* %p, align 4
+    %i = load volatile i32, i32* %p, align 4
+    ret void
+  }
+
+  define void @load_common_ptr_float(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, float* %g) #0 {
+  entry:
+    %0 = load float, float* %g, align 4
+    %arrayidx1 = getelementptr inbounds float, float* %g, i32 1
+    %1 = load float, float* %arrayidx1, align 4
+    %arrayidx2 = getelementptr inbounds float, float* %g, i32 2
+    %2 = load float, float* %arrayidx2, align 4
+    tail call void @load_common_ptr_float_1(float %0, float %1, float %2)
+    ret void
+  }
+
+  declare void @load_common_ptr_float_1(float, float, float) #0
+
+  define void @load_common_ptr_double(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, double* %g) #0 {
+  entry:
+    %0 = load double, double* %g, align 8
+    %arrayidx1 = getelementptr inbounds double, double* %g, i32 1
+    %1 = load double, double* %arrayidx1, align 8
+    %arrayidx2 = getelementptr inbounds double, double* %g, i32 2
+    %2 = load double, double* %arrayidx2, align 8
+    tail call void @load_common_ptr_double_1(double %0, double %1, double %2)
+    ret void
+  }
+
+  declare void @load_common_ptr_double_1(double, double, double) #0
+
+  define void @store_large_offset(i32* %p) #0 {
+  entry:
+    %0 = getelementptr inbounds i32, i32* %p, i32 100
+    store volatile i32 1, i32* %0, align 4
+    %1 = getelementptr inbounds i32, i32* %p, i32 101
+    store volatile i32 3, i32* %1, align 4
+    %2 = getelementptr inbounds i32, i32* %p, i32 102
+    store volatile i32 5, i32* %2, align 4
+    %3 = getelementptr inbounds i32, i32* %p, i32 103
+    store volatile i32 7, i32* %3, align 4
+    ret void
+  }
+
+  define void @store_large_offset_float(float* %p, float %a, float %b, float %c, float %d) #0 {
+  entry:
+    %0 = getelementptr inbounds float, float* %p, i32 100
+    store volatile float %a, float* %0, align 4
+    %1 = getelementptr inbounds float, float* %p, i32 101
+    store volatile float %b, float* %1, align 4
+    %2 = getelementptr inbounds float, float* %p, i32 102
+    store volatile float %c, float* %2, align 4
+    %3 = getelementptr inbounds float, float* %p, i32 103
+    store volatile float %d, float* %3, align 4
+    ret void
+  }
+
+  define void @store_large_offset_double(double* %p, double %a, double %b, double %c, double %d) #0 {
+  entry:
+    %0 = getelementptr inbounds double, double* %p, i32 100
+    store volatile double %a, double* %0, align 8
+    %1 = getelementptr inbounds double, double* %p, i32 101
+    store volatile double %b, double* %1, align 8
+    %2 = getelementptr inbounds double, double* %p, i32 102
+    store volatile double %c, double* %2, align 8
+    %3 = getelementptr inbounds double, double* %p, i32 103
+    store volatile double %d, double* %3, align 8
+    ret void
+  }
+
+  define void @load_large_offset(i32* %p) #0 {
+  entry:
+    %0 = getelementptr inbounds i32, i32* %p, i32 100
+    %a = load volatile i32, i32* %0, align 4
+    %1 = getelementptr inbounds i32, i32* %p, i32 101
+    %b = load volatile i32, i32* %1, align 4
+    %2 = getelementptr inbounds i32, i32* %p, i32 102
+    %c = load volatile i32, i32* %2, align 4
+    %3 = getelementptr inbounds i32, i32* %p, i32 103
+    %d = load volatile i32, i32* %3, align 4
+    ret void
+  }
+
+  define void @load_large_offset_float(float* %p) #0 {
+  entry:
+    %arrayidx = getelementptr inbounds float, float* %p, i32 100
+    %0 = load float, float* %arrayidx, align 4
+    %arrayidx1 = getelementptr inbounds float, float* %p, i32 101
+    %1 = load float, float* %arrayidx1, align 4
+    %arrayidx2 = getelementptr inbounds float, float* %p, i32 102
+    %2 = load float, float* %arrayidx2, align 4
+    tail call void @load_large_offset_float_1(float %0, float %1, float %2)
+    ret void
+  }
+
+  declare void @load_large_offset_float_1(float, float, float) #0
+
+  define void @load_large_offset_double(double* %p) #0 {
+  entry:
+    %arrayidx = getelementptr inbounds double, double* %p, i32 100
+    %0 = load double, double* %arrayidx, align 8
+    %arrayidx1 = getelementptr inbounds double, double* %p, i32 101
+    %1 = load double, double* %arrayidx1, align 8
+    %arrayidx2 = getelementptr inbounds double, double* %p, i32 102
+    %2 = load double, double* %arrayidx2, align 8
+    tail call void @load_large_offset_double_1(double %0, double %1, double %2)
+    ret void
+  }
+
+  declare void @load_large_offset_double_1(double, double, double) #0
+
+  define void @store_common_value_no_opt(i32* %a) #0 {
+  entry:
+    store i32 0, i32* %a, align 4
+    ret void
+  }
+
+  define void @store_common_value_float_no_opt(float* %a, float %b, float %c, float %d, float %e, float %f, float %g, float %h) #0 {
+  entry:
+    store float %h, float* %a, align 4
+    ret void
+  }
+
+  define void @store_common_value_double_no_opt(double* %a, double %b, double %c, double %d, double %e, double %f, double %g, double %h) #0 {
+  entry:
+    store double %h, double* %a, align 8
+    ret void
+  }
+
+  define void @store_common_ptr_no_opt(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32* %p) #0 {
+  entry:
+    store volatile i32 1, i32* %p, align 4
+    ret void
+  }
+
+  define void @store_common_ptr_float_no_opt(float %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, float* %p) #0 {
+  entry:
+    store volatile float %a, float* %p, align 4
+    ret void
+  }
+
+  define void @store_common_ptr_double_no_opt(double %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, double* %p) #0 {
+  entry:
+    store volatile double %a, double* %p, align 8
+    ret void
+  }
+
+  define void @load_common_ptr_no_opt(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32* %p) #0 {
+  entry:
+    %g = load volatile i32, i32* %p, align 4
+    ret void
+  }
+
+  define float @load_common_ptr_float_no_opt(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, float* %g) #0 {
+  entry:
+    %0 = load float, float* %g, align 4
+    ret float %0
+  }
+
+  define double @load_common_ptr_double_no_opt(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, double* %g) #0 {
+  entry:
+    %0 = load double, double* %g, align 8
+    ret double %0
+  }
+
+  define void @store_large_offset_no_opt(i32* %p) #0 {
+  entry:
+    %0 = getelementptr inbounds i32, i32* %p, i32 100
+    store volatile i32 1, i32* %0, align 4
+    %1 = getelementptr inbounds i32, i32* %p, i32 101
+    store volatile i32 3, i32* %1, align 4
+    ret void
+  }
+
+  define void @store_large_offset_float_no_opt(float* %p, float %a, float %b) #0 {
+  entry:
+    %0 = getelementptr inbounds float, float* %p, i32 100
+    store volatile float %a, float* %0, align 4
+    %1 = getelementptr inbounds float, float* %p, i32 101
+    store volatile float %b, float* %1, align 4
+    ret void
+  }
+
+  define void @store_large_offset_double_no_opt(double* %p, double %a, double %b) #0 {
+  entry:
+    %0 = getelementptr inbounds double, double* %p, i32 100
+    store volatile double %a, double* %0, align 8
+    %1 = getelementptr inbounds double, double* %p, i32 101
+    store volatile double %b, double* %1, align 8
+    ret void
+  }
+
+  define void @load_large_offset_no_opt(i32* %p) #0 {
+  entry:
+    %0 = getelementptr inbounds i32, i32* %p, i32 100
+    %a = load volatile i32, i32* %0, align 4
+    %1 = getelementptr inbounds i32, i32* %p, i32 101
+    %b = load volatile i32, i32* %1, align 4
+    ret void
+  }
+
+  define { float, float } @load_large_offset_float_no_opt(float* %p) #0 {
+  entry:
+    %arrayidx = getelementptr inbounds float, float* %p, i32 100
+    %0 = load float, float* %arrayidx, align 4
+    %arrayidx1 = getelementptr inbounds float, float* %p, i32 101
+    %1 = load float, float* %arrayidx1, align 4
+    %2 = insertvalue { float, float } undef, float %0, 0
+    %3 = insertvalue { float, float } %2, float %1, 1
+    ret { float, float } %3
+  }
+
+  define { double, double } @load_large_offset_double_no_opt(double* %p) #0 {
+  entry:
+    %arrayidx = getelementptr inbounds double, double* %p, i32 100
+    %0 = load double, double* %arrayidx, align 8
+    %arrayidx1 = getelementptr inbounds double, double* %p, i32 101
+    %1 = load double, double* %arrayidx1, align 8
+    %2 = insertvalue { double, double } undef, double %0, 0
+    %3 = insertvalue { double, double } %2, double %1, 1
+    ret { double, double } %3
+  }
+
+  attributes #0 = { optsize "target-features"="+c,+f,+d" }
+
+...
+---
+name:            store_common_value
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10, $x11, $x12
+
+    ; RV32-LABEL: name: store_common_value
+    ; RV32: liveins: $x10, $x11, $x12
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $x13 = ADDI $x0, 0
+    ; RV32-NEXT: SW $x13, killed renamable $x10, 0 :: (store (s32) into %ir.a)
+    ; RV32-NEXT: SW $x13, killed renamable $x11, 0 :: (store (s32) into %ir.b)
+    ; RV32-NEXT: SW $x13, killed renamable $x12, 0 :: (store (s32) into %ir.c)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_value
+    ; RV64: liveins: $x10, $x11, $x12
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $x13 = ADDI $x0, 0
+    ; RV64-NEXT: SW $x13, killed renamable $x10, 0 :: (store (s32) into %ir.a)
+    ; RV64-NEXT: SW $x13, killed renamable $x11, 0 :: (store (s32) into %ir.b)
+    ; RV64-NEXT: SW $x13, killed renamable $x12, 0 :: (store (s32) into %ir.c)
+    ; RV64-NEXT: PseudoRET
+    SW $x0, killed renamable $x10, 0 :: (store (s32) into %ir.a)
+    SW $x0, killed renamable $x11, 0 :: (store (s32) into %ir.b)
+    SW $x0, killed renamable $x12, 0 :: (store (s32) into %ir.c)
+    PseudoRET
+
+...
+---
+name:            store_common_value_float
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10, $x11, $x12, $f16_f
+
+    ; RV32-LABEL: name: store_common_value_float
+    ; RV32: liveins: $x10, $x11, $x12, $f16_f
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $f10_f = ADDI $f16_f, 0
+    ; RV32-NEXT: FSW $f10_f, killed renamable $x10, 0 :: (store (s32) into %ir.a)
+    ; RV32-NEXT: FSW $f10_f, killed renamable $x11, 0 :: (store (s32) into %ir.b)
+    ; RV32-NEXT: FSW killed $f10_f, killed renamable $x12, 0 :: (store (s32) into %ir.c)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_value_float
+    ; RV64: liveins: $x10, $x11, $x12, $f16_f
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $f10_f = ADDI $f16_f, 0
+    ; RV64-NEXT: FSW $f10_f, killed renamable $x10, 0 :: (store (s32) into %ir.a)
+    ; RV64-NEXT: FSW $f10_f, killed renamable $x11, 0 :: (store (s32) into %ir.b)
+    ; RV64-NEXT: FSW killed $f10_f, killed renamable $x12, 0 :: (store (s32) into %ir.c)
+    ; RV64-NEXT: PseudoRET
+    FSW renamable $f16_f, killed renamable $x10, 0 :: (store (s32) into %ir.a)
+    FSW renamable $f16_f, killed renamable $x11, 0 :: (store (s32) into %ir.b)
+    FSW killed renamable $f16_f, killed renamable $x12, 0 :: (store (s32) into %ir.c)
+    PseudoRET
+
+...
+---
+name:            store_common_value_double
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10, $x11, $x12, $f16_d
+
+    ; RV32-LABEL: name: store_common_value_double
+    ; RV32: liveins: $x10, $x11, $x12, $f16_d
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $f10_d = ADDI $f16_d, 0
+    ; RV32-NEXT: FSD $f10_d, killed renamable $x10, 0 :: (store (s64) into %ir.a)
+    ; RV32-NEXT: FSD $f10_d, killed renamable $x11, 0 :: (store (s64) into %ir.b)
+    ; RV32-NEXT: FSD killed $f10_d, killed renamable $x12, 0 :: (store (s64) into %ir.c)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_value_double
+    ; RV64: liveins: $x10, $x11, $x12, $f16_d
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $f10_d = ADDI $f16_d, 0
+    ; RV64-NEXT: FSD $f10_d, killed renamable $x10, 0 :: (store (s64) into %ir.a)
+    ; RV64-NEXT: FSD $f10_d, killed renamable $x11, 0 :: (store (s64) into %ir.b)
+    ; RV64-NEXT: FSD killed $f10_d, killed renamable $x12, 0 :: (store (s64) into %ir.c)
+    ; RV64-NEXT: PseudoRET
+    FSD renamable $f16_d, killed renamable $x10, 0 :: (store (s64) into %ir.a)
+    FSD renamable $f16_d, killed renamable $x11, 0 :: (store (s64) into %ir.b)
+    FSD killed renamable $f16_d, killed renamable $x12, 0 :: (store (s64) into %ir.c)
+    PseudoRET
+
+...
+---
+name:            store_common_ptr
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; RV32-LABEL: name: store_common_ptr
+    ; RV32: liveins: $x16
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: renamable $x10 = ADDI $x0, 1
+    ; RV32-NEXT: $x11 = ADDI $x16, 0
+    ; RV32-NEXT: SW killed renamable $x10, $x11, 0 :: (volatile store (s32) into %ir.p)
+    ; RV32-NEXT: renamable $x10 = ADDI $x0, 3
+    ; RV32-NEXT: SW killed renamable $x10, $x11, 0 :: (volatile store (s32) into %ir.p)
+    ; RV32-NEXT: renamable $x10 = ADDI $x0, 5
+    ; RV32-NEXT: SW killed renamable $x10, killed $x11, 0 :: (volatile store (s32) into %ir.p)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_ptr
+    ; RV64: liveins: $x16
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: renamable $x10 = ADDI $x0, 1
+    ; RV64-NEXT: $x11 = ADDI $x16, 0
+    ; RV64-NEXT: SW killed renamable $x10, $x11, 0 :: (volatile store (s32) into %ir.p)
+    ; RV64-NEXT: renamable $x10 = ADDI $x0, 3
+    ; RV64-NEXT: SW killed renamable $x10, $x11, 0 :: (volatile store (s32) into %ir.p)
+    ; RV64-NEXT: renamable $x10 = ADDI $x0, 5
+    ; RV64-NEXT: SW killed renamable $x10, killed $x11, 0 :: (volatile store (s32) into %ir.p)
+    ; RV64-NEXT: PseudoRET
+    renamable $x10 = ADDI $x0, 1
+    SW killed renamable $x10, renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    renamable $x10 = ADDI $x0, 3
+    SW killed renamable $x10, renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    renamable $x10 = ADDI $x0, 5
+    SW killed renamable $x10, killed renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    PseudoRET
+
+...
+---
+name:            store_common_ptr_self
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; RV32-LABEL: name: store_common_ptr_self
+    ; RV32: liveins: $x16
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: renamable $x10 = ADDI $x0, 1
+    ; RV32-NEXT: $x11 = ADDI $x16, 0
+    ; RV32-NEXT: SW killed renamable $x10, $x11, 0 :: (volatile store (s32) into %ir.p)
+    ; RV32-NEXT: renamable $x10 = ADDI $x0, 3
+    ; RV32-NEXT: SW killed renamable $x10, $x11, 0 :: (volatile store (s32) into %ir.p)
+    ; RV32-NEXT: SW killed $x11, $x11, 0 :: (volatile store (s32) into %ir.p)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_ptr_self
+    ; RV64: liveins: $x16
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: renamable $x10 = ADDI $x0, 1
+    ; RV64-NEXT: $x11 = ADDI $x16, 0
+    ; RV64-NEXT: SW killed renamable $x10, $x11, 0 :: (volatile store (s32) into %ir.p)
+    ; RV64-NEXT: renamable $x10 = ADDI $x0, 3
+    ; RV64-NEXT: SW killed renamable $x10, $x11, 0 :: (volatile store (s32) into %ir.p)
+    ; RV64-NEXT: SW killed $x11, $x11, 0 :: (volatile store (s32) into %ir.p)
+    ; RV64-NEXT: PseudoRET
+    renamable $x10 = ADDI $x0, 1
+    SW killed renamable $x10, renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    renamable $x10 = ADDI $x0, 3
+    SW killed renamable $x10, renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    SW killed renamable $x16, renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    PseudoRET
+
+...
+---
+name:            store_common_ptr_float
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16, $f10_f, $f11_f, $f12_f
+
+    ; RV32-LABEL: name: store_common_ptr_float
+    ; RV32: liveins: $x16, $f10_f, $f11_f, $f12_f
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $x10 = ADDI $x16, 0
+    ; RV32-NEXT: FSW killed renamable $f10_f, $x10, 0 :: (volatile store (s32) into %ir.p)
+    ; RV32-NEXT: FSW killed renamable $f11_f, $x10, 0 :: (volatile store (s32) into %ir.p)
+    ; RV32-NEXT: FSW killed renamable $f12_f, killed $x10, 0 :: (volatile store (s32) into %ir.p)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_ptr_float
+    ; RV64: liveins: $x16, $f10_f, $f11_f, $f12_f
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $x10 = ADDI $x16, 0
+    ; RV64-NEXT: FSW killed renamable $f10_f, $x10, 0 :: (volatile store (s32) into %ir.p)
+    ; RV64-NEXT: FSW killed renamable $f11_f, $x10, 0 :: (volatile store (s32) into %ir.p)
+    ; RV64-NEXT: FSW killed renamable $f12_f, killed $x10, 0 :: (volatile store (s32) into %ir.p)
+    ; RV64-NEXT: PseudoRET
+    FSW killed renamable $f10_f, renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    FSW killed renamable $f11_f, renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    FSW killed renamable $f12_f, killed renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    PseudoRET
+
+...
+---
+name:            store_common_ptr_double
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16, $f10_d, $f11_d, $f12_d
+
+    ; RV32-LABEL: name: store_common_ptr_double
+    ; RV32: liveins: $x16, $f10_d, $f11_d, $f12_d
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $x10 = ADDI $x16, 0
+    ; RV32-NEXT: FSD killed renamable $f10_d, $x10, 0 :: (volatile store (s64) into %ir.p)
+    ; RV32-NEXT: FSD killed renamable $f11_d, $x10, 0 :: (volatile store (s64) into %ir.p)
+    ; RV32-NEXT: FSD killed renamable $f12_d, killed $x10, 0 :: (volatile store (s64) into %ir.p)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_ptr_double
+    ; RV64: liveins: $x16, $f10_d, $f11_d, $f12_d
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $x10 = ADDI $x16, 0
+    ; RV64-NEXT: FSD killed renamable $f10_d, $x10, 0 :: (volatile store (s64) into %ir.p)
+    ; RV64-NEXT: FSD killed renamable $f11_d, $x10, 0 :: (volatile store (s64) into %ir.p)
+    ; RV64-NEXT: FSD killed renamable $f12_d, killed $x10, 0 :: (volatile store (s64) into %ir.p)
+    ; RV64-NEXT: PseudoRET
+    FSD killed renamable $f10_d, renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    FSD killed renamable $f11_d, renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    FSD killed renamable $f12_d, killed renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    PseudoRET
+
+...
+---
+name:            load_common_ptr
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; RV32-LABEL: name: load_common_ptr
+    ; RV32: liveins: $x16
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $x11 = ADDI $x16, 0
+    ; RV32-NEXT: dead renamable $x10 = LW $x11, 0 :: (volatile load (s32) from %ir.p)
+    ; RV32-NEXT: dead renamable $x10 = LW $x11, 0 :: (volatile load (s32) from %ir.p)
+    ; RV32-NEXT: dead renamable $x10 = LW killed $x11, 0 :: (volatile load (s32) from %ir.p)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: load_common_ptr
+    ; RV64: liveins: $x16
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $x11 = ADDI $x16, 0
+    ; RV64-NEXT: dead renamable $x10 = LW $x11, 0 :: (volatile load (s32) from %ir.p)
+    ; RV64-NEXT: dead renamable $x10 = LW $x11, 0 :: (volatile load (s32) from %ir.p)
+    ; RV64-NEXT: dead renamable $x10 = LW killed $x11, 0 :: (volatile load (s32) from %ir.p)
+    ; RV64-NEXT: PseudoRET
+    dead renamable $x10 = LW renamable $x16, 0 :: (volatile load (s32) from %ir.p)
+    dead renamable $x10 = LW renamable $x16, 0 :: (volatile load (s32) from %ir.p)
+    dead renamable $x10 = LW killed renamable $x16, 0 :: (volatile load (s32) from %ir.p)
+    PseudoRET
+
+...
+---
+name:            load_common_ptr_float
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; RV32-LABEL: name: load_common_ptr_float
+    ; RV32: liveins: $x16
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $x10 = ADDI $x16, 0
+    ; RV32-NEXT: renamable $f10_f = FLW $x10, 0 :: (load (s32) from %ir.g)
+    ; RV32-NEXT: renamable $f11_f = FLW $x10, 4 :: (load (s32) from %ir.arrayidx1)
+    ; RV32-NEXT: renamable $f12_f = FLW killed $x10, 8 :: (load (s32) from %ir.arrayidx2)
+    ; RV32-NEXT: PseudoTAIL target-flags(riscv-plt) @load_common_ptr_float_1, implicit $x2, implicit $f10_f, implicit $f11_f, implicit $f12_f
+    ; RV64-LABEL: name: load_common_ptr_float
+    ; RV64: liveins: $x16
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $x10 = ADDI $x16, 0
+    ; RV64-NEXT: renamable $f10_f = FLW $x10, 0 :: (load (s32) from %ir.g)
+    ; RV64-NEXT: renamable $f11_f = FLW $x10, 4 :: (load (s32) from %ir.arrayidx1)
+    ; RV64-NEXT: renamable $f12_f = FLW killed $x10, 8 :: (load (s32) from %ir.arrayidx2)
+    ; RV64-NEXT: PseudoTAIL target-flags(riscv-plt) @load_common_ptr_float_1, implicit $x2, implicit $f10_f, implicit $f11_f, implicit $f12_f
+    renamable $f10_f = FLW renamable $x16, 0 :: (load (s32) from %ir.g)
+    renamable $f11_f = FLW renamable $x16, 4 :: (load (s32) from %ir.arrayidx1)
+    renamable $f12_f = FLW killed renamable $x16, 8 :: (load (s32) from %ir.arrayidx2)
+    PseudoTAIL target-flags(riscv-plt) @load_common_ptr_float_1, implicit $x2, implicit $f10_f, implicit $f11_f, implicit $f12_f
+
+...
+---
+name:            load_common_ptr_double
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; RV32-LABEL: name: load_common_ptr_double
+    ; RV32: liveins: $x16
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $x10 = ADDI $x16, 0
+    ; RV32-NEXT: renamable $f10_d = FLD $x10, 0 :: (load (s64) from %ir.g)
+    ; RV32-NEXT: renamable $f11_d = FLD $x10, 8 :: (load (s64) from %ir.arrayidx1)
+    ; RV32-NEXT: renamable $f12_d = FLD killed $x10, 16 :: (load (s64) from %ir.arrayidx2)
+    ; RV32-NEXT: PseudoTAIL target-flags(riscv-plt) @load_common_ptr_double_1, implicit $x2, implicit $f10_d, implicit $f11_d, implicit $f12_d
+    ; RV64-LABEL: name: load_common_ptr_double
+    ; RV64: liveins: $x16
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $x10 = ADDI $x16, 0
+    ; RV64-NEXT: renamable $f10_d = FLD $x10, 0 :: (load (s64) from %ir.g)
+    ; RV64-NEXT: renamable $f11_d = FLD $x10, 8 :: (load (s64) from %ir.arrayidx1)
+    ; RV64-NEXT: renamable $f12_d = FLD killed $x10, 16 :: (load (s64) from %ir.arrayidx2)
+    ; RV64-NEXT: PseudoTAIL target-flags(riscv-plt) @load_common_ptr_double_1, implicit $x2, implicit $f10_d, implicit $f11_d, implicit $f12_d
+    renamable $f10_d = FLD renamable $x16, 0 :: (load (s64) from %ir.g)
+    renamable $f11_d = FLD renamable $x16, 8 :: (load (s64) from %ir.arrayidx1)
+    renamable $f12_d = FLD killed renamable $x16, 16 :: (load (s64) from %ir.arrayidx2)
+    PseudoTAIL target-flags(riscv-plt) @load_common_ptr_double_1, implicit $x2, implicit $f10_d, implicit $f11_d, implicit $f12_d
+
+...
+---
+name:            store_large_offset
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; RV32-LABEL: name: store_large_offset
+    ; RV32: liveins: $x10
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: renamable $x11 = ADDI $x0, 1
+    ; RV32-NEXT: $x12 = ADDI $x10, 384
+    ; RV32-NEXT: SW killed renamable $x11, $x12, 16 :: (volatile store (s32) into %ir.0)
+    ; RV32-NEXT: renamable $x11 = ADDI $x0, 3
+    ; RV32-NEXT: SW killed renamable $x11, $x12, 20 :: (volatile store (s32) into %ir.1)
+    ; RV32-NEXT: renamable $x11 = ADDI $x0, 5
+    ; RV32-NEXT: SW killed renamable $x11, $x12, 24 :: (volatile store (s32) into %ir.2)
+    ; RV32-NEXT: renamable $x11 = ADDI $x0, 7
+    ; RV32-NEXT: SW killed renamable $x11, killed $x12, 28 :: (volatile store (s32) into %ir.3)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_large_offset
+    ; RV64: liveins: $x10
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: renamable $x11 = ADDI $x0, 1
+    ; RV64-NEXT: $x12 = ADDI $x10, 384
+    ; RV64-NEXT: SW killed renamable $x11, $x12, 16 :: (volatile store (s32) into %ir.0)
+    ; RV64-NEXT: renamable $x11 = ADDI $x0, 3
+    ; RV64-NEXT: SW killed renamable $x11, $x12, 20 :: (volatile store (s32) into %ir.1)
+    ; RV64-NEXT: renamable $x11 = ADDI $x0, 5
+    ; RV64-NEXT: SW killed renamable $x11, $x12, 24 :: (volatile store (s32) into %ir.2)
+    ; RV64-NEXT: renamable $x11 = ADDI $x0, 7
+    ; RV64-NEXT: SW killed renamable $x11, killed $x12, 28 :: (volatile store (s32) into %ir.3)
+    ; RV64-NEXT: PseudoRET
+    renamable $x11 = ADDI $x0, 1
+    SW killed renamable $x11, renamable $x10, 400 :: (volatile store (s32) into %ir.0)
+    renamable $x11 = ADDI $x0, 3
+    SW killed renamable $x11, renamable $x10, 404 :: (volatile store (s32) into %ir.1)
+    renamable $x11 = ADDI $x0, 5
+    SW killed renamable $x11, renamable $x10, 408 :: (volatile store (s32) into %ir.2)
+    renamable $x11 = ADDI $x0, 7
+    SW killed renamable $x11, killed renamable $x10, 412 :: (volatile store (s32) into %ir.3)
+    PseudoRET
+
+...
+---
+name:            store_large_offset_float
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10, $f10_f, $f11_f, $f12_f, $f13_f
+
+    ; RV32-LABEL: name: store_large_offset_float
+    ; RV32: liveins: $x10, $f10_f, $f11_f, $f12_f, $f13_f
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $x11 = ADDI $x10, 384
+    ; RV32-NEXT: FSW killed renamable $f10_f, $x11, 16 :: (volatile store (s32) into %ir.0)
+    ; RV32-NEXT: FSW killed renamable $f11_f, $x11, 20 :: (volatile store (s32) into %ir.1)
+    ; RV32-NEXT: FSW killed renamable $f12_f, $x11, 24 :: (volatile store (s32) into %ir.2)
+    ; RV32-NEXT: FSW killed renamable $f13_f, killed $x11, 28 :: (volatile store (s32) into %ir.3)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_large_offset_float
+    ; RV64: liveins: $x10, $f10_f, $f11_f, $f12_f, $f13_f
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $x11 = ADDI $x10, 384
+    ; RV64-NEXT: FSW killed renamable $f10_f, $x11, 16 :: (volatile store (s32) into %ir.0)
+    ; RV64-NEXT: FSW killed renamable $f11_f, $x11, 20 :: (volatile store (s32) into %ir.1)
+    ; RV64-NEXT: FSW killed renamable $f12_f, $x11, 24 :: (volatile store (s32) into %ir.2)
+    ; RV64-NEXT: FSW killed renamable $f13_f, killed $x11, 28 :: (volatile store (s32) into %ir.3)
+    ; RV64-NEXT: PseudoRET
+    FSW killed renamable $f10_f, renamable $x10, 400 :: (volatile store (s32) into %ir.0)
+    FSW killed renamable $f11_f, renamable $x10, 404 :: (volatile store (s32) into %ir.1)
+    FSW killed renamable $f12_f, renamable $x10, 408 :: (volatile store (s32) into %ir.2)
+    FSW killed renamable $f13_f, killed renamable $x10, 412 :: (volatile store (s32) into %ir.3)
+    PseudoRET
+
+...
+---
+name:            store_large_offset_double
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10, $f10_d, $f11_d, $f12_d, $f13_d
+
+    ; RV32-LABEL: name: store_large_offset_double
+    ; RV32: liveins: $x10, $f10_d, $f11_d, $f12_d, $f13_d
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $x11 = ADDI $x10, 768
+    ; RV32-NEXT: FSD killed renamable $f10_d, $x11, 32 :: (volatile store (s64) into %ir.0)
+    ; RV32-NEXT: FSD killed renamable $f11_d, $x11, 40 :: (volatile store (s64) into %ir.1)
+    ; RV32-NEXT: FSD killed renamable $f12_d, $x11, 48 :: (volatile store (s64) into %ir.2)
+    ; RV32-NEXT: FSD killed renamable $f13_d, killed $x11, 56 :: (volatile store (s64) into %ir.3)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_large_offset_double
+    ; RV64: liveins: $x10, $f10_d, $f11_d, $f12_d, $f13_d
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $x11 = ADDI $x10, 768
+    ; RV64-NEXT: FSD killed renamable $f10_d, $x11, 32 :: (volatile store (s64) into %ir.0)
+    ; RV64-NEXT: FSD killed renamable $f11_d, $x11, 40 :: (volatile store (s64) into %ir.1)
+    ; RV64-NEXT: FSD killed renamable $f12_d, $x11, 48 :: (volatile store (s64) into %ir.2)
+    ; RV64-NEXT: FSD killed renamable $f13_d, killed $x11, 56 :: (volatile store (s64) into %ir.3)
+    ; RV64-NEXT: PseudoRET
+    FSD killed renamable $f10_d, renamable $x10, 800 :: (volatile store (s64) into %ir.0)
+    FSD killed renamable $f11_d, renamable $x10, 808 :: (volatile store (s64) into %ir.1)
+    FSD killed renamable $f12_d, renamable $x10, 816 :: (volatile store (s64) into %ir.2)
+    FSD killed renamable $f13_d, killed renamable $x10, 824 :: (volatile store (s64) into %ir.3)
+    PseudoRET
+
+...
+---
+name:            load_large_offset
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; RV32-LABEL: name: load_large_offset
+    ; RV32: liveins: $x10
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $x12 = ADDI $x10, 384
+    ; RV32-NEXT: dead renamable $x11 = LW $x12, 16 :: (volatile load (s32) from %ir.0)
+    ; RV32-NEXT: dead renamable $x11 = LW $x12, 20 :: (volatile load (s32) from %ir.1)
+    ; RV32-NEXT: dead renamable $x11 = LW $x12, 24 :: (volatile load (s32) from %ir.2)
+    ; RV32-NEXT: dead renamable $x10 = LW killed $x12, 28 :: (volatile load (s32) from %ir.3)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: load_large_offset
+    ; RV64: liveins: $x10
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $x12 = ADDI $x10, 384
+    ; RV64-NEXT: dead renamable $x11 = LW $x12, 16 :: (volatile load (s32) from %ir.0)
+    ; RV64-NEXT: dead renamable $x11 = LW $x12, 20 :: (volatile load (s32) from %ir.1)
+    ; RV64-NEXT: dead renamable $x11 = LW $x12, 24 :: (volatile load (s32) from %ir.2)
+    ; RV64-NEXT: dead renamable $x10 = LW killed $x12, 28 :: (volatile load (s32) from %ir.3)
+    ; RV64-NEXT: PseudoRET
+    dead renamable $x11 = LW renamable $x10, 400 :: (volatile load (s32) from %ir.0)
+    dead renamable $x11 = LW renamable $x10, 404 :: (volatile load (s32) from %ir.1)
+    dead renamable $x11 = LW renamable $x10, 408 :: (volatile load (s32) from %ir.2)
+    dead renamable $x10 = LW killed renamable $x10, 412 :: (volatile load (s32) from %ir.3)
+    PseudoRET
+
+...
+---
+name:            load_large_offset_float
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; RV32-LABEL: name: load_large_offset_float
+    ; RV32: liveins: $x10
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $x11 = ADDI $x10, 384
+    ; RV32-NEXT: renamable $f10_f = FLW $x11, 16 :: (load (s32) from %ir.arrayidx)
+    ; RV32-NEXT: renamable $f11_f = FLW $x11, 20 :: (load (s32) from %ir.arrayidx1)
+    ; RV32-NEXT: renamable $f12_f = FLW killed $x11, 24 :: (load (s32) from %ir.arrayidx2)
+    ; RV32-NEXT: PseudoTAIL target-flags(riscv-plt) @load_large_offset_float_1, implicit $x2, implicit $f10_f, implicit $f11_f, implicit $f12_f
+    ; RV64-LABEL: name: load_large_offset_float
+    ; RV64: liveins: $x10
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $x11 = ADDI $x10, 384
+    ; RV64-NEXT: renamable $f10_f = FLW $x11, 16 :: (load (s32) from %ir.arrayidx)
+    ; RV64-NEXT: renamable $f11_f = FLW $x11, 20 :: (load (s32) from %ir.arrayidx1)
+    ; RV64-NEXT: renamable $f12_f = FLW killed $x11, 24 :: (load (s32) from %ir.arrayidx2)
+    ; RV64-NEXT: PseudoTAIL target-flags(riscv-plt) @load_large_offset_float_1, implicit $x2, implicit $f10_f, implicit $f11_f, implicit $f12_f
+    renamable $f10_f = FLW renamable $x10, 400 :: (load (s32) from %ir.arrayidx)
+    renamable $f11_f = FLW renamable $x10, 404 :: (load (s32) from %ir.arrayidx1)
+    renamable $f12_f = FLW killed renamable $x10, 408 :: (load (s32) from %ir.arrayidx2)
+    PseudoTAIL target-flags(riscv-plt) @load_large_offset_float_1, implicit $x2, implicit $f10_f, implicit $f11_f, implicit $f12_f
+
+...
+---
+name:            load_large_offset_double
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; RV32-LABEL: name: load_large_offset_double
+    ; RV32: liveins: $x10
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: $x11 = ADDI $x10, 768
+    ; RV32-NEXT: renamable $f10_d = FLD $x11, 32 :: (load (s64) from %ir.arrayidx)
+    ; RV32-NEXT: renamable $f11_d = FLD $x11, 40 :: (load (s64) from %ir.arrayidx1)
+    ; RV32-NEXT: renamable $f12_d = FLD killed $x11, 48 :: (load (s64) from %ir.arrayidx2)
+    ; RV32-NEXT: PseudoTAIL target-flags(riscv-plt) @load_large_offset_double_1, implicit $x2, implicit $f10_d, implicit $f11_d, implicit $f12_d
+    ; RV64-LABEL: name: load_large_offset_double
+    ; RV64: liveins: $x10
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: $x11 = ADDI $x10, 768
+    ; RV64-NEXT: renamable $f10_d = FLD $x11, 32 :: (load (s64) from %ir.arrayidx)
+    ; RV64-NEXT: renamable $f11_d = FLD $x11, 40 :: (load (s64) from %ir.arrayidx1)
+    ; RV64-NEXT: renamable $f12_d = FLD killed $x11, 48 :: (load (s64) from %ir.arrayidx2)
+    ; RV64-NEXT: PseudoTAIL target-flags(riscv-plt) @load_large_offset_double_1, implicit $x2, implicit $f10_d, implicit $f11_d, implicit $f12_d
+    renamable $f10_d = FLD renamable $x10, 800 :: (load (s64) from %ir.arrayidx)
+    renamable $f11_d = FLD renamable $x10, 808 :: (load (s64) from %ir.arrayidx1)
+    renamable $f12_d = FLD killed renamable $x10, 816 :: (load (s64) from %ir.arrayidx2)
+    PseudoTAIL target-flags(riscv-plt) @load_large_offset_double_1, implicit $x2, implicit $f10_d, implicit $f11_d, implicit $f12_d
+
+...
+---
+name:            store_common_value_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; RV32-LABEL: name: store_common_value_no_opt
+    ; RV32: liveins: $x10
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: SW $x0, killed renamable $x10, 0 :: (store (s32) into %ir.a)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_value_no_opt
+    ; RV64: liveins: $x10
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: SW $x0, killed renamable $x10, 0 :: (store (s32) into %ir.a)
+    ; RV64-NEXT: PseudoRET
+    SW $x0, killed renamable $x10, 0 :: (store (s32) into %ir.a)
+    PseudoRET
+
+...
+---
+name:            store_common_value_float_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10, $f16_f
+
+    ; RV32-LABEL: name: store_common_value_float_no_opt
+    ; RV32: liveins: $x10, $f16_f
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: FSW killed renamable $f16_f, killed renamable $x10, 0 :: (store (s32) into %ir.a)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_value_float_no_opt
+    ; RV64: liveins: $x10, $f16_f
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: FSW killed renamable $f16_f, killed renamable $x10, 0 :: (store (s32) into %ir.a)
+    ; RV64-NEXT: PseudoRET
+    FSW killed renamable $f16_f, killed renamable $x10, 0 :: (store (s32) into %ir.a)
+    PseudoRET
+
+...
+---
+name:            store_common_value_double_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10, $f16_d
+
+    ; RV32-LABEL: name: store_common_value_double_no_opt
+    ; RV32: liveins: $x10, $f16_d
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: FSD killed renamable $f16_d, killed renamable $x10, 0 :: (store (s64) into %ir.a)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_value_double_no_opt
+    ; RV64: liveins: $x10, $f16_d
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: FSD killed renamable $f16_d, killed renamable $x10, 0 :: (store (s64) into %ir.a)
+    ; RV64-NEXT: PseudoRET
+    FSD killed renamable $f16_d, killed renamable $x10, 0 :: (store (s64) into %ir.a)
+    PseudoRET
+
+...
+---
+name:            store_common_ptr_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; RV32-LABEL: name: store_common_ptr_no_opt
+    ; RV32: liveins: $x16
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: renamable $x10 = ADDI $x0, 1
+    ; RV32-NEXT: SW killed renamable $x10, killed renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_ptr_no_opt
+    ; RV64: liveins: $x16
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: renamable $x10 = ADDI $x0, 1
+    ; RV64-NEXT: SW killed renamable $x10, killed renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    ; RV64-NEXT: PseudoRET
+    renamable $x10 = ADDI $x0, 1
+    SW killed renamable $x10, killed renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    PseudoRET
+
+...
+---
+name:            store_common_ptr_float_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16, $f10_f
+
+    ; RV32-LABEL: name: store_common_ptr_float_no_opt
+    ; RV32: liveins: $x16, $f10_f
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: FSW killed renamable $f10_f, killed renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_ptr_float_no_opt
+    ; RV64: liveins: $x16, $f10_f
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: FSW killed renamable $f10_f, killed renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    ; RV64-NEXT: PseudoRET
+    FSW killed renamable $f10_f, killed renamable $x16, 0 :: (volatile store (s32) into %ir.p)
+    PseudoRET
+
+...
+---
+name:            store_common_ptr_double_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16, $f10_d
+
+    ; RV32-LABEL: name: store_common_ptr_double_no_opt
+    ; RV32: liveins: $x16, $f10_d
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: FSD killed renamable $f10_d, killed renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_common_ptr_double_no_opt
+    ; RV64: liveins: $x16, $f10_d
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: FSD killed renamable $f10_d, killed renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    ; RV64-NEXT: PseudoRET
+    FSD killed renamable $f10_d, killed renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    PseudoRET
+
+...
+---
+name:            load_common_ptr_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; RV32-LABEL: name: load_common_ptr_no_opt
+    ; RV32: liveins: $x16
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: dead renamable $x10 = LW killed renamable $x16, 0 :: (volatile load (s32) from %ir.p)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: load_common_ptr_no_opt
+    ; RV64: liveins: $x16
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: dead renamable $x10 = LW killed renamable $x16, 0 :: (volatile load (s32) from %ir.p)
+    ; RV64-NEXT: PseudoRET
+    dead renamable $x10 = LW killed renamable $x16, 0 :: (volatile load (s32) from %ir.p)
+    PseudoRET
+
+...
+---
+name:            load_common_ptr_float_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; RV32-LABEL: name: load_common_ptr_float_no_opt
+    ; RV32: liveins: $x16
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: renamable $f10_f = FLW killed renamable $x16, 0 :: (load (s32) from %ir.g)
+    ; RV32-NEXT: PseudoRET implicit $f10_f
+    ; RV64-LABEL: name: load_common_ptr_float_no_opt
+    ; RV64: liveins: $x16
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: renamable $f10_f = FLW killed renamable $x16, 0 :: (load (s32) from %ir.g)
+    ; RV64-NEXT: PseudoRET implicit $f10_f
+    renamable $f10_f = FLW killed renamable $x16, 0 :: (load (s32) from %ir.g)
+    PseudoRET implicit $f10_f
+
+...
+---
+name:            load_common_ptr_double_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; RV32-LABEL: name: load_common_ptr_double_no_opt
+    ; RV32: liveins: $x16
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: renamable $f10_d = FLD killed renamable $x16, 0 :: (load (s64) from %ir.g)
+    ; RV32-NEXT: PseudoRET implicit $f10_d
+    ; RV64-LABEL: name: load_common_ptr_double_no_opt
+    ; RV64: liveins: $x16
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: renamable $f10_d = FLD killed renamable $x16, 0 :: (load (s64) from %ir.g)
+    ; RV64-NEXT: PseudoRET implicit $f10_d
+    renamable $f10_d = FLD killed renamable $x16, 0 :: (load (s64) from %ir.g)
+    PseudoRET implicit $f10_d
+
+...
+---
+name:            store_large_offset_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; RV32-LABEL: name: store_large_offset_no_opt
+    ; RV32: liveins: $x10
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: renamable $x11 = ADDI $x0, 1
+    ; RV32-NEXT: SW killed renamable $x11, renamable $x10, 400 :: (volatile store (s32) into %ir.0)
+    ; RV32-NEXT: renamable $x11 = ADDI $x0, 3
+    ; RV32-NEXT: SW killed renamable $x11, killed renamable $x10, 404 :: (volatile store (s32) into %ir.1)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_large_offset_no_opt
+    ; RV64: liveins: $x10
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: renamable $x11 = ADDI $x0, 1
+    ; RV64-NEXT: SW killed renamable $x11, renamable $x10, 400 :: (volatile store (s32) into %ir.0)
+    ; RV64-NEXT: renamable $x11 = ADDI $x0, 3
+    ; RV64-NEXT: SW killed renamable $x11, killed renamable $x10, 404 :: (volatile store (s32) into %ir.1)
+    ; RV64-NEXT: PseudoRET
+    renamable $x11 = ADDI $x0, 1
+    SW killed renamable $x11, renamable $x10, 400 :: (volatile store (s32) into %ir.0)
+    renamable $x11 = ADDI $x0, 3
+    SW killed renamable $x11, killed renamable $x10, 404 :: (volatile store (s32) into %ir.1)
+    PseudoRET
+
+...
+---
+name:            store_large_offset_float_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10, $f10_f, $f11_f
+
+    ; RV32-LABEL: name: store_large_offset_float_no_opt
+    ; RV32: liveins: $x10, $f10_f, $f11_f
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: FSW killed renamable $f10_f, renamable $x10, 400 :: (volatile store (s32) into %ir.0)
+    ; RV32-NEXT: FSW killed renamable $f11_f, killed renamable $x10, 404 :: (volatile store (s32) into %ir.1)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_large_offset_float_no_opt
+    ; RV64: liveins: $x10, $f10_f, $f11_f
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: FSW killed renamable $f10_f, renamable $x10, 400 :: (volatile store (s32) into %ir.0)
+    ; RV64-NEXT: FSW killed renamable $f11_f, killed renamable $x10, 404 :: (volatile store (s32) into %ir.1)
+    ; RV64-NEXT: PseudoRET
+    FSW killed renamable $f10_f, renamable $x10, 400 :: (volatile store (s32) into %ir.0)
+    FSW killed renamable $f11_f, killed renamable $x10, 404 :: (volatile store (s32) into %ir.1)
+    PseudoRET
+
+...
+---
+name:            store_large_offset_double_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10, $f10_d, $f11_d
+
+    ; RV32-LABEL: name: store_large_offset_double_no_opt
+    ; RV32: liveins: $x10, $f10_d, $f11_d
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: FSD killed renamable $f10_d, renamable $x10, 800 :: (volatile store (s64) into %ir.0)
+    ; RV32-NEXT: FSD killed renamable $f11_d, killed renamable $x10, 808 :: (volatile store (s64) into %ir.1)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: store_large_offset_double_no_opt
+    ; RV64: liveins: $x10, $f10_d, $f11_d
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: FSD killed renamable $f10_d, renamable $x10, 800 :: (volatile store (s64) into %ir.0)
+    ; RV64-NEXT: FSD killed renamable $f11_d, killed renamable $x10, 808 :: (volatile store (s64) into %ir.1)
+    ; RV64-NEXT: PseudoRET
+    FSD killed renamable $f10_d, renamable $x10, 800 :: (volatile store (s64) into %ir.0)
+    FSD killed renamable $f11_d, killed renamable $x10, 808 :: (volatile store (s64) into %ir.1)
+    PseudoRET
+
+...
+---
+name:            load_large_offset_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; RV32-LABEL: name: load_large_offset_no_opt
+    ; RV32: liveins: $x10
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: dead renamable $x11 = LW renamable $x10, 400 :: (volatile load (s32) from %ir.0)
+    ; RV32-NEXT: dead renamable $x10 = LW killed renamable $x10, 404 :: (volatile load (s32) from %ir.1)
+    ; RV32-NEXT: PseudoRET
+    ; RV64-LABEL: name: load_large_offset_no_opt
+    ; RV64: liveins: $x10
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: dead renamable $x11 = LW renamable $x10, 400 :: (volatile load (s32) from %ir.0)
+    ; RV64-NEXT: dead renamable $x10 = LW killed renamable $x10, 404 :: (volatile load (s32) from %ir.1)
+    ; RV64-NEXT: PseudoRET
+    dead renamable $x11 = LW renamable $x10, 400 :: (volatile load (s32) from %ir.0)
+    dead renamable $x10 = LW killed renamable $x10, 404 :: (volatile load (s32) from %ir.1)
+    PseudoRET
+
+...
+---
+name:            load_large_offset_float_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; RV32-LABEL: name: load_large_offset_float_no_opt
+    ; RV32: liveins: $x10
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: renamable $f10_f = FLW renamable $x10, 400 :: (load (s32) from %ir.arrayidx)
+    ; RV32-NEXT: renamable $f11_f = FLW killed renamable $x10, 404 :: (load (s32) from %ir.arrayidx1)
+    ; RV32-NEXT: PseudoRET implicit $f10_f, implicit $f11_f
+    ; RV64-LABEL: name: load_large_offset_float_no_opt
+    ; RV64: liveins: $x10
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: renamable $f10_f = FLW renamable $x10, 400 :: (load (s32) from %ir.arrayidx)
+    ; RV64-NEXT: renamable $f11_f = FLW killed renamable $x10, 404 :: (load (s32) from %ir.arrayidx1)
+    ; RV64-NEXT: PseudoRET implicit $f10_f, implicit $f11_f
+    renamable $f10_f = FLW renamable $x10, 400 :: (load (s32) from %ir.arrayidx)
+    renamable $f11_f = FLW killed renamable $x10, 404 :: (load (s32) from %ir.arrayidx1)
+    PseudoRET implicit $f10_f, implicit $f11_f
+
+...
+---
+name:            load_large_offset_double_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; RV32-LABEL: name: load_large_offset_double_no_opt
+    ; RV32: liveins: $x10
+    ; RV32-NEXT: {{  $}}
+    ; RV32-NEXT: renamable $f10_d = FLD renamable $x10, 800 :: (load (s64) from %ir.arrayidx)
+    ; RV32-NEXT: renamable $f11_d = FLD killed renamable $x10, 808 :: (load (s64) from %ir.arrayidx1)
+    ; RV32-NEXT: PseudoRET implicit $f10_d, implicit $f11_d
+    ; RV64-LABEL: name: load_large_offset_double_no_opt
+    ; RV64: liveins: $x10
+    ; RV64-NEXT: {{  $}}
+    ; RV64-NEXT: renamable $f10_d = FLD renamable $x10, 800 :: (load (s64) from %ir.arrayidx)
+    ; RV64-NEXT: renamable $f11_d = FLD killed renamable $x10, 808 :: (load (s64) from %ir.arrayidx1)
+    ; RV64-NEXT: PseudoRET implicit $f10_d, implicit $f11_d
+    renamable $f10_d = FLD renamable $x10, 800 :: (load (s64) from %ir.arrayidx)
+    renamable $f11_d = FLD killed renamable $x10, 808 :: (load (s64) from %ir.arrayidx1)
+    PseudoRET implicit $f10_d, implicit $f11_d
+
+...

llvm/test/CodeGen/RISCV/make-compressible-i64.mir

+# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
+# RUN: llc -o - %s -mtriple=riscv64 -mattr=+c -simplify-mir \
+# RUN:   -run-pass=riscv-make-compressible | FileCheck %s
+--- |
+
+  define void @store_common_value(i64* %a, i64* %b, i64* %c) #0 {
+  entry:
+    store i64 0, i64* %a, align 8
+    store i64 0, i64* %b, align 8
+    store i64 0, i64* %c, align 8
+    ret void
+  }
+
+  define void @store_common_ptr(i64 %a, i64 %b, i64 %c, i64 %d, i64 %e, i64 %f, i64* %p) #0 {
+  entry:
+    store volatile i64 1, i64* %p, align 8
+    store volatile i64 3, i64* %p, align 8
+    store volatile i64 5, i64* %p, align 8
+    ret void
+  }
+
+  define void @store_common_ptr_self(i64 %a, i64 %b, i64 %c, i64 %d, i64 %e, i64 %f, i64* %p) #0 {
+  entry:
+    %g = ptrtoint i64* %p to i64
+    store volatile i64 1, i64* %p, align 8
+    store volatile i64 3, i64* %p, align 8
+    store volatile i64 %g, i64* %p, align 8
+    ret void
+  }
+
+  define void @load_common_ptr(i64 %a, i64 %b, i64 %c, i64 %d, i64 %e, i64 %f, i64* %p) #0 {
+  entry:
+    %g = load volatile i64, i64* %p, align 8
+    %h = load volatile i64, i64* %p, align 8
+    %i = load volatile i64, i64* %p, align 8
+    ret void
+  }
+
+  define void @store_large_offset(i64* %p) #0 {
+  entry:
+    %0 = getelementptr inbounds i64, i64* %p, i64 100
+    store volatile i64 1, i64* %0, align 8
+    %1 = getelementptr inbounds i64, i64* %p, i64 101
+    store volatile i64 3, i64* %1, align 8
+    %2 = getelementptr inbounds i64, i64* %p, i64 102
+    store volatile i64 5, i64* %2, align 8
+    %3 = getelementptr inbounds i64, i64* %p, i64 103
+    store volatile i64 7, i64* %3, align 8
+    ret void
+  }
+
+  define void @load_large_offset(i64* %p) #0 {
+  entry:
+    %0 = getelementptr inbounds i64, i64* %p, i64 100
+    %a = load volatile i64, i64* %0, align 8
+    %1 = getelementptr inbounds i64, i64* %p, i64 101
+    %b = load volatile i64, i64* %1, align 8
+    %2 = getelementptr inbounds i64, i64* %p, i64 102
+    %c = load volatile i64, i64* %2, align 8
+    %3 = getelementptr inbounds i64, i64* %p, i64 103
+    %d = load volatile i64, i64* %3, align 8
+    ret void
+  }
+
+  define void @store_common_value_no_opt(i64* %a) #0 {
+  entry:
+    store i64 0, i64* %a, align 8
+    ret void
+  }
+
+  define void @store_common_ptr_no_opt(i64 %a, i64 %b, i64 %c, i64 %d, i64 %e, i64 %f, i64* %p) #0 {
+  entry:
+    store volatile i64 1, i64* %p, align 8
+    ret void
+  }
+
+  define void @load_common_ptr_no_opt(i64 %a, i64 %b, i64 %c, i64 %d, i64 %e, i64 %f, i64* %p) #0 {
+  entry:
+    %g = load volatile i64, i64* %p, align 8
+    ret void
+  }
+
+  define void @store_large_offset_no_opt(i64* %p) #0 {
+  entry:
+    %0 = getelementptr inbounds i64, i64* %p, i64 100
+    store volatile i64 1, i64* %0, align 8
+    %1 = getelementptr inbounds i64, i64* %p, i64 101
+    store volatile i64 3, i64* %1, align 8
+    ret void
+  }
+
+  define void @load_large_offset_no_opt(i64* %p) #0 {
+  entry:
+    %0 = getelementptr inbounds i64, i64* %p, i64 100
+    %a = load volatile i64, i64* %0, align 8
+    %1 = getelementptr inbounds i64, i64* %p, i64 101
+    %b = load volatile i64, i64* %1, align 8
+    ret void
+  }
+
+  attributes #0 = { optsize "target-features"="+c" }
+
+...
+---
+name:            store_common_value
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10, $x11, $x12
+
+    ; CHECK-LABEL: name: store_common_value
+    ; CHECK: liveins: $x10, $x11, $x12
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: $x13 = ADDI $x0, 0
+    ; CHECK-NEXT: SD $x13, killed renamable $x10, 0 :: (store (s64) into %ir.a)
+    ; CHECK-NEXT: SD $x13, killed renamable $x11, 0 :: (store (s64) into %ir.b)
+    ; CHECK-NEXT: SD $x13, killed renamable $x12, 0 :: (store (s64) into %ir.c)
+    ; CHECK-NEXT: PseudoRET
+    SD $x0, killed renamable $x10, 0 :: (store (s64) into %ir.a)
+    SD $x0, killed renamable $x11, 0 :: (store (s64) into %ir.b)
+    SD $x0, killed renamable $x12, 0 :: (store (s64) into %ir.c)
+    PseudoRET
+
+...
+---
+name:            store_common_ptr
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; CHECK-LABEL: name: store_common_ptr
+    ; CHECK: liveins: $x16
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: renamable $x10 = ADDI $x0, 1
+    ; CHECK-NEXT: $x11 = ADDI $x16, 0
+    ; CHECK-NEXT: SD killed renamable $x10, $x11, 0 :: (volatile store (s64) into %ir.p)
+    ; CHECK-NEXT: renamable $x10 = ADDI $x0, 3
+    ; CHECK-NEXT: SD killed renamable $x10, $x11, 0 :: (volatile store (s64) into %ir.p)
+    ; CHECK-NEXT: renamable $x10 = ADDI $x0, 5
+    ; CHECK-NEXT: SD killed renamable $x10, killed $x11, 0 :: (volatile store (s64) into %ir.p)
+    ; CHECK-NEXT: PseudoRET
+    renamable $x10 = ADDI $x0, 1
+    SD killed renamable $x10, renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    renamable $x10 = ADDI $x0, 3
+    SD killed renamable $x10, renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    renamable $x10 = ADDI $x0, 5
+    SD killed renamable $x10, killed renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    PseudoRET
+
+...
+---
+name:            store_common_ptr_self
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; CHECK-LABEL: name: store_common_ptr_self
+    ; CHECK: liveins: $x16
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: renamable $x10 = ADDI $x0, 1
+    ; CHECK-NEXT: $x11 = ADDI $x16, 0
+    ; CHECK-NEXT: SD killed renamable $x10, $x11, 0 :: (volatile store (s64) into %ir.p)
+    ; CHECK-NEXT: renamable $x10 = ADDI $x0, 3
+    ; CHECK-NEXT: SD killed renamable $x10, $x11, 0 :: (volatile store (s64) into %ir.p)
+    ; CHECK-NEXT: SD killed $x11, $x11, 0 :: (volatile store (s64) into %ir.p)
+    ; CHECK-NEXT: PseudoRET
+    renamable $x10 = ADDI $x0, 1
+    SD killed renamable $x10, renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    renamable $x10 = ADDI $x0, 3
+    SD killed renamable $x10, renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    SD killed renamable $x16, renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    PseudoRET
+
+...
+---
+name:            load_common_ptr
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; CHECK-LABEL: name: load_common_ptr
+    ; CHECK: liveins: $x16
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: $x11 = ADDI $x16, 0
+    ; CHECK-NEXT: dead renamable $x10 = LD $x11, 0 :: (volatile load (s64) from %ir.p)
+    ; CHECK-NEXT: dead renamable $x10 = LD $x11, 0 :: (volatile load (s64) from %ir.p)
+    ; CHECK-NEXT: dead renamable $x10 = LD killed $x11, 0 :: (volatile load (s64) from %ir.p)
+    ; CHECK-NEXT: PseudoRET
+    dead renamable $x10 = LD renamable $x16, 0 :: (volatile load (s64) from %ir.p)
+    dead renamable $x10 = LD renamable $x16, 0 :: (volatile load (s64) from %ir.p)
+    dead renamable $x10 = LD killed renamable $x16, 0 :: (volatile load (s64) from %ir.p)
+    PseudoRET
+
+...
+---
+name:            store_large_offset
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; CHECK-LABEL: name: store_large_offset
+    ; CHECK: liveins: $x10
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: renamable $x11 = ADDI $x0, 1
+    ; CHECK-NEXT: $x12 = ADDI $x10, 768
+    ; CHECK-NEXT: SD killed renamable $x11, $x12, 32 :: (volatile store (s64) into %ir.0)
+    ; CHECK-NEXT: renamable $x11 = ADDI $x0, 3
+    ; CHECK-NEXT: SD killed renamable $x11, $x12, 40 :: (volatile store (s64) into %ir.1)
+    ; CHECK-NEXT: renamable $x11 = ADDI $x0, 5
+    ; CHECK-NEXT: SD killed renamable $x11, $x12, 48 :: (volatile store (s64) into %ir.2)
+    ; CHECK-NEXT: renamable $x11 = ADDI $x0, 7
+    ; CHECK-NEXT: SD killed renamable $x11, killed $x12, 56 :: (volatile store (s64) into %ir.3)
+    ; CHECK-NEXT: PseudoRET
+    renamable $x11 = ADDI $x0, 1
+    SD killed renamable $x11, renamable $x10, 800 :: (volatile store (s64) into %ir.0)
+    renamable $x11 = ADDI $x0, 3
+    SD killed renamable $x11, renamable $x10, 808 :: (volatile store (s64) into %ir.1)
+    renamable $x11 = ADDI $x0, 5
+    SD killed renamable $x11, renamable $x10, 816 :: (volatile store (s64) into %ir.2)
+    renamable $x11 = ADDI $x0, 7
+    SD killed renamable $x11, killed renamable $x10, 824 :: (volatile store (s64) into %ir.3)
+    PseudoRET
+
+...
+---
+name:            load_large_offset
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; CHECK-LABEL: name: load_large_offset
+    ; CHECK: liveins: $x10
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: $x12 = ADDI $x10, 768
+    ; CHECK-NEXT: dead renamable $x11 = LD $x12, 32 :: (volatile load (s64) from %ir.0)
+    ; CHECK-NEXT: dead renamable $x11 = LD $x12, 40 :: (volatile load (s64) from %ir.1)
+    ; CHECK-NEXT: dead renamable $x11 = LD $x12, 48 :: (volatile load (s64) from %ir.2)
+    ; CHECK-NEXT: dead renamable $x10 = LD killed $x12, 56 :: (volatile load (s64) from %ir.3)
+    ; CHECK-NEXT: PseudoRET
+    dead renamable $x11 = LD renamable $x10, 800 :: (volatile load (s64) from %ir.0)
+    dead renamable $x11 = LD renamable $x10, 808 :: (volatile load (s64) from %ir.1)
+    dead renamable $x11 = LD renamable $x10, 816 :: (volatile load (s64) from %ir.2)
+    dead renamable $x10 = LD killed renamable $x10, 824 :: (volatile load (s64) from %ir.3)
+    PseudoRET
+
+...
+---
+name:            store_common_value_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; CHECK-LABEL: name: store_common_value_no_opt
+    ; CHECK: liveins: $x10
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: SD $x0, killed renamable $x10, 0 :: (store (s64) into %ir.a)
+    ; CHECK-NEXT: PseudoRET
+    SD $x0, killed renamable $x10, 0 :: (store (s64) into %ir.a)
+    PseudoRET
+
+...
+---
+name:            store_common_ptr_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; CHECK-LABEL: name: store_common_ptr_no_opt
+    ; CHECK: liveins: $x16
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: renamable $x10 = ADDI $x0, 1
+    ; CHECK-NEXT: SD killed renamable $x10, killed renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    ; CHECK-NEXT: PseudoRET
+    renamable $x10 = ADDI $x0, 1
+    SD killed renamable $x10, killed renamable $x16, 0 :: (volatile store (s64) into %ir.p)
+    PseudoRET
+
+...
+---
+name:            load_common_ptr_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x16
+
+    ; CHECK-LABEL: name: load_common_ptr_no_opt
+    ; CHECK: liveins: $x16
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: dead renamable $x10 = LD killed renamable $x16, 0 :: (volatile load (s64) from %ir.p)
+    ; CHECK-NEXT: PseudoRET
+    dead renamable $x10 = LD killed renamable $x16, 0 :: (volatile load (s64) from %ir.p)
+    PseudoRET
+
+...
+---
+name:            store_large_offset_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; CHECK-LABEL: name: store_large_offset_no_opt
+    ; CHECK: liveins: $x10
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: renamable $x11 = ADDI $x0, 1
+    ; CHECK-NEXT: SD killed renamable $x11, renamable $x10, 800 :: (volatile store (s64) into %ir.0)
+    ; CHECK-NEXT: renamable $x11 = ADDI $x0, 3
+    ; CHECK-NEXT: SD killed renamable $x11, killed renamable $x10, 808 :: (volatile store (s64) into %ir.1)
+    ; CHECK-NEXT: PseudoRET
+    renamable $x11 = ADDI $x0, 1
+    SD killed renamable $x11, renamable $x10, 800 :: (volatile store (s64) into %ir.0)
+    renamable $x11 = ADDI $x0, 3
+    SD killed renamable $x11, killed renamable $x10, 808 :: (volatile store (s64) into %ir.1)
+    PseudoRET
+
+...
+---
+name:            load_large_offset_no_opt
+tracksRegLiveness: true
+body:             |
+  bb.0.entry:
+    liveins: $x10
+
+    ; CHECK-LABEL: name: load_large_offset_no_opt
+    ; CHECK: liveins: $x10
+    ; CHECK-NEXT: {{  $}}
+    ; CHECK-NEXT: dead renamable $x11 = LD renamable $x10, 800 :: (volatile load (s64) from %ir.0)
+    ; CHECK-NEXT: dead renamable $x10 = LD killed renamable $x10, 808 :: (volatile load (s64) from %ir.1)
+    ; CHECK-NEXT: PseudoRET
+    dead renamable $x11 = LD renamable $x10, 800 :: (volatile load (s64) from %ir.0)
+    dead renamable $x10 = LD killed renamable $x10, 808 :: (volatile load (s64) from %ir.1)
+    PseudoRET
+
+...