AMDGPU: Fix broken opaque pointer handling in printf pass

[arsenm]

Summary

This was directly considering the pointee type, and also applying
special semantics to constant address space.

@vikramRH since you're looking at this in D138702, can you please do something
about the test coverage before touching this pass? There's no coverage of any of the
format string handling and I see obvious bugs in every part of it. The same initializer bugs I fixed
for the format string in D140558 are repeated for print of string later.

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp

333

Should use GLOBAL_ADDRESS, this is repeated several other times in this function

384–385

Should be using IRBuilder, this is unconditionally creating no-op bitcasts with opaque pointers

387

Should create stores with explicit alignments

420

None of these paths are tested and I think this is broken for undef/poison. Also need some half handling

426–435

This is all wrong for the same reasons as the format string

446

No raw news. Use SmallString

467

Don't see why we need to use ptrtoint, store of pointer works just as well

472

Should at least not die on scalable vector IR

473

This is broken for vectors of pointers

520

Should use getTypeStoreSize

525–526

Another unneeded bitcast with opaque pointers

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp

326–327

Can add a lot of other attributes

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp

426

I don't see why this can't just emit a memcpy

[arsenm]

ping

[sameerds]

This pass is used only by OpenCL on AMDGPU. It's meant to be deprecated with @vikramRH working on a replacement that unifies HIP and OpenCL.

@arsenm, The change looks straightforward enough, but is it known to pass on internal OpenCL builds?

[sameerds]

LGTM, assuming it does not break internal OpenCL builds.

[arsenm]

In D140560#4027791, @sameerds wrote:

LGTM, assuming it does not break internal OpenCL builds.

It passes. A hacky workaround for this slipped in one of the merge commits into the internal branches

[arsenm]

7c327c2fbb8af6ff6eeb93cb976212068044a9e2

[saghir]

Hi, this seems to be causing our bots to fail. One example is https://lab.llvm.org/buildbot/#/builders/231/builds/6915. Can you please take a look? Thanks!

[arsenm]

In D140560#4030857, @saghir wrote:

Hi, this seems to be causing our bots to fail. One example is https://lab.llvm.org/buildbot/#/builders/231/builds/6915. Can you please take a look? Thanks!

I have a patch ready for this, need to write some more tests for it

[arsenm]

In D140560#4031989, @arsenm wrote:

In D140560#4030857, @saghir wrote:

Hi, this seems to be causing our bots to fail. One example is https://lab.llvm.org/buildbot/#/builders/231/builds/6915. Can you please take a look? Thanks!

I have a patch ready for this, need to write some more tests for it

Try 40078a6b713730ffc164d4c0733d26352eb1e236

[saghir]

In D140560#4032567, @arsenm wrote:

In D140560#4031989, @arsenm wrote:

In D140560#4030857, @saghir wrote:

Hi, this seems to be causing our bots to fail. One example is https://lab.llvm.org/buildbot/#/builders/231/builds/6915. Can you please take a look? Thanks!

I have a patch ready for this, need to write some more tests for it

Try 40078a6b713730ffc164d4c0733d26352eb1e236

Thanks for taking a look. Your patch seems to have fixed the error seen before but it fails at a later check now:

/llvm/test/CodeGen/AMDGPU/opencl-printf.ll:1874:13: error: GCN-NEXT: expected string not found in input
; GCN-NEXT: store i32 1953722977, ptr addrspace(1) [[PRINTBUFFPTRCAST]], align 4

Logs can be found here: https://lab.llvm.org/buildbot/#/builders/231/builds/7035/steps/6/logs/FAIL__LLVM__opencl-printf_ll

[nemanjai]

In D140560#4036217, @saghir wrote:

In D140560#4032567, @arsenm wrote:

In D140560#4031989, @arsenm wrote:

In D140560#4030857, @saghir wrote:

Hi, this seems to be causing our bots to fail. One example is https://lab.llvm.org/buildbot/#/builders/231/builds/6915. Can you please take a look? Thanks!

I have a patch ready for this, need to write some more tests for it

Try 40078a6b713730ffc164d4c0733d26352eb1e236

Thanks for taking a look. Your patch seems to have fixed the error seen before but it fails at a later check now:

/llvm/test/CodeGen/AMDGPU/opencl-printf.ll:1874:13: error: GCN-NEXT: expected string not found in input
; GCN-NEXT: store i32 1953722977, ptr addrspace(1) [[PRINTBUFFPTRCAST]], align 4

Logs can be found here: https://lab.llvm.org/buildbot/#/builders/231/builds/7035/steps/6/logs/FAIL__LLVM__opencl-printf_ll

Since this is still causing failures (i.e. DataExtractor does not reorder bytes for getBytes() as it does for getU...()), we can fix the problem as follows:

diff --git a/llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp b/llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp
index 18dbf5d..63a365e 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp
@@ -435,19 +435,31 @@ bool AMDGPUPrintfRuntimeBindingImpl::lowerPrintfForGpu(Module &M) {
             DataExtractor Extractor(S, /*IsLittleEndian=*/true, 8);
             DataExtractor::Cursor Offset(0);
             while (Offset && Offset.tell() < S.size()) {
-              StringRef ReadBytes = Extractor.getBytes(
-                  Offset, std::min(ReadSize, S.size() - Offset.tell()));
+              uint64_t ReadNow = std::min(ReadSize, S.size() - Offset.tell());
+              uint64_t ReadBytes = 0;
+              switch (ReadNow) {
+              default: llvm_unreachable("min(4, X) > 4?");
+              case 1:
+                ReadBytes = Extractor.getU8(Offset);
+                break;
+              case 2:
+                ReadBytes = Extractor.getU16(Offset);
+                break;
+              case 3:
+                ReadBytes = Extractor.getU24(Offset);
+                break;
+              case 4:
+                ReadBytes = Extractor.getU32(Offset);
+                break;
+              }
 
               cantFail(Offset.takeError(),
                        "failed to read bytes from constant array");
 
-              APInt IntVal(8 * ReadBytes.size(), 0);
-              LoadIntFromMemory(
-                  IntVal, reinterpret_cast<const uint8_t *>(ReadBytes.data()),
-                  ReadBytes.size());
+              APInt IntVal(8 * ReadSize, ReadBytes);
 
               // TODO: Should not bothering aligning up.
-              if (ReadBytes.size() < ReadSize)
+              if (ReadNow < ReadSize)
                 IntVal = IntVal.zext(8 * ReadSize);
 
               Type *IntTy = Type::getIntNTy(Ctx, IntVal.getBitWidth());

@arsenm Would a fix similar to this be acceptable?

[arsenm]

In D140560#4040447, @nemanjai wrote:

In D140560#4036217, @saghir wrote:

In D140560#4032567, @arsenm wrote:

In D140560#4031989, @arsenm wrote:

In D140560#4030857, @saghir wrote:

Hi, this seems to be causing our bots to fail. One example is https://lab.llvm.org/buildbot/#/builders/231/builds/6915. Can you please take a look? Thanks!

I have a patch ready for this, need to write some more tests for it

Try 40078a6b713730ffc164d4c0733d26352eb1e236

Thanks for taking a look. Your patch seems to have fixed the error seen before but it fails at a later check now:

/llvm/test/CodeGen/AMDGPU/opencl-printf.ll:1874:13: error: GCN-NEXT: expected string not found in input
; GCN-NEXT: store i32 1953722977, ptr addrspace(1) [[PRINTBUFFPTRCAST]], align 4

Logs can be found here: https://lab.llvm.org/buildbot/#/builders/231/builds/7035/steps/6/logs/FAIL__LLVM__opencl-printf_ll

Since this is still causing failures (i.e. DataExtractor does not reorder bytes for getBytes() as it does for getU...()), we can fix the problem as follows:

diff --git a/llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp b/llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp
index 18dbf5d..63a365e 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp
@@ -435,19 +435,31 @@ bool AMDGPUPrintfRuntimeBindingImpl::lowerPrintfForGpu(Module &M) {
             DataExtractor Extractor(S, /*IsLittleEndian=*/true, 8);
             DataExtractor::Cursor Offset(0);
             while (Offset && Offset.tell() < S.size()) {
-              StringRef ReadBytes = Extractor.getBytes(
-                  Offset, std::min(ReadSize, S.size() - Offset.tell()));
+              uint64_t ReadNow = std::min(ReadSize, S.size() - Offset.tell());
+              uint64_t ReadBytes = 0;
+              switch (ReadNow) {
+              default: llvm_unreachable("min(4, X) > 4?");
+              case 1:
+                ReadBytes = Extractor.getU8(Offset);
+                break;
+              case 2:
+                ReadBytes = Extractor.getU16(Offset);
+                break;
+              case 3:
+                ReadBytes = Extractor.getU24(Offset);
+                break;
+              case 4:
+                ReadBytes = Extractor.getU32(Offset);
+                break;
+              }
 
               cantFail(Offset.takeError(),
                        "failed to read bytes from constant array");
 
-              APInt IntVal(8 * ReadBytes.size(), 0);
-              LoadIntFromMemory(
-                  IntVal, reinterpret_cast<const uint8_t *>(ReadBytes.data()),
-                  ReadBytes.size());
+              APInt IntVal(8 * ReadSize, ReadBytes);
 
               // TODO: Should not bothering aligning up.
-              if (ReadBytes.size() < ReadSize)
+              if (ReadNow < ReadSize)
                 IntVal = IntVal.zext(8 * ReadSize);
 
               Type *IntTy = Type::getIntNTy(Ctx, IntVal.getBitWidth());

@arsenm Would a fix similar to this be acceptable?

Yes, I was hoping to extend this to up to 16-bytes at a time but I guess I can figure that out then (we should probably just be emitting a memcpy/strcpy anyway)

[nemanjai]

In D140560#4040448, @arsenm wrote:

@arsenm Would a fix similar to this be acceptable?

Yes, I was hoping to extend this to up to 16-bytes at a time but I guess I can figure that out then (we should probably just be emitting a memcpy/strcpy anyway)

Did you want me to go ahead with this fix now to unblock the bots and then you guys can finalize the fixes with memcpy/strcpy at a later date?

[arsenm]

In D140560#4040714, @nemanjai wrote:

In D140560#4040448, @arsenm wrote:

@arsenm Would a fix similar to this be acceptable?

Yes, I was hoping to extend this to up to 16-bytes at a time but I guess I can figure that out then (we should probably just be emitting a memcpy/strcpy anyway)

Did you want me to go ahead with this fix now to unblock the bots and then you guys can finalize the fixes with memcpy/strcpy at a later date?

Yes, thanks

llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp

if (ArgDump)
       OpConvSpecifiers.push_back(Fmt[CurFmtSpecifierIdx]);
 
     PrevFmtSpecifierIdx = ++CurFmtSpecifierIdx;
   }
 }
 
 bool AMDGPUPrintfRuntimeBindingImpl::shouldPrintAsStr(char Specifier,
                                                       Type *OpType) const {
-  if (Specifier != 's')
-    return false;
-  const PointerType *PT = dyn_cast<PointerType>(OpType);
-  if (!PT || PT->getAddressSpace() != AMDGPUAS::CONSTANT_ADDRESS)
-    return false;
-  Type *ElemType = PT->getContainedType(0);
-  if (ElemType->getTypeID() != Type::IntegerTyID)
-    return false;
-  IntegerType *ElemIType = cast<IntegerType>(ElemType);
-  return ElemIType->getBitWidth() == 8;
+  return Specifier == 's' && isa<PointerType>(OpType);
 }
 
 static void diagnoseInvalidFormatString(const CallBase *CI) {
   DiagnosticInfoUnsupported UnsupportedFormatStr(
       *CI->getParent()->getParent(),
       "printf format string must be a trivially resolved constant string "
       "global variable",
       CI->getDebugLoc());
for (char C : Str) {
         break;
       }
     }
 
     // Insert the printf_alloc call
     Builder.SetInsertPoint(CI);
     Builder.SetCurrentDebugLocation(CI->getDebugLoc());
 
     AttributeList Attr = AttributeList::get(Ctx, AttributeList::FunctionIndex,
                                             Attribute::NoUnwind);
 
     Type *SizetTy = Type::getInt32Ty(Ctx);
 
     Type *Tys_alloc[1] = {SizetTy};
     Type *I8Ty = Type::getInt8Ty(Ctx);
     Type *I8Ptr = PointerType::get(I8Ty, 1);
     FunctionType *FTy_alloc = FunctionType::get(I8Ptr, Tys_alloc, false);
     FunctionCallee PrintfAllocFn =
         M.getOrInsertFunction(StringRef("__printf_alloc"), FTy_alloc, Attr);
 
     LLVM_DEBUG(dbgs() << "Printf metadata = " << Sizes.str() << '\n');
     std::string fmtstr = itostr(++UniqID) + ":" + Sizes.str();
     MDString *fmtStrArray = MDString::get(Ctx, fmtstr);
 
for (auto *CI : Printfs) {
     Builder.SetInsertPoint(Brnch);
 
     // store unique printf id in the buffer
     //
     GetElementPtrInst *BufferIdx = GetElementPtrInst::Create(
         I8Ty, pcall, ConstantInt::get(Ctx, APInt(32, 0)), "PrintBuffID", Brnch);
 
     Type *idPointer = PointerType::get(I32Ty, AMDGPUAS::GLOBAL_ADDRESS);
     Value *id_gep_cast =
         new BitCastInst(BufferIdx, idPointer, "PrintBuffIdCast", Brnch);
 
     new StoreInst(ConstantInt::get(I32Ty, UniqID), id_gep_cast, Brnch);
 
     // 1st 4 bytes hold the printf_id
     // the following GEP is the buffer pointer
     BufferIdx = GetElementPtrInst::Create(I8Ty, pcall,
                                           ConstantInt::get(Ctx, APInt(32, 4)),
                                           "PrintBuffGep", Brnch);
 
     Type *Int32Ty = Type::getInt32Ty(Ctx);
for (unsigned ArgCount = 1;
             IType = Int32Ty;
           } else if (auto *FpExt = dyn_cast<FPExtInst>(Arg)) {
             if (FpExt->getType()->isDoubleTy() &&
                 FpExt->getOperand(0)->getType()->isFloatTy()) {
               Arg = FpExt->getOperand(0);
               IType = Int32Ty;
             }
           }
         }
         Arg = new BitCastInst(Arg, IType, "PrintArgFP", Brnch);
         WhatToStore.push_back(Arg);
       } else if (ArgType->getTypeID() == Type::PointerTyID) {
         if (shouldPrintAsStr(OpConvSpecifiers[ArgCount - 1], ArgType)) {
           const char *S = NonLiteralStr;
           if (auto *ConstExpr = dyn_cast<ConstantExpr>(Arg)) {
             auto *GV = dyn_cast<GlobalVariable>(ConstExpr->getOperand(0));
             if (GV && GV->hasInitializer()) {
               Constant *Init = GV->getInitializer();
               bool IsZeroValue = Init->isZeroValue();
               auto *CA = dyn_cast<ConstantDataArray>(Init);
               if (IsZeroValue || (CA && CA->isString())) {
                 S = IsZeroValue ? "" : CA->getAsCString().data();
               }
             }
           }
           size_t SizeStr = strlen(S) + 1;
           size_t Rem = SizeStr % DWORD_ALIGN;
           size_t NSizeStr = 0;
           if (Rem) {
             NSizeStr = SizeStr + (DWORD_ALIGN - Rem);
           } else {
             NSizeStr = SizeStr;
           }
           if (S[0]) {
             char *MyNewStr = new char[NSizeStr]();
             strcpy(MyNewStr, S);
             int NumInts = NSizeStr / 4;
             int CharC = 0;
             while (NumInts) {
               int ANum = *(int *)(MyNewStr + CharC);
               CharC += 4;
               NumInts--;
               Value *ANumV = ConstantInt::get(Int32Ty, ANum, false);
               WhatToStore.push_back(ANumV);
             }
             delete[] MyNewStr;
           } else {
             // Empty string, give a hint to RT it is no NULL
             Value *ANumV = ConstantInt::get(Int32Ty, 0xFFFFFF00, false);
             WhatToStore.push_back(ANumV);
           }
         } else {
           uint64_t Size = TD->getTypeAllocSizeInBits(ArgType);
           assert((Size == 32 || Size == 64) && "unsupported size");
           Type *DstType = (Size == 32) ? Int32Ty : Int64Ty;
           Arg = new PtrToIntInst(Arg, DstType, "PrintArgPtr", Brnch);
           WhatToStore.push_back(Arg);
         }
       } else if (isa<FixedVectorType>(ArgType)) {
         Type *IType = nullptr;
         uint32_t EleCount = cast<FixedVectorType>(ArgType)->getNumElements();
         uint32_t EleSize = ArgType->getScalarSizeInBits();
         uint32_t TotalSize = EleCount * EleSize;
         if (EleCount == 3) {
           ShuffleVectorInst *Shuffle =
               new ShuffleVectorInst(Arg, Arg, ArrayRef<int>{0, 1, 2, 2});
           Shuffle->insertBefore(Brnch);
           Arg = Shuffle;
           ArgType = Arg->getType();
           TotalSize += EleSize;
for (unsigned ArgCount = 1;
         }
         Arg = new BitCastInst(Arg, IType, "PrintArgVect", Brnch);
         WhatToStore.push_back(Arg);
       } else {
         WhatToStore.push_back(Arg);
       }
       for (unsigned I = 0, E = WhatToStore.size(); I != E; ++I) {
         Value *TheBtCast = WhatToStore[I];
         unsigned ArgSize = TD->getTypeAllocSizeInBits(TheBtCast->getType()) / 8;
         SmallVector<Value *, 1> BuffOffset;
         BuffOffset.push_back(ConstantInt::get(I32Ty, ArgSize));
 
         Type *ArgPointer = PointerType::get(TheBtCast->getType(), 1);
         Value *CastedGEP =
             new BitCastInst(BufferIdx, ArgPointer, "PrintBuffPtrCast", Brnch);
         StoreInst *StBuff = new StoreInst(TheBtCast, CastedGEP, Brnch);
         LLVM_DEBUG(dbgs() << "inserting store to printf buffer:\n"
                           << *StBuff << '\n');
         (void)StBuff;
         if (I + 1 == E && ArgCount + 1 == CI->arg_size())
           break;
         BufferIdx = GetElementPtrInst::Create(I8Ty, BufferIdx, BuffOffset,
                                               "PrintBuffNextPtr", Brnch);

llvm/test/CodeGen/AMDGPU/opencl-printf.ll

 ; R600-NEXT:  entry:
 ; R600-NEXT:    [[STR:%.*]] = alloca [9 x i8], align 1, addrspace(5)
 ; R600-NEXT:    [[CALL1:%.*]] = call i32 (ptr addrspace(4), ...) @printf(ptr addrspace(4) @.str, ptr addrspace(5) [[STR]], i32 [[N:%.*]])
 ; R600-NEXT:    ret void
 ;
 ; GCN-LABEL: @test_kernel(
 ; GCN-NEXT:  entry:
 ; GCN-NEXT:    [[STR:%.*]] = alloca [9 x i8], align 1, addrspace(5)
-; GCN-NEXT:    [[PRINTF_ALLOC_FN:%.*]] = call ptr addrspace(1) @__printf_alloc(i32 16)
+; GCN-NEXT:    [[PRINTF_ALLOC_FN:%.*]] = call ptr addrspace(1) @__printf_alloc(i32 12)
 ; GCN-NEXT:    br label [[ENTRY_SPLIT:%.*]]
 ; GCN:       entry.split:
 ; GCN-NEXT:    [[TMP0:%.*]] = icmp ne ptr addrspace(1) [[PRINTF_ALLOC_FN]], null
 ; GCN-NEXT:    br i1 [[TMP0]], label [[TMP1:%.*]], label [[TMP2:%.*]]
 ; GCN:       1:
 ; GCN-NEXT:    [[PRINTBUFFID:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTF_ALLOC_FN]], i32 0
 ; GCN-NEXT:    [[PRINTBUFFIDCAST:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFID]] to ptr addrspace(1)
 ; GCN-NEXT:    store i32 1, ptr addrspace(1) [[PRINTBUFFIDCAST]], align 4
 ; GCN-NEXT:    [[PRINTBUFFGEP:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTF_ALLOC_FN]], i32 4
-; GCN-NEXT:    [[PRINTARGPTR:%.*]] = ptrtoint ptr addrspace(5) [[STR]] to i64
 ; GCN-NEXT:    [[PRINTBUFFPTRCAST:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFGEP]] to ptr addrspace(1)
-; GCN-NEXT:    store i64 [[PRINTARGPTR]], ptr addrspace(1) [[PRINTBUFFPTRCAST]], align 4
-; GCN-NEXT:    [[PRINTBUFFNEXTPTR:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTBUFFGEP]], i32 8
+; GCN-NEXT:    store i32 4144959, ptr addrspace(1) [[PRINTBUFFPTRCAST]], align 4
+; GCN-NEXT:    [[PRINTBUFFNEXTPTR:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTBUFFGEP]], i32 4
 ; GCN-NEXT:    [[PRINTBUFFPTRCAST1:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFNEXTPTR]] to ptr addrspace(1)
 ; GCN-NEXT:    store i32 [[N:%.*]], ptr addrspace(1) [[PRINTBUFFPTRCAST1]], align 4
 ; GCN-NEXT:    br label [[TMP2]]
 ; GCN:       2:
 ; GCN-NEXT:    ret void
 ;
 entry:
   %str = alloca [9 x i8], align 1, addrspace(5)
   %call1 = call i32 (ptr addrspace(4), ...) @printf(ptr addrspace(4) @.str, ptr addrspace(5) %str, i32 %n)
   ret void
 }
 
+define amdgpu_kernel void @string_pointee_type(i32 %n) {
+; R600-LABEL: @string_pointee_type(
+; R600-NEXT:    [[STR:%.*]] = alloca [9 x i8], align 1, addrspace(5)
+; R600-NEXT:    [[CALL1:%.*]] = call i32 (ptr addrspace(4), ...) @printf(ptr addrspace(4) @.str, ptr addrspace(5) [[STR]], i32 [[N:%.*]])
+; R600-NEXT:    ret void
+;
+; GCN-LABEL: @string_pointee_type(
+; GCN-NEXT:    [[STR:%.*]] = alloca [9 x i8], align 1, addrspace(5)
+; GCN-NEXT:    [[PRINTF_ALLOC_FN:%.*]] = call ptr addrspace(1) @__printf_alloc(i32 12)
+; GCN-NEXT:    br label [[DOTSPLIT:%.*]]
+; GCN:       .split:
+; GCN-NEXT:    [[TMP1:%.*]] = icmp ne ptr addrspace(1) [[PRINTF_ALLOC_FN]], null
+; GCN-NEXT:    br i1 [[TMP1]], label [[TMP2:%.*]], label [[TMP3:%.*]]
+; GCN:       2:
+; GCN-NEXT:    [[PRINTBUFFID:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTF_ALLOC_FN]], i32 0
+; GCN-NEXT:    [[PRINTBUFFIDCAST:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFID]] to ptr addrspace(1)
+; GCN-NEXT:    store i32 2, ptr addrspace(1) [[PRINTBUFFIDCAST]], align 4
+; GCN-NEXT:    [[PRINTBUFFGEP:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTF_ALLOC_FN]], i32 4
+; GCN-NEXT:    [[PRINTBUFFPTRCAST:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFGEP]] to ptr addrspace(1)
+; GCN-NEXT:    store i32 4144959, ptr addrspace(1) [[PRINTBUFFPTRCAST]], align 4
+; GCN-NEXT:    [[PRINTBUFFNEXTPTR:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTBUFFGEP]], i32 4
+; GCN-NEXT:    [[PRINTBUFFPTRCAST1:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFNEXTPTR]] to ptr addrspace(1)
+; GCN-NEXT:    store i32 [[N:%.*]], ptr addrspace(1) [[PRINTBUFFPTRCAST1]], align 4
+; GCN-NEXT:    br label [[TMP3]]
+; GCN:       3:
+; GCN-NEXT:    ret void
+;
+  %str = alloca [9 x i8], align 1, addrspace(5)
+  %call1 = call i32 (ptr addrspace(4), ...) @printf(ptr addrspace(4) @.str, ptr addrspace(5) %str, i32 %n)
+  ret void
+}
+
+define amdgpu_kernel void @string_address_space4(i32 %n, ptr addrspace(4) %str) {
+; R600-LABEL: @string_address_space4(
+; R600-NEXT:    [[CALL1:%.*]] = call i32 (ptr addrspace(4), ...) @printf(ptr addrspace(4) @.str, ptr addrspace(4) [[STR:%.*]], i32 [[N:%.*]])
+; R600-NEXT:    ret void
+;
+; GCN-LABEL: @string_address_space4(
+; GCN-NEXT:    [[PRINTF_ALLOC_FN:%.*]] = call ptr addrspace(1) @__printf_alloc(i32 12)
+; GCN-NEXT:    br label [[DOTSPLIT:%.*]]
+; GCN:       .split:
+; GCN-NEXT:    [[TMP1:%.*]] = icmp ne ptr addrspace(1) [[PRINTF_ALLOC_FN]], null
+; GCN-NEXT:    br i1 [[TMP1]], label [[TMP2:%.*]], label [[TMP3:%.*]]
+; GCN:       2:
+; GCN-NEXT:    [[PRINTBUFFID:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTF_ALLOC_FN]], i32 0
+; GCN-NEXT:    [[PRINTBUFFIDCAST:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFID]] to ptr addrspace(1)
+; GCN-NEXT:    store i32 3, ptr addrspace(1) [[PRINTBUFFIDCAST]], align 4
+; GCN-NEXT:    [[PRINTBUFFGEP:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTF_ALLOC_FN]], i32 4
+; GCN-NEXT:    [[PRINTBUFFPTRCAST:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFGEP]] to ptr addrspace(1)
+; GCN-NEXT:    store i32 4144959, ptr addrspace(1) [[PRINTBUFFPTRCAST]], align 4
+; GCN-NEXT:    [[PRINTBUFFNEXTPTR:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTBUFFGEP]], i32 4
+; GCN-NEXT:    [[PRINTBUFFPTRCAST1:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFNEXTPTR]] to ptr addrspace(1)
+; GCN-NEXT:    store i32 [[N:%.*]], ptr addrspace(1) [[PRINTBUFFPTRCAST1]], align 4
+; GCN-NEXT:    br label [[TMP3]]
+; GCN:       3:
+; GCN-NEXT:    ret void
+;
+  %call1 = call i32 (ptr addrspace(4), ...) @printf(ptr addrspace(4) @.str, ptr addrspace(4) %str, i32 %n)
+  ret void
+}
+
+define amdgpu_kernel void @string_address_space1(i32 %n, ptr addrspace(1) %str) {
+; R600-LABEL: @string_address_space1(
+; R600-NEXT:    [[CALL1:%.*]] = call i32 (ptr addrspace(4), ...) @printf(ptr addrspace(4) @.str, ptr addrspace(1) [[STR:%.*]], i32 [[N:%.*]])
+; R600-NEXT:    ret void
+;
+; GCN-LABEL: @string_address_space1(
+; GCN-NEXT:    [[PRINTF_ALLOC_FN:%.*]] = call ptr addrspace(1) @__printf_alloc(i32 12)
+; GCN-NEXT:    br label [[DOTSPLIT:%.*]]
+; GCN:       .split:
+; GCN-NEXT:    [[TMP1:%.*]] = icmp ne ptr addrspace(1) [[PRINTF_ALLOC_FN]], null
+; GCN-NEXT:    br i1 [[TMP1]], label [[TMP2:%.*]], label [[TMP3:%.*]]
+; GCN:       2:
+; GCN-NEXT:    [[PRINTBUFFID:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTF_ALLOC_FN]], i32 0
+; GCN-NEXT:    [[PRINTBUFFIDCAST:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFID]] to ptr addrspace(1)
+; GCN-NEXT:    store i32 4, ptr addrspace(1) [[PRINTBUFFIDCAST]], align 4
+; GCN-NEXT:    [[PRINTBUFFGEP:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTF_ALLOC_FN]], i32 4
+; GCN-NEXT:    [[PRINTBUFFPTRCAST:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFGEP]] to ptr addrspace(1)
+; GCN-NEXT:    store i32 4144959, ptr addrspace(1) [[PRINTBUFFPTRCAST]], align 4
+; GCN-NEXT:    [[PRINTBUFFNEXTPTR:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTBUFFGEP]], i32 4
+; GCN-NEXT:    [[PRINTBUFFPTRCAST1:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFNEXTPTR]] to ptr addrspace(1)
+; GCN-NEXT:    store i32 [[N:%.*]], ptr addrspace(1) [[PRINTBUFFPTRCAST1]], align 4
+; GCN-NEXT:    br label [[TMP3]]
+; GCN:       3:
+; GCN-NEXT:    ret void
+;
+  %call1 = call i32 (ptr addrspace(4), ...) @printf(ptr addrspace(4) @.str, ptr addrspace(1) %str, i32 %n)
+  ret void
+}
+
+define amdgpu_kernel void @string_format_passed_i32(i32 %n, i32 %str) {
+; R600-LABEL: @string_format_passed_i32(
+; R600-NEXT:    [[CALL1:%.*]] = call i32 (ptr addrspace(4), ...) @printf(ptr addrspace(4) @.str, i32 [[STR:%.*]], i32 [[N:%.*]])
+; R600-NEXT:    ret void
+;
+; GCN-LABEL: @string_format_passed_i32(
+; GCN-NEXT:    [[PRINTF_ALLOC_FN:%.*]] = call ptr addrspace(1) @__printf_alloc(i32 12)
+; GCN-NEXT:    br label [[DOTSPLIT:%.*]]
+; GCN:       .split:
+; GCN-NEXT:    [[TMP1:%.*]] = icmp ne ptr addrspace(1) [[PRINTF_ALLOC_FN]], null
+; GCN-NEXT:    br i1 [[TMP1]], label [[TMP2:%.*]], label [[TMP3:%.*]]
+; GCN:       2:
+; GCN-NEXT:    [[PRINTBUFFID:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTF_ALLOC_FN]], i32 0
+; GCN-NEXT:    [[PRINTBUFFIDCAST:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFID]] to ptr addrspace(1)
+; GCN-NEXT:    store i32 5, ptr addrspace(1) [[PRINTBUFFIDCAST]], align 4
+; GCN-NEXT:    [[PRINTBUFFGEP:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTF_ALLOC_FN]], i32 4
+; GCN-NEXT:    [[PRINTBUFFPTRCAST:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFGEP]] to ptr addrspace(1)
+; GCN-NEXT:    store i32 [[STR:%.*]], ptr addrspace(1) [[PRINTBUFFPTRCAST]], align 4
+; GCN-NEXT:    [[PRINTBUFFNEXTPTR:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTBUFFGEP]], i32 4
+; GCN-NEXT:    [[PRINTBUFFPTRCAST1:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFNEXTPTR]] to ptr addrspace(1)
+; GCN-NEXT:    store i32 [[N:%.*]], ptr addrspace(1) [[PRINTBUFFPTRCAST1]], align 4
+; GCN-NEXT:    br label [[TMP3]]
+; GCN:       3:
+; GCN-NEXT:    ret void
+;
+  %call1 = call i32 (ptr addrspace(4), ...) @printf(ptr addrspace(4) @.str, i32 %str, i32 %n)
+  ret void
+}
+
+
 @str.as1 = private unnamed_addr addrspace(1) constant [6 x i8] c"%s:%d\00", align 1
 
 define amdgpu_kernel void @test_kernel_addrspacecasted_format_str(i32 %n) {
 ; R600-LABEL: @test_kernel_addrspacecasted_format_str(
 ; R600-NEXT:  entry:
 ; R600-NEXT:    [[STR:%.*]] = alloca [9 x i8], align 1, addrspace(5)
 ; R600-NEXT:    [[ARRAYDECAY:%.*]] = getelementptr inbounds [9 x i8], ptr addrspace(5) [[STR]], i32 0, i32 0
 ; R600-NEXT:    [[CALL1:%.*]] = call i32 (ptr addrspace(4), ...) @printf(ptr addrspace(4) addrspacecast (ptr addrspace(1) @str.as1 to ptr addrspace(4)), ptr addrspace(5) [[ARRAYDECAY]], i32 [[N:%.*]])
 ; R600-NEXT:    ret void
 ;
 ; GCN-LABEL: @test_kernel_addrspacecasted_format_str(
 ; GCN-NEXT:  entry:
 ; GCN-NEXT:    [[STR:%.*]] = alloca [9 x i8], align 1, addrspace(5)
 ; GCN-NEXT:    [[ARRAYDECAY:%.*]] = getelementptr inbounds [9 x i8], ptr addrspace(5) [[STR]], i32 0, i32 0
-; GCN-NEXT:    [[PRINTF_ALLOC_FN:%.*]] = call ptr addrspace(1) @__printf_alloc(i32 16)
+; GCN-NEXT:    [[PRINTF_ALLOC_FN:%.*]] = call ptr addrspace(1) @__printf_alloc(i32 12)
 ; GCN-NEXT:    br label [[ENTRY_SPLIT:%.*]]
 ; GCN:       entry.split:
 ; GCN-NEXT:    [[TMP0:%.*]] = icmp ne ptr addrspace(1) [[PRINTF_ALLOC_FN]], null
 ; GCN-NEXT:    br i1 [[TMP0]], label [[TMP1:%.*]], label [[TMP2:%.*]]
 ; GCN:       1:
 ; GCN-NEXT:    [[PRINTBUFFID:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTF_ALLOC_FN]], i32 0
 ; GCN-NEXT:    [[PRINTBUFFIDCAST:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFID]] to ptr addrspace(1)
-; GCN-NEXT:    store i32 2, ptr addrspace(1) [[PRINTBUFFIDCAST]], align 4
+; GCN-NEXT:    store i32 6, ptr addrspace(1) [[PRINTBUFFIDCAST]], align 4
 ; GCN-NEXT:    [[PRINTBUFFGEP:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTF_ALLOC_FN]], i32 4
-; GCN-NEXT:    [[PRINTARGPTR:%.*]] = ptrtoint ptr addrspace(5) [[ARRAYDECAY]] to i64
 ; GCN-NEXT:    [[PRINTBUFFPTRCAST:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFGEP]] to ptr addrspace(1)
-; GCN-NEXT:    store i64 [[PRINTARGPTR]], ptr addrspace(1) [[PRINTBUFFPTRCAST]], align 4
-; GCN-NEXT:    [[PRINTBUFFNEXTPTR:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTBUFFGEP]], i32 8
+; GCN-NEXT:    store i32 4144959, ptr addrspace(1) [[PRINTBUFFPTRCAST]], align 4
+; GCN-NEXT:    [[PRINTBUFFNEXTPTR:%.*]] = getelementptr i8, ptr addrspace(1) [[PRINTBUFFGEP]], i32 4
 ; GCN-NEXT:    [[PRINTBUFFPTRCAST1:%.*]] = bitcast ptr addrspace(1) [[PRINTBUFFNEXTPTR]] to ptr addrspace(1)
 ; GCN-NEXT:    store i32 [[N:%.*]], ptr addrspace(1) [[PRINTBUFFPTRCAST1]], align 4
 ; GCN-NEXT:    br label [[TMP2]]
 ; GCN:       2:
 ; GCN-NEXT:    ret void
 ;
 entry:
   %str = alloca [9 x i8], align 1, addrspace(5)