[GISel]; Add a helper legalization rule for legalizing addressspacecast if no-op

[aditya_nandakumar]

Summary

Added .legalIfNoopAddrSpaceCast predicate to handle the common case of a no-op addrspacecast in most targets.

[aemerson]

This seems like something that most targets would want done by default. I wonder if we should have a standard set of legalizer actions that targets can use. LGTM anyway.

lib/CodeGen/GlobalISel/LegalityPredicates.cpp

104

This should assert already in getAddressSpace().

include/llvm/CodeGen/GlobalISel/LegalizerInfo.h

 namespace llvm {
 
 extern cl::opt<bool> DisableGISelLegalityCheck;
 
 class MachineInstr;
 class MachineIRBuilder;
 class MachineRegisterInfo;
 class MCInstrInfo;
+class TargetLowering;
 
 namespace LegalizeActions {
 enum LegalizeAction : std::uint8_t {
   /// The operation is expected to be selectable directly by the target, and
   /// no transformation is necessary.
   Legal,
 
   /// The operation should be synthesized from multiple instructions acting on

 /// True iff the specified type index is a scalar whose size is not a power of
 /// 2.
 LegalityPredicate sizeNotPow2(unsigned TypeIdx);
 /// True iff the specified MMO index has a size that is not a power of 2
 LegalityPredicate memSizeInBytesNotPow2(unsigned MMOIdx);
 /// True iff the specified type index is a vector whose element count is not a
 /// power of 2.
 LegalityPredicate numElementsNotPow2(unsigned TypeIdx);
+/// True iff the pointer addressspacecast b/w Types at indices 0 and 1 are a
+/// noop.
+LegalityPredicate isNoopAddrSpaceCast(const TargetLowering *TLI);
 } // end namespace LegalityPredicates
 
 namespace LegalizeMutations {
 /// Select this specific type for the given type index.
 LegalizeMutation changeTo(unsigned TypeIdx, LLT Ty);
 /// Keep the same type as the given type index.
 LegalizeMutation changeTo(unsigned TypeIdx, unsigned FromTypeIdx);
 /// Widen the type for the given type index to the next power of 2.
LegalizeRuleSet &clampNumElements(unsigned TypeIdx, const LLT &MinTy,
     assert(MinTy.getElementType() == MaxTy.getElementType() &&
            "Expected element types to agree");
 
     const LLT &EltTy = MinTy.getElementType();
     return clampMinNumElements(TypeIdx, EltTy, MinTy.getNumElements())
         .clampMaxNumElements(TypeIdx, EltTy, MaxTy.getNumElements());
   }
 
+  /// Legal if the address space cast b/w the two pointers is a noop.
+  LegalizeRuleSet &legalIfNoopAddrSpaceCast(const TargetLowering *TLI) {
+    markAllTypeIdxsAsCovered();
+    return actionIf(LegalizeAction::Legal,
+                    LegalityPredicates::isNoopAddrSpaceCast(TLI));
+  }
+
   /// Fallback on the previous implementation. This should only be used while
   /// porting a rule.
   LegalizeRuleSet &fallback() {
     add({always, LegalizeAction::UseLegacyRules});
     return *this;
   }
 
   /// Check if there is no type index which is obviously not handled by the

lib/CodeGen/GlobalISel/LegalityPredicates.cpp

 //===- lib/CodeGen/GlobalISel/LegalizerPredicates.cpp - Predicates --------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // A library of predicate factories to use for LegalityPredicate.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
+#include "llvm/CodeGen/TargetLowering.h"
 
 using namespace llvm;
 
 LegalityPredicate
 LegalityPredicates::all(LegalityPredicate P0, LegalityPredicate P1) {
   return [=](const LegalityQuery &Query) {
     return P0(Query) && P1(Query);
   };

 }
 
 LegalityPredicate LegalityPredicates::numElementsNotPow2(unsigned TypeIdx) {
   return [=](const LegalityQuery &Query) {
     const LLT &QueryTy = Query.Types[TypeIdx];
     return QueryTy.isVector() && isPowerOf2_32(QueryTy.getNumElements());
   };
 }
+
+LegalityPredicate
+LegalityPredicates::isNoopAddrSpaceCast(const TargetLowering *TLI) {
+  return [=](const LegalityQuery &Query) {
+    const LLT &Ty0 = Query.Types[0];
+    const LLT &Ty1 = Query.Types[1];
+    assert(Ty0.isPointer() && Ty1.isPointer());
+    return TLI->isNoopAddrSpaceCast(Ty1.getAddressSpace(),
+                                    Ty0.getAddressSpace());
+  };
+}

lib/Target/AArch64/AArch64LegalizerInfo.cpp

AArch64LegalizerInfo::AArch64LegalizerInfo(const AArch64Subtarget &ST) {
   const LLT v4s32 = LLT::vector(4, 32);
   const LLT v2s64 = LLT::vector(2, 64);
 
   getActionDefinitionsBuilder(G_IMPLICIT_DEF)
       .legalFor({p0, s1, s8, s16, s32, s64})
       .clampScalar(0, s1, s64)
       .widenScalarToNextPow2(0, 8);
 
+  getActionDefinitionsBuilder(G_ADDRSPACE_CAST)
+      .legalIfNoopAddrSpaceCast(ST.getTargetLowering());
+
   getActionDefinitionsBuilder(G_PHI)
       .legalFor({p0, s16, s32, s64})
       .clampScalar(0, s16, s64)
       .widenScalarToNextPow2(0);
 
   getActionDefinitionsBuilder(G_BSWAP)
       .legalFor({s32, s64})
       .clampScalar(0, s16, s64)

test/CodeGen/AArch64/GlobalISel/legalize-addrspacecast.mir

+# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
+# RUN: llc -o - -mtriple=aarch64-- -global-isel -run-pass=legalizer %s | FileCheck %s
+
+---
+name:            test_addrspacecast
+body:             |
+  bb.1:
+    ; CHECK-LABEL: name: test_addrspacecast
+    ; CHECK: [[DEF:%[0-9]+]]:_(s64) = G_IMPLICIT_DEF
+    ; CHECK: [[INTTOPTR:%[0-9]+]]:_(p0) = G_INTTOPTR [[DEF]](s64)
+    ; CHECK: [[ADDRSPACE_CAST:%[0-9]+]]:_(p1) = G_ADDRSPACE_CAST [[INTTOPTR]](p0)
+    ; CHECK: [[ADDRSPACE_CAST1:%[0-9]+]]:_(p0) = G_ADDRSPACE_CAST [[ADDRSPACE_CAST]](p1)
+    ; CHECK: [[PTRTOINT:%[0-9]+]]:_(s64) = G_PTRTOINT [[ADDRSPACE_CAST1]](p0)
+    ; CHECK: $x0 = COPY [[PTRTOINT]](s64)
+    %0:_(s64) = G_IMPLICIT_DEF
+    %1:_(p0) = G_INTTOPTR %0
+    %2:_(p1) = G_ADDRSPACE_CAST %1
+    %3:_(p0) = G_ADDRSPACE_CAST %2
+    %4:_(s64) = G_PTRTOINT %3
+    $x0 = COPY %4
+...