[IR][ASMParser] Use default AS for alloca without explicit AS

llvm/include/llvm/AsmParser/LLParser.h

@@ -326,7 +326,8 @@ namespace llvm {
     bool parseOptionalStackAlignment(unsigned &Alignment);
     bool parseOptionalCommaAlign(MaybeAlign &Alignment, bool &AteExtraComma);
     bool parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
-                                     bool &AteExtraComma);
+                                     bool &AteExtraComma,
+                                     unsigned DefaultAS = 0);
     bool parseAllocSizeArguments(unsigned &BaseSizeArg,
                                  std::optional<unsigned> &HowManyArg);
     bool parseVScaleRangeArguments(unsigned &MinValue, unsigned &MaxValue);

llvm/lib/AsmParser/LLParser.cpp

@@ -2711,7 +2711,8 @@ bool LLParser::parseOptionalCommaAlign(MaybeAlign &Alignment,
 /// This returns with AteExtraComma set to true if it ate an excess comma at the
 /// end.
 bool LLParser::parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
-                                           bool &AteExtraComma) {
+                                           bool &AteExtraComma,
+                                           unsigned DefaultAS) {
   AteExtraComma = false;
   while (EatIfPresent(lltok::comma)) {
     // Metadata at the end is an early exit.
@@ -2724,7 +2725,7 @@ bool LLParser::parseOptionalCommaAddrSpace(unsigned &AddrSpace, LocTy &Loc,
     if (Lex.getKind() != lltok::kw_addrspace)
       return error(Lex.getLoc(), "expected metadata or 'addrspace'");
 
-    if (parseOptionalAddrSpace(AddrSpace))
+    if (parseOptionalAddrSpace(AddrSpace, DefaultAS))
       return true;
   }
 
@@ -8354,7 +8355,8 @@ int LLParser::parseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
   Value *Size = nullptr;
   LocTy SizeLoc, TyLoc, ASLoc;
   MaybeAlign Alignment;
-  unsigned AddrSpace = 0;
+  unsigned DefaultAS = M->getDataLayout().getAllocaAddrSpace();
+  unsigned AddrSpace = DefaultAS;
   Type *Ty = nullptr;
 
   bool IsInAlloca = EatIfPresent(lltok::kw_inalloca);
@@ -8371,11 +8373,12 @@ int LLParser::parseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
     if (Lex.getKind() == lltok::kw_align) {
       if (parseOptionalAlignment(Alignment))
         return true;
-      if (parseOptionalCommaAddrSpace(AddrSpace, ASLoc, AteExtraComma))
+      if (parseOptionalCommaAddrSpace(AddrSpace, ASLoc, AteExtraComma,
+                                      DefaultAS))
         return true;
     } else if (Lex.getKind() == lltok::kw_addrspace) {
       ASLoc = Lex.getLoc();
-      if (parseOptionalAddrSpace(AddrSpace))
+      if (parseOptionalAddrSpace(AddrSpace, DefaultAS))
         return true;
     } else if (Lex.getKind() == lltok::MetadataVar) {
       AteExtraComma = true;
@@ -8386,11 +8389,12 @@ int LLParser::parseAlloc(Instruction *&Inst, PerFunctionState &PFS) {
         if (Lex.getKind() == lltok::kw_align) {
           if (parseOptionalAlignment(Alignment))
             return true;
-          if (parseOptionalCommaAddrSpace(AddrSpace, ASLoc, AteExtraComma))
+          if (parseOptionalCommaAddrSpace(AddrSpace, ASLoc, AteExtraComma,
+                                          DefaultAS))
             return true;
         } else if (Lex.getKind() == lltok::kw_addrspace) {
           ASLoc = Lex.getLoc();
-          if (parseOptionalAddrSpace(AddrSpace))
+          if (parseOptionalAddrSpace(AddrSpace, DefaultAS))
             return true;
         } else if (Lex.getKind() == lltok::MetadataVar) {
           AteExtraComma = true;

llvm/lib/IR/AsmWriter.cpp

@@ -4724,7 +4724,11 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
     }
 
     unsigned AddrSpace = AI->getAddressSpace();
-    if (AddrSpace != 0) {
+    unsigned DefaultAllocaAS =
+        I.getModule()->getDataLayout().getAllocaAddrSpace();
+    // Avoid confusion by omitting the addrspace only if it is 0 and that is the
+    // default. Dropping the "AddrSpace != 0" condition would also be correct.
+    if (AddrSpace != 0 || AddrSpace != DefaultAllocaAS) {
       Out << ", addrspace(" << AddrSpace << ')';
     }
   } else if (isa<CastInst>(I)) {

llvm/test/Assembler/alloca-addrspace-default.ll

@@ -0,0 +1,41 @@
+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+target datalayout = "A9"
+; CHECK: target datalayout = "A9"
+
+
+; CHECK: %alloca_scalar_no_align = alloca i32, align 4, addrspace(9)
+; CHECK-NEXT: %alloca_scalar_align4 = alloca i32, align 4, addrspace(9)
+; CHECK-NEXT: %alloca_scalar_no_align_metadata = alloca i32, align 4, addrspace(9), !foo !0
+; CHECK-NEXT: %alloca_scalar_align4_metadata = alloca i32, align 4, addrspace(9), !foo !0
+; CHECK-NEXT: %alloca_inalloca_scalar_no_align = alloca inalloca i32, align 4, addrspace(9)
+; CHECK-NEXT: %alloca_inalloca_scalar_align4_metadata = alloca inalloca i32, align 4, addrspace(9), !foo !0
+define void @use_alloca_default() {
+  %alloca_scalar_no_align = alloca i32
+  %alloca_scalar_align4 = alloca i32, align 4
+  %alloca_scalar_no_align_metadata = alloca i32, !foo !0
+  %alloca_scalar_align4_metadata = alloca i32, align 4, !foo !0
+  %alloca_inalloca_scalar_no_align = alloca inalloca i32
+  %alloca_inalloca_scalar_align4_metadata = alloca inalloca i32, align 4, !foo !0
+
+  ret void
+}
+
+; CHECK: %alloca_scalar_no_align = alloca i32, align 4, addrspace(0)
+; CHECK-NEXT: %alloca_scalar_align4 = alloca i32, align 4, addrspace(0)
+; CHECK-NEXT: %alloca_scalar_no_align_metadata = alloca i32, align 4, addrspace(0), !foo !0
+; CHECK-NEXT: %alloca_scalar_align4_metadata = alloca i32, align 4, addrspace(0), !foo !0
+; CHECK-NEXT: %alloca_inalloca_scalar_no_align = alloca inalloca i32, align 4, addrspace(0)
+; CHECK-NEXT: %alloca_inalloca_scalar_align4_metadata = alloca inalloca i32, align 4, addrspace(0), !foo !0
+define void @use_alloca_nondefault0() {
+  %alloca_scalar_no_align = alloca i32, addrspace(0)
+  %alloca_scalar_align4 = alloca i32, align 4, addrspace(0)
+  %alloca_scalar_no_align_metadata = alloca i32, addrspace(0), !foo !0
+  %alloca_scalar_align4_metadata = alloca i32, align 4, addrspace(0), !foo !0
+  %alloca_inalloca_scalar_no_align = alloca inalloca i32, addrspace(0)
+  %alloca_inalloca_scalar_align4_metadata = alloca inalloca i32, align 4, addrspace(0), !foo !0
+
+  ret void
+}
+
+!0 = !{}

llvm/test/Assembler/symbolic-addrspace.ll

@@ -38,7 +38,7 @@ target datalayout = "A1-G2-P3"
 define void @foo() {
   ; ALLOCA-IN-GLOBALS: %alloca = alloca i32, align 4, addrspace(2){{$}}
   ; ALLOCA-IN-GLOBALS: %alloca2 = alloca i32, align 4, addrspace(1){{$}}
-  ; ALLOCA-IN-GLOBALS: %alloca3 = alloca i32, align 4{{$}}
+  ; ALLOCA-IN-GLOBALS: %alloca3 = alloca i32, align 4, addrspace(1){{$}}
   ; ALLOCA-IN-GLOBALS: %alloca4 = alloca i32, align 4, addrspace(3){{$}}
   %alloca = alloca i32, addrspace("G")
   %alloca2 = alloca i32, addrspace("A")

llvm/test/CodeGen/AMDGPU/assert-wrong-alloca-addrspace.ll

@@ -10,7 +10,7 @@ declare void @func(ptr)
 
 define void @main() {
 bb:
-  %alloca = alloca i32, align 4
+  %alloca = alloca i32, align 4, addrspace(0)
   call void @func(ptr %alloca)
   ret void
 }

llvm/test/CodeGen/AMDGPU/lower-indirect-lds-references.ll

@@ -16,7 +16,7 @@ define amdgpu_kernel void @offloading_kernel() {
 }
 
 define void @call_unknown() {
-  %1 = alloca ptr, align 8
+  %1 = alloca ptr, align 8, addrspace(0)
   %2 = call i32 %1()
   ret void
 }

llvm/test/Transforms/Attributor/ArgumentPromotion/alloca-as.ll

@@ -10,7 +10,7 @@ define i32 @bar(i32 %arg) {
 ; TUNIT-LABEL: define {{[^@]+}}@bar
 ; TUNIT-SAME: (i32 [[ARG:%.*]]) {
 ; TUNIT-NEXT:  entry:
-; TUNIT-NEXT:    [[STACK:%.*]] = alloca i32, align 4
+; TUNIT-NEXT:    [[STACK:%.*]] = alloca i32, align 4, addrspace(0)
 ; TUNIT-NEXT:    store i32 [[ARG]], ptr [[STACK]], align 4
 ; TUNIT-NEXT:    [[TMP0:%.*]] = load i32, ptr [[STACK]], align 4
 ; TUNIT-NEXT:    [[CALL:%.*]] = call i32 @foo(i32 [[TMP0]])
@@ -19,13 +19,13 @@ define i32 @bar(i32 %arg) {
 ; CGSCC-LABEL: define {{[^@]+}}@bar
 ; CGSCC-SAME: (i32 [[ARG:%.*]]) {
 ; CGSCC-NEXT:  entry:
-; CGSCC-NEXT:    [[STACK:%.*]] = alloca i32, align 4
+; CGSCC-NEXT:    [[STACK:%.*]] = alloca i32, align 4, addrspace(0)
 ; CGSCC-NEXT:    store i32 [[ARG]], ptr [[STACK]], align 4
 ; CGSCC-NEXT:    [[CALL:%.*]] = call i32 @foo(i32 [[ARG]])
 ; CGSCC-NEXT:    ret i32 [[CALL]]
 ;
 entry:
-  %stack = alloca i32
+  %stack = alloca i32, addrspace(0)
   store i32 %arg, ptr %stack
   %call = call i32 @foo(ptr %stack)
   ret i32 %call

llvm/test/Transforms/InstCombine/alloca-in-non-alloca-as.ll

@@ -12,12 +12,12 @@ declare void @use2(ptr, ptr)
 define weak amdgpu_kernel void @__omp_offloading_802_ea0109_main_l8(ptr %a) {
 ; CHECK-LABEL: @__omp_offloading_802_ea0109_main_l8(
 ; CHECK-NEXT:  .master:
-; CHECK-NEXT:    [[TMP0:%.*]] = alloca [8 x i8], align 1
+; CHECK-NEXT:    [[TMP0:%.*]] = alloca [8 x i8], align 1, addrspace(0)
 ; CHECK-NEXT:    call void @use2(ptr nonnull [[TMP0]], ptr nonnull [[TMP0]])
 ; CHECK-NEXT:    ret void
 ;
 .master:
-  %0 = alloca i8, i64 8, align 1
+  %0 = alloca i8, i64 8, align 1, addrspace(0)
   store ptr undef, ptr %0, align 8
   call void @use2(ptr %0, ptr %0)
   ret void
@@ -28,23 +28,23 @@ define weak amdgpu_kernel void @__omp_offloading_802_ea0109_main_l8(ptr %a) {
 define void @spam(ptr %arg1) {
 ; CHECK-LABEL: @spam(
 ; CHECK-NEXT:  bb:
-; CHECK-NEXT:    [[ALLOCA1:%.*]] = alloca [0 x [30 x %struct.widget]], align 16
+; CHECK-NEXT:    [[ALLOCA1:%.*]] = alloca [0 x [30 x %struct.widget]], align 16, addrspace(0)
 ; CHECK-NEXT:    call void @zot(ptr nonnull [[ALLOCA1]])
 ; CHECK-NEXT:    ret void
 ;
 bb:
-  %alloca = alloca [30 x %struct.widget], i32 0, align 16
+  %alloca = alloca [30 x %struct.widget], i32 0, align 16, addrspace(0)
   call void @zot(ptr %alloca)
   ret void
 }
 
 define i1 @alloca_addrspace_0_nonnull() {
 ; CHECK-LABEL: @alloca_addrspace_0_nonnull(
-; CHECK-NEXT:    [[ALLOCA:%.*]] = alloca i8, align 1
+; CHECK-NEXT:    [[ALLOCA:%.*]] = alloca i8, align 1, addrspace(0)
 ; CHECK-NEXT:    call void @use(ptr nonnull [[ALLOCA]])
 ; CHECK-NEXT:    ret i1 true
 ;
-  %alloca = alloca i8
+  %alloca = alloca i8, addrspace(0)
   call void @use(ptr %alloca)
   %cmp = icmp ne ptr %alloca, null
   ret i1 %cmp

llvm/test/Transforms/InstCombine/ptr-replace-alloca.ll

@@ -153,7 +153,7 @@ define i32 @remove_alloca_ptr_arg(i1 %c, ptr %ptr) {
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
 entry:
-  %alloca = alloca [32 x i8]
+  %alloca = alloca [32 x i8], addrspace(0)
   call void @llvm.memcpy.p0.p0.i64(ptr %alloca, ptr @g1, i64 32, i1 false)
   br i1 %c, label %if, label %join
 
@@ -212,7 +212,7 @@ define i32 @test_memcpy_after_phi(i1 %cond, ptr %ptr) {
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
 entry:
-  %a = alloca [32 x i8]
+  %a = alloca [32 x i8], addrspace(0)
   br i1 %cond, label %if, label %join
 
 if:
@@ -228,7 +228,7 @@ join:
 define i32 @addrspace_diff_keep_alloca(i1 %cond, ptr %x) {
 ; CHECK-LABEL: @addrspace_diff_keep_alloca(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[A:%.*]] = alloca [32 x i8], align 1
+; CHECK-NEXT:    [[A:%.*]] = alloca [32 x i8], align 1, addrspace(0)
 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p1.i64(ptr noundef nonnull align 1 dereferenceable(32) [[A]], ptr addrspace(1) noundef align 16 dereferenceable(32) @g2, i64 32, i1 false)
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[IF:%.*]], label [[JOIN:%.*]]
 ; CHECK:       if:
@@ -239,7 +239,7 @@ define i32 @addrspace_diff_keep_alloca(i1 %cond, ptr %x) {
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
 entry:
-  %a = alloca [32 x i8]
+  %a = alloca [32 x i8], addrspace(0)
   call void @llvm.memcpy.p0.p1.i64(ptr %a, ptr addrspace(1) @g2, i64 32, i1 false)
   br i1 %cond, label %if, label %join
 
@@ -255,7 +255,7 @@ join:
 define i32 @addrspace_diff_keep_alloca_extra_gep(i1 %cond, ptr %x) {
 ; CHECK-LABEL: @addrspace_diff_keep_alloca_extra_gep(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[A:%.*]] = alloca [32 x i8], align 1
+; CHECK-NEXT:    [[A:%.*]] = alloca [32 x i8], align 1, addrspace(0)
 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p1.i64(ptr noundef nonnull align 1 dereferenceable(32) [[A]], ptr addrspace(1) noundef align 16 dereferenceable(32) @g2, i64 32, i1 false)
 ; CHECK-NEXT:    br i1 [[COND:%.*]], label [[IF:%.*]], label [[JOIN:%.*]]
 ; CHECK:       if:
@@ -267,7 +267,7 @@ define i32 @addrspace_diff_keep_alloca_extra_gep(i1 %cond, ptr %x) {
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
 entry:
-  %a = alloca [32 x i8]
+  %a = alloca [32 x i8], addrspace(0)
   call void @llvm.memcpy.p0.p1.i64(ptr %a, ptr addrspace(1) @g2, i64 32, i1 false)
   %gep = getelementptr i8, ptr %a, i64 4
   br i1 %cond, label %if, label %join
@@ -293,7 +293,7 @@ define i32 @addrspace_diff_remove_alloca(i1 %cond) {
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
 entry:
-  %a = alloca [32 x i8]
+  %a = alloca [32 x i8], addrspace(0)
   call void @llvm.memcpy.p0.p1.i64(ptr %a, ptr addrspace(1) @g2, i64 32, i1 false)
   %gep = getelementptr inbounds [32 x i8], ptr %a, i32 0, i32 2
   br i1 %cond, label %if, label %join
@@ -320,7 +320,7 @@ define i32 @phi_loop(i1 %c) {
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
 entry:
-  %alloca = alloca [32 x i8]
+  %alloca = alloca [32 x i8], addrspace(0)
   call void @llvm.memcpy.p0.p0.i64(ptr %alloca, ptr @g1, i64 32, i1 false)
   br label %loop
 
@@ -337,7 +337,7 @@ exit:
 define i32 @phi_loop_different_addrspace(i1 %c) {
 ; CHECK-LABEL: @phi_loop_different_addrspace(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[ALLOCA:%.*]] = alloca [32 x i8], align 1
+; CHECK-NEXT:    [[ALLOCA:%.*]] = alloca [32 x i8], align 1, addrspace(0)
 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p1.i64(ptr noundef nonnull align 1 dereferenceable(32) [[ALLOCA]], ptr addrspace(1) noundef align 16 dereferenceable(32) @g2, i64 32, i1 false)
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
@@ -349,7 +349,7 @@ define i32 @phi_loop_different_addrspace(i1 %c) {
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
 entry:
-  %alloca = alloca [32 x i8]
+  %alloca = alloca [32 x i8], addrspace(0)
   call void @llvm.memcpy.p0.p1.i64(ptr %alloca, ptr addrspace(1) @g2, i64 32, i1 false)
   br label %loop
 
@@ -371,7 +371,7 @@ define i8 @select_same_addrspace_remove_alloca(i1 %cond, ptr %p) {
 ; CHECK-NEXT:    ret i8 [[LOAD]]
 ;
 entry:
-  %alloca = alloca [32 x i8]
+  %alloca = alloca [32 x i8], addrspace(0)
   call void @llvm.memcpy.p0.p0.i64(ptr %alloca, ptr @g1, i64 32, i1 false)
   %ptr = select i1 %cond, ptr %alloca, ptr %p
   %load = load i8, ptr %ptr
@@ -381,14 +381,14 @@ entry:
 define i8 @select_after_memcpy_keep_alloca(i1 %cond, ptr %p) {
 ; CHECK-LABEL: @select_after_memcpy_keep_alloca(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[ALLOCA:%.*]] = alloca [32 x i8], align 1
+; CHECK-NEXT:    [[ALLOCA:%.*]] = alloca [32 x i8], align 1, addrspace(0)
 ; CHECK-NEXT:    [[PTR:%.*]] = select i1 [[COND:%.*]], ptr [[ALLOCA]], ptr [[P:%.*]]
 ; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 1 dereferenceable(32) [[PTR]], ptr noundef nonnull align 16 dereferenceable(32) @g1, i64 32, i1 false)
 ; CHECK-NEXT:    [[LOAD:%.*]] = load i8, ptr [[PTR]], align 1
 ; CHECK-NEXT:    ret i8 [[LOAD]]
 ;
 entry:
-  %alloca = alloca [32 x i8]
+  %alloca = alloca [32 x i8], addrspace(0)
   %ptr = select i1 %cond, ptr %alloca, ptr %p
   call void @llvm.memcpy.p0.p0.i64(ptr %ptr, ptr @g1, i64 32, i1 false)
   %load = load i8, ptr %ptr
@@ -418,7 +418,7 @@ define i8 @select_diff_addrspace_remove_alloca(i1 %cond, ptr %p) {
 ; CHECK-NEXT:    ret i8 0
 ;
 entry:
-  %alloca = alloca [32 x i8]
+  %alloca = alloca [32 x i8], addrspace(0)
   call void @llvm.memcpy.p0.p1.i64(ptr %alloca, ptr addrspace(1) @g2, i64 32, i1 false)
   %gep = getelementptr inbounds [32 x i8], ptr %alloca, i32 0, i32 2
   %sel = select i1 %cond, ptr %alloca, ptr %gep
@@ -435,7 +435,7 @@ define i8 @select_diff_addrspace_remove_alloca_asan(i1 %cond, ptr %p) sanitize_a
 ; CHECK-NEXT:    ret i8 [[LOAD]]
 ;
 entry:
-  %alloca = alloca [32 x i8]
+  %alloca = alloca [32 x i8], addrspace(0)
   call void @llvm.memcpy.p0.p1.i64(ptr %alloca, ptr addrspace(1) @g2, i64 32, i1 false)
   %gep = getelementptr inbounds [32 x i8], ptr %alloca, i32 0, i32 2
   %sel = select i1 %cond, ptr %alloca, ptr %gep