[Mlir-commits] [flang] [mlir] [MLIR][LLVM] Enable strict property assembly format (PR #217277)
Mehdi Amini
llvmlistbot at llvm.org
Thu Aug 20 03:18:07 PDT 2026
https://github.com/joker-eph updated https://github.com/llvm/llvm-project/pull/217277
>From 52678b44b458e274fb5779f6e87382785dbf80ff Mon Sep 17 00:00:00 2001
From: Mehdi Amini <joker.eph at gmail.com>
Date: Wed, 6 May 2026 15:36:00 -0700
Subject: [PATCH] [MLIR][LLVM] Enable strict property assembly format
Enable strict property assembly format mode for the LLVM dialect. Bind LLVM
operation properties directly in declarative assembly formats so strict
parsing does not rely on fallback handling.
Update LLVM dialect, target, and conversion tests to use the direct property
spelling.
Assisted-by: Codex
---
flang/test/Driver/tco-test-gen.fir | 18 +-
.../test/Fir/convert-nontemporal-to-llvm.fir | 8 +-
.../test/Fir/convert-to-llvm-access-group.fir | 14 +-
flang/test/Fir/convert-to-llvm.fir | 42 ++--
flang/test/Fir/tbaa.fir | 68 +++---
flang/test/Fir/vector-always-cfg.fir | 3 +-
.../mlir/Dialect/LLVMIR/LLVMDialect.td | 1 +
.../mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td | 94 +++++----
mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td | 53 ++++-
.../ControlFlowToLLVM/ControlFlowToLLVM.cpp | 10 +-
.../Conversion/ArithToLLVM/arith-to-llvm.mlir | 24 +--
.../ComplexToLLVM/complex-range-option.mlir | 104 +++++-----
.../ComplexToLLVM/convert-to-llvm.mlir | 46 ++---
.../GPUCommon/lower-memory-space-attrs.mlir | 2 +-
.../Conversion/GPUCommon/transfer_write.mlir | 2 +-
.../Conversion/MathToLLVM/math-to-llvm.mlir | 42 ++--
.../MemRefToLLVM/memref-to-llvm.mlir | 8 +-
.../SPIRVToLLVM/memory-ops-to-llvm.mlir | 8 +-
.../VectorToLLVM/use-vector-alignment.mlir | 48 ++---
.../vector-load-store-to-llvm.mlir | 32 +--
.../vector-reduction-to-llvm.mlir | 25 ++-
.../vector-to-llvm-interface.mlir | 73 +++----
.../VectorToLLVM/vector-to-llvm.mlir | 8 +-
.../VectorToLLVM/vector-xfer-to-llvm.mlir | 20 +-
mlir/test/Dialect/LLVMIR/bytecode.mlir | 2 +-
mlir/test/Dialect/LLVMIR/canonicalize.mlir | 4 +-
.../LLVMIR/dereferenceable-invalid.mlir | 2 +-
mlir/test/Dialect/LLVMIR/ifunc.mlir | 8 +-
.../Dialect/LLVMIR/inlining-alias-scopes.mlir | 34 +--
.../LLVMIR/inlining-loop-annotation.mlir | 4 +-
mlir/test/Dialect/LLVMIR/inlining.mlir | 8 +-
mlir/test/Dialect/LLVMIR/invalid.mlir | 41 ++--
mlir/test/Dialect/LLVMIR/loop-metadata.mlir | 4 +-
mlir/test/Dialect/LLVMIR/mem2reg-dbginfo.mlir | 20 +-
.../Dialect/LLVMIR/mem2reg-intrinsics.mlir | 30 +--
mlir/test/Dialect/LLVMIR/mem2reg.mlir | 194 +++++++++---------
mlir/test/Dialect/LLVMIR/opaque-ptr.mlir | 8 +-
mlir/test/Dialect/LLVMIR/roundtrip.mlir | 100 ++++-----
mlir/test/Dialect/LLVMIR/tbaa-roundtrip.mlir | 24 +--
...tract-to-matrix-intrinsics-transforms.mlir | 2 +-
...nspose-to-matrix-intrinsics-transform.mlir | 2 +-
.../Vector/CPU/flat-transpose-col.mlir | 8 +-
.../Vector/CPU/flat-transpose-row.mlir | 8 +-
.../Vector/CPU/matrix-multiply-col.mlir | 3 +-
.../Vector/CPU/matrix-multiply-row.mlir | 3 +-
mlir/test/Target/LLVMIR/Import/fastmath.ll | 28 +--
mlir/test/Target/LLVMIR/Import/ifunc.ll | 4 +-
.../test/Target/LLVMIR/Import/instructions.ll | 26 +--
mlir/test/Target/LLVMIR/Import/intrinsic.ll | 82 ++++----
.../Target/LLVMIR/Import/metadata-loop.ll | 28 +--
.../LLVMIR/Import/metadata-profiling.ll | 4 +-
.../Target/LLVMIR/Import/metadata-tbaa.ll | 17 +-
.../Target/LLVMIR/Import/target-ext-type.ll | 2 +-
.../LLVMIR/allocatable_gpu_reduction.mlir | 2 +-
.../allocatable_gpu_reduction_teams.mlir | 2 +-
mlir/test/Target/LLVMIR/anonymous-tbaa.mlir | 2 +-
.../Target/LLVMIR/attribute-alias-scopes.mlir | 16 +-
.../LLVMIR/attribute-dereferenceable.mlir | 12 +-
mlir/test/Target/LLVMIR/attribute-tbaa.mlir | 12 +-
mlir/test/Target/LLVMIR/ifunc.mlir | 6 +-
.../test/Target/LLVMIR/llvmir-intrinsics.mlir | 74 +++----
mlir/test/Target/LLVMIR/llvmir-invalid.mlir | 20 +-
mlir/test/Target/LLVMIR/llvmir.mlir | 40 ++--
mlir/test/Target/LLVMIR/loop-metadata.mlir | 54 ++---
.../LLVMIR/omptarget-debug-record-pos.mlir | 2 +-
.../LLVMIR/omptarget-multi-reduction.mlir | 12 +-
mlir/test/Target/LLVMIR/omptarget-nowait.mlir | 2 +-
mlir/test/Target/LLVMIR/opaque-ptr.mlir | 8 +-
mlir/test/Target/LLVMIR/openmp-llvm.mlir | 8 +-
.../Target/LLVMIR/openmp-nontemporal.mlir | 10 +-
.../LLVMIR/openmp-reduction-sections.mlir | 6 +-
.../Target/LLVMIR/openmp-simd-private.mlir | 4 +-
.../LLVMIR/openmp-simd-reduction-simple.mlir | 4 +-
.../Target/LLVMIR/openmp-target-private.mlir | 4 +-
.../Target/LLVMIR/openmp-wsloop-private.mlir | 2 +-
mlir/test/Target/LLVMIR/target-ext-type.mlir | 2 +-
76 files changed, 903 insertions(+), 854 deletions(-)
diff --git a/flang/test/Driver/tco-test-gen.fir b/flang/test/Driver/tco-test-gen.fir
index 438804ce42b76..b8fd5aa65680d 100644
--- a/flang/test/Driver/tco-test-gen.fir
+++ b/flang/test/Driver/tco-test-gen.fir
@@ -53,17 +53,17 @@ func.func @_QPtest(%arg0: !fir.ref<i32> {fir.bindc_name = "num"}, %arg1: !fir.re
// SIMPLE: %[[VAL_0:.*]] = llvm.mlir.constant(1 : i64) : i64
// SIMPLE: %[[VAL_1:.*]] = llvm.alloca %[[VAL_0]] x i32 {bindc_name = "i"} : (i64) -> !llvm.ptr
-// AA: %[[VAL_5:.*]] = llvm.load %[[ARG1]] {tbaa = [#llvm.tbaa_tag<base_type = <id = "dummy arg data/_QFtestElb", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "dummy arg data/_QFtestElb", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> i32
+// AA: %[[VAL_5:.*]] = llvm.load %[[ARG1]] tbaa = [#llvm.tbaa_tag<base_type = <id = "dummy arg data/_QFtestElb", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "dummy arg data/_QFtestElb", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>] : !llvm.ptr -> i32
// NOAA: %[[VAL_5:.*]] = llvm.load %[[ARG1]] : !llvm.ptr -> i32
// CHECK: %[[VAL_6:.*]] = llvm.sext %[[VAL_5]] : i32 to i64
-// AA: %[[VAL_7:.*]] = llvm.load %[[ARG2]] {tbaa = [#llvm.tbaa_tag<base_type = <id = "dummy arg data/_QFtestEub", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "dummy arg data/_QFtestEub", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> i32
+// AA: %[[VAL_7:.*]] = llvm.load %[[ARG2]] tbaa = [#llvm.tbaa_tag<base_type = <id = "dummy arg data/_QFtestEub", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "dummy arg data/_QFtestEub", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>] : !llvm.ptr -> i32
// NOAA: %[[VAL_7:.*]] = llvm.load %[[ARG2]] : !llvm.ptr -> i32
// CHECK: %[[VAL_8:.*]] = llvm.sext %[[VAL_7]] : i32 to i64
-// AA: %[[VAL_9:.*]] = llvm.load %[[ARG3]] {tbaa = [#llvm.tbaa_tag<base_type = <id = "dummy arg data/_QFtestEstep", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "dummy arg data/_QFtestEstep", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> i32
+// AA: %[[VAL_9:.*]] = llvm.load %[[ARG3]] tbaa = [#llvm.tbaa_tag<base_type = <id = "dummy arg data/_QFtestEstep", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "dummy arg data/_QFtestEstep", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>] : !llvm.ptr -> i32
// NOAA: %[[VAL_9:.*]] = llvm.load %[[ARG3]] : !llvm.ptr -> i32
// CHECK: %[[VAL_10:.*]] = llvm.sext %[[VAL_9]] : i32 to i64
@@ -77,22 +77,22 @@ func.func @_QPtest(%arg0: !fir.ref<i32> {fir.bindc_name = "num"}, %arg1: !fir.re
// CHECK: llvm.cond_br %[[VAL_17]], ^bb2, ^bb3
// CHECK: ^bb2:
-// AA: llvm.store %[[VAL_15]], %[[VAL_1]] {tbaa = [#llvm.tbaa_tag<base_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>]} : i32, !llvm.ptr
+// AA: llvm.store %[[VAL_15]], %[[VAL_1]] tbaa = [#llvm.tbaa_tag<base_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>] : i32, !llvm.ptr
// NOAA: llvm.store %[[VAL_15]], %{{.*}} : i32, !llvm.ptr
-// AA: %[[VAL_18:.*]] = llvm.load %[[ARG0]] {tbaa = [#llvm.tbaa_tag<base_type = <id = "dummy arg data/_QFtestEnum", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "dummy arg data/_QFtestEnum", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> i32
+// AA: %[[VAL_18:.*]] = llvm.load %[[ARG0]] tbaa = [#llvm.tbaa_tag<base_type = <id = "dummy arg data/_QFtestEnum", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "dummy arg data/_QFtestEnum", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>] : !llvm.ptr -> i32
// NOAA: %[[VAL_18:.*]] = llvm.load %[[ARG0]] : !llvm.ptr -> i32
-// AA: %[[VAL_19:.*]] = llvm.load %[[VAL_1]] {tbaa = [#llvm.tbaa_tag<base_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> i32
+// AA: %[[VAL_19:.*]] = llvm.load %[[VAL_1]] tbaa = [#llvm.tbaa_tag<base_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>] : !llvm.ptr -> i32
// NOAA: %[[VAL_19:.*]] = llvm.load %{{.*}} : !llvm.ptr -> i32
// CHECK: %[[VAL_20:.*]] = llvm.add %[[VAL_18]], %[[VAL_19]] : i32
-// AA: llvm.store %[[VAL_20]], %[[ARG0]] {tbaa = [#llvm.tbaa_tag<base_type = <id = "dummy arg data/_QFtestEnum", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "dummy arg data/_QFtestEnum", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>]} : i32, !llvm.ptr
+// AA: llvm.store %[[VAL_20]], %[[ARG0]] tbaa = [#llvm.tbaa_tag<base_type = <id = "dummy arg data/_QFtestEnum", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "dummy arg data/_QFtestEnum", members = {<#llvm.tbaa_type_desc<id = "dummy arg data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>] : i32, !llvm.ptr
// NOAA: llvm.store %[[VAL_20]], %[[ARG0]] : i32, !llvm.ptr
// CHECK: %[[VAL_21:.*]] = llvm.trunc %[[VAL_10]] : i64 to i32
-// AA: %[[VAL_22:.*]] = llvm.load %[[VAL_1]] {tbaa = [#llvm.tbaa_tag<base_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>]} : !llvm.ptr -> i32
+// AA: %[[VAL_22:.*]] = llvm.load %[[VAL_1]] tbaa = [#llvm.tbaa_tag<base_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>] : !llvm.ptr -> i32
// NOAA: %[[VAL_22:.*]] = llvm.load %{{.*}} : !llvm.ptr -> i32
// CHECK: %[[VAL_23:.*]] = llvm.add %[[VAL_22]], %[[VAL_21]] overflow<nsw> : i32
@@ -100,7 +100,7 @@ func.func @_QPtest(%arg0: !fir.ref<i32> {fir.bindc_name = "num"}, %arg1: !fir.re
// CHECK: llvm.br ^bb1(%[[VAL_23]], %[[VAL_24]] : i32, i64)
// CHECK: ^bb3:
-// AA: llvm.store %[[VAL_15]], %[[VAL_1]] {tbaa = [#llvm.tbaa_tag<base_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>]} : i32, !llvm.ptr
+// AA: llvm.store %[[VAL_15]], %[[VAL_1]] tbaa = [#llvm.tbaa_tag<base_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, access_type = <id = "allocated data/_QFtestEi", members = {<#llvm.tbaa_type_desc<id = "allocated data", members = {<#llvm.tbaa_type_desc<id = "any data access", members = {<#llvm.tbaa_type_desc<id = "any access", members = {<#llvm.tbaa_root<id = "Flang function root _QPtest">, 0>}>, 0>}>, 0>}>, 0>}>, offset = 0>] : i32, !llvm.ptr
// NOAA: llvm.store %[[VAL_15]], %{{.*}} : i32, !llvm.ptr
// CHECK: llvm.return
diff --git a/flang/test/Fir/convert-nontemporal-to-llvm.fir b/flang/test/Fir/convert-nontemporal-to-llvm.fir
index 584f1055b9e4f..b87a41eb34073 100644
--- a/flang/test/Fir/convert-nontemporal-to-llvm.fir
+++ b/flang/test/Fir/convert-nontemporal-to-llvm.fir
@@ -17,10 +17,10 @@
// CHECK: omp.simd nontemporal(%[[VAL5]], %[[VAL3]] : !llvm.ptr, !llvm.ptr) {
// CHECK: omp.loop_nest (%{{.*}}) : i32 = (%[[CONST_VAL5]]) to (%[[VAL6]]) inclusive step (%[[CONST_VAL5]]) {
// CHECK: llvm.store %{{.*}}, %{{.*}} : i32, !llvm.ptr
-// CHECK: %[[VAL8:.*]] = llvm.load %[[VAL5]] {nontemporal} : !llvm.ptr -> i32
+// CHECK: %[[VAL8:.*]] = llvm.load %[[VAL5]] nontemporal : !llvm.ptr -> i32
// CHECK: %[[VAL9:.*]] = llvm.load %[[VAL4]] : !llvm.ptr -> i32
// CHECK: %[[VAL10:.*]] = llvm.add %[[VAL8]], %[[VAL9]] : i32
-// CHECK: llvm.store %[[VAL10]], %[[VAL3]] {nontemporal} : i32, !llvm.ptr
+// CHECK: llvm.store %[[VAL10]], %[[VAL3]] nontemporal : i32, !llvm.ptr
// CHECK: omp.yield
// CHECK: }
// CHECK: }
@@ -73,10 +73,10 @@
// CHECK: %[[VAL15:.*]] = llvm.add %[[VAL14]], %[[VAL11]] overflow<nsw, nuw> : i64
// CHECK: %[[VAL16:.*]] = llvm.mul %[[VAL10]], %[[VAL8]] overflow<nsw, nuw> : i64
// CHECK: %[[VAL17:.*]] = llvm.getelementptr nusw|nuw %[[VAL4]][%[[VAL15]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32
-// CHECK: %[[VAL18:.*]] = llvm.load %[[VAL17]] {nontemporal} : !llvm.ptr -> i32
+// CHECK: %[[VAL18:.*]] = llvm.load %[[VAL17]] nontemporal : !llvm.ptr -> i32
// CHECK: %[[VAL19:.*]] = llvm.load %{{.*}} : !llvm.ptr -> i32
// CHECK: %[[VAL20:.*]] = llvm.add %[[VAL18]], %[[VAL19]] : i32
-// CHECK: llvm.store %[[VAL20]], %[[VAL17]] {nontemporal} : i32, !llvm.ptr
+// CHECK: llvm.store %[[VAL20]], %[[VAL17]] nontemporal : i32, !llvm.ptr
// CHECK: omp.yield
// CHECK: }
// CHECK: }
diff --git a/flang/test/Fir/convert-to-llvm-access-group.fir b/flang/test/Fir/convert-to-llvm-access-group.fir
index f9807c8b8ed09..49f4c9392246d 100644
--- a/flang/test/Fir/convert-to-llvm-access-group.fir
+++ b/flang/test/Fir/convert-to-llvm-access-group.fir
@@ -22,14 +22,14 @@
// CHECK: %[[ICMP_0:.*]] = llvm.icmp "sgt" %[[VAL_1]], %[[MLIR_2]] : i64
// CHECK: llvm.cond_br %[[ICMP_0]], ^bb2, ^bb3
// CHECK: ^bb2:
-// CHECK: llvm.store %[[VAL_0]], %[[ALLOCA_1]] {access_groups = [#[[$ATTR_0]]]} : i32, !llvm.ptr
-// CHECK: %[[LOAD_1:.*]] = llvm.load %[[ALLOCA_1]] {accessGroups = [#[[$ATTR_0]]], access_groups = [#[[$ATTR_0]]]} : !llvm.ptr -> i32
-// CHECK: %[[LOAD_2:.*]] = llvm.load %[[ARG1]] {accessGroups = [#[[$ATTR_0]]], access_groups = [#[[$ATTR_0]]]} : !llvm.ptr -> i32
+// CHECK: llvm.store %[[VAL_0]], %[[ALLOCA_1]] access_groups = [#[[$ATTR_0]]] : i32, !llvm.ptr
+// CHECK: %[[LOAD_1:.*]] = llvm.load %[[ALLOCA_1]] access_groups = [#[[$ATTR_0]]] {accessGroups = [#[[$ATTR_0]]]} : !llvm.ptr -> i32
+// CHECK: %[[LOAD_2:.*]] = llvm.load %[[ARG1]] access_groups = [#[[$ATTR_0]]] {accessGroups = [#[[$ATTR_0]]]} : !llvm.ptr -> i32
// CHECK: %[[ADD_0:.*]] = llvm.add %[[LOAD_1]], %[[LOAD_2]] : i32
// CHECK: %[[SITOFP_0:.*]] = llvm.sitofp %[[ADD_0]] : i32 to f32
// CHECK: %[[MLIR_5:.*]] = llvm.mlir.constant(72 : i32) : i32
// CHECK: "llvm.intr.memcpy"(%[[ALLOCA_0]], %[[ARG3]], %[[MLIR_5]]) <{access_groups = [#[[$ATTR_0]]], arg_attrs = [{llvm.align = 8 : i64}, {llvm.align = 8 : i64}, {}], isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()
-// CHECK: %[[LOAD_3:.*]] = llvm.load %[[ARG0]] {accessGroups = [#[[$ATTR_0]]], access_groups = [#[[$ATTR_0]]]} : !llvm.ptr -> i32
+// CHECK: %[[LOAD_3:.*]] = llvm.load %[[ARG0]] access_groups = [#[[$ATTR_0]]] {accessGroups = [#[[$ATTR_0]]]} : !llvm.ptr -> i32
// CHECK: %[[SEXT_1:.*]] = llvm.sext %[[LOAD_3]] : i32 to i64
// CHECK: %[[SEXT_2:.*]] = llvm.sext %[[LOAD_1]] : i32 to i64
// CHECK: %[[GETELEMENTPTR_0:.*]] = llvm.getelementptr %[[ALLOCA_0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<2 x array<3 x i64>>)>
@@ -59,11 +59,11 @@
// CHECK: %[[ADD_2:.*]] = llvm.add %[[MUL_4]], %[[ADD_1]] overflow<nsw, nuw> : i64
// CHECK: %[[MUL_5:.*]] = llvm.mul %[[MUL_2]], %[[LOAD_9]] overflow<nsw, nuw> : i64
// CHECK: %[[GETELEMENTPTR_7:.*]] = llvm.getelementptr nusw|nuw %[[LOAD_4]]{{\[}}%[[ADD_2]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// CHECK: llvm.store %[[SITOFP_0]], %[[GETELEMENTPTR_7]] {access_groups = [#[[$ATTR_0]]]} : f32, !llvm.ptr
-// CHECK: %[[LOAD_11:.*]] = llvm.load %[[ALLOCA_1]] {accessGroups = [#[[$ATTR_0]]], access_groups = [#[[$ATTR_0]]]} : !llvm.ptr -> i32
+// CHECK: llvm.store %[[SITOFP_0]], %[[GETELEMENTPTR_7]] access_groups = [#[[$ATTR_0]]] : f32, !llvm.ptr
+// CHECK: %[[LOAD_11:.*]] = llvm.load %[[ALLOCA_1]] access_groups = [#[[$ATTR_0]]] {accessGroups = [#[[$ATTR_0]]]} : !llvm.ptr -> i32
// CHECK: %[[ADD_3:.*]] = llvm.add %[[LOAD_11]], %[[TRUNC_0]] overflow<nsw> : i32
// CHECK: %[[SUB_2:.*]] = llvm.sub %[[VAL_1]], %[[MLIR_3]] : i64
-// CHECK: llvm.br ^bb1(%[[ADD_3]], %[[SUB_2]] : i32, i64) {loop_annotation = #[[$ATTR_1]]}
+// CHECK: llvm.br ^bb1(%[[ADD_3]], %[[SUB_2]] : i32, i64) loop_annotation = #[[$ATTR_1]]
// CHECK: ^bb3:
// CHECK: llvm.store %[[VAL_0]], %[[ALLOCA_1]] : i32, !llvm.ptr
// CHECK: llvm.return
diff --git a/flang/test/Fir/convert-to-llvm.fir b/flang/test/Fir/convert-to-llvm.fir
index fe803ea2e65af..ef304a62a65ed 100644
--- a/flang/test/Fir/convert-to-llvm.fir
+++ b/flang/test/Fir/convert-to-llvm.fir
@@ -460,8 +460,8 @@ func.func @fir_complex_add(%a: complex<f128>, %b: complex<f128>) -> complex<f128
// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)>
// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.struct<(f128, f128)>
// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1] : !llvm.struct<(f128, f128)>
-// CHECK: %[[ADD_X0_X1:.*]] = llvm.fadd %[[X0]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[ADD_Y0_Y1:.*]] = llvm.fadd %[[Y0]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
+// CHECK: %[[ADD_X0_X1:.*]] = llvm.fadd %[[X0]], %[[X1]] fastmath<fast> : f128
+// CHECK: %[[ADD_Y0_Y1:.*]] = llvm.fadd %[[Y0]], %[[Y1]] fastmath<fast> : f128
// CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)>
// CHECK: %{{.*}} = llvm.insertvalue %[[ADD_X0_X1]], %{{.*}}[0] : !llvm.struct<(f128, f128)>
// CHECK: %{{.*}} = llvm.insertvalue %[[ADD_Y0_Y1]], %{{.*}}[1] : !llvm.struct<(f128, f128)>
@@ -485,8 +485,8 @@ func.func @fir_complex_sub(%a: complex<f128>, %b: complex<f128>) -> complex<f128
// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)>
// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.struct<(f128, f128)>
// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1] : !llvm.struct<(f128, f128)>
-// CHECK: %[[SUB_X0_X1:.*]] = llvm.fsub %[[X0]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[SUB_Y0_Y1:.*]] = llvm.fsub %[[Y0]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
+// CHECK: %[[SUB_X0_X1:.*]] = llvm.fsub %[[X0]], %[[X1]] fastmath<fast> : f128
+// CHECK: %[[SUB_Y0_Y1:.*]] = llvm.fsub %[[Y0]], %[[Y1]] fastmath<fast> : f128
// CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)>
// CHECK: %{{.*}} = llvm.insertvalue %[[SUB_X0_X1]], %{{.*}}[0] : !llvm.struct<(f128, f128)>
// CHECK: %{{.*}} = llvm.insertvalue %[[SUB_Y0_Y1]], %{{.*}}[1] : !llvm.struct<(f128, f128)>
@@ -510,12 +510,12 @@ func.func @fir_complex_mul(%a: complex<f128>, %b: complex<f128>) -> complex<f128
// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)>
// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.struct<(f128, f128)>
// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1] : !llvm.struct<(f128, f128)>
-// CHECK: %[[MUL_X0_X1:.*]] = llvm.fmul %[[X0]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[MUL_Y0_X1:.*]] = llvm.fmul %[[Y0]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[MUL_X0_Y1:.*]] = llvm.fmul %[[X0]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[ADD:.*]] = llvm.fadd %[[MUL_X0_Y1]], %[[MUL_Y0_X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[MUL_Y0_Y1:.*]] = llvm.fmul %[[Y0]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[SUB:.*]] = llvm.fsub %[[MUL_X0_X1]], %[[MUL_Y0_Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
+// CHECK: %[[MUL_X0_X1:.*]] = llvm.fmul %[[X0]], %[[X1]] fastmath<fast> : f128
+// CHECK: %[[MUL_Y0_X1:.*]] = llvm.fmul %[[Y0]], %[[X1]] fastmath<fast> : f128
+// CHECK: %[[MUL_X0_Y1:.*]] = llvm.fmul %[[X0]], %[[Y1]] fastmath<fast> : f128
+// CHECK: %[[ADD:.*]] = llvm.fadd %[[MUL_X0_Y1]], %[[MUL_Y0_X1]] fastmath<fast> : f128
+// CHECK: %[[MUL_Y0_Y1:.*]] = llvm.fmul %[[Y0]], %[[Y1]] fastmath<fast> : f128
+// CHECK: %[[SUB:.*]] = llvm.fsub %[[MUL_X0_X1]], %[[MUL_Y0_Y1]] fastmath<fast> : f128
// CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)>
// CHECK: %{{.*}} = llvm.insertvalue %[[SUB]], %{{.*}}[0] : !llvm.struct<(f128, f128)>
// CHECK: %{{.*}} = llvm.insertvalue %[[ADD]], %{{.*}}[1] : !llvm.struct<(f128, f128)>
@@ -539,17 +539,17 @@ func.func @fir_complex_div(%a: complex<f128>, %b: complex<f128>) -> complex<f128
// CHECK: %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1] : !llvm.struct<(f128, f128)>
// CHECK: %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0] : !llvm.struct<(f128, f128)>
// CHECK: %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1] : !llvm.struct<(f128, f128)>
-// CHECK: %[[MUL_X0_X1:.*]] = llvm.fmul %[[X0]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[MUL_X1_X1:.*]] = llvm.fmul %[[X1]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[MUL_Y0_X1:.*]] = llvm.fmul %[[Y0]], %[[X1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[MUL_X0_Y1:.*]] = llvm.fmul %[[X0]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[MUL_Y0_Y1:.*]] = llvm.fmul %[[Y0]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[MUL_Y1_Y1:.*]] = llvm.fmul %[[Y1]], %[[Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[ADD_X1X1_Y1Y1:.*]] = llvm.fadd %[[MUL_X1_X1]], %[[MUL_Y1_Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[ADD_X0X1_Y0Y1:.*]] = llvm.fadd %[[MUL_X0_X1]], %[[MUL_Y0_Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[SUB_Y0X1_X0Y1:.*]] = llvm.fsub %[[MUL_Y0_X1]], %[[MUL_X0_Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[DIV0:.*]] = llvm.fdiv %[[ADD_X0X1_Y0Y1]], %[[ADD_X1X1_Y1Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
-// CHECK: %[[DIV1:.*]] = llvm.fdiv %[[SUB_Y0X1_X0Y1]], %[[ADD_X1X1_Y1Y1]] {fastmathFlags = #llvm.fastmath<fast>} : f128
+// CHECK: %[[MUL_X0_X1:.*]] = llvm.fmul %[[X0]], %[[X1]] fastmath<fast> : f128
+// CHECK: %[[MUL_X1_X1:.*]] = llvm.fmul %[[X1]], %[[X1]] fastmath<fast> : f128
+// CHECK: %[[MUL_Y0_X1:.*]] = llvm.fmul %[[Y0]], %[[X1]] fastmath<fast> : f128
+// CHECK: %[[MUL_X0_Y1:.*]] = llvm.fmul %[[X0]], %[[Y1]] fastmath<fast> : f128
+// CHECK: %[[MUL_Y0_Y1:.*]] = llvm.fmul %[[Y0]], %[[Y1]] fastmath<fast> : f128
+// CHECK: %[[MUL_Y1_Y1:.*]] = llvm.fmul %[[Y1]], %[[Y1]] fastmath<fast> : f128
+// CHECK: %[[ADD_X1X1_Y1Y1:.*]] = llvm.fadd %[[MUL_X1_X1]], %[[MUL_Y1_Y1]] fastmath<fast> : f128
+// CHECK: %[[ADD_X0X1_Y0Y1:.*]] = llvm.fadd %[[MUL_X0_X1]], %[[MUL_Y0_Y1]] fastmath<fast> : f128
+// CHECK: %[[SUB_Y0X1_X0Y1:.*]] = llvm.fsub %[[MUL_Y0_X1]], %[[MUL_X0_Y1]] fastmath<fast> : f128
+// CHECK: %[[DIV0:.*]] = llvm.fdiv %[[ADD_X0X1_Y0Y1]], %[[ADD_X1X1_Y1Y1]] fastmath<fast> : f128
+// CHECK: %[[DIV1:.*]] = llvm.fdiv %[[SUB_Y0X1_X0Y1]], %[[ADD_X1X1_Y1Y1]] fastmath<fast> : f128
// CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)>
// CHECK: %{{.*}} = llvm.insertvalue %[[DIV0]], %{{.*}}[0] : !llvm.struct<(f128, f128)>
// CHECK: %{{.*}} = llvm.insertvalue %[[DIV1]], %{{.*}}[1] : !llvm.struct<(f128, f128)>
diff --git a/flang/test/Fir/tbaa.fir b/flang/test/Fir/tbaa.fir
index 073eb65c7f449..d96ff8c4b531c 100644
--- a/flang/test/Fir/tbaa.fir
+++ b/flang/test/Fir/tbaa.fir
@@ -37,24 +37,24 @@ module {
// CHECK: %[[VAL_4:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[VAL_5:.*]] = llvm.mlir.constant(10 : i32) : i32
// CHECK: %[[VAL_6:.*]] = llvm.getelementptr %[[VAL_0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> !llvm.ptr
+// CHECK: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> !llvm.ptr
// CHECK: %[[VAL_8:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[VAL_9:.*]] = llvm.getelementptr %[[VAL_0]][0, 7, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i64
+// CHECK: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i64
// CHECK: %[[VAL_11:.*]] = llvm.mul %[[VAL_4]], %[[VAL_10]] overflow<nsw> : i64
// CHECK: %[[VAL_12:.*]] = llvm.add %[[VAL_11]], %[[VAL_8]] overflow<nsw> : i64
// CHECK: %[[VAL_14:.*]] = llvm.getelementptr %[[VAL_7]]{{\[}}%[[VAL_12]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8
// CHECK: %[[VAL_16:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[VAL_17:.*]] = llvm.mlir.constant(-1 : i32) : i32
// CHECK: %[[VAL_18:.*]] = llvm.getelementptr %[[VAL_0]][0, 8] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_19:.*]] = llvm.load %[[VAL_18]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> !llvm.ptr
+// CHECK: %[[VAL_19:.*]] = llvm.load %[[VAL_18]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> !llvm.ptr
// CHECK: %[[VAL_20:.*]] = llvm.getelementptr %[[VAL_0]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_21:.*]] = llvm.load %[[VAL_20]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i64
+// CHECK: %[[VAL_21:.*]] = llvm.load %[[VAL_20]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i64
// CHECK: %[[VAL_22:.*]] = llvm.getelementptr %[[VAL_0]][0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_23:.*]] = llvm.load %[[VAL_22]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i8
+// CHECK: %[[VAL_23:.*]] = llvm.load %[[VAL_22]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i8
// CHECK-NEXT: %[[VAL_23_EXT:.*]] = llvm.sext %[[VAL_23]] : i8 to i32
// CHECK: %[[EXTRA_GEP:.*]] = llvm.getelementptr %[[VAL_0]][0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[EXTRA:.*]] = llvm.load %[[EXTRA_GEP]] {tbaa = [#tbaa_tag]} : !llvm.ptr -> i8
+// CHECK: %[[EXTRA:.*]] = llvm.load %[[EXTRA_GEP]] tbaa = [#tbaa_tag] : !llvm.ptr -> i8
// CHECK: %[[VAL_24:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, ptr, array<1 x i64>)>
// CHECK: %[[VAL_25:.*]] = llvm.insertvalue %[[VAL_21]], %[[VAL_24]][1] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, ptr, array<1 x i64>)>
// CHECK: %[[VAL_26:.*]] = llvm.mlir.constant(20240719 : i32) : i32
@@ -73,15 +73,15 @@ module {
// CHECK: %[[VAL_40B:.*]] = llvm.insertvalue %[[VAL_19]], %[[VAL_38]][7] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, ptr, array<1 x i64>)>
// CHECK: %[[VAL_40:.*]] = llvm.insertvalue %{{.*}}, %[[VAL_40B]][8, 0] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, ptr, array<1 x i64>)>
// CHECK: %[[VAL_42:.*]] = llvm.insertvalue %[[VAL_14]], %[[VAL_40]][0] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, ptr, array<1 x i64>)>
-// CHECK: llvm.store %[[VAL_42]], %[[VAL_2]] {tbaa = [#[[$BOXT]]]} : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, ptr, array<1 x i64>)>, !llvm.ptr
+// CHECK: llvm.store %[[VAL_42]], %[[VAL_2]] tbaa = [#[[$BOXT]]] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, ptr, array<1 x i64>)>, !llvm.ptr
// CHECK: %[[VAL_43:.*]] = llvm.getelementptr %[[VAL_2]][0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_44:.*]] = llvm.load %[[VAL_43]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i8
+// CHECK: %[[VAL_44:.*]] = llvm.load %[[VAL_43]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i8
// CHECK: %[[VAL_45:.*]] = llvm.icmp "eq" %[[VAL_44]], %[[VAL_3]] : i8
// CHECK: llvm.cond_br %[[VAL_45]], ^bb1, ^bb2
// CHECK: ^bb1:
// CHECK: %[[VAL_46:.*]] = llvm.getelementptr %[[VAL_2]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_47:.*]] = llvm.load %[[VAL_46]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> !llvm.ptr
-// CHECK: llvm.store %[[VAL_5]], %[[VAL_47]] {tbaa = [#[[$DATAT]]]} : i32, !llvm.ptr
+// CHECK: %[[VAL_47:.*]] = llvm.load %[[VAL_46]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> !llvm.ptr
+// CHECK: llvm.store %[[VAL_5]], %[[VAL_47]] tbaa = [#[[$DATAT]]] : i32, !llvm.ptr
// CHECK: llvm.br ^bb2
// CHECK: ^bb2:
// CHECK: llvm.return
@@ -140,22 +140,22 @@ module {
// CHECK: %[[VAL_11:.*]] = llvm.mlir.constant(64 : i32) : i32
// CHECK: "llvm.intr.memcpy"(%[[VAL_3]], %[[VAL_7]], %[[VAL_11]]) <{{.*}} isVolatile = false, tbaa = [#[[$BOXT]]]{{.*}}>
// CHECK: %[[VAL_12:.*]] = llvm.getelementptr %[[VAL_3]][0, 7, %[[VAL_4]], 0] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_13:.*]] = llvm.load %[[VAL_12]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i64
+// CHECK: %[[VAL_13:.*]] = llvm.load %[[VAL_12]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i64
// CHECK: %[[VAL_14:.*]] = llvm.getelementptr %[[VAL_3]][0, 7, %[[VAL_4]], 1] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_15:.*]] = llvm.load %[[VAL_14]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i64
+// CHECK: %[[VAL_15:.*]] = llvm.load %[[VAL_14]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i64
// CHECK: %[[VAL_16:.*]] = llvm.getelementptr %[[VAL_3]][0, 7, %[[VAL_4]], 2] : (!llvm.ptr, i64) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_17:.*]] = llvm.load %[[VAL_16]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i64
+// CHECK: %[[VAL_17:.*]] = llvm.load %[[VAL_16]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i64
// CHECK: %[[VAL_18:.*]] = llvm.getelementptr %[[VAL_3]][0, 8] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_19:.*]] = llvm.load %[[VAL_18]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> !llvm.ptr
+// CHECK: %[[VAL_19:.*]] = llvm.load %[[VAL_18]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> !llvm.ptr
// CHECK: %[[VAL_20:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[VAL_21:.*]] = llvm.mlir.constant(-1 : i32) : i32
// CHECK: %[[VAL_22:.*]] = llvm.getelementptr %[[VAL_3]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_23:.*]] = llvm.load %[[VAL_22]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i64
+// CHECK: %[[VAL_23:.*]] = llvm.load %[[VAL_22]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i64
// CHECK: %[[VAL_24:.*]] = llvm.getelementptr %[[VAL_3]][0, 4] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_25:.*]] = llvm.load %[[VAL_24]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i8
+// CHECK: %[[VAL_25:.*]] = llvm.load %[[VAL_24]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i8
// CHECK-NEXT: %[[VAL_25_EXT:.*]] = llvm.sext %[[VAL_25]] : i8 to i32
// CHECK: %[[VAL_26:.*]] = llvm.getelementptr %[[VAL_3]][0, 8] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_27:.*]] = llvm.load %[[VAL_26]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> !llvm.ptr
+// CHECK: %[[VAL_27:.*]] = llvm.load %[[VAL_26]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> !llvm.ptr
// CHECK: %[[VAL_28:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
// CHECK: %[[VAL_29:.*]] = llvm.insertvalue %[[VAL_23]], %[[VAL_28]][1] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
// CHECK: %[[VAL_30:.*]] = llvm.mlir.constant(20240719 : i32) : i32
@@ -172,13 +172,13 @@ module {
// CHECK: %[[VAL_44B:.*]] = llvm.insertvalue %[[VAL_27]], %[[VAL_42]][8] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
// CHECK: %[[VAL_44:.*]] = llvm.insertvalue %{{.*}}, %[[VAL_44B]][9, 0] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
// CHECK: %[[VAL_45:.*]] = llvm.getelementptr %[[VAL_3]][0, 7, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_46:.*]] = llvm.load %[[VAL_45]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i64
+// CHECK: %[[VAL_46:.*]] = llvm.load %[[VAL_45]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i64
// CHECK: %[[VAL_47:.*]] = llvm.getelementptr %[[VAL_3]][0, 7, 0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_48:.*]] = llvm.load %[[VAL_47]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i64
+// CHECK: %[[VAL_48:.*]] = llvm.load %[[VAL_47]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i64
// CHECK: %[[VAL_49:.*]] = llvm.getelementptr %[[VAL_3]][0, 7, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_50:.*]] = llvm.load %[[VAL_49]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i64
+// CHECK: %[[VAL_50:.*]] = llvm.load %[[VAL_49]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i64
// CHECK: %[[VAL_51:.*]] = llvm.getelementptr %[[VAL_3]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: %[[VAL_52:.*]] = llvm.load %[[VAL_51]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> !llvm.ptr
+// CHECK: %[[VAL_52:.*]] = llvm.load %[[VAL_51]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> !llvm.ptr
// CHECK: %[[VAL_53:.*]] = llvm.mlir.constant(0 : i64) : i64
// CHECK: %[[VAL_54:.*]] = llvm.mlir.constant(1 : i64) : i64
// CHECK: %[[VAL_55:.*]] = llvm.icmp "eq" %[[VAL_48]], %[[VAL_53]] : i64
@@ -187,7 +187,7 @@ module {
// CHECK: %[[VAL_58:.*]] = llvm.insertvalue %[[VAL_48]], %[[VAL_57]][7, 0, 1] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
// CHECK: %[[VAL_59:.*]] = llvm.insertvalue %[[VAL_50]], %[[VAL_58]][7, 0, 2] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
// CHECK: %[[VAL_61:.*]] = llvm.insertvalue %[[VAL_52]], %[[VAL_59]][0] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
-// CHECK: llvm.store %[[VAL_61]], %[[VAL_1]] {tbaa = [#[[$BOXT]]]} : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>, !llvm.ptr
+// CHECK: llvm.store %[[VAL_61]], %[[VAL_1]] tbaa = [#[[$BOXT]]] : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>, !llvm.ptr
// CHECK: %[[VAL_63:.*]] = llvm.call @_FortranAioOutputDescriptor(%[[VAL_10]], %[[VAL_1]]) {fastmathFlags = #llvm.fastmath<contract>} : (!llvm.ptr, !llvm.ptr) -> i1
// CHECK: %[[VAL_64:.*]] = llvm.call @_FortranAioEndIoStatement(%[[VAL_10]]) {fastmathFlags = #llvm.fastmath<contract>} : (!llvm.ptr) -> i32
// CHECK: llvm.return
@@ -250,7 +250,7 @@ func.func @tbaa(%arg0: !fir.box<!fir.array<*:f64>>) -> i32 {
// CHECK-LABEL: llvm.func @tbaa(
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i32 {
// CHECK: %[[VAL_1:.*]] = llvm.getelementptr %[[VAL_0]][0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<15 x array<3 x i64>>)>
-// CHECK: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i8
+// CHECK: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i8
// CHECK: %[[VAL_3:.*]] = llvm.sext %[[VAL_2]] : i8 to i32
// CHECK: llvm.return %[[VAL_3]] : i32
// CHECK: }
@@ -270,7 +270,7 @@ func.func @tbaa(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 {
// CHECK-LABEL: llvm.func @tbaa(
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i1 {
// CHECK: %[[VAL_1:.*]] = llvm.getelementptr %[[VAL_0]][0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<15 x array<3 x i64>>)>
-// CHECK: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i8
+// CHECK: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i8
// CHECK: %[[VAL_3:.*]] = llvm.mlir.constant(0 : i8) : i8
// CHECK: %[[VAL_4:.*]] = llvm.icmp "ne" %[[VAL_2]], %[[VAL_3]] : i8
// CHECK: llvm.return %[[VAL_4]] : i1
@@ -291,7 +291,7 @@ func.func @tbaa(%arg0: !fir.box<f32>) -> i32 {
// CHECK-LABEL: llvm.func @tbaa(
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i32 {
// CHECK: %[[VAL_1:.*]] = llvm.getelementptr %[[VAL_0]][0, 1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8)>
-// CHECK: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i64
+// CHECK: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i64
// CHECK: %[[VAL_3:.*]] = llvm.trunc %[[VAL_2]] : i64 to i32
// CHECK: llvm.return %[[VAL_3]] : i32
// CHECK: }
@@ -311,7 +311,7 @@ func.func @tbaa(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 {
// CHECK-LABEL: llvm.func @tbaa(
// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> i1 {
// CHECK: %[[VAL_1:.*]] = llvm.getelementptr %[[VAL_0]][0, 5] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<15 x array<3 x i64>>)>
-// CHECK: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i8
+// CHECK: %[[VAL_2:.*]] = llvm.load %[[VAL_1]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i8
// CHECK: %[[VAL_2_I32:.*]] = llvm.sext %[[VAL_2]] : i8 to i32
// CHECK: %[[VAL_3:.*]] = llvm.mlir.constant(2 : i32) : i32
// CHECK: %[[VAL_4:.*]] = llvm.and %[[VAL_2_I32]], %[[VAL_3]] : i32
@@ -341,11 +341,11 @@ func.func @tbaa(%arg0: !fir.box<!fir.array<?xi32>>) {
// CHECK: %[[VAL_4:.*]] = llvm.sub %[[VAL_1]], %[[VAL_2]] overflow<nsw, nuw> : i64
// CHECK: %[[VAL_5:.*]] = llvm.mul %[[VAL_4]], %[[VAL_2]] overflow<nsw, nuw> : i64
// CHECK: %[[VAL_6:.*]] = llvm.getelementptr %[[VAL_0]][0, 7, 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
-// CHECK: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i64
+// CHECK: %[[VAL_7:.*]] = llvm.load %[[VAL_6]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i64
// CHECK: %[[VAL_8:.*]] = llvm.mul %[[VAL_5]], %[[VAL_7]] overflow<nsw> : i64
// CHECK: %[[VAL_9:.*]] = llvm.add %[[VAL_8]], %[[VAL_3]] overflow<nsw> : i64
// CHECK: %[[VAL_10:.*]] = llvm.getelementptr %[[VAL_0]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
-// CHECK: %[[VAL_11:.*]] = llvm.load %[[VAL_10]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> !llvm.ptr
+// CHECK: %[[VAL_11:.*]] = llvm.load %[[VAL_10]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> !llvm.ptr
// CHECK: %[[VAL_13:.*]] = llvm.getelementptr nusw %[[VAL_11]]{{\[}}%[[VAL_9]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8
// CHECK: llvm.return
// CHECK: }
@@ -364,8 +364,8 @@ func.func @tbaa(%arg0: !fir.ref<!fir.type<_QMtypesTt{x:!fir.box<!fir.heap<f32>>}
return
}
// CHECK-LABEL: llvm.func @tbaa(
-// CHECK: llvm.load{{.*}}{tbaa = [#[[$ANYT]]]}
-// CHECK: llvm.store{{.*}}{tbaa = [#[[$ANYT]]]}
+// CHECK: llvm.load{{.*}}tbaa = [#[[$ANYT]]]
+// CHECK: llvm.store{{.*}}tbaa = [#[[$ANYT]]]
// -----
@@ -381,8 +381,8 @@ func.func @tbaa(%arg0: !fir.ref<!fir.array<2x!fir.type<_QMtypesTt{x:!fir.box<!fi
return
}
// CHECK-LABEL: llvm.func @tbaa(
-// CHECK: llvm.load{{.*}}{tbaa = [#[[$ANYT]]]}
-// CHECK: llvm.store{{.*}}{tbaa = [#[[$ANYT]]]}
+// CHECK: llvm.load{{.*}}tbaa = [#[[$ANYT]]]
+// CHECK: llvm.store{{.*}}tbaa = [#[[$ANYT]]]
// -----
@@ -404,7 +404,7 @@ func.func private @some_assumed_rank_func(!fir.box<!fir.array<*:f64>>) -> ()
// CHECK: %[[VAL_2:.*]] = llvm.alloca %[[VAL_1]] x !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<15 x array<3 x i64>>)> {alignment = 8 : i64} : (i32) -> !llvm.ptr
// CHECK: %[[VAL_3:.*]] = llvm.mlir.constant(24 : i32) : i32
// CHECK: %[[VAL_4:.*]] = llvm.getelementptr %[[VAL_0]][0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<15 x array<3 x i64>>)>
-// CHECK: %[[VAL_5:.*]] = llvm.load %[[VAL_4]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i8
+// CHECK: %[[VAL_5:.*]] = llvm.load %[[VAL_4]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i8
// CHECK: %[[VAL_6:.*]] = llvm.sext %[[VAL_5]] : i8 to i32
// CHECK: %[[VAL_7:.*]] = llvm.mlir.constant(24 : i32) : i32
// CHECK: %[[VAL_8:.*]] = llvm.mul %[[VAL_7]], %[[VAL_6]] : i32
@@ -428,5 +428,5 @@ func.func @store_assumed_rank_box(%box: !fir.box<!fir.array<*:f32>>, %ref: !fir.
// CHECK-SAME: %[[VAL_0:[^:]*]]: !llvm.ptr,
// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr) {
// CHECK: %[[VAL_3:.*]] = llvm.getelementptr %[[VAL_0]][0, 3] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<15 x array<3 x i64>>)>
-// CHECK: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] {tbaa = [#[[$BOXT]]]} : !llvm.ptr -> i8
+// CHECK: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] tbaa = [#[[$BOXT]]] : !llvm.ptr -> i8
// CHECK: "llvm.intr.memcpy"(%[[VAL_1]], %[[VAL_0]], %{{.*}}) <{isVolatile = false, tbaa = [#[[$BOXT]]]}> : (!llvm.ptr, !llvm.ptr, i32) -> ()
diff --git a/flang/test/Fir/vector-always-cfg.fir b/flang/test/Fir/vector-always-cfg.fir
index 45c2ea056a707..9bb805538d06d 100644
--- a/flang/test/Fir/vector-always-cfg.fir
+++ b/flang/test/Fir/vector-always-cfg.fir
@@ -20,7 +20,7 @@ func.func @_QPvector_always() -> i32 {
%c0 = arith.constant 0 : index
%6 = arith.cmpi sgt, %5, %c0 : index
cf.cond_br %6, ^bb2, ^bb3 {loop_annotation = #loop_annotation}
-// CHECK: llvm.cond_br %{{.*}}, ^{{.*}}, ^{{.*}} {loop_annotation = #[[ANNOTATION]]}
+// CHECK: llvm.cond_br %{{.*}}, ^{{.*}}, ^{{.*}} loop_annotation = #[[ANNOTATION]]
^bb2: // pred: ^bb1
%7 = arith.addi %3, %c1 : index
%c1_0 = arith.constant 1 : index
@@ -29,4 +29,3 @@ func.func @_QPvector_always() -> i32 {
^bb3: // pred: ^bb1
return %4 : i32
}
-
diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.td
index 01a3c8e9a1bde..595231ebb0a70 100644
--- a/mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.td
+++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.td
@@ -20,6 +20,7 @@ def LLVM_Dialect : Dialect {
let hasRegionArgAttrVerify = 1;
let hasRegionResultAttrVerify = 1;
let hasOperationAttrVerify = 1;
+ let useStrictPropertiesInAssemblyFormat = 1;
let discardableAttrs = (ins
/// Attribute encoding size and type of GPU workgroup attributions.
diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td
index 69f44e64b2de9..2e517c2f870aa 100644
--- a/mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td
+++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMIntrinsicOps.td
@@ -33,6 +33,8 @@ class LLVM_UnaryIntrOpF<string func, list<Trait> traits = []> :
dag fmfArg = (
ins DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags);
let arguments = !con(commonArgs, fmfArg);
+ let assemblyFormat = "`(` operands `)` (`fastmath` `` $fastmathFlags^)? "
+ "attr-dict `:` functional-type(operands, results)";
}
class LLVM_BinarySameArgsIntrOpBase<string func, Type element,
@@ -57,6 +59,8 @@ class LLVM_BinarySameArgsIntrOpF<string func, list<Trait> traits = []> :
dag fmfArg = (
ins DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags);
let arguments = !con(commonArgs, fmfArg);
+ let assemblyFormat = "`(` operands `)` (`fastmath` `` $fastmathFlags^)? "
+ "attr-dict `:` functional-type(operands, results)";
}
class LLVM_TernarySameArgsIntrOpBase<string func, Type element,
@@ -82,6 +86,8 @@ class LLVM_TernarySameArgsIntrOpF<string func, list<Trait> traits = []> :
dag fmfArg = (
ins DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags);
let arguments = !con(commonArgs, fmfArg);
+ let assemblyFormat = "`(` operands `)` (`fastmath` `` $fastmathFlags^)? "
+ "attr-dict `:` functional-type(operands, results)";
}
class LLVM_CountZerosIntrOp<string func, list<Trait> traits = []> :
@@ -120,7 +126,8 @@ class LLVM_PowFI<string func> :
(ins LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$val,
AnySignlessInteger:$power,
DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags);
- let assemblyFormat = "`(` operands `)` attr-dict `:` "
+ let assemblyFormat = "`(` operands `)` (`fastmath` `` $fastmathFlags^)? "
+ "attr-dict `:` "
"functional-type(operands, results)";
}
@@ -134,7 +141,8 @@ def LLVM_FractionExpOp : LLVM_TwoResultIntrOp<"frexp", [0, 1], [],
let arguments =
(ins LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$val,
DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags);
- let assemblyFormat = "`(` operands `)` attr-dict `:` "
+ let assemblyFormat = "`(` operands `)` (`fastmath` `` $fastmathFlags^)? "
+ "attr-dict `:` "
"functional-type(operands, results)";
}
def LLVM_FAbsOp : LLVM_UnaryIntrOpF<"fabs">;
@@ -208,7 +216,8 @@ def LLVM_SincosOp : LLVM_TwoResultIntrOp<"sincos", [], [0],
let arguments =
(ins LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$val,
DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags);
- let assemblyFormat = "`(` operands `)` attr-dict `:` "
+ let assemblyFormat = "`(` operands `)` (`fastmath` `` $fastmathFlags^)? "
+ "attr-dict `:` "
"functional-type(operands, results)";
let hasVerifier = 1;
}
@@ -516,7 +525,7 @@ class LLVM_ConstrainedUnaryIntrRM<string mnem>
/*overloadedResult=*/1, /*overloadedOperands=*/[],
/*hasRoundingMode=*/1, [SameOperandsAndResultType]> {
let assemblyFormat = [{
- $arg_0 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0)
+ $arg_0 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0)
}];
}
@@ -528,7 +537,7 @@ class LLVM_ConstrainedUnaryIntrNoRM<string mnem>
/*overloadedResult=*/1, /*overloadedOperands=*/[],
/*hasRoundingMode=*/0, [SameOperandsAndResultType]> {
let assemblyFormat = [{
- $arg_0 $fpExceptionBehavior attr-dict `:` type($arg_0)
+ $arg_0 $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0)
}];
}
@@ -540,7 +549,7 @@ class LLVM_ConstrainedBinaryIntrRM<string mnem>
/*overloadedResult=*/1, /*overloadedOperands=*/[],
/*hasRoundingMode=*/1, [SameOperandsAndResultType]> {
let assemblyFormat = [{
- $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0)
+ $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0)
}];
}
@@ -552,7 +561,7 @@ class LLVM_ConstrainedBinaryIntrNoRM<string mnem>
/*overloadedResult=*/1, /*overloadedOperands=*/[],
/*hasRoundingMode=*/0, [SameOperandsAndResultType]> {
let assemblyFormat = [{
- $arg_0 `,` $arg_1 $fpExceptionBehavior attr-dict `:` type($arg_0)
+ $arg_0 `,` $arg_1 $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0)
}];
}
@@ -563,7 +572,7 @@ class LLVM_ConstrainedFPToIntIntrRM<string mnem>
/*overloadedResult=*/1, /*overloadedOperands=*/[0],
/*hasRoundingMode=*/1> {
let assemblyFormat = [{
- $arg_0 $roundingmode $fpExceptionBehavior attr-dict `:`
+ $arg_0 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:`
type($arg_0) `to` type(results)
}];
}
@@ -575,7 +584,7 @@ class LLVM_ConstrainedFPToIntIntrNoRM<string mnem>
/*overloadedResult=*/1, /*overloadedOperands=*/[0],
/*hasRoundingMode=*/0> {
let assemblyFormat = [{
- $arg_0 $fpExceptionBehavior attr-dict `:` type($arg_0) `to` type(results)
+ $arg_0 $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0) `to` type(results)
}];
}
@@ -600,7 +609,7 @@ class LLVM_ConstrainedFCmpIntrBase<string mnem>
// the exception behavior metadata is the fourth LLVM operand.
list<int> llvmArgIndices = [-1, 0, 1, 3, -1];
let assemblyFormat = [{
- $predicate $arg_0 `,` $arg_1 $fpExceptionBehavior attr-dict `:` type($arg_0)
+ $predicate $arg_0 `,` $arg_1 $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0)
}];
let llvmBuilder = [{
$res = builder.CreateConstrainedFPCmp(
@@ -627,7 +636,7 @@ def LLVM_ConstrainedFAddIntr
/*overloadedResult=*/1, /*overloadedOperands=*/[],
/*hasRoundingMode=*/1, [SameOperandsAndResultType]> {
let assemblyFormat = [{
- $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0)
+ $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0)
}];
}
@@ -636,7 +645,7 @@ def LLVM_ConstrainedFSubIntr
/*overloadedResult=*/1, /*overloadedOperands=*/[],
/*hasRoundingMode=*/1, [SameOperandsAndResultType]> {
let assemblyFormat = [{
- $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0)
+ $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0)
}];
}
@@ -645,7 +654,7 @@ def LLVM_ConstrainedFMulIntr
/*overloadedResult=*/1, /*overloadedOperands=*/[],
/*hasRoundingMode=*/1, [SameOperandsAndResultType]> {
let assemblyFormat = [{
- $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0)
+ $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0)
}];
}
@@ -654,7 +663,7 @@ def LLVM_ConstrainedFDivIntr
/*overloadedResult=*/1, /*overloadedOperands=*/[],
/*hasRoundingMode=*/1, [SameOperandsAndResultType]> {
let assemblyFormat = [{
- $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0)
+ $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0)
}];
}
@@ -663,7 +672,7 @@ def LLVM_ConstrainedFRemIntr
/*overloadedResult=*/1, /*overloadedOperands=*/[],
/*hasRoundingMode=*/1, [SameOperandsAndResultType]> {
let assemblyFormat = [{
- $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0)
+ $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0)
}];
}
@@ -672,7 +681,7 @@ def LLVM_ConstrainedFMAIntr
/*overloadedResult=*/1, /*overloadedOperands=*/[],
/*hasRoundingMode=*/1, [SameOperandsAndResultType]> {
let assemblyFormat = [{
- $arg_0 `,` $arg_1 `,` $arg_2 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0)
+ $arg_0 `,` $arg_1 `,` $arg_2 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0)
}];
}
@@ -681,7 +690,7 @@ def LLVM_ConstrainedFMulAddIntr
/*overloadedResult=*/1, /*overloadedOperands=*/[],
/*hasRoundingMode=*/1, [SameOperandsAndResultType]> {
let assemblyFormat = [{
- $arg_0 `,` $arg_1 `,` $arg_2 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0)
+ $arg_0 `,` $arg_1 `,` $arg_2 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0)
}];
}
@@ -730,7 +739,7 @@ def LLVM_ConstrainedPowIIntr
/*overloadedResult=*/1, /*overloadedOperands=*/[],
/*hasRoundingMode=*/1> {
let assemblyFormat = [{
- $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior attr-dict `:`
+ $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:`
functional-type(operands, results)
}];
}
@@ -740,7 +749,7 @@ def LLVM_ConstrainedLdexpIntr
/*overloadedResult=*/1, /*overloadedOperands=*/[1],
/*hasRoundingMode=*/1> {
let assemblyFormat = [{
- $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior attr-dict `:`
+ $arg_0 `,` $arg_1 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:`
functional-type(operands, results)
}];
}
@@ -764,7 +773,7 @@ def LLVM_ConstrainedUIToFP
/*overloadedResult=*/1, /*overloadedOperands=*/[0],
/*hasRoundingMode=*/1> {
let assemblyFormat = [{
- $arg_0 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0) `to` type(results)
+ $arg_0 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0) `to` type(results)
}];
}
@@ -773,7 +782,7 @@ def LLVM_ConstrainedSIToFP
/*overloadedResult=*/1, /*overloadedOperands=*/[0],
/*hasRoundingMode=*/1> {
let assemblyFormat = [{
- $arg_0 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0) `to` type(results)
+ $arg_0 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0) `to` type(results)
}];
}
@@ -782,7 +791,7 @@ def LLVM_ConstrainedFPTruncIntr
/*overloadedResult=*/1, /*overloadedOperands=*/[0],
/*hasRoundingMode=*/1> {
let assemblyFormat = [{
- $arg_0 $roundingmode $fpExceptionBehavior attr-dict `:` type($arg_0) `to` type(results)
+ $arg_0 $roundingmode $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0) `to` type(results)
}];
}
@@ -791,7 +800,7 @@ def LLVM_ConstrainedFPExtIntr
/*overloadedResult=*/1, /*overloadedOperands=*/[0],
/*hasRoundingMode=*/0> {
let assemblyFormat = [{
- $arg_0 $fpExceptionBehavior attr-dict `:` type($arg_0) `to` type(results)
+ $arg_0 $fpExceptionBehavior (`fastmath` `` $fastmathFlags^)? attr-dict `:` type($arg_0) `to` type(results)
}];
}
@@ -1194,7 +1203,8 @@ class LLVM_VecReductionF<string mnem>
ins DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags);
let arguments = !con(commonArgs, fmfArg);
- let assemblyFormat = "`(` operands `)` attr-dict `:` "
+ let assemblyFormat = "`(` operands `)` (`fastmath` `` $fastmathFlags^)? "
+ "attr-dict `:` "
"functional-type(operands, results)";
}
@@ -1213,7 +1223,10 @@ class LLVM_VecReductionAccBase<string mnem, Type element>
/*requiresFastmath=*/1>,
Arguments<(ins element:$start_value,
LLVM_VectorOf<element>:$input,
- DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags)>;
+ DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags)> {
+ let assemblyFormat = "`(` operands `)` (`fastmath` `` $fastmathFlags^)? "
+ "attr-dict `:` functional-type(operands, results)";
+}
class LLVM_VecReductionAccF<string mnem>
: LLVM_VecReductionAccBase<mnem, AnyFloat>;
@@ -1252,8 +1265,10 @@ def LLVM_MatrixColumnMajorLoadOp : LLVM_OneResultIntrOp<"matrix.column.major.loa
I32Attr:$rows, I32Attr:$columns);
let results = (outs LLVM_AnyVector:$res);
let builders = [LLVM_OneResultOpBuilder];
- let assemblyFormat = "$data `,` `<` `stride` `=` $stride `>` attr-dict"
- "`:` type($res) `from` qualified(type($data)) `stride` type($stride)";
+ let assemblyFormat = "$data `,` `<` `stride` `=` $stride `>` "
+ "`is_volatile` `=` $isVolatile `rows` `=` $rows "
+ "`columns` `=` $columns attr-dict `:` type($res) `from` "
+ "qualified(type($data)) `stride` type($stride)";
string llvmBuilder = [{
llvm::MatrixBuilder mb(builder);
@@ -1287,7 +1302,9 @@ def LLVM_MatrixColumnMajorStoreOp : LLVM_ZeroResultIntrOp<"matrix.column.major.s
I32Attr:$columns);
let builders = [LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder];
let assemblyFormat = "$matrix `,` $data `,` `<` `stride` `=` $stride `>` "
- "attr-dict`:` type($matrix) `to` qualified(type($data)) `stride` type($stride)";
+ "`is_volatile` `=` $isVolatile `rows` `=` $rows "
+ "`columns` `=` $columns attr-dict `:` type($matrix) `to` "
+ "qualified(type($data)) `stride` type($stride)";
string llvmBuilder = [{
llvm::MatrixBuilder mb(builder);
@@ -1314,7 +1331,9 @@ def LLVM_MatrixMultiplyOp : LLVM_OneResultIntrOp<"matrix.multiply"> {
I32Attr:$lhs_columns, I32Attr:$rhs_columns);
let results = (outs LLVM_AnyVector:$res);
let builders = [LLVM_OneResultOpBuilder];
- let assemblyFormat = "$lhs `,` $rhs attr-dict "
+ let assemblyFormat = "$lhs `,` $rhs "
+ "`lhs_rows` `=` $lhs_rows `lhs_columns` `=` $lhs_columns "
+ "`rhs_columns` `=` $rhs_columns attr-dict "
"`:` `(` type($lhs) `,` type($rhs) `)` `->` type($res)";
string llvmBuilder = [{
@@ -1336,7 +1355,8 @@ def LLVM_MatrixTransposeOp : LLVM_OneResultIntrOp<"matrix.transpose"> {
let arguments = (ins LLVM_AnyVector:$matrix, I32Attr:$rows, I32Attr:$columns);
let results = (outs LLVM_AnyVector:$res);
let builders = [LLVM_OneResultOpBuilder];
- let assemblyFormat = "$matrix attr-dict `:` type($matrix) `into` type($res)";
+ let assemblyFormat = "$matrix `rows` `=` $rows `columns` `=` $columns "
+ "attr-dict `:` type($matrix) `into` type($res)";
string llvmBuilder = [{
llvm::MatrixBuilder mb(builder);
@@ -1369,7 +1389,8 @@ def LLVM_MaskedLoadOp : LLVM_OneResultIntrOp<"masked.load"> {
UnitAttr:$nontemporal);
let results = (outs LLVM_AnyVector:$res);
let assemblyFormat =
- "operands attr-dict `:` functional-type(operands, results)";
+ "operands `alignment` `=` $alignment (`nontemporal` $nontemporal^)? "
+ "attr-dict `:` functional-type(operands, results)";
string llvmBuilder = [{
auto *inst = $pass_thru ? builder.CreateMaskedLoad(
@@ -1396,7 +1417,8 @@ def LLVM_MaskedStoreOp : LLVM_ZeroResultIntrOp<"masked.store"> {
LLVM_VectorOf<I1>:$mask, I32Attr:$alignment,
UnitAttr:$nontemporal);
let builders = [LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder];
- let assemblyFormat = "$value `,` $data `,` $mask attr-dict `:` "
+ let assemblyFormat = "$value `,` $data `,` $mask `alignment` `=` "
+ "$alignment (`nontemporal` $nontemporal^)? attr-dict `:` "
"type($value) `,` type($mask) `into` qualified(type($data))";
string llvmBuilder = [{
@@ -1422,7 +1444,8 @@ def LLVM_masked_gather : LLVM_OneResultIntrOp<"masked.gather"> {
let results = (outs LLVM_AnyVector:$res);
let builders = [LLVM_OneResultOpBuilder];
let assemblyFormat =
- "operands attr-dict `:` functional-type(operands, results)";
+ "operands `alignment` `=` $alignment attr-dict `:` "
+ "functional-type(operands, results)";
string llvmBuilder = [{
$res = $pass_thru.empty() ? builder.CreateMaskedGather(
@@ -1447,7 +1470,8 @@ def LLVM_masked_scatter : LLVM_ZeroResultIntrOp<"masked.scatter"> {
let arguments = (ins LLVM_AnyVector:$value, LLVM_VectorOf<LLVM_AnyPointer>:$ptrs,
LLVM_VectorOf<I1>:$mask, I32Attr:$alignment);
let builders = [LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder];
- let assemblyFormat = "$value `,` $ptrs `,` $mask attr-dict `:` "
+ let assemblyFormat = "$value `,` $ptrs `,` $mask `alignment` `=` "
+ "$alignment attr-dict `:` "
"type($value) `,` type($mask) `into` type($ptrs)";
string llvmBuilder = [{
@@ -1554,7 +1578,7 @@ def LLVM_UBSanTrap : LLVM_ZeroResultIntrOp<"ubsantrap",
/*immArgPositions=*/[0], /*immArgAttrNames=*/["failureKind"]> {
let arguments = (ins I8Attr:$failureKind);
- let assemblyFormat = "prop-dict attr-dict";
+ let assemblyFormat = "`failureKind` `=` $failureKind attr-dict";
}
/// Create a call to vscale intrinsic.
diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td
index 86b9e6f58ea31..707f31ba287bb 100644
--- a/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td
+++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td
@@ -121,6 +121,8 @@ class LLVM_FloatArithmeticOp<string mnemonic, string instName,
dag fmfArg = (
ins DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags);
let arguments = !con(commonArgs, fmfArg);
+ let assemblyFormat = "$lhs `,` $rhs (`fastmath` `` $fastmathFlags^)? "
+ "attr-dict `:` type($res)";
string mlirBuilder = [{
auto op = $_qualCppClassName::create($_builder, $_location, $lhs, $rhs);
moduleImport.setFastmathFlagsAttr(inst, op);
@@ -139,7 +141,8 @@ class LLVM_UnaryFloatArithmeticOp<Type type, string mnemonic,
DefaultValuedAttr<LLVM_FastmathFlagsAttr, "{}">:$fastmathFlags);
let results = (outs type:$res);
let builders = [LLVM_OneResultOpBuilder];
- let assemblyFormat = "$operand attr-dict `:` type($res)";
+ let assemblyFormat = "$operand (`fastmath` `` $fastmathFlags^)? "
+ "attr-dict `:` type($res)";
string llvmInstName = instName;
string mlirBuilder = [{
auto op = $_qualCppClassName::create($_builder, $_location, $operand);
@@ -422,6 +425,14 @@ def LLVM_LoadOp : LLVM_MemAccessOpBase<"load",
(`invariant` $invariant^)?
(`invariant_group` $invariantGroup^)?
(`dereferenceable` `` $dereferenceable^)?
+ oilist(
+ `nontemporal` $nontemporal |
+ `alignment` `=` $alignment |
+ `access_groups` `=` $access_groups |
+ `alias_scopes` `=` $alias_scopes |
+ `noalias_scopes` `=` $noalias_scopes |
+ `tbaa` `=` $tbaa
+ )
attr-dict `:` qualified(type($addr)) `->` type($res)
}];
string llvmBuilder = [{
@@ -507,6 +518,14 @@ def LLVM_StoreOp : LLVM_MemAccessOpBase<"store",
(`volatile` $volatile_^)? $value `,` $addr
(`atomic` (`syncscope` `(` $syncscope^ `)`)? $ordering^)?
(`invariant_group` $invariantGroup^)?
+ oilist(
+ `nontemporal` $nontemporal |
+ `alignment` `=` $alignment |
+ `access_groups` `=` $access_groups |
+ `alias_scopes` `=` $alias_scopes |
+ `noalias_scopes` `=` $noalias_scopes |
+ `tbaa` `=` $tbaa
+ )
attr-dict `:` type($value) `,` qualified(type($addr))
}];
string llvmBuilder = [{
@@ -1087,7 +1106,8 @@ def LLVM_SelectOp
DefaultValuedAttr<LLVM_FastmathFlagsAttr,
"{}">:$fastmathFlags);
let results = (outs LLVM_Type:$res);
- let assemblyFormat = "operands attr-dict `:` type($condition) `,` type($res)";
+ let assemblyFormat = "operands (`fastmath` `` $fastmathFlags^)? "
+ "attr-dict `:` type($condition) `,` type($res)";
string llvmInstName = "Select";
string mlirBuilder = [{
auto op = LLVM::SelectOp::create($_builder,
@@ -1117,7 +1137,8 @@ def LLVM_BrOp : LLVM_TerminatorOp<"br",
);
let successors = (successor AnySuccessor:$dest);
let assemblyFormat = [{
- $dest (`(` $destOperands^ `:` type($destOperands) `)`)? attr-dict
+ $dest (`(` $destOperands^ `:` type($destOperands) `)`)?
+ oilist(`loop_annotation` `=` $loop_annotation) attr-dict
}];
let builders = [
OpBuilder<(ins "Block *":$dest), [{
@@ -1151,6 +1172,7 @@ def LLVM_CondBrOp
$condition ( `weights` `(` $branch_weights^ `)` )? `,`
$trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,`
$falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)?
+ oilist(`loop_annotation` `=` $loop_annotation)
attr-dict
}];
@@ -1255,6 +1277,7 @@ def LLVM_SwitchOp
$defaultDestination (`(` $defaultOperands^ `:` type($defaultOperands) `)`)?
custom<SwitchOpCases>(ref(type($value)), $case_values, $caseDestinations,
$caseOperands, type($caseOperands))
+ (`weights` `(` $branch_weights^ `)`)?
attr-dict
}];
let hasVerifier = 1;
@@ -1780,7 +1803,9 @@ def LLVM_IFuncOp : LLVM_Op<"mlir.ifunc",
let assemblyFormat = [{
custom<LLVMLinkage>($linkage) ($visibility_^)? ($unnamed_addr^)?
- $sym_name `:` $i_func_type `,` $resolver_type $resolver attr-dict
+ $sym_name `:` $i_func_type `,` $resolver_type $resolver
+ oilist(`dso_local` $dso_local | `addr_space` `=` $address_space)
+ attr-dict
}];
let hasVerifier = 1;
}
@@ -2375,7 +2400,15 @@ def LLVM_AtomicRMWOp : LLVM_MemAccessOpBase<"atomicrmw", [
let results = (outs LLVM_AtomicRMWType:$res);
let assemblyFormat = [{
(`volatile` $volatile_^)? $bin_op $ptr `,` $val
- (`syncscope` `(` $syncscope^ `)`)? $ordering attr-dict `:`
+ (`syncscope` `(` $syncscope^ `)`)? $ordering
+ oilist(
+ `alignment` `=` $alignment |
+ `access_groups` `=` $access_groups |
+ `alias_scopes` `=` $alias_scopes |
+ `noalias_scopes` `=` $noalias_scopes |
+ `tbaa` `=` $tbaa
+ )
+ attr-dict `:`
qualified(type($ptr)) `,` type($val)
}];
string llvmInstName = "AtomicRMW";
@@ -2430,7 +2463,15 @@ def LLVM_AtomicCmpXchgOp : LLVM_MemAccessOpBase<"cmpxchg", [
let assemblyFormat = [{
(`weak` $weak^)? (`volatile` $volatile_^)? $ptr `,` $cmp `,` $val
(`syncscope` `(` $syncscope^ `)`)? $success_ordering $failure_ordering
- attr-dict `:` qualified(type($ptr)) `,` type($val)
+ oilist(
+ `alignment` `=` $alignment |
+ `access_groups` `=` $access_groups |
+ `alias_scopes` `=` $alias_scopes |
+ `noalias_scopes` `=` $noalias_scopes |
+ `tbaa` `=` $tbaa
+ )
+ attr-dict `:`
+ qualified(type($ptr)) `,` type($val)
}];
string llvmInstName = "AtomicCmpXchg";
string llvmBuilder = [{
diff --git a/mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp b/mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp
index fef78a46d69fc..001ce0c59b5b1 100644
--- a/mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp
+++ b/mlir/lib/Conversion/ControlFlowToLLVM/ControlFlowToLLVM.cpp
@@ -149,11 +149,14 @@ struct BranchOpLowering : public ConvertOpToLLVMPattern<cf::BranchOp> {
if (failed(convertedBlock))
return failure();
DictionaryAttr attrs = op->getAttrDictionary();
+ auto loopAnnotation =
+ op->getAttrOfType<LLVM::LoopAnnotationAttr>("loop_annotation");
Operation *newOp = rewriter.replaceOpWithNewOp<LLVM::BrOp>(
- op, flattenedAdaptor, *convertedBlock);
+ op, flattenedAdaptor, loopAnnotation, *convertedBlock);
// TODO: We should not just forward all attributes like that. But there are
// existing Flang tests that depend on this behavior.
newOp->setAttrs(attrs);
+ newOp->removeDiscardableAttr("loop_annotation");
return success();
}
};
@@ -185,13 +188,16 @@ struct CondBranchOpLowering : public ConvertOpToLLVMPattern<cf::CondBranchOp> {
if (failed(convertedFalseBlock))
return failure();
DictionaryAttr attrs = op->getDiscardableAttrDictionary();
+ auto loopAnnotation =
+ op->getAttrOfType<LLVM::LoopAnnotationAttr>("loop_annotation");
auto newOp = rewriter.replaceOpWithNewOp<LLVM::CondBrOp>(
op, llvm::getSingleElement(adaptor.getCondition()),
flattenedAdaptorTrue, flattenedAdaptorFalse, op.getBranchWeightsAttr(),
- *convertedTrueBlock, *convertedFalseBlock);
+ loopAnnotation, *convertedTrueBlock, *convertedFalseBlock);
// TODO: We should not just forward all attributes like that. But there are
// existing Flang tests that depend on this behavior.
newOp->setDiscardableAttrs(attrs);
+ newOp->removeDiscardableAttr("loop_annotation");
return success();
}
};
diff --git a/mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir b/mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir
index 8a8b48f5d6143..bf3818ec0f77a 100644
--- a/mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir
+++ b/mlir/test/Conversion/ArithToLLVM/arith-to-llvm.mlir
@@ -845,11 +845,11 @@ func.func @minmaxf(%arg0 : f32, %arg1 : f32) -> f32 {
// CHECK-LABEL: @fastmath
func.func @fastmath(%arg0: f32, %arg1: f32, %arg2: i32) {
-// CHECK: llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
-// CHECK: llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
-// CHECK: llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : f32
+// CHECK: llvm.fadd %arg0, %arg1 fastmath<fast> : f32
+// CHECK: llvm.fmul %arg0, %arg1 fastmath<fast> : f32
+// CHECK: llvm.fneg %arg0 fastmath<fast> : f32
// CHECK: llvm.fadd %arg0, %arg1 : f32
-// CHECK: llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
+// CHECK: llvm.fadd %arg0, %arg1 fastmath<nnan, ninf> : f32
%0 = arith.addf %arg0, %arg1 fastmath<fast> : f32
%1 = arith.mulf %arg0, %arg1 fastmath<fast> : f32
%2 = arith.negf %arg0 fastmath<fast> : f32
@@ -862,21 +862,21 @@ func.func @fastmath(%arg0: f32, %arg1: f32, %arg2: i32) {
// CHECK-LABEL: @ops_supporting_fastmath
func.func @ops_supporting_fastmath(%arg0: f32, %arg1: f32, %arg2: i32) {
-// CHECK: llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
+// CHECK: llvm.fadd %arg0, %arg1 fastmath<fast> : f32
%0 = arith.addf %arg0, %arg1 fastmath<fast> : f32
-// CHECK: llvm.fdiv %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
+// CHECK: llvm.fdiv %arg0, %arg1 fastmath<fast> : f32
%1 = arith.divf %arg0, %arg1 fastmath<fast> : f32
-// CHECK: llvm.intr.maximum(%arg0, %arg1) {fastmathFlags = #llvm.fastmath<fast>} : (f32, f32) -> f32
+// CHECK: llvm.intr.maximum(%arg0, %arg1) fastmath<fast> : (f32, f32) -> f32
%2 = arith.maximumf %arg0, %arg1 fastmath<fast> : f32
-// CHECK: llvm.intr.minimum(%arg0, %arg1) {fastmathFlags = #llvm.fastmath<fast>} : (f32, f32) -> f32
+// CHECK: llvm.intr.minimum(%arg0, %arg1) fastmath<fast> : (f32, f32) -> f32
%3 = arith.minimumf %arg0, %arg1 fastmath<fast> : f32
-// CHECK: llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
+// CHECK: llvm.fmul %arg0, %arg1 fastmath<fast> : f32
%4 = arith.mulf %arg0, %arg1 fastmath<fast> : f32
-// CHECK: llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : f32
+// CHECK: llvm.fneg %arg0 fastmath<fast> : f32
%5 = arith.negf %arg0 fastmath<fast> : f32
-// CHECK: llvm.frem %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
+// CHECK: llvm.frem %arg0, %arg1 fastmath<fast> : f32
%6 = arith.remf %arg0, %arg1 fastmath<fast> : f32
-// CHECK: llvm.fsub %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
+// CHECK: llvm.fsub %arg0, %arg1 fastmath<fast> : f32
%7 = arith.subf %arg0, %arg1 fastmath<fast> : f32
return
}
diff --git a/mlir/test/Conversion/ComplexToLLVM/complex-range-option.mlir b/mlir/test/Conversion/ComplexToLLVM/complex-range-option.mlir
index 78e8db795788a..089da8073b27f 100644
--- a/mlir/test/Conversion/ComplexToLLVM/complex-range-option.mlir
+++ b/mlir/test/Conversion/ComplexToLLVM/complex-range-option.mlir
@@ -169,31 +169,31 @@ func.func @complex_div_with_fmf(%lhs: complex<f32>, %rhs: complex<f32>) -> compl
// DIV-SMITH: %[[RESULT_0:.*]] = llvm.mlir.poison : ![[C_TY]]
-// DIV-SMITH: %[[RHS_REAL_IMAG_RATIO:.*]] = llvm.fdiv %[[RHS_REAL]], %[[RHS_IMAG]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RHS_REAL_TIMES_RHS_REAL_IMAG_RATIO:.*]] = llvm.fmul %[[RHS_REAL_IMAG_RATIO]], %[[RHS_REAL]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RHS_REAL_IMAG_DENOM:.*]] = llvm.fadd %[[RHS_IMAG]], %[[RHS_REAL_TIMES_RHS_REAL_IMAG_RATIO]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[LHS_REAL_TIMES_RHS_REAL_IMAG_RATIO:.*]] = llvm.fmul %[[LHS_REAL]], %[[RHS_REAL_IMAG_RATIO]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[REAL_NUMERATOR_1:.*]] = llvm.fadd %[[LHS_REAL_TIMES_RHS_REAL_IMAG_RATIO]], %[[LHS_IMAG]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RESULT_REAL_1:.*]] = llvm.fdiv %[[REAL_NUMERATOR_1]], %[[RHS_REAL_IMAG_DENOM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[LHS_IMAG_TIMES_RHS_REAL_IMAG_RATIO:.*]] = llvm.fmul %[[LHS_IMAG]], %[[RHS_REAL_IMAG_RATIO]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[IMAG_NUMERATOR_1:.*]] = llvm.fsub %[[LHS_IMAG_TIMES_RHS_REAL_IMAG_RATIO]], %[[LHS_REAL]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RESULT_IMAG_1:.*]] = llvm.fdiv %[[IMAG_NUMERATOR_1]], %[[RHS_REAL_IMAG_DENOM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-
-// DIV-SMITH: %[[RHS_IMAG_REAL_RATIO:.*]] = llvm.fdiv %[[RHS_IMAG]], %[[RHS_REAL]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RHS_IMAG_TIMES_RHS_IMAG_REAL_RATIO:.*]] = llvm.fmul %[[RHS_IMAG_REAL_RATIO]], %[[RHS_IMAG]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RHS_IMAG_REAL_DENOM:.*]] = llvm.fadd %[[RHS_REAL]], %[[RHS_IMAG_TIMES_RHS_IMAG_REAL_RATIO]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[LHS_IMAG_TIMES_RHS_IMAG_REAL_RATIO:.*]] = llvm.fmul %[[LHS_IMAG]], %[[RHS_IMAG_REAL_RATIO]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[REAL_NUMERATOR_2:.*]] = llvm.fadd %[[LHS_REAL]], %[[LHS_IMAG_TIMES_RHS_IMAG_REAL_RATIO]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RESULT_REAL_2:.*]] = llvm.fdiv %[[REAL_NUMERATOR_2]], %[[RHS_IMAG_REAL_DENOM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[LHS_REAL_TIMES_RHS_IMAG_REAL_RATIO:.*]] = llvm.fmul %[[LHS_REAL]], %[[RHS_IMAG_REAL_RATIO]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[IMAG_NUMERATOR_2:.*]] = llvm.fsub %[[LHS_IMAG]], %[[LHS_REAL_TIMES_RHS_IMAG_REAL_RATIO]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RESULT_IMAG_2:.*]] = llvm.fdiv %[[IMAG_NUMERATOR_2]], %[[RHS_IMAG_REAL_DENOM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
+// DIV-SMITH: %[[RHS_REAL_IMAG_RATIO:.*]] = llvm.fdiv %[[RHS_REAL]], %[[RHS_IMAG]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RHS_REAL_TIMES_RHS_REAL_IMAG_RATIO:.*]] = llvm.fmul %[[RHS_REAL_IMAG_RATIO]], %[[RHS_REAL]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RHS_REAL_IMAG_DENOM:.*]] = llvm.fadd %[[RHS_IMAG]], %[[RHS_REAL_TIMES_RHS_REAL_IMAG_RATIO]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[LHS_REAL_TIMES_RHS_REAL_IMAG_RATIO:.*]] = llvm.fmul %[[LHS_REAL]], %[[RHS_REAL_IMAG_RATIO]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[REAL_NUMERATOR_1:.*]] = llvm.fadd %[[LHS_REAL_TIMES_RHS_REAL_IMAG_RATIO]], %[[LHS_IMAG]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RESULT_REAL_1:.*]] = llvm.fdiv %[[REAL_NUMERATOR_1]], %[[RHS_REAL_IMAG_DENOM]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[LHS_IMAG_TIMES_RHS_REAL_IMAG_RATIO:.*]] = llvm.fmul %[[LHS_IMAG]], %[[RHS_REAL_IMAG_RATIO]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[IMAG_NUMERATOR_1:.*]] = llvm.fsub %[[LHS_IMAG_TIMES_RHS_REAL_IMAG_RATIO]], %[[LHS_REAL]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RESULT_IMAG_1:.*]] = llvm.fdiv %[[IMAG_NUMERATOR_1]], %[[RHS_REAL_IMAG_DENOM]] fastmath<nsz, arcp> : f32
+
+// DIV-SMITH: %[[RHS_IMAG_REAL_RATIO:.*]] = llvm.fdiv %[[RHS_IMAG]], %[[RHS_REAL]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RHS_IMAG_TIMES_RHS_IMAG_REAL_RATIO:.*]] = llvm.fmul %[[RHS_IMAG_REAL_RATIO]], %[[RHS_IMAG]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RHS_IMAG_REAL_DENOM:.*]] = llvm.fadd %[[RHS_REAL]], %[[RHS_IMAG_TIMES_RHS_IMAG_REAL_RATIO]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[LHS_IMAG_TIMES_RHS_IMAG_REAL_RATIO:.*]] = llvm.fmul %[[LHS_IMAG]], %[[RHS_IMAG_REAL_RATIO]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[REAL_NUMERATOR_2:.*]] = llvm.fadd %[[LHS_REAL]], %[[LHS_IMAG_TIMES_RHS_IMAG_REAL_RATIO]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RESULT_REAL_2:.*]] = llvm.fdiv %[[REAL_NUMERATOR_2]], %[[RHS_IMAG_REAL_DENOM]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[LHS_REAL_TIMES_RHS_IMAG_REAL_RATIO:.*]] = llvm.fmul %[[LHS_REAL]], %[[RHS_IMAG_REAL_RATIO]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[IMAG_NUMERATOR_2:.*]] = llvm.fsub %[[LHS_IMAG]], %[[LHS_REAL_TIMES_RHS_IMAG_REAL_RATIO]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RESULT_IMAG_2:.*]] = llvm.fdiv %[[IMAG_NUMERATOR_2]], %[[RHS_IMAG_REAL_DENOM]] fastmath<nsz, arcp> : f32
// Case 1. Zero denominator, numerator contains at most one NaN value.
// DIV-SMITH: %[[ZERO:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
-// DIV-SMITH: %[[RHS_REAL_ABS:.*]] = llvm.intr.fabs(%[[RHS_REAL]]) {fastmathFlags = #llvm.fastmath<nsz, arcp>} : (f32) -> f32
+// DIV-SMITH: %[[RHS_REAL_ABS:.*]] = llvm.intr.fabs(%[[RHS_REAL]]) fastmath<nsz, arcp> : (f32) -> f32
// DIV-SMITH: %[[RHS_REAL_ABS_IS_ZERO:.*]] = llvm.fcmp "oeq" %[[RHS_REAL_ABS]], %[[ZERO]] : f32
-// DIV-SMITH: %[[RHS_IMAG_ABS:.*]] = llvm.intr.fabs(%[[RHS_IMAG]]) {fastmathFlags = #llvm.fastmath<nsz, arcp>} : (f32) -> f32
+// DIV-SMITH: %[[RHS_IMAG_ABS:.*]] = llvm.intr.fabs(%[[RHS_IMAG]]) fastmath<nsz, arcp> : (f32) -> f32
// DIV-SMITH: %[[RHS_IMAG_ABS_IS_ZERO:.*]] = llvm.fcmp "oeq" %[[RHS_IMAG_ABS]], %[[ZERO]] : f32
// DIV-SMITH: %[[LHS_REAL_IS_NOT_NAN:.*]] = llvm.fcmp "ord" %[[LHS_REAL]], %[[ZERO]] : f32
// DIV-SMITH: %[[LHS_IMAG_IS_NOT_NAN:.*]] = llvm.fcmp "ord" %[[LHS_IMAG]], %[[ZERO]] : f32
@@ -202,16 +202,16 @@ func.func @complex_div_with_fmf(%lhs: complex<f32>, %rhs: complex<f32>) -> compl
// DIV-SMITH: %[[RESULT_IS_INFINITY:.*]] = llvm.and %[[LHS_CONTAINS_NOT_NAN_VALUE]], %[[RHS_IS_ZERO]] : i1
// DIV-SMITH: %[[INF:.*]] = llvm.mlir.constant(0x7F800000 : f32) : f32
// DIV-SMITH: %[[INF_WITH_SIGN_OF_RHS_REAL:.*]] = llvm.intr.copysign(%[[INF]], %[[RHS_REAL]]) : (f32, f32) -> f32
-// DIV-SMITH: %[[INFINITY_RESULT_REAL:.*]] = llvm.fmul %[[INF_WITH_SIGN_OF_RHS_REAL]], %[[LHS_REAL]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[INFINITY_RESULT_IMAG:.*]] = llvm.fmul %[[INF_WITH_SIGN_OF_RHS_REAL]], %[[LHS_IMAG]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
+// DIV-SMITH: %[[INFINITY_RESULT_REAL:.*]] = llvm.fmul %[[INF_WITH_SIGN_OF_RHS_REAL]], %[[LHS_REAL]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[INFINITY_RESULT_IMAG:.*]] = llvm.fmul %[[INF_WITH_SIGN_OF_RHS_REAL]], %[[LHS_IMAG]] fastmath<nsz, arcp> : f32
// Case 2. Infinite numerator, finite denominator.
// DIV-SMITH: %[[RHS_REAL_FINITE:.*]] = llvm.fcmp "one" %[[RHS_REAL_ABS]], %[[INF]] : f32
// DIV-SMITH: %[[RHS_IMAG_FINITE:.*]] = llvm.fcmp "one" %[[RHS_IMAG_ABS]], %[[INF]] : f32
// DIV-SMITH: %[[RHS_IS_FINITE:.*]] = llvm.and %[[RHS_REAL_FINITE]], %[[RHS_IMAG_FINITE]] : i1
-// DIV-SMITH: %[[LHS_REAL_ABS:.*]] = llvm.intr.fabs(%[[LHS_REAL]]) {fastmathFlags = #llvm.fastmath<nsz, arcp>} : (f32) -> f32
+// DIV-SMITH: %[[LHS_REAL_ABS:.*]] = llvm.intr.fabs(%[[LHS_REAL]]) fastmath<nsz, arcp> : (f32) -> f32
// DIV-SMITH: %[[LHS_REAL_INFINITE:.*]] = llvm.fcmp "oeq" %[[LHS_REAL_ABS]], %[[INF]] : f32
-// DIV-SMITH: %[[LHS_IMAG_ABS:.*]] = llvm.intr.fabs(%[[LHS_IMAG]]) {fastmathFlags = #llvm.fastmath<nsz, arcp>} : (f32) -> f32
+// DIV-SMITH: %[[LHS_IMAG_ABS:.*]] = llvm.intr.fabs(%[[LHS_IMAG]]) fastmath<nsz, arcp> : (f32) -> f32
// DIV-SMITH: %[[LHS_IMAG_INFINITE:.*]] = llvm.fcmp "oeq" %[[LHS_IMAG_ABS]], %[[INF]] : f32
// DIV-SMITH: %[[LHS_IS_INFINITE:.*]] = llvm.or %[[LHS_REAL_INFINITE]], %[[LHS_IMAG_INFINITE]] : i1
// DIV-SMITH: %[[INF_NUM_FINITE_DENOM:.*]] = llvm.and %[[LHS_IS_INFINITE]], %[[RHS_IS_FINITE]] : i1
@@ -220,14 +220,14 @@ func.func @complex_div_with_fmf(%lhs: complex<f32>, %rhs: complex<f32>) -> compl
// DIV-SMITH: %[[LHS_REAL_IS_INF_WITH_SIGN:.*]] = llvm.intr.copysign(%[[LHS_REAL_IS_INF]], %[[LHS_REAL]]) : (f32, f32) -> f32
// DIV-SMITH: %[[LHS_IMAG_IS_INF:.*]] = llvm.select %[[LHS_IMAG_INFINITE]], %[[ONE]], %[[ZERO]] : i1, f32
// DIV-SMITH: %[[LHS_IMAG_IS_INF_WITH_SIGN:.*]] = llvm.intr.copysign(%[[LHS_IMAG_IS_INF]], %[[LHS_IMAG]]) : (f32, f32) -> f32
-// DIV-SMITH: %[[LHS_REAL_IS_INF_WITH_SIGN_TIMES_RHS_REAL:.*]] = llvm.fmul %[[LHS_REAL_IS_INF_WITH_SIGN]], %[[RHS_REAL]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[LHS_IMAG_IS_INF_WITH_SIGN_TIMES_RHS_IMAG:.*]] = llvm.fmul %[[LHS_IMAG_IS_INF_WITH_SIGN]], %[[RHS_IMAG]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[INF_MULTIPLICATOR_1:.*]] = llvm.fadd %[[LHS_REAL_IS_INF_WITH_SIGN_TIMES_RHS_REAL]], %[[LHS_IMAG_IS_INF_WITH_SIGN_TIMES_RHS_IMAG]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RESULT_REAL_3:.*]] = llvm.fmul %[[INF]], %[[INF_MULTIPLICATOR_1]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[LHS_REAL_IS_INF_WITH_SIGN_TIMES_RHS_IMAG:.*]] = llvm.fmul %[[LHS_REAL_IS_INF_WITH_SIGN]], %[[RHS_IMAG]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[LHS_IMAG_IS_INF_WITH_SIGN_TIMES_RHS_REAL:.*]] = llvm.fmul %[[LHS_IMAG_IS_INF_WITH_SIGN]], %[[RHS_REAL]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[INF_MULTIPLICATOR_2:.*]] = llvm.fsub %[[LHS_IMAG_IS_INF_WITH_SIGN_TIMES_RHS_REAL]], %[[LHS_REAL_IS_INF_WITH_SIGN_TIMES_RHS_IMAG]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RESULT_IMAG_3:.*]] = llvm.fmul %[[INF]], %[[INF_MULTIPLICATOR_2]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
+// DIV-SMITH: %[[LHS_REAL_IS_INF_WITH_SIGN_TIMES_RHS_REAL:.*]] = llvm.fmul %[[LHS_REAL_IS_INF_WITH_SIGN]], %[[RHS_REAL]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[LHS_IMAG_IS_INF_WITH_SIGN_TIMES_RHS_IMAG:.*]] = llvm.fmul %[[LHS_IMAG_IS_INF_WITH_SIGN]], %[[RHS_IMAG]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[INF_MULTIPLICATOR_1:.*]] = llvm.fadd %[[LHS_REAL_IS_INF_WITH_SIGN_TIMES_RHS_REAL]], %[[LHS_IMAG_IS_INF_WITH_SIGN_TIMES_RHS_IMAG]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RESULT_REAL_3:.*]] = llvm.fmul %[[INF]], %[[INF_MULTIPLICATOR_1]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[LHS_REAL_IS_INF_WITH_SIGN_TIMES_RHS_IMAG:.*]] = llvm.fmul %[[LHS_REAL_IS_INF_WITH_SIGN]], %[[RHS_IMAG]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[LHS_IMAG_IS_INF_WITH_SIGN_TIMES_RHS_REAL:.*]] = llvm.fmul %[[LHS_IMAG_IS_INF_WITH_SIGN]], %[[RHS_REAL]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[INF_MULTIPLICATOR_2:.*]] = llvm.fsub %[[LHS_IMAG_IS_INF_WITH_SIGN_TIMES_RHS_REAL]], %[[LHS_REAL_IS_INF_WITH_SIGN_TIMES_RHS_IMAG]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RESULT_IMAG_3:.*]] = llvm.fmul %[[INF]], %[[INF_MULTIPLICATOR_2]] fastmath<nsz, arcp> : f32
// Case 3. Finite numerator, infinite denominator.
// DIV-SMITH: %[[LHS_REAL_FINITE:.*]] = llvm.fcmp "one" %[[LHS_REAL_ABS]], %[[INF]] : f32
@@ -241,14 +241,14 @@ func.func @complex_div_with_fmf(%lhs: complex<f32>, %rhs: complex<f32>) -> compl
// DIV-SMITH: %[[RHS_REAL_IS_INF_WITH_SIGN:.*]] = llvm.intr.copysign(%[[RHS_REAL_IS_INF]], %[[RHS_REAL]]) : (f32, f32) -> f32
// DIV-SMITH: %[[RHS_IMAG_IS_INF:.*]] = llvm.select %[[RHS_IMAG_INFINITE]], %[[ONE]], %[[ZERO]] : i1, f32
// DIV-SMITH: %[[RHS_IMAG_IS_INF_WITH_SIGN:.*]] = llvm.intr.copysign(%[[RHS_IMAG_IS_INF]], %[[RHS_IMAG]]) : (f32, f32) -> f32
-// DIV-SMITH: %[[RHS_REAL_IS_INF_WITH_SIGN_TIMES_LHS_REAL:.*]] = llvm.fmul %[[LHS_REAL]], %[[RHS_REAL_IS_INF_WITH_SIGN]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RHS_IMAG_IS_INF_WITH_SIGN_TIMES_LHS_IMAG:.*]] = llvm.fmul %[[LHS_IMAG]], %[[RHS_IMAG_IS_INF_WITH_SIGN]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[ZERO_MULTIPLICATOR_1:.*]] = llvm.fadd %[[RHS_REAL_IS_INF_WITH_SIGN_TIMES_LHS_REAL]], %[[RHS_IMAG_IS_INF_WITH_SIGN_TIMES_LHS_IMAG]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RESULT_REAL_4:.*]] = llvm.fmul %[[ZERO]], %[[ZERO_MULTIPLICATOR_1]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RHS_REAL_IS_INF_WITH_SIGN_TIMES_LHS_IMAG:.*]] = llvm.fmul %[[LHS_IMAG]], %[[RHS_REAL_IS_INF_WITH_SIGN]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RHS_IMAG_IS_INF_WITH_SIGN_TIMES_LHS_REAL:.*]] = llvm.fmul %[[LHS_REAL]], %[[RHS_IMAG_IS_INF_WITH_SIGN]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[ZERO_MULTIPLICATOR_2:.*]] = llvm.fsub %[[RHS_REAL_IS_INF_WITH_SIGN_TIMES_LHS_IMAG]], %[[RHS_IMAG_IS_INF_WITH_SIGN_TIMES_LHS_REAL]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-SMITH: %[[RESULT_IMAG_4:.*]] = llvm.fmul %[[ZERO]], %[[ZERO_MULTIPLICATOR_2]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
+// DIV-SMITH: %[[RHS_REAL_IS_INF_WITH_SIGN_TIMES_LHS_REAL:.*]] = llvm.fmul %[[LHS_REAL]], %[[RHS_REAL_IS_INF_WITH_SIGN]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RHS_IMAG_IS_INF_WITH_SIGN_TIMES_LHS_IMAG:.*]] = llvm.fmul %[[LHS_IMAG]], %[[RHS_IMAG_IS_INF_WITH_SIGN]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[ZERO_MULTIPLICATOR_1:.*]] = llvm.fadd %[[RHS_REAL_IS_INF_WITH_SIGN_TIMES_LHS_REAL]], %[[RHS_IMAG_IS_INF_WITH_SIGN_TIMES_LHS_IMAG]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RESULT_REAL_4:.*]] = llvm.fmul %[[ZERO]], %[[ZERO_MULTIPLICATOR_1]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RHS_REAL_IS_INF_WITH_SIGN_TIMES_LHS_IMAG:.*]] = llvm.fmul %[[LHS_IMAG]], %[[RHS_REAL_IS_INF_WITH_SIGN]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RHS_IMAG_IS_INF_WITH_SIGN_TIMES_LHS_REAL:.*]] = llvm.fmul %[[LHS_REAL]], %[[RHS_IMAG_IS_INF_WITH_SIGN]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[ZERO_MULTIPLICATOR_2:.*]] = llvm.fsub %[[RHS_REAL_IS_INF_WITH_SIGN_TIMES_LHS_IMAG]], %[[RHS_IMAG_IS_INF_WITH_SIGN_TIMES_LHS_REAL]] fastmath<nsz, arcp> : f32
+// DIV-SMITH: %[[RESULT_IMAG_4:.*]] = llvm.fmul %[[ZERO]], %[[ZERO_MULTIPLICATOR_2]] fastmath<nsz, arcp> : f32
// DIV-SMITH: %[[REAL_ABS_SMALLER_THAN_IMAG_ABS:.*]] = llvm.fcmp "olt" %[[RHS_REAL_ABS]], %[[RHS_IMAG_ABS]] : f32
// DIV-SMITH: %[[RESULT_REAL:.*]] = llvm.select %[[REAL_ABS_SMALLER_THAN_IMAG_ABS]], %[[RESULT_REAL_1]], %[[RESULT_REAL_2]] : i1, f32
@@ -282,20 +282,20 @@ func.func @complex_div_with_fmf(%lhs: complex<f32>, %rhs: complex<f32>) -> compl
// DIV-ALGEBRAIC: %[[RESULT_0:.*]] = llvm.mlir.poison : ![[C_TY]]
-// DIV-ALGEBRAIC-DAG: %[[RHS_RE_SQ:.*]] = llvm.fmul %[[RHS_RE]], %[[RHS_RE]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-ALGEBRAIC-DAG: %[[RHS_IM_SQ:.*]] = llvm.fmul %[[RHS_IM]], %[[RHS_IM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-ALGEBRAIC: %[[SQ_NORM:.*]] = llvm.fadd %[[RHS_RE_SQ]], %[[RHS_IM_SQ]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
+// DIV-ALGEBRAIC-DAG: %[[RHS_RE_SQ:.*]] = llvm.fmul %[[RHS_RE]], %[[RHS_RE]] fastmath<nsz, arcp> : f32
+// DIV-ALGEBRAIC-DAG: %[[RHS_IM_SQ:.*]] = llvm.fmul %[[RHS_IM]], %[[RHS_IM]] fastmath<nsz, arcp> : f32
+// DIV-ALGEBRAIC: %[[SQ_NORM:.*]] = llvm.fadd %[[RHS_RE_SQ]], %[[RHS_IM_SQ]] fastmath<nsz, arcp> : f32
-// DIV-ALGEBRAIC-DAG: %[[REAL_TMP_0:.*]] = llvm.fmul %[[LHS_RE]], %[[RHS_RE]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-ALGEBRAIC-DAG: %[[REAL_TMP_1:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_IM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-ALGEBRAIC: %[[REAL_TMP_2:.*]] = llvm.fadd %[[REAL_TMP_0]], %[[REAL_TMP_1]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
+// DIV-ALGEBRAIC-DAG: %[[REAL_TMP_0:.*]] = llvm.fmul %[[LHS_RE]], %[[RHS_RE]] fastmath<nsz, arcp> : f32
+// DIV-ALGEBRAIC-DAG: %[[REAL_TMP_1:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_IM]] fastmath<nsz, arcp> : f32
+// DIV-ALGEBRAIC: %[[REAL_TMP_2:.*]] = llvm.fadd %[[REAL_TMP_0]], %[[REAL_TMP_1]] fastmath<nsz, arcp> : f32
-// DIV-ALGEBRAIC-DAG: %[[IMAG_TMP_0:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_RE]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-ALGEBRAIC-DAG: %[[IMAG_TMP_1:.*]] = llvm.fmul %[[LHS_RE]], %[[RHS_IM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-ALGEBRAIC: %[[IMAG_TMP_2:.*]] = llvm.fsub %[[IMAG_TMP_0]], %[[IMAG_TMP_1]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
+// DIV-ALGEBRAIC-DAG: %[[IMAG_TMP_0:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_RE]] fastmath<nsz, arcp> : f32
+// DIV-ALGEBRAIC-DAG: %[[IMAG_TMP_1:.*]] = llvm.fmul %[[LHS_RE]], %[[RHS_IM]] fastmath<nsz, arcp> : f32
+// DIV-ALGEBRAIC: %[[IMAG_TMP_2:.*]] = llvm.fsub %[[IMAG_TMP_0]], %[[IMAG_TMP_1]] fastmath<nsz, arcp> : f32
-// DIV-ALGEBRAIC: %[[REAL:.*]] = llvm.fdiv %[[REAL_TMP_2]], %[[SQ_NORM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// DIV-ALGEBRAIC: %[[IMAG:.*]] = llvm.fdiv %[[IMAG_TMP_2]], %[[SQ_NORM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
+// DIV-ALGEBRAIC: %[[REAL:.*]] = llvm.fdiv %[[REAL_TMP_2]], %[[SQ_NORM]] fastmath<nsz, arcp> : f32
+// DIV-ALGEBRAIC: %[[IMAG:.*]] = llvm.fdiv %[[IMAG_TMP_2]], %[[SQ_NORM]] fastmath<nsz, arcp> : f32
// DIV-ALGEBRAIC: %[[RESULT_1:.*]] = llvm.insertvalue %[[REAL]], %[[RESULT_0]][0] : ![[C_TY]]
// DIV-ALGEBRAIC: %[[RESULT_2:.*]] = llvm.insertvalue %[[IMAG]], %[[RESULT_1]][1] : ![[C_TY]]
//
diff --git a/mlir/test/Conversion/ComplexToLLVM/convert-to-llvm.mlir b/mlir/test/Conversion/ComplexToLLVM/convert-to-llvm.mlir
index e71104c4b445f..c2f627af5d407 100644
--- a/mlir/test/Conversion/ComplexToLLVM/convert-to-llvm.mlir
+++ b/mlir/test/Conversion/ComplexToLLVM/convert-to-llvm.mlir
@@ -161,8 +161,8 @@ func.func @complex_abs(%arg: complex<f32>) -> f32 {
// CHECK-DAG: %[[A_IMAG:.*]] = llvm.extractvalue %[[A]][1] : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[B_IMAG:.*]] = llvm.extractvalue %[[B]][1] : !llvm.struct<(f64, f64)>
// CHECK: %[[C0:.*]] = llvm.mlir.poison : !llvm.struct<(f64, f64)>
-// CHECK-DAG: %[[C_REAL:.*]] = llvm.fadd %[[A_REAL]], %[[B_REAL]] {fastmathFlags = #llvm.fastmath<reassoc>} : f64
-// CHECK-DAG: %[[C_IMAG:.*]] = llvm.fadd %[[A_IMAG]], %[[B_IMAG]] {fastmathFlags = #llvm.fastmath<reassoc>} : f64
+// CHECK-DAG: %[[C_REAL:.*]] = llvm.fadd %[[A_REAL]], %[[B_REAL]] fastmath<reassoc> : f64
+// CHECK-DAG: %[[C_IMAG:.*]] = llvm.fadd %[[A_IMAG]], %[[B_IMAG]] fastmath<reassoc> : f64
// CHECK: %[[C1:.*]] = llvm.insertvalue %[[C_REAL]], %[[C0]][0] : !llvm.struct<(f64, f64)>
// CHECK: %[[C2:.*]] = llvm.insertvalue %[[C_IMAG]], %[[C1]][1] : !llvm.struct<(f64, f64)>
func.func @complex_addition_with_fmf() {
@@ -182,8 +182,8 @@ func.func @complex_addition_with_fmf() {
// CHECK-DAG: %[[A_IMAG:.*]] = llvm.extractvalue %[[A]][1] : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[B_IMAG:.*]] = llvm.extractvalue %[[B]][1] : !llvm.struct<(f64, f64)>
// CHECK: %[[C0:.*]] = llvm.mlir.poison : !llvm.struct<(f64, f64)>
-// CHECK-DAG: %[[C_REAL:.*]] = llvm.fsub %[[A_REAL]], %[[B_REAL]] {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f64
-// CHECK-DAG: %[[C_IMAG:.*]] = llvm.fsub %[[A_IMAG]], %[[B_IMAG]] {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f64
+// CHECK-DAG: %[[C_REAL:.*]] = llvm.fsub %[[A_REAL]], %[[B_REAL]] fastmath<nnan, ninf> : f64
+// CHECK-DAG: %[[C_IMAG:.*]] = llvm.fsub %[[A_IMAG]], %[[B_IMAG]] fastmath<nnan, ninf> : f64
// CHECK: %[[C1:.*]] = llvm.insertvalue %[[C_REAL]], %[[C0]][0] : !llvm.struct<(f64, f64)>
// CHECK: %[[C2:.*]] = llvm.insertvalue %[[C_IMAG]], %[[C1]][1] : !llvm.struct<(f64, f64)>
func.func @complex_substraction_with_fmf() {
@@ -209,20 +209,20 @@ func.func @complex_substraction_with_fmf() {
// CHECK: %[[RESULT_0:.*]] = llvm.mlir.poison : ![[C_TY]]
-// CHECK-DAG: %[[RHS_RE_SQ:.*]] = llvm.fmul %[[RHS_RE]], %[[RHS_RE]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// CHECK-DAG: %[[RHS_IM_SQ:.*]] = llvm.fmul %[[RHS_IM]], %[[RHS_IM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// CHECK: %[[SQ_NORM:.*]] = llvm.fadd %[[RHS_RE_SQ]], %[[RHS_IM_SQ]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
+// CHECK-DAG: %[[RHS_RE_SQ:.*]] = llvm.fmul %[[RHS_RE]], %[[RHS_RE]] fastmath<nsz, arcp> : f32
+// CHECK-DAG: %[[RHS_IM_SQ:.*]] = llvm.fmul %[[RHS_IM]], %[[RHS_IM]] fastmath<nsz, arcp> : f32
+// CHECK: %[[SQ_NORM:.*]] = llvm.fadd %[[RHS_RE_SQ]], %[[RHS_IM_SQ]] fastmath<nsz, arcp> : f32
-// CHECK-DAG: %[[REAL_TMP_0:.*]] = llvm.fmul %[[LHS_RE]], %[[RHS_RE]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// CHECK-DAG: %[[REAL_TMP_1:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_IM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// CHECK: %[[REAL_TMP_2:.*]] = llvm.fadd %[[REAL_TMP_0]], %[[REAL_TMP_1]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
+// CHECK-DAG: %[[REAL_TMP_0:.*]] = llvm.fmul %[[LHS_RE]], %[[RHS_RE]] fastmath<nsz, arcp> : f32
+// CHECK-DAG: %[[REAL_TMP_1:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_IM]] fastmath<nsz, arcp> : f32
+// CHECK: %[[REAL_TMP_2:.*]] = llvm.fadd %[[REAL_TMP_0]], %[[REAL_TMP_1]] fastmath<nsz, arcp> : f32
-// CHECK-DAG: %[[IMAG_TMP_0:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_RE]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// CHECK-DAG: %[[IMAG_TMP_1:.*]] = llvm.fmul %[[LHS_RE]], %[[RHS_IM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// CHECK: %[[IMAG_TMP_2:.*]] = llvm.fsub %[[IMAG_TMP_0]], %[[IMAG_TMP_1]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
+// CHECK-DAG: %[[IMAG_TMP_0:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_RE]] fastmath<nsz, arcp> : f32
+// CHECK-DAG: %[[IMAG_TMP_1:.*]] = llvm.fmul %[[LHS_RE]], %[[RHS_IM]] fastmath<nsz, arcp> : f32
+// CHECK: %[[IMAG_TMP_2:.*]] = llvm.fsub %[[IMAG_TMP_0]], %[[IMAG_TMP_1]] fastmath<nsz, arcp> : f32
-// CHECK: %[[REAL:.*]] = llvm.fdiv %[[REAL_TMP_2]], %[[SQ_NORM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
-// CHECK: %[[IMAG:.*]] = llvm.fdiv %[[IMAG_TMP_2]], %[[SQ_NORM]] {fastmathFlags = #llvm.fastmath<nsz, arcp>} : f32
+// CHECK: %[[REAL:.*]] = llvm.fdiv %[[REAL_TMP_2]], %[[SQ_NORM]] fastmath<nsz, arcp> : f32
+// CHECK: %[[IMAG:.*]] = llvm.fdiv %[[IMAG_TMP_2]], %[[SQ_NORM]] fastmath<nsz, arcp> : f32
// CHECK: %[[RESULT_1:.*]] = llvm.insertvalue %[[REAL]], %[[RESULT_0]][0] : ![[C_TY]]
// CHECK: %[[RESULT_2:.*]] = llvm.insertvalue %[[IMAG]], %[[RESULT_1]][1] : ![[C_TY]]
//
@@ -245,12 +245,12 @@ func.func @complex_div_with_fmf(%lhs: complex<f32>, %rhs: complex<f32>) -> compl
// CHECK: %[[RHS_IM:.*]] = llvm.extractvalue %[[CASTED_RHS]][1] : ![[C_TY]]
// CHECK: %[[RESULT_0:.*]] = llvm.mlir.poison : ![[C_TY]]
-// CHECK: %[[REAL_TMP:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_IM]] {fastmathFlags = #llvm.fastmath<contract, afn>} : f32
-// CHECK: %[[NEG_REAL_TMP:.*]] = llvm.fneg %[[REAL_TMP]] {fastmathFlags = #llvm.fastmath<contract, afn>} : f32
-// CHECK: %[[REAL:.*]] = llvm.intr.fma(%[[LHS_RE]], %[[RHS_RE]], %[[NEG_REAL_TMP]]) {fastmathFlags = #llvm.fastmath<contract, afn>} : (f32, f32, f32) -> f32
+// CHECK: %[[REAL_TMP:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_IM]] fastmath<contract, afn> : f32
+// CHECK: %[[NEG_REAL_TMP:.*]] = llvm.fneg %[[REAL_TMP]] fastmath<contract, afn> : f32
+// CHECK: %[[REAL:.*]] = llvm.intr.fma(%[[LHS_RE]], %[[RHS_RE]], %[[NEG_REAL_TMP]]) fastmath<contract, afn> : (f32, f32, f32) -> f32
-// CHECK: %[[IMAG_TMP:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_RE]] {fastmathFlags = #llvm.fastmath<contract, afn>} : f32
-// CHECK: %[[IMAG:.*]] = llvm.intr.fma(%[[LHS_RE]], %[[RHS_IM]], %[[IMAG_TMP]]) {fastmathFlags = #llvm.fastmath<contract, afn>} : (f32, f32, f32) -> f32
+// CHECK: %[[IMAG_TMP:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_RE]] fastmath<contract, afn> : f32
+// CHECK: %[[IMAG:.*]] = llvm.intr.fma(%[[LHS_RE]], %[[RHS_IM]], %[[IMAG_TMP]]) fastmath<contract, afn> : (f32, f32, f32) -> f32
// CHECK: %[[RESULT_1:.*]] = llvm.insertvalue %[[REAL]], %[[RESULT_0]][0]
// CHECK: %[[RESULT_2:.*]] = llvm.insertvalue %[[IMAG]], %[[RESULT_1]][1]
@@ -267,9 +267,9 @@ func.func @complex_mul_with_fmf(%lhs: complex<f32>, %rhs: complex<f32>) -> compl
// CHECK: %[[CASTED_ARG:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : complex<f32> to ![[C_TY:.*>]]
// CHECK: %[[REAL:.*]] = llvm.extractvalue %[[CASTED_ARG]][0] : ![[C_TY]]
// CHECK: %[[IMAG:.*]] = llvm.extractvalue %[[CASTED_ARG]][1] : ![[C_TY]]
-// CHECK-DAG: %[[REAL_SQ:.*]] = llvm.fmul %[[REAL]], %[[REAL]] {fastmathFlags = #llvm.fastmath<contract>} : f32
-// CHECK-DAG: %[[IMAG_SQ:.*]] = llvm.fmul %[[IMAG]], %[[IMAG]] {fastmathFlags = #llvm.fastmath<contract>} : f32
-// CHECK: %[[SQ_NORM:.*]] = llvm.fadd %[[REAL_SQ]], %[[IMAG_SQ]] {fastmathFlags = #llvm.fastmath<contract>} : f32
+// CHECK-DAG: %[[REAL_SQ:.*]] = llvm.fmul %[[REAL]], %[[REAL]] fastmath<contract> : f32
+// CHECK-DAG: %[[IMAG_SQ:.*]] = llvm.fmul %[[IMAG]], %[[IMAG]] fastmath<contract> : f32
+// CHECK: %[[SQ_NORM:.*]] = llvm.fadd %[[REAL_SQ]], %[[IMAG_SQ]] fastmath<contract> : f32
// CHECK: %[[NORM:.*]] = llvm.intr.sqrt(%[[SQ_NORM]]) : (f32) -> f32
// CHECK: return %[[NORM]] : f32
func.func @complex_abs_with_fmf(%arg: complex<f32>) -> f32 {
diff --git a/mlir/test/Conversion/GPUCommon/lower-memory-space-attrs.mlir b/mlir/test/Conversion/GPUCommon/lower-memory-space-attrs.mlir
index 771f3185904bb..0e23914979f01 100644
--- a/mlir/test/Conversion/GPUCommon/lower-memory-space-attrs.mlir
+++ b/mlir/test/Conversion/GPUCommon/lower-memory-space-attrs.mlir
@@ -64,7 +64,7 @@ gpu.module @kernel {
// NVVM: llvm.mlir.global internal @__dynamic_shmem__0() {addr_space = 3 : i32, alignment = 16 : i64} : !llvm.array<0 x i8>
// CHECK-LABEL: llvm.func @dynamic_shmem_with_vector
// CHECK: llvm.mlir.addressof @__dynamic_shmem__0 : !llvm.ptr<3>
-// CHECK: llvm.load %{{.*}} {alignment = 4 : i64} : !llvm.ptr<3> -> vector<1xf32>
+// CHECK: llvm.load %{{.*}} alignment = 4 : !llvm.ptr<3> -> vector<1xf32>
// CHECK: llvm.store
// -----
diff --git a/mlir/test/Conversion/GPUCommon/transfer_write.mlir b/mlir/test/Conversion/GPUCommon/transfer_write.mlir
index 4d2ae8c39240c..16fbd792efd16 100644
--- a/mlir/test/Conversion/GPUCommon/transfer_write.mlir
+++ b/mlir/test/Conversion/GPUCommon/transfer_write.mlir
@@ -4,7 +4,7 @@
// CHECK-SAME: %[[VEC:[a-zA-Z0-9_]+]]: vector<1xf32>
// CHECK:%[[BASE:[0-9]+]] = llvm.extractvalue
// CHECK:%[[PTR:[0-9]+]] = llvm.getelementptr %[[BASE]]
-// CHECK:llvm.store %[[VEC]], %[[PTR]] {alignment = 4 : i64} : vector<1xf32>, !llvm.ptr
+// CHECK:llvm.store %[[VEC]], %[[PTR]] alignment = 4 : vector<1xf32>, !llvm.ptr
func.func @warp_extract(%arg0: index, %arg1: memref<1024x1024xf32>, %arg2: vector<1xf32>) {
%c0 = arith.constant 0 : index
diff --git a/mlir/test/Conversion/MathToLLVM/math-to-llvm.mlir b/mlir/test/Conversion/MathToLLVM/math-to-llvm.mlir
index 638261bc6bde3..3cb902a64f18b 100644
--- a/mlir/test/Conversion/MathToLLVM/math-to-llvm.mlir
+++ b/mlir/test/Conversion/MathToLLVM/math-to-llvm.mlir
@@ -68,8 +68,8 @@ func.func @log1p(%arg0 : f32) {
// CHECK-SAME: f32
func.func @log1p_fmf(%arg0 : f32) {
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f32
- // CHECK: %[[ADD:.*]] = llvm.fadd %[[ONE]], %arg0 {fastmathFlags = #llvm.fastmath<fast>} : f32
- // CHECK: %[[LOG:.*]] = llvm.intr.log(%[[ADD]]) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32
+ // CHECK: %[[ADD:.*]] = llvm.fadd %[[ONE]], %arg0 fastmath<fast> : f32
+ // CHECK: %[[LOG:.*]] = llvm.intr.log(%[[ADD]]) fastmath<fast> : (f32) -> f32
%0 = math.log1p %arg0 fastmath<fast> : f32
func.return
}
@@ -93,8 +93,8 @@ func.func @log1p_2dvector(%arg0 : vector<4x3xf32>) {
func.func @log1p_2dvector_fmf(%arg0 : vector<4x3xf32>) {
// CHECK: %[[EXTRACT:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.array<4 x vector<3xf32>>
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<3xf32>) : vector<3xf32>
- // CHECK: %[[ADD:.*]] = llvm.fadd %[[ONE]], %[[EXTRACT]] {fastmathFlags = #llvm.fastmath<fast>} : vector<3xf32>
- // CHECK: %[[LOG:.*]] = llvm.intr.log(%[[ADD]]) {fastmathFlags = #llvm.fastmath<fast>} : (vector<3xf32>) -> vector<3xf32>
+ // CHECK: %[[ADD:.*]] = llvm.fadd %[[ONE]], %[[EXTRACT]] fastmath<fast> : vector<3xf32>
+ // CHECK: %[[LOG:.*]] = llvm.intr.log(%[[ADD]]) fastmath<fast> : (vector<3xf32>) -> vector<3xf32>
// CHECK: %[[INSERT:.*]] = llvm.insertvalue %[[LOG]], %{{.*}}[0] : !llvm.array<4 x vector<3xf32>>
%0 = math.log1p %arg0 fastmath<fast> : vector<4x3xf32>
func.return
@@ -143,8 +143,8 @@ func.func @expm1(%arg0 : f32) {
// CHECK-SAME: f32
func.func @expm1_fmf(%arg0 : f32) {
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f32
- // CHECK: %[[EXP:.*]] = llvm.intr.exp(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32
- // CHECK: %[[SUB:.*]] = llvm.fsub %[[EXP]], %[[ONE]] {fastmathFlags = #llvm.fastmath<fast>} : f32
+ // CHECK: %[[EXP:.*]] = llvm.intr.exp(%arg0) fastmath<fast> : (f32) -> f32
+ // CHECK: %[[SUB:.*]] = llvm.fsub %[[EXP]], %[[ONE]] fastmath<fast> : f32
%0 = math.expm1 %arg0 fastmath<fast> : f32
func.return
}
@@ -179,8 +179,8 @@ func.func @expm1_scalable_vector(%arg0 : vector<[4]xf32>) -> vector<[4]xf32> {
// CHECK-SAME: vector<4xf32>
func.func @expm1_vector_fmf(%arg0 : vector<4xf32>) {
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : vector<4xf32>
- // CHECK: %[[EXP:.*]] = llvm.intr.exp(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (vector<4xf32>) -> vector<4xf32>
- // CHECK: %[[SUB:.*]] = llvm.fsub %[[EXP]], %[[ONE]] {fastmathFlags = #llvm.fastmath<fast>} : vector<4xf32>
+ // CHECK: %[[EXP:.*]] = llvm.intr.exp(%arg0) fastmath<fast> : (vector<4xf32>) -> vector<4xf32>
+ // CHECK: %[[SUB:.*]] = llvm.fsub %[[EXP]], %[[ONE]] fastmath<fast> : vector<4xf32>
%0 = math.expm1 %arg0 fastmath<fast> : vector<4xf32>
func.return
}
@@ -306,13 +306,13 @@ func.func @atan2_vector(%arg0: vector<4xf32>, %arg1: vector<4xf32>) {
// CHECK-LABEL: func @inverse_trigonometrics_fmf
// CHECK-SAME: [[ARG0:%.+]]: f32
func.func @inverse_trigonometrics_fmf(%arg0: f32) {
- // CHECK: llvm.intr.asin([[ARG0]]) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32
+ // CHECK: llvm.intr.asin([[ARG0]]) fastmath<fast> : (f32) -> f32
%0 = math.asin %arg0 fastmath<fast> : f32
- // CHECK: llvm.intr.acos([[ARG0]]) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32
+ // CHECK: llvm.intr.acos([[ARG0]]) fastmath<fast> : (f32) -> f32
%1 = math.acos %arg0 fastmath<fast> : f32
- // CHECK: llvm.intr.atan([[ARG0]]) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32
+ // CHECK: llvm.intr.atan([[ARG0]]) fastmath<fast> : (f32) -> f32
%2 = math.atan %arg0 fastmath<fast> : f32
func.return
}
@@ -322,7 +322,7 @@ func.func @inverse_trigonometrics_fmf(%arg0: f32) {
// CHECK-LABEL: func @atan2_fmf
// CHECK-SAME: [[ARG0:%.+]]: f32, [[ARG1:%.+]]: f32
func.func @atan2_fmf(%arg0: f32, %arg1: f32) {
- // CHECK: llvm.intr.atan2([[ARG0]], [[ARG1]]) {fastmathFlags = #llvm.fastmath<fast>} : (f32, f32) -> f32
+ // CHECK: llvm.intr.atan2([[ARG0]], [[ARG1]]) fastmath<fast> : (f32, f32) -> f32
%0 = math.atan2 %arg0, %arg1 fastmath<fast> : f32
func.return
}
@@ -493,8 +493,8 @@ func.func @rsqrt_double(%arg0 : f64) {
// CHECK-SAME: f64
func.func @rsqrt_double_fmf(%arg0 : f64) {
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f64) : f64
- // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f64) -> f64
- // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] {fastmathFlags = #llvm.fastmath<fast>} : f64
+ // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%arg0) fastmath<fast> : (f64) -> f64
+ // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] fastmath<fast> : f64
%0 = math.rsqrt %arg0 fastmath<fast> : f64
func.return
}
@@ -529,8 +529,8 @@ func.func @rsqrt_scalable_vector(%arg0 : vector<[4]xf32>) -> vector<[4]xf32>{
// CHECK-SAME: vector<4xf32>
func.func @rsqrt_vector_fmf(%arg0 : vector<4xf32>) {
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : vector<4xf32>
- // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (vector<4xf32>) -> vector<4xf32>
- // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] {fastmathFlags = #llvm.fastmath<fast>} : vector<4xf32>
+ // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%arg0) fastmath<fast> : (vector<4xf32>) -> vector<4xf32>
+ // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] fastmath<fast> : vector<4xf32>
%0 = math.rsqrt %arg0 fastmath<fast> : vector<4xf32>
func.return
}
@@ -541,8 +541,8 @@ func.func @rsqrt_vector_fmf(%arg0 : vector<4xf32>) {
// CHECK-SAME: %[[VEC:.*]]: vector<[4]xf32>
func.func @rsqrt_scalable_vector_fmf(%arg0 : vector<[4]xf32>) -> vector<[4]xf32> {
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(dense<1.000000e+00> : vector<[4]xf32>) : vector<[4]xf32>
- // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%[[VEC]]) {fastmathFlags = #llvm.fastmath<fast>} : (vector<[4]xf32>) -> vector<[4]xf32>
- // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] {fastmathFlags = #llvm.fastmath<fast>} : vector<[4]xf32>
+ // CHECK: %[[SQRT:.*]] = llvm.intr.sqrt(%[[VEC]]) fastmath<fast> : (vector<[4]xf32>) -> vector<[4]xf32>
+ // CHECK: %[[DIV:.*]] = llvm.fdiv %[[ONE]], %[[SQRT]] fastmath<fast> : vector<[4]xf32>
%0 = math.rsqrt %arg0 fastmath<fast> : vector<[4]xf32>
func.return %0 : vector<[4]xf32>
}
@@ -629,13 +629,13 @@ func.func @trunc(%arg0 : f32) {
// CHECK-LABEL: func @fastmath(
// CHECK-SAME: f32
func.func @fastmath(%arg0 : f32, %arg1 : vector<4xf32>) {
- // CHECK: llvm.intr.trunc(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32
+ // CHECK: llvm.intr.trunc(%arg0) fastmath<fast> : (f32) -> f32
%0 = math.trunc %arg0 fastmath<fast> : f32
- // CHECK: llvm.intr.pow(%arg0, %arg0) {fastmathFlags = #llvm.fastmath<afn>} : (f32, f32) -> f32
+ // CHECK: llvm.intr.pow(%arg0, %arg0) fastmath<afn> : (f32, f32) -> f32
%1 = math.powf %arg0, %arg0 fastmath<afn> : f32
// CHECK: llvm.intr.sqrt(%arg0) : (f32) -> f32
%2 = math.sqrt %arg0 fastmath<none> : f32
- // CHECK: llvm.intr.fma(%arg0, %arg0, %arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32, f32, f32) -> f32
+ // CHECK: llvm.intr.fma(%arg0, %arg0, %arg0) fastmath<fast> : (f32, f32, f32) -> f32
%3 = math.fma %arg0, %arg0, %arg0 fastmath<reassoc,nnan,ninf,nsz,arcp,contract,afn> : f32
func.return
}
diff --git a/mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir b/mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir
index 9030eb3542853..5d0a81573f4da 100644
--- a/mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir
+++ b/mlir/test/Conversion/MemRefToLLVM/memref-to-llvm.mlir
@@ -808,7 +808,7 @@ func.func @extract_strided_metadata(
// CHECK-INTERFACE-LABEL: func @load_non_temporal(
func.func @load_non_temporal(%arg0 : memref<32xf32, affine_map<(d0) -> (d0)>>) {
%1 = arith.constant 7 : index
- // CHECK: llvm.load %{{.*}} {nontemporal} : !llvm.ptr -> f32
+ // CHECK: llvm.load %{{.*}} nontemporal : !llvm.ptr -> f32
// CHECK-INTERFACE: llvm.load
%2 = memref.load %arg0[%1] nontemporal(true) : memref<32xf32, affine_map<(d0) -> (d0)>>
func.return
@@ -831,7 +831,7 @@ func.func @load_invariant(%arg0 : memref<32xf32, affine_map<(d0) -> (d0)>>) {
// CHECK-LABEL: func @load_with_alignment(
// CHECK-INTERFACE-LABEL: func @load_with_alignment(
func.func @load_with_alignment(%arg0 : memref<32xf32>, %arg1 : index) {
- // CHECK: llvm.load %{{.*}} {alignment = 32 : i64} : !llvm.ptr -> f32
+ // CHECK: llvm.load %{{.*}} alignment = 32 : !llvm.ptr -> f32
// CHECK-INTERFACE: llvm.load
%1 = memref.load %arg0[%arg1] alignment(32) : memref<32xf32>
func.return
@@ -844,7 +844,7 @@ func.func @load_with_alignment(%arg0 : memref<32xf32>, %arg1 : index) {
func.func @store_non_temporal(%input : memref<32xf32, affine_map<(d0) -> (d0)>>, %output : memref<32xf32, affine_map<(d0) -> (d0)>>) {
%1 = arith.constant 7 : index
%2 = memref.load %input[%1] nontemporal(true) : memref<32xf32, affine_map<(d0) -> (d0)>>
- // CHECK: llvm.store %{{.*}}, %{{.*}} {nontemporal} : f32, !llvm.ptr
+ // CHECK: llvm.store %{{.*}}, %{{.*}} nontemporal : f32, !llvm.ptr
// CHECK-INTERFACE: llvm.store
memref.store %2, %output[%1] nontemporal(true) : memref<32xf32, affine_map<(d0) -> (d0)>>
func.return
@@ -855,7 +855,7 @@ func.func @store_non_temporal(%input : memref<32xf32, affine_map<(d0) -> (d0)>>,
// CHECK-LABEL: func @store_with_alignment(
// CHECK-INTERFACE-LABEL: func @store_with_alignment(
func.func @store_with_alignment(%arg0 : memref<32xf32>, %arg1 : f32, %arg2 : index) {
- // CHECK: llvm.store %{{.*}}, %{{.*}} {alignment = 32 : i64} : f32, !llvm.ptr
+ // CHECK: llvm.store %{{.*}}, %{{.*}} alignment = 32 : f32, !llvm.ptr
// CHECK-INTERFACE: llvm.store
memref.store %arg1, %arg0[%arg2] alignment(32) : memref<32xf32>
func.return
diff --git a/mlir/test/Conversion/SPIRVToLLVM/memory-ops-to-llvm.mlir b/mlir/test/Conversion/SPIRVToLLVM/memory-ops-to-llvm.mlir
index 803722294b316..7f17885f58834 100644
--- a/mlir/test/Conversion/SPIRVToLLVM/memory-ops-to-llvm.mlir
+++ b/mlir/test/Conversion/SPIRVToLLVM/memory-ops-to-llvm.mlir
@@ -110,7 +110,7 @@ spirv.func @load_none() "None" {
// CHECK-LABEL: @load_with_alignment
spirv.func @load_with_alignment() "None" {
%0 = spirv.Variable : !spirv.ptr<f32, Function>
- // CHECK: llvm.load %{{.*}} {alignment = 4 : i64} : !llvm.ptr -> f32
+ // CHECK: llvm.load %{{.*}} alignment = 4 : !llvm.ptr -> f32
%1 = spirv.Load "Function" %0 ["Aligned", 4] : f32
spirv.Return
}
@@ -126,7 +126,7 @@ spirv.func @load_volatile() "None" {
// CHECK-LABEL: @load_nontemporal
spirv.func @load_nontemporal() "None" {
%0 = spirv.Variable : !spirv.ptr<f32, Function>
- // CHECK: llvm.load %{{.*}} {nontemporal} : !llvm.ptr -> f32
+ // CHECK: llvm.load %{{.*}} nontemporal : !llvm.ptr -> f32
%1 = spirv.Load "Function" %0 ["Nontemporal"] : f32
spirv.Return
}
@@ -154,7 +154,7 @@ spirv.func @store_composite(%arg0 : !spirv.struct<(f64)>) "None" {
// CHECK-LABEL: @store_with_alignment
spirv.func @store_with_alignment(%arg0 : f32) "None" {
%0 = spirv.Variable : !spirv.ptr<f32, Function>
- // CHECK: llvm.store %{{.*}}, %{{.*}} {alignment = 4 : i64} : f32, !llvm.ptr
+ // CHECK: llvm.store %{{.*}}, %{{.*}} alignment = 4 : f32, !llvm.ptr
spirv.Store "Function" %0, %arg0 ["Aligned", 4] : f32
spirv.Return
}
@@ -170,7 +170,7 @@ spirv.func @store_volatile(%arg0 : f32) "None" {
// CHECK-LABEL: @store_nontemporal
spirv.func @store_nontemporal(%arg0 : f32) "None" {
%0 = spirv.Variable : !spirv.ptr<f32, Function>
- // CHECK: llvm.store %{{.*}}, %{{.*}} {nontemporal} : f32, !llvm.ptr
+ // CHECK: llvm.store %{{.*}}, %{{.*}} nontemporal : f32, !llvm.ptr
spirv.Store "Function" %0, %arg0 ["Nontemporal"] : f32
spirv.Return
}
diff --git a/mlir/test/Conversion/VectorToLLVM/use-vector-alignment.mlir b/mlir/test/Conversion/VectorToLLVM/use-vector-alignment.mlir
index 12fe3552ce1b7..d5b3b43feb19f 100644
--- a/mlir/test/Conversion/VectorToLLVM/use-vector-alignment.mlir
+++ b/mlir/test/Conversion/VectorToLLVM/use-vector-alignment.mlir
@@ -13,8 +13,8 @@ func.func @load(%base : memref<200x100xf32>, %i : index, %j : index) -> vector<8
// ALL-LABEL: func @load
-// VEC-ALIGN: llvm.load %{{.*}} {alignment = 32 : i64} : !llvm.ptr -> vector<8xf32>
-// MEMREF-ALIGN: llvm.load %{{.*}} {alignment = 4 : i64} : !llvm.ptr -> vector<8xf32>
+// VEC-ALIGN: llvm.load %{{.*}} alignment = 32 : !llvm.ptr -> vector<8xf32>
+// MEMREF-ALIGN: llvm.load %{{.*}} alignment = 4 : !llvm.ptr -> vector<8xf32>
// -----
@@ -25,8 +25,8 @@ func.func @load_with_alignment_attribute(%base : memref<200x100xf32>, %i : index
// ALL-LABEL: func @load_with_alignment_attribute
-// VEC-ALIGN: llvm.load %{{.*}} {alignment = 8 : i64} : !llvm.ptr -> vector<8xf32>
-// MEMREF-ALIGN: llvm.load %{{.*}} {alignment = 8 : i64} : !llvm.ptr -> vector<8xf32>
+// VEC-ALIGN: llvm.load %{{.*}} alignment = 8 : !llvm.ptr -> vector<8xf32>
+// MEMREF-ALIGN: llvm.load %{{.*}} alignment = 8 : !llvm.ptr -> vector<8xf32>
// -----
@@ -42,8 +42,8 @@ func.func @store(%base : memref<200x100xf32>, %i : index, %j : index) {
// ALL-LABEL: func @store
-// VEC-ALIGN: llvm.store %{{.*}}, %{{.*}} {alignment = 16 : i64} : vector<4xf32>, !llvm.ptr
-// MEMREF-ALIGN: llvm.store %{{.*}}, %{{.*}} {alignment = 4 : i64} : vector<4xf32>, !llvm.ptr
+// VEC-ALIGN: llvm.store %{{.*}}, %{{.*}} alignment = 16 : vector<4xf32>, !llvm.ptr
+// MEMREF-ALIGN: llvm.store %{{.*}}, %{{.*}} alignment = 4 : vector<4xf32>, !llvm.ptr
// -----
@@ -55,8 +55,8 @@ func.func @store_with_alignment_attribute(%base : memref<200x100xf32>, %i : inde
// ALL-LABEL: func @store_with_alignment_attribute
-// VEC-ALIGN: llvm.store %{{.*}}, %{{.*}} {alignment = 8 : i64} : vector<4xf32>, !llvm.ptr
-// MEMREF-ALIGN: llvm.store %{{.*}}, %{{.*}} {alignment = 8 : i64} : vector<4xf32>, !llvm.ptr
+// VEC-ALIGN: llvm.store %{{.*}}, %{{.*}} alignment = 8 : vector<4xf32>, !llvm.ptr
+// MEMREF-ALIGN: llvm.store %{{.*}}, %{{.*}} alignment = 8 : vector<4xf32>, !llvm.ptr
// -----
@@ -72,8 +72,8 @@ func.func @masked_load(%base: memref<?xf32>, %mask: vector<16xi1>, %passthru: ve
// ALL-LABEL: func @masked_load
-// VEC-ALIGN: %[[L:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 64 : i32} : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
-// MEMREF-ALIGN: %[[L:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 4 : i32} : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
+// VEC-ALIGN: %[[L:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} alignment = 64 : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
+// MEMREF-ALIGN: %[[L:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} alignment = 4 : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
// -----
@@ -85,8 +85,8 @@ func.func @masked_load_with_alignment_attribute(%base: memref<?xf32>, %mask: vec
// ALL-LABEL: func @masked_load_with_alignment_attribute
-// VEC-ALIGN: %[[L:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
-// MEMREF-ALIGN: %[[L:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
+// VEC-ALIGN: %[[L:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
+// MEMREF-ALIGN: %[[L:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
// -----
@@ -102,8 +102,8 @@ func.func @masked_store(%base: memref<?xf32>, %mask: vector<16xi1>, %passthru: v
// ALL-LABEL: func @masked_store
-// VEC-ALIGN: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} {alignment = 64 : i32} : vector<16xf32>, vector<16xi1> into !llvm.ptr
-// MEMREF-ALIGN: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} {alignment = 4 : i32} : vector<16xf32>, vector<16xi1> into !llvm.ptr
+// VEC-ALIGN: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} alignment = 64 : vector<16xf32>, vector<16xi1> into !llvm.ptr
+// MEMREF-ALIGN: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} alignment = 4 : vector<16xf32>, vector<16xi1> into !llvm.ptr
// -----
@@ -115,8 +115,8 @@ func.func @masked_store_with_alignment_attribute(%base: memref<?xf32>, %mask: ve
// ALL-LABEL: func @masked_store_with_alignment_attribute
-// VEC-ALIGN: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : vector<16xf32>, vector<16xi1> into !llvm.ptr
-// MEMREF-ALIGN: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : vector<16xf32>, vector<16xi1> into !llvm.ptr
+// VEC-ALIGN: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : vector<16xf32>, vector<16xi1> into !llvm.ptr
+// MEMREF-ALIGN: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : vector<16xf32>, vector<16xi1> into !llvm.ptr
// -----
@@ -132,8 +132,8 @@ func.func @scatter(%base: memref<?xf32>, %index: vector<3xi32>, %mask: vector<3x
// ALL-LABEL: func @scatter
-// VEC-ALIGN: llvm.intr.masked.scatter %{{.*}}, %{{.*}}, %{{.*}} {alignment = 16 : i32} : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>
-// MEMREF-ALIGN: llvm.intr.masked.scatter %{{.*}}, %{{.*}}, %{{.*}} {alignment = 4 : i32} : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>
+// VEC-ALIGN: llvm.intr.masked.scatter %{{.*}}, %{{.*}}, %{{.*}} alignment = 16 : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>
+// MEMREF-ALIGN: llvm.intr.masked.scatter %{{.*}}, %{{.*}}, %{{.*}} alignment = 4 : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>
// -----
@@ -145,8 +145,8 @@ func.func @scatter_with_alignment_attribute(%base: memref<?xf32>, %index: vector
// ALL-LABEL: func @scatter_with_alignment_attribute
-// VEC-ALIGN: llvm.intr.masked.scatter %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>
-// MEMREF-ALIGN: llvm.intr.masked.scatter %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>
+// VEC-ALIGN: llvm.intr.masked.scatter %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>
+// MEMREF-ALIGN: llvm.intr.masked.scatter %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>
// -----
@@ -162,8 +162,8 @@ func.func @gather(%base: memref<?xf32>, %index: vector<3xi32>, %mask: vector<3xi
// ALL-LABEL: func @gather
-// VEC-ALIGN: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 16 : i32} : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
-// MEMREF-ALIGN: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
+// VEC-ALIGN: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} alignment = 16 : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
+// MEMREF-ALIGN: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} alignment = 4 : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
// -----
@@ -175,5 +175,5 @@ func.func @gather_with_alignment_attribute(%base: memref<?xf32>, %index: vector<
// ALL-LABEL: func @gather_with_alignment_attribute
-// VEC-ALIGN: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
-// MEMREF-ALIGN: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
+// VEC-ALIGN: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
+// MEMREF-ALIGN: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
diff --git a/mlir/test/Conversion/VectorToLLVM/vector-load-store-to-llvm.mlir b/mlir/test/Conversion/VectorToLLVM/vector-load-store-to-llvm.mlir
index cab462efee2b5..962611dc987ea 100644
--- a/mlir/test/Conversion/VectorToLLVM/vector-load-store-to-llvm.mlir
+++ b/mlir/test/Conversion/VectorToLLVM/vector-load-store-to-llvm.mlir
@@ -16,7 +16,7 @@ func.func @load(%memref : memref<200x100xf32>, %i : index, %j : index) -> vector
// ALL: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}
// DEFAULT: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// INBOUNDS: %[[GEP:.*]] = llvm.getelementptr inbounds|nuw %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// ALL: llvm.load %[[GEP]] {alignment = 4 : i64} : !llvm.ptr -> vector<8xf32>
+// ALL: llvm.load %[[GEP]] alignment = 4 : !llvm.ptr -> vector<8xf32>
// -----
@@ -31,7 +31,7 @@ func.func @load_scalable(%memref : memref<200x100xf32>, %i : index, %j : index)
// ALL: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}
// DEFAULT: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// INBOUNDS: %[[GEP:.*]] = llvm.getelementptr inbounds|nuw %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// ALL: llvm.load %[[GEP]] {alignment = 4 : i64} : !llvm.ptr -> vector<[8]xf32>
+// ALL: llvm.load %[[GEP]] alignment = 4 : !llvm.ptr -> vector<[8]xf32>
// -----
@@ -46,7 +46,7 @@ func.func @load_nontemporal(%memref : memref<200x100xf32>, %i : index, %j : inde
// ALL: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}
// DEFAULT: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// INBOUNDS: %[[GEP:.*]] = llvm.getelementptr inbounds|nuw %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// ALL: llvm.load %[[GEP]] {alignment = 4 : i64, nontemporal} : !llvm.ptr -> vector<8xf32>
+// ALL: llvm.load %[[GEP]] nontemporal alignment = 4 : !llvm.ptr -> vector<8xf32>
// -----
@@ -61,7 +61,7 @@ func.func @load_nontemporal_scalable(%memref : memref<200x100xf32>, %i : index,
// ALL: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}
// DEFAULT: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// INBOUNDS: %[[GEP:.*]] = llvm.getelementptr inbounds|nuw %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// ALL: llvm.load %[[GEP]] {alignment = 4 : i64, nontemporal} : !llvm.ptr -> vector<[8]xf32>
+// ALL: llvm.load %[[GEP]] nontemporal alignment = 4 : !llvm.ptr -> vector<[8]xf32>
// -----
@@ -70,7 +70,7 @@ func.func @load_index(%memref : memref<200x100xindex>, %i : index, %j : index) -
return %0 : vector<8xindex>
}
// ALL-LABEL: func @load_index
-// ALL: %[[T0:.*]] = llvm.load %{{.*}} {alignment = 8 : i64} : !llvm.ptr -> vector<8xi64>
+// ALL: %[[T0:.*]] = llvm.load %{{.*}} alignment = 8 : !llvm.ptr -> vector<8xi64>
// ALL: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<8xi64> to vector<8xindex>
// ALL: return %[[T1]] : vector<8xindex>
@@ -81,7 +81,7 @@ func.func @load_index_scalable(%memref : memref<200x100xindex>, %i : index, %j :
return %0 : vector<[8]xindex>
}
// ALL-LABEL: func @load_index_scalable
-// ALL: %[[T0:.*]] = llvm.load %{{.*}} {alignment = 8 : i64} : !llvm.ptr -> vector<[8]xi64>
+// ALL: %[[T0:.*]] = llvm.load %{{.*}} alignment = 8 : !llvm.ptr -> vector<[8]xi64>
// ALL: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<[8]xi64> to vector<[8]xindex>
// ALL: return %[[T1]] : vector<[8]xindex>
@@ -102,7 +102,7 @@ func.func @load_0d(%memref : memref<200x100xf32>, %i : index, %j : index) -> vec
// ALL: %[[ADD:.*]] = llvm.add %[[MUL]], %[[J]]
// DEFAULT: %[[ADDR:.*]] = llvm.getelementptr %[[REF]][%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// INBOUNDS: %[[ADDR:.*]] = llvm.getelementptr inbounds|nuw %[[REF]][%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// ALL: %[[LOAD:.*]] = llvm.load %[[ADDR]] {alignment = 4 : i64} : !llvm.ptr -> vector<1xf32>
+// ALL: %[[LOAD:.*]] = llvm.load %[[ADDR]] alignment = 4 : !llvm.ptr -> vector<1xf32>
// ALL: %[[RES:.*]] = builtin.unrealized_conversion_cast %[[LOAD]] : vector<1xf32> to vector<f32>
// ALL: return %[[RES]] : vector<f32>
@@ -114,7 +114,7 @@ func.func @load_with_alignment(%memref : memref<200x100xf32>, %i : index, %j : i
}
// ALL-LABEL: func @load_with_alignment
-// ALL: llvm.load {{.*}} {alignment = 8 : i64} : !llvm.ptr -> vector<8xf32>
+// ALL: llvm.load {{.*}} alignment = 8 : !llvm.ptr -> vector<8xf32>
// -----
@@ -134,7 +134,7 @@ func.func @store(%memref : memref<200x100xf32>, %i : index, %j : index) {
// ALL: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}
// DEFAULT: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// INBOUNDS: %[[GEP:.*]] = llvm.getelementptr inbounds|nuw %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// ALL: llvm.store %{{.*}}, %[[GEP]] {alignment = 4 : i64} : vector<4xf32>, !llvm.ptr
+// ALL: llvm.store %{{.*}}, %[[GEP]] alignment = 4 : vector<4xf32>, !llvm.ptr
// -----
@@ -150,7 +150,7 @@ func.func @store_scalable(%memref : memref<200x100xf32>, %i : index, %j : index)
// ALL: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}
// DEFAULT: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// INBOUNDS: %[[GEP:.*]] = llvm.getelementptr inbounds|nuw %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// ALL: llvm.store %{{.*}}, %[[GEP]] {alignment = 4 : i64} : vector<[4]xf32>, !llvm.ptr
+// ALL: llvm.store %{{.*}}, %[[GEP]] alignment = 4 : vector<[4]xf32>, !llvm.ptr
// -----
@@ -166,7 +166,7 @@ func.func @store_nontemporal(%memref : memref<200x100xf32>, %i : index, %j : ind
// ALL: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}
// DEFAULT: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// INBOUNDS: %[[GEP:.*]] = llvm.getelementptr inbounds|nuw %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// ALL: llvm.store %{{.*}}, %[[GEP]] {alignment = 4 : i64, nontemporal} : vector<4xf32>, !llvm.ptr
+// ALL: llvm.store %{{.*}}, %[[GEP]] nontemporal alignment = 4 : vector<4xf32>, !llvm.ptr
// -----
@@ -182,7 +182,7 @@ func.func @store_nontemporal_scalable(%memref : memref<200x100xf32>, %i : index,
// ALL: %[[ADD:.*]] = llvm.add %[[MUL]], %{{.*}}
// DEFAULT: %[[GEP:.*]] = llvm.getelementptr %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// INBOUNDS: %[[GEP:.*]] = llvm.getelementptr inbounds|nuw %{{.*}}[%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// ALL: llvm.store %{{.*}}, %[[GEP]] {alignment = 4 : i64, nontemporal} : vector<[4]xf32>, !llvm.ptr
+// ALL: llvm.store %{{.*}}, %[[GEP]] nontemporal alignment = 4 : vector<[4]xf32>, !llvm.ptr
// -----
@@ -192,7 +192,7 @@ func.func @store_index(%memref : memref<200x100xindex>, %i : index, %j : index)
return
}
// ALL-LABEL: func @store_index
-// ALL: llvm.store %{{.*}}, %{{.*}} {alignment = 8 : i64} : vector<4xi64>, !llvm.ptr
+// ALL: llvm.store %{{.*}}, %{{.*}} alignment = 8 : vector<4xi64>, !llvm.ptr
// -----
@@ -202,7 +202,7 @@ func.func @store_index_scalable(%memref : memref<200x100xindex>, %i : index, %j
return
}
// ALL-LABEL: func @store_index_scalable
-// ALL: llvm.store %{{.*}}, %{{.*}} {alignment = 8 : i64} : vector<[4]xi64>, !llvm.ptr
+// ALL: llvm.store %{{.*}}, %{{.*}} alignment = 8 : vector<[4]xi64>, !llvm.ptr
// -----
@@ -224,7 +224,7 @@ func.func @store_0d(%memref : memref<200x100xf32>, %i : index, %j : index) {
// ALL: %[[ADD:.*]] = llvm.add %[[MUL]], %[[J]]
// DEFAULT: %[[ADDR:.*]] = llvm.getelementptr %[[REF]][%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// INBOUNDS: %[[ADDR:.*]] = llvm.getelementptr inbounds|nuw %[[REF]][%[[ADD]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// ALL: llvm.store %[[VAL]], %[[ADDR]] {alignment = 4 : i64} : vector<1xf32>, !llvm.ptr
+// ALL: llvm.store %[[VAL]], %[[ADDR]] alignment = 4 : vector<1xf32>, !llvm.ptr
// ALL: return
// -----
@@ -235,4 +235,4 @@ func.func @store_with_alignment(%memref : memref<200x100xf32>, %i : index, %j :
}
// ALL-LABEL: func @store_with_alignment
-// ALL: llvm.store %{{.*}} {alignment = 8 : i64} : vector<4xf32>, !llvm.ptr
+// ALL: llvm.store %{{.*}} alignment = 8 : vector<4xf32>, !llvm.ptr
diff --git a/mlir/test/Conversion/VectorToLLVM/vector-reduction-to-llvm.mlir b/mlir/test/Conversion/VectorToLLVM/vector-reduction-to-llvm.mlir
index c7d9e22fb2423..6681c1ca6f49d 100644
--- a/mlir/test/Conversion/VectorToLLVM/vector-reduction-to-llvm.mlir
+++ b/mlir/test/Conversion/VectorToLLVM/vector-reduction-to-llvm.mlir
@@ -4,15 +4,15 @@
// CHECK-LABEL: @reduce_add_f32(
// CHECK-SAME: %[[A:.*]]: vector<16xf32>)
// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
-// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
-// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<16xf32>) -> f32
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fadd(%[[C]], %[[A]])
+// CHECK-SAME: : (f32, vector<16xf32>) -> f32
// CHECK: return %[[V]] : f32
//
// REASSOC-LABEL: @reduce_add_f32(
// REASSOC-SAME: %[[A:.*]]: vector<16xf32>)
// REASSOC: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
-// REASSOC: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
-// REASSOC-SAME: <{fastmathFlags = #llvm.fastmath<reassoc>}> : (f32, vector<16xf32>) -> f32
+// REASSOC: %[[V:.*]] = llvm.intr.vector.reduce.fadd(%[[C]], %[[A]])
+// REASSOC-SAME: fastmath<reassoc> : (f32, vector<16xf32>) -> f32
// REASSOC: return %[[V]] : f32
//
func.func @reduce_add_f32(%arg0: vector<16xf32>) -> f32 {
@@ -25,17 +25,17 @@ func.func @reduce_add_f32(%arg0: vector<16xf32>) -> f32 {
// CHECK-LABEL: @reduce_add_f32_always_reassoc(
// CHECK-SAME: %[[A:.*]]: vector<16xf32>)
// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
-// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fadd(%[[C]], %[[A]])
/// Note: the reassoc flag remains even though the pass sets reassociate-fp-reduction to false.
/// Ponder whether this flag really is a property of the pass / pattern..
-// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<reassoc>}> : (f32, vector<16xf32>) -> f32
+// CHECK-SAME: fastmath<reassoc> : (f32, vector<16xf32>) -> f32
// CHECK: return %[[V]] : f32
//
// REASSOC-LABEL: @reduce_add_f32_always_reassoc(
// REASSOC-SAME: %[[A:.*]]: vector<16xf32>)
// REASSOC: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
-// REASSOC: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
-// REASSOC-SAME: <{fastmathFlags = #llvm.fastmath<reassoc>}> : (f32, vector<16xf32>) -> f32
+// REASSOC: %[[V:.*]] = llvm.intr.vector.reduce.fadd(%[[C]], %[[A]])
+// REASSOC-SAME: fastmath<reassoc> : (f32, vector<16xf32>) -> f32
// REASSOC: return %[[V]] : f32
//
func.func @reduce_add_f32_always_reassoc(%arg0: vector<16xf32>) -> f32 {
@@ -48,15 +48,15 @@ func.func @reduce_add_f32_always_reassoc(%arg0: vector<16xf32>) -> f32 {
// CHECK-LABEL: @reduce_mul_f32(
// CHECK-SAME: %[[A:.*]]: vector<16xf32>)
// CHECK: %[[C:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f32
-// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fmul"(%[[C]], %[[A]])
-// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<nnan, ninf>}> : (f32, vector<16xf32>) -> f32
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmul(%[[C]], %[[A]])
+// CHECK-SAME: fastmath<nnan, ninf> : (f32, vector<16xf32>) -> f32
// CHECK: return %[[V]] : f32
//
// REASSOC-LABEL: @reduce_mul_f32(
// REASSOC-SAME: %[[A:.*]]: vector<16xf32>)
// REASSOC: %[[C:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f32
-// REASSOC: %[[V:.*]] = "llvm.intr.vector.reduce.fmul"(%[[C]], %[[A]])
-// REASSOC-SAME: <{fastmathFlags = #llvm.fastmath<nnan, ninf, reassoc>}> : (f32, vector<16xf32>) -> f32
+// REASSOC: %[[V:.*]] = llvm.intr.vector.reduce.fmul(%[[C]], %[[A]])
+// REASSOC-SAME: fastmath<nnan, ninf, reassoc> : (f32, vector<16xf32>) -> f32
// REASSOC: return %[[V]] : f32
//
func.func @reduce_mul_f32(%arg0: vector<16xf32>) -> f32 {
@@ -390,4 +390,3 @@ func.func @masked_reduce_xor_i8_scalable(%arg0: vector<[32]xi8>, %mask : vector<
// CHECK: %[[VL_MUL:.*]] = arith.muli %[[VL_BASE]], %[[CAST_I32]] : i32
// CHECK: "llvm.intr.vp.reduce.xor"(%[[NEUTRAL]], %[[INPUT]], %[[MASK]], %[[VL_MUL]]) : (i8, vector<[32]xi8>, vector<[32]xi1>, i32) -> i8
-
diff --git a/mlir/test/Conversion/VectorToLLVM/vector-to-llvm-interface.mlir b/mlir/test/Conversion/VectorToLLVM/vector-to-llvm-interface.mlir
index 4cbea04e8076e..07f4b5629829b 100644
--- a/mlir/test/Conversion/VectorToLLVM/vector-to-llvm-interface.mlir
+++ b/mlir/test/Conversion/VectorToLLVM/vector-to-llvm-interface.mlir
@@ -890,8 +890,7 @@ func.func @reduce_0d_f32(%arg0: vector<f32>) -> f32 {
// CHECK-SAME: %[[A:.*]]: vector<f32>)
// CHECK: %[[CA:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<f32> to vector<1xf32>
// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
-// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[CA]])
-// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<1xf32>) -> f32
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fadd(%[[C]], %[[CA]]) : (f32, vector<1xf32>) -> f32
// CHECK: return %[[V]] : f32
// -----
@@ -903,8 +902,7 @@ func.func @reduce_f16(%arg0: vector<16xf16>) -> f16 {
// CHECK-LABEL: @reduce_f16(
// CHECK-SAME: %[[A:.*]]: vector<16xf16>)
// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f16) : f16
-// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
-// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f16, vector<16xf16>) -> f16
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fadd(%[[C]], %[[A]]) : (f16, vector<16xf16>) -> f16
// CHECK: return %[[V]] : f16
// -----
@@ -916,8 +914,7 @@ func.func @reduce_f16_scalable(%arg0: vector<[16]xf16>) -> f16 {
// CHECK-LABEL: @reduce_f16_scalable(
// CHECK-SAME: %[[A:.*]]: vector<[16]xf16>)
// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f16) : f16
-// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
-// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f16, vector<[16]xf16>) -> f16
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fadd(%[[C]], %[[A]]) : (f16, vector<[16]xf16>) -> f16
// CHECK: return %[[V]] : f16
// -----
@@ -929,8 +926,7 @@ func.func @reduce_f32(%arg0: vector<16xf32>) -> f32 {
// CHECK-LABEL: @reduce_f32(
// CHECK-SAME: %[[A:.*]]: vector<16xf32>)
// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
-// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
-// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<16xf32>) -> f32
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fadd(%[[C]], %[[A]]) : (f32, vector<16xf32>) -> f32
// CHECK: return %[[V]] : f32
// -----
@@ -942,8 +938,7 @@ func.func @reduce_f32_scalable(%arg0: vector<[16]xf32>) -> f32 {
// CHECK-LABEL: @reduce_f32_scalable(
// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>)
// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
-// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
-// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<[16]xf32>) -> f32
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fadd(%[[C]], %[[A]]) : (f32, vector<[16]xf32>) -> f32
// CHECK: return %[[V]] : f32
// -----
@@ -955,8 +950,7 @@ func.func @reduce_f64(%arg0: vector<16xf64>) -> f64 {
// CHECK-LABEL: @reduce_f64(
// CHECK-SAME: %[[A:.*]]: vector<16xf64>)
// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f64) : f64
-// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
-// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f64, vector<16xf64>) -> f64
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fadd(%[[C]], %[[A]]) : (f64, vector<16xf64>) -> f64
// CHECK: return %[[V]] : f64
// -----
@@ -968,8 +962,7 @@ func.func @reduce_f64_scalable(%arg0: vector<[16]xf64>) -> f64 {
// CHECK-LABEL: @reduce_f64_scalable(
// CHECK-SAME: %[[A:.*]]: vector<[16]xf64>)
// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f64) : f64
-// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
-// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f64, vector<[16]xf64>) -> f64
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fadd(%[[C]], %[[A]]) : (f64, vector<[16]xf64>) -> f64
// CHECK: return %[[V]] : f64
// -----
@@ -1591,7 +1584,7 @@ func.func @masked_load(%arg0: memref<?xf32>, %arg1: vector<16xi1>, %arg2: vector
// CHECK: %[[CO:.*]] = arith.constant 0 : index
// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i64
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// CHECK: %[[L:.*]] = llvm.intr.masked.load %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
+// CHECK: %[[L:.*]] = llvm.intr.masked.load %[[P]], %{{.*}}, %{{.*}} alignment = 4 : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
// CHECK: return %[[L]] : vector<16xf32>
// -----
@@ -1606,7 +1599,7 @@ func.func @masked_load_scalable(%arg0: memref<?xf32>, %arg1: vector<[16]xi1>, %a
// CHECK: %[[CO:.*]] = arith.constant 0 : index
// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i64
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// CHECK: %[[L:.*]] = llvm.intr.masked.load %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (!llvm.ptr, vector<[16]xi1>, vector<[16]xf32>) -> vector<[16]xf32>
+// CHECK: %[[L:.*]] = llvm.intr.masked.load %[[P]], %{{.*}}, %{{.*}} alignment = 4 : (!llvm.ptr, vector<[16]xi1>, vector<[16]xf32>) -> vector<[16]xf32>
// CHECK: return %[[L]] : vector<[16]xf32>
// -----
@@ -1617,7 +1610,7 @@ func.func @masked_load_index(%arg0: memref<?xindex>, %arg1: vector<16xi1>, %arg2
return %0 : vector<16xindex>
}
// CHECK-LABEL: func @masked_load_index
-// CHECK: %{{.*}} = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (!llvm.ptr, vector<16xi1>, vector<16xi64>) -> vector<16xi64>
+// CHECK: %{{.*}} = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : (!llvm.ptr, vector<16xi1>, vector<16xi64>) -> vector<16xi64>
// -----
@@ -1627,7 +1620,7 @@ func.func @masked_load_index_scalable(%arg0: memref<?xindex>, %arg1: vector<[16]
return %0 : vector<[16]xindex>
}
// CHECK-LABEL: func @masked_load_index_scalable
-// CHECK: %{{.*}} = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (!llvm.ptr, vector<[16]xi1>, vector<[16]xi64>) -> vector<[16]xi64>
+// CHECK: %{{.*}} = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : (!llvm.ptr, vector<[16]xi1>, vector<[16]xi64>) -> vector<[16]xi64>
// -----
@@ -1637,7 +1630,7 @@ func.func @masked_load_with_alignment(%arg0: memref<?xf32>, %arg1: vector<16xi1>
}
// CHECK-LABEL: func @masked_load_with_alignment
-// CHECK: llvm.intr.masked.load %{{.*}} {alignment = 2 : i32} : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
+// CHECK: llvm.intr.masked.load %{{.*}} alignment = 2 : (!llvm.ptr, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
// -----
@@ -1655,7 +1648,7 @@ func.func @masked_store(%arg0: memref<?xf32>, %arg1: vector<16xi1>, %arg2: vecto
// CHECK: %[[CO:.*]] = arith.constant 0 : index
// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i64
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// CHECK: llvm.intr.masked.store %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<16xf32>, vector<16xi1> into !llvm.ptr
+// CHECK: llvm.intr.masked.store %{{.*}}, %[[P]], %{{.*}} alignment = 4 : vector<16xf32>, vector<16xi1> into !llvm.ptr
// -----
@@ -1669,7 +1662,7 @@ func.func @masked_store_scalable(%arg0: memref<?xf32>, %arg1: vector<[16]xi1>, %
// CHECK: %[[CO:.*]] = arith.constant 0 : index
// CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i64
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32
-// CHECK: llvm.intr.masked.store %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<[16]xf32>, vector<[16]xi1> into !llvm.ptr
+// CHECK: llvm.intr.masked.store %{{.*}}, %[[P]], %{{.*}} alignment = 4 : vector<[16]xf32>, vector<[16]xi1> into !llvm.ptr
// -----
@@ -1679,7 +1672,7 @@ func.func @masked_store_index(%arg0: memref<?xindex>, %arg1: vector<16xi1>, %arg
return
}
// CHECK-LABEL: func @masked_store_index
-// CHECK: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : vector<16xi64>, vector<16xi1> into !llvm.ptr
+// CHECK: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : vector<16xi64>, vector<16xi1> into !llvm.ptr
// -----
@@ -1689,7 +1682,7 @@ func.func @masked_store_index_scalable(%arg0: memref<?xindex>, %arg1: vector<[16
return
}
// CHECK-LABEL: func @masked_store_index_scalable
-// CHECK: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : vector<[16]xi64>, vector<[16]xi1> into !llvm.ptr
+// CHECK: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : vector<[16]xi64>, vector<[16]xi1> into !llvm.ptr
// -----
@@ -1699,7 +1692,7 @@ func.func @masked_store_with_alignment(%arg0: memref<?xf32>, %arg1: vector<16xi1
}
// CHECK-LABEL: func @masked_store_with_alignment
-// CHECK: llvm.intr.masked.store %{{.*}} {alignment = 2 : i32} : vector<16xf32>, vector<16xi1> into !llvm.ptr
+// CHECK: llvm.intr.masked.store %{{.*}} alignment = 2 : vector<16xf32>, vector<16xi1> into !llvm.ptr
// -----
@@ -1715,7 +1708,7 @@ func.func @gather(%arg0: memref<?xf32>, %arg1: vector<3xi32>, %arg2: vector<3xi1
// CHECK-LABEL: func @gather
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<3xi32>) -> vector<3x!llvm.ptr>, f32
-// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
+// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} alignment = 4 : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
// CHECK: return %[[G]] : vector<3xf32>
// -----
@@ -1728,7 +1721,7 @@ func.func @gather_scalable(%arg0: memref<?xf32>, %arg1: vector<[3]xi32>, %arg2:
// CHECK-LABEL: func @gather_scalable
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<[3]xi32>) -> vector<[3]x!llvm.ptr>, f32
-// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<[3]x!llvm.ptr>, vector<[3]xi1>, vector<[3]xf32>) -> vector<[3]xf32>
+// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} alignment = 4 : (vector<[3]x!llvm.ptr>, vector<[3]xi1>, vector<[3]xf32>) -> vector<[3]xf32>
// CHECK: return %[[G]] : vector<[3]xf32>
// -----
@@ -1741,7 +1734,7 @@ func.func @gather_global_memory(%arg0: memref<?xf32, 1>, %arg1: vector<3xi32>, %
// CHECK-LABEL: func @gather_global_memory
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<1>, vector<3xi32>) -> vector<3x!llvm.ptr<1>>, f32
-// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<3x!llvm.ptr<1>>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
+// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} alignment = 4 : (vector<3x!llvm.ptr<1>>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
// CHECK: return %[[G]] : vector<3xf32>
// -----
@@ -1754,7 +1747,7 @@ func.func @gather_global_memory_scalable(%arg0: memref<?xf32, 1>, %arg1: vector<
// CHECK-LABEL: func @gather_global_memory_scalable
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<1>, vector<[3]xi32>) -> vector<[3]x!llvm.ptr<1>>, f32
-// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<[3]x!llvm.ptr<1>>, vector<[3]xi1>, vector<[3]xf32>) -> vector<[3]xf32>
+// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} alignment = 4 : (vector<[3]x!llvm.ptr<1>>, vector<[3]xi1>, vector<[3]xf32>) -> vector<[3]xf32>
// CHECK: return %[[G]] : vector<[3]xf32>
// -----
@@ -1768,7 +1761,7 @@ func.func @gather_index(%arg0: memref<?xindex>, %arg1: vector<3xindex>, %arg2: v
// CHECK-LABEL: func @gather_index
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<3xi64>) -> vector<3x!llvm.ptr>, i64
-// CHECK: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xi64>) -> vector<3xi64>
+// CHECK: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xi64>) -> vector<3xi64>
// CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[G]] : vector<3xi64> to vector<3xindex>
// -----
@@ -1781,7 +1774,7 @@ func.func @gather_index_scalable(%arg0: memref<?xindex>, %arg1: vector<[3]xindex
// CHECK-LABEL: func @gather_index_scalable
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<[3]xi64>) -> vector<[3]x!llvm.ptr>, i64
-// CHECK: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (vector<[3]x!llvm.ptr>, vector<[3]xi1>, vector<[3]xi64>) -> vector<[3]xi64>
+// CHECK: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : (vector<[3]x!llvm.ptr>, vector<[3]xi1>, vector<[3]xi64>) -> vector<[3]xi64>
// CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[G]] : vector<[3]xi64> to vector<[3]xindex>
// -----
@@ -1795,7 +1788,7 @@ func.func @gather_1d_from_2d(%arg0: memref<4x4xf32>, %arg1: vector<4xi32>, %arg2
// CHECK-LABEL: func @gather_1d_from_2d
// CHECK: %[[B:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// CHECK: %[[P:.*]] = llvm.getelementptr %[[B]][%{{.*}}] : (!llvm.ptr, vector<4xi32>) -> vector<4x!llvm.ptr>, f32
-// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<4x!llvm.ptr>, vector<4xi1>, vector<4xf32>) -> vector<4xf32>
+// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} alignment = 4 : (vector<4x!llvm.ptr>, vector<4xi1>, vector<4xf32>) -> vector<4xf32>
// CHECK: return %[[G]] : vector<4xf32>
// -----
@@ -1809,7 +1802,7 @@ func.func @gather_1d_from_2d_scalable(%arg0: memref<4x?xf32>, %arg1: vector<[4]x
// CHECK-LABEL: func @gather_1d_from_2d_scalable
// CHECK: %[[B:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// CHECK: %[[P:.*]] = llvm.getelementptr %[[B]][%{{.*}}] : (!llvm.ptr, vector<[4]xi32>) -> vector<[4]x!llvm.ptr>, f32
-// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<[4]x!llvm.ptr>, vector<[4]xi1>, vector<[4]xf32>) -> vector<[4]xf32>
+// CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} alignment = 4 : (vector<[4]x!llvm.ptr>, vector<[4]xi1>, vector<[4]xf32>) -> vector<[4]xf32>
// CHECK: return %[[G]] : vector<[4]xf32>
// -----
@@ -1820,7 +1813,7 @@ func.func @gather_with_alignment(%arg0: memref<?xf32>, %arg1: vector<3xi32>, %ar
}
// CHECK-LABEL: func @gather_with_alignment
-// CHECK: llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
+// CHECK: llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
// -----
@@ -1850,7 +1843,7 @@ func.func @scatter(%arg0: memref<?xf32>, %arg1: vector<3xi32>, %arg2: vector<3xi
// CHECK-LABEL: func @scatter
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<3xi32>) -> vector<3x!llvm.ptr>, f32
-// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>
+// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} alignment = 4 : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>
// -----
@@ -1862,7 +1855,7 @@ func.func @scatter_scalable(%arg0: memref<?xf32>, %arg1: vector<[3]xi32>, %arg2:
// CHECK-LABEL: func @scatter_scalable
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<[3]xi32>) -> vector<[3]x!llvm.ptr>, f32
-// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<[3]xf32>, vector<[3]xi1> into vector<[3]x!llvm.ptr>
+// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} alignment = 4 : vector<[3]xf32>, vector<[3]xi1> into vector<[3]x!llvm.ptr>
// -----
@@ -1874,7 +1867,7 @@ func.func @scatter_index(%arg0: memref<?xindex>, %arg1: vector<3xindex>, %arg2:
// CHECK-LABEL: func @scatter_index
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<3xi64>) -> vector<3x!llvm.ptr>, i64
-// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 8 : i32} : vector<3xi64>, vector<3xi1> into vector<3x!llvm.ptr>
+// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} alignment = 8 : vector<3xi64>, vector<3xi1> into vector<3x!llvm.ptr>
// -----
@@ -1886,7 +1879,7 @@ func.func @scatter_index_scalable(%arg0: memref<?xindex>, %arg1: vector<[3]xinde
// CHECK-LABEL: func @scatter_index_scalable
// CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, vector<[3]xi64>) -> vector<[3]x!llvm.ptr>, i64
-// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 8 : i32} : vector<[3]xi64>, vector<[3]xi1> into vector<[3]x!llvm.ptr>
+// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} alignment = 8 : vector<[3]xi64>, vector<[3]xi1> into vector<[3]x!llvm.ptr>
// -----
@@ -1899,7 +1892,7 @@ func.func @scatter_1d_into_2d(%arg0: memref<4x4xf32>, %arg1: vector<4xi32>, %arg
// CHECK-LABEL: func @scatter_1d_into_2d
// CHECK: %[[B:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// CHECK: %[[P:.*]] = llvm.getelementptr %[[B]][%{{.*}}] : (!llvm.ptr, vector<4xi32>) -> vector<4x!llvm.ptr>, f32
-// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<4xf32>, vector<4xi1> into vector<4x!llvm.ptr>
+// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} alignment = 4 : vector<4xf32>, vector<4xi1> into vector<4x!llvm.ptr>
// -----
@@ -1912,7 +1905,7 @@ func.func @scatter_1d_into_2d_scalable(%arg0: memref<4x?xf32>, %arg1: vector<[4]
// CHECK-LABEL: func @scatter_1d_into_2d_scalable
// CHECK: %[[B:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr, i64) -> !llvm.ptr, f32
// CHECK: %[[P:.*]] = llvm.getelementptr %[[B]][%{{.*}}] : (!llvm.ptr, vector<[4]xi32>) -> vector<[4]x!llvm.ptr>, f32
-// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<[4]xf32>, vector<[4]xi1> into vector<[4]x!llvm.ptr>
+// CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} alignment = 4 : vector<[4]xf32>, vector<[4]xi1> into vector<[4]x!llvm.ptr>
// -----
@@ -1922,7 +1915,7 @@ func.func @scatter_with_alignment(%arg0: memref<?xf32>, %arg1: vector<3xi32>, %a
}
// CHECK-LABEL: func @scatter_with_alignment
-// CHECK: llvm.intr.masked.scatter %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>
+// CHECK: llvm.intr.masked.scatter %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 : vector<3xf32>, vector<3xi1> into vector<3x!llvm.ptr>
// -----
diff --git a/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir b/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir
index 094353119e493..304904ac958f6 100644
--- a/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir
+++ b/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir
@@ -1606,8 +1606,8 @@ func.func @gather_with_mask(%arg0: memref<?xf32>, %arg1: vector<2x3xi32>, %arg2:
}
// CHECK-LABEL: func @gather_with_mask
-// CHECK: %[[G0:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
-// CHECK: %[[G1:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
+// CHECK: %[[G0:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} alignment = 4 : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
+// CHECK: %[[G1:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} alignment = 4 : (vector<3x!llvm.ptr>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
// -----
@@ -1622,8 +1622,8 @@ func.func @gather_with_mask_scalable(%arg0: memref<?xf32>, %arg1: vector<2x[3]xi
}
// CHECK-LABEL: func @gather_with_mask_scalable
-// CHECK: %[[G0:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<[3]x!llvm.ptr>, vector<[3]xi1>, vector<[3]xf32>) -> vector<[3]xf32>
-// CHECK: %[[G1:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 4 : i32} : (vector<[3]x!llvm.ptr>, vector<[3]xi1>, vector<[3]xf32>) -> vector<[3]xf32>
+// CHECK: %[[G0:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} alignment = 4 : (vector<[3]x!llvm.ptr>, vector<[3]xi1>, vector<[3]xf32>) -> vector<[3]xf32>
+// CHECK: %[[G1:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} alignment = 4 : (vector<[3]x!llvm.ptr>, vector<[3]xi1>, vector<[3]xf32>) -> vector<[3]xf32>
// -----
diff --git a/mlir/test/Conversion/VectorToLLVM/vector-xfer-to-llvm.mlir b/mlir/test/Conversion/VectorToLLVM/vector-xfer-to-llvm.mlir
index 18deadd0d7a79..19b5fe4fac9dd 100644
--- a/mlir/test/Conversion/VectorToLLVM/vector-xfer-to-llvm.mlir
+++ b/mlir/test/Conversion/VectorToLLVM/vector-xfer-to-llvm.mlir
@@ -41,7 +41,7 @@ func.func @transfer_read_write_1d(%A : memref<?xf32>, %base: index) -> vector<17
//
// 6. Rewrite as a masked read.
// CHECK: %[[loaded:.*]] = llvm.intr.masked.load %[[gep]], %[[mask]],
-// CHECK-SAME: %[[PASS_THROUGH]] {alignment = 4 : i32} :
+// CHECK-SAME: %[[PASS_THROUGH]] alignment = 4 :
// CHECK-SAME: -> vector<17xf32>
//
// 1. Let dim be the memref dimension, compute the in-bound index (dim - offset)
@@ -62,7 +62,7 @@ func.func @transfer_read_write_1d(%A : memref<?xf32>, %base: index) -> vector<17
//
// 4. Rewrite as a masked write.
// CHECK: llvm.intr.masked.store %[[loaded]], %[[gep_b]], %[[mask_b]]
-// CHECK-SAME: {alignment = 4 : i32} :
+// CHECK-SAME: alignment = 4 :
// CHECK-SAME: vector<17xf32>, vector<17xi1> into !llvm.ptr
func.func @transfer_read_write_1d_scalable(%A : memref<?xf32>, %base: index) -> vector<[17]xf32> {
@@ -105,7 +105,7 @@ func.func @transfer_read_write_1d_scalable(%A : memref<?xf32>, %base: index) ->
//
// 6. Rewrite as a masked read.
// CHECK: %[[loaded:.*]] = llvm.intr.masked.load %[[gep]], %[[mask]],
-// CHECK-SAME: %[[PASS_THROUGH]] {alignment = 4 : i32} :
+// CHECK-SAME: %[[PASS_THROUGH]] alignment = 4 :
// CHECK-SAME: -> vector<[17]xf32>
//
// 1. Let dim be the memref dimension, compute the in-bound index (dim - offset)
@@ -129,7 +129,7 @@ func.func @transfer_read_write_1d_scalable(%A : memref<?xf32>, %base: index) ->
//
// 5. Rewrite as a masked write.
// CHECK: llvm.intr.masked.store %[[loaded]], %[[gep_b]], %[[mask_b]]
-// CHECK-SAME: {alignment = 4 : i32} :
+// CHECK-SAME: alignment = 4 :
// CHECK-SAME: vector<[17]xf32>, vector<[17]xi1> into !llvm.ptr
// -----
@@ -149,10 +149,10 @@ func.func @transfer_read_write_index_1d(%A : memref<?xindex>, %base: index) -> v
// CHECK: %[[SPLAT:.*]] = arith.constant dense<7> : vector<17xindex>
// CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[SPLAT]] : vector<17xindex> to vector<17xi64>
-// CHECK: %[[loaded:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} :
+// CHECK: %[[loaded:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 :
// CHECK-SAME: (!llvm.ptr, vector<17xi1>, vector<17xi64>) -> vector<17xi64>
-// CHECK: llvm.intr.masked.store %[[loaded]], %{{.*}}, %{{.*}} {alignment = 8 : i32} :
+// CHECK: llvm.intr.masked.store %[[loaded]], %{{.*}}, %{{.*}} alignment = 8 :
// CHECK-SAME: vector<17xi64>, vector<17xi1> into !llvm.ptr
func.func @transfer_read_write_index_1d_scalable(%A : memref<?xindex>, %base: index) -> vector<[17]xindex> {
@@ -170,10 +170,10 @@ func.func @transfer_read_write_index_1d_scalable(%A : memref<?xindex>, %base: in
// CHECK: %[[SPLAT:.*]] = arith.constant dense<7> : vector<[17]xindex>
// CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[SPLAT]] : vector<[17]xindex> to vector<[17]xi64>
-// CHECK: %[[loaded:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} :
+// CHECK: %[[loaded:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} alignment = 8 :
// CHECK-SAME: (!llvm.ptr, vector<[17]xi1>, vector<[17]xi64>) -> vector<[17]xi64>
-// CHECK: llvm.intr.masked.store %[[loaded]], %{{.*}}, %{{.*}} {alignment = 8 : i32} :
+// CHECK: llvm.intr.masked.store %[[loaded]], %{{.*}}, %{{.*}} alignment = 8 :
// CHECK-SAME: vector<[17]xi64>, vector<[17]xi1> into !llvm.ptr
// -----
@@ -302,7 +302,7 @@ func.func @transfer_read_1d_inbounds(%A : memref<?xf32>, %base: index) -> vector
// CHECK-SAME: (!llvm.ptr, i64) -> !llvm.ptr, f32
//
// 2. Rewrite as a load.
-// CHECK: %[[loaded:.*]] = llvm.load %[[gep]] {alignment = 4 : i64} : !llvm.ptr -> vector<17xf32>
+// CHECK: %[[loaded:.*]] = llvm.load %[[gep]] alignment = 4 : !llvm.ptr -> vector<17xf32>
func.func @transfer_read_1d_inbounds_scalable(%A : memref<?xf32>, %base: index) -> vector<[17]xf32> {
%f7 = arith.constant 7.0: f32
@@ -318,7 +318,7 @@ func.func @transfer_read_1d_inbounds_scalable(%A : memref<?xf32>, %base: index)
// CHECK-SAME: (!llvm.ptr, i64) -> !llvm.ptr, f32
//
// 2. Rewrite as a load.
-// CHECK: %[[loaded:.*]] = llvm.load %[[gep]] {alignment = 4 : i64} : !llvm.ptr -> vector<[17]xf32>
+// CHECK: %[[loaded:.*]] = llvm.load %[[gep]] alignment = 4 : !llvm.ptr -> vector<[17]xf32>
// -----
diff --git a/mlir/test/Dialect/LLVMIR/bytecode.mlir b/mlir/test/Dialect/LLVMIR/bytecode.mlir
index 02409c8adab94..a6f92e35f4dd8 100644
--- a/mlir/test/Dialect/LLVMIR/bytecode.mlir
+++ b/mlir/test/Dialect/LLVMIR/bytecode.mlir
@@ -13,7 +13,7 @@ module {
llvm.return loc(#loc2)
} loc(#loc8)
llvm.func @loop_annotation_with_locs() {
- llvm.br ^bb1 {loop_annotation = #loop_annotation} loc(#loc4)
+ llvm.br ^bb1 loop_annotation = #loop_annotation loc(#loc4)
^bb1: // pred: ^bb0
llvm.return loc(#loc5)
} loc(#loc3)
diff --git a/mlir/test/Dialect/LLVMIR/canonicalize.mlir b/mlir/test/Dialect/LLVMIR/canonicalize.mlir
index 11e28d52355cd..7674b2c98f277 100644
--- a/mlir/test/Dialect/LLVMIR/canonicalize.mlir
+++ b/mlir/test/Dialect/LLVMIR/canonicalize.mlir
@@ -434,10 +434,10 @@ llvm.func @volatile_load(%x : !llvm.ptr) {
%0 = llvm.load volatile %x : !llvm.ptr -> i8
// Same with monotonic atomics and any stricter modes.
// CHECK: llvm.load %{{.*}} atomic monotonic
- %2 = llvm.load %x atomic monotonic { alignment = 1 } : !llvm.ptr -> i8
+ %2 = llvm.load %x atomic monotonic alignment = 1 : !llvm.ptr -> i8
// But not unordered!
// CHECK-NOT: llvm.load %{{.*}} atomic unordered
- %3 = llvm.load %x atomic unordered { alignment = 1 } : !llvm.ptr -> i8
+ %3 = llvm.load %x atomic unordered alignment = 1 : !llvm.ptr -> i8
llvm.return
}
diff --git a/mlir/test/Dialect/LLVMIR/dereferenceable-invalid.mlir b/mlir/test/Dialect/LLVMIR/dereferenceable-invalid.mlir
index f2129b7b00d02..cec07e0824da7 100644
--- a/mlir/test/Dialect/LLVMIR/dereferenceable-invalid.mlir
+++ b/mlir/test/Dialect/LLVMIR/dereferenceable-invalid.mlir
@@ -2,6 +2,6 @@
llvm.func @deref(%arg0: !llvm.ptr) {
// expected-error @below {{op expected op to return a single LLVM pointer type}}
- %0 = llvm.load %arg0 dereferenceable<bytes = 8> {alignment = 8 : i64} : !llvm.ptr -> i64
+ %0 = llvm.load %arg0 dereferenceable<bytes = 8> alignment = 8 : !llvm.ptr -> i64
llvm.return
}
diff --git a/mlir/test/Dialect/LLVMIR/ifunc.mlir b/mlir/test/Dialect/LLVMIR/ifunc.mlir
index 33e21bab0d51b..fb5ad32f22c72 100644
--- a/mlir/test/Dialect/LLVMIR/ifunc.mlir
+++ b/mlir/test/Dialect/LLVMIR/ifunc.mlir
@@ -10,8 +10,8 @@ llvm.func @resolver() -> !llvm.ptr {
// -----
-// CHECK: llvm.mlir.ifunc linkonce_odr hidden @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver {dso_local}
-llvm.mlir.ifunc linkonce_odr hidden @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver {dso_local}
+// CHECK: llvm.mlir.ifunc linkonce_odr hidden @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver dso_local
+llvm.mlir.ifunc linkonce_odr hidden @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver dso_local
llvm.func @resolver() -> !llvm.ptr {
%0 = llvm.mlir.constant(333 : i64) : i64
%1 = llvm.inttoptr %0 : i64 to !llvm.ptr
@@ -20,8 +20,8 @@ llvm.func @resolver() -> !llvm.ptr {
// -----
-// CHECK: llvm.mlir.ifunc private @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver {dso_local}
-llvm.mlir.ifunc private @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver {dso_local}
+// CHECK: llvm.mlir.ifunc private @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver dso_local
+llvm.mlir.ifunc private @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver dso_local
llvm.func @resolver() -> !llvm.ptr {
%0 = llvm.mlir.constant(333 : i64) : i64
%1 = llvm.inttoptr %0 : i64 to !llvm.ptr
diff --git a/mlir/test/Dialect/LLVMIR/inlining-alias-scopes.mlir b/mlir/test/Dialect/LLVMIR/inlining-alias-scopes.mlir
index 6b369c5012105..062cdb4cde08a 100644
--- a/mlir/test/Dialect/LLVMIR/inlining-alias-scopes.mlir
+++ b/mlir/test/Dialect/LLVMIR/inlining-alias-scopes.mlir
@@ -23,10 +23,10 @@
llvm.func @foo(%arg0: !llvm.ptr, %arg1: !llvm.ptr) {
%0 = llvm.mlir.constant(5 : i64) : i64
llvm.intr.experimental.noalias.scope.decl #alias_scope
- %2 = llvm.load %arg1 {alias_scopes = [#alias_scope], alignment = 4 : i64, noalias_scopes = [#alias_scope1]} : !llvm.ptr -> f32
+ %2 = llvm.load %arg1 alias_scopes = [#alias_scope] alignment = 4 noalias_scopes = [#alias_scope1] : !llvm.ptr -> f32
"test.one_region_op"() ({
%3 = llvm.getelementptr inbounds %arg0[%0] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %2, %3 {alias_scopes = [#alias_scope1], alignment = 4 : i64, noalias_scopes = [#alias_scope]} : f32, !llvm.ptr
+ llvm.store %2, %3 alias_scopes = [#alias_scope1] alignment = 4 noalias_scopes = [#alias_scope] : f32, !llvm.ptr
"test.terminator"() : () -> ()
}) : () -> ()
llvm.return
@@ -85,15 +85,15 @@ llvm.func @callee_with_metadata(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm
%0 = llvm.mlir.constant(5 : i64) : i64
%1 = llvm.mlir.constant(8 : i64) : i64
%2 = llvm.mlir.constant(7 : i64) : i64
- %3 = llvm.load %arg2 {alignment = 4 : i64, noalias_scopes = [#alias_scope, #alias_scope1]} : !llvm.ptr -> f32
+ %3 = llvm.load %arg2 alignment = 4 noalias_scopes = [#alias_scope, #alias_scope1] : !llvm.ptr -> f32
%4 = llvm.getelementptr inbounds %arg0[%0] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %3, %4 {alias_scopes = [#alias_scope], alignment = 4 : i64, noalias_scopes = [#alias_scope1]} : f32, !llvm.ptr
+ llvm.store %3, %4 alias_scopes = [#alias_scope] alignment = 4 noalias_scopes = [#alias_scope1] : f32, !llvm.ptr
%5 = llvm.getelementptr inbounds %arg1[%1] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %3, %5 {alias_scopes = [#alias_scope1], alignment = 4 : i64, noalias_scopes = [#alias_scope]} : f32, !llvm.ptr
+ llvm.store %3, %5 alias_scopes = [#alias_scope1] alignment = 4 noalias_scopes = [#alias_scope] : f32, !llvm.ptr
"test.one_region_op"() ({
- %6 = llvm.load %arg2 {alignment = 4 : i64} : !llvm.ptr -> f32
+ %6 = llvm.load %arg2 alignment = 4 : !llvm.ptr -> f32
%7 = llvm.getelementptr inbounds %arg0[%2] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %6, %7 {alignment = 4 : i64} : f32, !llvm.ptr
+ llvm.store %6, %7 alignment = 4 : f32, !llvm.ptr
"test.terminator"() : () -> ()
}) : () -> ()
llvm.return
@@ -106,15 +106,15 @@ llvm.func @callee_without_metadata(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !l
%0 = llvm.mlir.constant(5 : i64) : i64
%1 = llvm.mlir.constant(8 : i64) : i64
%2 = llvm.mlir.constant(7 : i64) : i64
- %3 = llvm.load %arg2 {alignment = 4 : i64} : !llvm.ptr -> f32
+ %3 = llvm.load %arg2 alignment = 4 : !llvm.ptr -> f32
%4 = llvm.getelementptr inbounds %arg0[%0] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %3, %4 {alignment = 4 : i64} : f32, !llvm.ptr
+ llvm.store %3, %4 alignment = 4 : f32, !llvm.ptr
%5 = llvm.getelementptr inbounds %arg1[%1] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %3, %5 {alignment = 4 : i64} : f32, !llvm.ptr
+ llvm.store %3, %5 alignment = 4 : f32, !llvm.ptr
"test.one_region_op"() ({
- %6 = llvm.load %arg2 {alignment = 4 : i64} : !llvm.ptr -> f32
+ %6 = llvm.load %arg2 alignment = 4 : !llvm.ptr -> f32
%7 = llvm.getelementptr inbounds %arg0[%2] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %6, %7 {alignment = 4 : i64} : f32, !llvm.ptr
+ llvm.store %6, %7 alignment = 4 : f32, !llvm.ptr
"test.terminator"() : () -> ()
}) : () -> ()
@@ -198,7 +198,7 @@ llvm.func @callee_without_metadata(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !l
// CHECK-NOT: noalias_scopes
llvm.func @caller(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr) {
- %0 = llvm.load %arg2 {alias_scopes = [#alias_scope2], alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
+ %0 = llvm.load %arg2 alias_scopes = [#alias_scope2] alignment = 8 : !llvm.ptr -> !llvm.ptr
llvm.call @callee_with_metadata(%arg0, %arg1, %0) {noalias_scopes = [#alias_scope2]} : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
llvm.call @callee_with_metadata(%arg1, %arg1, %arg0) {alias_scopes = [#alias_scope2]} : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
llvm.call @callee_without_metadata(%arg0, %arg1, %0) {noalias_scopes = [#alias_scope2]} : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
@@ -214,9 +214,9 @@ llvm.func @caller(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr) {
llvm.func @foo(%arg0: !llvm.ptr {llvm.noalias}, %arg1: !llvm.ptr {llvm.noalias}) {
%0 = llvm.mlir.constant(5 : i64) : i64
- %1 = llvm.load %arg1 {alignment = 4 : i64} : !llvm.ptr -> f32
+ %1 = llvm.load %arg1 alignment = 4 : !llvm.ptr -> f32
%2 = llvm.getelementptr inbounds %arg0[%0] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %1, %2 {alignment = 4 : i64} : f32, !llvm.ptr
+ llvm.store %1, %2 alignment = 4 : f32, !llvm.ptr
llvm.return
}
@@ -239,9 +239,9 @@ llvm.func @bar(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr) {
llvm.func @foo(%arg0: !llvm.ptr {llvm.noalias}, %arg1: !llvm.ptr) {
%0 = llvm.mlir.constant(5 : i64) : i64
- %1 = llvm.load %arg0 {alignment = 4 : i64} : !llvm.ptr -> f32
+ %1 = llvm.load %arg0 alignment = 4 : !llvm.ptr -> f32
%2 = llvm.getelementptr inbounds %arg1[%0] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %1, %2 {alignment = 4 : i64} : f32, !llvm.ptr
+ llvm.store %1, %2 alignment = 4 : f32, !llvm.ptr
llvm.return
}
diff --git a/mlir/test/Dialect/LLVMIR/inlining-loop-annotation.mlir b/mlir/test/Dialect/LLVMIR/inlining-loop-annotation.mlir
index e218c151400c7..c09f2d18bcd09 100644
--- a/mlir/test/Dialect/LLVMIR/inlining-loop-annotation.mlir
+++ b/mlir/test/Dialect/LLVMIR/inlining-loop-annotation.mlir
@@ -42,7 +42,7 @@ llvm.func @callee() {
llvm.br ^head
^head:
%c = llvm.call @cond() : () -> i1
- llvm.cond_br %c, ^head, ^exit {loop_annotation = #loopMD}
+ llvm.cond_br %c, ^head, ^exit loop_annotation = #loopMD
^exit:
llvm.return
}
@@ -50,7 +50,7 @@ llvm.func @callee() {
// CHECK: @loop_annotation
llvm.func @loop_annotation() {
// CHECK: llvm.cond_br
- // CHECK-SAME: {loop_annotation = #[[LOOP_ANNOT]]
+ // CHECK-SAME: loop_annotation = #[[LOOP_ANNOT]]
llvm.call @callee() : () -> () loc(#call_loc)
llvm.return
} loc(#caller_loc)
diff --git a/mlir/test/Dialect/LLVMIR/inlining.mlir b/mlir/test/Dialect/LLVMIR/inlining.mlir
index 85cae992f01de..7af560dd54b3d 100644
--- a/mlir/test/Dialect/LLVMIR/inlining.mlir
+++ b/mlir/test/Dialect/LLVMIR/inlining.mlir
@@ -8,8 +8,8 @@
func.func @inner_func_inlinable(%ptr : !llvm.ptr) -> i32 {
%0 = llvm.mlir.constant(42 : i32) : i32
%stack = llvm.intr.stacksave : !llvm.ptr
- llvm.store %0, %ptr { alignment = 8 } : i32, !llvm.ptr
- %1 = llvm.load %ptr { alignment = 8 } : !llvm.ptr -> i32
+ llvm.store %0, %ptr alignment = 8 : i32, !llvm.ptr
+ %1 = llvm.load %ptr alignment = 8 : !llvm.ptr -> i32
llvm.intr.dbg.value #variable = %0 : i32
llvm.intr.dbg.declare #variableAddr = %ptr : !llvm.ptr
llvm.intr.dbg.label #label
@@ -647,7 +647,7 @@ llvm.func @test_disallow_arg_attr(%ptr : !llvm.ptr) {
#caller = #llvm.access_group<id = distinct[1]<>>
llvm.func @inlinee(%ptr : !llvm.ptr) -> i32 {
- %0 = llvm.load %ptr { access_groups = [#callee] } : !llvm.ptr -> i32
+ %0 = llvm.load %ptr access_groups = [#callee] : !llvm.ptr -> i32
llvm.return %0 : i32
}
@@ -681,7 +681,7 @@ llvm.func @inlinee(%ptr : !llvm.ptr) -> i32 {
llvm.func @caller(%ptr : !llvm.ptr) -> i32 {
%c5 = llvm.mlir.constant(5 : i32) : i32
%0 = llvm.call @inlinee(%ptr) { access_groups = [#caller] } : (!llvm.ptr) -> (i32)
- llvm.store %c5, %ptr { access_groups = [#caller] } : i32, !llvm.ptr
+ llvm.store %c5, %ptr access_groups = [#caller] : i32, !llvm.ptr
llvm.return %0 : i32
}
diff --git a/mlir/test/Dialect/LLVMIR/invalid.mlir b/mlir/test/Dialect/LLVMIR/invalid.mlir
index 9fc3f769d1020..0bfeb3c9c675f 100644
--- a/mlir/test/Dialect/LLVMIR/invalid.mlir
+++ b/mlir/test/Dialect/LLVMIR/invalid.mlir
@@ -150,28 +150,28 @@ func.func @load_syncscope(%ptr : !llvm.ptr) {
func.func @load_unsupported_ordering(%ptr : !llvm.ptr) {
// expected-error at below {{unsupported ordering 'release'}}
- %1 = llvm.load %ptr atomic release {alignment = 4 : i64} : !llvm.ptr -> f32
+ %1 = llvm.load %ptr atomic release alignment = 4 : !llvm.ptr -> f32
}
// -----
func.func @load_unsupported_type(%ptr : !llvm.ptr) {
// expected-error at below {{unsupported type 'f80' for atomic access}}
- %1 = llvm.load %ptr atomic monotonic {alignment = 16 : i64} : !llvm.ptr -> f80
+ %1 = llvm.load %ptr atomic monotonic alignment = 16 : !llvm.ptr -> f80
}
// -----
func.func @load_unsupported_type(%ptr : !llvm.ptr) {
// expected-error at below {{unsupported type 'i1' for atomic access}}
- %1 = llvm.load %ptr atomic monotonic {alignment = 16 : i64} : !llvm.ptr -> i1
+ %1 = llvm.load %ptr atomic monotonic alignment = 16 : !llvm.ptr -> i1
}
// -----
func.func @load_unsupported_type(%ptr : !llvm.ptr) {
// expected-error at below {{unsupported type 'i33' for atomic access}}
- %1 = llvm.load %ptr atomic monotonic {alignment = 16 : i64} : !llvm.ptr -> i33
+ %1 = llvm.load %ptr atomic monotonic alignment = 16 : !llvm.ptr -> i33
}
// -----
@@ -192,28 +192,28 @@ func.func @store_syncscope(%val : f32, %ptr : !llvm.ptr) {
func.func @store_unsupported_ordering(%val : f32, %ptr : !llvm.ptr) {
// expected-error at below {{unsupported ordering 'acquire'}}
- llvm.store %val, %ptr atomic acquire {alignment = 4 : i64} : f32, !llvm.ptr
+ llvm.store %val, %ptr atomic acquire alignment = 4 : f32, !llvm.ptr
}
// -----
func.func @store_unsupported_type(%val : f80, %ptr : !llvm.ptr) {
// expected-error at below {{unsupported type 'f80' for atomic access}}
- llvm.store %val, %ptr atomic monotonic {alignment = 16 : i64} : f80, !llvm.ptr
+ llvm.store %val, %ptr atomic monotonic alignment = 16 : f80, !llvm.ptr
}
// -----
func.func @store_unsupported_type(%val : i1, %ptr : !llvm.ptr) {
// expected-error at below {{unsupported type 'i1' for atomic access}}
- llvm.store %val, %ptr atomic monotonic {alignment = 16 : i64} : i1, !llvm.ptr
+ llvm.store %val, %ptr atomic monotonic alignment = 16 : i1, !llvm.ptr
}
// -----
func.func @store_unsupported_type(%val : i48, %ptr : !llvm.ptr) {
// expected-error at below {{unsupported type 'i48' for atomic access}}
- llvm.store %val, %ptr atomic monotonic {alignment = 16 : i64} : i48, !llvm.ptr
+ llvm.store %val, %ptr atomic monotonic alignment = 16 : i48, !llvm.ptr
}
// -----
@@ -1025,7 +1025,7 @@ func.func @switch_wrong_number_of_weights(%arg0 : i32) {
// expected-error at +1 {{expects number of branch weights to match number of successors: 3 vs 2}}
llvm.switch %arg0 : i32, ^bb1 [
42: ^bb2(%arg0, %arg0 : i32, i32)
- ] {branch_weights = array<i32: 13, 17, 19>}
+ ] weights([13, 17, 19])
^bb1: // pred: ^bb0
llvm.return
@@ -1065,7 +1065,7 @@ llvm.mlir.global appending @non_array_type_global_appending_linkage() : i32
module {
llvm.func @accessGroups(%arg0 : !llvm.ptr) {
// expected-error at below {{attribute 'access_groups' failed to satisfy constraint: LLVM dialect access group metadata array}}
- %0 = llvm.load %arg0 { "access_groups" = [@func1] } : !llvm.ptr -> i32
+ %0 = llvm.load %arg0 access_groups = [@func1] : !llvm.ptr -> i32
llvm.return
}
llvm.func @func1() {
@@ -1078,12 +1078,9 @@ module {
module {
llvm.func @accessGroups(%arg0 : !llvm.ptr, %arg1 : i32, %arg2 : i32) {
// expected-error at below {{attribute 'access_groups' failed to satisfy constraint: LLVM dialect access group metadata array}}
- %0 = llvm.cmpxchg %arg0, %arg1, %arg2 acq_rel monotonic { "access_groups" = [@metadata::@scope] } : !llvm.ptr, i32
+ %0 = llvm.cmpxchg %arg0, %arg1, %arg2 acq_rel monotonic access_groups = ["test"] : !llvm.ptr, i32
llvm.return
}
- llvm.metadata @metadata {
- llvm.func @scope()
- }
}
// -----
@@ -1091,7 +1088,7 @@ module {
module {
llvm.func @aliasScope(%arg0 : !llvm.ptr, %arg1 : i32, %arg2 : i32) {
// expected-error at below {{attribute 'alias_scopes' failed to satisfy constraint: LLVM dialect alias scope array}}
- %0 = llvm.cmpxchg %arg0, %arg1, %arg2 acq_rel monotonic { "alias_scopes" = "test" } : !llvm.ptr, i32
+ %0 = llvm.cmpxchg %arg0, %arg1, %arg2 acq_rel monotonic alias_scopes = ["test"] : !llvm.ptr, i32
llvm.return
}
}
@@ -1101,7 +1098,7 @@ module {
module {
llvm.func @noAliasScopes(%arg0 : !llvm.ptr) {
// expected-error at below {{attribute 'noalias_scopes' failed to satisfy constraint: LLVM dialect alias scope array}}
- %0 = llvm.load %arg0 { "noalias_scopes" = "test" } : !llvm.ptr -> i32
+ %0 = llvm.load %arg0 noalias_scopes = ["test"] : !llvm.ptr -> i32
llvm.return
}
}
@@ -1489,14 +1486,14 @@ func.func @invalid_target_ext_alloca() {
func.func @invalid_target_ext_load(%arg0 : !llvm.ptr) {
// expected-error at +1 {{result #0 must be LLVM type with size, but got '!llvm.target<"no_load">'}}
- %0 = llvm.load %arg0 {alignment = 8 : i64} : !llvm.ptr -> !llvm.target<"no_load">
+ %0 = llvm.load %arg0 alignment = 8 : !llvm.ptr -> !llvm.target<"no_load">
}
// -----
func.func @invalid_target_ext_atomic(%arg0 : !llvm.ptr) {
// expected-error at +1 {{unsupported type '!llvm.target<"spirv.Event">' for atomic access}}
- %0 = llvm.load %arg0 atomic monotonic {alignment = 8 : i64} : !llvm.ptr -> !llvm.target<"spirv.Event">
+ %0 = llvm.load %arg0 atomic monotonic alignment = 8 : !llvm.ptr -> !llvm.target<"spirv.Event">
}
// -----
@@ -2096,19 +2093,19 @@ llvm.func @invalid_xevm_mma_mx(%loaded_c_casted: vector<4xf32>, %loaded_a: vecto
llvm.func external @resolve_foo() -> !llvm.ptr attributes {dso_local}
// expected-error at +1 {{'llvm.mlir.ifunc' op resolver must be a definition}}
-llvm.mlir.ifunc external @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @resolve_foo {dso_local}
+llvm.mlir.ifunc external @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @resolve_foo dso_local
// -----
llvm.mlir.global external @resolve_foo() : !llvm.ptr
// expected-error at +1 {{'llvm.mlir.ifunc' op must have a function resolver}}
-llvm.mlir.ifunc external @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @resolve_foo {dso_local}
+llvm.mlir.ifunc external @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @resolve_foo dso_local
// -----
llvm.func external @resolve_foo() -> !llvm.ptr
// expected-error at +1 {{'llvm.mlir.ifunc' op 'common' linkage not supported in ifuncs}}
-llvm.mlir.ifunc common @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @resolve_foo {dso_local}
+llvm.mlir.ifunc common @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @resolve_foo dso_local
// -----
@@ -2118,7 +2115,7 @@ llvm.mlir.alias external @alias_resolver : !llvm.ptr {
llvm.return %0 : !llvm.ptr
}
// expected-error at +1 {{'llvm.mlir.ifunc' op must have a function resolver}}
-llvm.mlir.ifunc external @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @alias_resolver {dso_local}
+llvm.mlir.ifunc external @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @alias_resolver dso_local
// -----
diff --git a/mlir/test/Dialect/LLVMIR/loop-metadata.mlir b/mlir/test/Dialect/LLVMIR/loop-metadata.mlir
index 6b4c3217d5c72..5bdafda536195 100644
--- a/mlir/test/Dialect/LLVMIR/loop-metadata.mlir
+++ b/mlir/test/Dialect/LLVMIR/loop-metadata.mlir
@@ -117,8 +117,8 @@ llvm.func @loop_annotation() {
// CHECK: llvm.func @loop_annotation_with_locs
llvm.func @loop_annotation_with_locs() {
- // CHECK: llvm.br ^bb1 {loop_annotation = #[[LOOP_ANNOT]]
- llvm.br ^bb1 {loop_annotation = #loopMD}
+ // CHECK: llvm.br ^bb1 loop_annotation = #[[LOOP_ANNOT]]
+ llvm.br ^bb1 loop_annotation = #loopMD
^bb1:
llvm.return
}
diff --git a/mlir/test/Dialect/LLVMIR/mem2reg-dbginfo.mlir b/mlir/test/Dialect/LLVMIR/mem2reg-dbginfo.mlir
index cf979ee786861..e45bd2bae71a5 100644
--- a/mlir/test/Dialect/LLVMIR/mem2reg-dbginfo.mlir
+++ b/mlir/test/Dialect/LLVMIR/mem2reg-dbginfo.mlir
@@ -17,14 +17,14 @@ llvm.func @basic_store_load(%arg0: i64) -> i64 {
// CHECK-NOT: = llvm.alloca
%1 = llvm.alloca %0 x i64 {alignment = 8 : i64} : (i32) -> !llvm.ptr
// CHECK-NOT: llvm.store
- llvm.store %arg0, %1 {alignment = 4 : i64} : i64, !llvm.ptr
+ llvm.store %arg0, %1 alignment = 4 : i64, !llvm.ptr
// CHECK-NOT: llvm.intr.dbg.declare
llvm.intr.dbg.declare #di_local_variable = %1 : !llvm.ptr
// CHECK: llvm.intr.dbg.value #[[$VAR]] = %[[LOADED:.*]] : i64
// CHECK-NOT: llvm.intr.dbg.value
// CHECK-NOT: llvm.intr.dbg.declare
// CHECK-NOT: llvm.store
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i64
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i64
// CHECK: llvm.return %[[LOADED]] : i64
llvm.return %2 : i64
}
@@ -37,7 +37,7 @@ llvm.func @multiple_store_load(%arg0: i64) -> i64 {
// CHECK-NOT: llvm.intr.dbg.declare
llvm.intr.dbg.declare #di_local_variable = %1 : !llvm.ptr
// CHECK-NOT: llvm.store
- llvm.store %arg0, %1 {alignment = 4 : i64} : i64, !llvm.ptr
+ llvm.store %arg0, %1 alignment = 4 : i64, !llvm.ptr
// CHECK-NOT: llvm.intr.dbg.declare
llvm.intr.dbg.declare #di_local_variable = %1 : !llvm.ptr
// CHECK: llvm.intr.dbg.value #[[$VAR]] = %[[LOADED:.*]] : i64
@@ -45,7 +45,7 @@ llvm.func @multiple_store_load(%arg0: i64) -> i64 {
// CHECK-NOT: llvm.intr.dbg.value
// CHECK-NOT: llvm.intr.dbg.declare
// CHECK-NOT: llvm.store
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i64
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i64
// CHECK: llvm.return %[[LOADED]] : i64
llvm.return %2 : i64
}
@@ -63,12 +63,12 @@ llvm.func @block_argument_value(%arg0: i64, %arg1: i1) -> i64 {
^bb1:
// CHECK: llvm.intr.dbg.value #[[$VAR]] = %[[ARG0]]
// CHECK-NOT: llvm.intr.dbg.value
- llvm.store %arg0, %1 {alignment = 4 : i64} : i64, !llvm.ptr
+ llvm.store %arg0, %1 alignment = 4 : i64, !llvm.ptr
llvm.br ^bb2
// CHECK: ^{{.*}}(%[[BLOCKARG:.*]]: i64):
^bb2:
// CHECK: llvm.intr.dbg.value #[[$VAR]] = %[[BLOCKARG]]
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i64
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i64
llvm.return %2 : i64
}
@@ -84,10 +84,10 @@ llvm.func @double_block_argument_value(%arg0: i64, %arg1: i1) -> i64 {
// CHECK: ^{{.*}}(%[[BLOCKARG1:.*]]: i64):
^bb1:
// CHECK: llvm.intr.dbg.value #[[$VAR]] = %[[BLOCKARG1]]
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i64
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i64
llvm.call @use(%2) : (i64) -> ()
// CHECK: llvm.intr.dbg.value #[[$VAR]] = %[[ARG0]]
- llvm.store %arg0, %1 {alignment = 4 : i64} : i64, !llvm.ptr
+ llvm.store %arg0, %1 alignment = 4 : i64, !llvm.ptr
llvm.br ^bb2
// CHECK-NOT: llvm.intr.dbg.value
// CHECK: ^{{.*}}(%[[BLOCKARG2:.*]]: i64):
@@ -163,8 +163,8 @@ llvm.func @dbg_declare_with_store_type_conversion(%val : f32) -> i32 {
%0 = llvm.mlir.constant(1 : i32) : i32
%1 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
llvm.intr.dbg.declare #di_local_variable = %1 : !llvm.ptr
- llvm.store %val, %1 {alignment = 4 : i64} : f32, !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ llvm.store %val, %1 alignment = 4 : f32, !llvm.ptr
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
llvm.return %2 : i32
}
diff --git a/mlir/test/Dialect/LLVMIR/mem2reg-intrinsics.mlir b/mlir/test/Dialect/LLVMIR/mem2reg-intrinsics.mlir
index 37c2f525a9dcb..bf474cd793b7c 100644
--- a/mlir/test/Dialect/LLVMIR/mem2reg-intrinsics.mlir
+++ b/mlir/test/Dialect/LLVMIR/mem2reg-intrinsics.mlir
@@ -16,7 +16,7 @@ llvm.func @basic_memset(%memset_value: i8) -> i32 {
// CHECK: %[[SHIFTED_16:.*]] = llvm.shl %[[VALUE_16]], %[[C16]]
// CHECK: %[[VALUE_32:.*]] = llvm.or %[[VALUE_16]], %[[SHIFTED_16]]
// CHECK-NOT: "llvm.intr.memset"
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK: llvm.return %[[VALUE_32]] : i32
llvm.return %2 : i32
}
@@ -40,7 +40,7 @@ llvm.func @memset_float(%memset_value: i8) -> f32 {
// CHECK: %[[VALUE_32:.*]] = llvm.or %[[VALUE_16]], %[[SHIFTED_16]]
// CHECK: %[[VALUE_FLOAT:.+]] = llvm.bitcast %[[VALUE_32]] : i32 to f32
// CHECK-NOT: "llvm.intr.memset"
- %load = llvm.load %alloca {alignment = 4 : i64} : !llvm.ptr -> f32
+ %load = llvm.load %alloca alignment = 4 : !llvm.ptr -> f32
// CHECK: llvm.return %[[VALUE_FLOAT]] : f32
llvm.return %load : f32
}
@@ -62,7 +62,7 @@ llvm.func @basic_memset_inline(%memset_value: i8) -> i32 {
// CHECK: %[[SHIFTED_16:.*]] = llvm.shl %[[VALUE_16]], %[[C16]]
// CHECK: %[[VALUE_32:.*]] = llvm.or %[[VALUE_16]], %[[SHIFTED_16]]
// CHECK-NOT: "llvm.intr.memset.inline"
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK: llvm.return %[[VALUE_32]] : i32
llvm.return %2 : i32
}
@@ -76,7 +76,7 @@ llvm.func @basic_memset_constant() -> i32 {
%memset_value = llvm.mlir.constant(42 : i8) : i8
%memset_len = llvm.mlir.constant(4 : i32) : i32
"llvm.intr.memset"(%1, %memset_value, %memset_len) <{isVolatile = false}> : (!llvm.ptr, i8, i32) -> ()
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK: %[[CONSTANT_VAL:..*]] = llvm.mlir.constant(707406378 : i32) : i32
// CHECK: llvm.return %[[CONSTANT_VAL]] : i32
llvm.return %2 : i32
@@ -105,7 +105,7 @@ llvm.func @basic_memset_inline_constant() -> i32 {
%1 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
%memset_value = llvm.mlir.constant(42 : i8) : i8
"llvm.intr.memset.inline"(%1, %memset_value) <{isVolatile = false, len = 4}> : (!llvm.ptr, i8) -> ()
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK: %[[CONSTANT_VAL:..*]] = llvm.mlir.constant(707406378 : i32) : i32
// CHECK: llvm.return %[[CONSTANT_VAL]] : i32
llvm.return %2 : i32
@@ -132,7 +132,7 @@ llvm.func @exotic_target_memset(%memset_value: i8) -> i40 {
// CHECK: %[[SHIFTED_COMPL:.*]] = llvm.shl %[[VALUE_32]], %[[C32]]
// CHECK: %[[VALUE_COMPL:.*]] = llvm.or %[[VALUE_32]], %[[SHIFTED_COMPL]]
// CHECK-NOT: "llvm.intr.memset"
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i40
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i40
// CHECK: llvm.return %[[VALUE_COMPL]] : i40
llvm.return %2 : i40
}
@@ -157,7 +157,7 @@ llvm.func @exotic_target_memset_inline(%memset_value: i8) -> i40 {
// CHECK: %[[SHIFTED_COMPL:.*]] = llvm.shl %[[VALUE_32]], %[[C32]]
// CHECK: %[[VALUE_COMPL:.*]] = llvm.or %[[VALUE_32]], %[[SHIFTED_COMPL]]
// CHECK-NOT: "llvm.intr.memset.inline"
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i40
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i40
// CHECK: llvm.return %[[VALUE_COMPL]] : i40
llvm.return %2 : i40
}
@@ -176,7 +176,7 @@ llvm.func @no_volatile_memset() -> i32 {
%memset_len = llvm.mlir.constant(4 : i32) : i32
// CHECK: "llvm.intr.memset"(%[[ALLOCA]], %[[MEMSET_VALUE]], %[[MEMSET_LEN]]) <{isVolatile = true}>
"llvm.intr.memset"(%1, %memset_value, %memset_len) <{isVolatile = true}> : (!llvm.ptr, i8, i32) -> ()
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
llvm.return %2 : i32
}
@@ -192,7 +192,7 @@ llvm.func @no_volatile_memset_inline() -> i32 {
%memset_value = llvm.mlir.constant(42 : i8) : i8
// CHECK: "llvm.intr.memset.inline"(%[[ALLOCA]], %[[MEMSET_VALUE]]) <{isVolatile = true, len = 4 : i64}>
"llvm.intr.memset.inline"(%1, %memset_value) <{isVolatile = true, len = 4}> : (!llvm.ptr, i8) -> ()
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
llvm.return %2 : i32
}
@@ -210,7 +210,7 @@ llvm.func @no_partial_memset() -> i32 {
%memset_len = llvm.mlir.constant(2 : i32) : i32
// CHECK: "llvm.intr.memset"(%[[ALLOCA]], %[[MEMSET_VALUE]], %[[MEMSET_LEN]]) <{isVolatile = false}>
"llvm.intr.memset"(%1, %memset_value, %memset_len) <{isVolatile = false}> : (!llvm.ptr, i8, i32) -> ()
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
llvm.return %2 : i32
}
@@ -226,7 +226,7 @@ llvm.func @no_partial_memset_inline() -> i32 {
%memset_value = llvm.mlir.constant(42 : i8) : i8
// CHECK: "llvm.intr.memset.inline"(%[[ALLOCA]], %[[MEMSET_VALUE]]) <{isVolatile = false, len = 2 : i64}>
"llvm.intr.memset.inline"(%1, %memset_value) <{isVolatile = false, len = 2}> : (!llvm.ptr, i8) -> ()
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
llvm.return %2 : i32
}
@@ -244,7 +244,7 @@ llvm.func @no_overflowing_memset() -> i32 {
%memset_len = llvm.mlir.constant(6 : i32) : i32
// CHECK: "llvm.intr.memset"(%[[ALLOCA]], %[[MEMSET_VALUE]], %[[MEMSET_LEN]]) <{isVolatile = false}>
"llvm.intr.memset"(%1, %memset_value, %memset_len) <{isVolatile = false}> : (!llvm.ptr, i8, i32) -> ()
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
llvm.return %2 : i32
}
@@ -260,7 +260,7 @@ llvm.func @no_overflowing_memset_inline() -> i32 {
%memset_value = llvm.mlir.constant(42 : i8) : i8
// CHECK: "llvm.intr.memset.inline"(%[[ALLOCA]], %[[MEMSET_VALUE]]) <{isVolatile = false, len = 6 : i64}>
"llvm.intr.memset.inline"(%1, %memset_value) <{isVolatile = false, len = 6}> : (!llvm.ptr, i8) -> ()
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
llvm.return %2 : i32
}
@@ -278,7 +278,7 @@ llvm.func @only_byte_aligned_integers_memset() -> i10 {
%memset_len = llvm.mlir.constant(2 : i32) : i32
// CHECK: "llvm.intr.memset"(%[[ALLOCA]], %[[MEMSET_VALUE]], %[[MEMSET_LEN]]) <{isVolatile = false}>
"llvm.intr.memset"(%1, %memset_value, %memset_len) <{isVolatile = false}> : (!llvm.ptr, i8, i32) -> ()
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i10
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i10
llvm.return %2 : i10
}
@@ -294,7 +294,7 @@ llvm.func @only_byte_aligned_integers_memset_inline() -> i10 {
%memset_value = llvm.mlir.constant(42 : i8) : i8
// CHECK: "llvm.intr.memset.inline"(%[[ALLOCA]], %[[MEMSET_VALUE]]) <{isVolatile = false, len = 2 : i64}>
"llvm.intr.memset.inline"(%1, %memset_value) <{isVolatile = false, len = 2}> : (!llvm.ptr, i8) -> ()
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i10
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i10
llvm.return %2 : i10
}
diff --git a/mlir/test/Dialect/LLVMIR/mem2reg.mlir b/mlir/test/Dialect/LLVMIR/mem2reg.mlir
index 5f1029625b9b4..544ceff47f104 100644
--- a/mlir/test/Dialect/LLVMIR/mem2reg.mlir
+++ b/mlir/test/Dialect/LLVMIR/mem2reg.mlir
@@ -5,7 +5,7 @@ llvm.func @default_value() -> i32 {
// CHECK: %[[UNDEF:.*]] = llvm.mlir.undef : i32
%0 = llvm.mlir.constant(1 : i32) : i32
%1 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK: llvm.return %[[UNDEF]] : i32
llvm.return %2 : i32
}
@@ -20,9 +20,9 @@ llvm.func @store_of_ptr() {
// CHECK: %[[ALLOCA:.*]] = llvm.alloca
%3 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
// CHECK: llvm.store %{{.*}}, %[[ALLOCA]]
- llvm.store %1, %3 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %1, %3 alignment = 4 : i32, !llvm.ptr
// CHECK: llvm.store %[[ALLOCA]], %{{.*}}
- llvm.store %3, %2 {alignment = 8 : i64} : !llvm.ptr, !llvm.ptr
+ llvm.store %3, %2 alignment = 8 : !llvm.ptr, !llvm.ptr
llvm.return
}
@@ -39,7 +39,7 @@ llvm.func @unreachable() {
// CHECK: ^{{.*}}:
// CHECK-NEXT: llvm.return
^bb1: // no predecessors
- llvm.store %1, %2 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %1, %2 alignment = 4 : i32, !llvm.ptr
llvm.return
}
@@ -52,14 +52,14 @@ llvm.func @unreachable_in_loop() -> i32 {
%1 = llvm.mlir.constant(6 : i32) : i32
%2 = llvm.mlir.constant(5 : i32) : i32
%3 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- llvm.store %1, %3 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %1, %3 alignment = 4 : i32, !llvm.ptr
// CHECK: llvm.br ^[[LOOP:.*]]
llvm.br ^bb1
// CHECK: ^[[LOOP]]:
^bb1: // 2 preds: ^bb0, ^bb3
// CHECK-NEXT: llvm.br ^[[ENDOFLOOP:.*]]
- llvm.store %2, %3 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %2, %3 alignment = 4 : i32, !llvm.ptr
llvm.br ^bb3
// CHECK: ^[[UNREACHABLE:.*]]:
@@ -84,12 +84,12 @@ llvm.func @branching(%arg0: i1, %arg1: i1) -> i32 {
// CHECK: llvm.cond_br %{{.*}}, ^[[BB2:.*]](%{{.*}} : i32), ^{{.*}}
llvm.cond_br %arg0, ^bb2, ^bb1
^bb1: // pred: ^bb0
- llvm.store %1, %2 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %1, %2 alignment = 4 : i32, !llvm.ptr
// CHECK: llvm.cond_br %{{.*}}, ^[[BB2]](%{{.*}} : i32), ^[[BB2]](%{{.*}} : i32)
llvm.cond_br %arg1, ^bb2, ^bb2
// CHECK: ^[[BB2]](%[[V3:.*]]: i32):
^bb2: // 3 preds: ^bb0, ^bb1, ^bb1
- %3 = llvm.load %2 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %3 = llvm.load %2 alignment = 4 : !llvm.ptr -> i32
// CHECK: llvm.return %[[V3]] : i32
llvm.return %3 : i32
}
@@ -104,12 +104,12 @@ llvm.func @recursive_alloca() -> i32 {
%2 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
%3 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
%4 = llvm.alloca %0 x !llvm.ptr {alignment = 8 : i64} : (i32) -> !llvm.ptr
- llvm.store %1, %3 {alignment = 4 : i64} : i32, !llvm.ptr
- llvm.store %3, %4 {alignment = 8 : i64} : !llvm.ptr, !llvm.ptr
- %5 = llvm.load %4 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
- %6 = llvm.load %5 {alignment = 4 : i64} : !llvm.ptr -> i32
- llvm.store %6, %2 {alignment = 4 : i64} : i32, !llvm.ptr
- %7 = llvm.load %2 {alignment = 4 : i64} : !llvm.ptr -> i32
+ llvm.store %1, %3 alignment = 4 : i32, !llvm.ptr
+ llvm.store %3, %4 alignment = 8 : !llvm.ptr, !llvm.ptr
+ %5 = llvm.load %4 alignment = 8 : !llvm.ptr -> !llvm.ptr
+ %6 = llvm.load %5 alignment = 4 : !llvm.ptr -> i32
+ llvm.store %6, %2 alignment = 4 : i32, !llvm.ptr
+ %7 = llvm.load %2 alignment = 4 : !llvm.ptr -> i32
llvm.return %7 : i32
}
@@ -123,15 +123,15 @@ llvm.func @reset_in_branch(%arg0: i32, %arg1: i1) {
%1 = llvm.mlir.constant(true) : i1
%2 = llvm.mlir.constant(false) : i1
%3 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- llvm.store %arg0, %3 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %arg0, %3 alignment = 4 : i32, !llvm.ptr
llvm.cond_br %arg1, ^bb1, ^bb2
^bb1: // pred: ^bb0
- llvm.store %arg0, %3 {alignment = 4 : i64} : i32, !llvm.ptr
- %4 = llvm.load %3 {alignment = 4 : i64} : !llvm.ptr -> i32
+ llvm.store %arg0, %3 alignment = 4 : i32, !llvm.ptr
+ %4 = llvm.load %3 alignment = 4 : !llvm.ptr -> i32
llvm.call @reset_in_branch(%4, %2) : (i32, i1) -> ()
llvm.br ^bb3
^bb2: // pred: ^bb0
- %5 = llvm.load %3 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %5 = llvm.load %3 alignment = 4 : !llvm.ptr -> i32
llvm.call @reset_in_branch(%5, %1) : (i32, i1) -> ()
llvm.br ^bb3
^bb3: // 2 preds: ^bb1, ^bb2
@@ -150,38 +150,38 @@ llvm.func @intertwined_alloca(%arg0: !llvm.ptr, %arg1: i32) {
%4 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
%5 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
%6 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- llvm.store %arg0, %2 {alignment = 8 : i64} : !llvm.ptr, !llvm.ptr
- llvm.store %arg1, %3 {alignment = 4 : i64} : i32, !llvm.ptr
- llvm.store %1, %4 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %arg0, %2 alignment = 8 : !llvm.ptr, !llvm.ptr
+ llvm.store %arg1, %3 alignment = 4 : i32, !llvm.ptr
+ llvm.store %1, %4 alignment = 4 : i32, !llvm.ptr
llvm.br ^bb1
^bb1: // 2 preds: ^bb0, ^bb4
- %7 = llvm.load %3 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %7 = llvm.load %3 alignment = 4 : !llvm.ptr -> i32
%8 = llvm.add %7, %0 : i32
- %9 = llvm.load %4 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %9 = llvm.load %4 alignment = 4 : !llvm.ptr -> i32
%10 = llvm.icmp "sgt" %8, %9 : i32
%11 = llvm.zext %10 : i1 to i32
llvm.cond_br %10, ^bb2, ^bb5
^bb2: // pred: ^bb1
- %12 = llvm.load %6 {alignment = 4 : i64} : !llvm.ptr -> i32
- llvm.store %12, %5 {alignment = 4 : i64} : i32, !llvm.ptr
- llvm.store %1, %6 {alignment = 4 : i64} : i32, !llvm.ptr
- %13 = llvm.load %4 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %12 = llvm.load %6 alignment = 4 : !llvm.ptr -> i32
+ llvm.store %12, %5 alignment = 4 : i32, !llvm.ptr
+ llvm.store %1, %6 alignment = 4 : i32, !llvm.ptr
+ %13 = llvm.load %4 alignment = 4 : !llvm.ptr -> i32
%14 = llvm.icmp "sgt" %13, %1 : i32
%15 = llvm.zext %14 : i1 to i32
llvm.cond_br %14, ^bb3, ^bb4
^bb3: // pred: ^bb2
- %16 = llvm.load %2 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
- %17 = llvm.load %4 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %16 = llvm.load %2 alignment = 8 : !llvm.ptr -> !llvm.ptr
+ %17 = llvm.load %4 alignment = 4 : !llvm.ptr -> i32
%18 = llvm.sub %17, %0 : i32
%19 = llvm.getelementptr %16[%18] : (!llvm.ptr, i32) -> !llvm.ptr, i8
- %20 = llvm.load %5 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %20 = llvm.load %5 alignment = 4 : !llvm.ptr -> i32
%21 = llvm.trunc %20 : i32 to i8
- llvm.store %21, %19 {alignment = 1 : i64} : i8, !llvm.ptr
+ llvm.store %21, %19 alignment = 1 : i8, !llvm.ptr
llvm.br ^bb4
^bb4: // 2 preds: ^bb2, ^bb3
- %22 = llvm.load %4 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %22 = llvm.load %4 alignment = 4 : !llvm.ptr -> i32
%23 = llvm.add %22, %0 : i32
- llvm.store %23, %4 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %23, %4 alignment = 4 : i32, !llvm.ptr
llvm.br ^bb1
^bb5: // pred: ^bb1
llvm.return
@@ -200,7 +200,7 @@ llvm.func @complex_cf(%arg0: i32, ...) {
^bb1: // pred: ^bb0
llvm.br ^bb2
^bb2: // 2 preds: ^bb0, ^bb1
- llvm.store %2, %3 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %2, %3 alignment = 4 : i32, !llvm.ptr
llvm.br ^bb3
^bb3: // 2 preds: ^bb2, ^bb16
llvm.cond_br %1, ^bb4, ^bb17
@@ -233,7 +233,7 @@ llvm.func @complex_cf(%arg0: i32, ...) {
^bb17: // pred: ^bb3
llvm.br ^bb20
^bb18: // no predecessors
- %4 = llvm.load %3 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %4 = llvm.load %3 alignment = 4 : !llvm.ptr -> i32
llvm.br ^bb24
^bb19: // no predecessors
llvm.br ^bb20
@@ -269,7 +269,7 @@ llvm.func @llvm_crash() -> i32 {
%6 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
%7 = llvm.bitcast %1 : i32 to i32
// CHECK: llvm.store volatile %{{.*}}, %[[VOLATILE_ALLOCA]]
- llvm.store volatile %1, %5 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store volatile %1, %5 alignment = 4 : i32, !llvm.ptr
%8 = llvm.call @_setjmp(%2) : (!llvm.ptr) -> i32
%9 = llvm.icmp "ne" %8, %1 : i32
%10 = llvm.zext %9 : i1 to i8
@@ -277,21 +277,21 @@ llvm.func @llvm_crash() -> i32 {
llvm.cond_br %11, ^bb1, ^bb2
^bb1: // pred: ^bb0
// CHECK: = llvm.load volatile %[[VOLATILE_ALLOCA]]
- %12 = llvm.load volatile %5 {alignment = 4 : i64} : !llvm.ptr -> i32
- llvm.store %12, %6 {alignment = 4 : i64} : i32, !llvm.ptr
+ %12 = llvm.load volatile %5 alignment = 4 : !llvm.ptr -> i32
+ llvm.store %12, %6 alignment = 4 : i32, !llvm.ptr
llvm.br ^bb3
^bb2: // pred: ^bb0
// CHECK: llvm.store volatile %{{.*}}, %[[VOLATILE_ALLOCA]]
- llvm.store volatile %0, %5 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store volatile %0, %5 alignment = 4 : i32, !llvm.ptr
llvm.call @g() : () -> ()
- llvm.store %1, %6 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %1, %6 alignment = 4 : i32, !llvm.ptr
llvm.br ^bb3
^bb3: // 2 preds: ^bb1, ^bb2
- %13 = llvm.load %6 {alignment = 4 : i64} : !llvm.ptr -> i32
- llvm.store %13, %4 {alignment = 4 : i64} : i32, !llvm.ptr
+ %13 = llvm.load %6 alignment = 4 : !llvm.ptr -> i32
+ llvm.store %13, %4 alignment = 4 : i32, !llvm.ptr
llvm.br ^bb4
^bb4: // pred: ^bb3
- %14 = llvm.load %4 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %14 = llvm.load %4 alignment = 4 : !llvm.ptr -> i32
llvm.return %14 : i32
}
llvm.mlir.global external @j() {addr_space = 0 : i32} : !llvm.array<1 x struct<"struct.__jmp_buf_tag", (array<6 x i32>, i32, struct<"struct.__sigset_t", (array<32 x i32>)>)>>
@@ -318,8 +318,8 @@ llvm.func @ignore_atomic(%arg0: i32) -> i32 {
// CHECK-NOT: = llvm.alloca
%0 = llvm.mlir.constant(1 : i32) : i32
%1 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- llvm.store %arg0, %1 atomic seq_cst {alignment = 4 : i64} : i32, !llvm.ptr
- %2 = llvm.load %1 atomic seq_cst {alignment = 4 : i64} : !llvm.ptr -> i32
+ llvm.store %arg0, %1 atomic seq_cst alignment = 4 : i32, !llvm.ptr
+ %2 = llvm.load %1 atomic seq_cst alignment = 4 : !llvm.ptr -> i32
// CHECK: llvm.return %[[ARG0]] : i32
llvm.return %2 : i32
}
@@ -338,12 +338,12 @@ llvm.func @landing_pad() -> i32 attributes {personality = @__gxx_personality_v0}
%2 = llvm.invoke @landing_padf() to ^bb1 unwind ^bb3 : () -> i32
// CHECK: ^{{.*}}:
^bb1:// pred: ^bb0
- llvm.store %2, %1 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %2, %1 alignment = 4 : i32, !llvm.ptr
// CHECK: llvm.br ^[[BB2:.*]](%[[V2]] : i32)
llvm.br ^bb2
// CHECK: ^[[BB2]]([[V3:.*]]: i32):
^bb2:// 2 preds: ^bb1, ^bb3
- %3 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %3 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK: llvm.return [[V3]] : i32
llvm.return %3 : i32
// CHECK: ^{{.*}}:
@@ -366,12 +366,12 @@ llvm.func @unreachable_defines() -> i32 {
%1 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
llvm.br ^bb1
^bb1: // 2 preds: ^bb0, ^bb2
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK: llvm.return %[[UNDEF]] : i32
llvm.return %2 : i32
^bb2: // no predecessors
- %3 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
- llvm.store %3, %1 {alignment = 4 : i64} : i32, !llvm.ptr
+ %3 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
+ llvm.store %3, %1 alignment = 4 : i32, !llvm.ptr
llvm.br ^bb1
}
@@ -386,15 +386,15 @@ llvm.func @unreachable_jumps_to_merge_point(%arg0: i1) -> i32 {
%3 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
llvm.cond_br %arg0, ^bb1, ^bb2
^bb1: // 2 preds: ^bb0, ^bb4
- llvm.store %1, %3 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %1, %3 alignment = 4 : i32, !llvm.ptr
llvm.br ^bb4
^bb2: // pred: ^bb0
- llvm.store %2, %3 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %2, %3 alignment = 4 : i32, !llvm.ptr
llvm.br ^bb4
^bb3: // no predecessors
llvm.br ^bb4
^bb4: // 3 preds: ^bb1, ^bb2, ^bb3
- %4 = llvm.load %3 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %4 = llvm.load %3 alignment = 4 : !llvm.ptr -> i32
llvm.return %4 : i32
}
@@ -406,7 +406,7 @@ llvm.func @ignore_lifetime() {
%0 = llvm.mlir.constant(1 : i32) : i32
%1 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
llvm.intr.lifetime.start %1 : !llvm.ptr
- llvm.store %0, %1 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %0, %1 alignment = 4 : i32, !llvm.ptr
llvm.intr.lifetime.end %1 : !llvm.ptr
llvm.return
}
@@ -437,7 +437,7 @@ llvm.func @ignore_discardable_tree() {
%6 = llvm.alloca %0 x !llvm.struct<(i8, i16)> {alignment = 8 : i64} : (i32) -> !llvm.ptr
%7 = llvm.getelementptr %6[0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(i8, i16)>
llvm.intr.lifetime.start %7 : !llvm.ptr
- llvm.store %5, %6 {alignment = 2 : i64} : !llvm.struct<(i8, i16)>, !llvm.ptr
+ llvm.store %5, %6 alignment = 2 : !llvm.struct<(i8, i16)>, !llvm.ptr
llvm.intr.lifetime.end %7 : !llvm.ptr
llvm.return
}
@@ -451,8 +451,8 @@ llvm.func @store_load_forward() -> i32 {
// CHECK: %[[RES:.*]] = llvm.mlir.constant(0 : i32) : i32
%1 = llvm.mlir.constant(0 : i32) : i32
%2 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- llvm.store %1, %2 {alignment = 4 : i64} : i32, !llvm.ptr
- %3 = llvm.load %2 {alignment = 4 : i64} : !llvm.ptr -> i32
+ llvm.store %1, %2 alignment = 4 : i32, !llvm.ptr
+ %3 = llvm.load %2 alignment = 4 : !llvm.ptr -> i32
// CHECK: llvm.return %[[RES]] : i32
llvm.return %3 : i32
}
@@ -469,12 +469,12 @@ llvm.func @merge_point_cycle() {
llvm.br ^bb1
// CHECK: ^[[BB1]](%[[BARG:.*]]: i32):
^bb1: // 2 preds: ^bb0, ^bb1
- %3 = llvm.load %2 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %3 = llvm.load %2 alignment = 4 : !llvm.ptr -> i32
// CHECK: = llvm.call @use(%[[BARG]])
%4 = llvm.call @use(%3) : (i32) -> i1
// CHECK: %[[DEF:.*]] = llvm.call @def
%5 = llvm.call @def(%1) : (i32) -> i32
- llvm.store %5, %2 {alignment = 4 : i64} : i32, !llvm.ptr
+ llvm.store %5, %2 alignment = 4 : i32, !llvm.ptr
// CHECK: llvm.cond_br %{{.*}}, ^[[BB1]](%[[DEF]] : i32), ^{{.*}}
llvm.cond_br %4, ^bb1, ^bb2
^bb2: // pred: ^bb1
@@ -495,7 +495,7 @@ llvm.func @no_unnecessary_arguments() {
llvm.br ^bb1
// CHECK: ^[[BB1]]:
^bb1: // 2 preds: ^bb0, ^bb1
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK: = llvm.call @use(%[[UNDEF]])
%3 = llvm.call @use(%2) : (i32) -> i1
// CHECK: llvm.cond_br %{{.*}}, ^[[BB1]], ^{{.*}}
@@ -592,15 +592,15 @@ llvm.func @live_cycle(%arg0: i64, %arg1: i1, %arg2: i64) -> i64 {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: = llvm.alloca
%1 = llvm.alloca %0 x i64 {alignment = 8 : i64} : (i32) -> !llvm.ptr
- llvm.store %arg2, %1 {alignment = 4 : i64} : i64, !llvm.ptr
+ llvm.store %arg2, %1 alignment = 4 : i64, !llvm.ptr
// CHECK: llvm.cond_br %{{.*}}, ^[[BB1:.*]](%[[ARG2]] : i64), ^[[BB2:.*]](%[[ARG2]] : i64)
llvm.cond_br %arg1, ^bb1, ^bb2
// CHECK: ^[[BB1]](%[[V1:.*]]: i64):
^bb1:
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i64
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i64
// CHECK: llvm.call @use(%[[V1]])
llvm.call @use(%2) : (i64) -> ()
- llvm.store %arg0, %1 {alignment = 4 : i64} : i64, !llvm.ptr
+ llvm.store %arg0, %1 alignment = 4 : i64, !llvm.ptr
// CHECK: llvm.br ^[[BB2]](%[[ARG0]] : i64)
llvm.br ^bb2
// CHECK: ^[[BB2]](%[[V2:.*]]: i64):
@@ -619,15 +619,15 @@ llvm.func @subregion_block_promotion(%arg0: i64, %arg1: i64) -> i64 {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: = llvm.alloca
%1 = llvm.alloca %0 x i64 {alignment = 8 : i64} : (i32) -> !llvm.ptr
- llvm.store %arg1, %1 {alignment = 4 : i64} : i64, !llvm.ptr
+ llvm.store %arg1, %1 alignment = 4 : i64, !llvm.ptr
// CHECK: %[[RES:.*]] = scf.execute_region -> i64 {
scf.execute_region {
- llvm.store %arg0, %1 {alignment = 4 : i64} : i64, !llvm.ptr
+ llvm.store %arg0, %1 alignment = 4 : i64, !llvm.ptr
scf.yield
}
// CHECK: scf.yield %[[ARG0]] : i64
// CHECK: }
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i64
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i64
// CHECK: llvm.return %[[RES]] : i64
llvm.return %2 : i64
}
@@ -640,8 +640,8 @@ llvm.func @subregion_simple_transitive_promotion(%arg0: i64, %arg1: i64) -> i64
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: = llvm.alloca
%1 = llvm.alloca %0 x i64 {alignment = 8 : i64} : (i32) -> !llvm.ptr
- llvm.store %arg1, %1 {alignment = 4 : i64} : i64, !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i64
+ llvm.store %arg1, %1 alignment = 4 : i64, !llvm.ptr
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i64
// CHECK: scf.execute_region {
scf.execute_region {
// CHECK: llvm.call @use(%[[ARG1]])
@@ -672,9 +672,9 @@ llvm.func @no_inner_alloca_promotion(%arg: i64) -> i64 {
// CHECK: %[[ALLOCA:.*]] = llvm.alloca
%1 = llvm.alloca %0 x i64 {alignment = 8 : i64} : (i32) -> !llvm.ptr
// CHECK: llvm.store %[[ARG]], %[[ALLOCA]]
- llvm.store %arg, %1 {alignment = 4 : i64} : i64, !llvm.ptr
+ llvm.store %arg, %1 alignment = 4 : i64, !llvm.ptr
// CHECK: %[[RES:.*]] = llvm.load %[[ALLOCA]]
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i64
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i64
// CHECK: llvm.return %[[RES]] : i64
llvm.return %2 : i64
}
@@ -686,9 +686,9 @@ llvm.func @transitive_reaching_def() -> !llvm.ptr {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: alloca
%1 = llvm.alloca %0 x !llvm.ptr {alignment = 8 : i64} : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
- llvm.store %2, %1 {alignment = 8 : i64} : !llvm.ptr, !llvm.ptr
- %3 = llvm.load %1 {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
+ %2 = llvm.load %1 alignment = 8 : !llvm.ptr -> !llvm.ptr
+ llvm.store %2, %1 alignment = 8 : !llvm.ptr, !llvm.ptr
+ %3 = llvm.load %1 alignment = 8 : !llvm.ptr -> !llvm.ptr
llvm.return %3 : !llvm.ptr
}
@@ -699,7 +699,7 @@ llvm.func @load_int_from_float() -> i32 {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: llvm.alloca
%1 = llvm.alloca %0 x f32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK: %[[UNDEF:.*]] = llvm.mlir.undef
// CHECK: %[[BITCAST:.*]] = llvm.bitcast %[[UNDEF]] : f32 to i32
// CHECK: llvm.return %[[BITCAST:.*]]
@@ -713,7 +713,7 @@ llvm.func @load_float_from_int() -> f32 {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: llvm.alloca
%1 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> f32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> f32
// CHECK: %[[UNDEF:.*]] = llvm.mlir.undef
// CHECK: %[[BITCAST:.*]] = llvm.bitcast %[[UNDEF]] : i32 to f32
// CHECK: llvm.return %[[BITCAST:.*]]
@@ -727,7 +727,7 @@ llvm.func @load_int_from_vector() -> i32 {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: llvm.alloca
%1 = llvm.alloca %0 x vector<2xi16> : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK: %[[UNDEF:.*]] = llvm.mlir.undef
// CHECK: %[[BITCAST:.*]] = llvm.bitcast %[[UNDEF]] : vector<2xi16> to i32
// CHECK: llvm.return %[[BITCAST:.*]]
@@ -743,7 +743,7 @@ llvm.func @load_int_from_array() -> i32 {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK: llvm.alloca
%1 = llvm.alloca %0 x !llvm.array<2 x i16> : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK-NOT: llvm.bitcast
llvm.return %2 : i32
}
@@ -756,8 +756,8 @@ llvm.func @store_int_to_float(%arg: i32) -> i32 {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: llvm.alloca
%1 = llvm.alloca %0 x f32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- llvm.store %arg, %1 {alignment = 4 : i64} : i32, !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ llvm.store %arg, %1 alignment = 4 : i32, !llvm.ptr
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK: llvm.return %[[ARG]]
llvm.return %2 : i32
}
@@ -770,8 +770,8 @@ llvm.func @store_float_to_int(%arg: f32) -> i32 {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: llvm.alloca
%1 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- llvm.store %arg, %1 {alignment = 4 : i64} : f32, !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i32
+ llvm.store %arg, %1 alignment = 4 : f32, !llvm.ptr
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i32
// CHECK: %[[BITCAST:.*]] = llvm.bitcast %[[ARG]] : f32 to i32
// CHECK: llvm.return %[[BITCAST]]
llvm.return %2 : i32
@@ -785,8 +785,8 @@ llvm.func @store_int_to_vector(%arg: i32) -> vector<4xi8> {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: llvm.alloca
%1 = llvm.alloca %0 x vector<2xi16> {alignment = 4 : i64} : (i32) -> !llvm.ptr
- llvm.store %arg, %1 {alignment = 4 : i64} : i32, !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> vector<4xi8>
+ llvm.store %arg, %1 alignment = 4 : i32, !llvm.ptr
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> vector<4xi8>
// CHECK: %[[BITCAST:.*]] = llvm.bitcast %[[ARG]] : i32 to vector<4xi8>
// CHECK: llvm.return %[[BITCAST]]
llvm.return %2 : vector<4xi8>
@@ -799,7 +799,7 @@ llvm.func @load_ptr_from_int() -> !llvm.ptr {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: llvm.alloca
%1 = llvm.alloca %0 x i64 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> !llvm.ptr
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> !llvm.ptr
// CHECK: %[[UNDEF:.*]] = llvm.mlir.undef
// CHECK: %[[CAST:.*]] = llvm.inttoptr %[[UNDEF]] : i64 to !llvm.ptr
// CHECK: llvm.return %[[CAST:.*]]
@@ -813,7 +813,7 @@ llvm.func @load_int_from_ptr() -> i64 {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: llvm.alloca
%1 = llvm.alloca %0 x !llvm.ptr {alignment = 4 : i64} : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i64
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i64
// CHECK: %[[UNDEF:.*]] = llvm.mlir.undef
// CHECK: %[[CAST:.*]] = llvm.ptrtoint %[[UNDEF]] : !llvm.ptr to i64
// CHECK: llvm.return %[[CAST:.*]]
@@ -827,7 +827,7 @@ llvm.func @load_ptr_addrspace_cast() -> !llvm.ptr<2> {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: llvm.alloca
%1 = llvm.alloca %0 x !llvm.ptr<1> {alignment = 4 : i64} : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> !llvm.ptr<2>
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> !llvm.ptr<2>
// CHECK: %[[UNDEF:.*]] = llvm.mlir.undef
// CHECK: %[[CAST:.*]] = llvm.addrspacecast %[[UNDEF]] : !llvm.ptr<1> to !llvm.ptr<2>
// CHECK: llvm.return %[[CAST:.*]]
@@ -845,17 +845,17 @@ llvm.func @stores_with_different_types(%arg0: i64, %arg1: f64, %cond: i1) -> f64
%1 = llvm.alloca %0 x i64 {alignment = 4 : i64} : (i32) -> !llvm.ptr
llvm.cond_br %cond, ^bb1, ^bb2
^bb1:
- llvm.store %arg0, %1 {alignment = 4 : i64} : i64, !llvm.ptr
+ llvm.store %arg0, %1 alignment = 4 : i64, !llvm.ptr
// CHECK: llvm.br ^[[BB3:.*]](%[[ARG0]]
llvm.br ^bb3
^bb2:
- llvm.store %arg1, %1 {alignment = 4 : i64} : f64, !llvm.ptr
+ llvm.store %arg1, %1 alignment = 4 : f64, !llvm.ptr
// CHECK: %[[BITCAST:.*]] = llvm.bitcast %[[ARG1]] : f64 to i64
// CHECK: llvm.br ^[[BB3]](%[[BITCAST]]
llvm.br ^bb3
// CHECK: ^[[BB3]](%[[BLOCK_ARG:.*]]: i64)
^bb3:
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> f64
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> f64
// CHECK: %[[BITCAST:.*]] = llvm.bitcast %[[BLOCK_ARG]] : i64 to f64
// CHECK: llvm.return %[[BITCAST]]
llvm.return %2 : f64
@@ -868,7 +868,7 @@ llvm.func @load_smaller_int() -> i16 {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: llvm.alloca
%1 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> i16
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> i16
llvm.return %2 : i16
}
@@ -879,7 +879,7 @@ llvm.func @load_different_type_same_size() -> f32 {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK-NOT: llvm.alloca
%1 = llvm.alloca %0 x i64 {alignment = 8 : i64} : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> f32
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> f32
llvm.return %2 : f32
}
@@ -892,7 +892,7 @@ llvm.func @impossible_load() -> f64 {
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK: llvm.alloca
%1 = llvm.alloca %0 x i32 {alignment = 4 : i64} : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> f64
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> f64
llvm.return %2 : f64
}
@@ -911,7 +911,7 @@ module attributes { dlti.dl_spec = #dlti.dl_spec<
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK: llvm.alloca
%1 = llvm.alloca %0 x !llvm.ptr<1> {alignment = 4 : i64} : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> !llvm.ptr<2>
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> !llvm.ptr<2>
llvm.return %2 : !llvm.ptr<2>
}
@@ -920,7 +920,7 @@ module attributes { dlti.dl_spec = #dlti.dl_spec<
%0 = llvm.mlir.constant(1 : i32) : i32
// CHECK: llvm.alloca
%1 = llvm.alloca %0 x !llvm.ptr<2> {alignment = 4 : i64} : (i32) -> !llvm.ptr
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> !llvm.ptr<1>
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> !llvm.ptr<1>
llvm.return %2 : !llvm.ptr<1>
}
}
@@ -1149,11 +1149,11 @@ llvm.func @stores_with_different_types_branches(%arg0: i64, %arg1: f32, %cond: i
%1 = llvm.alloca %0 x i64 {alignment = 4 : i64} : (i32) -> !llvm.ptr
llvm.cond_br %cond, ^bb1, ^bb2
^bb1:
- llvm.store %arg0, %1 {alignment = 4 : i64} : i64, !llvm.ptr
+ llvm.store %arg0, %1 alignment = 4 : i64, !llvm.ptr
// CHECK: llvm.br ^[[BB3:.+]](%[[ARG0]] : i64)
llvm.br ^bb3
^bb2:
- llvm.store %arg1, %1 {alignment = 4 : i64} : f32, !llvm.ptr
+ llvm.store %arg1, %1 alignment = 4 : f32, !llvm.ptr
// CHECK: %[[CAST:.+]] = llvm.bitcast %[[ARG1]] : f32 to i32
// CHECK: %[[ZEXT:.+]] = llvm.zext %[[CAST]] : i32 to i64
// CHECK: %[[MASK:.+]] = llvm.mlir.constant(-4294967296 : i64) : i64
@@ -1162,7 +1162,7 @@ llvm.func @stores_with_different_types_branches(%arg0: i64, %arg1: f32, %cond: i
// CHECK: llvm.br ^[[BB3]](%[[NEW_DEF]] : i64)
llvm.br ^bb3
^bb3:
- %2 = llvm.load %1 {alignment = 4 : i64} : !llvm.ptr -> f64
+ %2 = llvm.load %1 alignment = 4 : !llvm.ptr -> f64
llvm.return %2 : f64
}
diff --git a/mlir/test/Dialect/LLVMIR/opaque-ptr.mlir b/mlir/test/Dialect/LLVMIR/opaque-ptr.mlir
index 82c3e5bf2e2db..d7eb990b332c7 100644
--- a/mlir/test/Dialect/LLVMIR/opaque-ptr.mlir
+++ b/mlir/test/Dialect/LLVMIR/opaque-ptr.mlir
@@ -48,12 +48,12 @@ llvm.func @opaque_ptr_matrix_load_store(%ptr: !llvm.ptr, %stride: i64) -> vector
// CHECK: = llvm.intr.matrix.column.major.load
// CHECK: vector<48xf32> from !llvm.ptr stride i64
%0 = llvm.intr.matrix.column.major.load %ptr, <stride=%stride>
- { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
+ is_volatile = false rows = 3 columns = 16 :
vector<48 x f32> from !llvm.ptr stride i64
// CHECK: llvm.intr.matrix.column.major.store
// CHECK: vector<48xf32> to !llvm.ptr stride i64
llvm.intr.matrix.column.major.store %0, %ptr, <stride=%stride>
- { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
+ is_volatile = false rows = 3 columns = 16 :
vector<48 x f32> to !llvm.ptr stride i64
llvm.return %0 : vector<48 x f32>
}
@@ -62,7 +62,7 @@ llvm.func @opaque_ptr_matrix_load_store(%ptr: !llvm.ptr, %stride: i64) -> vector
llvm.func @opaque_ptr_masked_load(%arg0: !llvm.ptr, %arg1: vector<7xi1>) -> vector<7xf32> {
// CHECK: = llvm.intr.masked.load
// CHECK: (!llvm.ptr, vector<7xi1>) -> vector<7xf32>
- %0 = llvm.intr.masked.load %arg0, %arg1 { alignment = 1: i32} :
+ %0 = llvm.intr.masked.load %arg0, %arg1 alignment = 1 :
(!llvm.ptr, vector<7xi1>) -> vector<7xf32>
llvm.return %0 : vector<7 x f32>
}
@@ -71,7 +71,7 @@ llvm.func @opaque_ptr_masked_load(%arg0: !llvm.ptr, %arg1: vector<7xi1>) -> vect
llvm.func @opaque_ptr_gather(%M: vector<7x!llvm.ptr>, %mask: vector<7xi1>) -> vector<7xf32> {
// CHECK: = llvm.intr.masked.gather
// CHECK: (vector<7x!llvm.ptr>, vector<7xi1>) -> vector<7xf32>
- %a = llvm.intr.masked.gather %M, %mask { alignment = 1: i32} :
+ %a = llvm.intr.masked.gather %M, %mask alignment = 1 :
(vector<7x!llvm.ptr>, vector<7xi1>) -> vector<7xf32>
llvm.return %a : vector<7xf32>
}
diff --git a/mlir/test/Dialect/LLVMIR/roundtrip.mlir b/mlir/test/Dialect/LLVMIR/roundtrip.mlir
index f4805c5541f91..4399442d51644 100644
--- a/mlir/test/Dialect/LLVMIR/roundtrip.mlir
+++ b/mlir/test/Dialect/LLVMIR/roundtrip.mlir
@@ -533,23 +533,23 @@ func.func @zero() {
// CHECK-LABEL: @atomic_load
func.func @atomic_load(%ptr : !llvm.ptr) {
- // CHECK: llvm.load %{{.*}} atomic monotonic {alignment = 4 : i64} : !llvm.ptr -> f32
- %0 = llvm.load %ptr atomic monotonic {alignment = 4 : i64} : !llvm.ptr -> f32
- // CHECK: llvm.load volatile %{{.*}} atomic syncscope("singlethread") monotonic {alignment = 16 : i64} : !llvm.ptr -> f32
- %1 = llvm.load volatile %ptr atomic syncscope("singlethread") monotonic {alignment = 16 : i64} : !llvm.ptr -> f32
- // CHECK: llvm.load %{{.*}} atomic monotonic {alignment = 4 : i64} : !llvm.ptr -> i128
- %2 = llvm.load %ptr atomic monotonic {alignment = 4 : i64} : !llvm.ptr -> i128
+ // CHECK: llvm.load %{{.*}} atomic monotonic alignment = 4 : !llvm.ptr -> f32
+ %0 = llvm.load %ptr atomic monotonic alignment = 4 : !llvm.ptr -> f32
+ // CHECK: llvm.load volatile %{{.*}} atomic syncscope("singlethread") monotonic alignment = 16 : !llvm.ptr -> f32
+ %1 = llvm.load volatile %ptr atomic syncscope("singlethread") monotonic alignment = 16 : !llvm.ptr -> f32
+ // CHECK: llvm.load %{{.*}} atomic monotonic alignment = 4 : !llvm.ptr -> i128
+ %2 = llvm.load %ptr atomic monotonic alignment = 4 : !llvm.ptr -> i128
llvm.return
}
// CHECK-LABEL: @atomic_store
func.func @atomic_store(%val : f32, %large_val : i256, %ptr : !llvm.ptr) {
- // CHECK: llvm.store %{{.*}}, %{{.*}} atomic monotonic {alignment = 4 : i64} : f32, !llvm.ptr
- llvm.store %val, %ptr atomic monotonic {alignment = 4 : i64} : f32, !llvm.ptr
- // CHECK: llvm.store volatile %{{.*}}, %{{.*}} atomic syncscope("singlethread") monotonic {alignment = 16 : i64} : f32, !llvm.ptr
- llvm.store volatile %val, %ptr atomic syncscope("singlethread") monotonic {alignment = 16 : i64} : f32, !llvm.ptr
- // CHECK: llvm.store %{{.*}}, %{{.*}} atomic monotonic {alignment = 4 : i64} : i256, !llvm.ptr
- llvm.store %large_val, %ptr atomic monotonic {alignment = 4 : i64} : i256, !llvm.ptr
+ // CHECK: llvm.store %{{.*}}, %{{.*}} atomic monotonic alignment = 4 : f32, !llvm.ptr
+ llvm.store %val, %ptr atomic monotonic alignment = 4 : f32, !llvm.ptr
+ // CHECK: llvm.store volatile %{{.*}}, %{{.*}} atomic syncscope("singlethread") monotonic alignment = 16 : f32, !llvm.ptr
+ llvm.store volatile %val, %ptr atomic syncscope("singlethread") monotonic alignment = 16 : f32, !llvm.ptr
+ // CHECK: llvm.store %{{.*}}, %{{.*}} atomic monotonic alignment = 4 : i256, !llvm.ptr
+ llvm.store %large_val, %ptr atomic monotonic alignment = 4 : i256, !llvm.ptr
llvm.return
}
@@ -557,8 +557,8 @@ func.func @atomic_store(%val : f32, %large_val : i256, %ptr : !llvm.ptr) {
func.func @atomicrmw(%ptr : !llvm.ptr, %f32 : f32, %f16_vec : vector<2xf16>) {
// CHECK: llvm.atomicrmw fadd %{{.*}}, %{{.*}} monotonic : !llvm.ptr, f32
%0 = llvm.atomicrmw fadd %ptr, %f32 monotonic : !llvm.ptr, f32
- // CHECK: llvm.atomicrmw volatile fsub %{{.*}}, %{{.*}} syncscope("singlethread") monotonic {alignment = 16 : i64} : !llvm.ptr, f32
- %1 = llvm.atomicrmw volatile fsub %ptr, %f32 syncscope("singlethread") monotonic {alignment = 16 : i64} : !llvm.ptr, f32
+ // CHECK: llvm.atomicrmw volatile fsub %{{.*}}, %{{.*}} syncscope("singlethread") monotonic alignment = 16 : !llvm.ptr, f32
+ %1 = llvm.atomicrmw volatile fsub %ptr, %f32 syncscope("singlethread") monotonic alignment = 16 : !llvm.ptr, f32
// CHECK: llvm.atomicrmw fmin %{{.*}}, %{{.*}} monotonic : !llvm.ptr, vector<2xf16>
%2 = llvm.atomicrmw fmin %ptr, %f16_vec monotonic : !llvm.ptr, vector<2xf16>
// CHECK: llvm.atomicrmw fminimumnum %{{.*}}, %{{.*}} monotonic : !llvm.ptr, f32
@@ -570,22 +570,22 @@ func.func @atomicrmw(%ptr : !llvm.ptr, %f32 : f32, %f16_vec : vector<2xf16>) {
func.func @cmpxchg(%ptr : !llvm.ptr, %cmp : i32, %new : i32) {
// CHECK: llvm.cmpxchg %{{.*}}, %{{.*}}, %{{.*}} acq_rel monotonic : !llvm.ptr, i32
%0 = llvm.cmpxchg %ptr, %cmp, %new acq_rel monotonic : !llvm.ptr, i32
- // CHECK: llvm.cmpxchg weak volatile %{{.*}}, %{{.*}}, %{{.*}} syncscope("singlethread") acq_rel monotonic {alignment = 16 : i64} : !llvm.ptr, i32
- %1 = llvm.cmpxchg weak volatile %ptr, %cmp, %new syncscope("singlethread") acq_rel monotonic {alignment = 16 : i64} : !llvm.ptr, i32
+ // CHECK: llvm.cmpxchg weak volatile %{{.*}}, %{{.*}}, %{{.*}} syncscope("singlethread") acq_rel monotonic alignment = 16 : !llvm.ptr, i32
+ %1 = llvm.cmpxchg weak volatile %ptr, %cmp, %new syncscope("singlethread") acq_rel monotonic alignment = 16 : !llvm.ptr, i32
llvm.return
}
// CHECK-LABEL: @invariant_load
func.func @invariant_load(%ptr : !llvm.ptr) -> i32 {
- // CHECK: llvm.load %{{.+}} invariant {alignment = 4 : i64} : !llvm.ptr -> i32
- %0 = llvm.load %ptr invariant {alignment = 4 : i64} : !llvm.ptr -> i32
+ // CHECK: llvm.load %{{.+}} invariant alignment = 4 : !llvm.ptr -> i32
+ %0 = llvm.load %ptr invariant alignment = 4 : !llvm.ptr -> i32
func.return %0 : i32
}
// CHECK-LABEL: @invariant_group_load
func.func @invariant_group_load(%ptr : !llvm.ptr) -> i32 {
- // CHECK: llvm.load %{{.+}} invariant_group {alignment = 4 : i64} : !llvm.ptr -> i32
- %0 = llvm.load %ptr invariant_group {alignment = 4 : i64} : !llvm.ptr -> i32
+ // CHECK: llvm.load %{{.+}} invariant_group alignment = 4 : !llvm.ptr -> i32
+ %0 = llvm.load %ptr invariant_group alignment = 4 : !llvm.ptr -> i32
func.return %0 : i32
}
@@ -712,16 +712,16 @@ llvm.func @useInlineAsm(%arg0: i32) {
// CHECK-LABEL: @fastmathFlags
func.func @fastmathFlags(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: vector<2 x f32>, %arg4: vector<2 x f32>) {
-// CHECK: {{.*}} = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
-// CHECK: {{.*}} = llvm.fsub %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
-// CHECK: {{.*}} = llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
-// CHECK: {{.*}} = llvm.fdiv %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
-// CHECK: {{.*}} = llvm.frem %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
- %0 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
- %1 = llvm.fsub %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
- %2 = llvm.fmul %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
- %3 = llvm.fdiv %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
- %4 = llvm.frem %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
+// CHECK: {{.*}} = llvm.fadd %arg0, %arg1 fastmath<fast> : f32
+// CHECK: {{.*}} = llvm.fsub %arg0, %arg1 fastmath<fast> : f32
+// CHECK: {{.*}} = llvm.fmul %arg0, %arg1 fastmath<fast> : f32
+// CHECK: {{.*}} = llvm.fdiv %arg0, %arg1 fastmath<fast> : f32
+// CHECK: {{.*}} = llvm.frem %arg0, %arg1 fastmath<fast> : f32
+ %0 = llvm.fadd %arg0, %arg1 fastmath<fast> : f32
+ %1 = llvm.fsub %arg0, %arg1 fastmath<fast> : f32
+ %2 = llvm.fmul %arg0, %arg1 fastmath<fast> : f32
+ %3 = llvm.fdiv %arg0, %arg1 fastmath<fast> : f32
+ %4 = llvm.frem %arg0, %arg1 fastmath<fast> : f32
// CHECK: %[[SCALAR_PRED0:.+]] = llvm.fcmp "oeq" %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
%5 = llvm.fcmp "oeq" %arg0, %arg1 {fastmathFlags = #llvm.fastmath<fast>} : f32
@@ -732,33 +732,33 @@ func.func @fastmathFlags(%arg0: f32, %arg1: f32, %arg2: i32, %arg3: vector<2 x f
// CHECK: %{{.*}} = llvm.add %[[VEC_PRED0]], %[[VEC_PRED0]] : vector<2xi1>
%typecheck_vcmp = llvm.add %vcmp, %vcmp : vector<2xi1>
-// CHECK: {{.*}} = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : f32
- %6 = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<fast>} : f32
+// CHECK: {{.*}} = llvm.fneg %arg0 fastmath<fast> : f32
+ %6 = llvm.fneg %arg0 fastmath<fast> : f32
// CHECK: {{.*}} = llvm.call @foo(%arg2) {fastmathFlags = #llvm.fastmath<fast>} : (i32) -> !llvm.struct<(i32, f64, i32)>
%7 = llvm.call @foo(%arg2) {fastmathFlags = #llvm.fastmath<fast>} : (i32) -> !llvm.struct<(i32, f64, i32)>
// CHECK: {{.*}} = llvm.fadd %arg0, %arg1 : f32
- %8 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<none>} : f32
-// CHECK: {{.*}} = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
- %9 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<nnan,ninf>} : f32
+ %8 = llvm.fadd %arg0, %arg1 fastmath<none> : f32
+// CHECK: {{.*}} = llvm.fadd %arg0, %arg1 fastmath<nnan, ninf> : f32
+ %9 = llvm.fadd %arg0, %arg1 fastmath<nnan,ninf> : f32
// CHECK: {{.*}} = llvm.fneg %arg0 : f32
- %10 = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<none>} : f32
-
-// CHECK: {{.*}} = llvm.intr.sin(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32
- %11 = llvm.intr.sin(%arg0) {fastmathFlags = #llvm.fastmath<fast>} : (f32) -> f32
-// CHECK: {{.*}} = llvm.intr.sin(%arg0) {fastmathFlags = #llvm.fastmath<afn>} : (f32) -> f32
- %12 = llvm.intr.sin(%arg0) {fastmathFlags = #llvm.fastmath<afn>} : (f32) -> f32
-
-// CHECK: {{.*}} = llvm.intr.vector.reduce.fmin(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
- %13 = llvm.intr.vector.reduce.fmin(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
-// CHECK: {{.*}} = llvm.intr.vector.reduce.fmax(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
- %14 = llvm.intr.vector.reduce.fmax(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
-// CHECK: {{.*}} = llvm.intr.vector.reduce.fminimum(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
- %15 = llvm.intr.vector.reduce.fminimum(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
-// CHECK: {{.*}} = llvm.intr.vector.reduce.fmaximum(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
- %16 = llvm.intr.vector.reduce.fmaximum(%arg3) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
+ %10 = llvm.fneg %arg0 fastmath<none> : f32
+
+// CHECK: {{.*}} = llvm.intr.sin(%arg0) fastmath<fast> : (f32) -> f32
+ %11 = llvm.intr.sin(%arg0) fastmath<fast> : (f32) -> f32
+// CHECK: {{.*}} = llvm.intr.sin(%arg0) fastmath<afn> : (f32) -> f32
+ %12 = llvm.intr.sin(%arg0) fastmath<afn> : (f32) -> f32
+
+// CHECK: {{.*}} = llvm.intr.vector.reduce.fmin(%arg3) fastmath<nnan> : (vector<2xf32>) -> f32
+ %13 = llvm.intr.vector.reduce.fmin(%arg3) fastmath<nnan> : (vector<2xf32>) -> f32
+// CHECK: {{.*}} = llvm.intr.vector.reduce.fmax(%arg3) fastmath<nnan> : (vector<2xf32>) -> f32
+ %14 = llvm.intr.vector.reduce.fmax(%arg3) fastmath<nnan> : (vector<2xf32>) -> f32
+// CHECK: {{.*}} = llvm.intr.vector.reduce.fminimum(%arg3) fastmath<nnan> : (vector<2xf32>) -> f32
+ %15 = llvm.intr.vector.reduce.fminimum(%arg3) fastmath<nnan> : (vector<2xf32>) -> f32
+// CHECK: {{.*}} = llvm.intr.vector.reduce.fmaximum(%arg3) fastmath<nnan> : (vector<2xf32>) -> f32
+ %16 = llvm.intr.vector.reduce.fmaximum(%arg3) fastmath<nnan> : (vector<2xf32>) -> f32
return
}
diff --git a/mlir/test/Dialect/LLVMIR/tbaa-roundtrip.mlir b/mlir/test/Dialect/LLVMIR/tbaa-roundtrip.mlir
index 472ae609004c0..996ca0077ad85 100644
--- a/mlir/test/Dialect/LLVMIR/tbaa-roundtrip.mlir
+++ b/mlir/test/Dialect/LLVMIR/tbaa-roundtrip.mlir
@@ -35,15 +35,15 @@
llvm.func @tbaa1(%arg0: !llvm.ptr, %arg1: !llvm.ptr) {
%0 = llvm.mlir.constant(1 : i8) : i8
- llvm.store %0, %arg0 {tbaa = [#tbaa_tag_0]} : i8, !llvm.ptr
- llvm.store %0, %arg1 {tbaa = [#tbaa_tag_1]} : i8, !llvm.ptr
+ llvm.store %0, %arg0 tbaa = [#tbaa_tag_0] : i8, !llvm.ptr
+ llvm.store %0, %arg1 tbaa = [#tbaa_tag_1] : i8, !llvm.ptr
llvm.return
}
// CHECK: llvm.func @tbaa1(%[[VAL_0:.*]]: !llvm.ptr, %[[VAL_1:.*]]: !llvm.ptr) {
// CHECK: %[[VAL_2:.*]] = llvm.mlir.constant(1 : i8) : i8
-// CHECK: llvm.store %[[VAL_2]], %[[VAL_0]] {tbaa = [#[[$TAG_0]]]} : i8, !llvm.ptr
-// CHECK: llvm.store %[[VAL_2]], %[[VAL_1]] {tbaa = [#[[$TAG_1]]]} : i8, !llvm.ptr
+// CHECK: llvm.store %[[VAL_2]], %[[VAL_0]] tbaa = [#[[$TAG_0]]] : i8, !llvm.ptr
+// CHECK: llvm.store %[[VAL_2]], %[[VAL_1]] tbaa = [#[[$TAG_1]]] : i8, !llvm.ptr
// CHECK: llvm.return
// CHECK: }
@@ -51,10 +51,10 @@ llvm.func @tbaa2(%arg0: !llvm.ptr, %arg1: !llvm.ptr) {
%0 = llvm.mlir.constant(0 : i32) : i32
%1 = llvm.mlir.constant(1 : i32) : i32
%2 = llvm.getelementptr inbounds %arg1[%0, 1] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg2_t", (i64, i64)>
- %3 = llvm.load %2 {tbaa = [#tbaa_tag_2]} : !llvm.ptr -> i64
+ %3 = llvm.load %2 tbaa = [#tbaa_tag_2] : !llvm.ptr -> i64
%4 = llvm.trunc %3 : i64 to i32
%5 = llvm.getelementptr inbounds %arg0[%0, 0] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg1_t", (i32, i32)>
- llvm.store %4, %5 {tbaa = [#tbaa_tag_3]} : i32, !llvm.ptr
+ llvm.store %4, %5 tbaa = [#tbaa_tag_3] : i32, !llvm.ptr
llvm.return
}
@@ -62,33 +62,33 @@ llvm.func @tbaa2(%arg0: !llvm.ptr, %arg1: !llvm.ptr) {
// CHECK: %[[VAL_2:.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: %[[VAL_3:.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: %[[VAL_4:.*]] = llvm.getelementptr inbounds %[[VAL_1]]{{\[}}%[[VAL_2]], 1] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg2_t", (i64, i64)>
-// CHECK: %[[VAL_5:.*]] = llvm.load %[[VAL_4]] {tbaa = [#[[$TAG_2]]]} : !llvm.ptr -> i64
+// CHECK: %[[VAL_5:.*]] = llvm.load %[[VAL_4]] tbaa = [#[[$TAG_2]]] : !llvm.ptr -> i64
// CHECK: %[[VAL_6:.*]] = llvm.trunc %[[VAL_5]] : i64 to i32
// CHECK: %[[VAL_7:.*]] = llvm.getelementptr inbounds %[[VAL_0]]{{\[}}%[[VAL_2]], 0] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg1_t", (i32, i32)>
-// CHECK: llvm.store %[[VAL_6]], %[[VAL_7]] {tbaa = [#[[$TAG_3]]]} : i32, !llvm.ptr
+// CHECK: llvm.store %[[VAL_6]], %[[VAL_7]] tbaa = [#[[$TAG_3]]] : i32, !llvm.ptr
// CHECK: llvm.return
// CHECK: }
llvm.func @tbaa3(%arg0: !llvm.ptr) {
%0 = llvm.mlir.constant(1 : i8) : i8
- llvm.store %0, %arg0 {tbaa = [#tbaa_tag_0, #tbaa_tag_1]} : i8, !llvm.ptr
+ llvm.store %0, %arg0 tbaa = [#tbaa_tag_0, #tbaa_tag_1] : i8, !llvm.ptr
llvm.return
}
// CHECK: llvm.func @tbaa3(%[[VAL_0:.*]]: !llvm.ptr) {
// CHECK: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i8) : i8
-// CHECK: llvm.store %[[VAL_1]], %[[VAL_0]] {tbaa = [#[[$TAG_0]], #[[$TAG_1]]]} : i8, !llvm.ptr
+// CHECK: llvm.store %[[VAL_1]], %[[VAL_0]] tbaa = [#[[$TAG_0]], #[[$TAG_1]]] : i8, !llvm.ptr
// CHECK: llvm.return
// CHECK: }
llvm.func @tbaa4(%arg0: !llvm.ptr) {
%0 = llvm.mlir.constant(1 : i8) : i8
- llvm.store %0, %arg0 {tbaa = [#tbaa_tag_4]} : i8, !llvm.ptr
+ llvm.store %0, %arg0 tbaa = [#tbaa_tag_4] : i8, !llvm.ptr
llvm.return
}
// CHECK: llvm.func @tbaa4(%[[VAL_0:.*]]: !llvm.ptr) {
// CHECK: %[[VAL_1:.*]] = llvm.mlir.constant(1 : i8) : i8
-// CHECK: llvm.store %[[VAL_1]], %[[VAL_0]] {tbaa = [#[[$TAG_4]]]} : i8, !llvm.ptr
+// CHECK: llvm.store %[[VAL_1]], %[[VAL_0]] tbaa = [#[[$TAG_4]]] : i8, !llvm.ptr
// CHECK: llvm.return
// CHECK: }
diff --git a/mlir/test/Dialect/Vector/vector-contract-to-matrix-intrinsics-transforms.mlir b/mlir/test/Dialect/Vector/vector-contract-to-matrix-intrinsics-transforms.mlir
index 11ca563c82d3f..f79c09642165e 100644
--- a/mlir/test/Dialect/Vector/vector-contract-to-matrix-intrinsics-transforms.mlir
+++ b/mlir/test/Dialect/Vector/vector-contract-to-matrix-intrinsics-transforms.mlir
@@ -55,7 +55,7 @@
// CHECK: %[[RHS:.*]] = llvm.shufflevector %[[TP_10]], %[[TP_9]] [12, 13, 14, 15, 16, 17, 18, 19, 20, 0, 1, 2] : vector<12xf32>
// ===> Matrix multiply
-// CHECK: %[[MM:.*]] = llvm.intr.matrix.multiply %[[LHS]], %[[RHS]] {lhs_columns = 4 : i32, lhs_rows = 2 : i32, rhs_columns = 3 : i32} : (vector<8xf32>, vector<12xf32>) -> vector<6xf32>
+// CHECK: %[[MM:.*]] = llvm.intr.matrix.multiply %[[LHS]], %[[RHS]] lhs_rows = 2 lhs_columns = 4 rhs_columns = 3 : (vector<8xf32>, vector<12xf32>) -> vector<6xf32>
// CHECK: %[[RES:.*]] = arith.addf %[[ARG2]], %{{.*}} : vector<2x3xf32>
// CHECK: return %[[RES]] : vector<2x3xf32>
func.func @matmul(%arg0: vector<2x4xf32>,
diff --git a/mlir/test/Dialect/Vector/vector-transpose-to-matrix-intrinsics-transform.mlir b/mlir/test/Dialect/Vector/vector-transpose-to-matrix-intrinsics-transform.mlir
index f68badaa122cd..0816358c0fa84 100644
--- a/mlir/test/Dialect/Vector/vector-transpose-to-matrix-intrinsics-transform.mlir
+++ b/mlir/test/Dialect/Vector/vector-transpose-to-matrix-intrinsics-transform.mlir
@@ -2,7 +2,7 @@
// CHECK-LABEL: func @transpose(
func.func @transpose(%arg0: vector<2x4xf32>) -> vector<4x2xf32> {
- // CHECK: llvm.intr.matrix.transpose %{{.*}} {columns = 2 : i32, rows = 4 : i32} : vector<8xf32> into vector<8xf32>
+ // CHECK: llvm.intr.matrix.transpose %{{.*}} rows = 4 columns = 2 : vector<8xf32> into vector<8xf32>
%0 = vector.transpose %arg0, [1, 0] : vector<2x4xf32> to vector<4x2xf32>
return %0 : vector<4x2xf32>
}
diff --git a/mlir/test/Integration/Dialect/Vector/CPU/flat-transpose-col.mlir b/mlir/test/Integration/Dialect/Vector/CPU/flat-transpose-col.mlir
index 86bd0b1e09763..8134ecc1d5a5a 100644
--- a/mlir/test/Integration/Dialect/Vector/CPU/flat-transpose-col.mlir
+++ b/mlir/test/Integration/Dialect/Vector/CPU/flat-transpose-col.mlir
@@ -57,10 +57,10 @@ func.func @entry() {
// ( 1, 4 ) -> ( 3, 4, 5 )
// ( 2, 5 )
//
- %d = llvm.intr.matrix.transpose %a { rows = 2: i32, columns = 2: i32 } : vector<4xf64> into vector<4xf64>
- %e = llvm.intr.matrix.transpose %b { rows = 2: i32, columns = 2: i32 } : vector<4xf64> into vector<4xf64>
- %f = llvm.intr.matrix.transpose %c { rows = 2: i32, columns = 3: i32 } : vector<6xf64> into vector<6xf64>
- %g = llvm.intr.matrix.transpose %c { rows = 3: i32, columns = 2: i32 } : vector<6xf64> into vector<6xf64>
+ %d = llvm.intr.matrix.transpose %a rows = 2 columns = 2 : vector<4xf64> into vector<4xf64>
+ %e = llvm.intr.matrix.transpose %b rows = 2 columns = 2 : vector<4xf64> into vector<4xf64>
+ %f = llvm.intr.matrix.transpose %c rows = 2 columns = 3 : vector<6xf64> into vector<6xf64>
+ %g = llvm.intr.matrix.transpose %c rows = 3 columns = 2 : vector<6xf64> into vector<6xf64>
vector.print %d : vector<4xf64>
vector.print %e : vector<4xf64>
diff --git a/mlir/test/Integration/Dialect/Vector/CPU/flat-transpose-row.mlir b/mlir/test/Integration/Dialect/Vector/CPU/flat-transpose-row.mlir
index 55103bc686fb2..66f3423037f21 100644
--- a/mlir/test/Integration/Dialect/Vector/CPU/flat-transpose-row.mlir
+++ b/mlir/test/Integration/Dialect/Vector/CPU/flat-transpose-row.mlir
@@ -57,10 +57,10 @@ func.func @entry() {
// ( 2, 3 ) -> ( 1, 3, 5 )
// ( 4, 5 )
//
- %d = llvm.intr.matrix.transpose %a { rows = 2: i32, columns = 2: i32 } : vector<4xf64> into vector<4xf64>
- %e = llvm.intr.matrix.transpose %b { rows = 2: i32, columns = 2: i32 } : vector<4xf64> into vector<4xf64>
- %f = llvm.intr.matrix.transpose %c { rows = 2: i32, columns = 3: i32 } : vector<6xf64> into vector<6xf64>
- %g = llvm.intr.matrix.transpose %c { rows = 3: i32, columns = 2: i32 } : vector<6xf64> into vector<6xf64>
+ %d = llvm.intr.matrix.transpose %a rows = 2 columns = 2 : vector<4xf64> into vector<4xf64>
+ %e = llvm.intr.matrix.transpose %b rows = 2 columns = 2 : vector<4xf64> into vector<4xf64>
+ %f = llvm.intr.matrix.transpose %c rows = 2 columns = 3 : vector<6xf64> into vector<6xf64>
+ %g = llvm.intr.matrix.transpose %c rows = 3 columns = 2 : vector<6xf64> into vector<6xf64>
vector.print %d : vector<4xf64>
vector.print %e : vector<4xf64>
diff --git a/mlir/test/Integration/Dialect/Vector/CPU/matrix-multiply-col.mlir b/mlir/test/Integration/Dialect/Vector/CPU/matrix-multiply-col.mlir
index 09941192cbc42..c7b53d2116ad4 100644
--- a/mlir/test/Integration/Dialect/Vector/CPU/matrix-multiply-col.mlir
+++ b/mlir/test/Integration/Dialect/Vector/CPU/matrix-multiply-col.mlir
@@ -40,8 +40,7 @@ func.func @entry() {
// ( 1, 3 ) (5, 7) ( 19, 27 )
//
%c = llvm.intr.matrix.multiply %a, %b
- { lhs_rows = 2: i32, lhs_columns = 2: i32 , rhs_columns = 2: i32 }
- : (vector<4xf64>, vector<4xf64>) -> vector<4xf64>
+ lhs_rows = 2 lhs_columns = 2 rhs_columns = 2 : (vector<4xf64>, vector<4xf64>) -> vector<4xf64>
vector.print %c : vector<4xf64>
//
diff --git a/mlir/test/Integration/Dialect/Vector/CPU/matrix-multiply-row.mlir b/mlir/test/Integration/Dialect/Vector/CPU/matrix-multiply-row.mlir
index d5f511c8ac119..cfd740a7dc7b6 100644
--- a/mlir/test/Integration/Dialect/Vector/CPU/matrix-multiply-row.mlir
+++ b/mlir/test/Integration/Dialect/Vector/CPU/matrix-multiply-row.mlir
@@ -40,8 +40,7 @@ func.func @entry() {
// ( 2, 3 ) (6, 7) ( 26, 31 )
//
%c = llvm.intr.matrix.multiply %a, %b
- { lhs_rows = 2: i32, lhs_columns = 2: i32 , rhs_columns = 2: i32 }
- : (vector<4xf64>, vector<4xf64>) -> vector<4xf64>
+ lhs_rows = 2 lhs_columns = 2 rhs_columns = 2 : (vector<4xf64>, vector<4xf64>) -> vector<4xf64>
vector.print %c : vector<4xf64>
//
diff --git a/mlir/test/Target/LLVMIR/Import/fastmath.ll b/mlir/test/Target/LLVMIR/Import/fastmath.ll
index a6f8f10a5f8f9..98ea65f37e18a 100644
--- a/mlir/test/Target/LLVMIR/Import/fastmath.ll
+++ b/mlir/test/Target/LLVMIR/Import/fastmath.ll
@@ -2,17 +2,17 @@
; CHECK-LABEL: @fastmath_inst
define void @fastmath_inst(float %arg1, float %arg2, i1 %arg3) {
- ; CHECK: llvm.fadd %{{.*}}, %{{.*}} {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
+ ; CHECK: llvm.fadd %{{.*}}, %{{.*}} fastmath<nnan, ninf> : f32
%1 = fadd nnan ninf float %arg1, %arg2
- ; CHECK: llvm.fsub %{{.*}}, %{{.*}} {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.fsub %{{.*}}, %{{.*}} fastmath<nsz> : f32
%2 = fsub nsz float %arg1, %arg2
- ; CHECK: llvm.fmul %{{.*}}, %{{.*}} {fastmathFlags = #llvm.fastmath<arcp, contract>} : f32
+ ; CHECK: llvm.fmul %{{.*}}, %{{.*}} fastmath<arcp, contract> : f32
%3 = fmul arcp contract float %arg1, %arg2
- ; CHECK: llvm.fdiv %{{.*}}, %{{.*}} {fastmathFlags = #llvm.fastmath<afn, reassoc>} : f32
+ ; CHECK: llvm.fdiv %{{.*}}, %{{.*}} fastmath<afn, reassoc> : f32
%4 = fdiv afn reassoc float %arg1, %arg2
- ; CHECK: llvm.fneg %{{.*}} {fastmathFlags = #llvm.fastmath<fast>} : f32
+ ; CHECK: llvm.fneg %{{.*}} fastmath<fast> : f32
%5 = fneg fast float %arg1
- ; CHECK: llvm.select %{{.*}}, %{{.*}}, %{{.*}} {fastmathFlags = #llvm.fastmath<contract>} : i1, f32
+ ; CHECK: llvm.select %{{.*}}, %{{.*}}, %{{.*}} fastmath<contract> : i1, f32
%6 = select contract i1 %arg3, float %arg1, float %arg2
ret void
}
@@ -61,21 +61,21 @@ declare float @llvm.vector.reduce.fmaximum.v2f32(<2 x float>)
; CHECK-LABEL: @fastmath_intr
define void @fastmath_intr(float %arg1, i32 %arg2, <2 x float> %arg3) {
- ; CHECK: llvm.intr.exp(%{{.*}}) {fastmathFlags = #llvm.fastmath<nnan, ninf>} : (f32) -> f32
+ ; CHECK: llvm.intr.exp(%{{.*}}) fastmath<nnan, ninf> : (f32) -> f32
%1 = call nnan ninf float @llvm.exp.f32(float %arg1)
- ; CHECK: llvm.intr.powi(%{{.*}}, %{{.*}}) {fastmathFlags = #llvm.fastmath<fast>} : (f32, i32) -> f32
+ ; CHECK: llvm.intr.powi(%{{.*}}, %{{.*}}) fastmath<fast> : (f32, i32) -> f32
%2 = call fast float @llvm.powi.f32.i32(float %arg1, i32 %arg2)
- ; CHECK: llvm.intr.pow(%{{.*}}, %{{.*}}) {fastmathFlags = #llvm.fastmath<fast>} : (f32, f32) -> f32
+ ; CHECK: llvm.intr.pow(%{{.*}}, %{{.*}}) fastmath<fast> : (f32, f32) -> f32
%3 = call fast float @llvm.pow.f32(float %arg1, float %arg1)
- ; CHECK: llvm.intr.fmuladd(%{{.*}}, %{{.*}}, %{{.*}}) {fastmathFlags = #llvm.fastmath<fast>} : (f32, f32, f32) -> f32
+ ; CHECK: llvm.intr.fmuladd(%{{.*}}, %{{.*}}, %{{.*}}) fastmath<fast> : (f32, f32, f32) -> f32
%4 = call fast float @llvm.fmuladd.f32(float %arg1, float %arg1, float %arg1)
- ; CHECK: %{{.*}} = llvm.intr.vector.reduce.fmin({{.*}}) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
+ ; CHECK: %{{.*}} = llvm.intr.vector.reduce.fmin({{.*}}) fastmath<nnan> : (vector<2xf32>) -> f32
%5 = call nnan float @llvm.vector.reduce.fmin.v2f32(<2 x float> %arg3)
- ; CHECK: %{{.*}} = llvm.intr.vector.reduce.fmax({{.*}}) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
+ ; CHECK: %{{.*}} = llvm.intr.vector.reduce.fmax({{.*}}) fastmath<nnan> : (vector<2xf32>) -> f32
%6 = call nnan float @llvm.vector.reduce.fmax.v2f32(<2 x float> %arg3)
- ; CHECK: %{{.*}} = llvm.intr.vector.reduce.fminimum({{.*}}) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
+ ; CHECK: %{{.*}} = llvm.intr.vector.reduce.fminimum({{.*}}) fastmath<nnan> : (vector<2xf32>) -> f32
%7 = call nnan float @llvm.vector.reduce.fminimum.v2f32(<2 x float> %arg3)
- ; CHECK: %{{.*}} = llvm.intr.vector.reduce.fmaximum({{.*}}) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
+ ; CHECK: %{{.*}} = llvm.intr.vector.reduce.fmaximum({{.*}}) fastmath<nnan> : (vector<2xf32>) -> f32
%8 = call nnan float @llvm.vector.reduce.fmaximum.v2f32(<2 x float> %arg3)
ret void
diff --git a/mlir/test/Target/LLVMIR/Import/ifunc.ll b/mlir/test/Target/LLVMIR/Import/ifunc.ll
index 0cec205dfce68..c6d188afd8650 100644
--- a/mlir/test/Target/LLVMIR/Import/ifunc.ll
+++ b/mlir/test/Target/LLVMIR/Import/ifunc.ll
@@ -1,6 +1,6 @@
; RUN: mlir-translate --import-llvm %s --split-input-file | FileCheck %s
-; CHECK: llvm.mlir.ifunc external @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @resolve_foo {dso_local}
+; CHECK: llvm.mlir.ifunc external @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @resolve_foo dso_local
@foo = dso_local ifunc void (ptr, i32), ptr @resolve_foo
define dso_local void @call_foo(ptr noundef %0, i32 noundef %1) {
@@ -50,7 +50,7 @@ define ptr @resolver() {
ret ptr inttoptr (i64 333 to ptr)
}
-; CHECK: llvm.mlir.ifunc private @ifunc {{.*}} {dso_local}
+; CHECK: llvm.mlir.ifunc private @ifunc {{.*}} dso_local
@ifunc = private dso_local ifunc float (i64), ptr @resolver
; // -----
diff --git a/mlir/test/Target/LLVMIR/Import/instructions.ll b/mlir/test/Target/LLVMIR/Import/instructions.ll
index 6fae74dcf9895..4bf99da654423 100644
--- a/mlir/test/Target/LLVMIR/Import/instructions.ll
+++ b/mlir/test/Target/LLVMIR/Import/instructions.ll
@@ -359,13 +359,13 @@ define ptr @alloca(i64 %size) {
; CHECK-LABEL: @load_store
; CHECK-SAME: %[[PTR:[a-zA-Z0-9]+]]
define void @load_store(ptr %ptr) {
- ; CHECK: %[[V1:[0-9]+]] = llvm.load %[[PTR]] {alignment = 8 : i64} : !llvm.ptr -> f64
- ; CHECK: %[[V2:[0-9]+]] = llvm.load volatile %[[PTR]] {alignment = 16 : i64, nontemporal} : !llvm.ptr -> f64
+ ; CHECK: %[[V1:[0-9]+]] = llvm.load %[[PTR]] alignment = 8 : !llvm.ptr -> f64
+ ; CHECK: %[[V2:[0-9]+]] = llvm.load volatile %[[PTR]] nontemporal alignment = 16 : !llvm.ptr -> f64
%1 = load double, ptr %ptr
%2 = load volatile double, ptr %ptr, align 16, !nontemporal !0
- ; CHECK: llvm.store %[[V1]], %[[PTR]] {alignment = 8 : i64} : f64, !llvm.ptr
- ; CHECK: llvm.store volatile %[[V2]], %[[PTR]] {alignment = 16 : i64, nontemporal} : f64, !llvm.ptr
+ ; CHECK: llvm.store %[[V1]], %[[PTR]] alignment = 8 : f64, !llvm.ptr
+ ; CHECK: llvm.store volatile %[[V2]], %[[PTR]] nontemporal alignment = 16 : f64, !llvm.ptr
store double %1, ptr %ptr
store volatile double %2, ptr %ptr, align 16, !nontemporal !0
ret void
@@ -378,7 +378,7 @@ define void @load_store(ptr %ptr) {
; CHECK-LABEL: @invariant_load
; CHECK-SAME: %[[PTR:[a-zA-Z0-9]+]]
define float @invariant_load(ptr %ptr) {
- ; CHECK: %[[V:[0-9]+]] = llvm.load %[[PTR]] invariant {alignment = 4 : i64} : !llvm.ptr -> f32
+ ; CHECK: %[[V:[0-9]+]] = llvm.load %[[PTR]] invariant alignment = 4 : !llvm.ptr -> f32
%1 = load float, ptr %ptr, align 4, !invariant.load !0
; CHECK: llvm.return %[[V]]
ret float %1
@@ -391,7 +391,7 @@ define float @invariant_load(ptr %ptr) {
; CHECK-LABEL: @invariant_group_load
; CHECK-SAME: %[[PTR:[a-zA-Z0-9]+]]
define float @invariant_group_load(ptr %ptr) {
- ; CHECK: %[[VAL:.+]] = llvm.load %[[PTR]] invariant_group {alignment = 4 : i64} : !llvm.ptr -> f32
+ ; CHECK: %[[VAL:.+]] = llvm.load %[[PTR]] invariant_group alignment = 4 : !llvm.ptr -> f32
%1 = load float, ptr %ptr, align 4, !invariant.group !0
; CHECK: llvm.return %[[VAL]]
ret float %1
@@ -405,7 +405,7 @@ define float @invariant_group_load(ptr %ptr) {
; CHECK-SAME: %[[VAL:[a-zA-Z0-9]+]]
; CHECK-SAME: %[[PTR:[a-zA-Z0-9]+]]
define void @invariant_group_store(float %val, ptr %ptr) {
- ; CHECK: llvm.store %[[VAL]], %[[PTR]] invariant_group {alignment = 4 : i64} : f32, !llvm.ptr
+ ; CHECK: llvm.store %[[VAL]], %[[PTR]] invariant_group alignment = 4 : f32, !llvm.ptr
store float %val, ptr %ptr, align 4, !invariant.group !0
; CHECK: llvm.return
ret void
@@ -418,13 +418,13 @@ define void @invariant_group_store(float %val, ptr %ptr) {
; CHECK-LABEL: @atomic_load_store
; CHECK-SAME: %[[PTR:[a-zA-Z0-9]+]]
define void @atomic_load_store(ptr %ptr) {
- ; CHECK: %[[V1:[0-9]+]] = llvm.load %[[PTR]] atomic acquire {alignment = 8 : i64} : !llvm.ptr -> f64
- ; CHECK: %[[V2:[0-9]+]] = llvm.load volatile %[[PTR]] atomic syncscope("singlethreaded") acquire {alignment = 16 : i64} : !llvm.ptr -> f64
+ ; CHECK: %[[V1:[0-9]+]] = llvm.load %[[PTR]] atomic acquire alignment = 8 : !llvm.ptr -> f64
+ ; CHECK: %[[V2:[0-9]+]] = llvm.load volatile %[[PTR]] atomic syncscope("singlethreaded") acquire alignment = 16 : !llvm.ptr -> f64
%1 = load atomic double, ptr %ptr acquire, align 8
%2 = load atomic volatile double, ptr %ptr syncscope("singlethreaded") acquire, align 16
- ; CHECK: llvm.store %[[V1]], %[[PTR]] atomic release {alignment = 8 : i64} : f64, !llvm.ptr
- ; CHECK: llvm.store volatile %[[V2]], %[[PTR]] atomic syncscope("singlethreaded") release {alignment = 16 : i64} : f64, !llvm.ptr
+ ; CHECK: llvm.store %[[V1]], %[[PTR]] atomic release alignment = 8 : f64, !llvm.ptr
+ ; CHECK: llvm.store volatile %[[V2]], %[[PTR]] atomic syncscope("singlethreaded") release alignment = 16 : f64, !llvm.ptr
store atomic double %1, ptr %ptr release, align 8
store atomic volatile double %2, ptr %ptr syncscope("singlethreaded") release, align 16
ret void
@@ -483,7 +483,7 @@ define void @atomic_rmw(ptr %ptr1, i32 %val1, ptr %ptr2, float %val2) {
; CHECK: llvm.atomicrmw volatile
; CHECK-SAME: syncscope("singlethread")
- ; CHECK-SAME: {alignment = 8 : i64}
+ ; CHECK-SAME: alignment = 8
%22 = atomicrmw volatile udec_wrap ptr %ptr1, i32 %val1 syncscope("singlethread") acquire, align 8
ret void
}
@@ -502,7 +502,7 @@ define void @atomic_cmpxchg(ptr %ptr1, i32 %val1, i32 %val2) {
; CHECK: llvm.cmpxchg weak volatile
; CHECK-SAME: syncscope("singlethread")
- ; CHECK-SAME: {alignment = 8 : i64}
+ ; CHECK-SAME: alignment = 8
%3 = cmpxchg weak volatile ptr %ptr1, i32 %val1, i32 %val2 syncscope("singlethread") monotonic seq_cst, align 8
ret void
}
diff --git a/mlir/test/Target/LLVMIR/Import/intrinsic.ll b/mlir/test/Target/LLVMIR/Import/intrinsic.ll
index e201145e6575f..f2a5456f8f9f6 100644
--- a/mlir/test/Target/LLVMIR/Import/intrinsic.ll
+++ b/mlir/test/Target/LLVMIR/Import/intrinsic.ll
@@ -465,13 +465,13 @@ define void @vector_reductions(float %0, <8 x float> %1, <8 x i32> %2) {
%12 = call i32 @llvm.vector.reduce.umax.v8i32(<8 x i32> %2)
; CHECK: "llvm.intr.vector.reduce.umin"(%{{.*}}) : (vector<8xi32>) -> i32
%13 = call i32 @llvm.vector.reduce.umin.v8i32(<8 x i32> %2)
- ; CHECK: "llvm.intr.vector.reduce.fadd"(%{{.*}}, %{{.*}}) <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<8xf32>) -> f32
+ ; CHECK: llvm.intr.vector.reduce.fadd(%{{.*}}, %{{.*}}) : (f32, vector<8xf32>) -> f32
%14 = call float @llvm.vector.reduce.fadd.v8f32(float %0, <8 x float> %1)
- ; CHECK: "llvm.intr.vector.reduce.fmul"(%{{.*}}, %{{.*}}) <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<8xf32>) -> f32
+ ; CHECK: llvm.intr.vector.reduce.fmul(%{{.*}}, %{{.*}}) : (f32, vector<8xf32>) -> f32
%15 = call float @llvm.vector.reduce.fmul.v8f32(float %0, <8 x float> %1)
- ; CHECK: "llvm.intr.vector.reduce.fadd"(%{{.*}}, %{{.*}}) <{fastmathFlags = #llvm.fastmath<reassoc>}> : (f32, vector<8xf32>) -> f32
+ ; CHECK: llvm.intr.vector.reduce.fadd(%{{.*}}, %{{.*}}) fastmath<reassoc> : (f32, vector<8xf32>) -> f32
%16 = call reassoc float @llvm.vector.reduce.fadd.v8f32(float %0, <8 x float> %1)
- ; CHECK: "llvm.intr.vector.reduce.fmul"(%{{.*}}, %{{.*}}) <{fastmathFlags = #llvm.fastmath<reassoc>}> : (f32, vector<8xf32>) -> f32
+ ; CHECK: llvm.intr.vector.reduce.fmul(%{{.*}}, %{{.*}}) fastmath<reassoc> : (f32, vector<8xf32>) -> f32
%17 = call reassoc float @llvm.vector.reduce.fmul.v8f32(float %0, <8 x float> %1)
; CHECK: "llvm.intr.vector.reduce.xor"(%{{.*}}) : (vector<8xi32>) -> i32
%18 = call i32 @llvm.vector.reduce.xor.v8i32(<8 x i32> %2)
@@ -489,16 +489,16 @@ define void @vector_reductions(float %0, <8 x float> %1, <8 x i32> %2) {
; CHECK-SAME: %[[STRIDE:[a-zA-Z0-9]+]]
define void @matrix_intrinsics(<64 x float> %vec1, <48 x float> %vec2, ptr %ptr, i64 %stride) {
; CHECK: llvm.intr.matrix.multiply %[[VEC1]], %[[VEC2]]
- ; CHECK-SAME: {lhs_columns = 16 : i32, lhs_rows = 4 : i32, rhs_columns = 3 : i32}
+ ; CHECK-SAME: lhs_rows = 4 lhs_columns = 16 rhs_columns = 3
%1 = call <12 x float> @llvm.matrix.multiply.v12f32.v64f32.v48f32(<64 x float> %vec1, <48 x float> %vec2, i32 4, i32 16, i32 3)
; CHECK: llvm.intr.matrix.transpose %[[VEC2]]
- ; CHECK-SAME: {columns = 16 : i32, rows = 3 : i32}
+ ; CHECK-SAME: rows = 3 columns = 16
%2 = call <48 x float> @llvm.matrix.transpose.v48f32(<48 x float> %vec2, i32 3, i32 16)
; CHECK: %[[VAL1:.+]] = llvm.intr.matrix.column.major.load %[[PTR]], <stride = %[[STRIDE]]>
- ; CHECK-SAME: {columns = 16 : i32, isVolatile = false, rows = 3 : i32}
+ ; CHECK-SAME: is_volatile = false rows = 3 columns = 16
%3 = call <48 x float> @llvm.matrix.column.major.load.v48f32.i64(ptr align 4 %ptr, i64 %stride, i1 false, i32 3, i32 16)
; CHECK: llvm.intr.matrix.column.major.store %[[VAL1]], %[[PTR]], <stride = %[[STRIDE]]>
- ; CHECK-SAME: {columns = 16 : i32, isVolatile = true, rows = 3 : i32}
+ ; CHECK-SAME: is_volatile = true rows = 3 columns = 16
call void @llvm.matrix.column.major.store.v48f32.i64(<48 x float> %3, ptr align 4 %ptr, i64 %stride, i1 true, i32 3, i32 16)
ret void
}
@@ -515,17 +515,17 @@ define <7 x i1> @get_active_lane_mask(i64 %0, i64 %1) {
; CHECK-SAME: %[[MASK:[a-zA-Z0-9]+]]
define void @masked_load_store_intrinsics(ptr %vec, <7 x i1> %mask) {
; CHECK: %[[UNDEF:.+]] = llvm.mlir.undef
- ; CHECK: %[[VAL1:.+]] = llvm.intr.masked.load %[[VEC]], %[[MASK]], %[[UNDEF]] {alignment = 1 : i32}
+ ; CHECK: %[[VAL1:.+]] = llvm.intr.masked.load %[[VEC]], %[[MASK]], %[[UNDEF]] alignment = 1
; CHECK-SAME: (!llvm.ptr, vector<7xi1>, vector<7xf32>) -> vector<7xf32>
%1 = call <7 x float> @llvm.masked.load.v7f32.p0(ptr %vec, i32 1, <7 x i1> %mask, <7 x float> undef)
- ; CHECK: %[[VAL2:.+]] = llvm.intr.masked.load %[[VEC]], %[[MASK]], %[[VAL1]] {alignment = 4 : i32}
+ ; CHECK: %[[VAL2:.+]] = llvm.intr.masked.load %[[VEC]], %[[MASK]], %[[VAL1]] alignment = 4
%2 = call <7 x float> @llvm.masked.load.v7f32.p0(ptr %vec, i32 4, <7 x i1> %mask, <7 x float> %1)
- ; CHECK: %[[VAL3:.+]] = llvm.intr.masked.load %[[VEC]], %[[MASK]], %[[VAL1]] {alignment = 4 : i32, nontemporal}
+ ; CHECK: %[[VAL3:.+]] = llvm.intr.masked.load %[[VEC]], %[[MASK]], %[[VAL1]] alignment = 4 nontemporal
%3 = call <7 x float> @llvm.masked.load.v7f32.p0(ptr %vec, i32 4, <7 x i1> %mask, <7 x float> %1), !nontemporal !{i32 1}
- ; CHECK: llvm.intr.masked.store %[[VAL2]], %[[VEC]], %[[MASK]] {alignment = 8 : i32}
+ ; CHECK: llvm.intr.masked.store %[[VAL2]], %[[VEC]], %[[MASK]] alignment = 8
; CHECK-SAME: vector<7xf32>, vector<7xi1> into !llvm.ptr
call void @llvm.masked.store.v7f32.p0(<7 x float> %2, ptr %vec, i32 8, <7 x i1> %mask)
- ; CHECK: llvm.intr.masked.store %[[VAL2]], %[[VEC]], %[[MASK]] {alignment = 8 : i32, nontemporal}
+ ; CHECK: llvm.intr.masked.store %[[VAL2]], %[[VEC]], %[[MASK]] alignment = 8 nontemporal
; CHECK-SAME: vector<7xf32>, vector<7xi1> into !llvm.ptr
call void @llvm.masked.store.v7f32.p0(<7 x float> %2, ptr %vec, i32 8, <7 x i1> %mask), !nontemporal !{i32 1}
ret void
@@ -536,12 +536,12 @@ define void @masked_load_store_intrinsics(ptr %vec, <7 x i1> %mask) {
; CHECK-SAME: %[[MASK:[a-zA-Z0-9]+]]
define void @masked_gather_scatter_intrinsics(<7 x ptr> %vec, <7 x i1> %mask) {
; CHECK: %[[UNDEF:.+]] = llvm.mlir.undef
- ; CHECK: %[[VAL1:.+]] = llvm.intr.masked.gather %[[VEC]], %[[MASK]], %[[UNDEF]] {alignment = 1 : i32}
+ ; CHECK: %[[VAL1:.+]] = llvm.intr.masked.gather %[[VEC]], %[[MASK]], %[[UNDEF]] alignment = 1
; CHECK-SAME: (vector<7x!llvm.ptr>, vector<7xi1>, vector<7xf32>) -> vector<7xf32>
%1 = call <7 x float> @llvm.masked.gather.v7f32.v7p0(<7 x ptr> %vec, i32 1, <7 x i1> %mask, <7 x float> undef)
- ; CHECK: %[[VAL2:.+]] = llvm.intr.masked.gather %[[VEC]], %[[MASK]], %[[VAL1]] {alignment = 4 : i32}
+ ; CHECK: %[[VAL2:.+]] = llvm.intr.masked.gather %[[VEC]], %[[MASK]], %[[VAL1]] alignment = 4
%2 = call <7 x float> @llvm.masked.gather.v7f32.v7p0(<7 x ptr> %vec, i32 4, <7 x i1> %mask, <7 x float> %1)
- ; CHECK: llvm.intr.masked.scatter %[[VAL2]], %[[VEC]], %[[MASK]] {alignment = 8 : i32}
+ ; CHECK: llvm.intr.masked.scatter %[[VAL2]], %[[VEC]], %[[MASK]] alignment = 8
; CHECK-SAME: vector<7xf32>, vector<7xi1> into vector<7x!llvm.ptr>
call void @llvm.masked.scatter.v7f32.v7p0(<7 x float> %2, <7 x ptr> %vec, i32 8, <7 x i1> %mask)
ret void
@@ -582,7 +582,7 @@ define void @trap_intrinsics() {
call void @llvm.trap()
; CHECK: llvm.intr.debugtrap
call void @llvm.debugtrap()
- ; CHECK: llvm.intr.ubsantrap <{failureKind = 1 : i8}>
+ ; CHECK: llvm.intr.ubsantrap failureKind = 1
call void @llvm.ubsantrap(i8 1)
ret void
}
@@ -1176,7 +1176,7 @@ define void @experimental_constrained_fadd(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.fadd.f32(float %s, float %s, metadata !"round.towardzero", metadata !"fpexcept.ignore")
; CHECK: llvm.intr.experimental.constrained.fadd %{{.*}}, %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.fadd.v4f32(<4 x float> %v, <4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.fadd %{{.*}}, %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nnan, nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.fadd %{{.*}}, %{{.*}} tonearest strict fastmath<nnan, nsz> : f32
%3 = call nnan nsz float @llvm.experimental.constrained.fadd.f32(float %s, float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1305,7 +1305,7 @@ define void @experimental_constrained_sqrt(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.sqrt.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.sqrt %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.sqrt.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.sqrt %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.sqrt %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.sqrt.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1316,7 +1316,7 @@ define void @experimental_constrained_sin(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.sin.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.sin %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.sin.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.sin %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.sin %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.sin.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1327,7 +1327,7 @@ define void @experimental_constrained_cos(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.cos.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.cos %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.cos.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.cos %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.cos %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.cos.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1338,7 +1338,7 @@ define void @experimental_constrained_tan(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.tan.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.tan %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.tan.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.tan %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.tan %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.tan.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1349,7 +1349,7 @@ define void @experimental_constrained_asin(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.asin.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.asin %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.asin.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.asin %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.asin %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.asin.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1360,7 +1360,7 @@ define void @experimental_constrained_acos(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.acos.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.acos %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.acos.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.acos %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.acos %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.acos.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1371,7 +1371,7 @@ define void @experimental_constrained_atan(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.atan.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.atan %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.atan.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.atan %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.atan %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.atan.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1382,7 +1382,7 @@ define void @experimental_constrained_sinh(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.sinh.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.sinh %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.sinh.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.sinh %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.sinh %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.sinh.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1393,7 +1393,7 @@ define void @experimental_constrained_cosh(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.cosh.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.cosh %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.cosh.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.cosh %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.cosh %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.cosh.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1404,7 +1404,7 @@ define void @experimental_constrained_tanh(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.tanh.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.tanh %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.tanh.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.tanh %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.tanh %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.tanh.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1415,7 +1415,7 @@ define void @experimental_constrained_exp(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.exp.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.exp %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.exp.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.exp %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.exp %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.exp.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1426,7 +1426,7 @@ define void @experimental_constrained_exp2(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.exp2.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.exp2 %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.exp2.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.exp2 %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.exp2 %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.exp2.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1437,7 +1437,7 @@ define void @experimental_constrained_log(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.log.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.log %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.log.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.log %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.log %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.log.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1448,7 +1448,7 @@ define void @experimental_constrained_log10(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.log10.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.log10 %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.log10.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.log10 %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.log10 %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.log10.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1459,7 +1459,7 @@ define void @experimental_constrained_log2(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.log2.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.log2 %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.log2.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.log2 %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.log2 %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.log2.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1470,7 +1470,7 @@ define void @experimental_constrained_rint(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.rint.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.rint %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.rint.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.rint %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.rint %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.rint.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1481,7 +1481,7 @@ define void @experimental_constrained_nearbyint(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.nearbyint.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.nearbyint %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.nearbyint.v4f32(<4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.nearbyint %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.nearbyint %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.nearbyint.f32(float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1537,7 +1537,7 @@ define void @experimental_constrained_pow(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.pow.f32(float %s, float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.pow %{{.*}}, %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.pow.v4f32(<4 x float> %v, <4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.pow %{{.*}}, %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.pow %{{.*}}, %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.pow.f32(float %s, float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1548,7 +1548,7 @@ define void @experimental_constrained_atan2(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.atan2.f32(float %s, float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.atan2 %{{.*}}, %{{.*}} towardzero ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.atan2.v4f32(<4 x float> %v, <4 x float> %v, metadata !"round.towardzero", metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.atan2 %{{.*}}, %{{.*}} tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.atan2 %{{.*}}, %{{.*}} tonearest strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.atan2.f32(float %s, float %s, metadata !"round.tonearest", metadata !"fpexcept.strict")
ret void
}
@@ -1559,7 +1559,7 @@ define void @experimental_constrained_maxnum(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.maxnum.f32(float %s, float %s, metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.maxnum %{{.*}}, %{{.*}} ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.maxnum.v4f32(<4 x float> %v, <4 x float> %v, metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.maxnum %{{.*}}, %{{.*}} strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.maxnum %{{.*}}, %{{.*}} strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.maxnum.f32(float %s, float %s, metadata !"fpexcept.strict")
ret void
}
@@ -1570,7 +1570,7 @@ define void @experimental_constrained_minnum(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.minnum.f32(float %s, float %s, metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.minnum %{{.*}}, %{{.*}} ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.minnum.v4f32(<4 x float> %v, <4 x float> %v, metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.minnum %{{.*}}, %{{.*}} strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.minnum %{{.*}}, %{{.*}} strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.minnum.f32(float %s, float %s, metadata !"fpexcept.strict")
ret void
}
@@ -1581,7 +1581,7 @@ define void @experimental_constrained_maximum(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.maximum.f32(float %s, float %s, metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.maximum %{{.*}}, %{{.*}} ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.maximum.v4f32(<4 x float> %v, <4 x float> %v, metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.maximum %{{.*}}, %{{.*}} strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.maximum %{{.*}}, %{{.*}} strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.maximum.f32(float %s, float %s, metadata !"fpexcept.strict")
ret void
}
@@ -1592,7 +1592,7 @@ define void @experimental_constrained_minimum(float %s, <4 x float> %v) {
%1 = call float @llvm.experimental.constrained.minimum.f32(float %s, float %s, metadata !"fpexcept.strict")
; CHECK: llvm.intr.experimental.constrained.minimum %{{.*}}, %{{.*}} ignore : vector<4xf32>
%2 = call <4 x float> @llvm.experimental.constrained.minimum.v4f32(<4 x float> %v, <4 x float> %v, metadata !"fpexcept.ignore")
- ; CHECK: llvm.intr.experimental.constrained.minimum %{{.*}}, %{{.*}} strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ ; CHECK: llvm.intr.experimental.constrained.minimum %{{.*}}, %{{.*}} strict fastmath<nsz> : f32
%3 = call nsz float @llvm.experimental.constrained.minimum.f32(float %s, float %s, metadata !"fpexcept.strict")
ret void
}
diff --git a/mlir/test/Target/LLVMIR/Import/metadata-loop.ll b/mlir/test/Target/LLVMIR/Import/metadata-loop.ll
index fcdff0573e31f..89357186409e3 100644
--- a/mlir/test/Target/LLVMIR/Import/metadata-loop.ll
+++ b/mlir/test/Target/LLVMIR/Import/metadata-loop.ll
@@ -59,7 +59,7 @@ declare void @foo(ptr %arg1)
; CHECK-LABEL: @simple
define void @simple(i64 %n, ptr %A) {
entry:
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -79,7 +79,7 @@ end:
; CHECK-LABEL: @vectorize
define void @vectorize(i64 %n, ptr %A) {
entry:
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -105,7 +105,7 @@ end:
; CHECK-LABEL: @interleave
define void @interleave(i64 %n, ptr %A) {
entry:
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -123,7 +123,7 @@ end:
; CHECK-LABEL: @unroll
define void @unroll(i64 %n, ptr %A) {
entry:
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -149,7 +149,7 @@ end:
; CHECK-LABEL: @unroll_disable
define void @unroll_disable(i64 %n, ptr %A) {
entry:
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -167,7 +167,7 @@ end:
; CHECK-LABEL: @unroll_and_jam
define void @unroll_and_jam(i64 %n, ptr %A) {
entry:
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -193,7 +193,7 @@ end:
; CHECK-LABEL: @licm
define void @licm(i64 %n, ptr %A) {
entry:
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -212,7 +212,7 @@ end:
; CHECK-LABEL: @distribute
define void @distribute(i64 %n, ptr %A) {
entry:
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -236,7 +236,7 @@ end:
; CHECK-LABEL: @pipeline
define void @pipeline(i64 %n, ptr %A) {
entry:
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -254,7 +254,7 @@ end:
; CHECK-LABEL: @peeled
define void @peeled(i64 %n, ptr %A) {
entry:
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -271,7 +271,7 @@ end:
; CHECK-LABEL: @unswitched
define void @unswitched(i64 %n, ptr %A) {
entry:
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -289,7 +289,7 @@ end:
define void @parallel_accesses(ptr %arg) {
entry:
%0 = load i32, ptr %arg, !llvm.access.group !0
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -310,7 +310,7 @@ define void @multiple_parallel_accesses(ptr %arg) {
entry:
%0 = load i32, ptr %arg, !llvm.access.group !0
%1 = load i32, ptr %arg, !llvm.access.group !3
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !1
end:
ret void
@@ -355,7 +355,7 @@ end:
; CHECK-LABEL: @loop_locs
define void @loop_locs(i64 %n, ptr %A) {
entry:
-; CHECK: llvm.br ^{{.*}} {loop_annotation = #[[$ANNOT_ATTR]]}
+; CHECK: llvm.br ^{{.*}} loop_annotation = #[[$ANNOT_ATTR]]
br label %end, !llvm.loop !6
end:
ret void
diff --git a/mlir/test/Target/LLVMIR/Import/metadata-profiling.ll b/mlir/test/Target/LLVMIR/Import/metadata-profiling.ll
index 328062545ed63..5c53c28a9a5ec 100644
--- a/mlir/test/Target/LLVMIR/Import/metadata-profiling.ll
+++ b/mlir/test/Target/LLVMIR/Import/metadata-profiling.ll
@@ -35,7 +35,7 @@ bb2:
; CHECK-LABEL: @simple_switch(
define i32 @simple_switch(i32 %arg1) {
; CHECK: llvm.switch
- ; CHECK: {branch_weights = array<i32: 42, 3, 5>}
+ ; CHECK: weights([42, 3, 5])
switch i32 %arg1, label %bbd [
i32 0, label %bb1
i32 9, label %bb2
@@ -55,7 +55,7 @@ bbd:
; CHECK-LABEL: @simple_switch_expected(
define i32 @simple_switch_expected(i32 %arg1) {
; CHECK: llvm.switch
- ; CHECK: {branch_weights = array<i32: 1, 1, 2000>}
+ ; CHECK: weights([1, 1, 2000])
switch i32 %arg1, label %bbd [
i32 0, label %bb1
i32 9, label %bb2
diff --git a/mlir/test/Target/LLVMIR/Import/metadata-tbaa.ll b/mlir/test/Target/LLVMIR/Import/metadata-tbaa.ll
index 2a7685c4e0247..c32a3e09090a9 100644
--- a/mlir/test/Target/LLVMIR/Import/metadata-tbaa.ll
+++ b/mlir/test/Target/LLVMIR/Import/metadata-tbaa.ll
@@ -8,12 +8,8 @@
; CHECK-DAG: #[[$T1:.*]] = #llvm.tbaa_tag<base_type = #[[D1]], access_type = #[[D1]], offset = 0>
; CHECK-LABEL: llvm.func @tbaa1
-; CHECK: llvm.store %{{.*}}, %{{.*}} {
-; CHECK-SAME: tbaa = [#[[$T0]]]
-; CHECK-SAME: } : i8, !llvm.ptr
-; CHECK: llvm.store %{{.*}}, %{{.*}} {
-; CHECK-SAME: tbaa = [#[[$T1]]]
-; CHECK-SAME: } : i8, !llvm.ptr
+; CHECK: llvm.store %{{.*}}, %{{.*}} alignment = 4 tbaa = [#[[$T0]]] : i8, !llvm.ptr
+; CHECK: llvm.store %{{.*}}, %{{.*}} alignment = 4 tbaa = [#[[$T1]]] : i8, !llvm.ptr
define dso_local void @tbaa1(ptr %0, ptr %1) {
store i8 1, ptr %0, align 4, !tbaa !0
store i8 1, ptr %1, align 4, !tbaa !3
@@ -40,12 +36,8 @@ define dso_local void @tbaa1(ptr %0, ptr %1) {
; CHECK-DAG: #[[D4]] = #llvm.tbaa_type_desc<id = "agg1_t", members = {<#[[D3]], 0>, <#[[D3]], 4>}>
; CHECK-LABEL: llvm.func @tbaa2
-; CHECK: llvm.load %{{.*}} {
-; CHECK-SAME: tbaa = [#[[$T0]]]
-; CHECK-SAME: } : !llvm.ptr -> i64
-; CHECK: llvm.store %{{.*}}, %{{.*}} {
-; CHECK-SAME: tbaa = [#[[$T1]]]
-; CHECK-SAME: } : i32, !llvm.ptr
+; CHECK: llvm.load %{{.*}} alignment = 8 tbaa = [#[[$T0]]] : !llvm.ptr -> i64
+; CHECK: llvm.store %{{.*}}, %{{.*}} alignment = 4 tbaa = [#[[$T1]]] : i32, !llvm.ptr
%struct.agg2_t = type { i64, i64 }
%struct.agg1_t = type { i32, i32 }
@@ -111,4 +103,3 @@ define void @nameless_root(ptr %arg1) {
!0 = !{!1, !1, i64 0}
!1 = !{!"scalar type", !2, i64 0}
!2 = !{}
-
diff --git a/mlir/test/Target/LLVMIR/Import/target-ext-type.ll b/mlir/test/Target/LLVMIR/Import/target-ext-type.ll
index 3c575b71038bf..fdb4fdd9a48b9 100644
--- a/mlir/test/Target/LLVMIR/Import/target-ext-type.ll
+++ b/mlir/test/Target/LLVMIR/Import/target-ext-type.ll
@@ -37,7 +37,7 @@ define target("spirv.Event") @func2() {
; CHECK-NEXT: %1 = llvm.mlir.poison : !llvm.target<"spirv.Event">
; CHECK-NEXT: %2 = llvm.alloca %0 x !llvm.target<"spirv.Event"> {alignment = 8 : i64} : (i32) -> !llvm.ptr
%mem = alloca target("spirv.Event")
- ; CHECK-NEXT: %3 = llvm.load %2 {alignment = 8 : i64} : !llvm.ptr -> !llvm.target<"spirv.Event">
+ ; CHECK-NEXT: %3 = llvm.load %2 alignment = 8 : !llvm.ptr -> !llvm.target<"spirv.Event">
%val = load target("spirv.Event"), ptr %mem
; CHECK-NEXT: llvm.return %1 : !llvm.target<"spirv.Event">
ret target("spirv.Event") poison
diff --git a/mlir/test/Target/LLVMIR/allocatable_gpu_reduction.mlir b/mlir/test/Target/LLVMIR/allocatable_gpu_reduction.mlir
index d37eb4e1eea7b..ea1516d69f3e2 100644
--- a/mlir/test/Target/LLVMIR/allocatable_gpu_reduction.mlir
+++ b/mlir/test/Target/LLVMIR/allocatable_gpu_reduction.mlir
@@ -32,7 +32,7 @@ module attributes {dlti.dl_spec = #dlti.dl_spec<"dlti.alloca_memory_space" = 5 :
%11 = llvm.load %10 : !llvm.ptr -> !llvm.ptr
%12 = llvm.load %9 : !llvm.ptr -> f32
%13 = llvm.load %11 : !llvm.ptr -> f32
- %14 = llvm.fadd %12, %13 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %14 = llvm.fadd %12, %13 fastmath<contract> : f32
llvm.store %14, %9 : f32, !llvm.ptr
omp.yield(%arg0 : !llvm.ptr)
} data_ptr_ptr {
diff --git a/mlir/test/Target/LLVMIR/allocatable_gpu_reduction_teams.mlir b/mlir/test/Target/LLVMIR/allocatable_gpu_reduction_teams.mlir
index 7c564b65f446e..56d87fb58404f 100644
--- a/mlir/test/Target/LLVMIR/allocatable_gpu_reduction_teams.mlir
+++ b/mlir/test/Target/LLVMIR/allocatable_gpu_reduction_teams.mlir
@@ -30,7 +30,7 @@ module attributes {dlti.dl_spec = #dlti.dl_spec<"dlti.alloca_memory_space" = 5 :
%11 = llvm.load %10 : !llvm.ptr -> !llvm.ptr
%12 = llvm.load %9 : !llvm.ptr -> f32
%13 = llvm.load %11 : !llvm.ptr -> f32
- %14 = llvm.fadd %12, %13 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %14 = llvm.fadd %12, %13 fastmath<contract> : f32
llvm.store %14, %9 : f32, !llvm.ptr
omp.yield(%arg0 : !llvm.ptr)
} data_ptr_ptr {
diff --git a/mlir/test/Target/LLVMIR/anonymous-tbaa.mlir b/mlir/test/Target/LLVMIR/anonymous-tbaa.mlir
index b54bfe47e0807..5569607b96d52 100644
--- a/mlir/test/Target/LLVMIR/anonymous-tbaa.mlir
+++ b/mlir/test/Target/LLVMIR/anonymous-tbaa.mlir
@@ -16,6 +16,6 @@
// CHECK: ![[BASE]] = !{!"omnipotent char", ![[ROOT:[0-9]+]], i64 0}
// CHECK: ![[ROOT]] = distinct !{![[ROOT]]}
llvm.func @tbaa_anonymous_root(%arg0: !llvm.ptr) {
- %0 = llvm.load %arg0 {tbaa = [#tbaa_tag_3]} : !llvm.ptr -> i64
+ %0 = llvm.load %arg0 tbaa = [#tbaa_tag_3] : !llvm.ptr -> i64
llvm.return
}
diff --git a/mlir/test/Target/LLVMIR/attribute-alias-scopes.mlir b/mlir/test/Target/LLVMIR/attribute-alias-scopes.mlir
index ae399d4f7edef..f6672deb97be6 100644
--- a/mlir/test/Target/LLVMIR/attribute-alias-scopes.mlir
+++ b/mlir/test/Target/LLVMIR/attribute-alias-scopes.mlir
@@ -13,13 +13,13 @@ llvm.func @alias_scopes(%arg1 : !llvm.ptr) {
// CHECK: call void @llvm.experimental.noalias.scope.decl(metadata ![[SCOPES1:[0-9]+]])
llvm.intr.experimental.noalias.scope.decl #alias_scope1
// CHECK: store {{.*}}, !alias.scope ![[SCOPES1]], !noalias ![[SCOPES23:[0-9]+]]
- llvm.store %0, %arg1 {alias_scopes = [#alias_scope1], noalias_scopes = [#alias_scope2, #alias_scope3]} : i32, !llvm.ptr
+ llvm.store %0, %arg1 alias_scopes = [#alias_scope1] noalias_scopes = [#alias_scope2, #alias_scope3] : i32, !llvm.ptr
// CHECK: load {{.*}}, !alias.scope ![[SCOPES2:[0-9]+]], !noalias ![[SCOPES13:[0-9]+]]
- %1 = llvm.load %arg1 {alias_scopes = [#alias_scope2], noalias_scopes = [#alias_scope1, #alias_scope3]} : !llvm.ptr -> i32
+ %1 = llvm.load %arg1 alias_scopes = [#alias_scope2] noalias_scopes = [#alias_scope1, #alias_scope3] : !llvm.ptr -> i32
// CHECK: atomicrmw {{.*}}, !alias.scope ![[SCOPES3:[0-9]+]], !noalias ![[SCOPES12:[0-9]+]]
- %2 = llvm.atomicrmw add %arg1, %0 monotonic {alias_scopes = [#alias_scope3], noalias_scopes = [#alias_scope1, #alias_scope2]} : !llvm.ptr, i32
+ %2 = llvm.atomicrmw add %arg1, %0 monotonic alias_scopes = [#alias_scope3] noalias_scopes = [#alias_scope1, #alias_scope2] : !llvm.ptr, i32
// CHECK: cmpxchg {{.*}}, !alias.scope ![[SCOPES3]]
- %3 = llvm.cmpxchg %arg1, %1, %2 acq_rel monotonic {alias_scopes = [#alias_scope3]} : !llvm.ptr, i32
+ %3 = llvm.cmpxchg %arg1, %1, %2 acq_rel monotonic alias_scopes = [#alias_scope3] : !llvm.ptr, i32
%5 = llvm.mlir.constant(42 : i8) : i8
// CHECK: llvm.memcpy{{.*}}, !alias.scope ![[SCOPES3]]
"llvm.intr.memcpy"(%arg1, %arg1, %0) <{isVolatile = false}> {alias_scopes = [#alias_scope3]} : (!llvm.ptr, !llvm.ptr, i32) -> ()
@@ -120,13 +120,13 @@ llvm.func @alias_scopes(%arg1 : !llvm.ptr) {
// CHECK: call void @llvm.experimental.noalias.scope.decl(metadata ![[SCOPES1:[0-9]+]])
llvm.intr.experimental.noalias.scope.decl #alias_scope1
// CHECK: store {{.*}}, !alias.scope ![[SCOPES1]], !noalias ![[SCOPES23:[0-9]+]]
- llvm.store %0, %arg1 {alias_scopes = [#alias_scope1], noalias_scopes = [#alias_scope2, #alias_scope3]} : i32, !llvm.ptr
+ llvm.store %0, %arg1 alias_scopes = [#alias_scope1] noalias_scopes = [#alias_scope2, #alias_scope3] : i32, !llvm.ptr
// CHECK: load {{.*}}, !alias.scope ![[SCOPES2:[0-9]+]], !noalias ![[SCOPES13:[0-9]+]]
- %1 = llvm.load %arg1 {alias_scopes = [#alias_scope2], noalias_scopes = [#alias_scope1, #alias_scope3]} : !llvm.ptr -> i32
+ %1 = llvm.load %arg1 alias_scopes = [#alias_scope2] noalias_scopes = [#alias_scope1, #alias_scope3] : !llvm.ptr -> i32
// CHECK: atomicrmw {{.*}}, !alias.scope ![[SCOPES3:[0-9]+]], !noalias ![[SCOPES12:[0-9]+]]
- %2 = llvm.atomicrmw add %arg1, %0 monotonic {alias_scopes = [#alias_scope3], noalias_scopes = [#alias_scope1, #alias_scope2]} : !llvm.ptr, i32
+ %2 = llvm.atomicrmw add %arg1, %0 monotonic alias_scopes = [#alias_scope3] noalias_scopes = [#alias_scope1, #alias_scope2] : !llvm.ptr, i32
// CHECK: cmpxchg {{.*}}, !alias.scope ![[SCOPES3]]
- %3 = llvm.cmpxchg %arg1, %1, %2 acq_rel monotonic {alias_scopes = [#alias_scope3]} : !llvm.ptr, i32
+ %3 = llvm.cmpxchg %arg1, %1, %2 acq_rel monotonic alias_scopes = [#alias_scope3] : !llvm.ptr, i32
%5 = llvm.mlir.constant(42 : i8) : i8
// CHECK: llvm.memcpy{{.*}}, !alias.scope ![[SCOPES3]]
"llvm.intr.memcpy"(%arg1, %arg1, %0) <{isVolatile = false}> {alias_scopes = [#alias_scope3]} : (!llvm.ptr, !llvm.ptr, i32) -> ()
diff --git a/mlir/test/Target/LLVMIR/attribute-dereferenceable.mlir b/mlir/test/Target/LLVMIR/attribute-dereferenceable.mlir
index 6e7f03110faa7..f6c980238b24b 100644
--- a/mlir/test/Target/LLVMIR/attribute-dereferenceable.mlir
+++ b/mlir/test/Target/LLVMIR/attribute-dereferenceable.mlir
@@ -3,20 +3,20 @@
llvm.func @deref(%arg0: i64, %arg1: !llvm.ptr) {
// CHECK: inttoptr {{.*}} !dereferenceable [[D0:![0-9]+]]
%0 = llvm.inttoptr %arg0 dereferenceable<bytes = 4> : i64 to !llvm.ptr
- %1 = llvm.load %0 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %1 = llvm.load %0 alignment = 4 : !llvm.ptr -> i32
// CHECK: load {{.*}} !dereferenceable [[D1:![0-9]+]]
- %2 = llvm.load %arg1 dereferenceable<bytes = 8> {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
- llvm.store %1, %2 {alignment = 4 : i64} : i32, !llvm.ptr
+ %2 = llvm.load %arg1 dereferenceable<bytes = 8> alignment = 8 : !llvm.ptr -> !llvm.ptr
+ llvm.store %1, %2 alignment = 4 : i32, !llvm.ptr
llvm.return
}
llvm.func @deref_or_null(%arg0: i64, %arg1: !llvm.ptr) {
// CHECK: inttoptr {{.*}} !dereferenceable_or_null [[D0]]
%0 = llvm.inttoptr %arg0 dereferenceable<bytes = 4, mayBeNull = true> : i64 to !llvm.ptr
- %1 = llvm.load %0 {alignment = 4 : i64} : !llvm.ptr -> i32
+ %1 = llvm.load %0 alignment = 4 : !llvm.ptr -> i32
// CHECK: load {{.*}} !dereferenceable_or_null [[D1]]
- %2 = llvm.load %arg1 dereferenceable<bytes = 8, mayBeNull = true> {alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
- llvm.store %1, %2 {alignment = 4 : i64} : i32, !llvm.ptr
+ %2 = llvm.load %arg1 dereferenceable<bytes = 8, mayBeNull = true> alignment = 8 : !llvm.ptr -> !llvm.ptr
+ llvm.store %1, %2 alignment = 4 : i32, !llvm.ptr
llvm.return
}
diff --git a/mlir/test/Target/LLVMIR/attribute-tbaa.mlir b/mlir/test/Target/LLVMIR/attribute-tbaa.mlir
index 69b666a1ec353..ace61101b3c87 100644
--- a/mlir/test/Target/LLVMIR/attribute-tbaa.mlir
+++ b/mlir/test/Target/LLVMIR/attribute-tbaa.mlir
@@ -14,11 +14,11 @@ llvm.func @tbaa2(%arg0: !llvm.ptr, %arg1: !llvm.ptr) {
%1 = llvm.mlir.constant(1 : i32) : i32
%2 = llvm.getelementptr inbounds %arg1[%0, 1] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg2_t", (i64, i64)>
// CHECK: load i64, ptr %{{.*}},{{.*}}!tbaa ![[LTAG:[0-9]*]]
- %3 = llvm.load %2 {tbaa = [#tbaa_tag_4]} : !llvm.ptr -> i64
+ %3 = llvm.load %2 tbaa = [#tbaa_tag_4] : !llvm.ptr -> i64
%4 = llvm.trunc %3 : i64 to i32
%5 = llvm.getelementptr inbounds %arg0[%0, 0] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg1_t", (i32, i32)>
// CHECK: store i32 %{{.*}}, ptr %{{.*}},{{.*}}!tbaa ![[STAG:[0-9]*]]
- llvm.store %4, %5 {tbaa = [#tbaa_tag_7]} : i32, !llvm.ptr
+ llvm.store %4, %5 tbaa = [#tbaa_tag_7] : i32, !llvm.ptr
llvm.return
}
@@ -58,15 +58,15 @@ llvm.func @tbaa2(%arg0: !llvm.ptr, %arg1: !llvm.ptr) {
%1 = llvm.mlir.constant(1 : i32) : i32
%2 = llvm.getelementptr inbounds %arg1[%0, 0] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg2_t", (f32, f32)>
// CHECK: load float, ptr %{{.*}},{{.*}}!tbaa ![[LTAG:[0-9]*]]
- %3 = llvm.load %2 {tbaa = [#tbaa_tag_4]} : !llvm.ptr -> f32
+ %3 = llvm.load %2 tbaa = [#tbaa_tag_4] : !llvm.ptr -> f32
%4 = llvm.fptosi %3 : f32 to i32
%5 = llvm.getelementptr inbounds %arg0[%0, 0] : (!llvm.ptr, i32) -> !llvm.ptr, !llvm.struct<"struct.agg1_t", (i32, i32)>
// CHECK: store i32 %{{.*}}, ptr %{{.*}},{{.*}}!tbaa ![[STAG:[0-9]*]]
- llvm.store %4, %5 {tbaa = [#tbaa_tag_7]} : i32, !llvm.ptr
+ llvm.store %4, %5 tbaa = [#tbaa_tag_7] : i32, !llvm.ptr
// CHECK: atomicrmw add ptr %{{.*}}, i32 %{{.*}} !tbaa ![[STAG]]
- %6 = llvm.atomicrmw add %5, %4 monotonic {tbaa = [#tbaa_tag_7]} : !llvm.ptr, i32
+ %6 = llvm.atomicrmw add %5, %4 monotonic tbaa = [#tbaa_tag_7] : !llvm.ptr, i32
// CHECK: cmpxchg ptr %{{.*}}, i32 %{{.*}}, i32 %{{.*}} !tbaa ![[STAG]]
- %7 = llvm.cmpxchg %5, %6, %4 acq_rel monotonic {tbaa = [#tbaa_tag_7]} : !llvm.ptr, i32
+ %7 = llvm.cmpxchg %5, %6, %4 acq_rel monotonic tbaa = [#tbaa_tag_7] : !llvm.ptr, i32
%9 = llvm.mlir.constant(42 : i8) : i8
// CHECK: llvm.memcpy{{.*}} !tbaa ![[STAG]]
"llvm.intr.memcpy"(%arg1, %arg1, %0) <{isVolatile = false}> {tbaa = [#tbaa_tag_7]} : (!llvm.ptr, !llvm.ptr, i32) -> ()
diff --git a/mlir/test/Target/LLVMIR/ifunc.mlir b/mlir/test/Target/LLVMIR/ifunc.mlir
index bba306c1e1ab3..c2ed11ee7b472 100644
--- a/mlir/test/Target/LLVMIR/ifunc.mlir
+++ b/mlir/test/Target/LLVMIR/ifunc.mlir
@@ -1,7 +1,7 @@
// RUN: mlir-translate -mlir-to-llvmir %s --split-input-file | FileCheck %s
// CHECK: @foo = dso_local ifunc void (ptr, i32), ptr @resolve_foo
-llvm.mlir.ifunc external @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @resolve_foo {dso_local}
+llvm.mlir.ifunc external @foo : !llvm.func<void (ptr, i32)>, !llvm.ptr @resolve_foo dso_local
llvm.func @call_foo(%arg0: !llvm.ptr {llvm.noundef}, %arg1: i32 {llvm.noundef}) attributes {dso_local} {
// CHECK: call void @foo
llvm.call @foo(%arg0, %arg1) : (!llvm.ptr {llvm.noundef}, i32 {llvm.noundef}) -> ()
@@ -42,7 +42,7 @@ llvm.func @resolver() -> !llvm.ptr {
// -----
// CHECK: @ifunc = linkonce_odr hidden ifunc
-llvm.mlir.ifunc linkonce_odr hidden @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver {dso_local}
+llvm.mlir.ifunc linkonce_odr hidden @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver dso_local
llvm.func @resolver() -> !llvm.ptr {
%0 = llvm.mlir.constant(333 : i64) : i64
%1 = llvm.inttoptr %0 : i64 to !llvm.ptr
@@ -52,7 +52,7 @@ llvm.func @resolver() -> !llvm.ptr {
// -----
// CHECK: @ifunc = private ifunc
-llvm.mlir.ifunc private @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver {dso_local}
+llvm.mlir.ifunc private @ifunc : !llvm.func<f32 (i64)>, !llvm.ptr @resolver dso_local
llvm.func @resolver() -> !llvm.ptr {
%0 = llvm.mlir.constant(333 : i64) : i64
%1 = llvm.inttoptr %0 : i64 to !llvm.ptr
diff --git a/mlir/test/Target/LLVMIR/llvmir-intrinsics.mlir b/mlir/test/Target/LLVMIR/llvmir-intrinsics.mlir
index 13d4155e4ca04..c48d20d65b343 100644
--- a/mlir/test/Target/LLVMIR/llvmir-intrinsics.mlir
+++ b/mlir/test/Target/LLVMIR/llvmir-intrinsics.mlir
@@ -538,18 +538,18 @@ llvm.func @matrix_intrinsics(%A: vector<64 x f32>, %B: vector<48 x f32>,
%ptr: !llvm.ptr, %stride: i64) {
// CHECK: call <12 x float> @llvm.matrix.multiply.v12f32.v64f32.v48f32(<64 x float> %0, <48 x float> %1, i32 4, i32 16, i32 3)
%C = llvm.intr.matrix.multiply %A, %B
- { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32} :
+ lhs_rows = 4 lhs_columns = 16 rhs_columns = 3 :
(vector<64 x f32>, vector<48 x f32>) -> vector<12 x f32>
// CHECK: call <48 x float> @llvm.matrix.transpose.v48f32(<48 x float> %1, i32 3, i32 16)
- %D = llvm.intr.matrix.transpose %B { rows = 3: i32, columns = 16: i32} :
+ %D = llvm.intr.matrix.transpose %B rows = 3 columns = 16 :
vector<48 x f32> into vector<48 x f32>
// CHECK: call <48 x float> @llvm.matrix.column.major.load.v48f32.i64(ptr align 4 %2, i64 %3, i1 false, i32 3, i32 16)
%E = llvm.intr.matrix.column.major.load %ptr, <stride=%stride>
- { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
+ is_volatile = false rows = 3 columns = 16 :
vector<48 x f32> from !llvm.ptr stride i64
// CHECK: call void @llvm.matrix.column.major.store.v48f32.i64(<48 x float> %7, ptr align 4 %2, i64 %3, i1 false, i32 3, i32 16)
llvm.intr.matrix.column.major.store %E, %ptr, <stride=%stride>
- { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
+ is_volatile = false rows = 3 columns = 16 :
vector<48 x f32> to !llvm.ptr stride i64
llvm.return
}
@@ -564,19 +564,19 @@ llvm.func @get_active_lane_mask(%base: i64, %n: i64) -> (vector<7xi1>) {
// CHECK-LABEL: @masked_load_store_intrinsics
llvm.func @masked_load_store_intrinsics(%A: !llvm.ptr, %mask: vector<7xi1>) {
// CHECK: call <7 x float> @llvm.masked.load.v7f32.p0(ptr align 1 %{{.*}}, <7 x i1> %{{.*}}, <7 x float> poison)
- %a = llvm.intr.masked.load %A, %mask { alignment = 1: i32} :
+ %a = llvm.intr.masked.load %A, %mask alignment = 1 :
(!llvm.ptr, vector<7xi1>) -> vector<7xf32>
// CHECK: call <7 x float> @llvm.masked.load.v7f32.p0(ptr align 1 %{{.*}}, <7 x i1> %{{.*}}, <7 x float> poison), !nontemporal !1
- %b = llvm.intr.masked.load %A, %mask { alignment = 1: i32, nontemporal} :
+ %b = llvm.intr.masked.load %A, %mask alignment = 1 nontemporal :
(!llvm.ptr, vector<7xi1>) -> vector<7xf32>
// CHECK: call <7 x float> @llvm.masked.load.v7f32.p0(ptr align 1 %{{.*}}, <7 x i1> %{{.*}}, <7 x float> %{{.*}})
- %c = llvm.intr.masked.load %A, %mask, %a { alignment = 1: i32} :
+ %c = llvm.intr.masked.load %A, %mask, %a alignment = 1 :
(!llvm.ptr, vector<7xi1>, vector<7xf32>) -> vector<7xf32>
// CHECK: call void @llvm.masked.store.v7f32.p0(<7 x float> %{{.*}}, ptr align 1 %0, <7 x i1> %{{.*}})
- llvm.intr.masked.store %b, %A, %mask { alignment = 1: i32} :
+ llvm.intr.masked.store %b, %A, %mask alignment = 1 :
vector<7xf32>, vector<7xi1> into !llvm.ptr
// CHECK: call void @llvm.masked.store.v7f32.p0(<7 x float> %{{.*}}, ptr align 1 %0, <7 x i1> %{{.*}}), !nontemporal !{{.*}}
- llvm.intr.masked.store %b, %A, %mask { alignment = 1: i32, nontemporal} :
+ llvm.intr.masked.store %b, %A, %mask alignment = 1 nontemporal :
vector<7xf32>, vector<7xi1> into !llvm.ptr
llvm.return
}
@@ -584,13 +584,13 @@ llvm.func @masked_load_store_intrinsics(%A: !llvm.ptr, %mask: vector<7xi1>) {
// CHECK-LABEL: @masked_gather_scatter_intrinsics
llvm.func @masked_gather_scatter_intrinsics(%M: vector<7 x !llvm.ptr>, %mask: vector<7xi1>) {
// CHECK: call <7 x float> @llvm.masked.gather.v7f32.v7p0(<7 x ptr> align 1 %{{.*}}, <7 x i1> %{{.*}}, <7 x float> poison)
- %a = llvm.intr.masked.gather %M, %mask { alignment = 1: i32} :
+ %a = llvm.intr.masked.gather %M, %mask alignment = 1 :
(vector<7 x !llvm.ptr>, vector<7xi1>) -> vector<7xf32>
// CHECK: call <7 x float> @llvm.masked.gather.v7f32.v7p0(<7 x ptr> align 1 %{{.*}}, <7 x i1> %{{.*}}, <7 x float> %{{.*}})
- %b = llvm.intr.masked.gather %M, %mask, %a { alignment = 1: i32} :
+ %b = llvm.intr.masked.gather %M, %mask, %a alignment = 1 :
(vector<7 x !llvm.ptr>, vector<7xi1>, vector<7xf32>) -> vector<7xf32>
// CHECK: call void @llvm.masked.scatter.v7f32.v7p0(<7 x float> %{{.*}}, <7 x ptr> align 1 %{{.*}}, <7 x i1> %{{.*}})
- llvm.intr.masked.scatter %b, %M, %mask { alignment = 1: i32} :
+ llvm.intr.masked.scatter %b, %M, %mask alignment = 1 :
vector<7xf32>, vector<7xi1> into vector<7 x !llvm.ptr>
llvm.return
}
@@ -642,7 +642,7 @@ llvm.func @trap_intrinsics() {
// CHECK: call void @llvm.debugtrap()
llvm.intr.debugtrap
// CHECK: call void @llvm.ubsantrap(i8 1)
- llvm.intr.ubsantrap <{failureKind = 1 : i8}>
+ llvm.intr.ubsantrap failureKind = 1
llvm.return
}
@@ -1303,7 +1303,7 @@ llvm.func @experimental_constrained_fadd(%s: f32, %v: vector<4 x f32>) attribute
// CHECK: call nnan nsz float @llvm.experimental.constrained.fadd.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.fadd %s, %s tonearest strict {fastmathFlags = #llvm.fastmath<nnan, nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.fadd %s, %s tonearest strict fastmath<nnan, nsz> : f32
llvm.return
}
@@ -1502,7 +1502,7 @@ llvm.func @experimental_constrained_sqrt(%s: f32, %v: vector<4 x f32>) attribute
// CHECK: call nsz float @llvm.experimental.constrained.sqrt.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.sqrt %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.sqrt %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1519,7 +1519,7 @@ llvm.func @experimental_constrained_sin(%s: f32, %v: vector<4 x f32>) attributes
// CHECK: call nsz float @llvm.experimental.constrained.sin.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.sin %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.sin %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1536,7 +1536,7 @@ llvm.func @experimental_constrained_cos(%s: f32, %v: vector<4 x f32>) attributes
// CHECK: call nsz float @llvm.experimental.constrained.cos.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.cos %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.cos %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1553,7 +1553,7 @@ llvm.func @experimental_constrained_tan(%s: f32, %v: vector<4 x f32>) attributes
// CHECK: call nsz float @llvm.experimental.constrained.tan.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.tan %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.tan %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1570,7 +1570,7 @@ llvm.func @experimental_constrained_asin(%s: f32, %v: vector<4 x f32>) attribute
// CHECK: call nsz float @llvm.experimental.constrained.asin.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.asin %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.asin %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1587,7 +1587,7 @@ llvm.func @experimental_constrained_acos(%s: f32, %v: vector<4 x f32>) attribute
// CHECK: call nsz float @llvm.experimental.constrained.acos.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.acos %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.acos %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1604,7 +1604,7 @@ llvm.func @experimental_constrained_atan(%s: f32, %v: vector<4 x f32>) attribute
// CHECK: call nsz float @llvm.experimental.constrained.atan.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.atan %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.atan %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1621,7 +1621,7 @@ llvm.func @experimental_constrained_sinh(%s: f32, %v: vector<4 x f32>) attribute
// CHECK: call nsz float @llvm.experimental.constrained.sinh.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.sinh %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.sinh %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1638,7 +1638,7 @@ llvm.func @experimental_constrained_cosh(%s: f32, %v: vector<4 x f32>) attribute
// CHECK: call nsz float @llvm.experimental.constrained.cosh.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.cosh %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.cosh %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1655,7 +1655,7 @@ llvm.func @experimental_constrained_tanh(%s: f32, %v: vector<4 x f32>) attribute
// CHECK: call nsz float @llvm.experimental.constrained.tanh.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.tanh %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.tanh %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1672,7 +1672,7 @@ llvm.func @experimental_constrained_exp(%s: f32, %v: vector<4 x f32>) attributes
// CHECK: call nsz float @llvm.experimental.constrained.exp.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.exp %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.exp %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1689,7 +1689,7 @@ llvm.func @experimental_constrained_exp2(%s: f32, %v: vector<4 x f32>) attribute
// CHECK: call nsz float @llvm.experimental.constrained.exp2.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.exp2 %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.exp2 %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1706,7 +1706,7 @@ llvm.func @experimental_constrained_log(%s: f32, %v: vector<4 x f32>) attributes
// CHECK: call nsz float @llvm.experimental.constrained.log.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.log %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.log %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1723,7 +1723,7 @@ llvm.func @experimental_constrained_log10(%s: f32, %v: vector<4 x f32>) attribut
// CHECK: call nsz float @llvm.experimental.constrained.log10.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.log10 %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.log10 %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1740,7 +1740,7 @@ llvm.func @experimental_constrained_log2(%s: f32, %v: vector<4 x f32>) attribute
// CHECK: call nsz float @llvm.experimental.constrained.log2.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.log2 %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.log2 %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1757,7 +1757,7 @@ llvm.func @experimental_constrained_rint(%s: f32, %v: vector<4 x f32>) attribute
// CHECK: call nsz float @llvm.experimental.constrained.rint.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.rint %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.rint %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1774,7 +1774,7 @@ llvm.func @experimental_constrained_nearbyint(%s: f32, %v: vector<4 x f32>) attr
// CHECK: call nsz float @llvm.experimental.constrained.nearbyint.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.nearbyint %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.nearbyint %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1846,7 +1846,7 @@ llvm.func @experimental_constrained_pow(%s: f32, %v: vector<4 x f32>) attributes
// CHECK: call nsz float @llvm.experimental.constrained.pow.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.pow %s, %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.pow %s, %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1863,7 +1863,7 @@ llvm.func @experimental_constrained_atan2(%s: f32, %v: vector<4 x f32>) attribut
// CHECK: call nsz float @llvm.experimental.constrained.atan2.f32(
// CHECK: metadata !"round.tonearest"
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.atan2 %s, %s tonearest strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.atan2 %s, %s tonearest strict fastmath<nsz> : f32
llvm.return
}
@@ -1877,7 +1877,7 @@ llvm.func @experimental_constrained_maxnum(%s: f32, %v: vector<4 x f32>) attribu
%1 = llvm.intr.experimental.constrained.maxnum %v, %v ignore : vector<4 x f32>
// CHECK: call nsz float @llvm.experimental.constrained.maxnum.f32(
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.maxnum %s, %s strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.maxnum %s, %s strict fastmath<nsz> : f32
llvm.return
}
@@ -1891,7 +1891,7 @@ llvm.func @experimental_constrained_minnum(%s: f32, %v: vector<4 x f32>) attribu
%1 = llvm.intr.experimental.constrained.minnum %v, %v ignore : vector<4 x f32>
// CHECK: call nsz float @llvm.experimental.constrained.minnum.f32(
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.minnum %s, %s strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.minnum %s, %s strict fastmath<nsz> : f32
llvm.return
}
@@ -1905,7 +1905,7 @@ llvm.func @experimental_constrained_maximum(%s: f32, %v: vector<4 x f32>) attrib
%1 = llvm.intr.experimental.constrained.maximum %v, %v ignore : vector<4 x f32>
// CHECK: call nsz float @llvm.experimental.constrained.maximum.f32(
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.maximum %s, %s strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.maximum %s, %s strict fastmath<nsz> : f32
llvm.return
}
@@ -1919,7 +1919,7 @@ llvm.func @experimental_constrained_minimum(%s: f32, %v: vector<4 x f32>) attrib
%1 = llvm.intr.experimental.constrained.minimum %v, %v ignore : vector<4 x f32>
// CHECK: call nsz float @llvm.experimental.constrained.minimum.f32(
// CHECK: metadata !"fpexcept.strict"
- %2 = llvm.intr.experimental.constrained.minimum %s, %s strict {fastmathFlags = #llvm.fastmath<nsz>} : f32
+ %2 = llvm.intr.experimental.constrained.minimum %s, %s strict fastmath<nsz> : f32
llvm.return
}
diff --git a/mlir/test/Target/LLVMIR/llvmir-invalid.mlir b/mlir/test/Target/LLVMIR/llvmir-invalid.mlir
index ef6681ca3821f..2e3fe8618b100 100644
--- a/mlir/test/Target/LLVMIR/llvmir-invalid.mlir
+++ b/mlir/test/Target/LLVMIR/llvmir-invalid.mlir
@@ -156,7 +156,7 @@ llvm.func @vec_reduce_fmax_intr_wrong_type(%arg0 : vector<4xi32>) -> i32 {
llvm.func @matrix_load_intr_wrong_type(%ptr : !llvm.ptr, %stride : i32) -> f32 {
// expected-error @+2{{invalid kind of type specified: expected builtin.vector, but found 'f32'}}
%0 = llvm.intr.matrix.column.major.load %ptr, <stride=%stride>
- { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} : f32 from !llvm.ptr stride i32
+ is_volatile = false rows = 3 columns = 16 : f32 from !llvm.ptr stride i32
llvm.return %0 : f32
}
@@ -165,7 +165,7 @@ llvm.func @matrix_load_intr_wrong_type(%ptr : !llvm.ptr, %stride : i32) -> f32 {
llvm.func @matrix_store_intr_wrong_type(%matrix : vector<48xf32>, %ptr : i32, %stride : i64) {
// expected-error @below {{op operand #1 must be LLVM pointer type, but got 'i32'}}
llvm.intr.matrix.column.major.store %matrix, %ptr, <stride=%stride>
- { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} : vector<48xf32> to i32 stride i64
+ is_volatile = false rows = 3 columns = 16 : vector<48xf32> to i32 stride i64
llvm.return
}
@@ -174,7 +174,7 @@ llvm.func @matrix_store_intr_wrong_type(%matrix : vector<48xf32>, %ptr : i32, %s
llvm.func @matrix_multiply_intr_wrong_type(%arg0 : vector<64xf32>, %arg1 : f32) -> vector<12xf32> {
// expected-error @+2{{invalid kind of type specified: expected builtin.vector, but found 'f32'}}
%0 = llvm.intr.matrix.multiply %arg0, %arg1
- { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32} : (vector<64xf32>, f32) -> vector<12xf32>
+ lhs_rows = 4 lhs_columns = 16 rhs_columns = 3 : (vector<64xf32>, f32) -> vector<12xf32>
llvm.return %0 : vector<12xf32>
}
@@ -182,7 +182,7 @@ llvm.func @matrix_multiply_intr_wrong_type(%arg0 : vector<64xf32>, %arg1 : f32)
llvm.func @matrix_transpose_intr_wrong_type(%matrix : f32) -> vector<48xf32> {
// expected-error @below{{invalid kind of type specified: expected builtin.vector, but found 'f32'}}
- %0 = llvm.intr.matrix.transpose %matrix {rows = 3: i32, columns = 16: i32} : f32 into vector<48xf32>
+ %0 = llvm.intr.matrix.transpose %matrix rows = 3 columns = 16 : f32 into vector<48xf32>
llvm.return %0 : vector<48xf32>
}
@@ -198,7 +198,7 @@ llvm.func @active_lane_intr_wrong_type(%base : i64, %n : vector<7xi64>) -> vecto
llvm.func @masked_load_intr_wrong_type(%ptr : i64, %mask : vector<7xi1>) -> vector<7xf32> {
// expected-error @below{{op operand #0 must be LLVM pointer type, but got 'i64'}}
- %0 = llvm.intr.masked.load %ptr, %mask { alignment = 1: i32} : (i64, vector<7xi1>) -> vector<7xf32>
+ %0 = llvm.intr.masked.load %ptr, %mask alignment = 1 : (i64, vector<7xi1>) -> vector<7xf32>
llvm.return %0 : vector<7xf32>
}
@@ -206,7 +206,7 @@ llvm.func @masked_load_intr_wrong_type(%ptr : i64, %mask : vector<7xi1>) -> vect
llvm.func @masked_store_intr_wrong_type(%vec : vector<7xf32>, %ptr : !llvm.ptr, %mask : vector<7xi32>) {
// expected-error @below{{op operand #2 must be LLVM dialect-compatible vector of 1-bit signless integer, but got 'vector<7xi32>}}
- llvm.intr.masked.store %vec, %ptr, %mask { alignment = 1: i32} : vector<7xf32>, vector<7xi32> into !llvm.ptr
+ llvm.intr.masked.store %vec, %ptr, %mask alignment = 1 : vector<7xf32>, vector<7xi32> into !llvm.ptr
llvm.return
}
@@ -214,7 +214,7 @@ llvm.func @masked_store_intr_wrong_type(%vec : vector<7xf32>, %ptr : !llvm.ptr,
llvm.func @masked_gather_intr_wrong_type(%ptrs : vector<7xf32>, %mask : vector<7xi1>) -> vector<7xf32> {
// expected-error @below{{op operand #0 must be LLVM dialect-compatible vector of LLVM pointer type, but got 'vector<7xf32>'}}
- %0 = llvm.intr.masked.gather %ptrs, %mask { alignment = 1: i32} : (vector<7xf32>, vector<7xi1>) -> vector<7xf32>
+ %0 = llvm.intr.masked.gather %ptrs, %mask alignment = 1 : (vector<7xf32>, vector<7xi1>) -> vector<7xf32>
llvm.return %0 : vector<7xf32>
}
@@ -222,7 +222,7 @@ llvm.func @masked_gather_intr_wrong_type(%ptrs : vector<7xf32>, %mask : vector<7
llvm.func @masked_gather_intr_wrong_type_scalable(%ptrs : vector<7x!llvm.ptr>, %mask : vector<[7]xi1>) -> vector<[7]xf32> {
// expected-error @below{{expected operand #1 type to be 'vector<[7]x!llvm.ptr>'}}
- %0 = llvm.intr.masked.gather %ptrs, %mask { alignment = 1: i32} : (vector<7x!llvm.ptr>, vector<[7]xi1>) -> vector<[7]xf32>
+ %0 = llvm.intr.masked.gather %ptrs, %mask alignment = 1 : (vector<7x!llvm.ptr>, vector<[7]xi1>) -> vector<[7]xf32>
llvm.return %0 : vector<[7]xf32>
}
@@ -230,7 +230,7 @@ llvm.func @masked_gather_intr_wrong_type_scalable(%ptrs : vector<7x!llvm.ptr>, %
llvm.func @masked_scatter_intr_wrong_type(%vec : f32, %ptrs : vector<7x!llvm.ptr>, %mask : vector<7xi1>) {
// expected-error @below{{invalid kind of type specified: expected builtin.vector, but found 'f32'}}
- llvm.intr.masked.scatter %vec, %ptrs, %mask { alignment = 1: i32} : f32, vector<7xi1> into vector<7x!llvm.ptr>
+ llvm.intr.masked.scatter %vec, %ptrs, %mask alignment = 1 : f32, vector<7xi1> into vector<7x!llvm.ptr>
llvm.return
}
@@ -238,7 +238,7 @@ llvm.func @masked_scatter_intr_wrong_type(%vec : f32, %ptrs : vector<7x!llvm.ptr
llvm.func @masked_scatter_intr_wrong_type_scalable(%vec : vector<[7]xf32>, %ptrs : vector<7x!llvm.ptr>, %mask : vector<[7]xi1>) {
// expected-error @below{{expected operand #2 type to be 'vector<[7]x!llvm.ptr>'}}
- llvm.intr.masked.scatter %vec, %ptrs, %mask { alignment = 1: i32} : vector<[7]xf32>, vector<[7]xi1> into vector<7x!llvm.ptr>
+ llvm.intr.masked.scatter %vec, %ptrs, %mask alignment = 1 : vector<[7]xf32>, vector<[7]xi1> into vector<7x!llvm.ptr>
llvm.return
}
diff --git a/mlir/test/Target/LLVMIR/llvmir.mlir b/mlir/test/Target/LLVMIR/llvmir.mlir
index f27c0a46780f2..c0480ed5ed6ce 100644
--- a/mlir/test/Target/LLVMIR/llvmir.mlir
+++ b/mlir/test/Target/LLVMIR/llvmir.mlir
@@ -1662,7 +1662,7 @@ llvm.func @atomicrmw(
// CHECK: atomicrmw volatile
// CHECK-SAME: syncscope("singlethread")
// CHECK-SAME: align 8
- %27 = llvm.atomicrmw volatile udec_wrap %i32_ptr, %i32 syncscope("singlethread") monotonic {alignment = 8 : i64} : !llvm.ptr, i32
+ %27 = llvm.atomicrmw volatile udec_wrap %i32_ptr, %i32 syncscope("singlethread") monotonic alignment = 8 : !llvm.ptr, i32
llvm.return
}
@@ -1678,7 +1678,7 @@ llvm.func @cmpxchg(%ptr : !llvm.ptr, %cmp : i32, %val: i32) {
// CHECK: cmpxchg weak volatile
// CHECK-SAME: syncscope("singlethread")
// CHECK-SAME: align 8
- %3 = llvm.cmpxchg weak volatile %ptr, %cmp, %val syncscope("singlethread") acq_rel monotonic {alignment = 8 : i64} : !llvm.ptr, i32
+ %3 = llvm.cmpxchg weak volatile %ptr, %cmp, %val syncscope("singlethread") acq_rel monotonic alignment = 8 : !llvm.ptr, i32
llvm.return
}
@@ -2089,9 +2089,9 @@ llvm.func @nontemporal_store_and_load() {
%size = llvm.mlir.constant(1 : i64) : i64
%0 = llvm.alloca %size x i32 : (i64) -> (!llvm.ptr)
// CHECK: !nontemporal ![[NODE:[0-9]+]]
- llvm.store %val, %0 {nontemporal} : i32, !llvm.ptr
+ llvm.store %val, %0 nontemporal : i32, !llvm.ptr
// CHECK: !nontemporal ![[NODE]]
- %1 = llvm.load %0 {nontemporal} : !llvm.ptr -> i32
+ %1 = llvm.load %0 nontemporal : !llvm.ptr -> i32
llvm.return
}
@@ -2127,17 +2127,17 @@ llvm.func @nontemporal_store_and_load(%ptr : !llvm.ptr) -> i32 {
llvm.func @atomic_store_and_load(%ptr : !llvm.ptr) {
// CHECK: load atomic
// CHECK-SAME: acquire, align 4
- %1 = llvm.load %ptr atomic acquire {alignment = 4 : i64} : !llvm.ptr -> f32
+ %1 = llvm.load %ptr atomic acquire alignment = 4 : !llvm.ptr -> f32
// CHECK: load atomic
// CHECK-SAME: syncscope("singlethread") acquire, align 4
- %2 = llvm.load %ptr atomic syncscope("singlethread") acquire {alignment = 4 : i64} : !llvm.ptr -> f32
+ %2 = llvm.load %ptr atomic syncscope("singlethread") acquire alignment = 4 : !llvm.ptr -> f32
// CHECK: store atomic
// CHECK-SAME: release, align 4
- llvm.store %1, %ptr atomic release {alignment = 4 : i64} : f32, !llvm.ptr
+ llvm.store %1, %ptr atomic release alignment = 4 : f32, !llvm.ptr
// CHECK: store atomic
// CHECK-SAME: syncscope("singlethread") release, align 4
- llvm.store %2, %ptr atomic syncscope("singlethread") release {alignment = 4 : i64} : f32, !llvm.ptr
+ llvm.store %2, %ptr atomic syncscope("singlethread") release alignment = 4 : f32, !llvm.ptr
llvm.return
}
@@ -2242,17 +2242,17 @@ llvm.func @fastmathFlags(%arg0: f32, %arg1 : vector<2xf32>) {
// CHECK: {{.*}} = fmul nnan ninf float {{.*}}, {{.*}}
// CHECK: {{.*}} = fdiv nnan ninf float {{.*}}, {{.*}}
// CHECK: {{.*}} = frem nnan ninf float {{.*}}, {{.*}}
- %0 = llvm.fadd %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
- %1 = llvm.fsub %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
- %2 = llvm.fmul %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
- %3 = llvm.fdiv %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
- %4 = llvm.frem %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
+ %0 = llvm.fadd %arg0, %arg0 fastmath<nnan, ninf> : f32
+ %1 = llvm.fsub %arg0, %arg0 fastmath<nnan, ninf> : f32
+ %2 = llvm.fmul %arg0, %arg0 fastmath<nnan, ninf> : f32
+ %3 = llvm.fdiv %arg0, %arg0 fastmath<nnan, ninf> : f32
+ %4 = llvm.frem %arg0, %arg0 fastmath<nnan, ninf> : f32
// CHECK: {{.*}} = fcmp nnan ninf oeq {{.*}}, {{.*}}
%5 = llvm.fcmp "oeq" %arg0, %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
// CHECK: {{.*}} = fneg nnan ninf float {{.*}}
- %6 = llvm.fneg %arg0 {fastmathFlags = #llvm.fastmath<nnan, ninf>} : f32
+ %6 = llvm.fneg %arg0 fastmath<nnan, ninf> : f32
// CHECK: {{.*}} = call float @fastmathFlagsFunc({{.*}})
// CHECK: {{.*}} = call nnan float @fastmathFlagsFunc({{.*}})
@@ -2286,17 +2286,17 @@ llvm.func @fastmathFlags(%arg0: f32, %arg1 : vector<2xf32>) {
// CHECK: call nnan float @llvm.vector.reduce.fmax.v2f32(<2 x float> {{.*}})
// CHECK: call nnan float @llvm.vector.reduce.fmin.v2f32(<2 x float> {{.*}})
- %21 = llvm.intr.vector.reduce.fmax(%arg1) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
- %22 = llvm.intr.vector.reduce.fmin(%arg1) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
+ %21 = llvm.intr.vector.reduce.fmax(%arg1) fastmath<nnan> : (vector<2xf32>) -> f32
+ %22 = llvm.intr.vector.reduce.fmin(%arg1) fastmath<nnan> : (vector<2xf32>) -> f32
// CHECK: call nnan float @llvm.vector.reduce.fmaximum.v2f32(<2 x float> {{.*}})
// CHECK: call nnan float @llvm.vector.reduce.fminimum.v2f32(<2 x float> {{.*}})
- %23 = llvm.intr.vector.reduce.fmaximum(%arg1) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
- %24 = llvm.intr.vector.reduce.fminimum(%arg1) {fastmathFlags = #llvm.fastmath<nnan>} : (vector<2xf32>) -> f32
+ %23 = llvm.intr.vector.reduce.fmaximum(%arg1) fastmath<nnan> : (vector<2xf32>) -> f32
+ %24 = llvm.intr.vector.reduce.fminimum(%arg1) fastmath<nnan> : (vector<2xf32>) -> f32
%25 = llvm.mlir.constant(true) : i1
// CHECK: select contract i1
- %26 = llvm.select %25, %arg0, %20 {fastmathFlags = #llvm.fastmath<contract>} : i1, f32
+ %26 = llvm.select %25, %arg0, %20 fastmath<contract> : i1, f32
// CHECK: {{.*}} = fpext nnan float {{.*}} to double
// CHECK: {{.*}} = fptrunc fast float {{.*}} to half
@@ -2364,7 +2364,7 @@ llvm.func @switch_weights(%arg0: i32) -> i32 {
llvm.switch %arg0 : i32, ^bb1(%0 : i32) [
9: ^bb2(%1, %2 : i32, i32),
99: ^bb3
- ] {branch_weights = array<i32 : 13, 17, 19>}
+ ] weights([13, 17, 19])
^bb1(%3: i32): // pred: ^bb0
llvm.return %3 : i32
diff --git a/mlir/test/Target/LLVMIR/loop-metadata.mlir b/mlir/test/Target/LLVMIR/loop-metadata.mlir
index 5fcb8f3918656..2cd3b09984ae6 100644
--- a/mlir/test/Target/LLVMIR/loop-metadata.mlir
+++ b/mlir/test/Target/LLVMIR/loop-metadata.mlir
@@ -3,7 +3,7 @@
// CHECK-LABEL: @disableNonForced
llvm.func @disableNonForced() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<disableNonforced = true>}
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<disableNonforced = true>
^bb1:
llvm.return
}
@@ -16,7 +16,7 @@ llvm.func @disableNonForced() {
// CHECK-LABEL: @mustprogress
llvm.func @mustprogress() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<mustProgress = true>}
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<mustProgress = true>
^bb1:
llvm.return
}
@@ -29,7 +29,7 @@ llvm.func @mustprogress() {
// CHECK-LABEL: @isvectorized
llvm.func @isvectorized() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<isVectorized = true>}
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<isVectorized = true>
^bb1:
llvm.return
}
@@ -44,10 +44,10 @@ llvm.func @isvectorized() {
// CHECK-LABEL: @vectorizeOptions
llvm.func @vectorizeOptions() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<vectorize = <
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<vectorize = <
disable = false, predicateEnable = true, scalableEnable = false, width = 16 : i32,
followupVectorized = #followup, followupEpilogue = #followup, followupAll = #followup>
- >}
+ >
^bb1:
llvm.return
}
@@ -68,7 +68,7 @@ llvm.func @vectorizeOptions() {
// CHECK-LABEL: @interleaveOptions
llvm.func @interleaveOptions() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<interleave = <count = 32 : i32>>}
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<interleave = <count = 32 : i32>>
^bb1:
llvm.return
}
@@ -83,10 +83,10 @@ llvm.func @interleaveOptions() {
// CHECK-LABEL: @unrollOptions
llvm.func @unrollOptions() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<unroll = <
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<unroll = <
disable = true, count = 64 : i32, runtimeDisable = false, full = false,
followupUnrolled = #followup, followupRemainder = #followup, followupAll = #followup>
- >}
+ >
^bb1:
llvm.return
}
@@ -106,7 +106,7 @@ llvm.func @unrollOptions() {
// CHECK-LABEL: @unrollOptions2
llvm.func @unrollOptions2() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<unroll = <disable = false, full = true>>}
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<unroll = <disable = false, full = true>>
^bb1:
llvm.return
}
@@ -122,10 +122,10 @@ llvm.func @unrollOptions2() {
// CHECK-LABEL: @unrollAndJamOptions
llvm.func @unrollAndJamOptions() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<unrollAndJam = <
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<unrollAndJam = <
disable = false, count = 8 : i32, followupOuter = #followup, followupInner = #followup,
followupRemainderOuter = #followup, followupRemainderInner = #followup, followupAll = #followup>
- >}
+ >
^bb1:
llvm.return
}
@@ -146,7 +146,7 @@ llvm.func @unrollAndJamOptions() {
// CHECK-LABEL: @licmOptions
llvm.func @licmOptions() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<licm = <disable = false, versioningDisable = true>>}
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<licm = <disable = false, versioningDisable = true>>
^bb1:
llvm.return
}
@@ -159,7 +159,7 @@ llvm.func @licmOptions() {
// CHECK-LABEL: @licmOptions2
llvm.func @licmOptions2() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<licm = <disable = true, versioningDisable = false>>}
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<licm = <disable = true, versioningDisable = false>>
^bb1:
llvm.return
}
@@ -174,10 +174,10 @@ llvm.func @licmOptions2() {
// CHECK-LABEL: @distributeOptions
llvm.func @distributeOptions() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<distribute = <
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<distribute = <
disable = true, followupCoincident = #followup, followupSequential = #followup,
followupFallback = #followup, followupAll = #followup>
- >}
+ >
^bb1:
llvm.return
}
@@ -196,7 +196,7 @@ llvm.func @distributeOptions() {
// CHECK-LABEL: @pipelineOptions
llvm.func @pipelineOptions() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<pipeline = <disable = false, initiationinterval = 1 : i32>>}
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<pipeline = <disable = false, initiationinterval = 1 : i32>>
^bb1:
llvm.return
}
@@ -210,7 +210,7 @@ llvm.func @pipelineOptions() {
// CHECK-LABEL: @peeledOptions
llvm.func @peeledOptions() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<peeled = <count = 3 : i32>>}
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<peeled = <count = 3 : i32>>
^bb1:
llvm.return
}
@@ -223,7 +223,7 @@ llvm.func @peeledOptions() {
// CHECK-LABEL: @unswitchOptions
llvm.func @unswitchOptions() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #llvm.loop_annotation<unswitch = <partialDisable = true>>}
+ llvm.br ^bb1 loop_annotation = #llvm.loop_annotation<unswitch = <partialDisable = true>>
^bb1:
llvm.return
}
@@ -246,21 +246,21 @@ llvm.func @loopOptions(%arg1 : i32, %arg2 : i32) {
^bb3(%1: i32):
%2 = llvm.icmp "slt" %1, %arg1 : i32
// CHECK: br i1 {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.cond_br %2, ^bb4, ^bb5 {loop_annotation = #llvm.loop_annotation<
+ llvm.cond_br %2, ^bb4, ^bb5 loop_annotation = #llvm.loop_annotation<
licm = <disable = true>,
interleave = <count = 1>,
unroll = <disable = true>, pipeline = <disable = true, initiationinterval = 2>,
- parallelAccesses = #group1, #group2>}
+ parallelAccesses = #group1, #group2>
^bb4:
%3 = llvm.add %1, %arg2 : i32
// CHECK: = load i32, ptr %{{.*}} !llvm.access.group ![[ACCESS_GROUPS_NODE:[0-9]+]]
- %5 = llvm.load %4 {access_groups = [#group1, #group2]} : !llvm.ptr -> i32
+ %5 = llvm.load %4 access_groups = [#group1, #group2] : !llvm.ptr -> i32
// CHECK: store i32 %{{.*}}, ptr %{{.*}} !llvm.access.group ![[ACCESS_GROUPS_NODE]]
- llvm.store %5, %4 {access_groups = [#group1, #group2]} : i32, !llvm.ptr
+ llvm.store %5, %4 access_groups = [#group1, #group2] : i32, !llvm.ptr
// CHECK: = atomicrmw add ptr %{{.*}}, i32 %{{.*}} !llvm.access.group ![[ACCESS_GROUPS_NODE]]
- %6 = llvm.atomicrmw add %4, %5 monotonic {access_groups = [#group1, #group2]} : !llvm.ptr, i32
+ %6 = llvm.atomicrmw add %4, %5 monotonic access_groups = [#group1, #group2] : !llvm.ptr, i32
// CHECK: = cmpxchg ptr %{{.*}}, i32 %{{.*}}, i32 %{{.*}} !llvm.access.group ![[ACCESS_GROUPS_NODE]]
- %7 = llvm.cmpxchg %4, %5, %6 acq_rel monotonic {access_groups = [#group1, #group2]} : !llvm.ptr, i32
+ %7 = llvm.cmpxchg %4, %5, %6 acq_rel monotonic access_groups = [#group1, #group2] : !llvm.ptr, i32
%9 = llvm.mlir.constant(42 : i8) : i8
// CHECK: llvm.memcpy{{.*}} !llvm.access.group ![[ACCESS_GROUPS_NODE]]
"llvm.intr.memcpy"(%4, %4, %0) <{isVolatile = false}> {access_groups = [#group1, #group2]} : (!llvm.ptr, !llvm.ptr, i32) -> ()
@@ -269,11 +269,11 @@ llvm.func @loopOptions(%arg1 : i32, %arg2 : i32) {
// CHECK: call void @foo({{.*}} !llvm.access.group ![[ACCESS_GROUPS_NODE]]
llvm.call @foo(%arg1) {access_groups = [#group1, #group2]} : (i32) -> ()
// CHECK: br label {{.*}} !llvm.loop ![[LOOP_NODE]]
- llvm.br ^bb3(%3 : i32) {loop_annotation = #llvm.loop_annotation<
+ llvm.br ^bb3(%3 : i32) loop_annotation = #llvm.loop_annotation<
licm = <disable = true>,
interleave = <count = 1>,
unroll = <disable = true>, pipeline = <disable = true, initiationinterval = 2>,
- parallelAccesses = #group1, #group2>}
+ parallelAccesses = #group1, #group2>
^bb5:
llvm.return
@@ -312,7 +312,7 @@ llvm.func @loopOptions(%arg1 : i32, %arg2 : i32) {
// CHECK-LABEL: @loop_annotation_with_locs
llvm.func @loop_annotation_with_locs() {
// CHECK: br {{.*}} !llvm.loop ![[LOOP_NODE:[0-9]+]]
- llvm.br ^bb1 {loop_annotation = #loopMD}
+ llvm.br ^bb1 loop_annotation = #loopMD
^bb1:
llvm.return
}
diff --git a/mlir/test/Target/LLVMIR/omptarget-debug-record-pos.mlir b/mlir/test/Target/LLVMIR/omptarget-debug-record-pos.mlir
index dabacf57a8e18..d725a533004f2 100644
--- a/mlir/test/Target/LLVMIR/omptarget-debug-record-pos.mlir
+++ b/mlir/test/Target/LLVMIR/omptarget-debug-record-pos.mlir
@@ -29,7 +29,7 @@ module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<"dlti.alloca_memo
%5 = llvm.mlir.constant(1.000000e+00 : f32) : f32 loc(#loc3)
llvm.intr.dbg.declare #var2 = %arg0 : !llvm.ptr loc(#loc3)
%6 = llvm.load %arg0 : !llvm.ptr -> f32 loc(#loc3)
- %7 = llvm.fadd %6, %5 {fastmathFlags = #llvm.fastmath<contract>} : f32 loc(#loc3)
+ %7 = llvm.fadd %6, %5 fastmath<contract> : f32 loc(#loc3)
llvm.store %7, %arg0 : f32, !llvm.ptr loc(#loc3)
omp.terminator loc(#loc3)
} loc(#loc4)
diff --git a/mlir/test/Target/LLVMIR/omptarget-multi-reduction.mlir b/mlir/test/Target/LLVMIR/omptarget-multi-reduction.mlir
index 10b8d8479399e..bb38623d31cd8 100644
--- a/mlir/test/Target/LLVMIR/omptarget-multi-reduction.mlir
+++ b/mlir/test/Target/LLVMIR/omptarget-multi-reduction.mlir
@@ -11,7 +11,7 @@ module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<"dlti.alloca_memo
omp.yield(%0 : f32)
} combiner {
^bb0(%arg0: f32, %arg1: f32):
- %0 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %0 = llvm.fadd %arg0, %arg1 fastmath<contract> : f32
omp.yield(%0 : f32)
}
omp.declare_reduction @add_reduction_f64 : f64 init {
@@ -20,7 +20,7 @@ module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<"dlti.alloca_memo
omp.yield(%0 : f64)
} combiner {
^bb0(%arg0: f64, %arg1: f64):
- %0 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<contract>} : f64
+ %0 = llvm.fadd %arg0, %arg1 fastmath<contract> : f64
omp.yield(%0 : f64)
}
llvm.func @_QQmain() attributes {fir.bindc_name = "reduction", frame_pointer = #llvm.framePointerKind<all>, omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (to)>, target_cpu = "gfx1030", target_features = #llvm.target_features<["+16-bit-insts", "+ci-insts", "+dl-insts", "+dot1-insts", "+dot10-insts", "+dot2-insts", "+dot5-insts", "+dot6-insts", "+dot7-insts", "+dpp", "+gfx10-3-insts", "+gfx10-insts", "+gfx8-insts", "+gfx9-insts", "+gws", "+image-insts", "+s-memrealtime", "+s-memtime-inst", "+vmem-to-lds-load-insts", "+wavefrontsize32"]>} {
@@ -76,16 +76,16 @@ module attributes {dlti.dl_spec = #dlti.dl_spec<#dlti.dl_entry<"dlti.alloca_memo
omp.loop_nest (%arg18) : i32 = (%38) to (%37) inclusive step (%38) {
llvm.store %arg18, %arg13 : i32, !llvm.ptr
%39 = llvm.load %arg14 : !llvm.ptr -> f64
- %40 = llvm.fadd %39, %36 {fastmathFlags = #llvm.fastmath<contract>} : f64
+ %40 = llvm.fadd %39, %36 fastmath<contract> : f64
llvm.store %40, %arg14 : f64, !llvm.ptr
%41 = llvm.load %arg15 : !llvm.ptr -> f64
- %42 = llvm.fadd %41, %36 {fastmathFlags = #llvm.fastmath<contract>} : f64
+ %42 = llvm.fadd %41, %36 fastmath<contract> : f64
llvm.store %42, %arg15 : f64, !llvm.ptr
%43 = llvm.load %arg16 : !llvm.ptr -> f32
- %44 = llvm.fadd %43, %35 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %44 = llvm.fadd %43, %35 fastmath<contract> : f32
llvm.store %44, %arg16 : f32, !llvm.ptr
%45 = llvm.load %arg17 : !llvm.ptr -> f32
- %46 = llvm.fadd %45, %35 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %46 = llvm.fadd %45, %35 fastmath<contract> : f32
llvm.store %46, %arg17 : f32, !llvm.ptr
omp.yield
}
diff --git a/mlir/test/Target/LLVMIR/omptarget-nowait.mlir b/mlir/test/Target/LLVMIR/omptarget-nowait.mlir
index d1a01c8d84369..f7a767d4a3b77 100644
--- a/mlir/test/Target/LLVMIR/omptarget-nowait.mlir
+++ b/mlir/test/Target/LLVMIR/omptarget-nowait.mlir
@@ -15,7 +15,7 @@ module attributes {omp.target_triples = ["amdgcn-amd-amdhsa"]} {
%7 = llvm.load %6 : !llvm.ptr -> !llvm.ptr
%8 = llvm.getelementptr %7[%one_i] : (!llvm.ptr, i64) -> !llvm.ptr, i8
%9 = llvm.load %8 : !llvm.ptr -> f64
- %10 = llvm.fmul %9, %two_f {fastmathFlags = #llvm.fastmath<contract>} : f64
+ %10 = llvm.fmul %9, %two_f fastmath<contract> : f64
llvm.store %10, %8 : f64, !llvm.ptr
omp.terminator
}
diff --git a/mlir/test/Target/LLVMIR/opaque-ptr.mlir b/mlir/test/Target/LLVMIR/opaque-ptr.mlir
index cd7c31a0945a8..03e2dd5d7bbbc 100644
--- a/mlir/test/Target/LLVMIR/opaque-ptr.mlir
+++ b/mlir/test/Target/LLVMIR/opaque-ptr.mlir
@@ -47,12 +47,12 @@ llvm.func @opaque_ptr_matrix_load_store(%ptr: !llvm.ptr, %stride: i64) -> vector
// CHECK: call <48 x float> @llvm.matrix.column.major.load.v48f32.i64
// CHECK: (ptr {{.*}}, i64 %{{.*}}
%0 = llvm.intr.matrix.column.major.load %ptr, <stride=%stride>
- { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
+ is_volatile = false rows = 3 columns = 16 :
vector<48 x f32> from !llvm.ptr stride i64
// CHECK: call void @llvm.matrix.column.major.store.v48f32.i64
// CHECK: <48 x float> %{{.*}}, ptr {{.*}}, i64
llvm.intr.matrix.column.major.store %0, %ptr, <stride=%stride>
- { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :
+ is_volatile = false rows = 3 columns = 16 :
vector<48 x f32> to !llvm.ptr stride i64
llvm.return %0 : vector<48 x f32>
}
@@ -60,7 +60,7 @@ llvm.func @opaque_ptr_matrix_load_store(%ptr: !llvm.ptr, %stride: i64) -> vector
// CHECK-LABEL: @opaque_ptr_masked_load
llvm.func @opaque_ptr_masked_load(%arg0: !llvm.ptr, %arg1: vector<7xi1>) -> vector<7xf32> {
// CHECK: call <7 x float> @llvm.masked.load.v7f32.p0(ptr
- %0 = llvm.intr.masked.load %arg0, %arg1 { alignment = 1: i32} :
+ %0 = llvm.intr.masked.load %arg0, %arg1 alignment = 1 :
(!llvm.ptr, vector<7xi1>) -> vector<7xf32>
llvm.return %0 : vector<7 x f32>
}
@@ -68,7 +68,7 @@ llvm.func @opaque_ptr_masked_load(%arg0: !llvm.ptr, %arg1: vector<7xi1>) -> vect
// CHECK-LABEL: @opaque_ptr_gather
llvm.func @opaque_ptr_gather(%M: vector<7 x !llvm.ptr>, %mask: vector<7xi1>) -> vector<7xf32> {
// CHECK: call <7 x float> @llvm.masked.gather.v7f32.v7p0(<7 x ptr> align 1 {{.*}},
- %a = llvm.intr.masked.gather %M, %mask { alignment = 1: i32} :
+ %a = llvm.intr.masked.gather %M, %mask alignment = 1 :
(vector<7 x !llvm.ptr>, vector<7xi1>) -> vector<7xf32>
llvm.return %a : vector<7xf32>
}
diff --git a/mlir/test/Target/LLVMIR/openmp-llvm.mlir b/mlir/test/Target/LLVMIR/openmp-llvm.mlir
index 1435f15983218..04c718f340075 100644
--- a/mlir/test/Target/LLVMIR/openmp-llvm.mlir
+++ b/mlir/test/Target/LLVMIR/openmp-llvm.mlir
@@ -1756,8 +1756,8 @@ llvm.func @_QPomp_atomic_update_complex() {
%9 = llvm.extractvalue %arg0[1] : !llvm.struct<(f32, f32)>
%10 = llvm.extractvalue %7[0] : !llvm.struct<(f32, f32)>
%11 = llvm.extractvalue %7[1] : !llvm.struct<(f32, f32)>
- %12 = llvm.fadd %8, %10 {fastmathFlags = #llvm.fastmath<contract>} : f32
- %13 = llvm.fadd %9, %11 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %12 = llvm.fadd %8, %10 fastmath<contract> : f32
+ %13 = llvm.fadd %9, %11 fastmath<contract> : f32
%14 = llvm.mlir.undef : !llvm.struct<(f32, f32)>
%15 = llvm.insertvalue %12, %14[0] : !llvm.struct<(f32, f32)>
%16 = llvm.insertvalue %13, %15[1] : !llvm.struct<(f32, f32)>
@@ -1816,8 +1816,8 @@ llvm.func @_QPomp_atomic_capture_complex() {
%13 = llvm.extractvalue %arg0[1] : !llvm.struct<(f32, f32)>
%14 = llvm.extractvalue %11[0] : !llvm.struct<(f32, f32)>
%15 = llvm.extractvalue %11[1] : !llvm.struct<(f32, f32)>
- %16 = llvm.fadd %12, %14 {fastmathFlags = #llvm.fastmath<contract>} : f32
- %17 = llvm.fadd %13, %15 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %16 = llvm.fadd %12, %14 fastmath<contract> : f32
+ %17 = llvm.fadd %13, %15 fastmath<contract> : f32
%18 = llvm.mlir.undef : !llvm.struct<(f32, f32)>
%19 = llvm.insertvalue %16, %18[0] : !llvm.struct<(f32, f32)>
%20 = llvm.insertvalue %17, %19[1] : !llvm.struct<(f32, f32)>
diff --git a/mlir/test/Target/LLVMIR/openmp-nontemporal.mlir b/mlir/test/Target/LLVMIR/openmp-nontemporal.mlir
index 974cf674d547d..fcd7d15e475fd 100644
--- a/mlir/test/Target/LLVMIR/openmp-nontemporal.mlir
+++ b/mlir/test/Target/LLVMIR/openmp-nontemporal.mlir
@@ -13,8 +13,8 @@ llvm.func @simd_nontemporal() {
//CHECK: store i64 %[[B]], ptr %[[A_ADDR]], align 4, !nontemporal !1, !llvm.access.group !2
omp.simd nontemporal(%2, %3 : !llvm.ptr, !llvm.ptr) {
omp.loop_nest (%arg0) : i64 = (%1) to (%0) inclusive step (%1) {
- %4 = llvm.load %3 {nontemporal}: !llvm.ptr -> i64
- llvm.store %4, %2 {nontemporal} : i64, !llvm.ptr
+ %4 = llvm.load %3 nontemporal: !llvm.ptr -> i64
+ llvm.store %4, %2 nontemporal : i64, !llvm.ptr
omp.yield
}
}
@@ -60,9 +60,9 @@ llvm.func @_QPtest(%arg0: !llvm.ptr {fir.bindc_name = "n"}, %arg1: !llvm.ptr {fi
// CHECK: %[[LOAD_A:.*]] = load float, ptr %[[VAL1]], align 4, !nontemporal
// CHECK: %[[RES:.*]] = fadd contract float %[[LOAD_A]], 2.000000e+01
%25 = llvm.getelementptr %11[%23] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- %26 = llvm.load %25 {nontemporal} : !llvm.ptr -> f32
+ %26 = llvm.load %25 nontemporal : !llvm.ptr -> f32
%27 = llvm.mlir.constant(2.000000e+01 : f32) : f32
- %28 = llvm.fadd %26, %27 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %28 = llvm.fadd %26, %27 fastmath<contract> : f32
// CHECK: call void @llvm.memcpy.p0.p0.i32(ptr %[[A_VAL1]], ptr %1, i32 48, i1 false)
%29 = llvm.mlir.constant(48 : i32) : i32
"llvm.intr.memcpy"(%1, %arg1, %29) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()
@@ -85,7 +85,7 @@ llvm.func @_QPtest(%arg0: !llvm.ptr {fir.bindc_name = "n"}, %arg1: !llvm.ptr {fi
// CHECK: %[[VAL2:.*]] = getelementptr float, ptr %{{.*}}, i64 %{{.*}}
// CHECK: store float %[[RES]], ptr %[[VAL2]], align 4, !nontemporal
%46 = llvm.getelementptr %33[%44] : (!llvm.ptr, i64) -> !llvm.ptr, f32
- llvm.store %28, %46 {nontemporal} : f32, !llvm.ptr
+ llvm.store %28, %46 nontemporal : f32, !llvm.ptr
omp.yield
}
}
diff --git a/mlir/test/Target/LLVMIR/openmp-reduction-sections.mlir b/mlir/test/Target/LLVMIR/openmp-reduction-sections.mlir
index 84ef9050a7b7c..c8394144708a1 100644
--- a/mlir/test/Target/LLVMIR/openmp-reduction-sections.mlir
+++ b/mlir/test/Target/LLVMIR/openmp-reduction-sections.mlir
@@ -6,7 +6,7 @@ omp.declare_reduction @add_reduction_f32 : f32 init {
omp.yield(%0 : f32)
} combiner {
^bb0(%arg0: f32, %arg1: f32):
- %0 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %0 = llvm.fadd %arg0, %arg1 fastmath<contract> : f32
omp.yield(%0 : f32)
}
llvm.func @sections_(%arg0: !llvm.ptr {fir.bindc_name = "x"}) attributes {fir.internal_name = "_QPsections"} {
@@ -17,14 +17,14 @@ llvm.func @sections_(%arg0: !llvm.ptr {fir.bindc_name = "x"}) attributes {fir.in
omp.section {
^bb0(%arg2: !llvm.ptr):
%2 = llvm.load %arg2 : !llvm.ptr -> f32
- %3 = llvm.fadd %2, %1 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %3 = llvm.fadd %2, %1 fastmath<contract> : f32
llvm.store %3, %arg2 : f32, !llvm.ptr
omp.terminator
}
omp.section {
^bb0(%arg2: !llvm.ptr):
%2 = llvm.load %arg2 : !llvm.ptr -> f32
- %3 = llvm.fadd %2, %0 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %3 = llvm.fadd %2, %0 fastmath<contract> : f32
llvm.store %3, %arg2 : f32, !llvm.ptr
omp.terminator
}
diff --git a/mlir/test/Target/LLVMIR/openmp-simd-private.mlir b/mlir/test/Target/LLVMIR/openmp-simd-private.mlir
index 15dfb6dbc0e87..935659924f062 100644
--- a/mlir/test/Target/LLVMIR/openmp-simd-private.mlir
+++ b/mlir/test/Target/LLVMIR/openmp-simd-private.mlir
@@ -68,7 +68,7 @@ llvm.func @test_loop_var_privatization() attributes {fir.internal_name = "_QPtes
%8 = llvm.load %3 : !llvm.ptr -> f32
%9 = llvm.load %arg0 : !llvm.ptr -> i32
%10 = llvm.sitofp %9 : i32 to f32
- %11 = llvm.fadd %8, %10 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %11 = llvm.fadd %8, %10 fastmath<contract> : f32
llvm.store %11, %3 : f32, !llvm.ptr
omp.yield
}
@@ -104,7 +104,7 @@ llvm.func @test_private_clause() attributes {fir.internal_name = "_QPtest_privat
%8 = llvm.load %arg0 : !llvm.ptr -> f32
%9 = llvm.load %arg1 : !llvm.ptr -> i32
%10 = llvm.sitofp %9 : i32 to f32
- %11 = llvm.fadd %8, %10 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %11 = llvm.fadd %8, %10 fastmath<contract> : f32
llvm.store %11, %arg0 : f32, !llvm.ptr
omp.yield
}
diff --git a/mlir/test/Target/LLVMIR/openmp-simd-reduction-simple.mlir b/mlir/test/Target/LLVMIR/openmp-simd-reduction-simple.mlir
index a712b847e8557..865c489adbace 100644
--- a/mlir/test/Target/LLVMIR/openmp-simd-reduction-simple.mlir
+++ b/mlir/test/Target/LLVMIR/openmp-simd-reduction-simple.mlir
@@ -7,7 +7,7 @@ omp.declare_reduction @add_reduction_f32 : f32 init {
omp.yield(%0 : f32)
} combiner {
^bb0(%arg0: f32, %arg1: f32):
- %0 = llvm.fadd %arg0, %arg1 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %0 = llvm.fadd %arg0, %arg1 fastmath<contract> : f32
omp.yield(%0 : f32)
}
llvm.func @_QPsimd_reduction(%arg0: !llvm.ptr {fir.bindc_name = "a", llvm.nocapture}, %arg1: !llvm.ptr {fir.bindc_name = "sum", llvm.nocapture}) {
@@ -26,7 +26,7 @@ llvm.func @_QPsimd_reduction(%arg0: !llvm.ptr {fir.bindc_name = "a", llvm.nocapt
%8 = llvm.sub %7, %3 overflow<nsw> : i64
%9 = llvm.getelementptr %arg0[%8] : (!llvm.ptr, i64) -> !llvm.ptr, f32
%10 = llvm.load %9 : !llvm.ptr -> f32
- %11 = llvm.fadd %5, %10 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %11 = llvm.fadd %5, %10 fastmath<contract> : f32
llvm.store %11, %arg3 : f32, !llvm.ptr
omp.yield
}
diff --git a/mlir/test/Target/LLVMIR/openmp-target-private.mlir b/mlir/test/Target/LLVMIR/openmp-target-private.mlir
index e1798b5c66b63..7f29b404bb2c1 100644
--- a/mlir/test/Target/LLVMIR/openmp-target-private.mlir
+++ b/mlir/test/Target/LLVMIR/openmp-target-private.mlir
@@ -37,7 +37,7 @@ llvm.func @target_map_2_privates() attributes {fir.internal_name = "_QPtarget_ma
llvm.store %11, %arg1 : i32, !llvm.ptr
%12 = llvm.load %arg1 : !llvm.ptr -> i32
%13 = llvm.sitofp %12 : i32 to f32
- %14 = llvm.fadd %13, %8 {fastmathFlags = #llvm.fastmath<contract>} : f32
+ %14 = llvm.fadd %13, %8 fastmath<contract> : f32
llvm.store %14, %arg2 : f32, !llvm.ptr
omp.terminator
}
@@ -172,7 +172,7 @@ llvm.func @target_firstprivate_() attributes {fir.internal_name = "_QPtarget_fir
llvm.store %11, %arg2 : i32, !llvm.ptr
%12 = llvm.load %arg3 : !llvm.ptr -> f32
%13 = llvm.fpext %12 : f32 to f64
- %14 = llvm.fadd %13, %8 {fastmathFlags = #llvm.fastmath<contract>} : f64
+ %14 = llvm.fadd %13, %8 fastmath<contract> : f64
%15 = llvm.fptrunc %14 : f64 to f32
llvm.store %15, %arg3 : f32, !llvm.ptr
omp.terminator
diff --git a/mlir/test/Target/LLVMIR/openmp-wsloop-private.mlir b/mlir/test/Target/LLVMIR/openmp-wsloop-private.mlir
index 878c6fe1da20f..0cb7e57663f57 100644
--- a/mlir/test/Target/LLVMIR/openmp-wsloop-private.mlir
+++ b/mlir/test/Target/LLVMIR/openmp-wsloop-private.mlir
@@ -24,7 +24,7 @@ omp.declare_reduction @max_f32 : f32 init {
omp.yield(%0 : f32)
} combiner {
^bb0(%arg0: f32, %arg1: f32):
- %0 = llvm.intr.maxnum(%arg0, %arg1) {fastmathFlags = #llvm.fastmath<contract>} : (f32, f32) -> f32
+ %0 = llvm.intr.maxnum(%arg0, %arg1) fastmath<contract> : (f32, f32) -> f32
omp.yield(%0 : f32)
}
diff --git a/mlir/test/Target/LLVMIR/target-ext-type.mlir b/mlir/test/Target/LLVMIR/target-ext-type.mlir
index cee630163ca21..15dc53bf0678c 100644
--- a/mlir/test/Target/LLVMIR/target-ext-type.mlir
+++ b/mlir/test/Target/LLVMIR/target-ext-type.mlir
@@ -20,7 +20,7 @@ llvm.func @func2() -> !llvm.target<"spirv.Event"> {
%0 = llvm.mlir.constant(1 : i32) : i32
%1 = llvm.mlir.poison : !llvm.target<"spirv.Event">
%2 = llvm.alloca %0 x !llvm.target<"spirv.Event"> {alignment = 8 : i64} : (i32) -> !llvm.ptr
- %3 = llvm.load %2 {alignment = 8 : i64} : !llvm.ptr -> !llvm.target<"spirv.Event">
+ %3 = llvm.load %2 alignment = 8 : !llvm.ptr -> !llvm.target<"spirv.Event">
llvm.return %1 : !llvm.target<"spirv.Event">
}
More information about the Mlir-commits
mailing list