[clang] [CIR] Annotate AMDGPU printf ops with constant strings before lowering (PR #242111)

Bruno Cardoso Lopes via cfe-commits cfe-commits at lists.llvm.org
Thu Nov 12 16:49:10 PST 2026


https://github.com/bcardosolopes updated https://github.com/llvm/llvm-project/pull/242111

>From 9f0686b0acee07de9e0507ff1027a0cb278ddd01 Mon Sep 17 00:00:00 2001
From: Bruno Cardoso Lopes <bruno.cardoso at gmail.com>
Date: Wed, 11 Nov 2026 14:51:56 -0800
Subject: [PATCH] [CIR] Annotate AMDGPU printf ops with constant strings before
 lowering

Resolve constant format strings while producers are still CIR, so the
AMDGPU printf lowering does not meet converted producers under one-shot
conversion. This is required work for the one-shot LLVM conversion flip:
record one string per operand on each op and read the annotation in the
lowering, instead of walking producers there.

Direct constants use matchPattern and single widening steps use
CastOp::fold; the cast chain walk stays hand written because CastOp is
not ConstantLike and its fold folds narrowing casts. New tests cover
int-array globals, stale annotations, and a narrowing cast that must
not fold.

Assisted-by: Muse Code (Muse).
---
 .../CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp |   4 +
 .../DirectToLLVM/LowerToLLVMOffloadPrintf.cpp |   3 +-
 .../DirectToLLVM/LowerToLLVMOffloadPrintf.h   |  10 +
 .../LowerToLLVMOffloadPrintfAMDGPU.cpp        | 238 ++++++++---
 .../CIR/Lowering/offload-printf-amdgpu.cir    | 403 ++++++++++++++++++
 5 files changed, 598 insertions(+), 60 deletions(-)

diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
index 461b72839ec70..98c01696b9620 100644
--- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
+++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp
@@ -12,6 +12,7 @@
 
 #include "LowerToLLVM.h"
 #include "LowerToLLVMMetadata.h"
+#include "LowerToLLVMOffloadPrintf.h"
 #include "LowerToLLVMOpenCLMetadata.h"
 
 #include <array>
@@ -5237,6 +5238,9 @@ void ConvertCIRToLLVMPass::runOnOperation() {
   // the annotations attribute is filtered out during FuncOp/GlobalOp lowering.
   collectGlobalAnnotations(module);
 
+  // Resolve constant printf strings while their producers are still CIR.
+  annotateAMDGPUPrintfStrings(module, symbolTables);
+
   mlir::ConversionTarget target(getContext());
   target.addLegalOp<mlir::ModuleOp>();
   target.addLegalDialect<mlir::LLVM::LLVMDialect>();
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMOffloadPrintf.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMOffloadPrintf.cpp
index 7422a5d1cccfa..420c511221de3 100644
--- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMOffloadPrintf.cpp
+++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMOffloadPrintf.cpp
@@ -35,8 +35,7 @@ mlir::LogicalResult CIRToLLVMOffloadPrintfOpLowering::matchAndRewrite(
     return lowerNVPTXPrintf(op, adaptor.getFormat(), adaptor.getArgs(),
                             rewriter, dataLayout, symbolTables);
 
-  if (triple.isAMDGCN() ||
-      (triple.isSPIRV() && triple.getVendor() == llvm::Triple::AMD)) {
+  if (isAMDGPUPrintfModule(mod)) {
     bool isBuffered = false;
     if (auto kind = mod->getAttrOfType<mlir::StringAttr>(
             cir::CIRDialect::getAMDGPUPrintfKindAttrName()))
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMOffloadPrintf.h b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMOffloadPrintf.h
index 69a2811de9adf..a6362cd3dbbf1 100644
--- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMOffloadPrintf.h
+++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMOffloadPrintf.h
@@ -41,6 +41,16 @@ mlir::LogicalResult lowerAMDGPUPrintf(cir::OffloadPrintfOp op,
                                       unsigned genericAddrSpace,
                                       bool isBuffered);
 
+/// Whether \p module lowers device printf with the AMDGPU runtime
+/// interface: an AMDGCN triple, or SPIR-V with the AMD vendor.
+bool isAMDGPUPrintfModule(mlir::ModuleOp module);
+
+/// Resolve constant format strings for AMDGPU printf ops while their
+/// producers are still CIR, recording one string per operand on each
+/// op for the lowering to read. Must run before ConvertCIRToLLVM.
+void annotateAMDGPUPrintfStrings(mlir::ModuleOp module,
+                                 mlir::SymbolTableCollection &symbolTables);
+
 } // namespace direct
 } // namespace cir
 
diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMOffloadPrintfAMDGPU.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMOffloadPrintfAMDGPU.cpp
index 62883b562d89f..d832ce97a399e 100644
--- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMOffloadPrintfAMDGPU.cpp
+++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVMOffloadPrintfAMDGPU.cpp
@@ -16,9 +16,12 @@
 
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/Matchers.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SparseBitVector.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/TargetParser/Triple.h"
 #include "llvm/Transforms/Utils/AMDGPUEmitPrintf.h"
 
 namespace cir {
@@ -26,48 +29,118 @@ namespace direct {
 
 namespace {
 
+// One entry per operand, format first. A string entry means the
+// operand is a constant string; a unit entry means it is not.
+constexpr llvm::StringLiteral kPrintfConstStringsAttrName =
+    "cir.printf.const_strings";
+
+// Fold a constant through widening integral casts, each at its own width.
+// TODO: use the regular fold helpers once they fold widening cast chains
+// without also folding narrowing casts. CastOp is not ConstantLike and
+// its fold folds narrowing casts, so the chain stays hand written today.
+std::optional<llvm::APInt>
+foldConstantInt(mlir::Value value,
+                llvm::SmallPtrSetImpl<mlir::Operation *> &seen) {
+  mlir::Operation *def = value.getDefiningOp();
+  if (!def || !seen.insert(def).second)
+    return std::nullopt;
+  cir::IntAttr intAttr;
+  if (mlir::matchPattern(value, mlir::m_Constant(&intAttr)))
+    return intAttr.getValue();
+  auto cast = mlir::dyn_cast<cir::CastOp>(def);
+  if (!cast || cast.getKind() != cir::CastKind::integral)
+    return std::nullopt;
+  auto srcTy = mlir::dyn_cast<cir::IntType>(cast.getSrc().getType());
+  auto dstTy = mlir::dyn_cast<cir::IntType>(cast.getType());
+  if (!srcTy || !dstTy || dstTy.getWidth() < srcTy.getWidth() ||
+      dstTy.getWidth() > 64)
+    return std::nullopt;
+  // One widening step from a direct constant is the op's own fold;
+  // chains recurse, since fold sees only the immediate source.
+  llvm::SmallVector<mlir::OpFoldResult, 1> folded;
+  if (succeeded(cast->fold(folded)) && folded.size() == 1)
+    if (auto attr = mlir::dyn_cast<mlir::Attribute>(folded[0]))
+      if (auto foldedInt = mlir::dyn_cast<cir::IntAttr>(attr))
+        return foldedInt.getValue();
+  std::optional<llvm::APInt> foldedSrc = foldConstantInt(cast.getSrc(), seen);
+  if (!foldedSrc)
+    return std::nullopt;
+  return srcTy.isUnsigned() ? foldedSrc->zextOrTrunc(dstTy.getWidth())
+                            : foldedSrc->sextOrTrunc(dstTy.getWidth());
+}
+
 std::optional<int64_t> getConstantInt(mlir::Value value) {
-  auto constOp = value.getDefiningOp<cir::ConstantOp>();
-  auto intAttr =
-      constOp ? mlir::dyn_cast<cir::IntAttr>(constOp.getValue()) : nullptr;
-  if (!intAttr)
+  bool isUnsigned = false;
+  if (auto intTy = mlir::dyn_cast<cir::IntType>(value.getType()))
+    isUnsigned = !intTy.isSigned();
+  llvm::SmallPtrSet<mlir::Operation *, 4> seen;
+  std::optional<llvm::APInt> result = foldConstantInt(value, seen);
+  if (!result || result->getBitWidth() > 64)
     return std::nullopt;
-  const llvm::APInt &v = intAttr.getValue();
-  if (mlir::cast<cir::IntType>(intAttr.getType()).isSigned()
-          ? v.getSignificantBits() > 64
-          : v.getActiveBits() > 63)
+  // An unsigned value past INT64_MAX cannot be a byte offset here:
+  // returning it would wrap negative in the signed offset below.
+  if (isUnsigned ? result->getActiveBits() > 63
+                 : result->getSignificantBits() > 64)
     return std::nullopt;
-  return v.getSExtValue();
+  return isUnsigned ? result->getZExtValue() : result->getSExtValue();
 }
 
 bool isByteType(mlir::Type ty) {
-  auto intTy = mlir::dyn_cast<cir::IntType>(ty);
-  return intTy && intTy.getWidth() == 8;
+  if (auto intTy = mlir::dyn_cast<cir::IntType>(ty))
+    return intTy.getWidth() == 8;
+  return ty.isInteger(8);
+}
+
+std::optional<int64_t> scaledOffset(int64_t index, mlir::Type elemTy,
+                                    const mlir::DataLayout &dataLayout) {
+  llvm::TypeSize size = dataLayout.getTypeAllocSize(elemTy);
+  if (size.isScalable() || size.getFixedValue() >= (1ULL << 63))
+    return std::nullopt;
+  int64_t offset;
+  if (llvm::MulOverflow(index, static_cast<int64_t>(size.getFixedValue()),
+                        offset))
+    return std::nullopt;
+  return offset;
 }
 
 bool getConstantStringInfo(mlir::Value ptr, mlir::ModuleOp mod,
+                           const mlir::DataLayout &dataLayout,
                            mlir::SymbolTableCollection &symbolTables,
                            std::string &str) {
   int64_t offset = 0;
+  llvm::SmallPtrSet<mlir::Operation *, 8> seen;
   while (mlir::Operation *def = ptr.getDefiningOp()) {
+    if (!seen.insert(def).second)
+      return false;
     if (auto cast = mlir::dyn_cast<cir::CastOp>(def)) {
       if (cast.getKind() != cir::CastKind::array_to_ptrdecay &&
           cast.getKind() != cir::CastKind::bitcast &&
           cast.getKind() != cir::CastKind::address_space)
         break;
       ptr = cast.getSrc();
-    } else if (auto elt = mlir::dyn_cast<cir::GetElementOp>(def)) {
-      std::optional<int64_t> index = getConstantInt(elt.getIndex());
-      if (!index || !isByteType(elt.getElementType()) ||
-          llvm::AddOverflow(offset, *index, offset))
-        return false;
-      ptr = elt.getBase();
     } else if (auto stride = mlir::dyn_cast<cir::PtrStrideOp>(def)) {
+      mlir::Type elemTy = stride.getElementType();
+      // Lowering treats void and function elements as bytes, and
+      // neither has a data layout entry.
+      if (mlir::isa<cir::VoidType, cir::FuncType>(elemTy))
+        elemTy = cir::IntType::get(elemTy.getContext(), 8, false);
       std::optional<int64_t> index = getConstantInt(stride.getStride());
-      if (!index || !isByteType(stride.getElementType()) ||
-          llvm::AddOverflow(offset, *index, offset))
+      std::optional<int64_t> step =
+          index ? scaledOffset(*index, elemTy, dataLayout) : std::nullopt;
+      if (!step || llvm::AddOverflow(offset, *step, offset))
         return false;
       ptr = stride.getBase();
+    } else if (auto elt = mlir::dyn_cast<cir::GetElementOp>(def)) {
+      auto arrayTy =
+          mlir::dyn_cast<cir::ArrayType>(elt.getBaseType().getPointee());
+      std::optional<int64_t> index = getConstantInt(elt.getIndex());
+      std::optional<int64_t> step =
+          arrayTy && index
+              ? scaledOffset(*index, elt.getElementType(), dataLayout)
+              : std::nullopt;
+      if (!step || llvm::AddOverflow(offset, *step, offset))
+        return false;
+      ptr = elt.getBase();
     } else {
       break;
     }
@@ -76,45 +149,46 @@ bool getConstantStringInfo(mlir::Value ptr, mlir::ModuleOp mod,
   auto getGlobal = ptr.getDefiningOp<cir::GetGlobalOp>();
   if (!getGlobal)
     return false;
-
-  // The global may or may not have been converted already.
-  std::string data;
   mlir::Operation *symbol =
       symbolTables.lookupSymbolIn(mod, getGlobal.getNameAttr());
-  if (auto global = mlir::dyn_cast_if_present<cir::GlobalOp>(symbol)) {
-    std::optional<mlir::Attribute> init = global.getInitialValue();
-    auto arrayTy = mlir::dyn_cast<cir::ArrayType>(global.getSymType());
-    if (!global.getConstant() || !init || !arrayTy ||
-        !isByteType(arrayTy.getElementType()))
-      return false;
-    if (auto constArr = mlir::dyn_cast<cir::ConstArrayAttr>(*init)) {
-      auto strAttr = mlir::dyn_cast<mlir::StringAttr>(constArr.getElts());
-      if (!strAttr)
-        return false;
-      data = strAttr.getValue().str();
-    } else if (!mlir::isa<cir::ZeroAttr>(*init)) {
-      return false;
-    }
-    // Add back the trailing NULs the string attribute leaves out.
-    data.resize(arrayTy.getSize(), '\0');
-  } else if (auto global =
-                 mlir::dyn_cast_if_present<mlir::LLVM::GlobalOp>(symbol)) {
-    if (!global.getConstant())
-      return false;
-    mlir::Attribute value = global.getValueOrNull();
-    if (auto strAttr = mlir::dyn_cast_if_present<mlir::StringAttr>(value)) {
+  auto global = mlir::dyn_cast_if_present<cir::GlobalOp>(symbol);
+  if (!global)
+    return false;
+
+  std::string data;
+  std::optional<mlir::Attribute> init = global.getInitialValue();
+  auto arrayTy = mlir::dyn_cast<cir::ArrayType>(global.getSymType());
+  if (!global.getConstant() || !init || !arrayTy ||
+      !isByteType(arrayTy.getElementType()))
+    return false;
+  if (auto constArr = mlir::dyn_cast<cir::ConstArrayAttr>(*init)) {
+    if (auto strAttr = mlir::dyn_cast<mlir::StringAttr>(constArr.getElts())) {
       data = strAttr.getValue().str();
-    } else if (auto dense =
-                   mlir::dyn_cast_if_present<mlir::DenseIntElementsAttr>(value);
-               dense && dense.getElementType().isInteger(8)) {
-      for (const llvm::APInt &c : dense.getValues<llvm::APInt>())
-        data.push_back(static_cast<char>(c.getZExtValue()));
+    } else if (auto arrayAttr =
+                   mlir::dyn_cast<mlir::ArrayAttr>(constArr.getElts())) {
+      for (mlir::Attribute elt : arrayAttr) {
+        llvm::APInt byte;
+        if (auto intAttr = mlir::dyn_cast<cir::IntAttr>(elt)) {
+          if (!isByteType(intAttr.getType()))
+            return false;
+          byte = intAttr.getValue();
+        } else if (auto intAttr = mlir::dyn_cast<mlir::IntegerAttr>(elt)) {
+          if (!isByteType(intAttr.getType()))
+            return false;
+          byte = intAttr.getValue();
+        } else {
+          return false;
+        }
+        data.push_back(static_cast<char>(byte.getZExtValue()));
+      }
     } else {
       return false;
     }
-  } else {
+  } else if (!mlir::isa<cir::ZeroAttr>(*init)) {
     return false;
   }
+  // Add back the trailing NULs the string attribute leaves out.
+  data.resize(arrayTy.getSize(), '\0');
 
   if (offset < 0 || static_cast<uint64_t>(offset) > data.size())
     return false;
@@ -140,11 +214,24 @@ class AMDGPUPrintfLowering {
                        unsigned genericAddrSpace)
       : op(op), rewriter(rewriter), dataLayout(dataLayout),
         symbolTables(symbolTables), mod(op->getParentOfType<mlir::ModuleOp>()),
-        genericAddrSpace(genericAddrSpace) {}
+        genericAddrSpace(genericAddrSpace) {
+    if (auto attr =
+            op->getAttrOfType<mlir::ArrayAttr>(kPrintfConstStringsAttrName))
+      if (attr.size() == op.getArgs().size() + 1)
+        constStrings = attr;
+  }
 
   mlir::LogicalResult lower(mlir::ValueRange args, bool isBuffered);
 
 private:
+  std::optional<std::string> getConstString(size_t operandIndex) const {
+    if (!constStrings || operandIndex >= constStrings.size())
+      return std::nullopt;
+    auto strAttr = mlir::dyn_cast<mlir::StringAttr>(constStrings[operandIndex]);
+    if (!strAttr)
+      return std::nullopt;
+    return strAttr.getValue().str();
+  }
   mlir::Value getI32(uint32_t value) {
     return mlir::LLVM::ConstantOp::create(
         rewriter, op.getLoc(), rewriter.getI32Type(), llvm::APInt(32, value));
@@ -190,6 +277,7 @@ class AMDGPUPrintfLowering {
   mlir::SymbolTableCollection &symbolTables;
   mlir::ModuleOp mod;
   unsigned genericAddrSpace;
+  mlir::ArrayAttr constStrings;
 
   /// The rest of the op's block, which the expansion branches to.
   mlir::Block *cont = nullptr;
@@ -199,6 +287,40 @@ class AMDGPUPrintfLowering {
 
 } // namespace
 
+bool isAMDGPUPrintfModule(mlir::ModuleOp module) {
+  llvm::StringRef tripleStr;
+  if (auto tripleAttr = module->getAttrOfType<mlir::StringAttr>(
+          cir::CIRDialect::getTripleAttrName()))
+    tripleStr = tripleAttr.getValue();
+  llvm::Triple triple(tripleStr);
+  return triple.isAMDGCN() ||
+         (triple.isSPIRV() && triple.getVendor() == llvm::Triple::AMD);
+}
+
+void annotateAMDGPUPrintfStrings(mlir::ModuleOp module,
+                                 mlir::SymbolTableCollection &symbolTables) {
+  mlir::MLIRContext *ctx = module.getContext();
+  module.walk([&](cir::OffloadPrintfOp op) {
+    mlir::ModuleOp opModule = op->getParentOfType<mlir::ModuleOp>();
+    if (!isAMDGPUPrintfModule(opModule))
+      return;
+    mlir::DataLayout opLayout(opModule);
+    llvm::SmallVector<mlir::Attribute> entries;
+    auto resolve = [&](mlir::Value value) {
+      std::string str;
+      if (getConstantStringInfo(value, opModule, opLayout, symbolTables, str))
+        entries.push_back(mlir::StringAttr::get(ctx, str));
+      else
+        entries.push_back(mlir::UnitAttr::get(ctx));
+    };
+    resolve(op.getFormat());
+    for (mlir::Value arg : op.getArgs())
+      resolve(arg);
+    op->setAttr(kPrintfConstStringsAttrName,
+                mlir::ArrayAttr::get(ctx, entries));
+  });
+}
+
 mlir::Value AMDGPUPrintfLowering::createCall(llvm::StringRef name,
                                              mlir::Type resTy,
                                              mlir::ValueRange args) {
@@ -434,14 +556,12 @@ mlir::Value AMDGPUPrintfLowering::callBufferedPrintfStart(
     stringContents.push_back({"", lenWithNull, nonConstStrLen, false});
   }
 
-  mlir::OperandRange cirArgs = op->getOperands();
   for (size_t i = 1; i < args.size(); i++) {
     if (isCStringArg(args, i)) {
-      std::string argStr;
-      if (getConstantStringInfo(cirArgs[i], mod, symbolTables, argStr)) {
-        auto alignedLen = llvm::alignTo(argStr.size() + 1, 8);
-        stringContents.push_back({argStr, /*realSize=*/{}, /*alignedSize=*/{},
-                                  /*isConst=*/true});
+      if (std::optional<std::string> argStr = getConstString(i)) {
+        auto alignedLen = llvm::alignTo(argStr->size() + 1, 8);
+        stringContents.push_back({*argStr, /*realSize=*/{},
+                                  /*alignedSize=*/{}, /*isConst=*/true});
         bufSize += alignedLen;
       } else {
         lenWithNull = getStrlenWithNull(args[i]);
@@ -586,8 +706,10 @@ mlir::Value AMDGPUPrintfLowering::emitAMDGPUPrintfCall(mlir::ValueRange args,
 
   mlir::Value fmt = args[0];
 
-  if (getConstantStringInfo(op.getFormat(), mod, symbolTables, fmtStr))
+  if (std::optional<std::string> resolved = getConstString(0)) {
+    fmtStr = *resolved;
     llvm::locateAMDGPUPrintfCStrings(specIsCString, fmtStr);
+  }
 
   if (isBuffered) {
     llvm::SmallVector<StringData, 8> stringContents;
diff --git a/clang/test/CIR/Lowering/offload-printf-amdgpu.cir b/clang/test/CIR/Lowering/offload-printf-amdgpu.cir
index 89f37eecf7569..a734f7bfc658d 100644
--- a/clang/test/CIR/Lowering/offload-printf-amdgpu.cir
+++ b/clang/test/CIR/Lowering/offload-printf-amdgpu.cir
@@ -132,3 +132,406 @@ module attributes {cir.amdgpu_printf_kind = "buffered"} {
 // BUFFERED: [[P3:%.*]] = getelementptr inbounds i8, ptr addrspace(1) [[P2]], i32 8
 // BUFFERED: [[ARG:%.*]] = zext i32 %1 to i64
 // BUFFERED: store i64 [[ARG]], ptr addrspace(1) [[P3]], align 8
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+!u8i = !cir.int<u, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<"0123456789ABCDEFGHIJKLMNOPQRSTUV" : !cir.array<!s8i x 32>, trailing_zeros> : !cir.array<!s8i x 33>
+  cir.func @buffered_unsigned_stride() -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 33>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 33>> -> !cir.ptr<!s8i>
+    %2 = cir.const #cir.int<200> : !u8i
+    %3 = cir.ptr_stride %1, %2 : (!cir.ptr<!s8i>, !u8i) -> !cir.ptr<!s8i>
+    %4 = cir.const #cir.int<-195> : !s32i
+    %5 = cir.ptr_stride %3, %4 : (!cir.ptr<!s8i>, !s32i) -> !cir.ptr<!s8i>
+    %6 = cir.offload.printf(%5) : (!cir.ptr<!s8i>) -> !s32i
+    cir.return %6 : !s32i
+  }
+}
+
+// An unsigned narrow index stays unsigned: 200 + (-195) = 5.
+// Read as signed, the first stride would be -56 and the offset
+// out of range, so nothing would fold.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_unsigned_stride()
+// BUFFERED: call ptr addrspace(1) @__printf_alloc(i32 12)
+// BUFFERED: store i64 -3575341472883867058, ptr addrspace(1) %{{.*}}, align 8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:ce61d5df9609024e,56789ABCDEFGHIJKLMNOPQRSTUV"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.func @buffered_late_global(%v: !s32i, %str: !cir.ptr<!s8i>) -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 7>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 7>> -> !cir.ptr<!s8i>
+    %2 = cir.offload.printf(%1, %v, %str) : (!cir.ptr<!s8i>, !s32i, !cir.ptr<!s8i>) -> !s32i
+    cir.return %2 : !s32i
+  }
+  cir.global "private" constant cir_private @".str" = #cir.const_array<"%d %s\0A" : !cir.array<!s8i x 6>, trailing_zeros> : !cir.array<!s8i x 7>
+}
+
+// The global is defined after the function.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_late_global(i32 %0, ptr %1)
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:d3e1b03bc04075f4,%d %s\0A"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<"0123456789ABCDEFGHIJKLMNOPQRSTUV" : !cir.array<!s8i x 32>, trailing_zeros> : !cir.array<!s8i x 33>
+  cir.func @buffered_negative_stride() -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 33>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 33>> -> !cir.ptr<!s8i>
+    %2 = cir.const #cir.int<64> : !s32i
+    %3 = cir.ptr_stride %1, %2 : (!cir.ptr<!s8i>, !s32i) -> !cir.ptr<!s8i>
+    %4 = cir.const #cir.int<-56> : !s8i
+    %5 = cir.ptr_stride %3, %4 : (!cir.ptr<!s8i>, !s8i) -> !cir.ptr<!s8i>
+    %6 = cir.offload.printf(%5) : (!cir.ptr<!s8i>) -> !s32i
+    cir.return %6 : !s32i
+  }
+}
+
+// A negative signed stride subtracts: the folded format is the string at
+// byte 64 - 56 = 8.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_negative_stride()
+// BUFFERED: call ptr addrspace(1) @__printf_alloc(i32 12)
+// BUFFERED: store i64 6552682480851187470, ptr addrspace(1) %{{.*}}, align 8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:5aefcdffad0f770e,89ABCDEFGHIJKLMNOPQRSTUV"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<"0123456789ABCDEFGHIJKLMNOPQRSTUV" : !cir.array<!s8i x 32>, trailing_zeros> : !cir.array<!s8i x 33>
+  cir.func @buffered_get_element() -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 33>>
+    %idx = cir.const #cir.int<11> : !s32i
+    %1 = cir.get_element %0[%idx : !s32i] : !cir.ptr<!cir.array<!s8i x 33>> -> !cir.ptr<!s8i>
+    %2 = cir.offload.printf(%1) : (!cir.ptr<!s8i>) -> !s32i
+    cir.return %2 : !s32i
+  }
+}
+
+// A nonzero get_element index folds like the equivalent stride.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_get_element()
+// BUFFERED: call ptr addrspace(1) @__printf_alloc(i32 12)
+// BUFFERED: store i64 9208594728922682447, ptr addrspace(1) %{{.*}}, align 8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:7fcb801de1f8944f,BCDEFGHIJKLMNOPQRSTUV"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+!s16i = !cir.int<s, 16>
+!u16i = !cir.int<u, 16>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<"0123456789ABCDEFGHIJKLMNOPQRSTUV" : !cir.array<!s8i x 32>, trailing_zeros> : !cir.array<!s8i x 33>
+  cir.func @buffered_zext_sext() -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 33>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 33>> -> !cir.ptr<!s8i>
+    %2 = cir.const #cir.int<-56> : !s8i
+    %3 = cir.cast integral %2 : !s8i -> !s16i
+    %4 = cir.cast integral %3 : !s16i -> !u16i
+    %5 = cir.ptr_stride %1, %4 : (!cir.ptr<!s8i>, !u16i) -> !cir.ptr<!s8i>
+    %6 = cir.const #cir.int<-65463> : !s32i
+    %7 = cir.ptr_stride %5, %6 : (!cir.ptr<!s8i>, !s32i) -> !cir.ptr<!s8i>
+    %8 = cir.offload.printf(%7) : (!cir.ptr<!s8i>) -> !s32i
+    cir.return %8 : !s32i
+  }
+}
+
+// A zext of a sext keeps the sign extended bits: -56 widens to 65480,
+// and 65480 - 65463 = 17.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_zext_sext()
+// BUFFERED: call ptr addrspace(1) @__printf_alloc(i32 12)
+// BUFFERED: store i64 -8663088140963090983, ptr addrspace(1) %{{.*}}, align 8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:87c6873c1bfeedd9,HIJKLMNOPQRSTUV"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<"0123456789ABCDEFGHIJKLMNOPQRSTUV" : !cir.array<!s8i x 32>, trailing_zeros> : !cir.array<!s8i x 33>
+  cir.func @buffered_stride_i32() -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 33>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 33>> -> !cir.ptr<!s8i>
+    %2 = cir.cast bitcast %1 : !cir.ptr<!s8i> -> !cir.ptr<!s32i>
+    %3 = cir.const #cir.int<3> : !s32i
+    %4 = cir.ptr_stride %2, %3 : (!cir.ptr<!s32i>, !s32i) -> !cir.ptr<!s32i>
+    %5 = cir.cast bitcast %4 : !cir.ptr<!s32i> -> !cir.ptr<!s8i>
+    %6 = cir.offload.printf(%5) : (!cir.ptr<!s8i>) -> !s32i
+    cir.return %6 : !s32i
+  }
+}
+
+// A stride scales by the element size: 3 elements of 4 bytes land at byte 12.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_stride_i32()
+// BUFFERED: call ptr addrspace(1) @__printf_alloc(i32 12)
+// BUFFERED: store i64 7009764703486015180, ptr addrspace(1) %{{.*}}, align 8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:6147afdbc65af6cc,CDEFGHIJKLMNOPQRSTUV"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<"0123456789ABCDEFGHIJKLMNOPQRSTUV" : !cir.array<!s8i x 32>, trailing_zeros> : !cir.array<!s8i x 33>
+  cir.func @buffered_void_stride() -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 33>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 33>> -> !cir.ptr<!s8i>
+    %2 = cir.cast bitcast %1 : !cir.ptr<!s8i> -> !cir.ptr<!cir.void>
+    %3 = cir.const #cir.int<4> : !s32i
+    %4 = cir.ptr_stride %2, %3 : (!cir.ptr<!cir.void>, !s32i) -> !cir.ptr<!cir.void>
+    %5 = cir.cast bitcast %4 : !cir.ptr<!cir.void> -> !cir.ptr<!s8i>
+    %6 = cir.offload.printf(%5) : (!cir.ptr<!s8i>) -> !s32i
+    cir.return %6 : !s32i
+  }
+}
+
+// A stride over void steps by bytes, the way lowering treats void
+// elements, so the folded format is the string at byte 4.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_void_stride()
+// BUFFERED: call ptr addrspace(1) @__printf_alloc(i32 12)
+// BUFFERED: store i64 -3566044351531173967, ptr addrspace(1) %{{.*}}, align 8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:ce82dd8e55b237b1,456789ABCDEFGHIJKLMNOPQRSTUV"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<[#cir.int<37> : !s8i, #cir.int<100> : !s8i], trailing_zeros> : !cir.array<!s8i x 3>
+  cir.func @buffered_int_array(%v: !s32i) -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 3>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 3>> -> !cir.ptr<!s8i>
+    %2 = cir.offload.printf(%1, %v) : (!cir.ptr<!s8i>, !s32i) -> !s32i
+    cir.return %2 : !s32i
+  }
+}
+
+// A format global spelled as integer elements folds the same way as
+// the string spelling.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_int_array(i32 %0)
+// BUFFERED: call ptr addrspace(1) @__printf_alloc(i32 20)
+// BUFFERED: store i64 -2582314622382785113, ptr addrspace(1) %{{.*}}, align 8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:dc29c6885a93bda7,%d"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<[#cir.int<37> : !s8i, #cir.int<100> : !s8i], trailing_zeros> : !cir.array<!s8i x 3>
+  cir.func @buffered_unreachable(%v: !s32i) -> !s32i {
+    %z = cir.const #cir.int<0> : !s32i
+    cir.return %z : !s32i
+  ^bb1:
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 3>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 3>> -> !cir.ptr<!s8i>
+    %2 = cir.offload.printf(%1, %v) : (!cir.ptr<!s8i>, !s32i) -> !s32i
+    cir.return %2 : !s32i
+  }
+}
+
+// A printf in a block no branch reaches still folds: the format is
+// resolved before conversion, which visits unreachable blocks too.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_unreachable(i32 %0)
+// BUFFERED: call ptr addrspace(1) @__printf_alloc(i32 20)
+// BUFFERED: store i64 -2582314622382785113, ptr addrspace(1) %{{.*}}, align 8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:dc29c6885a93bda7,%d"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".fmt" = #cir.const_array<"%d %s\0A" : !cir.array<!s8i x 6>, trailing_zeros> : !cir.array<!s8i x 7>
+  cir.global "private" constant cir_private @".empty" = #cir.const_array<[#cir.int<0> : !s8i], trailing_zeros> : !cir.array<!s8i x 1>
+  cir.func @buffered_empty_arg(%v: !s32i) -> !s32i {
+    %0 = cir.get_global @".fmt" : !cir.ptr<!cir.array<!s8i x 7>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 7>> -> !cir.ptr<!s8i>
+    %2 = cir.get_global @".empty" : !cir.ptr<!cir.array<!s8i x 1>>
+    %3 = cir.cast array_to_ptrdecay %2 : !cir.ptr<!cir.array<!s8i x 1>> -> !cir.ptr<!s8i>
+    %4 = cir.offload.printf(%1, %v, %3) : (!cir.ptr<!s8i>, !s32i, !cir.ptr<!s8i>) -> !s32i
+    cir.return %4 : !s32i
+  }
+}
+
+// An empty constant %s argument takes the constant path: 8 aligned
+// bytes for the empty string, with no runtime length computation.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_empty_arg(i32 %0)
+// BUFFERED: call ptr addrspace(1) @__printf_alloc(i32 28)
+// BUFFERED-NOT: load i8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:d3e1b03bc04075f4,%d %s\0A"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<[#cir.int<37> : !s8i, #cir.int<100> : !s8i], trailing_zeros> : !cir.array<!s8i x 3>
+  cir.func @buffered_stale_attr(%v: !s32i) -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 3>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 3>> -> !cir.ptr<!s8i>
+    %2 = "cir.offload.printf"(%1, %v) {cir.printf.const_strings = ["WRONG", unit]} : (!cir.ptr<!s8i>, !s32i) -> !s32i
+    cir.return %2 : !s32i
+  }
+}
+
+// A bogus annotation carried in from the input is overwritten with
+// the resolved strings before lowering reads it.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_stale_attr(i32 %0)
+// BUFFERED: call ptr addrspace(1) @__printf_alloc(i32 20)
+// BUFFERED: store i64 -2582314622382785113, ptr addrspace(1) %{{.*}}, align 8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:dc29c6885a93bda7,%d"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<"0123456789ABCDEFGHIJKLMNOPQRSTUV" : !cir.array<!s8i x 32>, trailing_zeros> : !cir.array<!s8i x 33>
+  cir.func @buffered_narrowing_cast() -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 33>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 33>> -> !cir.ptr<!s8i>
+    %2 = cir.const #cir.int<261> : !s32i
+    %3 = cir.cast integral %2 : !s32i -> !s8i
+    %4 = cir.ptr_stride %1, %3 : (!cir.ptr<!s8i>, !s8i) -> !cir.ptr<!s8i>
+    %5 = cir.offload.printf(%4) : (!cir.ptr<!s8i>) -> !s32i
+    cir.return %5 : !s32i
+  }
+}
+
+// A narrowing cast is not folded: 261 would truncate to 5 in i8,
+// but the walk refuses narrowing casts, so the format length is
+// computed at runtime and only the dummy metadata entry is emitted.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_narrowing_cast()
+// BUFFERED: load i8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:ffffffff,\22Non const format string\22"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<"0123456789ABCDEFGHIJKLMNOPQRSTUV" : !cir.array<!s8i x 32>, trailing_zeros> : !cir.array<!s8i x 33>
+  cir.func @buffered_get_element_s32() -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 33>>
+    %1 = cir.cast bitcast %0 : !cir.ptr<!cir.array<!s8i x 33>> -> !cir.ptr<!cir.array<!s32i x 8>>
+    %idx = cir.const #cir.int<3> : !s32i
+    %2 = cir.get_element %1[%idx : !s32i] : !cir.ptr<!cir.array<!s32i x 8>> -> !cir.ptr<!s32i>
+    %3 = cir.cast bitcast %2 : !cir.ptr<!s32i> -> !cir.ptr<!s8i>
+    %4 = cir.offload.printf(%3) : (!cir.ptr<!s8i>) -> !s32i
+    cir.return %4 : !s32i
+  }
+}
+
+// A get_element index scales by the element size: 3 elements of
+// 4 bytes land at byte 12, the same offset as the equivalent stride.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_get_element_s32()
+// BUFFERED: call ptr addrspace(1) @__printf_alloc(i32 12)
+// BUFFERED: store i64 7009764703486015180, ptr addrspace(1) %{{.*}}, align 8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:6147afdbc65af6cc,CDEFGHIJKLMNOPQRSTUV"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "hostcall"} {
+  cir.global "private" constant cir_private @".fmt" = #cir.const_array<"%s\0A" : !cir.array<!s8i x 3>, trailing_zeros> : !cir.array<!s8i x 4>
+  cir.func @hostcall_constant_format(%str: !cir.ptr<!s8i>) -> !s32i {
+    %0 = cir.get_global @".fmt" : !cir.ptr<!cir.array<!s8i x 4>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 4>> -> !cir.ptr<!s8i>
+    %2 = cir.offload.printf(%1, %str) : (!cir.ptr<!s8i>, !cir.ptr<!s8i>) -> !s32i
+    cir.return %2 : !s32i
+  }
+}
+
+// The annotated format marks the argument as a string, so it is
+// appended with the string runtime call instead of as a scalar.
+// HOSTCALL-LABEL: define{{.*}} i32 @hostcall_constant_format(ptr %0)
+// HOSTCALL: [[DESC:%.*]] = call i64 @__ockl_printf_append_string_n(i64 {{.*}}, ptr @.fmt, i64 {{.*}}, i32 0)
+// HOSTCALL: call i64 @__ockl_printf_append_string_n(i64 [[DESC]], ptr %0, i64 {{.*}}, i32 1)
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<"0123456789ABCDEFGHIJKLMNOPQRSTUV" : !cir.array<!s8i x 32>, trailing_zeros> : !cir.array<!s8i x 33>
+  cir.func @buffered_past_end() -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 33>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 33>> -> !cir.ptr<!s8i>
+    %2 = cir.const #cir.int<40> : !s32i
+    %3 = cir.ptr_stride %1, %2 : (!cir.ptr<!s8i>, !s32i) -> !cir.ptr<!s8i>
+    %4 = cir.offload.printf(%3) : (!cir.ptr<!s8i>) -> !s32i
+    cir.return %4 : !s32i
+  }
+}
+
+// An offset past the end of the string is rejected, so the format
+// length is computed at runtime like the narrowing case.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_past_end()
+// BUFFERED: load i8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:ffffffff,\22Non const format string\22"}
+
+// -----
+
+!s32i = !cir.int<s, 32>
+!s8i = !cir.int<s, 8>
+
+module attributes {cir.amdgpu_printf_kind = "buffered"} {
+  cir.global "private" constant cir_private @".str" = #cir.const_array<"0123456789ABCDEFGHIJKLMNOPQRSTUV" : !cir.array<!s8i x 32>, trailing_zeros> : !cir.array<!s8i x 33>
+  cir.func @buffered_identity_cast() -> !s32i {
+    %0 = cir.get_global @".str" : !cir.ptr<!cir.array<!s8i x 33>>
+    %1 = cir.cast array_to_ptrdecay %0 : !cir.ptr<!cir.array<!s8i x 33>> -> !cir.ptr<!s8i>
+    %2 = cir.const #cir.int<7> : !s32i
+    %3 = cir.cast integral %2 : !s32i -> !s32i
+    %4 = cir.ptr_stride %1, %3 : (!cir.ptr<!s8i>, !s32i) -> !cir.ptr<!s8i>
+    %5 = cir.offload.printf(%4) : (!cir.ptr<!s8i>) -> !s32i
+    cir.return %5 : !s32i
+  }
+}
+
+// A same-type cast folds to its constant, landing at byte 7.
+// BUFFERED-LABEL: define{{.*}} i32 @buffered_identity_cast()
+// BUFFERED: call ptr addrspace(1) @__printf_alloc(i32 12)
+// BUFFERED: store i64 2513007642441926819, ptr addrspace(1) %{{.*}}, align 8
+// BUFFERED: !llvm.printf.fmts = !{[[FMT:![0-9]+]]}
+// BUFFERED: [[FMT]] = !{!"0:0:22dfff22e597c8a3,789ABCDEFGHIJKLMNOPQRSTUV"}



More information about the cfe-commits mailing list