AMDGPU/R600: Fix amdgpu alias analysis pass.

[jvesely]

Summary

R600 uses higher AS number to access kernel parameters

Fixes: r298846

Fixes ~1400 OpenCL piglit regressions on EG.

[arsenm]

lib/Target/AMDGPU/AMDGPUAliasAnalysis.cpp

87–89 ↗

(On Diff #93573)

No return after else

[jvesely]

v2: Return after reporting fatal error

[arsenm]

LGTM

llvm/trunk/lib/Target/AMDGPU/AMDGPUAliasAnalysis.h

 class AMDGPUAAResult : public AAResultBase<AMDGPUAAResult> {
   friend AAResultBase<AMDGPUAAResult>;
 
   const DataLayout &DL;
   AMDGPUAS AS;
 
 public:
   explicit AMDGPUAAResult(const DataLayout &DL, Triple T) : AAResultBase(),
-    DL(DL), AS(AMDGPU::getAMDGPUAS(T)), ASAliasRules(AS) {}
+    DL(DL), AS(AMDGPU::getAMDGPUAS(T)), ASAliasRules(AS, T.getArch()) {}
   AMDGPUAAResult(AMDGPUAAResult &&Arg)
       : AAResultBase(std::move(Arg)), DL(Arg.DL), AS(Arg.AS),
         ASAliasRules(Arg.ASAliasRules){}
 
   /// Handle invalidation events from the new pass manager.
   ///
   /// By definition, this result is stateless and so remains valid.
   bool invalidate(Function &, const PreservedAnalyses &) { return false; }
 
   AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB);
   bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal);
 
 private:
   bool Aliases(const MDNode *A, const MDNode *B) const;
   bool PathAliases(const MDNode *A, const MDNode *B) const;
 
   class ASAliasRulesTy {
   public:
-    ASAliasRulesTy(AMDGPUAS AS_);
+    ASAliasRulesTy(AMDGPUAS AS_, Triple::ArchType Arch_);
     AliasResult getAliasResult(unsigned AS1, unsigned AS2) const;
   private:
+    Triple::ArchType Arch;
     AMDGPUAS AS;
     const AliasResult (*ASAliasRules)[6][6];
   } ASAliasRules;
 };
 
 /// Analysis pass providing a never-invalidated alias analysis result.
 class AMDGPUAA : public AnalysisInfoMixin<AMDGPUAA> {
   friend AnalysisInfoMixin<AMDGPUAA>;

llvm/trunk/lib/Target/AMDGPU/AMDGPUAliasAnalysis.cpp

ImmutablePass *llvm::createAMDGPUAAWrapperPass() {
   return new AMDGPUAAWrapperPass();
 }
 
 void AMDGPUAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesAll();
 }
 
 // Must match the table in getAliasResult.
-AMDGPUAAResult::ASAliasRulesTy::ASAliasRulesTy(AMDGPUAS AS_) : AS(AS_) {
+AMDGPUAAResult::ASAliasRulesTy::ASAliasRulesTy(AMDGPUAS AS_, Triple::ArchType Arch_)
+  : Arch(Arch_), AS(AS_) {
   // These arrarys are indexed by address space value
   // enum elements 0 ... to 5
   static const AliasResult ASAliasRulesPrivIsZero[6][6] = {
   /*             Private    Global    Constant  Group     Flat      Region*/
   /* Private  */ {MayAlias, NoAlias , NoAlias , NoAlias , MayAlias, NoAlias},
   /* Global   */ {NoAlias , MayAlias, NoAlias , NoAlias , MayAlias, NoAlias},
   /* Constant */ {NoAlias , NoAlias , MayAlias, NoAlias , MayAlias, NoAlias},
   /* Group    */ {NoAlias , NoAlias , NoAlias , MayAlias, MayAlias, NoAlias},
assert(AS.PRIVATE_ADDRESS  == 0 &&
            AS.FLAT_ADDRESS     == 4 &&
            AS.REGION_ADDRESS   == 5);
     ASAliasRules = &ASAliasRulesPrivIsZero;
   }
 }
 
 AliasResult AMDGPUAAResult::ASAliasRulesTy::getAliasResult(unsigned AS1,
     unsigned AS2) const {
-  if (AS1 > AS.MAX_COMMON_ADDRESS || AS2 > AS.MAX_COMMON_ADDRESS)
+  if (AS1 > AS.MAX_COMMON_ADDRESS || AS2 > AS.MAX_COMMON_ADDRESS) {
+    if (Arch == Triple::amdgcn)
       report_fatal_error("Pointer address space out of range");
+    return AS1 == AS2 ? MayAlias : NoAlias;
+  }
+
   return (*ASAliasRules)[AS1][AS2];
 }
 
 AliasResult AMDGPUAAResult::alias(const MemoryLocation &LocA,
                                   const MemoryLocation &LocB) {
   unsigned asA = LocA.Ptr->getType()->getPointerAddressSpace();
   unsigned asB = LocB.Ptr->getType()->getPointerAddressSpace();
 

llvm/trunk/test/CodeGen/AMDGPU/amdgpu-alias-analysis.ll

 ; RUN: opt -mtriple=amdgcn-- -O3 -aa-eval -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s
+; RUN: opt -mtriple=r600-- -O3 -aa-eval -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s
 
 ; CHECK: NoAlias:      i8 addrspace(1)* %p1, i8* %p
 
 define void @test(i8* %p, i8 addrspace(1)* %p1) {
   ret void
 }
 

llvm/trunk/test/CodeGen/AMDGPU/r600.amdgpu-alias-analysis.ll

+; RUN: opt -mtriple=r600-- -O3 -aa-eval -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s
+
+; CHECK: NoAlias:      i8 addrspace(7)* %p1, i8* %p
+
+define amdgpu_kernel void @test(i8* %p, i8 addrspace(7)* %p1) {
+  ret void
+}