[GlobalISel] [AArch64] Fold G_PTRTOINT(G_CONSTANT)

[andcarminati]

Summary

Fold the following pattern:

    %0:_(p0) = G_CONSTANT i64 0
    %1:_(s64) = G_PTRTOINT %0:_(p0)
    %2 = COPY %1(s64)

Into:
    %0:_(s64) = G_CONSTANT i64 0
    %1 = COPY %0(s64)

[arsenm]

Where are these coming from? I thought we directly emitted pointer constants now?

[andcarminati]

In D140302#4004906, @arsenm wrote:

Where are these coming from? I thought we directly emitted pointer constants now?

Well, we have this folding implemented in our development branch (custom target) and we think it is interesting for AArch64 too.

[arsenm]

In D140302#4004906, @arsenm wrote:

Where are these coming from? I thought we directly emitted pointer constants now?

I think this is special cased for ConstantPointerNull

llvm/include/llvm/Target/GlobalISel/Combine.td

514

Should be able to just use replaceInstWithConstant

llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp

2095–2098

We already have a matchConstantOp, but that checks for a specific constant. Should have another generic one that checks for any constant

[arsenm]

Maybe should have the constant folding MIRBuilder do this too

[paquette]

In D140302#4004963, @andcarminati wrote:

In D140302#4004906, @arsenm wrote:

Where are these coming from? I thought we directly emitted pointer constants now?

Well, we have this folding implemented in our development branch (custom target) and we think it is interesting for AArch64 too.

How much of a code size improvement did you see with this change?

[andcarminati]

The patch was updated to the main branch.

Some background: we are upstreaming this pattern through the AArch64 because the target backend that we are developing in our company was not upstreamed yet. About usability, we observed that this pattern is being matched and can impact the final code.

llvm/include/llvm/CodeGen/GlobalISel/CombinerHelper.h

public:
 
   /// Transform IntToPtr(PtrToInt(x)) to x if cast is in the same address space.
   bool matchCombineI2PToP2I(MachineInstr &MI, Register &Reg);
   void applyCombineI2PToP2I(MachineInstr &MI, Register &Reg);
 
   /// Transform PtrToInt(IntToPtr(x)) to x.
   void applyCombineP2IToI2P(MachineInstr &MI, Register &Reg);
 
+  /// Transform Fold G_PTRTOINT(G_CONSTANT(x)) to x.
+  bool matchCombineP2IToC(MachineInstr &MI, Register &Reg);
+  void applyCombineP2IToC(MachineInstr &MI, Register &Reg);
+
   /// Transform G_ADD (G_PTRTOINT x), y -> G_PTRTOINT (G_PTR_ADD x, y)
   /// Transform G_ADD y, (G_PTRTOINT x) -> G_PTRTOINT (G_PTR_ADD x, y)
   bool matchCombineAddP2IToPtrAdd(MachineInstr &MI,
                                   std::pair<Register, bool> &PtrRegAndCommute);
   void applyCombineAddP2IToPtrAdd(MachineInstr &MI,
                                   std::pair<Register, bool> &PtrRegAndCommute);
 
   // Transform G_PTR_ADD (G_PTRTOINT C1), C2 -> C1 + C2

llvm/include/llvm/Target/GlobalISel/Combine.td

 def i2p_to_p2i: GICombineRule<
   (defs root:$dst, register_matchinfo:$info),
   (match (G_INTTOPTR $t, $ptr),
          (G_PTRTOINT $dst, $t):$mi,
     [{ ${info} = ${ptr}.getReg(); }]),
   (apply [{ Helper.applyCombineP2IToI2P(*${mi}, ${info}); }])
 >;
 
+// Fold ptr2int(cst) -> cst
+def i2p_to_c: GICombineRule<
+  (defs root:$root, register_matchinfo:$info),
+  (match (wip_match_opcode G_PTRTOINT):$root,
+    [{ return Helper.matchCombineP2IToC(*${root}, ${info}); }]),
+  (apply [{ Helper.applyCombineP2IToC(*${root}, ${info}); }])
+>;
+
 // Fold add ptrtoint(x), y -> ptrtoint (ptr_add x), y
 def add_p2i_to_ptradd_matchinfo : GIDefMatchData<"std::pair<Register, bool>">;
 def add_p2i_to_ptradd : GICombineRule<
   (defs root:$root, add_p2i_to_ptradd_matchinfo:$info),
   (match (wip_match_opcode G_ADD):$root,
     [{ return Helper.matchCombineAddP2IToPtrAdd(*${root}, ${info}); }]),
   (apply [{ Helper.applyCombineAddP2IToPtrAdd(*${root}, ${info}); }])
 >;

 def identity_combines : GICombineGroup<[select_same_val, right_identity_zero,
                                         binop_same_val, binop_left_to_zero,
                                         binop_right_to_zero, p2i_to_i2p,
                                         i2p_to_p2i, anyext_trunc_fold,
                                         fneg_fneg_fold, right_identity_one,
                                         add_sub_reg, buildvector_identity_fold,
                                         trunc_buildvector_fold,
                                         trunc_lshr_buildvector_fold,
-                                        bitcast_bitcast_fold, fptrunc_fpext_fold]>;
+                                        bitcast_bitcast_fold, fptrunc_fpext_fold,
+                                        i2p_to_c]>;
 
 def const_combines : GICombineGroup<[constant_fold_fp_ops, const_ptradd_to_i2p,
                                      overlapping_and, mulo_by_2, mulo_by_0,
                                      addo_by_0, adde_to_addo,
                                      combine_minmax_nan]>;
 
 def known_bits_simplifications : GICombineGroup<[
   redundant_and, redundant_sext_inreg, redundant_or, urem_pow2_to_mask,

llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp

 void CombinerHelper::applyCombineP2IToI2P(MachineInstr &MI, Register &Reg) {
   assert(MI.getOpcode() == TargetOpcode::G_PTRTOINT && "Expected a G_PTRTOINT");
   Register DstReg = MI.getOperand(0).getReg();
   Builder.setInstr(MI);
   Builder.buildZExtOrTrunc(DstReg, Reg);
   MI.eraseFromParent();
 }
 
+bool CombinerHelper::matchCombineP2IToC(MachineInstr &MI, Register &Reg) {
+  assert(MI.getOpcode() == TargetOpcode::G_PTRTOINT && "Expected a G_PTRTOINT");
+  const Register SrcReg = MI.getOperand(1).getReg();
+  const MachineInstr *SrcInstr = MRI.getVRegDef(SrcReg);
+  return SrcInstr->getOpcode() == TargetOpcode::G_CONSTANT;
+}
+
+void CombinerHelper::applyCombineP2IToC(MachineInstr &MI, Register &Reg) {
+  assert(MI.getOpcode() == TargetOpcode::G_PTRTOINT && "Expected a G_PTRTOINT");
+  Register DstReg = MI.getOperand(0).getReg();
+  Register SrcReg = MI.getOperand(1).getReg();
+  MachineInstr *SrcMI = MRI.getVRegDef(SrcReg);
+  const MachineOperand &CstVal = SrcMI->getOperand(1);
+  Builder.setInstr(MI);
+  Builder.buildConstant(DstReg, CstVal.getCImm()->getValue());
+  MI.eraseFromParent();
+}
+
 bool CombinerHelper::matchCombineAddP2IToPtrAdd(
     MachineInstr &MI, std::pair<Register, bool> &PtrReg) {
   assert(MI.getOpcode() == TargetOpcode::G_ADD);
   Register LHS = MI.getOperand(1).getReg();
   Register RHS = MI.getOperand(2).getReg();
   LLT IntTy = MRI.getType(LHS);
 
   // G_PTR_ADD always has the pointer in the LHS, so we may need to commute the

llvm/test/CodeGen/AArch64/GlobalISel/combine-ptradd-int2ptr.mir

 # NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
 # RUN: llc -run-pass=aarch64-prelegalizer-combiner -verify-machineinstrs -mtriple aarch64-unknown-unknown %s -o - | FileCheck %s
 # RUN: llc -debugify-and-strip-all-safe -run-pass=aarch64-prelegalizer-combiner -verify-machineinstrs -mtriple aarch64-unknown-unknown %s -o - | FileCheck %s
 
 ---
 name:            agc.test_combine_ptradd_constants_intres
 body:             |
   bb.1:
     liveins: $x0
     ; CHECK-LABEL: name: agc.test_combine_ptradd_constants_intres
-    ; CHECK: [[C:%[0-9]+]]:_(p64) = G_CONSTANT i64 44
-    ; CHECK: [[PTRTOINT:%[0-9]+]]:_(s64) = G_PTRTOINT [[C]](p64)
-    ; CHECK: $x0 = COPY [[PTRTOINT]](s64)
+    ; CHECK: [[C:%[0-9]+]]:_(s64) =  G_CONSTANT i64 44
+    ; CHECK: $x0 = COPY [[C]](s64)
     %1:_(s32) = G_CONSTANT i32 42
     %2:_(s32) = G_CONSTANT i32 2
     %3:_(p64) = G_INTTOPTR %2
     %4:_(p64) = G_PTR_ADD %3, %1
     %5:_(s64) = G_PTRTOINT %4
     $x0 = COPY %5(s64)
 ...
 ---