Rename scoped-noalias -> scoped-noalias-aa

[aeubanks]

Summary

To match NewPM name. Also the new name is clearer and more consistent.

[asbirlea]

Thank you!

llvm/lib/Analysis/ScopedNoAliasAA.cpp

 
 ScopedNoAliasAAResult ScopedNoAliasAA::run(Function &F,
                                            FunctionAnalysisManager &AM) {
   return ScopedNoAliasAAResult();
 }
 
 char ScopedNoAliasAAWrapperPass::ID = 0;
 
-INITIALIZE_PASS(ScopedNoAliasAAWrapperPass, "scoped-noalias",
+INITIALIZE_PASS(ScopedNoAliasAAWrapperPass, "scoped-noalias-aa",
                 "Scoped NoAlias Alias Analysis", false, true)
 
 ImmutablePass *llvm::createScopedNoAliasAAWrapperPass() {
   return new ScopedNoAliasAAWrapperPass();
 }
 
 ScopedNoAliasAAWrapperPass::ScopedNoAliasAAWrapperPass() : ImmutablePass(ID) {
   initializeScopedNoAliasAAWrapperPassPass(*PassRegistry::getPassRegistry());

llvm/test/Analysis/ScopedNoAliasAA/basic-domains.ll

-; RUN: opt < %s -basic-aa -scoped-noalias -aa-eval -evaluate-aa-metadata -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
+; RUN: opt < %s -basic-aa -scoped-noalias-aa -aa-eval -evaluate-aa-metadata -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @foo1(float* nocapture %a, float* nocapture readonly %c) #0 {
 entry:
 ; CHECK-LABEL: Function: foo1
   %0 = load float, float* %c, align 4, !alias.scope !0
   %arrayidx.i = getelementptr inbounds float, float* %a, i64 5

llvm/test/Analysis/ScopedNoAliasAA/basic.ll

-; RUN: opt < %s -basic-aa -scoped-noalias -aa-eval -evaluate-aa-metadata -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
+; RUN: opt < %s -basic-aa -scoped-noalias-aa -aa-eval -evaluate-aa-metadata -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
 ; RUN: opt < %s -aa-pipeline=basic-aa,scoped-noalias-aa -passes=aa-eval -evaluate-aa-metadata -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @foo1(float* nocapture %a, float* nocapture readonly %c) #0 {
 entry:
 ; CHECK-LABEL: Function: foo1
   %0 = load float, float* %c, align 4, !alias.scope !2

llvm/test/Analysis/ScopedNoAliasAA/basic2.ll

-; RUN: opt < %s -basic-aa -scoped-noalias -aa-eval -evaluate-aa-metadata -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
+; RUN: opt < %s -basic-aa -scoped-noalias-aa -aa-eval -evaluate-aa-metadata -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @foo2(float* nocapture %a, float* nocapture %b, float* nocapture readonly %c) #0 {
 entry:
 ; CHECK-LABEL: Function: foo2
   %0 = load float, float* %c, align 4, !alias.scope !0
   %arrayidx.i = getelementptr inbounds float, float* %a, i64 5

llvm/test/Transforms/GVN/noalias.ll

-; RUN: opt -scoped-noalias -basic-aa -gvn -S < %s | FileCheck %s
+; RUN: opt -scoped-noalias-aa -basic-aa -gvn -S < %s | FileCheck %s
 
 define i32 @test1(i32* %p, i32* %q) {
 ; CHECK-LABEL: @test1(i32* %p, i32* %q)
 ; CHECK: load i32, i32* %p
 ; CHECK-NOT: noalias
 ; CHECK: %c = add i32 %a, %a
   %a = load i32, i32* %p, !noalias !0
   %b = load i32, i32* %p

llvm/test/Transforms/LICM/dropped-tbaa.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -scoped-noalias -tbaa -licm -S | FileCheck %s
+; RUN: opt < %s -scoped-noalias-aa -tbaa -licm -S | FileCheck %s
 
 ; This test case case is generated from the following C code with -fstrict-aliasing,
 ; and after passing through -inline -mem2reg -loop-rotate -instcombine
 ; void add(double *restrict data, int *restrict addend) {
 ;    *data += *addend;
 ; }
 ;
 ; void foo(double *data, int *addend) {

llvm/test/Transforms/LICM/pr42969.ll

-; RUN: opt %s -S -scoped-noalias -enable-mssa-loop-dependency=true -licm | FileCheck %s
+; RUN: opt %s -S -scoped-noalias-aa -enable-mssa-loop-dependency=true -licm | FileCheck %s
 
 define i16 @main(i1 %a_b_mayalias, i16* %a, i16* %b) {
 ; CHECK:       scalar.body:
 ; CHECK-NEXT:    [[J:%.*]] = phi i64
 ; CHECK-NEXT:    [[TMP3:%.*]] = load i16
 ; CHECK-NEXT:    [[RESULT:%.*]] = add i16 [[TMP3]], 1
 ; CHECK-NEXT:    store i16 [[RESULT]]
 

llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/aa-metadata.ll

-; RUN: opt -mtriple=amdgcn-amd-amdhsa -basic-aa -scoped-noalias -load-store-vectorizer -S -o - %s | FileCheck -check-prefix=SCOPE -check-prefix=ALL %s
+; RUN: opt -mtriple=amdgcn-amd-amdhsa -basic-aa -scoped-noalias-aa -load-store-vectorizer -S -o - %s | FileCheck -check-prefix=SCOPE -check-prefix=ALL %s
 ; RUN: opt -mtriple=amdgcn-amd-amdhsa -basic-aa -load-store-vectorizer -S -o - %s | FileCheck -check-prefix=NOSCOPE -check-prefix=ALL %s
 
 target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
 
 ; This fails to vectorize if the !alias.scope is not used
 
 ; ALL-LABEL: @vectorize_alias_scope(
 ; SCOPE: load float, float addrspace(1)* %c

llvm/test/Transforms/LoopVectorize/noalias-md-licm.ll

-; RUN: opt -basic-aa -scoped-noalias -loop-vectorize -licm -force-vector-width=2 \
+; RUN: opt -basic-aa -scoped-noalias-aa -loop-vectorize -licm -force-vector-width=2 \
 ; RUN:     -force-vector-interleave=1 -S < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; In order to vectorize the inner loop, it needs to be versioned with
 ; memchecks between {A} x {B, C} first:
 ;
 ;   for (i = 0; i < n; i++)

llvm/test/Transforms/LoopVectorize/noalias-md.ll

 ; RUN: opt -basic-aa -loop-vectorize -force-vector-width=2 \
 ; RUN:     -force-vector-interleave=1 -S < %s \
 ; RUN:     | FileCheck %s -check-prefix=BOTH -check-prefix=LV
-; RUN: opt -basic-aa -scoped-noalias -loop-vectorize -dse -force-vector-width=2 \
+; RUN: opt -basic-aa -scoped-noalias-aa -loop-vectorize -dse -force-vector-width=2 \
 ; RUN:     -force-vector-interleave=1 -S < %s \
 ; RUN:     | FileCheck %s -check-prefix=BOTH -check-prefix=DSE
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; This loop needs to be versioned with memchecks between {A, B} x {C} before
 ; it can be vectorized.
 ;

llvm/test/Transforms/LoopVersioning/noalias-version-twice.ll

-; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute -loop-simplify -scoped-noalias \
+; RUN: opt -basic-aa -loop-distribute -enable-loop-distribute -loop-simplify -scoped-noalias-aa \
 ; RUN:     -loop-versioning -S < %s | FileCheck %s
 
 ; Test the metadata generated when versioning an already versioned loop.  Here
 ; we invoke loop distribution to perform the first round of versioning.  It
 ; adds memchecks for accesses that can alias across the distribution boundary.
 ; Then we further version the distributed loops to fully disambiguate accesses
 ; within each.
 ;

llvm/test/Transforms/MemCpyOpt/load-store-to-memcpy.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -basic-aa -scoped-noalias -memcpyopt -S %s | FileCheck %s
+; RUN: opt -basic-aa -scoped-noalias-aa -memcpyopt -S %s | FileCheck %s
 
 %T = type { i8, i32 }
 
 ; Ensure load-store forwarding of an aggregate is interpreted as
 ; a memmove when the source and dest may alias
 define void @test_memmove(%T* align 8 %a, %T* align 16 %b) {
 ; CHECK-LABEL: @test_memmove(
 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast %T* [[B:%.*]] to i8*

llvm/test/Transforms/NewGVN/noalias.ll

-; RUN: opt -scoped-noalias -basic-aa -newgvn -S < %s | FileCheck %s
+; RUN: opt -scoped-noalias-aa -basic-aa -newgvn -S < %s | FileCheck %s
 
 define i32 @test1(i32* %p, i32* %q) {
 ; CHECK-LABEL: @test1(i32* %p, i32* %q)
 ; CHECK: load i32, i32* %p
 ; CHECK-NOT: noalias
 ; CHECK: %c = add i32 %a, %a
   %a = load i32, i32* %p, !noalias !0
   %b = load i32, i32* %p