From df29aaedc591ce6991c7d64d0e501b2524592812 Mon Sep 17 00:00:00 2001 From: fsx950223 Date: Fri, 5 Jun 2026 03:43:22 +0000 Subject: [PATCH 1/5] feat(gemm2): Add 1:1 HIP a4w4 gemm2 port with accuracy/perf test Port aiter PR #3470 mxfp4 a4w4 gemm2 (BM32 atomic) to FlyDSL with matching LLVM intrinsics and ISA compute instructions; bit-exact vs HIP. Adds kernels/gemm2_a4w4_port.py, tests/kernels/test_gemm2_a4w4_port.py, and reference IR/ISA + design notes under kernels/gemm2_port_ref/. Co-Authored-By: Claude Opus 4.8 Signed-off-by: fsx950223 --- kernels/gemm2_a4w4_port.py | 496 +++++++ kernels/gemm2_port_ref/PORT_DESIGN.md | 232 +++ .../gemm2_port_ref/flydsl_gemm2_existing.ll | 1256 +++++++++++++++++ kernels/gemm2_port_ref/flydsl_port_v1.ll | 892 ++++++++++++ kernels/gemm2_port_ref/flydsl_port_v2.ll | 956 +++++++++++++ kernels/gemm2_port_ref/flydsl_port_v3.ll | 1083 ++++++++++++++ kernels/gemm2_port_ref/flydsl_port_v4.ll | 943 +++++++++++++ kernels/gemm2_port_ref/flydsl_port_v5.ll | 898 ++++++++++++ kernels/gemm2_port_ref/flydsl_port_v6.ll | 866 ++++++++++++ kernels/gemm2_port_ref/hip_gemm2_bm32.ll | 570 ++++++++ tests/kernels/test_gemm2_a4w4_port.py | 273 ++++ 11 files changed, 8465 insertions(+) create mode 100644 kernels/gemm2_a4w4_port.py create mode 100644 kernels/gemm2_port_ref/PORT_DESIGN.md create mode 100644 kernels/gemm2_port_ref/flydsl_gemm2_existing.ll create mode 100644 kernels/gemm2_port_ref/flydsl_port_v1.ll create mode 100644 kernels/gemm2_port_ref/flydsl_port_v2.ll create mode 100644 kernels/gemm2_port_ref/flydsl_port_v3.ll create mode 100644 kernels/gemm2_port_ref/flydsl_port_v4.ll create mode 100644 kernels/gemm2_port_ref/flydsl_port_v5.ll create mode 100644 kernels/gemm2_port_ref/flydsl_port_v6.ll create mode 100644 kernels/gemm2_port_ref/hip_gemm2_bm32.ll create mode 100644 tests/kernels/test_gemm2_a4w4_port.py diff --git a/kernels/gemm2_a4w4_port.py b/kernels/gemm2_a4w4_port.py new file mode 100644 index 000000000..dda3e80b1 --- /dev/null +++ b/kernels/gemm2_a4w4_port.py @@ -0,0 +1,496 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2025 FlyDSL Project Contributors +"""1:1 FlyDSL port of aiter PR #3470 ``gemm2_a4w4`` (MXFP4 MoE down-proj, gfx950). + +Target instance (pinned, hardcoded constants): + ``mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC`` + launch_atomic + +The port mirrors gemm2_a4w4.cuh's atomic path instruction-for-instruction: + * 4 ``make.buffer.rsrc`` (A_q, A_scale, B_q, B_scale) with exact num_bytes. + * A -> LDS via ``raw.ptr.buffer.load.lds`` (2 slots), swizzled. + * B / scales via ``raw.ptr.buffer.load.v4i32`` / ``.i32``. + * ``s_waitcnt vmcnt(23/22)`` + ``s_barrier`` cross-wave fences. + * K=512 = 2 K-tiles fully unrolled; 32 ``mfma.scale.f32.16x16x128.f8f6f4``. + * atomic bf16 epilog: LDS cshuffle -> ``global.atomic.fadd.v2bf16`` * topk weight. + +Reference IR: kernels/gemm2_port_ref/hip_gemm2_bm32.ll +Design notes: kernels/gemm2_port_ref/PORT_DESIGN.md +""" + +import flydsl.compiler as flyc +import flydsl.expr as fx +from flydsl._mlir import ir +from flydsl._mlir.dialects import llvm, scf +from flydsl._mlir.dialects import memref as memref_dialect +from flydsl.expr import arith, buffer_ops, const_expr, gpu, range_constexpr, rocdl +from flydsl.expr.typing import T +from flydsl.expr.typing import Vector as Vec +from flydsl.utils.smem_allocator import SmemAllocator, SmemPtr + +# ── pinned compile-time constants (BM32 atomic instance) ──────────────────── +MAX_M = 655360 +NE = 385 +K = 512 # gemm2 contraction = inter_dim +N_OUT = 7168 # gemm2 output dim = model_dim +TOPK = 9 +BM = 32 + +BN = 256 +BK = 256 +K_HALF = K // 2 # 256 packed-fp4 bytes along K +KH_TILE = BK // 2 # 128 packed bytes per K-tile +NUM_N_BLOCKS = N_OUT // 256 # 28 +K_TILES_TOTAL = K // BK # 2 +kStages = 2 +kSubBlocks = BM // 32 # 1 +kMChunks = BM // 16 # 2 + +# scale-layout consts (mirror gemm2_a4w4.cuh) +kBS_c_k1 = (K // 32) // 4 // 2 # 2 +kBS_stride_k0_dw = 64 +kBS_stride_n0_dw = kBS_c_k1 * 64 # 128 +kBS_c_n1 = N_OUT // 16 // 2 # 224 +kBS_per_expert_dw = kBS_c_n1 * kBS_stride_n0_dw # 28672 +kAS_c_k1 = (K // 32) // 4 // 2 # 2 +kAS_per_chunk_dw = kAS_c_k1 * 64 # 128 + +# buffer resource sizes (bytes) — must match HIP make.buffer.rsrc num_bytes +AQ_BYTES = MAX_M * K_HALF # 167772160 +ASCALE_BYTES = (MAX_M // BM) * kAS_per_chunk_dw * 4 # 10485760 +BQ_BYTES = NE * N_OUT * K_HALF # 706478080 +BSCALE_BYTES = NE * kBS_per_expert_dw * 4 # 44154880 + +# LDS: union{ s_Aq[2][32][128] (8KB) , lds_acc[32*256] f32 (32KB) } = 32KB +LDS_ACC_FLOATS = BM * BN # 8192 +SAQ_SLOT_BYTES = BM * KH_TILE # 32*128 = 4096 bytes per slot +LDS_BYTES = LDS_ACC_FLOATS * 4 # 32768 (union max) + + +_PTR3 = "!llvm.ptr<3>" + + +def _raw(v): + """Unwrap an fx value to a raw ir.Value for raw llvm/arith ops.""" + if not isinstance(v, ir.Value) and hasattr(v, "ir_value"): + return v.ir_value() + return v + + +def _lds_ptr3(base_i32, byte_off_i32): + """ptr<3> = inttoptr(i64(base_i32 + byte_off_i32)).""" + addr_i64 = fx.Int64(base_i32 + byte_off_i32) + return llvm.inttoptr(ir.Type.parse(_PTR3), _raw(addr_i64)) + + +def _lds_base_ptr3(lds_view): + """One ptr<3> for the LDS base; offsets via GEP. + + FlyDSL allocates LDS as a ``memref.global`` (SmemAllocator), so the raw + addrspace(3) pointer is obtained via extract_aligned_pointer_as_index -> + inttoptr. (HIP uses ``getelementptr ... @lds`` on an llvm.mlir.global, which + has no inttoptr; ``llvm.addressof`` cannot reference a memref.global, so this + one bridge is forced by FlyDSL's LDS model — confirmed by verifier.) + """ + base_i32 = fx.Int32(memref_dialect.extract_aligned_pointer_as_index(lds_view)) + return llvm.inttoptr(ir.Type.parse(_PTR3), _raw(fx.Int64(base_i32))) + + +def _gep3(base_ptr, byte_off_i32): + """getelementptr i8, base_ptr, byte_off_i32 (ptr<3>).""" + return buffer_ops.get_element_ptr(base_ptr, byte_offset=_raw(byte_off_i32), elem_type=T.i8) + + +def _s_barrier_bare(): + """Bare ``s_barrier`` (no surrounding memory fence), matching HIP's K-loop + ``__builtin_amdgcn_s_barrier()`` cross-wave fence after the vmcnt wait.""" + llvm.inline_asm(res=None, operands_=[], asm_string="s_barrier", constraints="", has_side_effects=True) + + +def _global_base_ptr1(arg): + """One ptr<1> base for a global tensor (single memref->ptr conversion). + + Mirrors HIP, which addresses the index/scalar tensors via plain addrspace(1) + GEP+load from the kernel-arg pointer (only A_q/A_scale/B_q/B_scale get buffer + resources). One inttoptr per arg is the irreducible memref->raw-ptr bridge. + """ + base_idx = buffer_ops.extract_base_index(arg, address_space=1) + return llvm.inttoptr(ir.Type.parse("!llvm.ptr<1>"), _raw(fx.Int64(base_idx))) + + +def _gep1(base_ptr, byte_off_i32): + """getelementptr i8, base_ptr, byte_off_i32 (ptr<1>).""" + return buffer_ops.get_element_ptr(base_ptr, byte_offset=_raw(byte_off_i32), elem_type=T.i8) + + +def _global_ptr1(arg, byte_off_i32): + return _gep1(_global_base_ptr1(arg), byte_off_i32) + + +def _lds_swizzle_mask(row): + """lds_swizzle_mask(row): ((row & ((128/16-1)<<1)) << 3). + + kRowMask = ((128/16) - 1) << 1 = 7 << 1 = 14 (0xE). mask = (row & 14) << 3. + ``row`` is an fx Int32 expression. + """ + return (row & fx.Int32(14)) << fx.Int32(3) + + +def compile_gemm2_a4w4_port(): + allocator = SmemAllocator(None, arch="gfx950", global_sym_name="gemm2port_smem") + lds_off = allocator._align(allocator.ptr, 16) + allocator.ptr = lds_off + LDS_BYTES + + @flyc.kernel(name="gemm2_a4w4_port_bm32_atomic", known_block_size=[256, 1, 1]) + def gemm2_kernel( + arg_aq: fx.Tensor, + arg_ascale: fx.Tensor, + arg_bq: fx.Tensor, + arg_bscale: fx.Tensor, + arg_eids: fx.Tensor, + arg_cumsum: fx.Tensor, + arg_stids: fx.Tensor, + arg_sweights: fx.Tensor, + i32_M: fx.Int32, + arg_out: fx.Tensor, + ): + tx = gpu.thread_id("x") + bx = gpu.block_id("x") + tx_i32 = arith.index_cast(T.i32, tx) + bx_i32 = arith.index_cast(T.i32, bx) + + lane = tx_i32 % fx.Int32(64) + wave = rocdl.readfirstlane(T.i32, tx_i32 // fx.Int32(64)) # wave == wave_n + + # total_m_blocks = cumsum[0] / BM ; bound = total_m_blocks * NUM_N_BLOCKS + cumsum0 = llvm.load(T.i32, _global_ptr1(arg_cumsum, fx.Int32(0))) + total_m_blocks = cumsum0 // fx.Int32(BM) + bound = total_m_blocks * fx.Int32(NUM_N_BLOCKS) + + in_range = arith.cmpi(arith.CmpIPredicate.slt, bx_i32, bound) + if_op = scf.IfOp(in_range, [], has_else=False) + with ir.InsertionPoint(if_op.then_block): + _gemm2_body( + allocator, + lds_off, + arg_aq, + arg_ascale, + arg_bq, + arg_bscale, + arg_eids, + arg_stids, + arg_sweights, + i32_M, + arg_out, + bx_i32, + lane, + wave, + ) + scf.YieldOp([]) + + @flyc.jit + def launch_gemm2( + arg_aq: fx.Tensor, + arg_ascale: fx.Tensor, + arg_bq: fx.Tensor, + arg_bscale: fx.Tensor, + arg_eids: fx.Tensor, + arg_cumsum: fx.Tensor, + arg_stids: fx.Tensor, + arg_sweights: fx.Tensor, + i32_M: fx.Int32, + i32_max_m_blocks: fx.Int32, + arg_out: fx.Tensor, + stream: fx.Stream, + ): + from flydsl.compiler.kernel_function import CompilationContext + + ctx = CompilationContext.get_current() + allocator.finalized = False + with ir.InsertionPoint(ctx.gpu_module_body): + allocator.finalize() + grid_x = arith.index_cast(T.index, i32_max_m_blocks) * fx.Index(NUM_N_BLOCKS) + gemm2_kernel( + arg_aq, + arg_ascale, + arg_bq, + arg_bscale, + arg_eids, + arg_cumsum, + arg_stids, + arg_sweights, + i32_M, + arg_out, + ).launch(grid=(grid_x, 1, 1), block=(256, 1, 1), stream=stream) + + return launch_gemm2 + + +def _gemm2_body( + allocator, + lds_off, + arg_aq, + arg_ascale, + arg_bq, + arg_bscale, + arg_eids, + arg_stids, + arg_sweights, + i32_M, + arg_out, + bx_i32, + lane, + wave, +): + c0 = fx.Int32(0) + + # block -> (m_block_idx, n_block_idx) ; e = sorted_expert_ids[m_block_idx] + n_block_idx = bx_i32 % fx.Int32(NUM_N_BLOCKS) + m_block_idx = bx_i32 // fx.Int32(NUM_N_BLOCKS) + e = llvm.load(T.i32, _global_ptr1(arg_eids, m_block_idx * fx.Int32(4))) + e = rocdl.readfirstlane(T.i32, e) + m_row = m_block_idx * fx.Int32(BM) + + # ── buffer resources (exact num_bytes) ────────────────────────────────── + aq_rsrc = buffer_ops.create_buffer_resource(arg_aq, max_size=False, num_records_bytes=fx.Index(AQ_BYTES)) + ascale_rsrc = buffer_ops.create_buffer_resource( + arg_ascale, max_size=False, num_records_bytes=fx.Index(ASCALE_BYTES) + ) + bq_rsrc = buffer_ops.create_buffer_resource(arg_bq, max_size=False, num_records_bytes=fx.Index(BQ_BYTES)) + bscale_rsrc = buffer_ops.create_buffer_resource( + arg_bscale, max_size=False, num_records_bytes=fx.Index(BSCALE_BYTES) + ) + + # ── LDS base ──────────────────────────────────────────────────────────── + lds_base = allocator.get_base() + # s_Aq view as bytes (i8); lds_acc view as f32 — same storage (union). + saq = SmemPtr(lds_base, lds_off, T.i8, shape=(kStages * SAQ_SLOT_BYTES,)) + lds_acc = SmemPtr(lds_base, lds_off, T.f32, shape=(LDS_ACC_FLOATS,)) + + lane_div_8 = lane // fx.Int32(8) + lane_mod_8 = lane % fx.Int32(8) + lane_div_16 = lane // fx.Int32(16) + lane_mod_16 = lane % fx.Int32(16) + + # ── s_base computations (readfirstlane'd, uniform per wave) ────────────── + # b_load_s_base[j] = ((e*N_OUT + n_block_idx*BN + wave*(BN/4) + j*16) * K_HALF) + b_load_s_base = [] + for j in range_constexpr(4): + v = (e * fx.Int32(N_OUT) + n_block_idx * fx.Int32(BN) + wave * fx.Int32(BN // 4) + fx.Int32(j * 16)) * fx.Int32( + K_HALF + ) + b_load_s_base.append(rocdl.readfirstlane(T.i32, v)) + + # b_scale_s_base[mw]: mni_base = n_block_idx*(BN/16/2) + wave*(BN/64/2) + mni_base = n_block_idx * fx.Int32(BN // 16 // 2) + wave * fx.Int32(BN // 64 // 2) + b_scale_s_base = [] + for mw in range_constexpr(2): + v = (e * fx.Int32(kBS_per_expert_dw) + (mni_base + fx.Int32(mw)) * fx.Int32(kBS_stride_n0_dw)) * fx.Int32(4) + b_scale_s_base.append(rocdl.readfirstlane(T.i32, v)) + + # a_scale_s_base[0]: chunk_base = m_row/32 (BM!=16); sub=0 + chunk_base = m_row // fx.Int32(32) + a_scale_s_base0 = rocdl.readfirstlane(T.i32, chunk_base * fx.Int32(kAS_per_chunk_dw) * fx.Int32(4)) + + # cached_actual_row[0] (sub=0): m_row + wave*(BM/4) + 0 + lane/8 + car0 = m_row + wave * fx.Int32(BM // 4) + lane_div_8 + + # ── issue_a_load_lds(slot, kt) ────────────────────────────────────────── + def issue_a_load_lds(slot, kt): + # sub=0: lds_row = wave*(BM/4) + 0 ; row_off = lane/8 + lds_row = wave * fx.Int32(BM // 4) + mask = _lds_swizzle_mask(lds_row + lane_div_8) + voffset = ((lane_mod_8 * fx.Int32(16)) ^ mask) + car0 * fx.Int32(K // 2) + # LDS dst pointer = base + slot*SAQ_SLOT_BYTES + lds_row*KH_TILE (bytes) + base_i32 = fx.Int32(memref_dialect.extract_aligned_pointer_as_index(saq.get())) + off_i32 = fx.Int32(slot * SAQ_SLOT_BYTES) + lds_row * fx.Int32(KH_TILE) + lds_ptr = _lds_ptr3(base_i32, off_i32) + rocdl.raw_ptr_buffer_load_lds( + aq_rsrc, + lds_ptr, + fx.Int32(16), + voffset, + fx.Int32(kt * KH_TILE), + c0, + c0, + ) + + issue_a_load_lds(0, 0) + issue_a_load_lds(1, 1) + rocdl.sched_barrier(0) + + # ── a_scale (atomic) : v_voff = ((lane/16)*16 + lane%16)*4 ─────────────── + v_voff_scale = ((lane_div_16 * fx.Int32(16)) + lane_mod_16) * fx.Int32(4) + a_scale_v = [] + for ku in range_constexpr(2): + v = buffer_ops.buffer_load( + ascale_rsrc, + (v_voff_scale + fx.Int32(ku * 256)) // fx.Int32(4), + vec_width=1, + dtype=T.i32, + soffset_bytes=a_scale_s_base0, + ) + a_scale_v.append(v) + + # ── b_scale ku0/ku1 : IMM = ku*(kBS_stride_k0_dw*4) ───────────────────── + b_scale_v = [[None, None], [None, None]] + for ku in range_constexpr(2): + imm = ku * (kBS_stride_k0_dw * 4) + for mw in range_constexpr(2): + v = buffer_ops.buffer_load( + bscale_rsrc, + (v_voff_scale + fx.Int32(imm)) // fx.Int32(4), + vec_width=1, + dtype=T.i32, + soffset_bytes=b_scale_s_base[mw], + ) + b_scale_v[ku][mw] = v + + # ── B loads : v_voff = (lane/16)*256 + (lane%16)*16 + K_BYTE ───────────── + # b[slot][j][half] = i32x4 (vector<4xi32>) + b = [[[None, None] for _ in range(4)] for _ in range(2)] + for kc in range_constexpr(2): + k_byte = kc * 2048 + v_voff_b = (lane_div_16 * fx.Int32(256)) + (lane_mod_16 * fx.Int32(16)) + fx.Int32(k_byte) + for j in range_constexpr(4): + for half in range_constexpr(2): + imm = half * 1024 + frag = buffer_ops.buffer_load( + bq_rsrc, + (v_voff_b + fx.Int32(imm)) // fx.Int32(4), + vec_width=4, + dtype=T.i32, + soffset_bytes=b_load_s_base[j], + ) + b[kc][j][half] = Vec(frag) + + # ── ds_read(slot) -> a[i][k] (i32x4) ───────────────────────────────────── + def issue_a_ds_read(slot): + lane_row = lane_mod_16 + lane_col = lane_div_16 * fx.Int32(16) + mask = _lds_swizzle_mask(lane_row) + base_ptr = _lds_base_ptr3(saq.get()) + a = [[None, None] for _ in range(kMChunks)] + for k in range_constexpr(2): + lds_col = (lane_col + fx.Int32(k * 64)) ^ mask + for i in range_constexpr(kMChunks): + lds_row = lane_row + fx.Int32(i * 16) + byte_off = fx.Int32(slot * SAQ_SLOT_BYTES) + lds_row * fx.Int32(KH_TILE) + lds_col + a[i][k] = llvm.load(T.vec(4, T.i32), _gep3(base_ptr, byte_off)) # ds_read_b128 + return a + + # ── MFMA cluster ───────────────────────────────────────────────────────── + mfma_res_ty = T.f32x4 + zero4 = Vec.filled(4, 0.0, fx.Float32) + # HIP emits the .v4i32.v4i32 variant: A and B operands are passed as + # vector<4xi32> directly (no zero-padding to 8xi32). + + accm = [[None, None, None, None] for _ in range(kMChunks)] + + def mfma_cluster(slot, a, a_scale_aiter, b_scale_slot, init): + for J in range_constexpr(4): + mni = J // 2 + in_b = J % 2 + sb = b_scale_slot[mni] + sa = a_scale_aiter # sub=0 -> a_scale_aiter[0] + i0, i1 = 0, 1 + b_J0 = b[slot][J][0] + b_J1 = b[slot][J][1] + if const_expr(init): + accm[i0][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( + mfma_res_ty, [a[i0][0], b_J0, zero4, 4, 4, 0, sa, 0 + in_b, sb] + ) + accm[i1][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( + mfma_res_ty, [a[i1][0], b_J0, zero4, 4, 4, 1, sa, 0 + in_b, sb] + ) + else: + accm[i0][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( + mfma_res_ty, [a[i0][0], b_J0, accm[i0][J], 4, 4, 0, sa, 0 + in_b, sb] + ) + accm[i1][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( + mfma_res_ty, [a[i1][0], b_J0, accm[i1][J], 4, 4, 1, sa, 0 + in_b, sb] + ) + accm[i0][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( + mfma_res_ty, [a[i0][1], b_J1, accm[i0][J], 4, 4, 2, sa, 2 + in_b, sb] + ) + accm[i1][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( + mfma_res_ty, [a[i1][1], b_J1, accm[i1][J], 4, 4, 3, sa, 2 + in_b, sb] + ) + + # ── K loop (2 stages, fully unrolled) ──────────────────────────────────── + for S in range_constexpr(kStages): + kt = K_TILES_TOTAL - kStages + S + slot = kt % kStages + vmcnt = 23 if S == 0 else 22 + llvm.inline_asm( + res=None, operands_=[], asm_string=f"s_waitcnt vmcnt({vmcnt})", constraints="", has_side_effects=True + ) + _s_barrier_bare() + a = issue_a_ds_read(slot) + mfma_cluster(slot, a, a_scale_v[kt], b_scale_v[slot], init=(S == 0)) + + # ── epilog: apply_atomic_bf16_epilog (BM=32) ──────────────────────────── + saq._view_cache = None + lds_acc._view_cache = None + _atomic_bf16_epilog(lds_acc, accm, arg_out, arg_stids, arg_sweights, m_row, n_block_idx, wave, lane, i32_M) + + +def _atomic_bf16_epilog(lds_acc, accm, arg_out, arg_stids, arg_sweights, m_row, n_block_idx, wave, lane, i32_M): + lane_div_16 = lane // fx.Int32(16) + lane_mod_16 = lane % fx.Int32(16) + lds_base = _lds_base_ptr3(lds_acc.get()) + + # pre-store fence+barrier: all waves done reading s_Aq before lds_acc reuse + # (HIP run_one __syncthreads() before apply_atomic_bf16_epilog). + rocdl.barrier() + + # write accm -> lds_acc cshuffle (scalar f32 stores, as HIP does) + for i in range_constexpr(kMChunks): + row_base = fx.Int32(i * 16) + lane_div_16 * fx.Int32(4) + for J in range_constexpr(4): + col = wave * fx.Int32(64) + fx.Int32(J * 16) + lane_mod_16 + vec = Vec(accm[i][J]) + for v in range_constexpr(4): + idx = (row_base + fx.Int32(v)) * fx.Int32(BN) + col + llvm.StoreOp(_raw(vec[v]), _gep3(lds_base, idx * fx.Int32(4))) + + rocdl.barrier() + + # read back + weighted atomic add + tx_i32 = arith.index_cast(T.i32, gpu.thread_id("x")) + m_lane = tx_i32 // fx.Int32(32) + n_lane = tx_i32 % fx.Int32(32) + col_start = n_lane * fx.Int32(2) + + stids_base = _global_base_ptr1(arg_stids) + sweights_base = _global_base_ptr1(arg_sweights) + out_base = _global_base_ptr1(arg_out) + + M_REPS = BM // 8 # 4 + for mr in range_constexpr(M_REPS): + row_in_block = fx.Int32(mr * 8) + m_lane + sorted_pos = m_row + row_in_block + packed = llvm.load(T.i32, _gep1(stids_base, sorted_pos * fx.Int32(4))) + token_id = packed & fx.Int32(0x00FFFFFF) + valid = arith.cmpi(arith.CmpIPredicate.slt, token_id, i32_M) + weight = llvm.load(T.f32, _gep1(sweights_base, sorted_pos * fx.Int32(4))) + if_op = scf.IfOp(valid, [], has_else=False) + with ir.InsertionPoint(if_op.then_block): + row_base_addr = token_id * fx.Int32(N_OUT) + n_block_idx * fx.Int32(BN) + col_start + for s in range_constexpr(4): + # adjacent ee=0,1 are contiguous -> one <2xf32> load (as HIP vectorizes) + idx0 = row_in_block * fx.Int32(BN) + col_start + fx.Int32(s * 64) + v2 = Vec(llvm.load(T.vec(2, T.f32), _gep3(lds_base, idx0 * fx.Int32(4)))) + pk = Vec.from_elements([v2[0] * weight, v2[1] * weight], fx.Float32).to(fx.BFloat16) + off = (row_base_addr + fx.Int32(s * 64)) * fx.Int32(2) # bf16 byte offset + out_ptr = _gep1(out_base, off) + llvm.AtomicRMWOp( + llvm.AtomicBinOp.fadd, + out_ptr, + _raw(pk), + llvm.AtomicOrdering.monotonic, + syncscope="agent", + alignment=4, + ) + scf.YieldOp([]) diff --git a/kernels/gemm2_port_ref/PORT_DESIGN.md b/kernels/gemm2_port_ref/PORT_DESIGN.md new file mode 100644 index 000000000..d9ed0756e --- /dev/null +++ b/kernels/gemm2_port_ref/PORT_DESIGN.md @@ -0,0 +1,232 @@ +# gemm2_a4w4 HIP → FlyDSL 1:1 port — design & status + +## Goal +Port aiter PR #3470 `gemm2_a4w4` (HIP) into FlyDSL (`kernels/`), driving the +FlyDSL-generated LLVM IR to match the HIP-generated LLVM IR as closely as the +two toolchains allow. Test on remote gfx950 (`dzm-mi355-gpu34-dev`). + +## Feasibility calibration (important) +Byte-identical LLVM across clang(HIP) and MLIR(FlyDSL) is **not achievable** +(SSA value names, basic-block order, metadata/TBAA, attribute sets, GEP +canonicalization all differ structurally between the two frontends). + +**Achievable bar = instruction-level equivalence**: same set of `amdgcn.*` +intrinsic calls with identical immediate operands, same LDS layout/size, same +control-flow skeleton. The census below proves this is within reach. + +## Target instance (pinned) +`mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC` +`launch_atomic` + +Constants: BN=256, BK=256, K_HALF=256, K_TILES_TOTAL=2, kStages=2, +kSubBlocks=1, kMChunks=2, num_n_blocks=N_OUT/256=28. +LDS = union{ s_Aq[2][32][128] fp4x2 (8KB), lds_acc[32*256] f32 (32KB) } = **32KB = [8192 x float]**. + +Scale layout consts: kBS_c_n1=224, kBS_c_k1=2, kBS_stride_k0_dw=64, +kBS_stride_n0_dw=128, kBS_per_expert_dw=28672; kAS_c_k1=2, kAS_per_chunk_dw=128. + +## HIP reference IR census (kernels/gemm2_port_ref/hip_gemm2_bm32.ll, 570 lines) +| intrinsic | count | immediates | +|---|---|---| +| `mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32` | 32 | cbsz=4, blgp=4, op_sel a/b per cluster | +| `make.buffer.rsrc.p8.p1` | 4 | i16 0, flags i32 131072(0x20000); num_bytes: A_q=167772160, A_scale=10485760, B_q=706478080, B_scale=44154880 | +| `raw.ptr.buffer.load.lds` | 2 | size=16, soffset imm 0 then 128 | +| `raw.ptr.buffer.load.v4i32` (B) | 16 | 4 j × {imm 0,1024} × 2 K_C | +| `raw.ptr.buffer.load.i32` (scales) | 6 | A_scale 2 (imm 0,256) + B_scale 4 | +| inline asm `s_waitcnt vmcnt(23)` / `vmcnt(22)` | 2 | cross-wave fence before s_barrier | +| `s.barrier` | 3 | 2 in K-loop + 1 epilog | +| `global.atomic.fadd.v2bf16` | 16 | 4 mr × 4 stride | +| LDS addrspace(3) refs | 126 | | + +Kernel attrs: target-cpu gfx950, `amdgpu-flat-work-group-size`="1,256", +`amdgpu-waves-per-eu`="2", `amdgpu-agpr-alloc`="0". + +## FlyDSL existing gemm2 census (flydsl_gemm2_existing.ll, 1256 lines) +`mfma_moe2_afp4_wfp4_bf16_cshuffle_t32x256x256_vscale_fix3_persist_cu256` +ALREADY matches at intrinsic level: mfma 32 ✓, buffer.load.lds 2 ✓, +buffer.load.v4i32 16 ✓, atomic v2bf16 16 ✓. +Differences (structural, the port must fix): +- make.buffer.rsrc 8 (2×) vs 4 — persistent loop re-creates rsrc. +- s.barrier 6 vs 3; no `s_waitcnt vmcnt` inline-asm fences (0 vs 2). +- IR 1256 vs 570 lines — persistent cu256 grid loop + CShuffle verbosity. +→ Port targets the **non-persistent atomic** structure (one tile/block + early +return), 4 rsrc, explicit vmcnt fences, K=512 2-stage unroll. + +## FlyDSL primitives (exact) +- raw MFMA: `rocdl.mfma_scale_f32_16x16x128_f8f6f4(vec4_f32, [a8xi32, b8xi32, acc, cbsz, blgp, opselA, scaleA_i32, opselB, scaleB_i32])` — rocdl/__init__.py:168 +- A→LDS: `rocdl.raw_ptr_buffer_load_lds(rsrc_p8, lds_p3, size, voffset, soffset, offset, aux)` — :495 +- B/scale loads: `buffer_ops.buffer_load(rsrc, offset_elems, vec_width, dtype, soffset_bytes=)` ; rsrc via `buffer_ops.create_buffer_resource(memref, max_size=False, num_records_bytes=N)` (-> p8) — buffer_ops.py:386 +- atomic pk bf16: `rocdl.raw_ptr_buffer_atomic_fadd(vdata_2xbf16, rsrc, offset, soffset, aux)` — :456 (or llvm.AtomicRMWOp fadd v2bf16, syncscope agent, moe_gemm_2stage.py:3100) +- LDS: SmemAllocator/SmemPtr (utils/smem_allocator.py); ds_read via vector.load on LDS memref +- inline asm fence: `_llvm.inline_asm(None, [], "s_waitcnt vmcnt(N)\ns_barrier", "", has_side_effects=True)` — fp8_gemm_utils.py:197 +- s.barrier: `rocdl.barrier()`; sched: `rocdl.sched_barrier(0)`; `rocdl.readfirstlane(T.i32, src)` +- fp4 pack: build vector<4xi64> via vector.from_elements (2 data + 2 zero i64) then vector.bitcast to vector<8xi32> — mixed_moe_gemm_2stage.py:1232 +- decorators: `@flyc.kernel(name=, known_block_size=[256,1,1])`, `@flyc.jit`; launch `.launch(grid=, block=(256,1,1), stream=)`; waves-per-eu via CompilationContext.compile_hints({"waves_per_eu":2}) + +## Iteration loop (remote gfx950) +Helper: /tmp/rmi.sh '' runs in container. FlyDSL env: +``` +FLY=/home/zhiming_ding_qle/sixifang/FlyDSL +PYTHONPATH=$FLY/build-fly/python_packages:$FLY/python +LD_LIBRARY_PATH=$FLY/build-fly/python_packages/flydsl/_mlir/_mlir_libs +FLYDSL_DUMP_IR=1 FLYDSL_DUMP_DIR=/tmp/flydsl_dump FLYDSL_RUNTIME_ENABLE_CACHE=0 +``` +Dumped final LLVM IR = `//NN_llvm_ir.ll`. +HIP reference rebuild: /tmp/emit_hip_ir.sh (hipcc --cuda-device-only -emit-llvm -S). + +## Status +- [x] worktree on latest main (f3c8ff5d) +- [x] HIP source fully understood (gemm2_a4w4.cuh + mfma_f4f4 + epilogs + common) +- [x] HIP reference IR captured + censused +- [x] FlyDSL existing gemm2 IR captured — intrinsic parity confirmed +- [x] FlyDSL API mapped +- [x] kernels/gemm2_a4w4_port.py written — **COMPILES** end-to-end (COMPILE_ONLY) on gfx950 +- [x] IR dump + census vs HIP — core compute matches intrinsic-for-intrinsic +- [ ] close peripheral gap (rsrc 9→4, i32 loads 12→6): use plain global loads + for cumsum/eids/stids/sweights and a global atomic for out (HIP only makes + buffer rsrc for the 4 main tensors A_q/A_scale/B_q/B_scale). +- [ ] correctness vs HIP on gfx950 (cosine), benchmark + +## port v1 census (flydsl_port_v1.ll, 892 lines vs HIP 570) +MATCHED: mfma.scale .v4i32.v4i32 = 32 ✓ (NOT the .v8i32 padded variant the +existing FlyDSL kernel uses), buffer.load.lds = 2 ✓, buffer.load.v4i32 = 16 ✓, +s_waitcnt vmcnt fences = 2 ✓. +GAP: make.buffer.rsrc 9 vs 4, buffer.load.i32 12 vs 6 — because the port routes +cumsum/eids/sorted_token_ids/sorted_weights/out through buffer resources while +HIP uses plain addrspace(1) loads + global.atomic.fadd.v2bf16. Fix = plain +global loads for those + global atomic for the epilog. + +## port v2 census (flydsl_port_v2.ll, 956 lines vs HIP 570) — FULL INTRINSIC MATCH +| metric | HIP | port v2 | +|---|---|---| +| mfma.scale .v4i32.v4i32 | 32 | 32 ✓ | +| raw.ptr.buffer.load.lds | 2 | 2 ✓ | +| raw.ptr.buffer.load.v4i32 (B) | 16 | 16 ✓ | +| raw.ptr.buffer.load.i32 (scale) | 6 | 6 ✓ | +| make.buffer.rsrc | 4 | 4 ✓ | +| s_waitcnt vmcnt fences | 2 | 2 ✓ | +| atomicrmw fadd <2xbf16> | 16 | 16 ✓ | +| plain load i32 addrspace(1) | 6 | 6 ✓ | + +Every hardware intrinsic and memory-op class matches. (HIP's +`__builtin_amdgcn_global_atomic_fadd_v2bf16` lowers to `atomicrmw fadd <2xbf16>` +in this LLVM, same as the port — no named global.atomic intrinsic on either side.) + +RESIDUAL (the unavoidable cross-frontend delta): addrspace(3) refs 160 vs 126, +fence syncscope 6 vs 4, total lines 956 vs 570. Source = FlyDSL emits +`vector.load/store` on memref views for the LDS cshuffle, generating more +GEP/index scaffolding than clang's raw pointer arithmetic; optimizes to the same +ISA. Byte-identical .ll across clang vs MLIR is not achievable (stated up front). +Next refinement to shrink this: hand-build ptr<3> + llvm.load/store for the +epilog cshuffle (as done for ds_read) instead of SmemPtr.store/.load; and compare +final ISA (21_final_isa.s) which should be far closer than the .ll. + +## FINAL ISA comparison (the decisive "same machine code" check) — port v3 +Both compiled to gfx950 ISA (HIP: hipcc -S; FlyDSL: 21_final_isa.s). Every +compute and memory instruction matches exactly: +| ISA instruction | HIP | port | +|---|---|---| +| v_mfma_scale_f32_16x16x128_f8f6f4 | 32 | 32 ✓ | +| buffer_load_dwordx4 (16 B + 2 A→LDS) | 18 | 18 ✓ | +| buffer_load_dword (scales) | 6 | 6 ✓ | +| ds_read_b128 (A from LDS) | 8 | 8 ✓ | +| s_barrier | 4 | 4 ✓ | +| s_waitcnt vmcnt | 22 | 23 (1 extra) | +| total .s lines | 548 | 625 | + +The 77-line ISA delta is entirely scalar address arithmetic in the epilog +(per-element inttoptr address math + 1 extra s_waitcnt); zero difference in +MFMA / buffer-load / ds-read / barrier instructions. This is the strongest +"identical generated code" result achievable across the clang(HIP) and MLIR +(FlyDSL) frontends — both feed the same AMDGPU backend and emit the same +machine instructions for the compute core. + +## v3 changes (fence + raw-ptr epilog) +- K-loop barrier: bare `s_barrier` inline-asm (fence-free) → fence count 6→4 (=HIP). +- epilog cshuffle: raw ptr<3> + llvm.store/load (scalar) → `store float` 32 (=HIP). +- added pre-epilog fenced barrier (HIP run_one __syncthreads()). +Residual .ll delta (addrspace(3) 224 vs 126, lines 1083 vs 570) is LDS-address +scaffolding (inttoptr-per-op + no scalar-load vectorization that clang does); +it does NOT affect the ISA compute/memory instruction counts above. + +## CORRECTNESS (Task #6) — BIT-EXACT vs HIP +Same random inputs fed to both aiter HIP `mxfp4_moe_gemm2_a4w4` (kernelName +...BM32_ATOMIC) and the ported FlyDSL kernel; e8m0 scales pinned to 127 (2^0) +to avoid overflow, unique sorted_token_ids to avoid atomic-order nondeterminism. +Result (M=64, srt=64): finite 458752/458752 both, cosine=1.000000, +max_abs_diff=0, **bitexact=True — EXACT MATCH**. +Driver: /tmp/verify_gemm2.py + /tmp/run_verify.sh. + +## FINAL (v6) — diff minimized to irreducible cross-frontend artifacts +Iteration v1→v6 progressively closed the gap. v6 result: +- LLVM .ll: 866 lines (HIP 570). ALL intrinsics + memory ops match: + mfma.scale.v4i32 32, buffer.load.lds 2, buffer.load.v4i32 16, buffer.load.i32 6, + make.buffer.rsrc 4, fence 4, atomicrmw 16, **load <2xf32> 16, load float 4, + store float 32, addrspace(3) 124≈126**. +- ISA .s: 575 lines (HIP 548). EVERY compute/memory machine instruction identical: + v_mfma_scale ×32, buffer_load_dwordx4 ×18, buffer_load_dword ×6, ds_read_b128 ×8, + s_barrier ×4. +- Output: **bit-exact** (cosine 1.0, max_abs_diff 0). + +The ONLY remaining .ll differences are provably irreducible across clang↔MLIR: +1. SSA value names (%0,%1,...) — two frontends never name values identically. + This alone makes byte-identical text impossible, independent of any effort. +2. inttoptr ×9 (vs HIP 0) — FlyDSL models LDS (SmemAllocator) and kernel args as + memrefs; obtaining raw addrspace(1/3) pointers requires ptrtoint→inttoptr. + clang has native addrspace pointers / the @lds addrspace(3) global symbol. + A FlyDSL-model difference, not an algorithm difference. +3. Integer address-math is spelled with explicit arith ops in MLIR where clang + folds constants; these optimize to the same ISA (the 27-line ISA delta). + +Conclusion: literal byte-identical .ll is physically unattainable (point 1). +Achieved instead: identical LLVM intrinsics+memory-ops, identical ISA compute +instructions, and bit-exact output — the maximum attainable fidelity. + +## PERFORMANCE (gemm2 standalone, gfx950/MI355, /tmp/bench_gemm2.py) +| sorted rows | M-blocks | HIP us | port us | port/HIP | +|---|---|---|---|---| +| 256 | 8 | 18.7 | 27.2 | 1.46x | +| 1024 | 32 | 31.7 | 40.7 | 1.28x | +| 4096 | 128 | 79.3 | 83.0 | 1.05x | +| 8192 | 256 | 143.5 | 139.8 | 0.97x | + +GPU-saturating sizes (>=4096, 256 CU): within 5%, slightly FASTER at 8192 — +confirms near-identical ISA => near-identical perf. Small/latency-bound sizes: +1.3-1.5x slower, from per-block fixed overhead (the +27 ISA scalar-address lines, +9 inttoptr address setup, FlyDSL host launch path) being amplified when the grid +is small and compute is short. + +## opt -O3 comparison (fair, same passes) + the decisive impossibility proof +Fair comparison must opt both at the same level (FlyDSL's 20_llvm_ir.ll is +PRE-LLVM-opt; HIP's -emit-llvm is POST-O3). After `opt -O3` on both: +- FLY 866->690 lines; HIP 570->569. +- inttoptr 9->2 (opt eliminated 7); mfma 33, buffer.load.lds 3, buffer.load.v4i32 + 17, atomicrmw 16, fence 4, load <4xi32> 8, store float 32 — all still match. +- residual: ~120 extra lines, addrspace(3) 160 vs 126 (standalone opt -O3 lacks + the AMDGPU-target load-vectorizer that clang's full pipeline applied to HIP). + +DECISIVE: the two toolchains use DIFFERENT LLVM versions — FlyDSL bundles LLVM +rev 554785 (emits attrs like `nocreateundeforpoison`); HIP uses ROCm 7.2.3's +LLVM (its opt cannot even parse FlyDSL's IR). Different LLVM + different frontend +=> byte-identical .ll text is impossible in principle, independent of the kernel. +Maximal attainable fidelity (intrinsics + ISA compute instrs + bit-exact output) +is achieved and verified. + +## Unit test (tests/kernels/test_gemm2_a4w4_port.py) +4 tests, all PASS on gfx950/MI355: +- test_smoke (no aiter): compile+run, output finite & nonzero. +- test_accuracy_vs_hip[256,1024] (needs aiter): bit-exact vs HIP gemm2. +- test_performance[4096] (needs aiter): wall-clock ratio + loose regression bound. +Run: `python3 -m pytest tests/kernels/test_gemm2_a4w4_port.py -v -s` +(markers l2_device + rocm_lower; module-skips if not gfx95 / no CUDA). + +GOTCHA: `flyc.compile(launch, ..., out, ...)` EXECUTES the kernel once into the +buffer passed to it. Since gemm2 atomic-accumulates, compiling and then calling +into the SAME un-zeroed `out` doubles the result (looks like a 2x bug). Correct +pattern: compile against a throwaway buffer, then zero the real out and call once +(see `_compile_port`/`_run_port`). + +## Iterate loop helper +/tmp/iter_gemm2.sh → syncs kernel to remote, runs /tmp/run_compile_gemm2.sh +(COMPILE_ONLY=1 + FLYDSL_DUMP_IR), dumps to /tmp/gemm2_dump/. +Driver: /tmp/drive_gemm2.py. HIP ref rebuild: /tmp/emit_hip_ir.sh. diff --git a/kernels/gemm2_port_ref/flydsl_gemm2_existing.ll b/kernels/gemm2_port_ref/flydsl_gemm2_existing.ll new file mode 100644 index 000000000..8059c4f44 --- /dev/null +++ b/kernels/gemm2_port_ref/flydsl_gemm2_existing.ll @@ -0,0 +1,1256 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" +target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" + +@smem0 = external addrspace(3) global [32896 x i8], align 1024 +@smem1 = external addrspace(3) global [4096 x i8], align 1024 + +define amdgpu_kernel void @mfma_moe2_afp4_wfp4_bf16_cshuffle_t32x256x256_vscale_fix3_persist_cu256(ptr addrspace(1) noalias %0, ptr addrspace(1) noalias %1, ptr addrspace(1) noalias %2, ptr addrspace(1) noalias %3, ptr addrspace(1) noalias %4, ptr addrspace(1) noalias %5, ptr addrspace(1) noalias %6, ptr addrspace(1) noalias %7, ptr addrspace(1) noalias %8, ptr addrspace(1) noalias %9, i32 %10, i32 %11, i32 %12, i32 %13) #0 { + %15 = sext i32 %10 to i64 + %16 = sext i32 %12 to i64 + %17 = sext i32 %13 to i64 + %18 = call i32 @llvm.amdgcn.workitem.id.x() + %19 = sext i32 %18 to i64 + %20 = call i32 @llvm.amdgcn.workgroup.id.x() + %21 = sext i32 %20 to i64 + %22 = call i32 @llvm.amdgcn.workgroup.id.y() + %23 = sext i32 %22 to i64 + %24 = mul i64 %15, 9 + %25 = mul i64 %24, %16 + %26 = lshr i64 %25, 1 + %27 = trunc i64 %26 to i32 + %28 = ptrtoint ptr addrspace(1) %1 to i64 + %29 = inttoptr i64 %28 to ptr + %30 = sext i32 %27 to i64 + %31 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %29, i16 0, i64 %30, i32 159744) + %32 = ptrtoint ptr addrspace(1) %2 to i64 + %33 = inttoptr i64 %32 to ptr + %34 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %33, i16 0, i64 706478080, i32 159744) + %35 = ptrtoint ptr addrspace(1) %8 to i64 + %36 = inttoptr i64 %35 to ptr + %37 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %36, i16 0, i64 4, i32 159744) + %38 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %37, i32 0, i32 0, i32 0) + %39 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %38) + %40 = sext i32 %39 to i64 + %41 = lshr i64 %16, 5 + %42 = mul i64 %40, %41 + %43 = trunc i64 %42 to i32 + %44 = ptrtoint ptr addrspace(1) %3 to i64 + %45 = inttoptr i64 %44 to ptr + %46 = sext i32 %43 to i64 + %47 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %45, i16 0, i64 %46, i32 159744) + %48 = mul i64 %41, 2759680 + %49 = trunc i64 %48 to i32 + %50 = ptrtoint ptr addrspace(1) %4 to i64 + %51 = inttoptr i64 %50 to ptr + %52 = sext i32 %49 to i64 + %53 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %51, i16 0, i64 %52, i32 159744) + %54 = mul i64 %17, 32 + %55 = mul i64 %17, 128 + %56 = trunc i64 %55 to i32 + %57 = ptrtoint ptr addrspace(1) %5 to i64 + %58 = inttoptr i64 %57 to ptr + %59 = sext i32 %56 to i64 + %60 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %58, i16 0, i64 %59, i32 159744) + %61 = ptrtoint ptr addrspace(1) %7 to i64 + %62 = inttoptr i64 %61 to ptr + %63 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %62, i16 0, i64 %59, i32 159744) + %64 = add i64 %54, 31 + %65 = lshr i64 %64, 5 + %66 = mul i64 %65, 4 + %67 = trunc i64 %66 to i32 + %68 = ptrtoint ptr addrspace(1) %6 to i64 + %69 = inttoptr i64 %68 to ptr + %70 = sext i32 %67 to i64 + %71 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %69, i16 0, i64 %70, i32 159744) + %72 = add i64 %40, 31 + %73 = udiv i64 %72, 32 + %74 = add i64 %73, 255 + %75 = udiv i64 %74, 256 + br label %76 + +76: ; preds = %1118, %14 + %77 = phi i64 [ %1119, %1118 ], [ 0, %14 ] + %78 = phi i1 [ %97, %1118 ], [ true, %14 ] + %79 = icmp slt i64 %77, %75 + br i1 %79, label %80, label %1120 + +80: ; preds = %76 + %81 = mul i64 %23, %75 + %82 = add i64 %81, %77 + %83 = mul i64 %82, 32 + %84 = trunc i64 %83 to i32 + %85 = icmp ult i32 %84, %39 + %86 = lshr i64 %83, 5 + %87 = trunc i64 %86 to i32 + %88 = mul i32 %87, 4 + %89 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %71, i32 %88, i32 0, i32 0) + %90 = sext i32 %89 to i64 + %91 = icmp ult i32 %89, 385 + %92 = mul i64 %90, 1835008 + %93 = mul i32 %84, 4 + %94 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %60, i32 %93, i32 0, i32 0) + %95 = and i32 %94, 16777215 + %96 = icmp ult i32 %95, %10 + %97 = and i1 %78, %85 + %98 = and i1 %91, %96 + %99 = and i1 %97, %98 + br i1 %99, label %100, label %1118 + +100: ; preds = %80 + %101 = mul i64 %90, 7168 + %102 = lshr i64 %16, 1 + %103 = lshr i64 %102, 2 + %104 = mul i64 %19, 4 + %105 = trunc i64 %104 to i32 + %106 = sdiv i32 %105, 32 + %107 = srem i32 %106, 32 + %108 = srem i32 %105, 32 + %109 = sext i32 %107 to i64 + %110 = sext i32 %108 to i64 + %111 = add i64 %83, %109 + %112 = trunc i64 %111 to i32 + %113 = mul i32 %112, 4 + %114 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %60, i32 %113, i32 0, i32 0) + %115 = and i32 %114, 16777215 + %116 = lshr i32 %114, 24 + %117 = mul i32 %115, 9 + %118 = add i32 %117, %116 + %119 = sext i32 %118 to i64 + %120 = mul i64 %119, %103 + %121 = lshr i64 %19, 6 + %122 = and i64 %121, 3 + %123 = and i64 %19, 63 + %124 = lshr i64 %123, 4 + %125 = and i64 %124, 3 + %126 = and i64 %123, 15 + %127 = mul i64 %125, 16 + %128 = mul i64 %122, 64 + %129 = mul i64 %21, 256 + %130 = add i64 %129, %128 + %131 = add i64 %130, %126 + %132 = lshr i64 %131, 4 + %133 = and i64 %131, 15 + %134 = add i64 %130, 16 + %135 = add i64 %134, %126 + %136 = lshr i64 %135, 4 + %137 = and i64 %135, 15 + %138 = add i64 %130, 32 + %139 = add i64 %138, %126 + %140 = lshr i64 %139, 4 + %141 = and i64 %139, 15 + %142 = add i64 %130, 48 + %143 = add i64 %142, %126 + %144 = lshr i64 %143, 4 + %145 = and i64 %143, 15 + call void @llvm.amdgcn.sched.barrier(i32 0) + %146 = icmp ult i64 %19, 32 + br i1 %146, label %147, label %154 + +147: ; preds = %100 + %148 = add i64 %83, %19 + %149 = trunc i64 %148 to i32 + %150 = mul i32 %149, 4 + %151 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %60, i32 %150, i32 0, i32 0) + %152 = insertelement <1 x i32> poison, i32 %151, i32 0 + %153 = getelementptr i32, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @smem0, i32 32768), i64 %19 + store <1 x i32> %152, ptr addrspace(3) %153, align 4 + br label %154 + +154: ; preds = %147, %100 + %155 = mul i64 %132, 4096 + %156 = add i64 %92, %155 + %157 = mul i64 %125, 256 + %158 = add i64 %156, %157 + %159 = mul i64 %133, 16 + %160 = add i64 %158, %159 + %161 = lshr i64 %160, 2 + %162 = trunc i64 %161 to i32 + %163 = mul i32 %162, 4 + %164 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %163, i32 0, i32 2) + %165 = bitcast <4 x i32> %164 to <2 x i64> + %166 = extractelement <2 x i64> %165, i64 0 + %167 = extractelement <2 x i64> %165, i64 1 + %168 = mul i64 %136, 4096 + %169 = add i64 %92, %168 + %170 = add i64 %169, %157 + %171 = mul i64 %137, 16 + %172 = add i64 %170, %171 + %173 = lshr i64 %172, 2 + %174 = trunc i64 %173 to i32 + %175 = mul i32 %174, 4 + %176 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %175, i32 0, i32 2) + %177 = bitcast <4 x i32> %176 to <2 x i64> + %178 = extractelement <2 x i64> %177, i64 0 + %179 = extractelement <2 x i64> %177, i64 1 + %180 = mul i64 %140, 4096 + %181 = add i64 %92, %180 + %182 = add i64 %181, %157 + %183 = mul i64 %141, 16 + %184 = add i64 %182, %183 + %185 = lshr i64 %184, 2 + %186 = trunc i64 %185 to i32 + %187 = mul i32 %186, 4 + %188 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %187, i32 0, i32 2) + %189 = bitcast <4 x i32> %188 to <2 x i64> + %190 = extractelement <2 x i64> %189, i64 0 + %191 = extractelement <2 x i64> %189, i64 1 + %192 = mul i64 %144, 4096 + %193 = add i64 %92, %192 + %194 = add i64 %193, %157 + %195 = mul i64 %145, 16 + %196 = add i64 %194, %195 + %197 = lshr i64 %196, 2 + %198 = trunc i64 %197 to i32 + %199 = mul i32 %198, 4 + %200 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %199, i32 0, i32 2) + %201 = bitcast <4 x i32> %200 to <2 x i64> + %202 = extractelement <2 x i64> %201, i64 0 + %203 = extractelement <2 x i64> %201, i64 1 + %204 = lshr i64 %83, 1 + %205 = lshr i64 %204, 4 + %206 = mul i64 %205, 128 + %207 = add i64 %206, %127 + %208 = add i64 %207, %126 + %209 = trunc i64 %208 to i32 + %210 = mul i32 %209, 4 + %211 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %47, i32 %210, i32 0, i32 0) + %212 = add i64 %101, %129 + %213 = add i64 %212, %128 + %214 = lshr i64 %213, 1 + %215 = lshr i64 %214, 4 + %216 = mul i64 %215, 128 + %217 = add i64 %216, %127 + %218 = add i64 %217, %126 + %219 = trunc i64 %218 to i32 + %220 = mul i32 %219, 4 + %221 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %53, i32 %220, i32 0, i32 0) + %222 = add i64 %215, 1 + %223 = mul i64 %222, 128 + %224 = add i64 %223, %127 + %225 = add i64 %224, %126 + %226 = trunc i64 %225 to i32 + %227 = mul i32 %226, 4 + %228 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %53, i32 %227, i32 0, i32 0) + call void @llvm.amdgcn.sched.barrier(i32 0) + %229 = mul i64 %110, 4 + %230 = and i64 %109, 7 + %231 = mul i64 %230, 16 + %232 = xor i64 %229, %231 + %233 = mul i64 %120, 4 + %234 = add i64 %233, %232 + %235 = trunc i64 %234 to i32 + %236 = mul i64 %122, 1024 + %237 = add i64 ptrtoint (ptr addrspace(3) @smem0 to i64), %236 + %238 = call i64 @llvm.amdgcn.readfirstlane.i64(i64 %237) + %239 = inttoptr i64 %238 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %31, ptr addrspace(3) %239, i32 16, i32 %235, i32 0, i32 0, i32 0) + call void @llvm.amdgcn.s.waitcnt(i32 0) + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %240 = and i64 %126, 7 + %241 = mul i64 %240, 16 + %242 = xor i64 %127, %241 + %243 = mul i64 %126, 128 + %244 = add i64 %243, %242 + %245 = getelementptr i8, ptr addrspace(3) @smem0, i64 %244 + %246 = load <16 x i8>, ptr addrspace(3) %245, align 1 + %247 = bitcast <16 x i8> %246 to <2 x i64> + %248 = extractelement <2 x i64> %247, i64 0 + %249 = extractelement <2 x i64> %247, i64 1 + %250 = add i64 %127, 64 + %251 = xor i64 %250, %241 + %252 = add i64 %243, %251 + %253 = getelementptr i8, ptr addrspace(3) @smem0, i64 %252 + %254 = load <16 x i8>, ptr addrspace(3) %253, align 1 + %255 = bitcast <16 x i8> %254 to <2 x i64> + %256 = extractelement <2 x i64> %255, i64 0 + %257 = extractelement <2 x i64> %255, i64 1 + %258 = add i64 %16, 255 + %259 = udiv i64 %258, 256 + %260 = mul i64 %259, 256 + %261 = sub i64 %260, 256 + %262 = udiv i64 %261, 2 + %263 = lshr i64 %261, 1 + %264 = lshr i64 %263, 2 + %265 = add i64 %120, %264 + %266 = mul i64 %265, 4 + %267 = add i64 %266, %232 + %268 = trunc i64 %267 to i32 + %269 = add i64 ptrtoint (ptr addrspace(3) @smem1 to i64), %236 + %270 = call i64 @llvm.amdgcn.readfirstlane.i64(i64 %269) + %271 = inttoptr i64 %270 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %31, ptr addrspace(3) %271, i32 16, i32 %268, i32 0, i32 0, i32 0) + %272 = lshr i64 %262, 6 + %273 = mul i64 %272, 1024 + %274 = add i64 %156, %273 + %275 = add i64 %274, %157 + %276 = add i64 %275, %159 + %277 = lshr i64 %276, 2 + %278 = trunc i64 %277 to i32 + %279 = mul i32 %278, 4 + %280 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %279, i32 0, i32 2) + %281 = bitcast <4 x i32> %280 to <2 x i64> + %282 = extractelement <2 x i64> %281, i64 0 + %283 = extractelement <2 x i64> %281, i64 1 + %284 = add i64 %169, %273 + %285 = add i64 %284, %157 + %286 = add i64 %285, %171 + %287 = lshr i64 %286, 2 + %288 = trunc i64 %287 to i32 + %289 = mul i32 %288, 4 + %290 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %289, i32 0, i32 2) + %291 = bitcast <4 x i32> %290 to <2 x i64> + %292 = extractelement <2 x i64> %291, i64 0 + %293 = extractelement <2 x i64> %291, i64 1 + %294 = add i64 %181, %273 + %295 = add i64 %294, %157 + %296 = add i64 %295, %183 + %297 = lshr i64 %296, 2 + %298 = trunc i64 %297 to i32 + %299 = mul i32 %298, 4 + %300 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %299, i32 0, i32 2) + %301 = bitcast <4 x i32> %300 to <2 x i64> + %302 = extractelement <2 x i64> %301, i64 0 + %303 = extractelement <2 x i64> %301, i64 1 + %304 = add i64 %193, %273 + %305 = add i64 %304, %157 + %306 = add i64 %305, %195 + %307 = lshr i64 %306, 2 + %308 = trunc i64 %307 to i32 + %309 = mul i32 %308, 4 + %310 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %309, i32 0, i32 2) + %311 = bitcast <4 x i32> %310 to <2 x i64> + %312 = extractelement <2 x i64> %311, i64 0 + %313 = extractelement <2 x i64> %311, i64 1 + %314 = add i64 %206, 64 + %315 = add i64 %314, %127 + %316 = add i64 %315, %126 + %317 = trunc i64 %316 to i32 + %318 = mul i32 %317, 4 + %319 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %47, i32 %318, i32 0, i32 0) + %320 = add i64 %216, 64 + %321 = add i64 %320, %127 + %322 = add i64 %321, %126 + %323 = trunc i64 %322 to i32 + %324 = mul i32 %323, 4 + %325 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %53, i32 %324, i32 0, i32 0) + %326 = add i64 %223, 64 + %327 = add i64 %326, %127 + %328 = add i64 %327, %126 + %329 = trunc i64 %328 to i32 + %330 = mul i32 %329, 4 + %331 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %53, i32 %330, i32 0, i32 0) + %332 = add i64 %156, 1024 + %333 = add i64 %332, %157 + %334 = add i64 %333, %159 + %335 = lshr i64 %334, 2 + %336 = trunc i64 %335 to i32 + %337 = mul i32 %336, 4 + %338 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %337, i32 0, i32 2) + %339 = bitcast <4 x i32> %338 to <2 x i64> + %340 = extractelement <2 x i64> %339, i64 0 + %341 = extractelement <2 x i64> %339, i64 1 + %342 = add i64 %169, 1024 + %343 = add i64 %342, %157 + %344 = add i64 %343, %171 + %345 = lshr i64 %344, 2 + %346 = trunc i64 %345 to i32 + %347 = mul i32 %346, 4 + %348 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %347, i32 0, i32 2) + %349 = bitcast <4 x i32> %348 to <2 x i64> + %350 = extractelement <2 x i64> %349, i64 0 + %351 = extractelement <2 x i64> %349, i64 1 + %352 = add i64 %181, 1024 + %353 = add i64 %352, %157 + %354 = add i64 %353, %183 + %355 = lshr i64 %354, 2 + %356 = trunc i64 %355 to i32 + %357 = mul i32 %356, 4 + %358 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %357, i32 0, i32 2) + %359 = bitcast <4 x i32> %358 to <2 x i64> + %360 = extractelement <2 x i64> %359, i64 0 + %361 = extractelement <2 x i64> %359, i64 1 + %362 = add i64 %193, 1024 + %363 = add i64 %362, %157 + %364 = add i64 %363, %195 + %365 = lshr i64 %364, 2 + %366 = trunc i64 %365 to i32 + %367 = mul i32 %366, 4 + %368 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %367, i32 0, i32 2) + %369 = bitcast <4 x i32> %368 to <2 x i64> + %370 = extractelement <2 x i64> %369, i64 0 + %371 = extractelement <2 x i64> %369, i64 1 + %372 = insertelement <4 x i64> poison, i64 %248, i64 0 + %373 = insertelement <4 x i64> %372, i64 %249, i64 1 + %374 = insertelement <4 x i64> %373, i64 0, i64 2 + %375 = insertelement <4 x i64> %374, i64 0, i64 3 + %376 = bitcast <4 x i64> %375 to <8 x i32> + %377 = insertelement <4 x i64> poison, i64 %166, i64 0 + %378 = insertelement <4 x i64> %377, i64 %167, i64 1 + %379 = insertelement <4 x i64> %378, i64 0, i64 2 + %380 = insertelement <4 x i64> %379, i64 0, i64 3 + %381 = bitcast <4 x i64> %380 to <8 x i32> + %382 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %376, <8 x i32> %381, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %211, i32 0, i32 %221) + %383 = insertelement <4 x i64> poison, i64 %178, i64 0 + %384 = insertelement <4 x i64> %383, i64 %179, i64 1 + %385 = insertelement <4 x i64> %384, i64 0, i64 2 + %386 = insertelement <4 x i64> %385, i64 0, i64 3 + %387 = bitcast <4 x i64> %386 to <8 x i32> + %388 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %376, <8 x i32> %387, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %211, i32 1, i32 %221) + %389 = add i64 %126, 16 + %390 = and i64 %389, 7 + %391 = mul i64 %390, 16 + %392 = xor i64 %127, %391 + %393 = mul i64 %389, 128 + %394 = add i64 %393, %392 + %395 = getelementptr i8, ptr addrspace(3) @smem0, i64 %394 + %396 = load <16 x i8>, ptr addrspace(3) %395, align 1 + %397 = bitcast <16 x i8> %396 to <2 x i64> + %398 = extractelement <2 x i64> %397, i64 0 + %399 = extractelement <2 x i64> %397, i64 1 + %400 = insertelement <4 x i64> poison, i64 %398, i64 0 + %401 = insertelement <4 x i64> %400, i64 %399, i64 1 + %402 = insertelement <4 x i64> %401, i64 0, i64 2 + %403 = insertelement <4 x i64> %402, i64 0, i64 3 + %404 = bitcast <4 x i64> %403 to <8 x i32> + %405 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %404, <8 x i32> %381, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %211, i32 0, i32 %221) + %406 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %404, <8 x i32> %387, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %211, i32 1, i32 %221) + %407 = insertelement <4 x i64> poison, i64 %190, i64 0 + %408 = insertelement <4 x i64> %407, i64 %191, i64 1 + %409 = insertelement <4 x i64> %408, i64 0, i64 2 + %410 = insertelement <4 x i64> %409, i64 0, i64 3 + %411 = bitcast <4 x i64> %410 to <8 x i32> + %412 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %376, <8 x i32> %411, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %211, i32 0, i32 %228) + %413 = insertelement <4 x i64> poison, i64 %202, i64 0 + %414 = insertelement <4 x i64> %413, i64 %203, i64 1 + %415 = insertelement <4 x i64> %414, i64 0, i64 2 + %416 = insertelement <4 x i64> %415, i64 0, i64 3 + %417 = bitcast <4 x i64> %416 to <8 x i32> + %418 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %376, <8 x i32> %417, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %211, i32 1, i32 %228) + %419 = getelementptr i8, ptr addrspace(3) @smem0, i64 %394 + %420 = load <16 x i8>, ptr addrspace(3) %419, align 1 + %421 = bitcast <16 x i8> %420 to <2 x i64> + %422 = extractelement <2 x i64> %421, i64 0 + %423 = extractelement <2 x i64> %421, i64 1 + %424 = insertelement <4 x i64> poison, i64 %422, i64 0 + %425 = insertelement <4 x i64> %424, i64 %423, i64 1 + %426 = insertelement <4 x i64> %425, i64 0, i64 2 + %427 = insertelement <4 x i64> %426, i64 0, i64 3 + %428 = bitcast <4 x i64> %427 to <8 x i32> + %429 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %428, <8 x i32> %411, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %211, i32 0, i32 %228) + %430 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %428, <8 x i32> %417, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %211, i32 1, i32 %228) + %431 = insertelement <4 x i64> poison, i64 %256, i64 0 + %432 = insertelement <4 x i64> %431, i64 %257, i64 1 + %433 = insertelement <4 x i64> %432, i64 0, i64 2 + %434 = insertelement <4 x i64> %433, i64 0, i64 3 + %435 = bitcast <4 x i64> %434 to <8 x i32> + %436 = insertelement <4 x i64> poison, i64 %340, i64 0 + %437 = insertelement <4 x i64> %436, i64 %341, i64 1 + %438 = insertelement <4 x i64> %437, i64 0, i64 2 + %439 = insertelement <4 x i64> %438, i64 0, i64 3 + %440 = bitcast <4 x i64> %439 to <8 x i32> + %441 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %435, <8 x i32> %440, <4 x float> %382, i32 4, i32 4, i32 2, i32 %211, i32 2, i32 %221) + %442 = insertelement <4 x i64> poison, i64 %350, i64 0 + %443 = insertelement <4 x i64> %442, i64 %351, i64 1 + %444 = insertelement <4 x i64> %443, i64 0, i64 2 + %445 = insertelement <4 x i64> %444, i64 0, i64 3 + %446 = bitcast <4 x i64> %445 to <8 x i32> + %447 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %435, <8 x i32> %446, <4 x float> %388, i32 4, i32 4, i32 2, i32 %211, i32 3, i32 %221) + %448 = xor i64 %250, %391 + %449 = add i64 %393, %448 + %450 = getelementptr i8, ptr addrspace(3) @smem0, i64 %449 + %451 = load <16 x i8>, ptr addrspace(3) %450, align 1 + %452 = bitcast <16 x i8> %451 to <2 x i64> + %453 = extractelement <2 x i64> %452, i64 0 + %454 = extractelement <2 x i64> %452, i64 1 + %455 = insertelement <4 x i64> poison, i64 %453, i64 0 + %456 = insertelement <4 x i64> %455, i64 %454, i64 1 + %457 = insertelement <4 x i64> %456, i64 0, i64 2 + %458 = insertelement <4 x i64> %457, i64 0, i64 3 + %459 = bitcast <4 x i64> %458 to <8 x i32> + %460 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %459, <8 x i32> %440, <4 x float> %405, i32 4, i32 4, i32 3, i32 %211, i32 2, i32 %221) + %461 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %459, <8 x i32> %446, <4 x float> %406, i32 4, i32 4, i32 3, i32 %211, i32 3, i32 %221) + %462 = insertelement <4 x i64> poison, i64 %360, i64 0 + %463 = insertelement <4 x i64> %462, i64 %361, i64 1 + %464 = insertelement <4 x i64> %463, i64 0, i64 2 + %465 = insertelement <4 x i64> %464, i64 0, i64 3 + %466 = bitcast <4 x i64> %465 to <8 x i32> + %467 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %435, <8 x i32> %466, <4 x float> %412, i32 4, i32 4, i32 2, i32 %211, i32 2, i32 %228) + %468 = insertelement <4 x i64> poison, i64 %370, i64 0 + %469 = insertelement <4 x i64> %468, i64 %371, i64 1 + %470 = insertelement <4 x i64> %469, i64 0, i64 2 + %471 = insertelement <4 x i64> %470, i64 0, i64 3 + %472 = bitcast <4 x i64> %471 to <8 x i32> + %473 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %435, <8 x i32> %472, <4 x float> %418, i32 4, i32 4, i32 2, i32 %211, i32 3, i32 %228) + %474 = getelementptr i8, ptr addrspace(3) @smem0, i64 %449 + %475 = load <16 x i8>, ptr addrspace(3) %474, align 1 + %476 = bitcast <16 x i8> %475 to <2 x i64> + %477 = extractelement <2 x i64> %476, i64 0 + %478 = extractelement <2 x i64> %476, i64 1 + %479 = insertelement <4 x i64> poison, i64 %477, i64 0 + %480 = insertelement <4 x i64> %479, i64 %478, i64 1 + %481 = insertelement <4 x i64> %480, i64 0, i64 2 + %482 = insertelement <4 x i64> %481, i64 0, i64 3 + %483 = bitcast <4 x i64> %482 to <8 x i32> + %484 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %483, <8 x i32> %466, <4 x float> %429, i32 4, i32 4, i32 3, i32 %211, i32 2, i32 %228) + %485 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %483, <8 x i32> %472, <4 x float> %430, i32 4, i32 4, i32 3, i32 %211, i32 3, i32 %228) + call void @llvm.amdgcn.s.waitcnt(i32 0) + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %486 = getelementptr i8, ptr addrspace(3) @smem1, i64 %244 + %487 = load <16 x i8>, ptr addrspace(3) %486, align 1 + %488 = bitcast <16 x i8> %487 to <2 x i64> + %489 = extractelement <2 x i64> %488, i64 0 + %490 = extractelement <2 x i64> %488, i64 1 + %491 = getelementptr i8, ptr addrspace(3) @smem1, i64 %252 + %492 = load <16 x i8>, ptr addrspace(3) %491, align 1 + %493 = bitcast <16 x i8> %492 to <2 x i64> + %494 = extractelement <2 x i64> %493, i64 0 + %495 = extractelement <2 x i64> %493, i64 1 + %496 = mul i64 %125, 4 + %497 = add i64 %83, %496 + %498 = trunc i64 %497 to i32 + %499 = mul i32 %498, 4 + %500 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %499, i32 0, i32 0) + %501 = add i64 %496, 1 + %502 = add i64 %83, %501 + %503 = trunc i64 %502 to i32 + %504 = mul i32 %503, 4 + %505 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %504, i32 0, i32 0) + %506 = add i64 %496, 2 + %507 = add i64 %83, %506 + %508 = trunc i64 %507 to i32 + %509 = mul i32 %508, 4 + %510 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %509, i32 0, i32 0) + %511 = add i64 %496, 3 + %512 = add i64 %83, %511 + %513 = trunc i64 %512 to i32 + %514 = mul i32 %513, 4 + %515 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %514, i32 0, i32 0) + %516 = add i64 %496, 16 + %517 = add i64 %83, %516 + %518 = trunc i64 %517 to i32 + %519 = mul i32 %518, 4 + %520 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %519, i32 0, i32 0) + %521 = add i64 %496, 17 + %522 = add i64 %83, %521 + %523 = trunc i64 %522 to i32 + %524 = mul i32 %523, 4 + %525 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %524, i32 0, i32 0) + %526 = add i64 %496, 18 + %527 = add i64 %83, %526 + %528 = trunc i64 %527 to i32 + %529 = mul i32 %528, 4 + %530 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %529, i32 0, i32 0) + %531 = add i64 %496, 19 + %532 = add i64 %83, %531 + %533 = trunc i64 %532 to i32 + %534 = mul i32 %533, 4 + %535 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %534, i32 0, i32 0) + %536 = add i64 %272, 1 + %537 = mul i64 %536, 1024 + %538 = add i64 %156, %537 + %539 = add i64 %538, %157 + %540 = add i64 %539, %159 + %541 = lshr i64 %540, 2 + %542 = trunc i64 %541 to i32 + %543 = mul i32 %542, 4 + %544 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %543, i32 0, i32 2) + %545 = bitcast <4 x i32> %544 to <2 x i64> + %546 = extractelement <2 x i64> %545, i64 0 + %547 = extractelement <2 x i64> %545, i64 1 + %548 = add i64 %169, %537 + %549 = add i64 %548, %157 + %550 = add i64 %549, %171 + %551 = lshr i64 %550, 2 + %552 = trunc i64 %551 to i32 + %553 = mul i32 %552, 4 + %554 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %553, i32 0, i32 2) + %555 = bitcast <4 x i32> %554 to <2 x i64> + %556 = extractelement <2 x i64> %555, i64 0 + %557 = extractelement <2 x i64> %555, i64 1 + %558 = add i64 %181, %537 + %559 = add i64 %558, %157 + %560 = add i64 %559, %183 + %561 = lshr i64 %560, 2 + %562 = trunc i64 %561 to i32 + %563 = mul i32 %562, 4 + %564 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %563, i32 0, i32 2) + %565 = bitcast <4 x i32> %564 to <2 x i64> + %566 = extractelement <2 x i64> %565, i64 0 + %567 = extractelement <2 x i64> %565, i64 1 + %568 = add i64 %193, %537 + %569 = add i64 %568, %157 + %570 = add i64 %569, %195 + %571 = lshr i64 %570, 2 + %572 = trunc i64 %571 to i32 + %573 = mul i32 %572, 4 + %574 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %573, i32 0, i32 2) + %575 = bitcast <4 x i32> %574 to <2 x i64> + %576 = extractelement <2 x i64> %575, i64 0 + %577 = extractelement <2 x i64> %575, i64 1 + %578 = insertelement <4 x i64> poison, i64 %489, i64 0 + %579 = insertelement <4 x i64> %578, i64 %490, i64 1 + %580 = insertelement <4 x i64> %579, i64 0, i64 2 + %581 = insertelement <4 x i64> %580, i64 0, i64 3 + %582 = bitcast <4 x i64> %581 to <8 x i32> + %583 = insertelement <4 x i64> poison, i64 %282, i64 0 + %584 = insertelement <4 x i64> %583, i64 %283, i64 1 + %585 = insertelement <4 x i64> %584, i64 0, i64 2 + %586 = insertelement <4 x i64> %585, i64 0, i64 3 + %587 = bitcast <4 x i64> %586 to <8 x i32> + %588 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %582, <8 x i32> %587, <4 x float> %441, i32 4, i32 4, i32 0, i32 %319, i32 0, i32 %325) + %589 = insertelement <4 x i64> poison, i64 %292, i64 0 + %590 = insertelement <4 x i64> %589, i64 %293, i64 1 + %591 = insertelement <4 x i64> %590, i64 0, i64 2 + %592 = insertelement <4 x i64> %591, i64 0, i64 3 + %593 = bitcast <4 x i64> %592 to <8 x i32> + %594 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %582, <8 x i32> %593, <4 x float> %447, i32 4, i32 4, i32 0, i32 %319, i32 1, i32 %325) + %595 = getelementptr i8, ptr addrspace(3) @smem1, i64 %394 + %596 = load <16 x i8>, ptr addrspace(3) %595, align 1 + %597 = bitcast <16 x i8> %596 to <2 x i64> + %598 = extractelement <2 x i64> %597, i64 0 + %599 = extractelement <2 x i64> %597, i64 1 + %600 = insertelement <4 x i64> poison, i64 %598, i64 0 + %601 = insertelement <4 x i64> %600, i64 %599, i64 1 + %602 = insertelement <4 x i64> %601, i64 0, i64 2 + %603 = insertelement <4 x i64> %602, i64 0, i64 3 + %604 = bitcast <4 x i64> %603 to <8 x i32> + %605 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %604, <8 x i32> %587, <4 x float> %460, i32 4, i32 4, i32 1, i32 %319, i32 0, i32 %325) + %606 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %604, <8 x i32> %593, <4 x float> %461, i32 4, i32 4, i32 1, i32 %319, i32 1, i32 %325) + %607 = insertelement <4 x i64> poison, i64 %302, i64 0 + %608 = insertelement <4 x i64> %607, i64 %303, i64 1 + %609 = insertelement <4 x i64> %608, i64 0, i64 2 + %610 = insertelement <4 x i64> %609, i64 0, i64 3 + %611 = bitcast <4 x i64> %610 to <8 x i32> + %612 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %582, <8 x i32> %611, <4 x float> %467, i32 4, i32 4, i32 0, i32 %319, i32 0, i32 %331) + %613 = insertelement <4 x i64> poison, i64 %312, i64 0 + %614 = insertelement <4 x i64> %613, i64 %313, i64 1 + %615 = insertelement <4 x i64> %614, i64 0, i64 2 + %616 = insertelement <4 x i64> %615, i64 0, i64 3 + %617 = bitcast <4 x i64> %616 to <8 x i32> + %618 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %582, <8 x i32> %617, <4 x float> %473, i32 4, i32 4, i32 0, i32 %319, i32 1, i32 %331) + %619 = getelementptr i8, ptr addrspace(3) @smem1, i64 %394 + %620 = load <16 x i8>, ptr addrspace(3) %619, align 1 + %621 = bitcast <16 x i8> %620 to <2 x i64> + %622 = extractelement <2 x i64> %621, i64 0 + %623 = extractelement <2 x i64> %621, i64 1 + %624 = insertelement <4 x i64> poison, i64 %622, i64 0 + %625 = insertelement <4 x i64> %624, i64 %623, i64 1 + %626 = insertelement <4 x i64> %625, i64 0, i64 2 + %627 = insertelement <4 x i64> %626, i64 0, i64 3 + %628 = bitcast <4 x i64> %627 to <8 x i32> + %629 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %628, <8 x i32> %611, <4 x float> %484, i32 4, i32 4, i32 1, i32 %319, i32 0, i32 %331) + %630 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %628, <8 x i32> %617, <4 x float> %485, i32 4, i32 4, i32 1, i32 %319, i32 1, i32 %331) + %631 = insertelement <4 x i64> poison, i64 %494, i64 0 + %632 = insertelement <4 x i64> %631, i64 %495, i64 1 + %633 = insertelement <4 x i64> %632, i64 0, i64 2 + %634 = insertelement <4 x i64> %633, i64 0, i64 3 + %635 = bitcast <4 x i64> %634 to <8 x i32> + %636 = insertelement <4 x i64> poison, i64 %546, i64 0 + %637 = insertelement <4 x i64> %636, i64 %547, i64 1 + %638 = insertelement <4 x i64> %637, i64 0, i64 2 + %639 = insertelement <4 x i64> %638, i64 0, i64 3 + %640 = bitcast <4 x i64> %639 to <8 x i32> + %641 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %635, <8 x i32> %640, <4 x float> %588, i32 4, i32 4, i32 2, i32 %319, i32 2, i32 %325) + %642 = insertelement <4 x i64> poison, i64 %556, i64 0 + %643 = insertelement <4 x i64> %642, i64 %557, i64 1 + %644 = insertelement <4 x i64> %643, i64 0, i64 2 + %645 = insertelement <4 x i64> %644, i64 0, i64 3 + %646 = bitcast <4 x i64> %645 to <8 x i32> + %647 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %635, <8 x i32> %646, <4 x float> %594, i32 4, i32 4, i32 2, i32 %319, i32 3, i32 %325) + %648 = getelementptr i8, ptr addrspace(3) @smem1, i64 %449 + %649 = load <16 x i8>, ptr addrspace(3) %648, align 1 + %650 = bitcast <16 x i8> %649 to <2 x i64> + %651 = extractelement <2 x i64> %650, i64 0 + %652 = extractelement <2 x i64> %650, i64 1 + %653 = insertelement <4 x i64> poison, i64 %651, i64 0 + %654 = insertelement <4 x i64> %653, i64 %652, i64 1 + %655 = insertelement <4 x i64> %654, i64 0, i64 2 + %656 = insertelement <4 x i64> %655, i64 0, i64 3 + %657 = bitcast <4 x i64> %656 to <8 x i32> + %658 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %657, <8 x i32> %640, <4 x float> %605, i32 4, i32 4, i32 3, i32 %319, i32 2, i32 %325) + %659 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %657, <8 x i32> %646, <4 x float> %606, i32 4, i32 4, i32 3, i32 %319, i32 3, i32 %325) + %660 = insertelement <4 x i64> poison, i64 %566, i64 0 + %661 = insertelement <4 x i64> %660, i64 %567, i64 1 + %662 = insertelement <4 x i64> %661, i64 0, i64 2 + %663 = insertelement <4 x i64> %662, i64 0, i64 3 + %664 = bitcast <4 x i64> %663 to <8 x i32> + %665 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %635, <8 x i32> %664, <4 x float> %612, i32 4, i32 4, i32 2, i32 %319, i32 2, i32 %331) + %666 = insertelement <4 x i64> poison, i64 %576, i64 0 + %667 = insertelement <4 x i64> %666, i64 %577, i64 1 + %668 = insertelement <4 x i64> %667, i64 0, i64 2 + %669 = insertelement <4 x i64> %668, i64 0, i64 3 + %670 = bitcast <4 x i64> %669 to <8 x i32> + %671 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %635, <8 x i32> %670, <4 x float> %618, i32 4, i32 4, i32 2, i32 %319, i32 3, i32 %331) + %672 = getelementptr i8, ptr addrspace(3) @smem1, i64 %449 + %673 = load <16 x i8>, ptr addrspace(3) %672, align 1 + %674 = bitcast <16 x i8> %673 to <2 x i64> + %675 = extractelement <2 x i64> %674, i64 0 + %676 = extractelement <2 x i64> %674, i64 1 + %677 = insertelement <4 x i64> poison, i64 %675, i64 0 + %678 = insertelement <4 x i64> %677, i64 %676, i64 1 + %679 = insertelement <4 x i64> %678, i64 0, i64 2 + %680 = insertelement <4 x i64> %679, i64 0, i64 3 + %681 = bitcast <4 x i64> %680 to <8 x i32> + %682 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %681, <8 x i32> %664, <4 x float> %629, i32 4, i32 4, i32 3, i32 %319, i32 2, i32 %331) + %683 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %681, <8 x i32> %670, <4 x float> %630, i32 4, i32 4, i32 3, i32 %319, i32 3, i32 %331) + %684 = ptrtoint ptr addrspace(1) %0 to i64 + %685 = add i64 %128, %126 + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %686 = mul i64 %125, 1024 + %687 = extractelement <4 x float> %641, i64 0 + %688 = extractelement <4 x float> %647, i64 0 + %689 = extractelement <4 x float> %665, i64 0 + %690 = extractelement <4 x float> %671, i64 0 + %691 = insertelement <4 x float> poison, float %687, i64 0 + %692 = insertelement <4 x float> %691, float %688, i64 1 + %693 = insertelement <4 x float> %692, float %689, i64 2 + %694 = insertelement <4 x float> %693, float %690, i64 3 + %695 = insertelement <4 x float> poison, float %500, i32 0 + %696 = shufflevector <4 x float> %695, <4 x float> poison, <4 x i32> zeroinitializer + %697 = fmul <4 x float> %694, %696 + %698 = extractelement <4 x float> %697, i64 0 + %699 = add i64 %686, %685 + %700 = insertelement <1 x float> poison, float %698, i32 0 + %701 = getelementptr float, ptr addrspace(3) @smem0, i64 %699 + store <1 x float> %700, ptr addrspace(3) %701, align 4 + %702 = add i64 %685, 16 + %703 = extractelement <4 x float> %697, i64 1 + %704 = add i64 %686, %702 + %705 = insertelement <1 x float> poison, float %703, i32 0 + %706 = getelementptr float, ptr addrspace(3) @smem0, i64 %704 + store <1 x float> %705, ptr addrspace(3) %706, align 4 + %707 = add i64 %685, 32 + %708 = extractelement <4 x float> %697, i64 2 + %709 = add i64 %686, %707 + %710 = insertelement <1 x float> poison, float %708, i32 0 + %711 = getelementptr float, ptr addrspace(3) @smem0, i64 %709 + store <1 x float> %710, ptr addrspace(3) %711, align 4 + %712 = add i64 %685, 48 + %713 = extractelement <4 x float> %697, i64 3 + %714 = add i64 %686, %712 + %715 = insertelement <1 x float> poison, float %713, i32 0 + %716 = getelementptr float, ptr addrspace(3) @smem0, i64 %714 + store <1 x float> %715, ptr addrspace(3) %716, align 4 + %717 = mul i64 %501, 256 + %718 = extractelement <4 x float> %641, i64 1 + %719 = extractelement <4 x float> %647, i64 1 + %720 = extractelement <4 x float> %665, i64 1 + %721 = extractelement <4 x float> %671, i64 1 + %722 = insertelement <4 x float> poison, float %718, i64 0 + %723 = insertelement <4 x float> %722, float %719, i64 1 + %724 = insertelement <4 x float> %723, float %720, i64 2 + %725 = insertelement <4 x float> %724, float %721, i64 3 + %726 = insertelement <4 x float> poison, float %505, i32 0 + %727 = shufflevector <4 x float> %726, <4 x float> poison, <4 x i32> zeroinitializer + %728 = fmul <4 x float> %725, %727 + %729 = extractelement <4 x float> %728, i64 0 + %730 = add i64 %717, %685 + %731 = insertelement <1 x float> poison, float %729, i32 0 + %732 = getelementptr float, ptr addrspace(3) @smem0, i64 %730 + store <1 x float> %731, ptr addrspace(3) %732, align 4 + %733 = extractelement <4 x float> %728, i64 1 + %734 = add i64 %717, %702 + %735 = insertelement <1 x float> poison, float %733, i32 0 + %736 = getelementptr float, ptr addrspace(3) @smem0, i64 %734 + store <1 x float> %735, ptr addrspace(3) %736, align 4 + %737 = extractelement <4 x float> %728, i64 2 + %738 = add i64 %717, %707 + %739 = insertelement <1 x float> poison, float %737, i32 0 + %740 = getelementptr float, ptr addrspace(3) @smem0, i64 %738 + store <1 x float> %739, ptr addrspace(3) %740, align 4 + %741 = extractelement <4 x float> %728, i64 3 + %742 = add i64 %717, %712 + %743 = insertelement <1 x float> poison, float %741, i32 0 + %744 = getelementptr float, ptr addrspace(3) @smem0, i64 %742 + store <1 x float> %743, ptr addrspace(3) %744, align 4 + %745 = mul i64 %506, 256 + %746 = extractelement <4 x float> %641, i64 2 + %747 = extractelement <4 x float> %647, i64 2 + %748 = extractelement <4 x float> %665, i64 2 + %749 = extractelement <4 x float> %671, i64 2 + %750 = insertelement <4 x float> poison, float %746, i64 0 + %751 = insertelement <4 x float> %750, float %747, i64 1 + %752 = insertelement <4 x float> %751, float %748, i64 2 + %753 = insertelement <4 x float> %752, float %749, i64 3 + %754 = insertelement <4 x float> poison, float %510, i32 0 + %755 = shufflevector <4 x float> %754, <4 x float> poison, <4 x i32> zeroinitializer + %756 = fmul <4 x float> %753, %755 + %757 = extractelement <4 x float> %756, i64 0 + %758 = add i64 %745, %685 + %759 = insertelement <1 x float> poison, float %757, i32 0 + %760 = getelementptr float, ptr addrspace(3) @smem0, i64 %758 + store <1 x float> %759, ptr addrspace(3) %760, align 4 + %761 = extractelement <4 x float> %756, i64 1 + %762 = add i64 %745, %702 + %763 = insertelement <1 x float> poison, float %761, i32 0 + %764 = getelementptr float, ptr addrspace(3) @smem0, i64 %762 + store <1 x float> %763, ptr addrspace(3) %764, align 4 + %765 = extractelement <4 x float> %756, i64 2 + %766 = add i64 %745, %707 + %767 = insertelement <1 x float> poison, float %765, i32 0 + %768 = getelementptr float, ptr addrspace(3) @smem0, i64 %766 + store <1 x float> %767, ptr addrspace(3) %768, align 4 + %769 = extractelement <4 x float> %756, i64 3 + %770 = add i64 %745, %712 + %771 = insertelement <1 x float> poison, float %769, i32 0 + %772 = getelementptr float, ptr addrspace(3) @smem0, i64 %770 + store <1 x float> %771, ptr addrspace(3) %772, align 4 + %773 = mul i64 %511, 256 + %774 = extractelement <4 x float> %641, i64 3 + %775 = extractelement <4 x float> %647, i64 3 + %776 = extractelement <4 x float> %665, i64 3 + %777 = extractelement <4 x float> %671, i64 3 + %778 = insertelement <4 x float> poison, float %774, i64 0 + %779 = insertelement <4 x float> %778, float %775, i64 1 + %780 = insertelement <4 x float> %779, float %776, i64 2 + %781 = insertelement <4 x float> %780, float %777, i64 3 + %782 = insertelement <4 x float> poison, float %515, i32 0 + %783 = shufflevector <4 x float> %782, <4 x float> poison, <4 x i32> zeroinitializer + %784 = fmul <4 x float> %781, %783 + %785 = extractelement <4 x float> %784, i64 0 + %786 = add i64 %773, %685 + %787 = insertelement <1 x float> poison, float %785, i32 0 + %788 = getelementptr float, ptr addrspace(3) @smem0, i64 %786 + store <1 x float> %787, ptr addrspace(3) %788, align 4 + %789 = extractelement <4 x float> %784, i64 1 + %790 = add i64 %773, %702 + %791 = insertelement <1 x float> poison, float %789, i32 0 + %792 = getelementptr float, ptr addrspace(3) @smem0, i64 %790 + store <1 x float> %791, ptr addrspace(3) %792, align 4 + %793 = extractelement <4 x float> %784, i64 2 + %794 = add i64 %773, %707 + %795 = insertelement <1 x float> poison, float %793, i32 0 + %796 = getelementptr float, ptr addrspace(3) @smem0, i64 %794 + store <1 x float> %795, ptr addrspace(3) %796, align 4 + %797 = extractelement <4 x float> %784, i64 3 + %798 = add i64 %773, %712 + %799 = insertelement <1 x float> poison, float %797, i32 0 + %800 = getelementptr float, ptr addrspace(3) @smem0, i64 %798 + store <1 x float> %799, ptr addrspace(3) %800, align 4 + %801 = mul i64 %516, 256 + %802 = extractelement <4 x float> %658, i64 0 + %803 = extractelement <4 x float> %659, i64 0 + %804 = extractelement <4 x float> %682, i64 0 + %805 = extractelement <4 x float> %683, i64 0 + %806 = insertelement <4 x float> poison, float %802, i64 0 + %807 = insertelement <4 x float> %806, float %803, i64 1 + %808 = insertelement <4 x float> %807, float %804, i64 2 + %809 = insertelement <4 x float> %808, float %805, i64 3 + %810 = insertelement <4 x float> poison, float %520, i32 0 + %811 = shufflevector <4 x float> %810, <4 x float> poison, <4 x i32> zeroinitializer + %812 = fmul <4 x float> %809, %811 + %813 = extractelement <4 x float> %812, i64 0 + %814 = add i64 %801, %685 + %815 = insertelement <1 x float> poison, float %813, i32 0 + %816 = getelementptr float, ptr addrspace(3) @smem0, i64 %814 + store <1 x float> %815, ptr addrspace(3) %816, align 4 + %817 = extractelement <4 x float> %812, i64 1 + %818 = add i64 %801, %702 + %819 = insertelement <1 x float> poison, float %817, i32 0 + %820 = getelementptr float, ptr addrspace(3) @smem0, i64 %818 + store <1 x float> %819, ptr addrspace(3) %820, align 4 + %821 = extractelement <4 x float> %812, i64 2 + %822 = add i64 %801, %707 + %823 = insertelement <1 x float> poison, float %821, i32 0 + %824 = getelementptr float, ptr addrspace(3) @smem0, i64 %822 + store <1 x float> %823, ptr addrspace(3) %824, align 4 + %825 = extractelement <4 x float> %812, i64 3 + %826 = add i64 %801, %712 + %827 = insertelement <1 x float> poison, float %825, i32 0 + %828 = getelementptr float, ptr addrspace(3) @smem0, i64 %826 + store <1 x float> %827, ptr addrspace(3) %828, align 4 + %829 = mul i64 %521, 256 + %830 = extractelement <4 x float> %658, i64 1 + %831 = extractelement <4 x float> %659, i64 1 + %832 = extractelement <4 x float> %682, i64 1 + %833 = extractelement <4 x float> %683, i64 1 + %834 = insertelement <4 x float> poison, float %830, i64 0 + %835 = insertelement <4 x float> %834, float %831, i64 1 + %836 = insertelement <4 x float> %835, float %832, i64 2 + %837 = insertelement <4 x float> %836, float %833, i64 3 + %838 = insertelement <4 x float> poison, float %525, i32 0 + %839 = shufflevector <4 x float> %838, <4 x float> poison, <4 x i32> zeroinitializer + %840 = fmul <4 x float> %837, %839 + %841 = extractelement <4 x float> %840, i64 0 + %842 = add i64 %829, %685 + %843 = insertelement <1 x float> poison, float %841, i32 0 + %844 = getelementptr float, ptr addrspace(3) @smem0, i64 %842 + store <1 x float> %843, ptr addrspace(3) %844, align 4 + %845 = extractelement <4 x float> %840, i64 1 + %846 = add i64 %829, %702 + %847 = insertelement <1 x float> poison, float %845, i32 0 + %848 = getelementptr float, ptr addrspace(3) @smem0, i64 %846 + store <1 x float> %847, ptr addrspace(3) %848, align 4 + %849 = extractelement <4 x float> %840, i64 2 + %850 = add i64 %829, %707 + %851 = insertelement <1 x float> poison, float %849, i32 0 + %852 = getelementptr float, ptr addrspace(3) @smem0, i64 %850 + store <1 x float> %851, ptr addrspace(3) %852, align 4 + %853 = extractelement <4 x float> %840, i64 3 + %854 = add i64 %829, %712 + %855 = insertelement <1 x float> poison, float %853, i32 0 + %856 = getelementptr float, ptr addrspace(3) @smem0, i64 %854 + store <1 x float> %855, ptr addrspace(3) %856, align 4 + %857 = mul i64 %526, 256 + %858 = extractelement <4 x float> %658, i64 2 + %859 = extractelement <4 x float> %659, i64 2 + %860 = extractelement <4 x float> %682, i64 2 + %861 = extractelement <4 x float> %683, i64 2 + %862 = insertelement <4 x float> poison, float %858, i64 0 + %863 = insertelement <4 x float> %862, float %859, i64 1 + %864 = insertelement <4 x float> %863, float %860, i64 2 + %865 = insertelement <4 x float> %864, float %861, i64 3 + %866 = insertelement <4 x float> poison, float %530, i32 0 + %867 = shufflevector <4 x float> %866, <4 x float> poison, <4 x i32> zeroinitializer + %868 = fmul <4 x float> %865, %867 + %869 = extractelement <4 x float> %868, i64 0 + %870 = add i64 %857, %685 + %871 = insertelement <1 x float> poison, float %869, i32 0 + %872 = getelementptr float, ptr addrspace(3) @smem0, i64 %870 + store <1 x float> %871, ptr addrspace(3) %872, align 4 + %873 = extractelement <4 x float> %868, i64 1 + %874 = add i64 %857, %702 + %875 = insertelement <1 x float> poison, float %873, i32 0 + %876 = getelementptr float, ptr addrspace(3) @smem0, i64 %874 + store <1 x float> %875, ptr addrspace(3) %876, align 4 + %877 = extractelement <4 x float> %868, i64 2 + %878 = add i64 %857, %707 + %879 = insertelement <1 x float> poison, float %877, i32 0 + %880 = getelementptr float, ptr addrspace(3) @smem0, i64 %878 + store <1 x float> %879, ptr addrspace(3) %880, align 4 + %881 = extractelement <4 x float> %868, i64 3 + %882 = add i64 %857, %712 + %883 = insertelement <1 x float> poison, float %881, i32 0 + %884 = getelementptr float, ptr addrspace(3) @smem0, i64 %882 + store <1 x float> %883, ptr addrspace(3) %884, align 4 + %885 = mul i64 %531, 256 + %886 = extractelement <4 x float> %658, i64 3 + %887 = extractelement <4 x float> %659, i64 3 + %888 = extractelement <4 x float> %682, i64 3 + %889 = extractelement <4 x float> %683, i64 3 + %890 = insertelement <4 x float> poison, float %886, i64 0 + %891 = insertelement <4 x float> %890, float %887, i64 1 + %892 = insertelement <4 x float> %891, float %888, i64 2 + %893 = insertelement <4 x float> %892, float %889, i64 3 + %894 = insertelement <4 x float> poison, float %535, i32 0 + %895 = shufflevector <4 x float> %894, <4 x float> poison, <4 x i32> zeroinitializer + %896 = fmul <4 x float> %893, %895 + %897 = extractelement <4 x float> %896, i64 0 + %898 = add i64 %885, %685 + %899 = insertelement <1 x float> poison, float %897, i32 0 + %900 = getelementptr float, ptr addrspace(3) @smem0, i64 %898 + store <1 x float> %899, ptr addrspace(3) %900, align 4 + %901 = extractelement <4 x float> %896, i64 1 + %902 = add i64 %885, %702 + %903 = insertelement <1 x float> poison, float %901, i32 0 + %904 = getelementptr float, ptr addrspace(3) @smem0, i64 %902 + store <1 x float> %903, ptr addrspace(3) %904, align 4 + %905 = extractelement <4 x float> %896, i64 2 + %906 = add i64 %885, %707 + %907 = insertelement <1 x float> poison, float %905, i32 0 + %908 = getelementptr float, ptr addrspace(3) @smem0, i64 %906 + store <1 x float> %907, ptr addrspace(3) %908, align 4 + %909 = extractelement <4 x float> %896, i64 3 + %910 = add i64 %885, %712 + %911 = insertelement <1 x float> poison, float %909, i32 0 + %912 = getelementptr float, ptr addrspace(3) @smem0, i64 %910 + store <1 x float> %911, ptr addrspace(3) %912, align 4 + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %913 = udiv i64 %19, 32 + %914 = urem i64 %19, 32 + %915 = getelementptr inbounds nuw i32, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @smem0, i32 32768), i64 %913 + %916 = load i32, ptr addrspace(3) %915, align 4 + %917 = and i32 %916, 16777215 + %918 = icmp ult i32 %917, %10 + %919 = sext i32 %917 to i64 + %920 = mul i64 %919, 14336 + %921 = add i64 %684, %920 + %922 = add i64 %913, 8 + %923 = getelementptr inbounds nuw i32, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @smem0, i32 32768), i64 %922 + %924 = load i32, ptr addrspace(3) %923, align 4 + %925 = and i32 %924, 16777215 + %926 = icmp ult i32 %925, %10 + %927 = sext i32 %925 to i64 + %928 = mul i64 %927, 14336 + %929 = add i64 %684, %928 + %930 = add i64 %913, 16 + %931 = getelementptr inbounds nuw i32, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @smem0, i32 32768), i64 %930 + %932 = load i32, ptr addrspace(3) %931, align 4 + %933 = and i32 %932, 16777215 + %934 = icmp ult i32 %933, %10 + %935 = sext i32 %933 to i64 + %936 = mul i64 %935, 14336 + %937 = add i64 %684, %936 + %938 = add i64 %913, 24 + %939 = getelementptr inbounds nuw i32, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @smem0, i32 32768), i64 %938 + %940 = load i32, ptr addrspace(3) %939, align 4 + %941 = and i32 %940, 16777215 + %942 = icmp ult i32 %941, %10 + %943 = sext i32 %941 to i64 + %944 = mul i64 %943, 14336 + %945 = add i64 %684, %944 + br i1 %918, label %946, label %988 + +946: ; preds = %154 + %947 = mul i64 %913, 256 + %948 = mul i64 %914, 2 + %949 = add i64 %947, %948 + %950 = getelementptr float, ptr addrspace(3) @smem0, i64 %949 + %951 = load <2 x float>, ptr addrspace(3) %950, align 4 + %952 = add i64 %129, %948 + %953 = fptrunc <2 x float> %951 to <2 x bfloat> + %954 = mul i64 %952, 2 + %955 = add i64 %921, %954 + %956 = inttoptr i64 %955 to ptr addrspace(1) + %957 = atomicrmw fadd ptr addrspace(1) %956, <2 x bfloat> %953 syncscope("agent") monotonic, align 4 + %958 = add i64 %948, 64 + %959 = add i64 %947, %958 + %960 = getelementptr float, ptr addrspace(3) @smem0, i64 %959 + %961 = load <2 x float>, ptr addrspace(3) %960, align 4 + %962 = add i64 %129, %958 + %963 = fptrunc <2 x float> %961 to <2 x bfloat> + %964 = mul i64 %962, 2 + %965 = add i64 %921, %964 + %966 = inttoptr i64 %965 to ptr addrspace(1) + %967 = atomicrmw fadd ptr addrspace(1) %966, <2 x bfloat> %963 syncscope("agent") monotonic, align 4 + %968 = add i64 %948, 128 + %969 = add i64 %947, %968 + %970 = getelementptr float, ptr addrspace(3) @smem0, i64 %969 + %971 = load <2 x float>, ptr addrspace(3) %970, align 4 + %972 = add i64 %129, %968 + %973 = fptrunc <2 x float> %971 to <2 x bfloat> + %974 = mul i64 %972, 2 + %975 = add i64 %921, %974 + %976 = inttoptr i64 %975 to ptr addrspace(1) + %977 = atomicrmw fadd ptr addrspace(1) %976, <2 x bfloat> %973 syncscope("agent") monotonic, align 4 + %978 = add i64 %948, 192 + %979 = add i64 %947, %978 + %980 = getelementptr float, ptr addrspace(3) @smem0, i64 %979 + %981 = load <2 x float>, ptr addrspace(3) %980, align 4 + %982 = add i64 %129, %978 + %983 = fptrunc <2 x float> %981 to <2 x bfloat> + %984 = mul i64 %982, 2 + %985 = add i64 %921, %984 + %986 = inttoptr i64 %985 to ptr addrspace(1) + %987 = atomicrmw fadd ptr addrspace(1) %986, <2 x bfloat> %983 syncscope("agent") monotonic, align 4 + br label %988 + +988: ; preds = %946, %154 + br i1 %926, label %989, label %1031 + +989: ; preds = %988 + %990 = mul i64 %922, 256 + %991 = mul i64 %914, 2 + %992 = add i64 %990, %991 + %993 = getelementptr float, ptr addrspace(3) @smem0, i64 %992 + %994 = load <2 x float>, ptr addrspace(3) %993, align 4 + %995 = add i64 %129, %991 + %996 = fptrunc <2 x float> %994 to <2 x bfloat> + %997 = mul i64 %995, 2 + %998 = add i64 %929, %997 + %999 = inttoptr i64 %998 to ptr addrspace(1) + %1000 = atomicrmw fadd ptr addrspace(1) %999, <2 x bfloat> %996 syncscope("agent") monotonic, align 4 + %1001 = add i64 %991, 64 + %1002 = add i64 %990, %1001 + %1003 = getelementptr float, ptr addrspace(3) @smem0, i64 %1002 + %1004 = load <2 x float>, ptr addrspace(3) %1003, align 4 + %1005 = add i64 %129, %1001 + %1006 = fptrunc <2 x float> %1004 to <2 x bfloat> + %1007 = mul i64 %1005, 2 + %1008 = add i64 %929, %1007 + %1009 = inttoptr i64 %1008 to ptr addrspace(1) + %1010 = atomicrmw fadd ptr addrspace(1) %1009, <2 x bfloat> %1006 syncscope("agent") monotonic, align 4 + %1011 = add i64 %991, 128 + %1012 = add i64 %990, %1011 + %1013 = getelementptr float, ptr addrspace(3) @smem0, i64 %1012 + %1014 = load <2 x float>, ptr addrspace(3) %1013, align 4 + %1015 = add i64 %129, %1011 + %1016 = fptrunc <2 x float> %1014 to <2 x bfloat> + %1017 = mul i64 %1015, 2 + %1018 = add i64 %929, %1017 + %1019 = inttoptr i64 %1018 to ptr addrspace(1) + %1020 = atomicrmw fadd ptr addrspace(1) %1019, <2 x bfloat> %1016 syncscope("agent") monotonic, align 4 + %1021 = add i64 %991, 192 + %1022 = add i64 %990, %1021 + %1023 = getelementptr float, ptr addrspace(3) @smem0, i64 %1022 + %1024 = load <2 x float>, ptr addrspace(3) %1023, align 4 + %1025 = add i64 %129, %1021 + %1026 = fptrunc <2 x float> %1024 to <2 x bfloat> + %1027 = mul i64 %1025, 2 + %1028 = add i64 %929, %1027 + %1029 = inttoptr i64 %1028 to ptr addrspace(1) + %1030 = atomicrmw fadd ptr addrspace(1) %1029, <2 x bfloat> %1026 syncscope("agent") monotonic, align 4 + br label %1031 + +1031: ; preds = %989, %988 + br i1 %934, label %1032, label %1074 + +1032: ; preds = %1031 + %1033 = mul i64 %930, 256 + %1034 = mul i64 %914, 2 + %1035 = add i64 %1033, %1034 + %1036 = getelementptr float, ptr addrspace(3) @smem0, i64 %1035 + %1037 = load <2 x float>, ptr addrspace(3) %1036, align 4 + %1038 = add i64 %129, %1034 + %1039 = fptrunc <2 x float> %1037 to <2 x bfloat> + %1040 = mul i64 %1038, 2 + %1041 = add i64 %937, %1040 + %1042 = inttoptr i64 %1041 to ptr addrspace(1) + %1043 = atomicrmw fadd ptr addrspace(1) %1042, <2 x bfloat> %1039 syncscope("agent") monotonic, align 4 + %1044 = add i64 %1034, 64 + %1045 = add i64 %1033, %1044 + %1046 = getelementptr float, ptr addrspace(3) @smem0, i64 %1045 + %1047 = load <2 x float>, ptr addrspace(3) %1046, align 4 + %1048 = add i64 %129, %1044 + %1049 = fptrunc <2 x float> %1047 to <2 x bfloat> + %1050 = mul i64 %1048, 2 + %1051 = add i64 %937, %1050 + %1052 = inttoptr i64 %1051 to ptr addrspace(1) + %1053 = atomicrmw fadd ptr addrspace(1) %1052, <2 x bfloat> %1049 syncscope("agent") monotonic, align 4 + %1054 = add i64 %1034, 128 + %1055 = add i64 %1033, %1054 + %1056 = getelementptr float, ptr addrspace(3) @smem0, i64 %1055 + %1057 = load <2 x float>, ptr addrspace(3) %1056, align 4 + %1058 = add i64 %129, %1054 + %1059 = fptrunc <2 x float> %1057 to <2 x bfloat> + %1060 = mul i64 %1058, 2 + %1061 = add i64 %937, %1060 + %1062 = inttoptr i64 %1061 to ptr addrspace(1) + %1063 = atomicrmw fadd ptr addrspace(1) %1062, <2 x bfloat> %1059 syncscope("agent") monotonic, align 4 + %1064 = add i64 %1034, 192 + %1065 = add i64 %1033, %1064 + %1066 = getelementptr float, ptr addrspace(3) @smem0, i64 %1065 + %1067 = load <2 x float>, ptr addrspace(3) %1066, align 4 + %1068 = add i64 %129, %1064 + %1069 = fptrunc <2 x float> %1067 to <2 x bfloat> + %1070 = mul i64 %1068, 2 + %1071 = add i64 %937, %1070 + %1072 = inttoptr i64 %1071 to ptr addrspace(1) + %1073 = atomicrmw fadd ptr addrspace(1) %1072, <2 x bfloat> %1069 syncscope("agent") monotonic, align 4 + br label %1074 + +1074: ; preds = %1032, %1031 + br i1 %942, label %1075, label %1117 + +1075: ; preds = %1074 + %1076 = mul i64 %938, 256 + %1077 = mul i64 %914, 2 + %1078 = add i64 %1076, %1077 + %1079 = getelementptr float, ptr addrspace(3) @smem0, i64 %1078 + %1080 = load <2 x float>, ptr addrspace(3) %1079, align 4 + %1081 = add i64 %129, %1077 + %1082 = fptrunc <2 x float> %1080 to <2 x bfloat> + %1083 = mul i64 %1081, 2 + %1084 = add i64 %945, %1083 + %1085 = inttoptr i64 %1084 to ptr addrspace(1) + %1086 = atomicrmw fadd ptr addrspace(1) %1085, <2 x bfloat> %1082 syncscope("agent") monotonic, align 4 + %1087 = add i64 %1077, 64 + %1088 = add i64 %1076, %1087 + %1089 = getelementptr float, ptr addrspace(3) @smem0, i64 %1088 + %1090 = load <2 x float>, ptr addrspace(3) %1089, align 4 + %1091 = add i64 %129, %1087 + %1092 = fptrunc <2 x float> %1090 to <2 x bfloat> + %1093 = mul i64 %1091, 2 + %1094 = add i64 %945, %1093 + %1095 = inttoptr i64 %1094 to ptr addrspace(1) + %1096 = atomicrmw fadd ptr addrspace(1) %1095, <2 x bfloat> %1092 syncscope("agent") monotonic, align 4 + %1097 = add i64 %1077, 128 + %1098 = add i64 %1076, %1097 + %1099 = getelementptr float, ptr addrspace(3) @smem0, i64 %1098 + %1100 = load <2 x float>, ptr addrspace(3) %1099, align 4 + %1101 = add i64 %129, %1097 + %1102 = fptrunc <2 x float> %1100 to <2 x bfloat> + %1103 = mul i64 %1101, 2 + %1104 = add i64 %945, %1103 + %1105 = inttoptr i64 %1104 to ptr addrspace(1) + %1106 = atomicrmw fadd ptr addrspace(1) %1105, <2 x bfloat> %1102 syncscope("agent") monotonic, align 4 + %1107 = add i64 %1077, 192 + %1108 = add i64 %1076, %1107 + %1109 = getelementptr float, ptr addrspace(3) @smem0, i64 %1108 + %1110 = load <2 x float>, ptr addrspace(3) %1109, align 4 + %1111 = add i64 %129, %1107 + %1112 = fptrunc <2 x float> %1110 to <2 x bfloat> + %1113 = mul i64 %1111, 2 + %1114 = add i64 %945, %1113 + %1115 = inttoptr i64 %1114 to ptr addrspace(1) + %1116 = atomicrmw fadd ptr addrspace(1) %1115, <2 x bfloat> %1112 syncscope("agent") monotonic, align 4 + br label %1117 + +1117: ; preds = %1075, %1074 + br label %1118 + +1118: ; preds = %1117, %80 + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %1119 = add i64 %77, 1 + br label %76 + +1120: ; preds = %76 + ret void +} + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef i32 @llvm.amdgcn.workgroup.id.y() #1 + +; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) +declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #2 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #3 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) +declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #4 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.sched.barrier(i32 immarg) #5 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #3 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) +declare i64 @llvm.amdgcn.readfirstlane.i64(i64) #4 + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #6 + +; Function Attrs: nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.s.waitcnt(i32 immarg) #7 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.s.barrier() #5 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) +declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32>, <8 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #8 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #3 + +attributes #0 = { "amdgpu-flat-work-group-size"="1,256" "amdgpu-waves-per-eu"="4" "uniform-work-group-size" } +attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } +attributes #2 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } +attributes #3 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } +attributes #4 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } +attributes #5 = { convergent nocallback nofree nounwind willreturn } +attributes #6 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } +attributes #7 = { nocallback nofree nounwind willreturn } +attributes #8 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/kernels/gemm2_port_ref/flydsl_port_v1.ll b/kernels/gemm2_port_ref/flydsl_port_v1.ll new file mode 100644 index 000000000..a13551384 --- /dev/null +++ b/kernels/gemm2_port_ref/flydsl_port_v1.ll @@ -0,0 +1,892 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" +target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" + +@gemm2port_smem = external addrspace(3) global [32768 x i8], align 1024 + +define amdgpu_kernel void @gemm2_a4w4_port_bm32_atomic(ptr addrspace(1) %0, <{ <{ i32, i32 }>, <{ i64 }> }> %1, ptr addrspace(1) %2, <{ <{ i32, i32 }>, <{ i64 }> }> %3, ptr addrspace(1) %4, <{ <{ i32, i32, i32 }>, <{ i64, i64 }> }> %5, ptr addrspace(1) %6, <{ <{ i32, i32 }>, <{ i64 }> }> %7, ptr addrspace(1) %8, <{ <{ i32 }> }> %9, ptr addrspace(1) %10, <{ <{ i32 }> }> %11, ptr addrspace(1) %12, <{ <{ i32 }> }> %13, ptr addrspace(1) %14, <{ <{ i32 }> }> %15, i32 %16, ptr addrspace(1) %17, <{ <{ i32, i32 }>, <{ i64 }> }> %18) #0 !reqd_work_group_size !1 { + %20 = call range(i32 0, 256) i32 @llvm.amdgcn.workitem.id.x() + %21 = sext i32 %20 to i64 + %22 = call i32 @llvm.amdgcn.workgroup.id.x() + %23 = sext i32 %22 to i64 + %24 = trunc i64 %21 to i32 + %25 = trunc i64 %23 to i32 + %26 = srem i32 %24, 64 + %27 = sdiv i32 %24, 64 + %28 = mul i32 %27, 64 + %29 = icmp ne i32 %24, %28 + %30 = icmp slt i32 %24, 0 + %31 = icmp ne i1 %30, false + %32 = and i1 %29, %31 + %33 = add i32 %27, -1 + %34 = select i1 %32, i32 %33, i32 %27 + %35 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %34) + %36 = addrspacecast ptr addrspace(1) %10 to ptr + %37 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %36, i16 0, i64 4294967295, i32 159744) + %38 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %37, i32 0, i32 0, i32 0) + %39 = sdiv i32 %38, 32 + %40 = mul i32 %39, 32 + %41 = icmp ne i32 %38, %40 + %42 = icmp slt i32 %38, 0 + %43 = icmp ne i1 %42, false + %44 = and i1 %41, %43 + %45 = add i32 %39, -1 + %46 = select i1 %44, i32 %45, i32 %39 + %47 = mul i32 %46, 28 + %48 = icmp slt i32 %25, %47 + br i1 %48, label %49, label %786 + +49: ; preds = %19 + %50 = srem i32 %25, 28 + %51 = sdiv i32 %25, 28 + %52 = mul i32 %51, 28 + %53 = icmp ne i32 %25, %52 + %54 = icmp slt i32 %25, 0 + %55 = icmp ne i1 %54, false + %56 = and i1 %53, %55 + %57 = add i32 %51, -1 + %58 = select i1 %56, i32 %57, i32 %51 + %59 = addrspacecast ptr addrspace(1) %8 to ptr + %60 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %59, i16 0, i64 4294967295, i32 159744) + %61 = mul i32 %58, 4 + %62 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %60, i32 %61, i32 0, i32 0) + %63 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %62) + %64 = mul i32 %58, 32 + %65 = addrspacecast ptr addrspace(1) %0 to ptr + %66 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %65, i16 0, i64 167772160, i32 159744) + %67 = addrspacecast ptr addrspace(1) %2 to ptr + %68 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %67, i16 0, i64 10485760, i32 159744) + %69 = addrspacecast ptr addrspace(1) %4 to ptr + %70 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %69, i16 0, i64 706478080, i32 159744) + %71 = addrspacecast ptr addrspace(1) %6 to ptr + %72 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %71, i16 0, i64 44154880, i32 159744) + %73 = sdiv i32 %26, 8 + %74 = mul i32 %73, 8 + %75 = icmp ne i32 %26, %74 + %76 = icmp slt i32 %26, 0 + %77 = icmp ne i1 %76, false + %78 = and i1 %75, %77 + %79 = add i32 %73, -1 + %80 = select i1 %78, i32 %79, i32 %73 + %81 = srem i32 %26, 8 + %82 = sdiv i32 %26, 16 + %83 = mul i32 %82, 16 + %84 = icmp ne i32 %26, %83 + %85 = icmp slt i32 %26, 0 + %86 = icmp ne i1 %85, false + %87 = and i1 %84, %86 + %88 = add i32 %82, -1 + %89 = select i1 %87, i32 %88, i32 %82 + %90 = srem i32 %26, 16 + %91 = mul i32 %63, 7168 + %92 = mul i32 %50, 256 + %93 = add i32 %91, %92 + %94 = mul i32 %35, 64 + %95 = add i32 %93, %94 + %96 = mul i32 %95, 256 + %97 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %96) + %98 = add i32 %95, 16 + %99 = mul i32 %98, 256 + %100 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %99) + %101 = add i32 %95, 32 + %102 = mul i32 %101, 256 + %103 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %102) + %104 = add i32 %95, 48 + %105 = mul i32 %104, 256 + %106 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %105) + %107 = mul i32 %50, 8 + %108 = mul i32 %35, 2 + %109 = add i32 %107, %108 + %110 = mul i32 %63, 28672 + %111 = mul i32 %109, 128 + %112 = add i32 %110, %111 + %113 = mul i32 %112, 4 + %114 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %113) + %115 = add i32 %109, 1 + %116 = mul i32 %115, 128 + %117 = add i32 %110, %116 + %118 = mul i32 %117, 4 + %119 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %118) + %120 = sdiv i32 %64, 32 + %121 = mul i32 %120, 32 + %122 = icmp ne i32 %64, %121 + %123 = icmp slt i32 %64, 0 + %124 = icmp ne i1 %123, false + %125 = and i1 %122, %124 + %126 = add i32 %120, -1 + %127 = select i1 %125, i32 %126, i32 %120 + %128 = mul i32 %127, 512 + %129 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %128) + %130 = mul i32 %35, 8 + %131 = add i32 %64, %130 + %132 = add i32 %131, %80 + %133 = add i32 %130, %80 + %134 = and i32 %133, 14 + %135 = shl i32 %134, 3 + %136 = mul i32 %81, 16 + %137 = xor i32 %136, %135 + %138 = mul i32 %132, 256 + %139 = add i32 %137, %138 + %140 = mul i32 %35, 1024 + %141 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %140 + %142 = sext i32 %141 to i64 + %143 = inttoptr i64 %142 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %66, ptr addrspace(3) %143, i32 16, i32 %139, i32 0, i32 0, i32 0) + %144 = add i32 %140, 4096 + %145 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %144 + %146 = sext i32 %145 to i64 + %147 = inttoptr i64 %146 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %66, ptr addrspace(3) %147, i32 16, i32 %139, i32 128, i32 0, i32 0) + call void @llvm.amdgcn.sched.barrier(i32 0) + %148 = mul i32 %89, 16 + %149 = add i32 %148, %90 + %150 = mul i32 %149, 4 + %151 = sdiv i32 %150, 4 + %152 = mul i32 %151, 4 + %153 = icmp ne i32 %150, %152 + %154 = icmp slt i32 %150, 0 + %155 = icmp ne i1 %154, false + %156 = and i1 %153, %155 + %157 = add i32 %151, -1 + %158 = select i1 %156, i32 %157, i32 %151 + %159 = mul i32 %158, 4 + %160 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %68, i32 %159, i32 %129, i32 0) + %161 = add i32 %150, 256 + %162 = sdiv i32 %161, 4 + %163 = mul i32 %162, 4 + %164 = icmp ne i32 %161, %163 + %165 = icmp slt i32 %161, 0 + %166 = icmp ne i1 %165, false + %167 = and i1 %164, %166 + %168 = add i32 %162, -1 + %169 = select i1 %167, i32 %168, i32 %162 + %170 = mul i32 %169, 4 + %171 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %68, i32 %170, i32 %129, i32 0) + %172 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %72, i32 %159, i32 %114, i32 0) + %173 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %72, i32 %159, i32 %119, i32 0) + %174 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %72, i32 %170, i32 %114, i32 0) + %175 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %72, i32 %170, i32 %119, i32 0) + %176 = mul i32 %89, 256 + %177 = mul i32 %90, 16 + %178 = add i32 %176, %177 + %179 = sdiv i32 %178, 4 + %180 = mul i32 %179, 4 + %181 = icmp ne i32 %178, %180 + %182 = icmp slt i32 %178, 0 + %183 = icmp ne i1 %182, false + %184 = and i1 %181, %183 + %185 = add i32 %179, -1 + %186 = select i1 %184, i32 %185, i32 %179 + %187 = mul i32 %186, 4 + %188 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %187, i32 %97, i32 0) + %189 = add i32 %178, 1024 + %190 = sdiv i32 %189, 4 + %191 = mul i32 %190, 4 + %192 = icmp ne i32 %189, %191 + %193 = icmp slt i32 %189, 0 + %194 = icmp ne i1 %193, false + %195 = and i1 %192, %194 + %196 = add i32 %190, -1 + %197 = select i1 %195, i32 %196, i32 %190 + %198 = mul i32 %197, 4 + %199 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %198, i32 %97, i32 0) + %200 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %187, i32 %100, i32 0) + %201 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %198, i32 %100, i32 0) + %202 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %187, i32 %103, i32 0) + %203 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %198, i32 %103, i32 0) + %204 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %187, i32 %106, i32 0) + %205 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %198, i32 %106, i32 0) + %206 = add i32 %178, 2048 + %207 = sdiv i32 %206, 4 + %208 = mul i32 %207, 4 + %209 = icmp ne i32 %206, %208 + %210 = icmp slt i32 %206, 0 + %211 = icmp ne i1 %210, false + %212 = and i1 %209, %211 + %213 = add i32 %207, -1 + %214 = select i1 %212, i32 %213, i32 %207 + %215 = mul i32 %214, 4 + %216 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %215, i32 %97, i32 0) + %217 = add i32 %178, 3072 + %218 = sdiv i32 %217, 4 + %219 = mul i32 %218, 4 + %220 = icmp ne i32 %217, %219 + %221 = icmp slt i32 %217, 0 + %222 = icmp ne i1 %221, false + %223 = and i1 %220, %222 + %224 = add i32 %218, -1 + %225 = select i1 %223, i32 %224, i32 %218 + %226 = mul i32 %225, 4 + %227 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %226, i32 %97, i32 0) + %228 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %215, i32 %100, i32 0) + %229 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %226, i32 %100, i32 0) + %230 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %215, i32 %103, i32 0) + %231 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %226, i32 %103, i32 0) + %232 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %215, i32 %106, i32 0) + %233 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %226, i32 %106, i32 0) + call void asm sideeffect "s_waitcnt vmcnt(23)", ""() + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %234 = and i32 %90, 14 + %235 = shl i32 %234, 3 + %236 = xor i32 %148, %235 + %237 = mul i32 %90, 128 + %238 = add i32 %237, %236 + %239 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %238 + %240 = sext i32 %239 to i64 + %241 = inttoptr i64 %240 to ptr addrspace(3) + %242 = load <4 x i32>, ptr addrspace(3) %241, align 16 + %243 = add i32 %90, 16 + %244 = mul i32 %243, 128 + %245 = add i32 %244, %236 + %246 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %245 + %247 = sext i32 %246 to i64 + %248 = inttoptr i64 %247 to ptr addrspace(3) + %249 = load <4 x i32>, ptr addrspace(3) %248, align 16 + %250 = add i32 %148, 64 + %251 = xor i32 %250, %235 + %252 = add i32 %237, %251 + %253 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %252 + %254 = sext i32 %253 to i64 + %255 = inttoptr i64 %254 to ptr addrspace(3) + %256 = load <4 x i32>, ptr addrspace(3) %255, align 16 + %257 = add i32 %244, %251 + %258 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %257 + %259 = sext i32 %258 to i64 + %260 = inttoptr i64 %259 to ptr addrspace(3) + %261 = load <4 x i32>, ptr addrspace(3) %260, align 16 + %262 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %242, <4 x i32> %188, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %160, i32 0, i32 %172) + %263 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %188, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %160, i32 0, i32 %172) + %264 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %199, <4 x float> %262, i32 4, i32 4, i32 2, i32 %160, i32 2, i32 %172) + %265 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %261, <4 x i32> %199, <4 x float> %263, i32 4, i32 4, i32 3, i32 %160, i32 2, i32 %172) + %266 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %242, <4 x i32> %200, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %160, i32 1, i32 %172) + %267 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %200, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %160, i32 1, i32 %172) + %268 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %201, <4 x float> %266, i32 4, i32 4, i32 2, i32 %160, i32 3, i32 %172) + %269 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %261, <4 x i32> %201, <4 x float> %267, i32 4, i32 4, i32 3, i32 %160, i32 3, i32 %172) + %270 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %242, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %160, i32 0, i32 %173) + %271 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %160, i32 0, i32 %173) + %272 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %203, <4 x float> %270, i32 4, i32 4, i32 2, i32 %160, i32 2, i32 %173) + %273 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %261, <4 x i32> %203, <4 x float> %271, i32 4, i32 4, i32 3, i32 %160, i32 2, i32 %173) + %274 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %242, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %160, i32 1, i32 %173) + %275 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %160, i32 1, i32 %173) + %276 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %205, <4 x float> %274, i32 4, i32 4, i32 2, i32 %160, i32 3, i32 %173) + %277 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %261, <4 x i32> %205, <4 x float> %275, i32 4, i32 4, i32 3, i32 %160, i32 3, i32 %173) + call void asm sideeffect "s_waitcnt vmcnt(22)", ""() + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %278 = add i32 %237, 4096 + %279 = add i32 %278, %236 + %280 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %279 + %281 = sext i32 %280 to i64 + %282 = inttoptr i64 %281 to ptr addrspace(3) + %283 = load <4 x i32>, ptr addrspace(3) %282, align 16 + %284 = add i32 %244, 4096 + %285 = add i32 %284, %236 + %286 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %285 + %287 = sext i32 %286 to i64 + %288 = inttoptr i64 %287 to ptr addrspace(3) + %289 = load <4 x i32>, ptr addrspace(3) %288, align 16 + %290 = add i32 %278, %251 + %291 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %290 + %292 = sext i32 %291 to i64 + %293 = inttoptr i64 %292 to ptr addrspace(3) + %294 = load <4 x i32>, ptr addrspace(3) %293, align 16 + %295 = add i32 %284, %251 + %296 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %295 + %297 = sext i32 %296 to i64 + %298 = inttoptr i64 %297 to ptr addrspace(3) + %299 = load <4 x i32>, ptr addrspace(3) %298, align 16 + %300 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %216, <4 x float> %264, i32 4, i32 4, i32 0, i32 %171, i32 0, i32 %174) + %301 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %289, <4 x i32> %216, <4 x float> %265, i32 4, i32 4, i32 1, i32 %171, i32 0, i32 %174) + %302 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %294, <4 x i32> %227, <4 x float> %300, i32 4, i32 4, i32 2, i32 %171, i32 2, i32 %174) + %303 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %299, <4 x i32> %227, <4 x float> %301, i32 4, i32 4, i32 3, i32 %171, i32 2, i32 %174) + %304 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %228, <4 x float> %268, i32 4, i32 4, i32 0, i32 %171, i32 1, i32 %174) + %305 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %289, <4 x i32> %228, <4 x float> %269, i32 4, i32 4, i32 1, i32 %171, i32 1, i32 %174) + %306 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %294, <4 x i32> %229, <4 x float> %304, i32 4, i32 4, i32 2, i32 %171, i32 3, i32 %174) + %307 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %299, <4 x i32> %229, <4 x float> %305, i32 4, i32 4, i32 3, i32 %171, i32 3, i32 %174) + %308 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %230, <4 x float> %272, i32 4, i32 4, i32 0, i32 %171, i32 0, i32 %175) + %309 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %289, <4 x i32> %230, <4 x float> %273, i32 4, i32 4, i32 1, i32 %171, i32 0, i32 %175) + %310 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %294, <4 x i32> %231, <4 x float> %308, i32 4, i32 4, i32 2, i32 %171, i32 2, i32 %175) + %311 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %299, <4 x i32> %231, <4 x float> %309, i32 4, i32 4, i32 3, i32 %171, i32 2, i32 %175) + %312 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %232, <4 x float> %276, i32 4, i32 4, i32 0, i32 %171, i32 1, i32 %175) + %313 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %289, <4 x i32> %232, <4 x float> %277, i32 4, i32 4, i32 1, i32 %171, i32 1, i32 %175) + %314 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %294, <4 x i32> %233, <4 x float> %312, i32 4, i32 4, i32 2, i32 %171, i32 3, i32 %175) + %315 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %299, <4 x i32> %233, <4 x float> %313, i32 4, i32 4, i32 3, i32 %171, i32 3, i32 %175) + %316 = mul i32 %89, 4 + %317 = add i32 %94, %90 + %318 = mul i32 %89, 1024 + %319 = add i32 %318, %317 + %320 = extractelement <4 x float> %302, i64 0 + %321 = sext i32 %319 to i64 + %322 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %321 + store float %320, ptr addrspace(3) %322, align 4 + %323 = add i32 %316, 1 + %324 = mul i32 %323, 256 + %325 = add i32 %324, %317 + %326 = extractelement <4 x float> %302, i64 1 + %327 = sext i32 %325 to i64 + %328 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %327 + store float %326, ptr addrspace(3) %328, align 4 + %329 = add i32 %316, 2 + %330 = mul i32 %329, 256 + %331 = add i32 %330, %317 + %332 = extractelement <4 x float> %302, i64 2 + %333 = sext i32 %331 to i64 + %334 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %333 + store float %332, ptr addrspace(3) %334, align 4 + %335 = add i32 %316, 3 + %336 = mul i32 %335, 256 + %337 = add i32 %336, %317 + %338 = extractelement <4 x float> %302, i64 3 + %339 = sext i32 %337 to i64 + %340 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %339 + store float %338, ptr addrspace(3) %340, align 4 + %341 = add i32 %94, 16 + %342 = add i32 %341, %90 + %343 = add i32 %318, %342 + %344 = extractelement <4 x float> %306, i64 0 + %345 = sext i32 %343 to i64 + %346 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %345 + store float %344, ptr addrspace(3) %346, align 4 + %347 = add i32 %324, %342 + %348 = extractelement <4 x float> %306, i64 1 + %349 = sext i32 %347 to i64 + %350 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %349 + store float %348, ptr addrspace(3) %350, align 4 + %351 = add i32 %330, %342 + %352 = extractelement <4 x float> %306, i64 2 + %353 = sext i32 %351 to i64 + %354 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %353 + store float %352, ptr addrspace(3) %354, align 4 + %355 = add i32 %336, %342 + %356 = extractelement <4 x float> %306, i64 3 + %357 = sext i32 %355 to i64 + %358 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %357 + store float %356, ptr addrspace(3) %358, align 4 + %359 = add i32 %94, 32 + %360 = add i32 %359, %90 + %361 = add i32 %318, %360 + %362 = extractelement <4 x float> %310, i64 0 + %363 = sext i32 %361 to i64 + %364 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %363 + store float %362, ptr addrspace(3) %364, align 4 + %365 = add i32 %324, %360 + %366 = extractelement <4 x float> %310, i64 1 + %367 = sext i32 %365 to i64 + %368 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %367 + store float %366, ptr addrspace(3) %368, align 4 + %369 = add i32 %330, %360 + %370 = extractelement <4 x float> %310, i64 2 + %371 = sext i32 %369 to i64 + %372 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %371 + store float %370, ptr addrspace(3) %372, align 4 + %373 = add i32 %336, %360 + %374 = extractelement <4 x float> %310, i64 3 + %375 = sext i32 %373 to i64 + %376 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %375 + store float %374, ptr addrspace(3) %376, align 4 + %377 = add i32 %94, 48 + %378 = add i32 %377, %90 + %379 = add i32 %318, %378 + %380 = extractelement <4 x float> %314, i64 0 + %381 = sext i32 %379 to i64 + %382 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %381 + store float %380, ptr addrspace(3) %382, align 4 + %383 = add i32 %324, %378 + %384 = extractelement <4 x float> %314, i64 1 + %385 = sext i32 %383 to i64 + %386 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %385 + store float %384, ptr addrspace(3) %386, align 4 + %387 = add i32 %330, %378 + %388 = extractelement <4 x float> %314, i64 2 + %389 = sext i32 %387 to i64 + %390 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %389 + store float %388, ptr addrspace(3) %390, align 4 + %391 = add i32 %336, %378 + %392 = extractelement <4 x float> %314, i64 3 + %393 = sext i32 %391 to i64 + %394 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %393 + store float %392, ptr addrspace(3) %394, align 4 + %395 = add i32 %316, 16 + %396 = mul i32 %395, 256 + %397 = add i32 %396, %317 + %398 = extractelement <4 x float> %303, i64 0 + %399 = sext i32 %397 to i64 + %400 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %399 + store float %398, ptr addrspace(3) %400, align 4 + %401 = add i32 %316, 17 + %402 = mul i32 %401, 256 + %403 = add i32 %402, %317 + %404 = extractelement <4 x float> %303, i64 1 + %405 = sext i32 %403 to i64 + %406 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %405 + store float %404, ptr addrspace(3) %406, align 4 + %407 = add i32 %316, 18 + %408 = mul i32 %407, 256 + %409 = add i32 %408, %317 + %410 = extractelement <4 x float> %303, i64 2 + %411 = sext i32 %409 to i64 + %412 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %411 + store float %410, ptr addrspace(3) %412, align 4 + %413 = add i32 %316, 19 + %414 = mul i32 %413, 256 + %415 = add i32 %414, %317 + %416 = extractelement <4 x float> %303, i64 3 + %417 = sext i32 %415 to i64 + %418 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %417 + store float %416, ptr addrspace(3) %418, align 4 + %419 = add i32 %396, %342 + %420 = extractelement <4 x float> %307, i64 0 + %421 = sext i32 %419 to i64 + %422 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %421 + store float %420, ptr addrspace(3) %422, align 4 + %423 = add i32 %402, %342 + %424 = extractelement <4 x float> %307, i64 1 + %425 = sext i32 %423 to i64 + %426 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %425 + store float %424, ptr addrspace(3) %426, align 4 + %427 = add i32 %408, %342 + %428 = extractelement <4 x float> %307, i64 2 + %429 = sext i32 %427 to i64 + %430 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %429 + store float %428, ptr addrspace(3) %430, align 4 + %431 = add i32 %414, %342 + %432 = extractelement <4 x float> %307, i64 3 + %433 = sext i32 %431 to i64 + %434 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %433 + store float %432, ptr addrspace(3) %434, align 4 + %435 = add i32 %396, %360 + %436 = extractelement <4 x float> %311, i64 0 + %437 = sext i32 %435 to i64 + %438 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %437 + store float %436, ptr addrspace(3) %438, align 4 + %439 = add i32 %402, %360 + %440 = extractelement <4 x float> %311, i64 1 + %441 = sext i32 %439 to i64 + %442 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %441 + store float %440, ptr addrspace(3) %442, align 4 + %443 = add i32 %408, %360 + %444 = extractelement <4 x float> %311, i64 2 + %445 = sext i32 %443 to i64 + %446 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %445 + store float %444, ptr addrspace(3) %446, align 4 + %447 = add i32 %414, %360 + %448 = extractelement <4 x float> %311, i64 3 + %449 = sext i32 %447 to i64 + %450 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %449 + store float %448, ptr addrspace(3) %450, align 4 + %451 = add i32 %396, %378 + %452 = extractelement <4 x float> %315, i64 0 + %453 = sext i32 %451 to i64 + %454 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %453 + store float %452, ptr addrspace(3) %454, align 4 + %455 = add i32 %402, %378 + %456 = extractelement <4 x float> %315, i64 1 + %457 = sext i32 %455 to i64 + %458 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %457 + store float %456, ptr addrspace(3) %458, align 4 + %459 = add i32 %408, %378 + %460 = extractelement <4 x float> %315, i64 2 + %461 = sext i32 %459 to i64 + %462 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %461 + store float %460, ptr addrspace(3) %462, align 4 + %463 = add i32 %414, %378 + %464 = extractelement <4 x float> %315, i64 3 + %465 = sext i32 %463 to i64 + %466 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %465 + store float %464, ptr addrspace(3) %466, align 4 + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %467 = sdiv i32 %24, 32 + %468 = mul i32 %467, 32 + %469 = icmp ne i32 %24, %468 + %470 = icmp slt i32 %24, 0 + %471 = icmp ne i1 %470, false + %472 = and i1 %469, %471 + %473 = add i32 %467, -1 + %474 = select i1 %472, i32 %473, i32 %467 + %475 = srem i32 %24, 32 + %476 = mul i32 %475, 2 + %477 = addrspacecast ptr addrspace(1) %12 to ptr + %478 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %477, i16 0, i64 4294967295, i32 159744) + %479 = addrspacecast ptr addrspace(1) %14 to ptr + %480 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %479, i16 0, i64 4294967295, i32 159744) + %481 = addrspacecast ptr addrspace(1) %17 to ptr + %482 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %481, i16 0, i64 4294967295, i32 159744) + %483 = add i32 %64, %474 + %484 = mul i32 %483, 4 + %485 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %478, i32 %484, i32 0, i32 0) + %486 = and i32 %485, 16777215 + %487 = icmp slt i32 %486, %16 + %488 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %480, i32 %484, i32 0, i32 0) + br i1 %487, label %489, label %557 + +489: ; preds = %49 + %490 = mul i32 %486, 7168 + %491 = add i32 %490, %92 + %492 = add i32 %491, %476 + %493 = mul i32 %474, 256 + %494 = add i32 %493, %476 + %495 = sext i32 %494 to i64 + %496 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %495 + %497 = load float, ptr addrspace(3) %496, align 4 + %498 = fmul float %497, %488 + %499 = add i32 %494, 1 + %500 = sext i32 %499 to i64 + %501 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %500 + %502 = load float, ptr addrspace(3) %501, align 4 + %503 = fmul float %502, %488 + %504 = insertelement <2 x float> poison, float %498, i64 0 + %505 = insertelement <2 x float> %504, float %503, i64 1 + %506 = fptrunc <2 x float> %505 to <2 x bfloat> + %507 = mul i32 %492, 2 + %508 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %506, ptr addrspace(8) %482, i32 %507, i32 0, i32 0) + %509 = add i32 %494, 64 + %510 = sext i32 %509 to i64 + %511 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %510 + %512 = load float, ptr addrspace(3) %511, align 4 + %513 = fmul float %512, %488 + %514 = add i32 %494, 65 + %515 = sext i32 %514 to i64 + %516 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %515 + %517 = load float, ptr addrspace(3) %516, align 4 + %518 = fmul float %517, %488 + %519 = insertelement <2 x float> poison, float %513, i64 0 + %520 = insertelement <2 x float> %519, float %518, i64 1 + %521 = fptrunc <2 x float> %520 to <2 x bfloat> + %522 = add i32 %492, 64 + %523 = mul i32 %522, 2 + %524 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %521, ptr addrspace(8) %482, i32 %523, i32 0, i32 0) + %525 = add i32 %494, 128 + %526 = sext i32 %525 to i64 + %527 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %526 + %528 = load float, ptr addrspace(3) %527, align 4 + %529 = fmul float %528, %488 + %530 = add i32 %494, 129 + %531 = sext i32 %530 to i64 + %532 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %531 + %533 = load float, ptr addrspace(3) %532, align 4 + %534 = fmul float %533, %488 + %535 = insertelement <2 x float> poison, float %529, i64 0 + %536 = insertelement <2 x float> %535, float %534, i64 1 + %537 = fptrunc <2 x float> %536 to <2 x bfloat> + %538 = add i32 %492, 128 + %539 = mul i32 %538, 2 + %540 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %537, ptr addrspace(8) %482, i32 %539, i32 0, i32 0) + %541 = add i32 %494, 192 + %542 = sext i32 %541 to i64 + %543 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %542 + %544 = load float, ptr addrspace(3) %543, align 4 + %545 = fmul float %544, %488 + %546 = add i32 %494, 193 + %547 = sext i32 %546 to i64 + %548 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %547 + %549 = load float, ptr addrspace(3) %548, align 4 + %550 = fmul float %549, %488 + %551 = insertelement <2 x float> poison, float %545, i64 0 + %552 = insertelement <2 x float> %551, float %550, i64 1 + %553 = fptrunc <2 x float> %552 to <2 x bfloat> + %554 = add i32 %492, 192 + %555 = mul i32 %554, 2 + %556 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %553, ptr addrspace(8) %482, i32 %555, i32 0, i32 0) + br label %557 + +557: ; preds = %489, %49 + %558 = add i32 %474, 8 + %559 = add i32 %64, %558 + %560 = mul i32 %559, 4 + %561 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %478, i32 %560, i32 0, i32 0) + %562 = and i32 %561, 16777215 + %563 = icmp slt i32 %562, %16 + %564 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %480, i32 %560, i32 0, i32 0) + br i1 %563, label %565, label %633 + +565: ; preds = %557 + %566 = mul i32 %562, 7168 + %567 = add i32 %566, %92 + %568 = add i32 %567, %476 + %569 = mul i32 %558, 256 + %570 = add i32 %569, %476 + %571 = sext i32 %570 to i64 + %572 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %571 + %573 = load float, ptr addrspace(3) %572, align 4 + %574 = fmul float %573, %564 + %575 = add i32 %570, 1 + %576 = sext i32 %575 to i64 + %577 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %576 + %578 = load float, ptr addrspace(3) %577, align 4 + %579 = fmul float %578, %564 + %580 = insertelement <2 x float> poison, float %574, i64 0 + %581 = insertelement <2 x float> %580, float %579, i64 1 + %582 = fptrunc <2 x float> %581 to <2 x bfloat> + %583 = mul i32 %568, 2 + %584 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %582, ptr addrspace(8) %482, i32 %583, i32 0, i32 0) + %585 = add i32 %570, 64 + %586 = sext i32 %585 to i64 + %587 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %586 + %588 = load float, ptr addrspace(3) %587, align 4 + %589 = fmul float %588, %564 + %590 = add i32 %570, 65 + %591 = sext i32 %590 to i64 + %592 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %591 + %593 = load float, ptr addrspace(3) %592, align 4 + %594 = fmul float %593, %564 + %595 = insertelement <2 x float> poison, float %589, i64 0 + %596 = insertelement <2 x float> %595, float %594, i64 1 + %597 = fptrunc <2 x float> %596 to <2 x bfloat> + %598 = add i32 %568, 64 + %599 = mul i32 %598, 2 + %600 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %597, ptr addrspace(8) %482, i32 %599, i32 0, i32 0) + %601 = add i32 %570, 128 + %602 = sext i32 %601 to i64 + %603 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %602 + %604 = load float, ptr addrspace(3) %603, align 4 + %605 = fmul float %604, %564 + %606 = add i32 %570, 129 + %607 = sext i32 %606 to i64 + %608 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %607 + %609 = load float, ptr addrspace(3) %608, align 4 + %610 = fmul float %609, %564 + %611 = insertelement <2 x float> poison, float %605, i64 0 + %612 = insertelement <2 x float> %611, float %610, i64 1 + %613 = fptrunc <2 x float> %612 to <2 x bfloat> + %614 = add i32 %568, 128 + %615 = mul i32 %614, 2 + %616 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %613, ptr addrspace(8) %482, i32 %615, i32 0, i32 0) + %617 = add i32 %570, 192 + %618 = sext i32 %617 to i64 + %619 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %618 + %620 = load float, ptr addrspace(3) %619, align 4 + %621 = fmul float %620, %564 + %622 = add i32 %570, 193 + %623 = sext i32 %622 to i64 + %624 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %623 + %625 = load float, ptr addrspace(3) %624, align 4 + %626 = fmul float %625, %564 + %627 = insertelement <2 x float> poison, float %621, i64 0 + %628 = insertelement <2 x float> %627, float %626, i64 1 + %629 = fptrunc <2 x float> %628 to <2 x bfloat> + %630 = add i32 %568, 192 + %631 = mul i32 %630, 2 + %632 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %629, ptr addrspace(8) %482, i32 %631, i32 0, i32 0) + br label %633 + +633: ; preds = %565, %557 + %634 = add i32 %474, 16 + %635 = add i32 %64, %634 + %636 = mul i32 %635, 4 + %637 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %478, i32 %636, i32 0, i32 0) + %638 = and i32 %637, 16777215 + %639 = icmp slt i32 %638, %16 + %640 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %480, i32 %636, i32 0, i32 0) + br i1 %639, label %641, label %709 + +641: ; preds = %633 + %642 = mul i32 %638, 7168 + %643 = add i32 %642, %92 + %644 = add i32 %643, %476 + %645 = mul i32 %634, 256 + %646 = add i32 %645, %476 + %647 = sext i32 %646 to i64 + %648 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %647 + %649 = load float, ptr addrspace(3) %648, align 4 + %650 = fmul float %649, %640 + %651 = add i32 %646, 1 + %652 = sext i32 %651 to i64 + %653 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %652 + %654 = load float, ptr addrspace(3) %653, align 4 + %655 = fmul float %654, %640 + %656 = insertelement <2 x float> poison, float %650, i64 0 + %657 = insertelement <2 x float> %656, float %655, i64 1 + %658 = fptrunc <2 x float> %657 to <2 x bfloat> + %659 = mul i32 %644, 2 + %660 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %658, ptr addrspace(8) %482, i32 %659, i32 0, i32 0) + %661 = add i32 %646, 64 + %662 = sext i32 %661 to i64 + %663 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %662 + %664 = load float, ptr addrspace(3) %663, align 4 + %665 = fmul float %664, %640 + %666 = add i32 %646, 65 + %667 = sext i32 %666 to i64 + %668 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %667 + %669 = load float, ptr addrspace(3) %668, align 4 + %670 = fmul float %669, %640 + %671 = insertelement <2 x float> poison, float %665, i64 0 + %672 = insertelement <2 x float> %671, float %670, i64 1 + %673 = fptrunc <2 x float> %672 to <2 x bfloat> + %674 = add i32 %644, 64 + %675 = mul i32 %674, 2 + %676 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %673, ptr addrspace(8) %482, i32 %675, i32 0, i32 0) + %677 = add i32 %646, 128 + %678 = sext i32 %677 to i64 + %679 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %678 + %680 = load float, ptr addrspace(3) %679, align 4 + %681 = fmul float %680, %640 + %682 = add i32 %646, 129 + %683 = sext i32 %682 to i64 + %684 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %683 + %685 = load float, ptr addrspace(3) %684, align 4 + %686 = fmul float %685, %640 + %687 = insertelement <2 x float> poison, float %681, i64 0 + %688 = insertelement <2 x float> %687, float %686, i64 1 + %689 = fptrunc <2 x float> %688 to <2 x bfloat> + %690 = add i32 %644, 128 + %691 = mul i32 %690, 2 + %692 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %689, ptr addrspace(8) %482, i32 %691, i32 0, i32 0) + %693 = add i32 %646, 192 + %694 = sext i32 %693 to i64 + %695 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %694 + %696 = load float, ptr addrspace(3) %695, align 4 + %697 = fmul float %696, %640 + %698 = add i32 %646, 193 + %699 = sext i32 %698 to i64 + %700 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %699 + %701 = load float, ptr addrspace(3) %700, align 4 + %702 = fmul float %701, %640 + %703 = insertelement <2 x float> poison, float %697, i64 0 + %704 = insertelement <2 x float> %703, float %702, i64 1 + %705 = fptrunc <2 x float> %704 to <2 x bfloat> + %706 = add i32 %644, 192 + %707 = mul i32 %706, 2 + %708 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %705, ptr addrspace(8) %482, i32 %707, i32 0, i32 0) + br label %709 + +709: ; preds = %641, %633 + %710 = add i32 %474, 24 + %711 = add i32 %64, %710 + %712 = mul i32 %711, 4 + %713 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %478, i32 %712, i32 0, i32 0) + %714 = and i32 %713, 16777215 + %715 = icmp slt i32 %714, %16 + %716 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %480, i32 %712, i32 0, i32 0) + br i1 %715, label %717, label %785 + +717: ; preds = %709 + %718 = mul i32 %714, 7168 + %719 = add i32 %718, %92 + %720 = add i32 %719, %476 + %721 = mul i32 %710, 256 + %722 = add i32 %721, %476 + %723 = sext i32 %722 to i64 + %724 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %723 + %725 = load float, ptr addrspace(3) %724, align 4 + %726 = fmul float %725, %716 + %727 = add i32 %722, 1 + %728 = sext i32 %727 to i64 + %729 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %728 + %730 = load float, ptr addrspace(3) %729, align 4 + %731 = fmul float %730, %716 + %732 = insertelement <2 x float> poison, float %726, i64 0 + %733 = insertelement <2 x float> %732, float %731, i64 1 + %734 = fptrunc <2 x float> %733 to <2 x bfloat> + %735 = mul i32 %720, 2 + %736 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %734, ptr addrspace(8) %482, i32 %735, i32 0, i32 0) + %737 = add i32 %722, 64 + %738 = sext i32 %737 to i64 + %739 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %738 + %740 = load float, ptr addrspace(3) %739, align 4 + %741 = fmul float %740, %716 + %742 = add i32 %722, 65 + %743 = sext i32 %742 to i64 + %744 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %743 + %745 = load float, ptr addrspace(3) %744, align 4 + %746 = fmul float %745, %716 + %747 = insertelement <2 x float> poison, float %741, i64 0 + %748 = insertelement <2 x float> %747, float %746, i64 1 + %749 = fptrunc <2 x float> %748 to <2 x bfloat> + %750 = add i32 %720, 64 + %751 = mul i32 %750, 2 + %752 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %749, ptr addrspace(8) %482, i32 %751, i32 0, i32 0) + %753 = add i32 %722, 128 + %754 = sext i32 %753 to i64 + %755 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %754 + %756 = load float, ptr addrspace(3) %755, align 4 + %757 = fmul float %756, %716 + %758 = add i32 %722, 129 + %759 = sext i32 %758 to i64 + %760 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %759 + %761 = load float, ptr addrspace(3) %760, align 4 + %762 = fmul float %761, %716 + %763 = insertelement <2 x float> poison, float %757, i64 0 + %764 = insertelement <2 x float> %763, float %762, i64 1 + %765 = fptrunc <2 x float> %764 to <2 x bfloat> + %766 = add i32 %720, 128 + %767 = mul i32 %766, 2 + %768 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %765, ptr addrspace(8) %482, i32 %767, i32 0, i32 0) + %769 = add i32 %722, 192 + %770 = sext i32 %769 to i64 + %771 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %770 + %772 = load float, ptr addrspace(3) %771, align 4 + %773 = fmul float %772, %716 + %774 = add i32 %722, 193 + %775 = sext i32 %774 to i64 + %776 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %775 + %777 = load float, ptr addrspace(3) %776, align 4 + %778 = fmul float %777, %716 + %779 = insertelement <2 x float> poison, float %773, i64 0 + %780 = insertelement <2 x float> %779, float %778, i64 1 + %781 = fptrunc <2 x float> %780 to <2 x bfloat> + %782 = add i32 %720, 192 + %783 = mul i32 %782, 2 + %784 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %781, ptr addrspace(8) %482, i32 %783, i32 0, i32 0) + br label %785 + +785: ; preds = %717, %709 + br label %786 + +786: ; preds = %785, %19 + ret void +} + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) +declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 + +; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) +declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #3 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #4 + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #5 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.sched.barrier(i32 immarg) #6 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #4 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.s.barrier() #6 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) +declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #7 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #4 + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat>, ptr addrspace(8) captures(none), i32, i32, i32 immarg) #5 + +attributes #0 = { "amdgpu-flat-work-group-size"="256,256" "uniform-work-group-size" } +attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } +attributes #2 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } +attributes #3 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } +attributes #4 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } +attributes #5 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } +attributes #6 = { convergent nocallback nofree nounwind willreturn } +attributes #7 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = !{i32 256, i32 1, i32 1} diff --git a/kernels/gemm2_port_ref/flydsl_port_v2.ll b/kernels/gemm2_port_ref/flydsl_port_v2.ll new file mode 100644 index 000000000..1e0f7dce1 --- /dev/null +++ b/kernels/gemm2_port_ref/flydsl_port_v2.ll @@ -0,0 +1,956 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" +target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" + +@gemm2port_smem = external addrspace(3) global [32768 x i8], align 1024 + +define amdgpu_kernel void @gemm2_a4w4_port_bm32_atomic(ptr addrspace(1) %0, <{ <{ i32, i32 }>, <{ i64 }> }> %1, ptr addrspace(1) %2, <{ <{ i32, i32 }>, <{ i64 }> }> %3, ptr addrspace(1) %4, <{ <{ i32, i32, i32 }>, <{ i64, i64 }> }> %5, ptr addrspace(1) %6, <{ <{ i32, i32 }>, <{ i64 }> }> %7, ptr addrspace(1) %8, <{ <{ i32 }> }> %9, ptr addrspace(1) %10, <{ <{ i32 }> }> %11, ptr addrspace(1) %12, <{ <{ i32 }> }> %13, ptr addrspace(1) %14, <{ <{ i32 }> }> %15, i32 %16, ptr addrspace(1) %17, <{ <{ i32, i32 }>, <{ i64 }> }> %18) #0 !reqd_work_group_size !1 { + %20 = call range(i32 0, 256) i32 @llvm.amdgcn.workitem.id.x() + %21 = sext i32 %20 to i64 + %22 = call i32 @llvm.amdgcn.workgroup.id.x() + %23 = sext i32 %22 to i64 + %24 = trunc i64 %21 to i32 + %25 = trunc i64 %23 to i32 + %26 = srem i32 %24, 64 + %27 = sdiv i32 %24, 64 + %28 = mul i32 %27, 64 + %29 = icmp ne i32 %24, %28 + %30 = icmp slt i32 %24, 0 + %31 = icmp ne i1 %30, false + %32 = and i1 %29, %31 + %33 = add i32 %27, -1 + %34 = select i1 %32, i32 %33, i32 %27 + %35 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %34) + %36 = ptrtoint ptr addrspace(1) %10 to i64 + %37 = inttoptr i64 %36 to ptr addrspace(1) + %38 = load i32, ptr addrspace(1) %37, align 4 + %39 = sdiv i32 %38, 32 + %40 = mul i32 %39, 32 + %41 = icmp ne i32 %38, %40 + %42 = icmp slt i32 %38, 0 + %43 = icmp ne i1 %42, false + %44 = and i1 %41, %43 + %45 = add i32 %39, -1 + %46 = select i1 %44, i32 %45, i32 %39 + %47 = mul i32 %46, 28 + %48 = icmp slt i32 %25, %47 + br i1 %48, label %49, label %856 + +49: ; preds = %19 + %50 = srem i32 %25, 28 + %51 = sdiv i32 %25, 28 + %52 = mul i32 %51, 28 + %53 = icmp ne i32 %25, %52 + %54 = icmp slt i32 %25, 0 + %55 = icmp ne i1 %54, false + %56 = and i1 %53, %55 + %57 = add i32 %51, -1 + %58 = select i1 %56, i32 %57, i32 %51 + %59 = mul i32 %58, 4 + %60 = ptrtoint ptr addrspace(1) %8 to i64 + %61 = sext i32 %59 to i64 + %62 = add i64 %60, %61 + %63 = inttoptr i64 %62 to ptr addrspace(1) + %64 = load i32, ptr addrspace(1) %63, align 4 + %65 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %64) + %66 = mul i32 %58, 32 + %67 = addrspacecast ptr addrspace(1) %0 to ptr + %68 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %67, i16 0, i64 167772160, i32 159744) + %69 = addrspacecast ptr addrspace(1) %2 to ptr + %70 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %69, i16 0, i64 10485760, i32 159744) + %71 = addrspacecast ptr addrspace(1) %4 to ptr + %72 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %71, i16 0, i64 706478080, i32 159744) + %73 = addrspacecast ptr addrspace(1) %6 to ptr + %74 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %73, i16 0, i64 44154880, i32 159744) + %75 = sdiv i32 %26, 8 + %76 = mul i32 %75, 8 + %77 = icmp ne i32 %26, %76 + %78 = icmp slt i32 %26, 0 + %79 = icmp ne i1 %78, false + %80 = and i1 %77, %79 + %81 = add i32 %75, -1 + %82 = select i1 %80, i32 %81, i32 %75 + %83 = srem i32 %26, 8 + %84 = sdiv i32 %26, 16 + %85 = mul i32 %84, 16 + %86 = icmp ne i32 %26, %85 + %87 = icmp slt i32 %26, 0 + %88 = icmp ne i1 %87, false + %89 = and i1 %86, %88 + %90 = add i32 %84, -1 + %91 = select i1 %89, i32 %90, i32 %84 + %92 = srem i32 %26, 16 + %93 = mul i32 %65, 7168 + %94 = mul i32 %50, 256 + %95 = add i32 %93, %94 + %96 = mul i32 %35, 64 + %97 = add i32 %95, %96 + %98 = mul i32 %97, 256 + %99 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %98) + %100 = add i32 %97, 16 + %101 = mul i32 %100, 256 + %102 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %101) + %103 = add i32 %97, 32 + %104 = mul i32 %103, 256 + %105 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %104) + %106 = add i32 %97, 48 + %107 = mul i32 %106, 256 + %108 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %107) + %109 = mul i32 %50, 8 + %110 = mul i32 %35, 2 + %111 = add i32 %109, %110 + %112 = mul i32 %65, 28672 + %113 = mul i32 %111, 128 + %114 = add i32 %112, %113 + %115 = mul i32 %114, 4 + %116 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %115) + %117 = add i32 %111, 1 + %118 = mul i32 %117, 128 + %119 = add i32 %112, %118 + %120 = mul i32 %119, 4 + %121 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %120) + %122 = sdiv i32 %66, 32 + %123 = mul i32 %122, 32 + %124 = icmp ne i32 %66, %123 + %125 = icmp slt i32 %66, 0 + %126 = icmp ne i1 %125, false + %127 = and i1 %124, %126 + %128 = add i32 %122, -1 + %129 = select i1 %127, i32 %128, i32 %122 + %130 = mul i32 %129, 512 + %131 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %130) + %132 = mul i32 %35, 8 + %133 = add i32 %66, %132 + %134 = add i32 %133, %82 + %135 = add i32 %132, %82 + %136 = and i32 %135, 14 + %137 = shl i32 %136, 3 + %138 = mul i32 %83, 16 + %139 = xor i32 %138, %137 + %140 = mul i32 %134, 256 + %141 = add i32 %139, %140 + %142 = mul i32 %35, 1024 + %143 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %142 + %144 = sext i32 %143 to i64 + %145 = inttoptr i64 %144 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %68, ptr addrspace(3) %145, i32 16, i32 %141, i32 0, i32 0, i32 0) + %146 = add i32 %142, 4096 + %147 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %146 + %148 = sext i32 %147 to i64 + %149 = inttoptr i64 %148 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %68, ptr addrspace(3) %149, i32 16, i32 %141, i32 128, i32 0, i32 0) + call void @llvm.amdgcn.sched.barrier(i32 0) + %150 = mul i32 %91, 16 + %151 = add i32 %150, %92 + %152 = mul i32 %151, 4 + %153 = sdiv i32 %152, 4 + %154 = mul i32 %153, 4 + %155 = icmp ne i32 %152, %154 + %156 = icmp slt i32 %152, 0 + %157 = icmp ne i1 %156, false + %158 = and i1 %155, %157 + %159 = add i32 %153, -1 + %160 = select i1 %158, i32 %159, i32 %153 + %161 = mul i32 %160, 4 + %162 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %70, i32 %161, i32 %131, i32 0) + %163 = add i32 %152, 256 + %164 = sdiv i32 %163, 4 + %165 = mul i32 %164, 4 + %166 = icmp ne i32 %163, %165 + %167 = icmp slt i32 %163, 0 + %168 = icmp ne i1 %167, false + %169 = and i1 %166, %168 + %170 = add i32 %164, -1 + %171 = select i1 %169, i32 %170, i32 %164 + %172 = mul i32 %171, 4 + %173 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %70, i32 %172, i32 %131, i32 0) + %174 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %161, i32 %116, i32 0) + %175 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %161, i32 %121, i32 0) + %176 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %172, i32 %116, i32 0) + %177 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %172, i32 %121, i32 0) + %178 = mul i32 %91, 256 + %179 = mul i32 %92, 16 + %180 = add i32 %178, %179 + %181 = sdiv i32 %180, 4 + %182 = mul i32 %181, 4 + %183 = icmp ne i32 %180, %182 + %184 = icmp slt i32 %180, 0 + %185 = icmp ne i1 %184, false + %186 = and i1 %183, %185 + %187 = add i32 %181, -1 + %188 = select i1 %186, i32 %187, i32 %181 + %189 = mul i32 %188, 4 + %190 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %99, i32 0) + %191 = add i32 %180, 1024 + %192 = sdiv i32 %191, 4 + %193 = mul i32 %192, 4 + %194 = icmp ne i32 %191, %193 + %195 = icmp slt i32 %191, 0 + %196 = icmp ne i1 %195, false + %197 = and i1 %194, %196 + %198 = add i32 %192, -1 + %199 = select i1 %197, i32 %198, i32 %192 + %200 = mul i32 %199, 4 + %201 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %99, i32 0) + %202 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %102, i32 0) + %203 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %102, i32 0) + %204 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %105, i32 0) + %205 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %105, i32 0) + %206 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %108, i32 0) + %207 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %108, i32 0) + %208 = add i32 %180, 2048 + %209 = sdiv i32 %208, 4 + %210 = mul i32 %209, 4 + %211 = icmp ne i32 %208, %210 + %212 = icmp slt i32 %208, 0 + %213 = icmp ne i1 %212, false + %214 = and i1 %211, %213 + %215 = add i32 %209, -1 + %216 = select i1 %214, i32 %215, i32 %209 + %217 = mul i32 %216, 4 + %218 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %99, i32 0) + %219 = add i32 %180, 3072 + %220 = sdiv i32 %219, 4 + %221 = mul i32 %220, 4 + %222 = icmp ne i32 %219, %221 + %223 = icmp slt i32 %219, 0 + %224 = icmp ne i1 %223, false + %225 = and i1 %222, %224 + %226 = add i32 %220, -1 + %227 = select i1 %225, i32 %226, i32 %220 + %228 = mul i32 %227, 4 + %229 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %99, i32 0) + %230 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %102, i32 0) + %231 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %102, i32 0) + %232 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %105, i32 0) + %233 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %105, i32 0) + %234 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %108, i32 0) + %235 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %108, i32 0) + call void asm sideeffect "s_waitcnt vmcnt(23)", ""() + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %236 = and i32 %92, 14 + %237 = shl i32 %236, 3 + %238 = xor i32 %150, %237 + %239 = mul i32 %92, 128 + %240 = add i32 %239, %238 + %241 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %240 + %242 = sext i32 %241 to i64 + %243 = inttoptr i64 %242 to ptr addrspace(3) + %244 = load <4 x i32>, ptr addrspace(3) %243, align 16 + %245 = add i32 %92, 16 + %246 = mul i32 %245, 128 + %247 = add i32 %246, %238 + %248 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %247 + %249 = sext i32 %248 to i64 + %250 = inttoptr i64 %249 to ptr addrspace(3) + %251 = load <4 x i32>, ptr addrspace(3) %250, align 16 + %252 = add i32 %150, 64 + %253 = xor i32 %252, %237 + %254 = add i32 %239, %253 + %255 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %254 + %256 = sext i32 %255 to i64 + %257 = inttoptr i64 %256 to ptr addrspace(3) + %258 = load <4 x i32>, ptr addrspace(3) %257, align 16 + %259 = add i32 %246, %253 + %260 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %259 + %261 = sext i32 %260 to i64 + %262 = inttoptr i64 %261 to ptr addrspace(3) + %263 = load <4 x i32>, ptr addrspace(3) %262, align 16 + %264 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %190, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 0, i32 %174) + %265 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %190, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 0, i32 %174) + %266 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %201, <4 x float> %264, i32 4, i32 4, i32 2, i32 %162, i32 2, i32 %174) + %267 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %201, <4 x float> %265, i32 4, i32 4, i32 3, i32 %162, i32 2, i32 %174) + %268 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 1, i32 %174) + %269 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 1, i32 %174) + %270 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %203, <4 x float> %268, i32 4, i32 4, i32 2, i32 %162, i32 3, i32 %174) + %271 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %203, <4 x float> %269, i32 4, i32 4, i32 3, i32 %162, i32 3, i32 %174) + %272 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 0, i32 %175) + %273 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 0, i32 %175) + %274 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %205, <4 x float> %272, i32 4, i32 4, i32 2, i32 %162, i32 2, i32 %175) + %275 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %205, <4 x float> %273, i32 4, i32 4, i32 3, i32 %162, i32 2, i32 %175) + %276 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %206, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 1, i32 %175) + %277 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %206, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 1, i32 %175) + %278 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %207, <4 x float> %276, i32 4, i32 4, i32 2, i32 %162, i32 3, i32 %175) + %279 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %207, <4 x float> %277, i32 4, i32 4, i32 3, i32 %162, i32 3, i32 %175) + call void asm sideeffect "s_waitcnt vmcnt(22)", ""() + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %280 = add i32 %239, 4096 + %281 = add i32 %280, %238 + %282 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %281 + %283 = sext i32 %282 to i64 + %284 = inttoptr i64 %283 to ptr addrspace(3) + %285 = load <4 x i32>, ptr addrspace(3) %284, align 16 + %286 = add i32 %246, 4096 + %287 = add i32 %286, %238 + %288 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %287 + %289 = sext i32 %288 to i64 + %290 = inttoptr i64 %289 to ptr addrspace(3) + %291 = load <4 x i32>, ptr addrspace(3) %290, align 16 + %292 = add i32 %280, %253 + %293 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %292 + %294 = sext i32 %293 to i64 + %295 = inttoptr i64 %294 to ptr addrspace(3) + %296 = load <4 x i32>, ptr addrspace(3) %295, align 16 + %297 = add i32 %286, %253 + %298 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %297 + %299 = sext i32 %298 to i64 + %300 = inttoptr i64 %299 to ptr addrspace(3) + %301 = load <4 x i32>, ptr addrspace(3) %300, align 16 + %302 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %218, <4 x float> %266, i32 4, i32 4, i32 0, i32 %173, i32 0, i32 %176) + %303 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %218, <4 x float> %267, i32 4, i32 4, i32 1, i32 %173, i32 0, i32 %176) + %304 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %229, <4 x float> %302, i32 4, i32 4, i32 2, i32 %173, i32 2, i32 %176) + %305 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %229, <4 x float> %303, i32 4, i32 4, i32 3, i32 %173, i32 2, i32 %176) + %306 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %230, <4 x float> %270, i32 4, i32 4, i32 0, i32 %173, i32 1, i32 %176) + %307 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %230, <4 x float> %271, i32 4, i32 4, i32 1, i32 %173, i32 1, i32 %176) + %308 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %231, <4 x float> %306, i32 4, i32 4, i32 2, i32 %173, i32 3, i32 %176) + %309 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %231, <4 x float> %307, i32 4, i32 4, i32 3, i32 %173, i32 3, i32 %176) + %310 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %232, <4 x float> %274, i32 4, i32 4, i32 0, i32 %173, i32 0, i32 %177) + %311 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %232, <4 x float> %275, i32 4, i32 4, i32 1, i32 %173, i32 0, i32 %177) + %312 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %233, <4 x float> %310, i32 4, i32 4, i32 2, i32 %173, i32 2, i32 %177) + %313 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %233, <4 x float> %311, i32 4, i32 4, i32 3, i32 %173, i32 2, i32 %177) + %314 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %234, <4 x float> %278, i32 4, i32 4, i32 0, i32 %173, i32 1, i32 %177) + %315 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %234, <4 x float> %279, i32 4, i32 4, i32 1, i32 %173, i32 1, i32 %177) + %316 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %235, <4 x float> %314, i32 4, i32 4, i32 2, i32 %173, i32 3, i32 %177) + %317 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %235, <4 x float> %315, i32 4, i32 4, i32 3, i32 %173, i32 3, i32 %177) + %318 = mul i32 %91, 4 + %319 = add i32 %96, %92 + %320 = mul i32 %91, 1024 + %321 = add i32 %320, %319 + %322 = extractelement <4 x float> %304, i64 0 + %323 = sext i32 %321 to i64 + %324 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %323 + store float %322, ptr addrspace(3) %324, align 4 + %325 = add i32 %318, 1 + %326 = mul i32 %325, 256 + %327 = add i32 %326, %319 + %328 = extractelement <4 x float> %304, i64 1 + %329 = sext i32 %327 to i64 + %330 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %329 + store float %328, ptr addrspace(3) %330, align 4 + %331 = add i32 %318, 2 + %332 = mul i32 %331, 256 + %333 = add i32 %332, %319 + %334 = extractelement <4 x float> %304, i64 2 + %335 = sext i32 %333 to i64 + %336 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %335 + store float %334, ptr addrspace(3) %336, align 4 + %337 = add i32 %318, 3 + %338 = mul i32 %337, 256 + %339 = add i32 %338, %319 + %340 = extractelement <4 x float> %304, i64 3 + %341 = sext i32 %339 to i64 + %342 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %341 + store float %340, ptr addrspace(3) %342, align 4 + %343 = add i32 %96, 16 + %344 = add i32 %343, %92 + %345 = add i32 %320, %344 + %346 = extractelement <4 x float> %308, i64 0 + %347 = sext i32 %345 to i64 + %348 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %347 + store float %346, ptr addrspace(3) %348, align 4 + %349 = add i32 %326, %344 + %350 = extractelement <4 x float> %308, i64 1 + %351 = sext i32 %349 to i64 + %352 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %351 + store float %350, ptr addrspace(3) %352, align 4 + %353 = add i32 %332, %344 + %354 = extractelement <4 x float> %308, i64 2 + %355 = sext i32 %353 to i64 + %356 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %355 + store float %354, ptr addrspace(3) %356, align 4 + %357 = add i32 %338, %344 + %358 = extractelement <4 x float> %308, i64 3 + %359 = sext i32 %357 to i64 + %360 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %359 + store float %358, ptr addrspace(3) %360, align 4 + %361 = add i32 %96, 32 + %362 = add i32 %361, %92 + %363 = add i32 %320, %362 + %364 = extractelement <4 x float> %312, i64 0 + %365 = sext i32 %363 to i64 + %366 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %365 + store float %364, ptr addrspace(3) %366, align 4 + %367 = add i32 %326, %362 + %368 = extractelement <4 x float> %312, i64 1 + %369 = sext i32 %367 to i64 + %370 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %369 + store float %368, ptr addrspace(3) %370, align 4 + %371 = add i32 %332, %362 + %372 = extractelement <4 x float> %312, i64 2 + %373 = sext i32 %371 to i64 + %374 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %373 + store float %372, ptr addrspace(3) %374, align 4 + %375 = add i32 %338, %362 + %376 = extractelement <4 x float> %312, i64 3 + %377 = sext i32 %375 to i64 + %378 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %377 + store float %376, ptr addrspace(3) %378, align 4 + %379 = add i32 %96, 48 + %380 = add i32 %379, %92 + %381 = add i32 %320, %380 + %382 = extractelement <4 x float> %316, i64 0 + %383 = sext i32 %381 to i64 + %384 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %383 + store float %382, ptr addrspace(3) %384, align 4 + %385 = add i32 %326, %380 + %386 = extractelement <4 x float> %316, i64 1 + %387 = sext i32 %385 to i64 + %388 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %387 + store float %386, ptr addrspace(3) %388, align 4 + %389 = add i32 %332, %380 + %390 = extractelement <4 x float> %316, i64 2 + %391 = sext i32 %389 to i64 + %392 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %391 + store float %390, ptr addrspace(3) %392, align 4 + %393 = add i32 %338, %380 + %394 = extractelement <4 x float> %316, i64 3 + %395 = sext i32 %393 to i64 + %396 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %395 + store float %394, ptr addrspace(3) %396, align 4 + %397 = add i32 %318, 16 + %398 = mul i32 %397, 256 + %399 = add i32 %398, %319 + %400 = extractelement <4 x float> %305, i64 0 + %401 = sext i32 %399 to i64 + %402 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %401 + store float %400, ptr addrspace(3) %402, align 4 + %403 = add i32 %318, 17 + %404 = mul i32 %403, 256 + %405 = add i32 %404, %319 + %406 = extractelement <4 x float> %305, i64 1 + %407 = sext i32 %405 to i64 + %408 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %407 + store float %406, ptr addrspace(3) %408, align 4 + %409 = add i32 %318, 18 + %410 = mul i32 %409, 256 + %411 = add i32 %410, %319 + %412 = extractelement <4 x float> %305, i64 2 + %413 = sext i32 %411 to i64 + %414 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %413 + store float %412, ptr addrspace(3) %414, align 4 + %415 = add i32 %318, 19 + %416 = mul i32 %415, 256 + %417 = add i32 %416, %319 + %418 = extractelement <4 x float> %305, i64 3 + %419 = sext i32 %417 to i64 + %420 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %419 + store float %418, ptr addrspace(3) %420, align 4 + %421 = add i32 %398, %344 + %422 = extractelement <4 x float> %309, i64 0 + %423 = sext i32 %421 to i64 + %424 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %423 + store float %422, ptr addrspace(3) %424, align 4 + %425 = add i32 %404, %344 + %426 = extractelement <4 x float> %309, i64 1 + %427 = sext i32 %425 to i64 + %428 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %427 + store float %426, ptr addrspace(3) %428, align 4 + %429 = add i32 %410, %344 + %430 = extractelement <4 x float> %309, i64 2 + %431 = sext i32 %429 to i64 + %432 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %431 + store float %430, ptr addrspace(3) %432, align 4 + %433 = add i32 %416, %344 + %434 = extractelement <4 x float> %309, i64 3 + %435 = sext i32 %433 to i64 + %436 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %435 + store float %434, ptr addrspace(3) %436, align 4 + %437 = add i32 %398, %362 + %438 = extractelement <4 x float> %313, i64 0 + %439 = sext i32 %437 to i64 + %440 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %439 + store float %438, ptr addrspace(3) %440, align 4 + %441 = add i32 %404, %362 + %442 = extractelement <4 x float> %313, i64 1 + %443 = sext i32 %441 to i64 + %444 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %443 + store float %442, ptr addrspace(3) %444, align 4 + %445 = add i32 %410, %362 + %446 = extractelement <4 x float> %313, i64 2 + %447 = sext i32 %445 to i64 + %448 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %447 + store float %446, ptr addrspace(3) %448, align 4 + %449 = add i32 %416, %362 + %450 = extractelement <4 x float> %313, i64 3 + %451 = sext i32 %449 to i64 + %452 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %451 + store float %450, ptr addrspace(3) %452, align 4 + %453 = add i32 %398, %380 + %454 = extractelement <4 x float> %317, i64 0 + %455 = sext i32 %453 to i64 + %456 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %455 + store float %454, ptr addrspace(3) %456, align 4 + %457 = add i32 %404, %380 + %458 = extractelement <4 x float> %317, i64 1 + %459 = sext i32 %457 to i64 + %460 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %459 + store float %458, ptr addrspace(3) %460, align 4 + %461 = add i32 %410, %380 + %462 = extractelement <4 x float> %317, i64 2 + %463 = sext i32 %461 to i64 + %464 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %463 + store float %462, ptr addrspace(3) %464, align 4 + %465 = add i32 %416, %380 + %466 = extractelement <4 x float> %317, i64 3 + %467 = sext i32 %465 to i64 + %468 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %467 + store float %466, ptr addrspace(3) %468, align 4 + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %469 = sdiv i32 %24, 32 + %470 = mul i32 %469, 32 + %471 = icmp ne i32 %24, %470 + %472 = icmp slt i32 %24, 0 + %473 = icmp ne i1 %472, false + %474 = and i1 %471, %473 + %475 = add i32 %469, -1 + %476 = select i1 %474, i32 %475, i32 %469 + %477 = srem i32 %24, 32 + %478 = mul i32 %477, 2 + %479 = add i32 %66, %476 + %480 = mul i32 %479, 4 + %481 = ptrtoint ptr addrspace(1) %12 to i64 + %482 = sext i32 %480 to i64 + %483 = add i64 %481, %482 + %484 = inttoptr i64 %483 to ptr addrspace(1) + %485 = load i32, ptr addrspace(1) %484, align 4 + %486 = and i32 %485, 16777215 + %487 = icmp slt i32 %486, %16 + %488 = ptrtoint ptr addrspace(1) %14 to i64 + %489 = add i64 %488, %482 + %490 = inttoptr i64 %489 to ptr addrspace(1) + %491 = load float, ptr addrspace(1) %490, align 4 + br i1 %487, label %492, label %573 + +492: ; preds = %49 + %493 = mul i32 %486, 7168 + %494 = add i32 %493, %94 + %495 = add i32 %494, %478 + %496 = mul i32 %476, 256 + %497 = add i32 %496, %478 + %498 = sext i32 %497 to i64 + %499 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %498 + %500 = load float, ptr addrspace(3) %499, align 4 + %501 = fmul float %500, %491 + %502 = add i32 %497, 1 + %503 = sext i32 %502 to i64 + %504 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %503 + %505 = load float, ptr addrspace(3) %504, align 4 + %506 = fmul float %505, %491 + %507 = insertelement <2 x float> poison, float %501, i64 0 + %508 = insertelement <2 x float> %507, float %506, i64 1 + %509 = fptrunc <2 x float> %508 to <2 x bfloat> + %510 = mul i32 %495, 2 + %511 = ptrtoint ptr addrspace(1) %17 to i64 + %512 = sext i32 %510 to i64 + %513 = add i64 %511, %512 + %514 = inttoptr i64 %513 to ptr addrspace(1) + %515 = atomicrmw fadd ptr addrspace(1) %514, <2 x bfloat> %509 syncscope("agent") monotonic, align 4 + %516 = add i32 %497, 64 + %517 = sext i32 %516 to i64 + %518 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %517 + %519 = load float, ptr addrspace(3) %518, align 4 + %520 = fmul float %519, %491 + %521 = add i32 %497, 65 + %522 = sext i32 %521 to i64 + %523 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %522 + %524 = load float, ptr addrspace(3) %523, align 4 + %525 = fmul float %524, %491 + %526 = insertelement <2 x float> poison, float %520, i64 0 + %527 = insertelement <2 x float> %526, float %525, i64 1 + %528 = fptrunc <2 x float> %527 to <2 x bfloat> + %529 = add i32 %495, 64 + %530 = mul i32 %529, 2 + %531 = sext i32 %530 to i64 + %532 = add i64 %511, %531 + %533 = inttoptr i64 %532 to ptr addrspace(1) + %534 = atomicrmw fadd ptr addrspace(1) %533, <2 x bfloat> %528 syncscope("agent") monotonic, align 4 + %535 = add i32 %497, 128 + %536 = sext i32 %535 to i64 + %537 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %536 + %538 = load float, ptr addrspace(3) %537, align 4 + %539 = fmul float %538, %491 + %540 = add i32 %497, 129 + %541 = sext i32 %540 to i64 + %542 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %541 + %543 = load float, ptr addrspace(3) %542, align 4 + %544 = fmul float %543, %491 + %545 = insertelement <2 x float> poison, float %539, i64 0 + %546 = insertelement <2 x float> %545, float %544, i64 1 + %547 = fptrunc <2 x float> %546 to <2 x bfloat> + %548 = add i32 %495, 128 + %549 = mul i32 %548, 2 + %550 = sext i32 %549 to i64 + %551 = add i64 %511, %550 + %552 = inttoptr i64 %551 to ptr addrspace(1) + %553 = atomicrmw fadd ptr addrspace(1) %552, <2 x bfloat> %547 syncscope("agent") monotonic, align 4 + %554 = add i32 %497, 192 + %555 = sext i32 %554 to i64 + %556 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %555 + %557 = load float, ptr addrspace(3) %556, align 4 + %558 = fmul float %557, %491 + %559 = add i32 %497, 193 + %560 = sext i32 %559 to i64 + %561 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %560 + %562 = load float, ptr addrspace(3) %561, align 4 + %563 = fmul float %562, %491 + %564 = insertelement <2 x float> poison, float %558, i64 0 + %565 = insertelement <2 x float> %564, float %563, i64 1 + %566 = fptrunc <2 x float> %565 to <2 x bfloat> + %567 = add i32 %495, 192 + %568 = mul i32 %567, 2 + %569 = sext i32 %568 to i64 + %570 = add i64 %511, %569 + %571 = inttoptr i64 %570 to ptr addrspace(1) + %572 = atomicrmw fadd ptr addrspace(1) %571, <2 x bfloat> %566 syncscope("agent") monotonic, align 4 + br label %573 + +573: ; preds = %492, %49 + %574 = add i32 %476, 8 + %575 = add i32 %66, %574 + %576 = mul i32 %575, 4 + %577 = sext i32 %576 to i64 + %578 = add i64 %481, %577 + %579 = inttoptr i64 %578 to ptr addrspace(1) + %580 = load i32, ptr addrspace(1) %579, align 4 + %581 = and i32 %580, 16777215 + %582 = icmp slt i32 %581, %16 + %583 = add i64 %488, %577 + %584 = inttoptr i64 %583 to ptr addrspace(1) + %585 = load float, ptr addrspace(1) %584, align 4 + br i1 %582, label %586, label %667 + +586: ; preds = %573 + %587 = mul i32 %581, 7168 + %588 = add i32 %587, %94 + %589 = add i32 %588, %478 + %590 = mul i32 %574, 256 + %591 = add i32 %590, %478 + %592 = sext i32 %591 to i64 + %593 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %592 + %594 = load float, ptr addrspace(3) %593, align 4 + %595 = fmul float %594, %585 + %596 = add i32 %591, 1 + %597 = sext i32 %596 to i64 + %598 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %597 + %599 = load float, ptr addrspace(3) %598, align 4 + %600 = fmul float %599, %585 + %601 = insertelement <2 x float> poison, float %595, i64 0 + %602 = insertelement <2 x float> %601, float %600, i64 1 + %603 = fptrunc <2 x float> %602 to <2 x bfloat> + %604 = mul i32 %589, 2 + %605 = ptrtoint ptr addrspace(1) %17 to i64 + %606 = sext i32 %604 to i64 + %607 = add i64 %605, %606 + %608 = inttoptr i64 %607 to ptr addrspace(1) + %609 = atomicrmw fadd ptr addrspace(1) %608, <2 x bfloat> %603 syncscope("agent") monotonic, align 4 + %610 = add i32 %591, 64 + %611 = sext i32 %610 to i64 + %612 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %611 + %613 = load float, ptr addrspace(3) %612, align 4 + %614 = fmul float %613, %585 + %615 = add i32 %591, 65 + %616 = sext i32 %615 to i64 + %617 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %616 + %618 = load float, ptr addrspace(3) %617, align 4 + %619 = fmul float %618, %585 + %620 = insertelement <2 x float> poison, float %614, i64 0 + %621 = insertelement <2 x float> %620, float %619, i64 1 + %622 = fptrunc <2 x float> %621 to <2 x bfloat> + %623 = add i32 %589, 64 + %624 = mul i32 %623, 2 + %625 = sext i32 %624 to i64 + %626 = add i64 %605, %625 + %627 = inttoptr i64 %626 to ptr addrspace(1) + %628 = atomicrmw fadd ptr addrspace(1) %627, <2 x bfloat> %622 syncscope("agent") monotonic, align 4 + %629 = add i32 %591, 128 + %630 = sext i32 %629 to i64 + %631 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %630 + %632 = load float, ptr addrspace(3) %631, align 4 + %633 = fmul float %632, %585 + %634 = add i32 %591, 129 + %635 = sext i32 %634 to i64 + %636 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %635 + %637 = load float, ptr addrspace(3) %636, align 4 + %638 = fmul float %637, %585 + %639 = insertelement <2 x float> poison, float %633, i64 0 + %640 = insertelement <2 x float> %639, float %638, i64 1 + %641 = fptrunc <2 x float> %640 to <2 x bfloat> + %642 = add i32 %589, 128 + %643 = mul i32 %642, 2 + %644 = sext i32 %643 to i64 + %645 = add i64 %605, %644 + %646 = inttoptr i64 %645 to ptr addrspace(1) + %647 = atomicrmw fadd ptr addrspace(1) %646, <2 x bfloat> %641 syncscope("agent") monotonic, align 4 + %648 = add i32 %591, 192 + %649 = sext i32 %648 to i64 + %650 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %649 + %651 = load float, ptr addrspace(3) %650, align 4 + %652 = fmul float %651, %585 + %653 = add i32 %591, 193 + %654 = sext i32 %653 to i64 + %655 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %654 + %656 = load float, ptr addrspace(3) %655, align 4 + %657 = fmul float %656, %585 + %658 = insertelement <2 x float> poison, float %652, i64 0 + %659 = insertelement <2 x float> %658, float %657, i64 1 + %660 = fptrunc <2 x float> %659 to <2 x bfloat> + %661 = add i32 %589, 192 + %662 = mul i32 %661, 2 + %663 = sext i32 %662 to i64 + %664 = add i64 %605, %663 + %665 = inttoptr i64 %664 to ptr addrspace(1) + %666 = atomicrmw fadd ptr addrspace(1) %665, <2 x bfloat> %660 syncscope("agent") monotonic, align 4 + br label %667 + +667: ; preds = %586, %573 + %668 = add i32 %476, 16 + %669 = add i32 %66, %668 + %670 = mul i32 %669, 4 + %671 = sext i32 %670 to i64 + %672 = add i64 %481, %671 + %673 = inttoptr i64 %672 to ptr addrspace(1) + %674 = load i32, ptr addrspace(1) %673, align 4 + %675 = and i32 %674, 16777215 + %676 = icmp slt i32 %675, %16 + %677 = add i64 %488, %671 + %678 = inttoptr i64 %677 to ptr addrspace(1) + %679 = load float, ptr addrspace(1) %678, align 4 + br i1 %676, label %680, label %761 + +680: ; preds = %667 + %681 = mul i32 %675, 7168 + %682 = add i32 %681, %94 + %683 = add i32 %682, %478 + %684 = mul i32 %668, 256 + %685 = add i32 %684, %478 + %686 = sext i32 %685 to i64 + %687 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %686 + %688 = load float, ptr addrspace(3) %687, align 4 + %689 = fmul float %688, %679 + %690 = add i32 %685, 1 + %691 = sext i32 %690 to i64 + %692 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %691 + %693 = load float, ptr addrspace(3) %692, align 4 + %694 = fmul float %693, %679 + %695 = insertelement <2 x float> poison, float %689, i64 0 + %696 = insertelement <2 x float> %695, float %694, i64 1 + %697 = fptrunc <2 x float> %696 to <2 x bfloat> + %698 = mul i32 %683, 2 + %699 = ptrtoint ptr addrspace(1) %17 to i64 + %700 = sext i32 %698 to i64 + %701 = add i64 %699, %700 + %702 = inttoptr i64 %701 to ptr addrspace(1) + %703 = atomicrmw fadd ptr addrspace(1) %702, <2 x bfloat> %697 syncscope("agent") monotonic, align 4 + %704 = add i32 %685, 64 + %705 = sext i32 %704 to i64 + %706 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %705 + %707 = load float, ptr addrspace(3) %706, align 4 + %708 = fmul float %707, %679 + %709 = add i32 %685, 65 + %710 = sext i32 %709 to i64 + %711 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %710 + %712 = load float, ptr addrspace(3) %711, align 4 + %713 = fmul float %712, %679 + %714 = insertelement <2 x float> poison, float %708, i64 0 + %715 = insertelement <2 x float> %714, float %713, i64 1 + %716 = fptrunc <2 x float> %715 to <2 x bfloat> + %717 = add i32 %683, 64 + %718 = mul i32 %717, 2 + %719 = sext i32 %718 to i64 + %720 = add i64 %699, %719 + %721 = inttoptr i64 %720 to ptr addrspace(1) + %722 = atomicrmw fadd ptr addrspace(1) %721, <2 x bfloat> %716 syncscope("agent") monotonic, align 4 + %723 = add i32 %685, 128 + %724 = sext i32 %723 to i64 + %725 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %724 + %726 = load float, ptr addrspace(3) %725, align 4 + %727 = fmul float %726, %679 + %728 = add i32 %685, 129 + %729 = sext i32 %728 to i64 + %730 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %729 + %731 = load float, ptr addrspace(3) %730, align 4 + %732 = fmul float %731, %679 + %733 = insertelement <2 x float> poison, float %727, i64 0 + %734 = insertelement <2 x float> %733, float %732, i64 1 + %735 = fptrunc <2 x float> %734 to <2 x bfloat> + %736 = add i32 %683, 128 + %737 = mul i32 %736, 2 + %738 = sext i32 %737 to i64 + %739 = add i64 %699, %738 + %740 = inttoptr i64 %739 to ptr addrspace(1) + %741 = atomicrmw fadd ptr addrspace(1) %740, <2 x bfloat> %735 syncscope("agent") monotonic, align 4 + %742 = add i32 %685, 192 + %743 = sext i32 %742 to i64 + %744 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %743 + %745 = load float, ptr addrspace(3) %744, align 4 + %746 = fmul float %745, %679 + %747 = add i32 %685, 193 + %748 = sext i32 %747 to i64 + %749 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %748 + %750 = load float, ptr addrspace(3) %749, align 4 + %751 = fmul float %750, %679 + %752 = insertelement <2 x float> poison, float %746, i64 0 + %753 = insertelement <2 x float> %752, float %751, i64 1 + %754 = fptrunc <2 x float> %753 to <2 x bfloat> + %755 = add i32 %683, 192 + %756 = mul i32 %755, 2 + %757 = sext i32 %756 to i64 + %758 = add i64 %699, %757 + %759 = inttoptr i64 %758 to ptr addrspace(1) + %760 = atomicrmw fadd ptr addrspace(1) %759, <2 x bfloat> %754 syncscope("agent") monotonic, align 4 + br label %761 + +761: ; preds = %680, %667 + %762 = add i32 %476, 24 + %763 = add i32 %66, %762 + %764 = mul i32 %763, 4 + %765 = sext i32 %764 to i64 + %766 = add i64 %481, %765 + %767 = inttoptr i64 %766 to ptr addrspace(1) + %768 = load i32, ptr addrspace(1) %767, align 4 + %769 = and i32 %768, 16777215 + %770 = icmp slt i32 %769, %16 + %771 = add i64 %488, %765 + %772 = inttoptr i64 %771 to ptr addrspace(1) + %773 = load float, ptr addrspace(1) %772, align 4 + br i1 %770, label %774, label %855 + +774: ; preds = %761 + %775 = mul i32 %769, 7168 + %776 = add i32 %775, %94 + %777 = add i32 %776, %478 + %778 = mul i32 %762, 256 + %779 = add i32 %778, %478 + %780 = sext i32 %779 to i64 + %781 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %780 + %782 = load float, ptr addrspace(3) %781, align 4 + %783 = fmul float %782, %773 + %784 = add i32 %779, 1 + %785 = sext i32 %784 to i64 + %786 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %785 + %787 = load float, ptr addrspace(3) %786, align 4 + %788 = fmul float %787, %773 + %789 = insertelement <2 x float> poison, float %783, i64 0 + %790 = insertelement <2 x float> %789, float %788, i64 1 + %791 = fptrunc <2 x float> %790 to <2 x bfloat> + %792 = mul i32 %777, 2 + %793 = ptrtoint ptr addrspace(1) %17 to i64 + %794 = sext i32 %792 to i64 + %795 = add i64 %793, %794 + %796 = inttoptr i64 %795 to ptr addrspace(1) + %797 = atomicrmw fadd ptr addrspace(1) %796, <2 x bfloat> %791 syncscope("agent") monotonic, align 4 + %798 = add i32 %779, 64 + %799 = sext i32 %798 to i64 + %800 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %799 + %801 = load float, ptr addrspace(3) %800, align 4 + %802 = fmul float %801, %773 + %803 = add i32 %779, 65 + %804 = sext i32 %803 to i64 + %805 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %804 + %806 = load float, ptr addrspace(3) %805, align 4 + %807 = fmul float %806, %773 + %808 = insertelement <2 x float> poison, float %802, i64 0 + %809 = insertelement <2 x float> %808, float %807, i64 1 + %810 = fptrunc <2 x float> %809 to <2 x bfloat> + %811 = add i32 %777, 64 + %812 = mul i32 %811, 2 + %813 = sext i32 %812 to i64 + %814 = add i64 %793, %813 + %815 = inttoptr i64 %814 to ptr addrspace(1) + %816 = atomicrmw fadd ptr addrspace(1) %815, <2 x bfloat> %810 syncscope("agent") monotonic, align 4 + %817 = add i32 %779, 128 + %818 = sext i32 %817 to i64 + %819 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %818 + %820 = load float, ptr addrspace(3) %819, align 4 + %821 = fmul float %820, %773 + %822 = add i32 %779, 129 + %823 = sext i32 %822 to i64 + %824 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %823 + %825 = load float, ptr addrspace(3) %824, align 4 + %826 = fmul float %825, %773 + %827 = insertelement <2 x float> poison, float %821, i64 0 + %828 = insertelement <2 x float> %827, float %826, i64 1 + %829 = fptrunc <2 x float> %828 to <2 x bfloat> + %830 = add i32 %777, 128 + %831 = mul i32 %830, 2 + %832 = sext i32 %831 to i64 + %833 = add i64 %793, %832 + %834 = inttoptr i64 %833 to ptr addrspace(1) + %835 = atomicrmw fadd ptr addrspace(1) %834, <2 x bfloat> %829 syncscope("agent") monotonic, align 4 + %836 = add i32 %779, 192 + %837 = sext i32 %836 to i64 + %838 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %837 + %839 = load float, ptr addrspace(3) %838, align 4 + %840 = fmul float %839, %773 + %841 = add i32 %779, 193 + %842 = sext i32 %841 to i64 + %843 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %842 + %844 = load float, ptr addrspace(3) %843, align 4 + %845 = fmul float %844, %773 + %846 = insertelement <2 x float> poison, float %840, i64 0 + %847 = insertelement <2 x float> %846, float %845, i64 1 + %848 = fptrunc <2 x float> %847 to <2 x bfloat> + %849 = add i32 %777, 192 + %850 = mul i32 %849, 2 + %851 = sext i32 %850 to i64 + %852 = add i64 %793, %851 + %853 = inttoptr i64 %852 to ptr addrspace(1) + %854 = atomicrmw fadd ptr addrspace(1) %853, <2 x bfloat> %848 syncscope("agent") monotonic, align 4 + br label %855 + +855: ; preds = %774, %761 + br label %856 + +856: ; preds = %855, %19 + ret void +} + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) +declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 + +; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) +declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #3 + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #4 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.sched.barrier(i32 immarg) #5 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.s.barrier() #5 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) +declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #7 + +attributes #0 = { "amdgpu-flat-work-group-size"="256,256" "uniform-work-group-size" } +attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } +attributes #2 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } +attributes #3 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } +attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } +attributes #5 = { convergent nocallback nofree nounwind willreturn } +attributes #6 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } +attributes #7 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = !{i32 256, i32 1, i32 1} diff --git a/kernels/gemm2_port_ref/flydsl_port_v3.ll b/kernels/gemm2_port_ref/flydsl_port_v3.ll new file mode 100644 index 000000000..6069aa524 --- /dev/null +++ b/kernels/gemm2_port_ref/flydsl_port_v3.ll @@ -0,0 +1,1083 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" +target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" + +@gemm2port_smem = external addrspace(3) global [32768 x i8], align 1024 + +define amdgpu_kernel void @gemm2_a4w4_port_bm32_atomic(ptr addrspace(1) %0, <{ <{ i32, i32 }>, <{ i64 }> }> %1, ptr addrspace(1) %2, <{ <{ i32, i32 }>, <{ i64 }> }> %3, ptr addrspace(1) %4, <{ <{ i32, i32, i32 }>, <{ i64, i64 }> }> %5, ptr addrspace(1) %6, <{ <{ i32, i32 }>, <{ i64 }> }> %7, ptr addrspace(1) %8, <{ <{ i32 }> }> %9, ptr addrspace(1) %10, <{ <{ i32 }> }> %11, ptr addrspace(1) %12, <{ <{ i32 }> }> %13, ptr addrspace(1) %14, <{ <{ i32 }> }> %15, i32 %16, ptr addrspace(1) %17, <{ <{ i32, i32 }>, <{ i64 }> }> %18) #0 !reqd_work_group_size !1 { + %20 = call range(i32 0, 256) i32 @llvm.amdgcn.workitem.id.x() + %21 = sext i32 %20 to i64 + %22 = call i32 @llvm.amdgcn.workgroup.id.x() + %23 = sext i32 %22 to i64 + %24 = trunc i64 %21 to i32 + %25 = trunc i64 %23 to i32 + %26 = srem i32 %24, 64 + %27 = sdiv i32 %24, 64 + %28 = mul i32 %27, 64 + %29 = icmp ne i32 %24, %28 + %30 = icmp slt i32 %24, 0 + %31 = icmp ne i1 %30, false + %32 = and i1 %29, %31 + %33 = add i32 %27, -1 + %34 = select i1 %32, i32 %33, i32 %27 + %35 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %34) + %36 = ptrtoint ptr addrspace(1) %10 to i64 + %37 = inttoptr i64 %36 to ptr addrspace(1) + %38 = load i32, ptr addrspace(1) %37, align 4 + %39 = sdiv i32 %38, 32 + %40 = mul i32 %39, 32 + %41 = icmp ne i32 %38, %40 + %42 = icmp slt i32 %38, 0 + %43 = icmp ne i1 %42, false + %44 = and i1 %41, %43 + %45 = add i32 %39, -1 + %46 = select i1 %44, i32 %45, i32 %39 + %47 = mul i32 %46, 28 + %48 = icmp slt i32 %25, %47 + br i1 %48, label %49, label %984 + +49: ; preds = %19 + %50 = srem i32 %25, 28 + %51 = sdiv i32 %25, 28 + %52 = mul i32 %51, 28 + %53 = icmp ne i32 %25, %52 + %54 = icmp slt i32 %25, 0 + %55 = icmp ne i1 %54, false + %56 = and i1 %53, %55 + %57 = add i32 %51, -1 + %58 = select i1 %56, i32 %57, i32 %51 + %59 = mul i32 %58, 4 + %60 = ptrtoint ptr addrspace(1) %8 to i64 + %61 = sext i32 %59 to i64 + %62 = add i64 %60, %61 + %63 = inttoptr i64 %62 to ptr addrspace(1) + %64 = load i32, ptr addrspace(1) %63, align 4 + %65 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %64) + %66 = mul i32 %58, 32 + %67 = addrspacecast ptr addrspace(1) %0 to ptr + %68 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %67, i16 0, i64 167772160, i32 159744) + %69 = addrspacecast ptr addrspace(1) %2 to ptr + %70 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %69, i16 0, i64 10485760, i32 159744) + %71 = addrspacecast ptr addrspace(1) %4 to ptr + %72 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %71, i16 0, i64 706478080, i32 159744) + %73 = addrspacecast ptr addrspace(1) %6 to ptr + %74 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %73, i16 0, i64 44154880, i32 159744) + %75 = sdiv i32 %26, 8 + %76 = mul i32 %75, 8 + %77 = icmp ne i32 %26, %76 + %78 = icmp slt i32 %26, 0 + %79 = icmp ne i1 %78, false + %80 = and i1 %77, %79 + %81 = add i32 %75, -1 + %82 = select i1 %80, i32 %81, i32 %75 + %83 = srem i32 %26, 8 + %84 = sdiv i32 %26, 16 + %85 = mul i32 %84, 16 + %86 = icmp ne i32 %26, %85 + %87 = icmp slt i32 %26, 0 + %88 = icmp ne i1 %87, false + %89 = and i1 %86, %88 + %90 = add i32 %84, -1 + %91 = select i1 %89, i32 %90, i32 %84 + %92 = srem i32 %26, 16 + %93 = mul i32 %65, 7168 + %94 = mul i32 %50, 256 + %95 = add i32 %93, %94 + %96 = mul i32 %35, 64 + %97 = add i32 %95, %96 + %98 = mul i32 %97, 256 + %99 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %98) + %100 = add i32 %97, 16 + %101 = mul i32 %100, 256 + %102 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %101) + %103 = add i32 %97, 32 + %104 = mul i32 %103, 256 + %105 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %104) + %106 = add i32 %97, 48 + %107 = mul i32 %106, 256 + %108 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %107) + %109 = mul i32 %50, 8 + %110 = mul i32 %35, 2 + %111 = add i32 %109, %110 + %112 = mul i32 %65, 28672 + %113 = mul i32 %111, 128 + %114 = add i32 %112, %113 + %115 = mul i32 %114, 4 + %116 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %115) + %117 = add i32 %111, 1 + %118 = mul i32 %117, 128 + %119 = add i32 %112, %118 + %120 = mul i32 %119, 4 + %121 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %120) + %122 = sdiv i32 %66, 32 + %123 = mul i32 %122, 32 + %124 = icmp ne i32 %66, %123 + %125 = icmp slt i32 %66, 0 + %126 = icmp ne i1 %125, false + %127 = and i1 %124, %126 + %128 = add i32 %122, -1 + %129 = select i1 %127, i32 %128, i32 %122 + %130 = mul i32 %129, 512 + %131 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %130) + %132 = mul i32 %35, 8 + %133 = add i32 %66, %132 + %134 = add i32 %133, %82 + %135 = add i32 %132, %82 + %136 = and i32 %135, 14 + %137 = shl i32 %136, 3 + %138 = mul i32 %83, 16 + %139 = xor i32 %138, %137 + %140 = mul i32 %134, 256 + %141 = add i32 %139, %140 + %142 = mul i32 %35, 1024 + %143 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %142 + %144 = sext i32 %143 to i64 + %145 = inttoptr i64 %144 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %68, ptr addrspace(3) %145, i32 16, i32 %141, i32 0, i32 0, i32 0) + %146 = add i32 %142, 4096 + %147 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %146 + %148 = sext i32 %147 to i64 + %149 = inttoptr i64 %148 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %68, ptr addrspace(3) %149, i32 16, i32 %141, i32 128, i32 0, i32 0) + call void @llvm.amdgcn.sched.barrier(i32 0) + %150 = mul i32 %91, 16 + %151 = add i32 %150, %92 + %152 = mul i32 %151, 4 + %153 = sdiv i32 %152, 4 + %154 = mul i32 %153, 4 + %155 = icmp ne i32 %152, %154 + %156 = icmp slt i32 %152, 0 + %157 = icmp ne i1 %156, false + %158 = and i1 %155, %157 + %159 = add i32 %153, -1 + %160 = select i1 %158, i32 %159, i32 %153 + %161 = mul i32 %160, 4 + %162 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %70, i32 %161, i32 %131, i32 0) + %163 = add i32 %152, 256 + %164 = sdiv i32 %163, 4 + %165 = mul i32 %164, 4 + %166 = icmp ne i32 %163, %165 + %167 = icmp slt i32 %163, 0 + %168 = icmp ne i1 %167, false + %169 = and i1 %166, %168 + %170 = add i32 %164, -1 + %171 = select i1 %169, i32 %170, i32 %164 + %172 = mul i32 %171, 4 + %173 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %70, i32 %172, i32 %131, i32 0) + %174 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %161, i32 %116, i32 0) + %175 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %161, i32 %121, i32 0) + %176 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %172, i32 %116, i32 0) + %177 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %172, i32 %121, i32 0) + %178 = mul i32 %91, 256 + %179 = mul i32 %92, 16 + %180 = add i32 %178, %179 + %181 = sdiv i32 %180, 4 + %182 = mul i32 %181, 4 + %183 = icmp ne i32 %180, %182 + %184 = icmp slt i32 %180, 0 + %185 = icmp ne i1 %184, false + %186 = and i1 %183, %185 + %187 = add i32 %181, -1 + %188 = select i1 %186, i32 %187, i32 %181 + %189 = mul i32 %188, 4 + %190 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %99, i32 0) + %191 = add i32 %180, 1024 + %192 = sdiv i32 %191, 4 + %193 = mul i32 %192, 4 + %194 = icmp ne i32 %191, %193 + %195 = icmp slt i32 %191, 0 + %196 = icmp ne i1 %195, false + %197 = and i1 %194, %196 + %198 = add i32 %192, -1 + %199 = select i1 %197, i32 %198, i32 %192 + %200 = mul i32 %199, 4 + %201 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %99, i32 0) + %202 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %102, i32 0) + %203 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %102, i32 0) + %204 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %105, i32 0) + %205 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %105, i32 0) + %206 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %108, i32 0) + %207 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %108, i32 0) + %208 = add i32 %180, 2048 + %209 = sdiv i32 %208, 4 + %210 = mul i32 %209, 4 + %211 = icmp ne i32 %208, %210 + %212 = icmp slt i32 %208, 0 + %213 = icmp ne i1 %212, false + %214 = and i1 %211, %213 + %215 = add i32 %209, -1 + %216 = select i1 %214, i32 %215, i32 %209 + %217 = mul i32 %216, 4 + %218 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %99, i32 0) + %219 = add i32 %180, 3072 + %220 = sdiv i32 %219, 4 + %221 = mul i32 %220, 4 + %222 = icmp ne i32 %219, %221 + %223 = icmp slt i32 %219, 0 + %224 = icmp ne i1 %223, false + %225 = and i1 %222, %224 + %226 = add i32 %220, -1 + %227 = select i1 %225, i32 %226, i32 %220 + %228 = mul i32 %227, 4 + %229 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %99, i32 0) + %230 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %102, i32 0) + %231 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %102, i32 0) + %232 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %105, i32 0) + %233 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %105, i32 0) + %234 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %108, i32 0) + %235 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %108, i32 0) + call void asm sideeffect "s_waitcnt vmcnt(23)", ""() + call void asm sideeffect "s_barrier", ""() + %236 = and i32 %92, 14 + %237 = shl i32 %236, 3 + %238 = xor i32 %150, %237 + %239 = mul i32 %92, 128 + %240 = add i32 %239, %238 + %241 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %240 + %242 = sext i32 %241 to i64 + %243 = inttoptr i64 %242 to ptr addrspace(3) + %244 = load <4 x i32>, ptr addrspace(3) %243, align 16 + %245 = add i32 %92, 16 + %246 = mul i32 %245, 128 + %247 = add i32 %246, %238 + %248 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %247 + %249 = sext i32 %248 to i64 + %250 = inttoptr i64 %249 to ptr addrspace(3) + %251 = load <4 x i32>, ptr addrspace(3) %250, align 16 + %252 = add i32 %150, 64 + %253 = xor i32 %252, %237 + %254 = add i32 %239, %253 + %255 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %254 + %256 = sext i32 %255 to i64 + %257 = inttoptr i64 %256 to ptr addrspace(3) + %258 = load <4 x i32>, ptr addrspace(3) %257, align 16 + %259 = add i32 %246, %253 + %260 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %259 + %261 = sext i32 %260 to i64 + %262 = inttoptr i64 %261 to ptr addrspace(3) + %263 = load <4 x i32>, ptr addrspace(3) %262, align 16 + %264 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %190, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 0, i32 %174) + %265 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %190, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 0, i32 %174) + %266 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %201, <4 x float> %264, i32 4, i32 4, i32 2, i32 %162, i32 2, i32 %174) + %267 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %201, <4 x float> %265, i32 4, i32 4, i32 3, i32 %162, i32 2, i32 %174) + %268 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 1, i32 %174) + %269 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 1, i32 %174) + %270 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %203, <4 x float> %268, i32 4, i32 4, i32 2, i32 %162, i32 3, i32 %174) + %271 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %203, <4 x float> %269, i32 4, i32 4, i32 3, i32 %162, i32 3, i32 %174) + %272 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 0, i32 %175) + %273 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 0, i32 %175) + %274 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %205, <4 x float> %272, i32 4, i32 4, i32 2, i32 %162, i32 2, i32 %175) + %275 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %205, <4 x float> %273, i32 4, i32 4, i32 3, i32 %162, i32 2, i32 %175) + %276 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %206, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 1, i32 %175) + %277 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %206, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 1, i32 %175) + %278 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %207, <4 x float> %276, i32 4, i32 4, i32 2, i32 %162, i32 3, i32 %175) + %279 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %207, <4 x float> %277, i32 4, i32 4, i32 3, i32 %162, i32 3, i32 %175) + call void asm sideeffect "s_waitcnt vmcnt(22)", ""() + call void asm sideeffect "s_barrier", ""() + %280 = add i32 %239, 4096 + %281 = add i32 %280, %238 + %282 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %281 + %283 = sext i32 %282 to i64 + %284 = inttoptr i64 %283 to ptr addrspace(3) + %285 = load <4 x i32>, ptr addrspace(3) %284, align 16 + %286 = add i32 %246, 4096 + %287 = add i32 %286, %238 + %288 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %287 + %289 = sext i32 %288 to i64 + %290 = inttoptr i64 %289 to ptr addrspace(3) + %291 = load <4 x i32>, ptr addrspace(3) %290, align 16 + %292 = add i32 %280, %253 + %293 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %292 + %294 = sext i32 %293 to i64 + %295 = inttoptr i64 %294 to ptr addrspace(3) + %296 = load <4 x i32>, ptr addrspace(3) %295, align 16 + %297 = add i32 %286, %253 + %298 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %297 + %299 = sext i32 %298 to i64 + %300 = inttoptr i64 %299 to ptr addrspace(3) + %301 = load <4 x i32>, ptr addrspace(3) %300, align 16 + %302 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %218, <4 x float> %266, i32 4, i32 4, i32 0, i32 %173, i32 0, i32 %176) + %303 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %218, <4 x float> %267, i32 4, i32 4, i32 1, i32 %173, i32 0, i32 %176) + %304 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %229, <4 x float> %302, i32 4, i32 4, i32 2, i32 %173, i32 2, i32 %176) + %305 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %229, <4 x float> %303, i32 4, i32 4, i32 3, i32 %173, i32 2, i32 %176) + %306 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %230, <4 x float> %270, i32 4, i32 4, i32 0, i32 %173, i32 1, i32 %176) + %307 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %230, <4 x float> %271, i32 4, i32 4, i32 1, i32 %173, i32 1, i32 %176) + %308 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %231, <4 x float> %306, i32 4, i32 4, i32 2, i32 %173, i32 3, i32 %176) + %309 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %231, <4 x float> %307, i32 4, i32 4, i32 3, i32 %173, i32 3, i32 %176) + %310 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %232, <4 x float> %274, i32 4, i32 4, i32 0, i32 %173, i32 0, i32 %177) + %311 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %232, <4 x float> %275, i32 4, i32 4, i32 1, i32 %173, i32 0, i32 %177) + %312 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %233, <4 x float> %310, i32 4, i32 4, i32 2, i32 %173, i32 2, i32 %177) + %313 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %233, <4 x float> %311, i32 4, i32 4, i32 3, i32 %173, i32 2, i32 %177) + %314 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %234, <4 x float> %278, i32 4, i32 4, i32 0, i32 %173, i32 1, i32 %177) + %315 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %234, <4 x float> %279, i32 4, i32 4, i32 1, i32 %173, i32 1, i32 %177) + %316 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %235, <4 x float> %314, i32 4, i32 4, i32 2, i32 %173, i32 3, i32 %177) + %317 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %235, <4 x float> %315, i32 4, i32 4, i32 3, i32 %173, i32 3, i32 %177) + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %318 = mul i32 %91, 4 + %319 = add i32 %96, %92 + %320 = mul i32 %91, 1024 + %321 = add i32 %320, %319 + %322 = mul i32 %321, 4 + %323 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %322 + %324 = sext i32 %323 to i64 + %325 = inttoptr i64 %324 to ptr addrspace(3) + %326 = extractelement <4 x float> %304, i64 0 + store float %326, ptr addrspace(3) %325, align 4 + %327 = add i32 %318, 1 + %328 = mul i32 %327, 256 + %329 = add i32 %328, %319 + %330 = mul i32 %329, 4 + %331 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %330 + %332 = sext i32 %331 to i64 + %333 = inttoptr i64 %332 to ptr addrspace(3) + %334 = extractelement <4 x float> %304, i64 1 + store float %334, ptr addrspace(3) %333, align 4 + %335 = add i32 %318, 2 + %336 = mul i32 %335, 256 + %337 = add i32 %336, %319 + %338 = mul i32 %337, 4 + %339 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %338 + %340 = sext i32 %339 to i64 + %341 = inttoptr i64 %340 to ptr addrspace(3) + %342 = extractelement <4 x float> %304, i64 2 + store float %342, ptr addrspace(3) %341, align 4 + %343 = add i32 %318, 3 + %344 = mul i32 %343, 256 + %345 = add i32 %344, %319 + %346 = mul i32 %345, 4 + %347 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %346 + %348 = sext i32 %347 to i64 + %349 = inttoptr i64 %348 to ptr addrspace(3) + %350 = extractelement <4 x float> %304, i64 3 + store float %350, ptr addrspace(3) %349, align 4 + %351 = add i32 %96, 16 + %352 = add i32 %351, %92 + %353 = add i32 %320, %352 + %354 = mul i32 %353, 4 + %355 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %354 + %356 = sext i32 %355 to i64 + %357 = inttoptr i64 %356 to ptr addrspace(3) + %358 = extractelement <4 x float> %308, i64 0 + store float %358, ptr addrspace(3) %357, align 4 + %359 = add i32 %328, %352 + %360 = mul i32 %359, 4 + %361 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %360 + %362 = sext i32 %361 to i64 + %363 = inttoptr i64 %362 to ptr addrspace(3) + %364 = extractelement <4 x float> %308, i64 1 + store float %364, ptr addrspace(3) %363, align 4 + %365 = add i32 %336, %352 + %366 = mul i32 %365, 4 + %367 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %366 + %368 = sext i32 %367 to i64 + %369 = inttoptr i64 %368 to ptr addrspace(3) + %370 = extractelement <4 x float> %308, i64 2 + store float %370, ptr addrspace(3) %369, align 4 + %371 = add i32 %344, %352 + %372 = mul i32 %371, 4 + %373 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %372 + %374 = sext i32 %373 to i64 + %375 = inttoptr i64 %374 to ptr addrspace(3) + %376 = extractelement <4 x float> %308, i64 3 + store float %376, ptr addrspace(3) %375, align 4 + %377 = add i32 %96, 32 + %378 = add i32 %377, %92 + %379 = add i32 %320, %378 + %380 = mul i32 %379, 4 + %381 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %380 + %382 = sext i32 %381 to i64 + %383 = inttoptr i64 %382 to ptr addrspace(3) + %384 = extractelement <4 x float> %312, i64 0 + store float %384, ptr addrspace(3) %383, align 4 + %385 = add i32 %328, %378 + %386 = mul i32 %385, 4 + %387 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %386 + %388 = sext i32 %387 to i64 + %389 = inttoptr i64 %388 to ptr addrspace(3) + %390 = extractelement <4 x float> %312, i64 1 + store float %390, ptr addrspace(3) %389, align 4 + %391 = add i32 %336, %378 + %392 = mul i32 %391, 4 + %393 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %392 + %394 = sext i32 %393 to i64 + %395 = inttoptr i64 %394 to ptr addrspace(3) + %396 = extractelement <4 x float> %312, i64 2 + store float %396, ptr addrspace(3) %395, align 4 + %397 = add i32 %344, %378 + %398 = mul i32 %397, 4 + %399 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %398 + %400 = sext i32 %399 to i64 + %401 = inttoptr i64 %400 to ptr addrspace(3) + %402 = extractelement <4 x float> %312, i64 3 + store float %402, ptr addrspace(3) %401, align 4 + %403 = add i32 %96, 48 + %404 = add i32 %403, %92 + %405 = add i32 %320, %404 + %406 = mul i32 %405, 4 + %407 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %406 + %408 = sext i32 %407 to i64 + %409 = inttoptr i64 %408 to ptr addrspace(3) + %410 = extractelement <4 x float> %316, i64 0 + store float %410, ptr addrspace(3) %409, align 4 + %411 = add i32 %328, %404 + %412 = mul i32 %411, 4 + %413 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %412 + %414 = sext i32 %413 to i64 + %415 = inttoptr i64 %414 to ptr addrspace(3) + %416 = extractelement <4 x float> %316, i64 1 + store float %416, ptr addrspace(3) %415, align 4 + %417 = add i32 %336, %404 + %418 = mul i32 %417, 4 + %419 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %418 + %420 = sext i32 %419 to i64 + %421 = inttoptr i64 %420 to ptr addrspace(3) + %422 = extractelement <4 x float> %316, i64 2 + store float %422, ptr addrspace(3) %421, align 4 + %423 = add i32 %344, %404 + %424 = mul i32 %423, 4 + %425 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %424 + %426 = sext i32 %425 to i64 + %427 = inttoptr i64 %426 to ptr addrspace(3) + %428 = extractelement <4 x float> %316, i64 3 + store float %428, ptr addrspace(3) %427, align 4 + %429 = add i32 %318, 16 + %430 = mul i32 %429, 256 + %431 = add i32 %430, %319 + %432 = mul i32 %431, 4 + %433 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %432 + %434 = sext i32 %433 to i64 + %435 = inttoptr i64 %434 to ptr addrspace(3) + %436 = extractelement <4 x float> %305, i64 0 + store float %436, ptr addrspace(3) %435, align 4 + %437 = add i32 %318, 17 + %438 = mul i32 %437, 256 + %439 = add i32 %438, %319 + %440 = mul i32 %439, 4 + %441 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %440 + %442 = sext i32 %441 to i64 + %443 = inttoptr i64 %442 to ptr addrspace(3) + %444 = extractelement <4 x float> %305, i64 1 + store float %444, ptr addrspace(3) %443, align 4 + %445 = add i32 %318, 18 + %446 = mul i32 %445, 256 + %447 = add i32 %446, %319 + %448 = mul i32 %447, 4 + %449 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %448 + %450 = sext i32 %449 to i64 + %451 = inttoptr i64 %450 to ptr addrspace(3) + %452 = extractelement <4 x float> %305, i64 2 + store float %452, ptr addrspace(3) %451, align 4 + %453 = add i32 %318, 19 + %454 = mul i32 %453, 256 + %455 = add i32 %454, %319 + %456 = mul i32 %455, 4 + %457 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %456 + %458 = sext i32 %457 to i64 + %459 = inttoptr i64 %458 to ptr addrspace(3) + %460 = extractelement <4 x float> %305, i64 3 + store float %460, ptr addrspace(3) %459, align 4 + %461 = add i32 %430, %352 + %462 = mul i32 %461, 4 + %463 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %462 + %464 = sext i32 %463 to i64 + %465 = inttoptr i64 %464 to ptr addrspace(3) + %466 = extractelement <4 x float> %309, i64 0 + store float %466, ptr addrspace(3) %465, align 4 + %467 = add i32 %438, %352 + %468 = mul i32 %467, 4 + %469 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %468 + %470 = sext i32 %469 to i64 + %471 = inttoptr i64 %470 to ptr addrspace(3) + %472 = extractelement <4 x float> %309, i64 1 + store float %472, ptr addrspace(3) %471, align 4 + %473 = add i32 %446, %352 + %474 = mul i32 %473, 4 + %475 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %474 + %476 = sext i32 %475 to i64 + %477 = inttoptr i64 %476 to ptr addrspace(3) + %478 = extractelement <4 x float> %309, i64 2 + store float %478, ptr addrspace(3) %477, align 4 + %479 = add i32 %454, %352 + %480 = mul i32 %479, 4 + %481 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %480 + %482 = sext i32 %481 to i64 + %483 = inttoptr i64 %482 to ptr addrspace(3) + %484 = extractelement <4 x float> %309, i64 3 + store float %484, ptr addrspace(3) %483, align 4 + %485 = add i32 %430, %378 + %486 = mul i32 %485, 4 + %487 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %486 + %488 = sext i32 %487 to i64 + %489 = inttoptr i64 %488 to ptr addrspace(3) + %490 = extractelement <4 x float> %313, i64 0 + store float %490, ptr addrspace(3) %489, align 4 + %491 = add i32 %438, %378 + %492 = mul i32 %491, 4 + %493 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %492 + %494 = sext i32 %493 to i64 + %495 = inttoptr i64 %494 to ptr addrspace(3) + %496 = extractelement <4 x float> %313, i64 1 + store float %496, ptr addrspace(3) %495, align 4 + %497 = add i32 %446, %378 + %498 = mul i32 %497, 4 + %499 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %498 + %500 = sext i32 %499 to i64 + %501 = inttoptr i64 %500 to ptr addrspace(3) + %502 = extractelement <4 x float> %313, i64 2 + store float %502, ptr addrspace(3) %501, align 4 + %503 = add i32 %454, %378 + %504 = mul i32 %503, 4 + %505 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %504 + %506 = sext i32 %505 to i64 + %507 = inttoptr i64 %506 to ptr addrspace(3) + %508 = extractelement <4 x float> %313, i64 3 + store float %508, ptr addrspace(3) %507, align 4 + %509 = add i32 %430, %404 + %510 = mul i32 %509, 4 + %511 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %510 + %512 = sext i32 %511 to i64 + %513 = inttoptr i64 %512 to ptr addrspace(3) + %514 = extractelement <4 x float> %317, i64 0 + store float %514, ptr addrspace(3) %513, align 4 + %515 = add i32 %438, %404 + %516 = mul i32 %515, 4 + %517 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %516 + %518 = sext i32 %517 to i64 + %519 = inttoptr i64 %518 to ptr addrspace(3) + %520 = extractelement <4 x float> %317, i64 1 + store float %520, ptr addrspace(3) %519, align 4 + %521 = add i32 %446, %404 + %522 = mul i32 %521, 4 + %523 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %522 + %524 = sext i32 %523 to i64 + %525 = inttoptr i64 %524 to ptr addrspace(3) + %526 = extractelement <4 x float> %317, i64 2 + store float %526, ptr addrspace(3) %525, align 4 + %527 = add i32 %454, %404 + %528 = mul i32 %527, 4 + %529 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %528 + %530 = sext i32 %529 to i64 + %531 = inttoptr i64 %530 to ptr addrspace(3) + %532 = extractelement <4 x float> %317, i64 3 + store float %532, ptr addrspace(3) %531, align 4 + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %533 = sdiv i32 %24, 32 + %534 = mul i32 %533, 32 + %535 = icmp ne i32 %24, %534 + %536 = icmp slt i32 %24, 0 + %537 = icmp ne i1 %536, false + %538 = and i1 %535, %537 + %539 = add i32 %533, -1 + %540 = select i1 %538, i32 %539, i32 %533 + %541 = srem i32 %24, 32 + %542 = mul i32 %541, 2 + %543 = add i32 %66, %540 + %544 = mul i32 %543, 4 + %545 = ptrtoint ptr addrspace(1) %12 to i64 + %546 = sext i32 %544 to i64 + %547 = add i64 %545, %546 + %548 = inttoptr i64 %547 to ptr addrspace(1) + %549 = load i32, ptr addrspace(1) %548, align 4 + %550 = and i32 %549, 16777215 + %551 = icmp slt i32 %550, %16 + %552 = ptrtoint ptr addrspace(1) %14 to i64 + %553 = add i64 %552, %546 + %554 = inttoptr i64 %553 to ptr addrspace(1) + %555 = load float, ptr addrspace(1) %554, align 4 + br i1 %551, label %556, label %653 + +556: ; preds = %49 + %557 = mul i32 %550, 7168 + %558 = add i32 %557, %94 + %559 = add i32 %558, %542 + %560 = mul i32 %540, 256 + %561 = add i32 %560, %542 + %562 = mul i32 %561, 4 + %563 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %562 + %564 = sext i32 %563 to i64 + %565 = inttoptr i64 %564 to ptr addrspace(3) + %566 = load float, ptr addrspace(3) %565, align 4 + %567 = fmul float %566, %555 + %568 = add i32 %561, 1 + %569 = mul i32 %568, 4 + %570 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %569 + %571 = sext i32 %570 to i64 + %572 = inttoptr i64 %571 to ptr addrspace(3) + %573 = load float, ptr addrspace(3) %572, align 4 + %574 = fmul float %573, %555 + %575 = insertelement <2 x float> poison, float %567, i64 0 + %576 = insertelement <2 x float> %575, float %574, i64 1 + %577 = fptrunc <2 x float> %576 to <2 x bfloat> + %578 = mul i32 %559, 2 + %579 = ptrtoint ptr addrspace(1) %17 to i64 + %580 = sext i32 %578 to i64 + %581 = add i64 %579, %580 + %582 = inttoptr i64 %581 to ptr addrspace(1) + %583 = atomicrmw fadd ptr addrspace(1) %582, <2 x bfloat> %577 syncscope("agent") monotonic, align 4 + %584 = add i32 %561, 64 + %585 = mul i32 %584, 4 + %586 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %585 + %587 = sext i32 %586 to i64 + %588 = inttoptr i64 %587 to ptr addrspace(3) + %589 = load float, ptr addrspace(3) %588, align 4 + %590 = fmul float %589, %555 + %591 = add i32 %561, 65 + %592 = mul i32 %591, 4 + %593 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %592 + %594 = sext i32 %593 to i64 + %595 = inttoptr i64 %594 to ptr addrspace(3) + %596 = load float, ptr addrspace(3) %595, align 4 + %597 = fmul float %596, %555 + %598 = insertelement <2 x float> poison, float %590, i64 0 + %599 = insertelement <2 x float> %598, float %597, i64 1 + %600 = fptrunc <2 x float> %599 to <2 x bfloat> + %601 = add i32 %559, 64 + %602 = mul i32 %601, 2 + %603 = sext i32 %602 to i64 + %604 = add i64 %579, %603 + %605 = inttoptr i64 %604 to ptr addrspace(1) + %606 = atomicrmw fadd ptr addrspace(1) %605, <2 x bfloat> %600 syncscope("agent") monotonic, align 4 + %607 = add i32 %561, 128 + %608 = mul i32 %607, 4 + %609 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %608 + %610 = sext i32 %609 to i64 + %611 = inttoptr i64 %610 to ptr addrspace(3) + %612 = load float, ptr addrspace(3) %611, align 4 + %613 = fmul float %612, %555 + %614 = add i32 %561, 129 + %615 = mul i32 %614, 4 + %616 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %615 + %617 = sext i32 %616 to i64 + %618 = inttoptr i64 %617 to ptr addrspace(3) + %619 = load float, ptr addrspace(3) %618, align 4 + %620 = fmul float %619, %555 + %621 = insertelement <2 x float> poison, float %613, i64 0 + %622 = insertelement <2 x float> %621, float %620, i64 1 + %623 = fptrunc <2 x float> %622 to <2 x bfloat> + %624 = add i32 %559, 128 + %625 = mul i32 %624, 2 + %626 = sext i32 %625 to i64 + %627 = add i64 %579, %626 + %628 = inttoptr i64 %627 to ptr addrspace(1) + %629 = atomicrmw fadd ptr addrspace(1) %628, <2 x bfloat> %623 syncscope("agent") monotonic, align 4 + %630 = add i32 %561, 192 + %631 = mul i32 %630, 4 + %632 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %631 + %633 = sext i32 %632 to i64 + %634 = inttoptr i64 %633 to ptr addrspace(3) + %635 = load float, ptr addrspace(3) %634, align 4 + %636 = fmul float %635, %555 + %637 = add i32 %561, 193 + %638 = mul i32 %637, 4 + %639 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %638 + %640 = sext i32 %639 to i64 + %641 = inttoptr i64 %640 to ptr addrspace(3) + %642 = load float, ptr addrspace(3) %641, align 4 + %643 = fmul float %642, %555 + %644 = insertelement <2 x float> poison, float %636, i64 0 + %645 = insertelement <2 x float> %644, float %643, i64 1 + %646 = fptrunc <2 x float> %645 to <2 x bfloat> + %647 = add i32 %559, 192 + %648 = mul i32 %647, 2 + %649 = sext i32 %648 to i64 + %650 = add i64 %579, %649 + %651 = inttoptr i64 %650 to ptr addrspace(1) + %652 = atomicrmw fadd ptr addrspace(1) %651, <2 x bfloat> %646 syncscope("agent") monotonic, align 4 + br label %653 + +653: ; preds = %556, %49 + %654 = add i32 %540, 8 + %655 = add i32 %66, %654 + %656 = mul i32 %655, 4 + %657 = sext i32 %656 to i64 + %658 = add i64 %545, %657 + %659 = inttoptr i64 %658 to ptr addrspace(1) + %660 = load i32, ptr addrspace(1) %659, align 4 + %661 = and i32 %660, 16777215 + %662 = icmp slt i32 %661, %16 + %663 = add i64 %552, %657 + %664 = inttoptr i64 %663 to ptr addrspace(1) + %665 = load float, ptr addrspace(1) %664, align 4 + br i1 %662, label %666, label %763 + +666: ; preds = %653 + %667 = mul i32 %661, 7168 + %668 = add i32 %667, %94 + %669 = add i32 %668, %542 + %670 = mul i32 %654, 256 + %671 = add i32 %670, %542 + %672 = mul i32 %671, 4 + %673 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %672 + %674 = sext i32 %673 to i64 + %675 = inttoptr i64 %674 to ptr addrspace(3) + %676 = load float, ptr addrspace(3) %675, align 4 + %677 = fmul float %676, %665 + %678 = add i32 %671, 1 + %679 = mul i32 %678, 4 + %680 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %679 + %681 = sext i32 %680 to i64 + %682 = inttoptr i64 %681 to ptr addrspace(3) + %683 = load float, ptr addrspace(3) %682, align 4 + %684 = fmul float %683, %665 + %685 = insertelement <2 x float> poison, float %677, i64 0 + %686 = insertelement <2 x float> %685, float %684, i64 1 + %687 = fptrunc <2 x float> %686 to <2 x bfloat> + %688 = mul i32 %669, 2 + %689 = ptrtoint ptr addrspace(1) %17 to i64 + %690 = sext i32 %688 to i64 + %691 = add i64 %689, %690 + %692 = inttoptr i64 %691 to ptr addrspace(1) + %693 = atomicrmw fadd ptr addrspace(1) %692, <2 x bfloat> %687 syncscope("agent") monotonic, align 4 + %694 = add i32 %671, 64 + %695 = mul i32 %694, 4 + %696 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %695 + %697 = sext i32 %696 to i64 + %698 = inttoptr i64 %697 to ptr addrspace(3) + %699 = load float, ptr addrspace(3) %698, align 4 + %700 = fmul float %699, %665 + %701 = add i32 %671, 65 + %702 = mul i32 %701, 4 + %703 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %702 + %704 = sext i32 %703 to i64 + %705 = inttoptr i64 %704 to ptr addrspace(3) + %706 = load float, ptr addrspace(3) %705, align 4 + %707 = fmul float %706, %665 + %708 = insertelement <2 x float> poison, float %700, i64 0 + %709 = insertelement <2 x float> %708, float %707, i64 1 + %710 = fptrunc <2 x float> %709 to <2 x bfloat> + %711 = add i32 %669, 64 + %712 = mul i32 %711, 2 + %713 = sext i32 %712 to i64 + %714 = add i64 %689, %713 + %715 = inttoptr i64 %714 to ptr addrspace(1) + %716 = atomicrmw fadd ptr addrspace(1) %715, <2 x bfloat> %710 syncscope("agent") monotonic, align 4 + %717 = add i32 %671, 128 + %718 = mul i32 %717, 4 + %719 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %718 + %720 = sext i32 %719 to i64 + %721 = inttoptr i64 %720 to ptr addrspace(3) + %722 = load float, ptr addrspace(3) %721, align 4 + %723 = fmul float %722, %665 + %724 = add i32 %671, 129 + %725 = mul i32 %724, 4 + %726 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %725 + %727 = sext i32 %726 to i64 + %728 = inttoptr i64 %727 to ptr addrspace(3) + %729 = load float, ptr addrspace(3) %728, align 4 + %730 = fmul float %729, %665 + %731 = insertelement <2 x float> poison, float %723, i64 0 + %732 = insertelement <2 x float> %731, float %730, i64 1 + %733 = fptrunc <2 x float> %732 to <2 x bfloat> + %734 = add i32 %669, 128 + %735 = mul i32 %734, 2 + %736 = sext i32 %735 to i64 + %737 = add i64 %689, %736 + %738 = inttoptr i64 %737 to ptr addrspace(1) + %739 = atomicrmw fadd ptr addrspace(1) %738, <2 x bfloat> %733 syncscope("agent") monotonic, align 4 + %740 = add i32 %671, 192 + %741 = mul i32 %740, 4 + %742 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %741 + %743 = sext i32 %742 to i64 + %744 = inttoptr i64 %743 to ptr addrspace(3) + %745 = load float, ptr addrspace(3) %744, align 4 + %746 = fmul float %745, %665 + %747 = add i32 %671, 193 + %748 = mul i32 %747, 4 + %749 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %748 + %750 = sext i32 %749 to i64 + %751 = inttoptr i64 %750 to ptr addrspace(3) + %752 = load float, ptr addrspace(3) %751, align 4 + %753 = fmul float %752, %665 + %754 = insertelement <2 x float> poison, float %746, i64 0 + %755 = insertelement <2 x float> %754, float %753, i64 1 + %756 = fptrunc <2 x float> %755 to <2 x bfloat> + %757 = add i32 %669, 192 + %758 = mul i32 %757, 2 + %759 = sext i32 %758 to i64 + %760 = add i64 %689, %759 + %761 = inttoptr i64 %760 to ptr addrspace(1) + %762 = atomicrmw fadd ptr addrspace(1) %761, <2 x bfloat> %756 syncscope("agent") monotonic, align 4 + br label %763 + +763: ; preds = %666, %653 + %764 = add i32 %540, 16 + %765 = add i32 %66, %764 + %766 = mul i32 %765, 4 + %767 = sext i32 %766 to i64 + %768 = add i64 %545, %767 + %769 = inttoptr i64 %768 to ptr addrspace(1) + %770 = load i32, ptr addrspace(1) %769, align 4 + %771 = and i32 %770, 16777215 + %772 = icmp slt i32 %771, %16 + %773 = add i64 %552, %767 + %774 = inttoptr i64 %773 to ptr addrspace(1) + %775 = load float, ptr addrspace(1) %774, align 4 + br i1 %772, label %776, label %873 + +776: ; preds = %763 + %777 = mul i32 %771, 7168 + %778 = add i32 %777, %94 + %779 = add i32 %778, %542 + %780 = mul i32 %764, 256 + %781 = add i32 %780, %542 + %782 = mul i32 %781, 4 + %783 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %782 + %784 = sext i32 %783 to i64 + %785 = inttoptr i64 %784 to ptr addrspace(3) + %786 = load float, ptr addrspace(3) %785, align 4 + %787 = fmul float %786, %775 + %788 = add i32 %781, 1 + %789 = mul i32 %788, 4 + %790 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %789 + %791 = sext i32 %790 to i64 + %792 = inttoptr i64 %791 to ptr addrspace(3) + %793 = load float, ptr addrspace(3) %792, align 4 + %794 = fmul float %793, %775 + %795 = insertelement <2 x float> poison, float %787, i64 0 + %796 = insertelement <2 x float> %795, float %794, i64 1 + %797 = fptrunc <2 x float> %796 to <2 x bfloat> + %798 = mul i32 %779, 2 + %799 = ptrtoint ptr addrspace(1) %17 to i64 + %800 = sext i32 %798 to i64 + %801 = add i64 %799, %800 + %802 = inttoptr i64 %801 to ptr addrspace(1) + %803 = atomicrmw fadd ptr addrspace(1) %802, <2 x bfloat> %797 syncscope("agent") monotonic, align 4 + %804 = add i32 %781, 64 + %805 = mul i32 %804, 4 + %806 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %805 + %807 = sext i32 %806 to i64 + %808 = inttoptr i64 %807 to ptr addrspace(3) + %809 = load float, ptr addrspace(3) %808, align 4 + %810 = fmul float %809, %775 + %811 = add i32 %781, 65 + %812 = mul i32 %811, 4 + %813 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %812 + %814 = sext i32 %813 to i64 + %815 = inttoptr i64 %814 to ptr addrspace(3) + %816 = load float, ptr addrspace(3) %815, align 4 + %817 = fmul float %816, %775 + %818 = insertelement <2 x float> poison, float %810, i64 0 + %819 = insertelement <2 x float> %818, float %817, i64 1 + %820 = fptrunc <2 x float> %819 to <2 x bfloat> + %821 = add i32 %779, 64 + %822 = mul i32 %821, 2 + %823 = sext i32 %822 to i64 + %824 = add i64 %799, %823 + %825 = inttoptr i64 %824 to ptr addrspace(1) + %826 = atomicrmw fadd ptr addrspace(1) %825, <2 x bfloat> %820 syncscope("agent") monotonic, align 4 + %827 = add i32 %781, 128 + %828 = mul i32 %827, 4 + %829 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %828 + %830 = sext i32 %829 to i64 + %831 = inttoptr i64 %830 to ptr addrspace(3) + %832 = load float, ptr addrspace(3) %831, align 4 + %833 = fmul float %832, %775 + %834 = add i32 %781, 129 + %835 = mul i32 %834, 4 + %836 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %835 + %837 = sext i32 %836 to i64 + %838 = inttoptr i64 %837 to ptr addrspace(3) + %839 = load float, ptr addrspace(3) %838, align 4 + %840 = fmul float %839, %775 + %841 = insertelement <2 x float> poison, float %833, i64 0 + %842 = insertelement <2 x float> %841, float %840, i64 1 + %843 = fptrunc <2 x float> %842 to <2 x bfloat> + %844 = add i32 %779, 128 + %845 = mul i32 %844, 2 + %846 = sext i32 %845 to i64 + %847 = add i64 %799, %846 + %848 = inttoptr i64 %847 to ptr addrspace(1) + %849 = atomicrmw fadd ptr addrspace(1) %848, <2 x bfloat> %843 syncscope("agent") monotonic, align 4 + %850 = add i32 %781, 192 + %851 = mul i32 %850, 4 + %852 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %851 + %853 = sext i32 %852 to i64 + %854 = inttoptr i64 %853 to ptr addrspace(3) + %855 = load float, ptr addrspace(3) %854, align 4 + %856 = fmul float %855, %775 + %857 = add i32 %781, 193 + %858 = mul i32 %857, 4 + %859 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %858 + %860 = sext i32 %859 to i64 + %861 = inttoptr i64 %860 to ptr addrspace(3) + %862 = load float, ptr addrspace(3) %861, align 4 + %863 = fmul float %862, %775 + %864 = insertelement <2 x float> poison, float %856, i64 0 + %865 = insertelement <2 x float> %864, float %863, i64 1 + %866 = fptrunc <2 x float> %865 to <2 x bfloat> + %867 = add i32 %779, 192 + %868 = mul i32 %867, 2 + %869 = sext i32 %868 to i64 + %870 = add i64 %799, %869 + %871 = inttoptr i64 %870 to ptr addrspace(1) + %872 = atomicrmw fadd ptr addrspace(1) %871, <2 x bfloat> %866 syncscope("agent") monotonic, align 4 + br label %873 + +873: ; preds = %776, %763 + %874 = add i32 %540, 24 + %875 = add i32 %66, %874 + %876 = mul i32 %875, 4 + %877 = sext i32 %876 to i64 + %878 = add i64 %545, %877 + %879 = inttoptr i64 %878 to ptr addrspace(1) + %880 = load i32, ptr addrspace(1) %879, align 4 + %881 = and i32 %880, 16777215 + %882 = icmp slt i32 %881, %16 + %883 = add i64 %552, %877 + %884 = inttoptr i64 %883 to ptr addrspace(1) + %885 = load float, ptr addrspace(1) %884, align 4 + br i1 %882, label %886, label %983 + +886: ; preds = %873 + %887 = mul i32 %881, 7168 + %888 = add i32 %887, %94 + %889 = add i32 %888, %542 + %890 = mul i32 %874, 256 + %891 = add i32 %890, %542 + %892 = mul i32 %891, 4 + %893 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %892 + %894 = sext i32 %893 to i64 + %895 = inttoptr i64 %894 to ptr addrspace(3) + %896 = load float, ptr addrspace(3) %895, align 4 + %897 = fmul float %896, %885 + %898 = add i32 %891, 1 + %899 = mul i32 %898, 4 + %900 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %899 + %901 = sext i32 %900 to i64 + %902 = inttoptr i64 %901 to ptr addrspace(3) + %903 = load float, ptr addrspace(3) %902, align 4 + %904 = fmul float %903, %885 + %905 = insertelement <2 x float> poison, float %897, i64 0 + %906 = insertelement <2 x float> %905, float %904, i64 1 + %907 = fptrunc <2 x float> %906 to <2 x bfloat> + %908 = mul i32 %889, 2 + %909 = ptrtoint ptr addrspace(1) %17 to i64 + %910 = sext i32 %908 to i64 + %911 = add i64 %909, %910 + %912 = inttoptr i64 %911 to ptr addrspace(1) + %913 = atomicrmw fadd ptr addrspace(1) %912, <2 x bfloat> %907 syncscope("agent") monotonic, align 4 + %914 = add i32 %891, 64 + %915 = mul i32 %914, 4 + %916 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %915 + %917 = sext i32 %916 to i64 + %918 = inttoptr i64 %917 to ptr addrspace(3) + %919 = load float, ptr addrspace(3) %918, align 4 + %920 = fmul float %919, %885 + %921 = add i32 %891, 65 + %922 = mul i32 %921, 4 + %923 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %922 + %924 = sext i32 %923 to i64 + %925 = inttoptr i64 %924 to ptr addrspace(3) + %926 = load float, ptr addrspace(3) %925, align 4 + %927 = fmul float %926, %885 + %928 = insertelement <2 x float> poison, float %920, i64 0 + %929 = insertelement <2 x float> %928, float %927, i64 1 + %930 = fptrunc <2 x float> %929 to <2 x bfloat> + %931 = add i32 %889, 64 + %932 = mul i32 %931, 2 + %933 = sext i32 %932 to i64 + %934 = add i64 %909, %933 + %935 = inttoptr i64 %934 to ptr addrspace(1) + %936 = atomicrmw fadd ptr addrspace(1) %935, <2 x bfloat> %930 syncscope("agent") monotonic, align 4 + %937 = add i32 %891, 128 + %938 = mul i32 %937, 4 + %939 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %938 + %940 = sext i32 %939 to i64 + %941 = inttoptr i64 %940 to ptr addrspace(3) + %942 = load float, ptr addrspace(3) %941, align 4 + %943 = fmul float %942, %885 + %944 = add i32 %891, 129 + %945 = mul i32 %944, 4 + %946 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %945 + %947 = sext i32 %946 to i64 + %948 = inttoptr i64 %947 to ptr addrspace(3) + %949 = load float, ptr addrspace(3) %948, align 4 + %950 = fmul float %949, %885 + %951 = insertelement <2 x float> poison, float %943, i64 0 + %952 = insertelement <2 x float> %951, float %950, i64 1 + %953 = fptrunc <2 x float> %952 to <2 x bfloat> + %954 = add i32 %889, 128 + %955 = mul i32 %954, 2 + %956 = sext i32 %955 to i64 + %957 = add i64 %909, %956 + %958 = inttoptr i64 %957 to ptr addrspace(1) + %959 = atomicrmw fadd ptr addrspace(1) %958, <2 x bfloat> %953 syncscope("agent") monotonic, align 4 + %960 = add i32 %891, 192 + %961 = mul i32 %960, 4 + %962 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %961 + %963 = sext i32 %962 to i64 + %964 = inttoptr i64 %963 to ptr addrspace(3) + %965 = load float, ptr addrspace(3) %964, align 4 + %966 = fmul float %965, %885 + %967 = add i32 %891, 193 + %968 = mul i32 %967, 4 + %969 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %968 + %970 = sext i32 %969 to i64 + %971 = inttoptr i64 %970 to ptr addrspace(3) + %972 = load float, ptr addrspace(3) %971, align 4 + %973 = fmul float %972, %885 + %974 = insertelement <2 x float> poison, float %966, i64 0 + %975 = insertelement <2 x float> %974, float %973, i64 1 + %976 = fptrunc <2 x float> %975 to <2 x bfloat> + %977 = add i32 %889, 192 + %978 = mul i32 %977, 2 + %979 = sext i32 %978 to i64 + %980 = add i64 %909, %979 + %981 = inttoptr i64 %980 to ptr addrspace(1) + %982 = atomicrmw fadd ptr addrspace(1) %981, <2 x bfloat> %976 syncscope("agent") monotonic, align 4 + br label %983 + +983: ; preds = %886, %873 + br label %984 + +984: ; preds = %983, %19 + ret void +} + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) +declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 + +; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) +declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #3 + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #4 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.sched.barrier(i32 immarg) #5 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) +declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #7 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.s.barrier() #5 + +attributes #0 = { "amdgpu-flat-work-group-size"="256,256" "uniform-work-group-size" } +attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } +attributes #2 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } +attributes #3 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } +attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } +attributes #5 = { convergent nocallback nofree nounwind willreturn } +attributes #6 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } +attributes #7 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = !{i32 256, i32 1, i32 1} diff --git a/kernels/gemm2_port_ref/flydsl_port_v4.ll b/kernels/gemm2_port_ref/flydsl_port_v4.ll new file mode 100644 index 000000000..7d427907f --- /dev/null +++ b/kernels/gemm2_port_ref/flydsl_port_v4.ll @@ -0,0 +1,943 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" +target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" + +@gemm2port_smem = external addrspace(3) global [32768 x i8], align 1024 + +define amdgpu_kernel void @gemm2_a4w4_port_bm32_atomic(ptr addrspace(1) %0, <{ <{ i32, i32 }>, <{ i64 }> }> %1, ptr addrspace(1) %2, <{ <{ i32, i32 }>, <{ i64 }> }> %3, ptr addrspace(1) %4, <{ <{ i32, i32, i32 }>, <{ i64, i64 }> }> %5, ptr addrspace(1) %6, <{ <{ i32, i32 }>, <{ i64 }> }> %7, ptr addrspace(1) %8, <{ <{ i32 }> }> %9, ptr addrspace(1) %10, <{ <{ i32 }> }> %11, ptr addrspace(1) %12, <{ <{ i32 }> }> %13, ptr addrspace(1) %14, <{ <{ i32 }> }> %15, i32 %16, ptr addrspace(1) %17, <{ <{ i32, i32 }>, <{ i64 }> }> %18) #0 !reqd_work_group_size !1 { + %20 = call range(i32 0, 256) i32 @llvm.amdgcn.workitem.id.x() + %21 = sext i32 %20 to i64 + %22 = call i32 @llvm.amdgcn.workgroup.id.x() + %23 = sext i32 %22 to i64 + %24 = trunc i64 %21 to i32 + %25 = trunc i64 %23 to i32 + %26 = srem i32 %24, 64 + %27 = sdiv i32 %24, 64 + %28 = mul i32 %27, 64 + %29 = icmp ne i32 %24, %28 + %30 = icmp slt i32 %24, 0 + %31 = icmp ne i1 %30, false + %32 = and i1 %29, %31 + %33 = add i32 %27, -1 + %34 = select i1 %32, i32 %33, i32 %27 + %35 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %34) + %36 = ptrtoint ptr addrspace(1) %10 to i64 + %37 = inttoptr i64 %36 to ptr addrspace(1) + %38 = load i32, ptr addrspace(1) %37, align 4 + %39 = sdiv i32 %38, 32 + %40 = mul i32 %39, 32 + %41 = icmp ne i32 %38, %40 + %42 = icmp slt i32 %38, 0 + %43 = icmp ne i1 %42, false + %44 = and i1 %41, %43 + %45 = add i32 %39, -1 + %46 = select i1 %44, i32 %45, i32 %39 + %47 = mul i32 %46, 28 + %48 = icmp slt i32 %25, %47 + br i1 %48, label %49, label %844 + +49: ; preds = %19 + %50 = srem i32 %25, 28 + %51 = sdiv i32 %25, 28 + %52 = mul i32 %51, 28 + %53 = icmp ne i32 %25, %52 + %54 = icmp slt i32 %25, 0 + %55 = icmp ne i1 %54, false + %56 = and i1 %53, %55 + %57 = add i32 %51, -1 + %58 = select i1 %56, i32 %57, i32 %51 + %59 = mul i32 %58, 4 + %60 = ptrtoint ptr addrspace(1) %8 to i64 + %61 = sext i32 %59 to i64 + %62 = add i64 %60, %61 + %63 = inttoptr i64 %62 to ptr addrspace(1) + %64 = load i32, ptr addrspace(1) %63, align 4 + %65 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %64) + %66 = mul i32 %58, 32 + %67 = addrspacecast ptr addrspace(1) %0 to ptr + %68 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %67, i16 0, i64 167772160, i32 159744) + %69 = addrspacecast ptr addrspace(1) %2 to ptr + %70 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %69, i16 0, i64 10485760, i32 159744) + %71 = addrspacecast ptr addrspace(1) %4 to ptr + %72 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %71, i16 0, i64 706478080, i32 159744) + %73 = addrspacecast ptr addrspace(1) %6 to ptr + %74 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %73, i16 0, i64 44154880, i32 159744) + %75 = sdiv i32 %26, 8 + %76 = mul i32 %75, 8 + %77 = icmp ne i32 %26, %76 + %78 = icmp slt i32 %26, 0 + %79 = icmp ne i1 %78, false + %80 = and i1 %77, %79 + %81 = add i32 %75, -1 + %82 = select i1 %80, i32 %81, i32 %75 + %83 = srem i32 %26, 8 + %84 = sdiv i32 %26, 16 + %85 = mul i32 %84, 16 + %86 = icmp ne i32 %26, %85 + %87 = icmp slt i32 %26, 0 + %88 = icmp ne i1 %87, false + %89 = and i1 %86, %88 + %90 = add i32 %84, -1 + %91 = select i1 %89, i32 %90, i32 %84 + %92 = srem i32 %26, 16 + %93 = mul i32 %65, 7168 + %94 = mul i32 %50, 256 + %95 = add i32 %93, %94 + %96 = mul i32 %35, 64 + %97 = add i32 %95, %96 + %98 = mul i32 %97, 256 + %99 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %98) + %100 = add i32 %97, 16 + %101 = mul i32 %100, 256 + %102 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %101) + %103 = add i32 %97, 32 + %104 = mul i32 %103, 256 + %105 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %104) + %106 = add i32 %97, 48 + %107 = mul i32 %106, 256 + %108 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %107) + %109 = mul i32 %50, 8 + %110 = mul i32 %35, 2 + %111 = add i32 %109, %110 + %112 = mul i32 %65, 28672 + %113 = mul i32 %111, 128 + %114 = add i32 %112, %113 + %115 = mul i32 %114, 4 + %116 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %115) + %117 = add i32 %111, 1 + %118 = mul i32 %117, 128 + %119 = add i32 %112, %118 + %120 = mul i32 %119, 4 + %121 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %120) + %122 = sdiv i32 %66, 32 + %123 = mul i32 %122, 32 + %124 = icmp ne i32 %66, %123 + %125 = icmp slt i32 %66, 0 + %126 = icmp ne i1 %125, false + %127 = and i1 %124, %126 + %128 = add i32 %122, -1 + %129 = select i1 %127, i32 %128, i32 %122 + %130 = mul i32 %129, 512 + %131 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %130) + %132 = mul i32 %35, 8 + %133 = add i32 %66, %132 + %134 = add i32 %133, %82 + %135 = add i32 %132, %82 + %136 = and i32 %135, 14 + %137 = shl i32 %136, 3 + %138 = mul i32 %83, 16 + %139 = xor i32 %138, %137 + %140 = mul i32 %134, 256 + %141 = add i32 %139, %140 + %142 = mul i32 %35, 1024 + %143 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %142 + %144 = sext i32 %143 to i64 + %145 = inttoptr i64 %144 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %68, ptr addrspace(3) %145, i32 16, i32 %141, i32 0, i32 0, i32 0) + %146 = add i32 %142, 4096 + %147 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %146 + %148 = sext i32 %147 to i64 + %149 = inttoptr i64 %148 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %68, ptr addrspace(3) %149, i32 16, i32 %141, i32 128, i32 0, i32 0) + call void @llvm.amdgcn.sched.barrier(i32 0) + %150 = mul i32 %91, 16 + %151 = add i32 %150, %92 + %152 = mul i32 %151, 4 + %153 = sdiv i32 %152, 4 + %154 = mul i32 %153, 4 + %155 = icmp ne i32 %152, %154 + %156 = icmp slt i32 %152, 0 + %157 = icmp ne i1 %156, false + %158 = and i1 %155, %157 + %159 = add i32 %153, -1 + %160 = select i1 %158, i32 %159, i32 %153 + %161 = mul i32 %160, 4 + %162 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %70, i32 %161, i32 %131, i32 0) + %163 = add i32 %152, 256 + %164 = sdiv i32 %163, 4 + %165 = mul i32 %164, 4 + %166 = icmp ne i32 %163, %165 + %167 = icmp slt i32 %163, 0 + %168 = icmp ne i1 %167, false + %169 = and i1 %166, %168 + %170 = add i32 %164, -1 + %171 = select i1 %169, i32 %170, i32 %164 + %172 = mul i32 %171, 4 + %173 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %70, i32 %172, i32 %131, i32 0) + %174 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %161, i32 %116, i32 0) + %175 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %161, i32 %121, i32 0) + %176 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %172, i32 %116, i32 0) + %177 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %172, i32 %121, i32 0) + %178 = mul i32 %91, 256 + %179 = mul i32 %92, 16 + %180 = add i32 %178, %179 + %181 = sdiv i32 %180, 4 + %182 = mul i32 %181, 4 + %183 = icmp ne i32 %180, %182 + %184 = icmp slt i32 %180, 0 + %185 = icmp ne i1 %184, false + %186 = and i1 %183, %185 + %187 = add i32 %181, -1 + %188 = select i1 %186, i32 %187, i32 %181 + %189 = mul i32 %188, 4 + %190 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %99, i32 0) + %191 = add i32 %180, 1024 + %192 = sdiv i32 %191, 4 + %193 = mul i32 %192, 4 + %194 = icmp ne i32 %191, %193 + %195 = icmp slt i32 %191, 0 + %196 = icmp ne i1 %195, false + %197 = and i1 %194, %196 + %198 = add i32 %192, -1 + %199 = select i1 %197, i32 %198, i32 %192 + %200 = mul i32 %199, 4 + %201 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %99, i32 0) + %202 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %102, i32 0) + %203 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %102, i32 0) + %204 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %105, i32 0) + %205 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %105, i32 0) + %206 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %108, i32 0) + %207 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %108, i32 0) + %208 = add i32 %180, 2048 + %209 = sdiv i32 %208, 4 + %210 = mul i32 %209, 4 + %211 = icmp ne i32 %208, %210 + %212 = icmp slt i32 %208, 0 + %213 = icmp ne i1 %212, false + %214 = and i1 %211, %213 + %215 = add i32 %209, -1 + %216 = select i1 %214, i32 %215, i32 %209 + %217 = mul i32 %216, 4 + %218 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %99, i32 0) + %219 = add i32 %180, 3072 + %220 = sdiv i32 %219, 4 + %221 = mul i32 %220, 4 + %222 = icmp ne i32 %219, %221 + %223 = icmp slt i32 %219, 0 + %224 = icmp ne i1 %223, false + %225 = and i1 %222, %224 + %226 = add i32 %220, -1 + %227 = select i1 %225, i32 %226, i32 %220 + %228 = mul i32 %227, 4 + %229 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %99, i32 0) + %230 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %102, i32 0) + %231 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %102, i32 0) + %232 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %105, i32 0) + %233 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %105, i32 0) + %234 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %108, i32 0) + %235 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %108, i32 0) + call void asm sideeffect "s_waitcnt vmcnt(23)", ""() + call void asm sideeffect "s_barrier", ""() + %236 = and i32 %92, 14 + %237 = shl i32 %236, 3 + %238 = sext i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32) to i64 + %239 = inttoptr i64 %238 to ptr addrspace(3) + %240 = xor i32 %150, %237 + %241 = mul i32 %92, 128 + %242 = add i32 %241, %240 + %243 = getelementptr i8, ptr addrspace(3) %239, i32 %242 + %244 = load <4 x i32>, ptr addrspace(3) %243, align 16 + %245 = add i32 %92, 16 + %246 = mul i32 %245, 128 + %247 = add i32 %246, %240 + %248 = getelementptr i8, ptr addrspace(3) %239, i32 %247 + %249 = load <4 x i32>, ptr addrspace(3) %248, align 16 + %250 = add i32 %150, 64 + %251 = xor i32 %250, %237 + %252 = add i32 %241, %251 + %253 = getelementptr i8, ptr addrspace(3) %239, i32 %252 + %254 = load <4 x i32>, ptr addrspace(3) %253, align 16 + %255 = add i32 %246, %251 + %256 = getelementptr i8, ptr addrspace(3) %239, i32 %255 + %257 = load <4 x i32>, ptr addrspace(3) %256, align 16 + %258 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %190, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 0, i32 %174) + %259 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %190, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 0, i32 %174) + %260 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %254, <4 x i32> %201, <4 x float> %258, i32 4, i32 4, i32 2, i32 %162, i32 2, i32 %174) + %261 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %257, <4 x i32> %201, <4 x float> %259, i32 4, i32 4, i32 3, i32 %162, i32 2, i32 %174) + %262 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 1, i32 %174) + %263 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 1, i32 %174) + %264 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %254, <4 x i32> %203, <4 x float> %262, i32 4, i32 4, i32 2, i32 %162, i32 3, i32 %174) + %265 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %257, <4 x i32> %203, <4 x float> %263, i32 4, i32 4, i32 3, i32 %162, i32 3, i32 %174) + %266 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 0, i32 %175) + %267 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 0, i32 %175) + %268 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %254, <4 x i32> %205, <4 x float> %266, i32 4, i32 4, i32 2, i32 %162, i32 2, i32 %175) + %269 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %257, <4 x i32> %205, <4 x float> %267, i32 4, i32 4, i32 3, i32 %162, i32 2, i32 %175) + %270 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %206, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 1, i32 %175) + %271 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %206, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 1, i32 %175) + %272 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %254, <4 x i32> %207, <4 x float> %270, i32 4, i32 4, i32 2, i32 %162, i32 3, i32 %175) + %273 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %257, <4 x i32> %207, <4 x float> %271, i32 4, i32 4, i32 3, i32 %162, i32 3, i32 %175) + call void asm sideeffect "s_waitcnt vmcnt(22)", ""() + call void asm sideeffect "s_barrier", ""() + %274 = add i32 %241, 4096 + %275 = add i32 %274, %240 + %276 = getelementptr i8, ptr addrspace(3) %239, i32 %275 + %277 = load <4 x i32>, ptr addrspace(3) %276, align 16 + %278 = add i32 %246, 4096 + %279 = add i32 %278, %240 + %280 = getelementptr i8, ptr addrspace(3) %239, i32 %279 + %281 = load <4 x i32>, ptr addrspace(3) %280, align 16 + %282 = add i32 %274, %251 + %283 = getelementptr i8, ptr addrspace(3) %239, i32 %282 + %284 = load <4 x i32>, ptr addrspace(3) %283, align 16 + %285 = add i32 %278, %251 + %286 = getelementptr i8, ptr addrspace(3) %239, i32 %285 + %287 = load <4 x i32>, ptr addrspace(3) %286, align 16 + %288 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %277, <4 x i32> %218, <4 x float> %260, i32 4, i32 4, i32 0, i32 %173, i32 0, i32 %176) + %289 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %281, <4 x i32> %218, <4 x float> %261, i32 4, i32 4, i32 1, i32 %173, i32 0, i32 %176) + %290 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %284, <4 x i32> %229, <4 x float> %288, i32 4, i32 4, i32 2, i32 %173, i32 2, i32 %176) + %291 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %287, <4 x i32> %229, <4 x float> %289, i32 4, i32 4, i32 3, i32 %173, i32 2, i32 %176) + %292 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %277, <4 x i32> %230, <4 x float> %264, i32 4, i32 4, i32 0, i32 %173, i32 1, i32 %176) + %293 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %281, <4 x i32> %230, <4 x float> %265, i32 4, i32 4, i32 1, i32 %173, i32 1, i32 %176) + %294 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %284, <4 x i32> %231, <4 x float> %292, i32 4, i32 4, i32 2, i32 %173, i32 3, i32 %176) + %295 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %287, <4 x i32> %231, <4 x float> %293, i32 4, i32 4, i32 3, i32 %173, i32 3, i32 %176) + %296 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %277, <4 x i32> %232, <4 x float> %268, i32 4, i32 4, i32 0, i32 %173, i32 0, i32 %177) + %297 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %281, <4 x i32> %232, <4 x float> %269, i32 4, i32 4, i32 1, i32 %173, i32 0, i32 %177) + %298 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %284, <4 x i32> %233, <4 x float> %296, i32 4, i32 4, i32 2, i32 %173, i32 2, i32 %177) + %299 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %287, <4 x i32> %233, <4 x float> %297, i32 4, i32 4, i32 3, i32 %173, i32 2, i32 %177) + %300 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %277, <4 x i32> %234, <4 x float> %272, i32 4, i32 4, i32 0, i32 %173, i32 1, i32 %177) + %301 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %281, <4 x i32> %234, <4 x float> %273, i32 4, i32 4, i32 1, i32 %173, i32 1, i32 %177) + %302 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %284, <4 x i32> %235, <4 x float> %300, i32 4, i32 4, i32 2, i32 %173, i32 3, i32 %177) + %303 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %287, <4 x i32> %235, <4 x float> %301, i32 4, i32 4, i32 3, i32 %173, i32 3, i32 %177) + %304 = sext i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32) to i64 + %305 = inttoptr i64 %304 to ptr addrspace(3) + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %306 = mul i32 %91, 4 + %307 = add i32 %96, %92 + %308 = mul i32 %91, 1024 + %309 = add i32 %308, %307 + %310 = extractelement <4 x float> %290, i64 0 + %311 = mul i32 %309, 4 + %312 = getelementptr i8, ptr addrspace(3) %305, i32 %311 + store float %310, ptr addrspace(3) %312, align 4 + %313 = add i32 %306, 1 + %314 = mul i32 %313, 256 + %315 = add i32 %314, %307 + %316 = extractelement <4 x float> %290, i64 1 + %317 = mul i32 %315, 4 + %318 = getelementptr i8, ptr addrspace(3) %305, i32 %317 + store float %316, ptr addrspace(3) %318, align 4 + %319 = add i32 %306, 2 + %320 = mul i32 %319, 256 + %321 = add i32 %320, %307 + %322 = extractelement <4 x float> %290, i64 2 + %323 = mul i32 %321, 4 + %324 = getelementptr i8, ptr addrspace(3) %305, i32 %323 + store float %322, ptr addrspace(3) %324, align 4 + %325 = add i32 %306, 3 + %326 = mul i32 %325, 256 + %327 = add i32 %326, %307 + %328 = extractelement <4 x float> %290, i64 3 + %329 = mul i32 %327, 4 + %330 = getelementptr i8, ptr addrspace(3) %305, i32 %329 + store float %328, ptr addrspace(3) %330, align 4 + %331 = add i32 %96, 16 + %332 = add i32 %331, %92 + %333 = add i32 %308, %332 + %334 = extractelement <4 x float> %294, i64 0 + %335 = mul i32 %333, 4 + %336 = getelementptr i8, ptr addrspace(3) %305, i32 %335 + store float %334, ptr addrspace(3) %336, align 4 + %337 = add i32 %314, %332 + %338 = extractelement <4 x float> %294, i64 1 + %339 = mul i32 %337, 4 + %340 = getelementptr i8, ptr addrspace(3) %305, i32 %339 + store float %338, ptr addrspace(3) %340, align 4 + %341 = add i32 %320, %332 + %342 = extractelement <4 x float> %294, i64 2 + %343 = mul i32 %341, 4 + %344 = getelementptr i8, ptr addrspace(3) %305, i32 %343 + store float %342, ptr addrspace(3) %344, align 4 + %345 = add i32 %326, %332 + %346 = extractelement <4 x float> %294, i64 3 + %347 = mul i32 %345, 4 + %348 = getelementptr i8, ptr addrspace(3) %305, i32 %347 + store float %346, ptr addrspace(3) %348, align 4 + %349 = add i32 %96, 32 + %350 = add i32 %349, %92 + %351 = add i32 %308, %350 + %352 = extractelement <4 x float> %298, i64 0 + %353 = mul i32 %351, 4 + %354 = getelementptr i8, ptr addrspace(3) %305, i32 %353 + store float %352, ptr addrspace(3) %354, align 4 + %355 = add i32 %314, %350 + %356 = extractelement <4 x float> %298, i64 1 + %357 = mul i32 %355, 4 + %358 = getelementptr i8, ptr addrspace(3) %305, i32 %357 + store float %356, ptr addrspace(3) %358, align 4 + %359 = add i32 %320, %350 + %360 = extractelement <4 x float> %298, i64 2 + %361 = mul i32 %359, 4 + %362 = getelementptr i8, ptr addrspace(3) %305, i32 %361 + store float %360, ptr addrspace(3) %362, align 4 + %363 = add i32 %326, %350 + %364 = extractelement <4 x float> %298, i64 3 + %365 = mul i32 %363, 4 + %366 = getelementptr i8, ptr addrspace(3) %305, i32 %365 + store float %364, ptr addrspace(3) %366, align 4 + %367 = add i32 %96, 48 + %368 = add i32 %367, %92 + %369 = add i32 %308, %368 + %370 = extractelement <4 x float> %302, i64 0 + %371 = mul i32 %369, 4 + %372 = getelementptr i8, ptr addrspace(3) %305, i32 %371 + store float %370, ptr addrspace(3) %372, align 4 + %373 = add i32 %314, %368 + %374 = extractelement <4 x float> %302, i64 1 + %375 = mul i32 %373, 4 + %376 = getelementptr i8, ptr addrspace(3) %305, i32 %375 + store float %374, ptr addrspace(3) %376, align 4 + %377 = add i32 %320, %368 + %378 = extractelement <4 x float> %302, i64 2 + %379 = mul i32 %377, 4 + %380 = getelementptr i8, ptr addrspace(3) %305, i32 %379 + store float %378, ptr addrspace(3) %380, align 4 + %381 = add i32 %326, %368 + %382 = extractelement <4 x float> %302, i64 3 + %383 = mul i32 %381, 4 + %384 = getelementptr i8, ptr addrspace(3) %305, i32 %383 + store float %382, ptr addrspace(3) %384, align 4 + %385 = add i32 %306, 16 + %386 = mul i32 %385, 256 + %387 = add i32 %386, %307 + %388 = extractelement <4 x float> %291, i64 0 + %389 = mul i32 %387, 4 + %390 = getelementptr i8, ptr addrspace(3) %305, i32 %389 + store float %388, ptr addrspace(3) %390, align 4 + %391 = add i32 %306, 17 + %392 = mul i32 %391, 256 + %393 = add i32 %392, %307 + %394 = extractelement <4 x float> %291, i64 1 + %395 = mul i32 %393, 4 + %396 = getelementptr i8, ptr addrspace(3) %305, i32 %395 + store float %394, ptr addrspace(3) %396, align 4 + %397 = add i32 %306, 18 + %398 = mul i32 %397, 256 + %399 = add i32 %398, %307 + %400 = extractelement <4 x float> %291, i64 2 + %401 = mul i32 %399, 4 + %402 = getelementptr i8, ptr addrspace(3) %305, i32 %401 + store float %400, ptr addrspace(3) %402, align 4 + %403 = add i32 %306, 19 + %404 = mul i32 %403, 256 + %405 = add i32 %404, %307 + %406 = extractelement <4 x float> %291, i64 3 + %407 = mul i32 %405, 4 + %408 = getelementptr i8, ptr addrspace(3) %305, i32 %407 + store float %406, ptr addrspace(3) %408, align 4 + %409 = add i32 %386, %332 + %410 = extractelement <4 x float> %295, i64 0 + %411 = mul i32 %409, 4 + %412 = getelementptr i8, ptr addrspace(3) %305, i32 %411 + store float %410, ptr addrspace(3) %412, align 4 + %413 = add i32 %392, %332 + %414 = extractelement <4 x float> %295, i64 1 + %415 = mul i32 %413, 4 + %416 = getelementptr i8, ptr addrspace(3) %305, i32 %415 + store float %414, ptr addrspace(3) %416, align 4 + %417 = add i32 %398, %332 + %418 = extractelement <4 x float> %295, i64 2 + %419 = mul i32 %417, 4 + %420 = getelementptr i8, ptr addrspace(3) %305, i32 %419 + store float %418, ptr addrspace(3) %420, align 4 + %421 = add i32 %404, %332 + %422 = extractelement <4 x float> %295, i64 3 + %423 = mul i32 %421, 4 + %424 = getelementptr i8, ptr addrspace(3) %305, i32 %423 + store float %422, ptr addrspace(3) %424, align 4 + %425 = add i32 %386, %350 + %426 = extractelement <4 x float> %299, i64 0 + %427 = mul i32 %425, 4 + %428 = getelementptr i8, ptr addrspace(3) %305, i32 %427 + store float %426, ptr addrspace(3) %428, align 4 + %429 = add i32 %392, %350 + %430 = extractelement <4 x float> %299, i64 1 + %431 = mul i32 %429, 4 + %432 = getelementptr i8, ptr addrspace(3) %305, i32 %431 + store float %430, ptr addrspace(3) %432, align 4 + %433 = add i32 %398, %350 + %434 = extractelement <4 x float> %299, i64 2 + %435 = mul i32 %433, 4 + %436 = getelementptr i8, ptr addrspace(3) %305, i32 %435 + store float %434, ptr addrspace(3) %436, align 4 + %437 = add i32 %404, %350 + %438 = extractelement <4 x float> %299, i64 3 + %439 = mul i32 %437, 4 + %440 = getelementptr i8, ptr addrspace(3) %305, i32 %439 + store float %438, ptr addrspace(3) %440, align 4 + %441 = add i32 %386, %368 + %442 = extractelement <4 x float> %303, i64 0 + %443 = mul i32 %441, 4 + %444 = getelementptr i8, ptr addrspace(3) %305, i32 %443 + store float %442, ptr addrspace(3) %444, align 4 + %445 = add i32 %392, %368 + %446 = extractelement <4 x float> %303, i64 1 + %447 = mul i32 %445, 4 + %448 = getelementptr i8, ptr addrspace(3) %305, i32 %447 + store float %446, ptr addrspace(3) %448, align 4 + %449 = add i32 %398, %368 + %450 = extractelement <4 x float> %303, i64 2 + %451 = mul i32 %449, 4 + %452 = getelementptr i8, ptr addrspace(3) %305, i32 %451 + store float %450, ptr addrspace(3) %452, align 4 + %453 = add i32 %404, %368 + %454 = extractelement <4 x float> %303, i64 3 + %455 = mul i32 %453, 4 + %456 = getelementptr i8, ptr addrspace(3) %305, i32 %455 + store float %454, ptr addrspace(3) %456, align 4 + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %457 = sdiv i32 %24, 32 + %458 = mul i32 %457, 32 + %459 = icmp ne i32 %24, %458 + %460 = icmp slt i32 %24, 0 + %461 = icmp ne i1 %460, false + %462 = and i1 %459, %461 + %463 = add i32 %457, -1 + %464 = select i1 %462, i32 %463, i32 %457 + %465 = srem i32 %24, 32 + %466 = mul i32 %465, 2 + %467 = add i32 %66, %464 + %468 = mul i32 %467, 4 + %469 = ptrtoint ptr addrspace(1) %12 to i64 + %470 = sext i32 %468 to i64 + %471 = add i64 %469, %470 + %472 = inttoptr i64 %471 to ptr addrspace(1) + %473 = load i32, ptr addrspace(1) %472, align 4 + %474 = and i32 %473, 16777215 + %475 = icmp slt i32 %474, %16 + %476 = ptrtoint ptr addrspace(1) %14 to i64 + %477 = add i64 %476, %470 + %478 = inttoptr i64 %477 to ptr addrspace(1) + %479 = load float, ptr addrspace(1) %478, align 4 + br i1 %475, label %480, label %561 + +480: ; preds = %49 + %481 = mul i32 %474, 7168 + %482 = add i32 %481, %94 + %483 = add i32 %482, %466 + %484 = mul i32 %464, 256 + %485 = add i32 %484, %466 + %486 = mul i32 %485, 4 + %487 = getelementptr i8, ptr addrspace(3) %305, i32 %486 + %488 = load float, ptr addrspace(3) %487, align 4 + %489 = fmul float %488, %479 + %490 = add i32 %485, 1 + %491 = mul i32 %490, 4 + %492 = getelementptr i8, ptr addrspace(3) %305, i32 %491 + %493 = load float, ptr addrspace(3) %492, align 4 + %494 = fmul float %493, %479 + %495 = insertelement <2 x float> poison, float %489, i64 0 + %496 = insertelement <2 x float> %495, float %494, i64 1 + %497 = fptrunc <2 x float> %496 to <2 x bfloat> + %498 = mul i32 %483, 2 + %499 = ptrtoint ptr addrspace(1) %17 to i64 + %500 = sext i32 %498 to i64 + %501 = add i64 %499, %500 + %502 = inttoptr i64 %501 to ptr addrspace(1) + %503 = atomicrmw fadd ptr addrspace(1) %502, <2 x bfloat> %497 syncscope("agent") monotonic, align 4 + %504 = add i32 %485, 64 + %505 = mul i32 %504, 4 + %506 = getelementptr i8, ptr addrspace(3) %305, i32 %505 + %507 = load float, ptr addrspace(3) %506, align 4 + %508 = fmul float %507, %479 + %509 = add i32 %485, 65 + %510 = mul i32 %509, 4 + %511 = getelementptr i8, ptr addrspace(3) %305, i32 %510 + %512 = load float, ptr addrspace(3) %511, align 4 + %513 = fmul float %512, %479 + %514 = insertelement <2 x float> poison, float %508, i64 0 + %515 = insertelement <2 x float> %514, float %513, i64 1 + %516 = fptrunc <2 x float> %515 to <2 x bfloat> + %517 = add i32 %483, 64 + %518 = mul i32 %517, 2 + %519 = sext i32 %518 to i64 + %520 = add i64 %499, %519 + %521 = inttoptr i64 %520 to ptr addrspace(1) + %522 = atomicrmw fadd ptr addrspace(1) %521, <2 x bfloat> %516 syncscope("agent") monotonic, align 4 + %523 = add i32 %485, 128 + %524 = mul i32 %523, 4 + %525 = getelementptr i8, ptr addrspace(3) %305, i32 %524 + %526 = load float, ptr addrspace(3) %525, align 4 + %527 = fmul float %526, %479 + %528 = add i32 %485, 129 + %529 = mul i32 %528, 4 + %530 = getelementptr i8, ptr addrspace(3) %305, i32 %529 + %531 = load float, ptr addrspace(3) %530, align 4 + %532 = fmul float %531, %479 + %533 = insertelement <2 x float> poison, float %527, i64 0 + %534 = insertelement <2 x float> %533, float %532, i64 1 + %535 = fptrunc <2 x float> %534 to <2 x bfloat> + %536 = add i32 %483, 128 + %537 = mul i32 %536, 2 + %538 = sext i32 %537 to i64 + %539 = add i64 %499, %538 + %540 = inttoptr i64 %539 to ptr addrspace(1) + %541 = atomicrmw fadd ptr addrspace(1) %540, <2 x bfloat> %535 syncscope("agent") monotonic, align 4 + %542 = add i32 %485, 192 + %543 = mul i32 %542, 4 + %544 = getelementptr i8, ptr addrspace(3) %305, i32 %543 + %545 = load float, ptr addrspace(3) %544, align 4 + %546 = fmul float %545, %479 + %547 = add i32 %485, 193 + %548 = mul i32 %547, 4 + %549 = getelementptr i8, ptr addrspace(3) %305, i32 %548 + %550 = load float, ptr addrspace(3) %549, align 4 + %551 = fmul float %550, %479 + %552 = insertelement <2 x float> poison, float %546, i64 0 + %553 = insertelement <2 x float> %552, float %551, i64 1 + %554 = fptrunc <2 x float> %553 to <2 x bfloat> + %555 = add i32 %483, 192 + %556 = mul i32 %555, 2 + %557 = sext i32 %556 to i64 + %558 = add i64 %499, %557 + %559 = inttoptr i64 %558 to ptr addrspace(1) + %560 = atomicrmw fadd ptr addrspace(1) %559, <2 x bfloat> %554 syncscope("agent") monotonic, align 4 + br label %561 + +561: ; preds = %480, %49 + %562 = add i32 %464, 8 + %563 = add i32 %66, %562 + %564 = mul i32 %563, 4 + %565 = sext i32 %564 to i64 + %566 = add i64 %469, %565 + %567 = inttoptr i64 %566 to ptr addrspace(1) + %568 = load i32, ptr addrspace(1) %567, align 4 + %569 = and i32 %568, 16777215 + %570 = icmp slt i32 %569, %16 + %571 = add i64 %476, %565 + %572 = inttoptr i64 %571 to ptr addrspace(1) + %573 = load float, ptr addrspace(1) %572, align 4 + br i1 %570, label %574, label %655 + +574: ; preds = %561 + %575 = mul i32 %569, 7168 + %576 = add i32 %575, %94 + %577 = add i32 %576, %466 + %578 = mul i32 %562, 256 + %579 = add i32 %578, %466 + %580 = mul i32 %579, 4 + %581 = getelementptr i8, ptr addrspace(3) %305, i32 %580 + %582 = load float, ptr addrspace(3) %581, align 4 + %583 = fmul float %582, %573 + %584 = add i32 %579, 1 + %585 = mul i32 %584, 4 + %586 = getelementptr i8, ptr addrspace(3) %305, i32 %585 + %587 = load float, ptr addrspace(3) %586, align 4 + %588 = fmul float %587, %573 + %589 = insertelement <2 x float> poison, float %583, i64 0 + %590 = insertelement <2 x float> %589, float %588, i64 1 + %591 = fptrunc <2 x float> %590 to <2 x bfloat> + %592 = mul i32 %577, 2 + %593 = ptrtoint ptr addrspace(1) %17 to i64 + %594 = sext i32 %592 to i64 + %595 = add i64 %593, %594 + %596 = inttoptr i64 %595 to ptr addrspace(1) + %597 = atomicrmw fadd ptr addrspace(1) %596, <2 x bfloat> %591 syncscope("agent") monotonic, align 4 + %598 = add i32 %579, 64 + %599 = mul i32 %598, 4 + %600 = getelementptr i8, ptr addrspace(3) %305, i32 %599 + %601 = load float, ptr addrspace(3) %600, align 4 + %602 = fmul float %601, %573 + %603 = add i32 %579, 65 + %604 = mul i32 %603, 4 + %605 = getelementptr i8, ptr addrspace(3) %305, i32 %604 + %606 = load float, ptr addrspace(3) %605, align 4 + %607 = fmul float %606, %573 + %608 = insertelement <2 x float> poison, float %602, i64 0 + %609 = insertelement <2 x float> %608, float %607, i64 1 + %610 = fptrunc <2 x float> %609 to <2 x bfloat> + %611 = add i32 %577, 64 + %612 = mul i32 %611, 2 + %613 = sext i32 %612 to i64 + %614 = add i64 %593, %613 + %615 = inttoptr i64 %614 to ptr addrspace(1) + %616 = atomicrmw fadd ptr addrspace(1) %615, <2 x bfloat> %610 syncscope("agent") monotonic, align 4 + %617 = add i32 %579, 128 + %618 = mul i32 %617, 4 + %619 = getelementptr i8, ptr addrspace(3) %305, i32 %618 + %620 = load float, ptr addrspace(3) %619, align 4 + %621 = fmul float %620, %573 + %622 = add i32 %579, 129 + %623 = mul i32 %622, 4 + %624 = getelementptr i8, ptr addrspace(3) %305, i32 %623 + %625 = load float, ptr addrspace(3) %624, align 4 + %626 = fmul float %625, %573 + %627 = insertelement <2 x float> poison, float %621, i64 0 + %628 = insertelement <2 x float> %627, float %626, i64 1 + %629 = fptrunc <2 x float> %628 to <2 x bfloat> + %630 = add i32 %577, 128 + %631 = mul i32 %630, 2 + %632 = sext i32 %631 to i64 + %633 = add i64 %593, %632 + %634 = inttoptr i64 %633 to ptr addrspace(1) + %635 = atomicrmw fadd ptr addrspace(1) %634, <2 x bfloat> %629 syncscope("agent") monotonic, align 4 + %636 = add i32 %579, 192 + %637 = mul i32 %636, 4 + %638 = getelementptr i8, ptr addrspace(3) %305, i32 %637 + %639 = load float, ptr addrspace(3) %638, align 4 + %640 = fmul float %639, %573 + %641 = add i32 %579, 193 + %642 = mul i32 %641, 4 + %643 = getelementptr i8, ptr addrspace(3) %305, i32 %642 + %644 = load float, ptr addrspace(3) %643, align 4 + %645 = fmul float %644, %573 + %646 = insertelement <2 x float> poison, float %640, i64 0 + %647 = insertelement <2 x float> %646, float %645, i64 1 + %648 = fptrunc <2 x float> %647 to <2 x bfloat> + %649 = add i32 %577, 192 + %650 = mul i32 %649, 2 + %651 = sext i32 %650 to i64 + %652 = add i64 %593, %651 + %653 = inttoptr i64 %652 to ptr addrspace(1) + %654 = atomicrmw fadd ptr addrspace(1) %653, <2 x bfloat> %648 syncscope("agent") monotonic, align 4 + br label %655 + +655: ; preds = %574, %561 + %656 = add i32 %464, 16 + %657 = add i32 %66, %656 + %658 = mul i32 %657, 4 + %659 = sext i32 %658 to i64 + %660 = add i64 %469, %659 + %661 = inttoptr i64 %660 to ptr addrspace(1) + %662 = load i32, ptr addrspace(1) %661, align 4 + %663 = and i32 %662, 16777215 + %664 = icmp slt i32 %663, %16 + %665 = add i64 %476, %659 + %666 = inttoptr i64 %665 to ptr addrspace(1) + %667 = load float, ptr addrspace(1) %666, align 4 + br i1 %664, label %668, label %749 + +668: ; preds = %655 + %669 = mul i32 %663, 7168 + %670 = add i32 %669, %94 + %671 = add i32 %670, %466 + %672 = mul i32 %656, 256 + %673 = add i32 %672, %466 + %674 = mul i32 %673, 4 + %675 = getelementptr i8, ptr addrspace(3) %305, i32 %674 + %676 = load float, ptr addrspace(3) %675, align 4 + %677 = fmul float %676, %667 + %678 = add i32 %673, 1 + %679 = mul i32 %678, 4 + %680 = getelementptr i8, ptr addrspace(3) %305, i32 %679 + %681 = load float, ptr addrspace(3) %680, align 4 + %682 = fmul float %681, %667 + %683 = insertelement <2 x float> poison, float %677, i64 0 + %684 = insertelement <2 x float> %683, float %682, i64 1 + %685 = fptrunc <2 x float> %684 to <2 x bfloat> + %686 = mul i32 %671, 2 + %687 = ptrtoint ptr addrspace(1) %17 to i64 + %688 = sext i32 %686 to i64 + %689 = add i64 %687, %688 + %690 = inttoptr i64 %689 to ptr addrspace(1) + %691 = atomicrmw fadd ptr addrspace(1) %690, <2 x bfloat> %685 syncscope("agent") monotonic, align 4 + %692 = add i32 %673, 64 + %693 = mul i32 %692, 4 + %694 = getelementptr i8, ptr addrspace(3) %305, i32 %693 + %695 = load float, ptr addrspace(3) %694, align 4 + %696 = fmul float %695, %667 + %697 = add i32 %673, 65 + %698 = mul i32 %697, 4 + %699 = getelementptr i8, ptr addrspace(3) %305, i32 %698 + %700 = load float, ptr addrspace(3) %699, align 4 + %701 = fmul float %700, %667 + %702 = insertelement <2 x float> poison, float %696, i64 0 + %703 = insertelement <2 x float> %702, float %701, i64 1 + %704 = fptrunc <2 x float> %703 to <2 x bfloat> + %705 = add i32 %671, 64 + %706 = mul i32 %705, 2 + %707 = sext i32 %706 to i64 + %708 = add i64 %687, %707 + %709 = inttoptr i64 %708 to ptr addrspace(1) + %710 = atomicrmw fadd ptr addrspace(1) %709, <2 x bfloat> %704 syncscope("agent") monotonic, align 4 + %711 = add i32 %673, 128 + %712 = mul i32 %711, 4 + %713 = getelementptr i8, ptr addrspace(3) %305, i32 %712 + %714 = load float, ptr addrspace(3) %713, align 4 + %715 = fmul float %714, %667 + %716 = add i32 %673, 129 + %717 = mul i32 %716, 4 + %718 = getelementptr i8, ptr addrspace(3) %305, i32 %717 + %719 = load float, ptr addrspace(3) %718, align 4 + %720 = fmul float %719, %667 + %721 = insertelement <2 x float> poison, float %715, i64 0 + %722 = insertelement <2 x float> %721, float %720, i64 1 + %723 = fptrunc <2 x float> %722 to <2 x bfloat> + %724 = add i32 %671, 128 + %725 = mul i32 %724, 2 + %726 = sext i32 %725 to i64 + %727 = add i64 %687, %726 + %728 = inttoptr i64 %727 to ptr addrspace(1) + %729 = atomicrmw fadd ptr addrspace(1) %728, <2 x bfloat> %723 syncscope("agent") monotonic, align 4 + %730 = add i32 %673, 192 + %731 = mul i32 %730, 4 + %732 = getelementptr i8, ptr addrspace(3) %305, i32 %731 + %733 = load float, ptr addrspace(3) %732, align 4 + %734 = fmul float %733, %667 + %735 = add i32 %673, 193 + %736 = mul i32 %735, 4 + %737 = getelementptr i8, ptr addrspace(3) %305, i32 %736 + %738 = load float, ptr addrspace(3) %737, align 4 + %739 = fmul float %738, %667 + %740 = insertelement <2 x float> poison, float %734, i64 0 + %741 = insertelement <2 x float> %740, float %739, i64 1 + %742 = fptrunc <2 x float> %741 to <2 x bfloat> + %743 = add i32 %671, 192 + %744 = mul i32 %743, 2 + %745 = sext i32 %744 to i64 + %746 = add i64 %687, %745 + %747 = inttoptr i64 %746 to ptr addrspace(1) + %748 = atomicrmw fadd ptr addrspace(1) %747, <2 x bfloat> %742 syncscope("agent") monotonic, align 4 + br label %749 + +749: ; preds = %668, %655 + %750 = add i32 %464, 24 + %751 = add i32 %66, %750 + %752 = mul i32 %751, 4 + %753 = sext i32 %752 to i64 + %754 = add i64 %469, %753 + %755 = inttoptr i64 %754 to ptr addrspace(1) + %756 = load i32, ptr addrspace(1) %755, align 4 + %757 = and i32 %756, 16777215 + %758 = icmp slt i32 %757, %16 + %759 = add i64 %476, %753 + %760 = inttoptr i64 %759 to ptr addrspace(1) + %761 = load float, ptr addrspace(1) %760, align 4 + br i1 %758, label %762, label %843 + +762: ; preds = %749 + %763 = mul i32 %757, 7168 + %764 = add i32 %763, %94 + %765 = add i32 %764, %466 + %766 = mul i32 %750, 256 + %767 = add i32 %766, %466 + %768 = mul i32 %767, 4 + %769 = getelementptr i8, ptr addrspace(3) %305, i32 %768 + %770 = load float, ptr addrspace(3) %769, align 4 + %771 = fmul float %770, %761 + %772 = add i32 %767, 1 + %773 = mul i32 %772, 4 + %774 = getelementptr i8, ptr addrspace(3) %305, i32 %773 + %775 = load float, ptr addrspace(3) %774, align 4 + %776 = fmul float %775, %761 + %777 = insertelement <2 x float> poison, float %771, i64 0 + %778 = insertelement <2 x float> %777, float %776, i64 1 + %779 = fptrunc <2 x float> %778 to <2 x bfloat> + %780 = mul i32 %765, 2 + %781 = ptrtoint ptr addrspace(1) %17 to i64 + %782 = sext i32 %780 to i64 + %783 = add i64 %781, %782 + %784 = inttoptr i64 %783 to ptr addrspace(1) + %785 = atomicrmw fadd ptr addrspace(1) %784, <2 x bfloat> %779 syncscope("agent") monotonic, align 4 + %786 = add i32 %767, 64 + %787 = mul i32 %786, 4 + %788 = getelementptr i8, ptr addrspace(3) %305, i32 %787 + %789 = load float, ptr addrspace(3) %788, align 4 + %790 = fmul float %789, %761 + %791 = add i32 %767, 65 + %792 = mul i32 %791, 4 + %793 = getelementptr i8, ptr addrspace(3) %305, i32 %792 + %794 = load float, ptr addrspace(3) %793, align 4 + %795 = fmul float %794, %761 + %796 = insertelement <2 x float> poison, float %790, i64 0 + %797 = insertelement <2 x float> %796, float %795, i64 1 + %798 = fptrunc <2 x float> %797 to <2 x bfloat> + %799 = add i32 %765, 64 + %800 = mul i32 %799, 2 + %801 = sext i32 %800 to i64 + %802 = add i64 %781, %801 + %803 = inttoptr i64 %802 to ptr addrspace(1) + %804 = atomicrmw fadd ptr addrspace(1) %803, <2 x bfloat> %798 syncscope("agent") monotonic, align 4 + %805 = add i32 %767, 128 + %806 = mul i32 %805, 4 + %807 = getelementptr i8, ptr addrspace(3) %305, i32 %806 + %808 = load float, ptr addrspace(3) %807, align 4 + %809 = fmul float %808, %761 + %810 = add i32 %767, 129 + %811 = mul i32 %810, 4 + %812 = getelementptr i8, ptr addrspace(3) %305, i32 %811 + %813 = load float, ptr addrspace(3) %812, align 4 + %814 = fmul float %813, %761 + %815 = insertelement <2 x float> poison, float %809, i64 0 + %816 = insertelement <2 x float> %815, float %814, i64 1 + %817 = fptrunc <2 x float> %816 to <2 x bfloat> + %818 = add i32 %765, 128 + %819 = mul i32 %818, 2 + %820 = sext i32 %819 to i64 + %821 = add i64 %781, %820 + %822 = inttoptr i64 %821 to ptr addrspace(1) + %823 = atomicrmw fadd ptr addrspace(1) %822, <2 x bfloat> %817 syncscope("agent") monotonic, align 4 + %824 = add i32 %767, 192 + %825 = mul i32 %824, 4 + %826 = getelementptr i8, ptr addrspace(3) %305, i32 %825 + %827 = load float, ptr addrspace(3) %826, align 4 + %828 = fmul float %827, %761 + %829 = add i32 %767, 193 + %830 = mul i32 %829, 4 + %831 = getelementptr i8, ptr addrspace(3) %305, i32 %830 + %832 = load float, ptr addrspace(3) %831, align 4 + %833 = fmul float %832, %761 + %834 = insertelement <2 x float> poison, float %828, i64 0 + %835 = insertelement <2 x float> %834, float %833, i64 1 + %836 = fptrunc <2 x float> %835 to <2 x bfloat> + %837 = add i32 %765, 192 + %838 = mul i32 %837, 2 + %839 = sext i32 %838 to i64 + %840 = add i64 %781, %839 + %841 = inttoptr i64 %840 to ptr addrspace(1) + %842 = atomicrmw fadd ptr addrspace(1) %841, <2 x bfloat> %836 syncscope("agent") monotonic, align 4 + br label %843 + +843: ; preds = %762, %749 + br label %844 + +844: ; preds = %843, %19 + ret void +} + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) +declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 + +; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) +declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #3 + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #4 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.sched.barrier(i32 immarg) #5 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) +declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #7 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.s.barrier() #5 + +attributes #0 = { "amdgpu-flat-work-group-size"="256,256" "uniform-work-group-size" } +attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } +attributes #2 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } +attributes #3 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } +attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } +attributes #5 = { convergent nocallback nofree nounwind willreturn } +attributes #6 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } +attributes #7 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = !{i32 256, i32 1, i32 1} diff --git a/kernels/gemm2_port_ref/flydsl_port_v5.ll b/kernels/gemm2_port_ref/flydsl_port_v5.ll new file mode 100644 index 000000000..702f18afa --- /dev/null +++ b/kernels/gemm2_port_ref/flydsl_port_v5.ll @@ -0,0 +1,898 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" +target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" + +@gemm2port_smem = external addrspace(3) global [32768 x i8], align 1024 + +define amdgpu_kernel void @gemm2_a4w4_port_bm32_atomic(ptr addrspace(1) %0, <{ <{ i32, i32 }>, <{ i64 }> }> %1, ptr addrspace(1) %2, <{ <{ i32, i32 }>, <{ i64 }> }> %3, ptr addrspace(1) %4, <{ <{ i32, i32, i32 }>, <{ i64, i64 }> }> %5, ptr addrspace(1) %6, <{ <{ i32, i32 }>, <{ i64 }> }> %7, ptr addrspace(1) %8, <{ <{ i32 }> }> %9, ptr addrspace(1) %10, <{ <{ i32 }> }> %11, ptr addrspace(1) %12, <{ <{ i32 }> }> %13, ptr addrspace(1) %14, <{ <{ i32 }> }> %15, i32 %16, ptr addrspace(1) %17, <{ <{ i32, i32 }>, <{ i64 }> }> %18) #0 !reqd_work_group_size !1 { + %20 = call range(i32 0, 256) i32 @llvm.amdgcn.workitem.id.x() + %21 = sext i32 %20 to i64 + %22 = call i32 @llvm.amdgcn.workgroup.id.x() + %23 = sext i32 %22 to i64 + %24 = trunc i64 %21 to i32 + %25 = trunc i64 %23 to i32 + %26 = srem i32 %24, 64 + %27 = sdiv i32 %24, 64 + %28 = mul i32 %27, 64 + %29 = icmp ne i32 %24, %28 + %30 = icmp slt i32 %24, 0 + %31 = icmp ne i1 %30, false + %32 = and i1 %29, %31 + %33 = add i32 %27, -1 + %34 = select i1 %32, i32 %33, i32 %27 + %35 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %34) + %36 = ptrtoint ptr addrspace(1) %10 to i64 + %37 = inttoptr i64 %36 to ptr addrspace(1) + %38 = load i32, ptr addrspace(1) %37, align 4 + %39 = sdiv i32 %38, 32 + %40 = mul i32 %39, 32 + %41 = icmp ne i32 %38, %40 + %42 = icmp slt i32 %38, 0 + %43 = icmp ne i1 %42, false + %44 = and i1 %41, %43 + %45 = add i32 %39, -1 + %46 = select i1 %44, i32 %45, i32 %39 + %47 = mul i32 %46, 28 + %48 = icmp slt i32 %25, %47 + br i1 %48, label %49, label %799 + +49: ; preds = %19 + %50 = srem i32 %25, 28 + %51 = sdiv i32 %25, 28 + %52 = mul i32 %51, 28 + %53 = icmp ne i32 %25, %52 + %54 = icmp slt i32 %25, 0 + %55 = icmp ne i1 %54, false + %56 = and i1 %53, %55 + %57 = add i32 %51, -1 + %58 = select i1 %56, i32 %57, i32 %51 + %59 = mul i32 %58, 4 + %60 = ptrtoint ptr addrspace(1) %8 to i64 + %61 = inttoptr i64 %60 to ptr addrspace(1) + %62 = getelementptr i8, ptr addrspace(1) %61, i32 %59 + %63 = load i32, ptr addrspace(1) %62, align 4 + %64 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %63) + %65 = mul i32 %58, 32 + %66 = addrspacecast ptr addrspace(1) %0 to ptr + %67 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %66, i16 0, i64 167772160, i32 159744) + %68 = addrspacecast ptr addrspace(1) %2 to ptr + %69 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %68, i16 0, i64 10485760, i32 159744) + %70 = addrspacecast ptr addrspace(1) %4 to ptr + %71 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %70, i16 0, i64 706478080, i32 159744) + %72 = addrspacecast ptr addrspace(1) %6 to ptr + %73 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %72, i16 0, i64 44154880, i32 159744) + %74 = sdiv i32 %26, 8 + %75 = mul i32 %74, 8 + %76 = icmp ne i32 %26, %75 + %77 = icmp slt i32 %26, 0 + %78 = icmp ne i1 %77, false + %79 = and i1 %76, %78 + %80 = add i32 %74, -1 + %81 = select i1 %79, i32 %80, i32 %74 + %82 = srem i32 %26, 8 + %83 = sdiv i32 %26, 16 + %84 = mul i32 %83, 16 + %85 = icmp ne i32 %26, %84 + %86 = icmp slt i32 %26, 0 + %87 = icmp ne i1 %86, false + %88 = and i1 %85, %87 + %89 = add i32 %83, -1 + %90 = select i1 %88, i32 %89, i32 %83 + %91 = srem i32 %26, 16 + %92 = mul i32 %64, 7168 + %93 = mul i32 %50, 256 + %94 = add i32 %92, %93 + %95 = mul i32 %35, 64 + %96 = add i32 %94, %95 + %97 = mul i32 %96, 256 + %98 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %97) + %99 = add i32 %96, 16 + %100 = mul i32 %99, 256 + %101 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %100) + %102 = add i32 %96, 32 + %103 = mul i32 %102, 256 + %104 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %103) + %105 = add i32 %96, 48 + %106 = mul i32 %105, 256 + %107 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %106) + %108 = mul i32 %50, 8 + %109 = mul i32 %35, 2 + %110 = add i32 %108, %109 + %111 = mul i32 %64, 28672 + %112 = mul i32 %110, 128 + %113 = add i32 %111, %112 + %114 = mul i32 %113, 4 + %115 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %114) + %116 = add i32 %110, 1 + %117 = mul i32 %116, 128 + %118 = add i32 %111, %117 + %119 = mul i32 %118, 4 + %120 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %119) + %121 = sdiv i32 %65, 32 + %122 = mul i32 %121, 32 + %123 = icmp ne i32 %65, %122 + %124 = icmp slt i32 %65, 0 + %125 = icmp ne i1 %124, false + %126 = and i1 %123, %125 + %127 = add i32 %121, -1 + %128 = select i1 %126, i32 %127, i32 %121 + %129 = mul i32 %128, 512 + %130 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %129) + %131 = mul i32 %35, 8 + %132 = add i32 %65, %131 + %133 = add i32 %132, %81 + %134 = add i32 %131, %81 + %135 = and i32 %134, 14 + %136 = shl i32 %135, 3 + %137 = mul i32 %82, 16 + %138 = xor i32 %137, %136 + %139 = mul i32 %133, 256 + %140 = add i32 %138, %139 + %141 = mul i32 %35, 1024 + %142 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %141 + %143 = sext i32 %142 to i64 + %144 = inttoptr i64 %143 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %67, ptr addrspace(3) %144, i32 16, i32 %140, i32 0, i32 0, i32 0) + %145 = add i32 %141, 4096 + %146 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %145 + %147 = sext i32 %146 to i64 + %148 = inttoptr i64 %147 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %67, ptr addrspace(3) %148, i32 16, i32 %140, i32 128, i32 0, i32 0) + call void @llvm.amdgcn.sched.barrier(i32 0) + %149 = mul i32 %90, 16 + %150 = add i32 %149, %91 + %151 = mul i32 %150, 4 + %152 = sdiv i32 %151, 4 + %153 = mul i32 %152, 4 + %154 = icmp ne i32 %151, %153 + %155 = icmp slt i32 %151, 0 + %156 = icmp ne i1 %155, false + %157 = and i1 %154, %156 + %158 = add i32 %152, -1 + %159 = select i1 %157, i32 %158, i32 %152 + %160 = mul i32 %159, 4 + %161 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %69, i32 %160, i32 %130, i32 0) + %162 = add i32 %151, 256 + %163 = sdiv i32 %162, 4 + %164 = mul i32 %163, 4 + %165 = icmp ne i32 %162, %164 + %166 = icmp slt i32 %162, 0 + %167 = icmp ne i1 %166, false + %168 = and i1 %165, %167 + %169 = add i32 %163, -1 + %170 = select i1 %168, i32 %169, i32 %163 + %171 = mul i32 %170, 4 + %172 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %69, i32 %171, i32 %130, i32 0) + %173 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %160, i32 %115, i32 0) + %174 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %160, i32 %120, i32 0) + %175 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %171, i32 %115, i32 0) + %176 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %171, i32 %120, i32 0) + %177 = mul i32 %90, 256 + %178 = mul i32 %91, 16 + %179 = add i32 %177, %178 + %180 = sdiv i32 %179, 4 + %181 = mul i32 %180, 4 + %182 = icmp ne i32 %179, %181 + %183 = icmp slt i32 %179, 0 + %184 = icmp ne i1 %183, false + %185 = and i1 %182, %184 + %186 = add i32 %180, -1 + %187 = select i1 %185, i32 %186, i32 %180 + %188 = mul i32 %187, 4 + %189 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %98, i32 0) + %190 = add i32 %179, 1024 + %191 = sdiv i32 %190, 4 + %192 = mul i32 %191, 4 + %193 = icmp ne i32 %190, %192 + %194 = icmp slt i32 %190, 0 + %195 = icmp ne i1 %194, false + %196 = and i1 %193, %195 + %197 = add i32 %191, -1 + %198 = select i1 %196, i32 %197, i32 %191 + %199 = mul i32 %198, 4 + %200 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %98, i32 0) + %201 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %101, i32 0) + %202 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %101, i32 0) + %203 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %104, i32 0) + %204 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %104, i32 0) + %205 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %107, i32 0) + %206 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %107, i32 0) + %207 = add i32 %179, 2048 + %208 = sdiv i32 %207, 4 + %209 = mul i32 %208, 4 + %210 = icmp ne i32 %207, %209 + %211 = icmp slt i32 %207, 0 + %212 = icmp ne i1 %211, false + %213 = and i1 %210, %212 + %214 = add i32 %208, -1 + %215 = select i1 %213, i32 %214, i32 %208 + %216 = mul i32 %215, 4 + %217 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %98, i32 0) + %218 = add i32 %179, 3072 + %219 = sdiv i32 %218, 4 + %220 = mul i32 %219, 4 + %221 = icmp ne i32 %218, %220 + %222 = icmp slt i32 %218, 0 + %223 = icmp ne i1 %222, false + %224 = and i1 %221, %223 + %225 = add i32 %219, -1 + %226 = select i1 %224, i32 %225, i32 %219 + %227 = mul i32 %226, 4 + %228 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %98, i32 0) + %229 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %101, i32 0) + %230 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %101, i32 0) + %231 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %104, i32 0) + %232 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %104, i32 0) + %233 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %107, i32 0) + %234 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %107, i32 0) + call void asm sideeffect "s_waitcnt vmcnt(23)", ""() + call void asm sideeffect "s_barrier", ""() + %235 = and i32 %91, 14 + %236 = shl i32 %235, 3 + %237 = sext i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32) to i64 + %238 = inttoptr i64 %237 to ptr addrspace(3) + %239 = xor i32 %149, %236 + %240 = mul i32 %91, 128 + %241 = add i32 %240, %239 + %242 = getelementptr i8, ptr addrspace(3) %238, i32 %241 + %243 = load <4 x i32>, ptr addrspace(3) %242, align 16 + %244 = add i32 %91, 16 + %245 = mul i32 %244, 128 + %246 = add i32 %245, %239 + %247 = getelementptr i8, ptr addrspace(3) %238, i32 %246 + %248 = load <4 x i32>, ptr addrspace(3) %247, align 16 + %249 = add i32 %149, 64 + %250 = xor i32 %249, %236 + %251 = add i32 %240, %250 + %252 = getelementptr i8, ptr addrspace(3) %238, i32 %251 + %253 = load <4 x i32>, ptr addrspace(3) %252, align 16 + %254 = add i32 %245, %250 + %255 = getelementptr i8, ptr addrspace(3) %238, i32 %254 + %256 = load <4 x i32>, ptr addrspace(3) %255, align 16 + %257 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %189, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 0, i32 %173) + %258 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %189, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 0, i32 %173) + %259 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %200, <4 x float> %257, i32 4, i32 4, i32 2, i32 %161, i32 2, i32 %173) + %260 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %200, <4 x float> %258, i32 4, i32 4, i32 3, i32 %161, i32 2, i32 %173) + %261 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %201, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 1, i32 %173) + %262 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %201, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 1, i32 %173) + %263 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %202, <4 x float> %261, i32 4, i32 4, i32 2, i32 %161, i32 3, i32 %173) + %264 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %202, <4 x float> %262, i32 4, i32 4, i32 3, i32 %161, i32 3, i32 %173) + %265 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %203, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 0, i32 %174) + %266 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %203, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 0, i32 %174) + %267 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %204, <4 x float> %265, i32 4, i32 4, i32 2, i32 %161, i32 2, i32 %174) + %268 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %204, <4 x float> %266, i32 4, i32 4, i32 3, i32 %161, i32 2, i32 %174) + %269 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %205, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 1, i32 %174) + %270 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %205, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 1, i32 %174) + %271 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %206, <4 x float> %269, i32 4, i32 4, i32 2, i32 %161, i32 3, i32 %174) + %272 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %206, <4 x float> %270, i32 4, i32 4, i32 3, i32 %161, i32 3, i32 %174) + call void asm sideeffect "s_waitcnt vmcnt(22)", ""() + call void asm sideeffect "s_barrier", ""() + %273 = add i32 %240, 4096 + %274 = add i32 %273, %239 + %275 = getelementptr i8, ptr addrspace(3) %238, i32 %274 + %276 = load <4 x i32>, ptr addrspace(3) %275, align 16 + %277 = add i32 %245, 4096 + %278 = add i32 %277, %239 + %279 = getelementptr i8, ptr addrspace(3) %238, i32 %278 + %280 = load <4 x i32>, ptr addrspace(3) %279, align 16 + %281 = add i32 %273, %250 + %282 = getelementptr i8, ptr addrspace(3) %238, i32 %281 + %283 = load <4 x i32>, ptr addrspace(3) %282, align 16 + %284 = add i32 %277, %250 + %285 = getelementptr i8, ptr addrspace(3) %238, i32 %284 + %286 = load <4 x i32>, ptr addrspace(3) %285, align 16 + %287 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %217, <4 x float> %259, i32 4, i32 4, i32 0, i32 %172, i32 0, i32 %175) + %288 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %217, <4 x float> %260, i32 4, i32 4, i32 1, i32 %172, i32 0, i32 %175) + %289 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %228, <4 x float> %287, i32 4, i32 4, i32 2, i32 %172, i32 2, i32 %175) + %290 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %228, <4 x float> %288, i32 4, i32 4, i32 3, i32 %172, i32 2, i32 %175) + %291 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %229, <4 x float> %263, i32 4, i32 4, i32 0, i32 %172, i32 1, i32 %175) + %292 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %229, <4 x float> %264, i32 4, i32 4, i32 1, i32 %172, i32 1, i32 %175) + %293 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %230, <4 x float> %291, i32 4, i32 4, i32 2, i32 %172, i32 3, i32 %175) + %294 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %230, <4 x float> %292, i32 4, i32 4, i32 3, i32 %172, i32 3, i32 %175) + %295 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %231, <4 x float> %267, i32 4, i32 4, i32 0, i32 %172, i32 0, i32 %176) + %296 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %231, <4 x float> %268, i32 4, i32 4, i32 1, i32 %172, i32 0, i32 %176) + %297 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %232, <4 x float> %295, i32 4, i32 4, i32 2, i32 %172, i32 2, i32 %176) + %298 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %232, <4 x float> %296, i32 4, i32 4, i32 3, i32 %172, i32 2, i32 %176) + %299 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %233, <4 x float> %271, i32 4, i32 4, i32 0, i32 %172, i32 1, i32 %176) + %300 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %233, <4 x float> %272, i32 4, i32 4, i32 1, i32 %172, i32 1, i32 %176) + %301 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %234, <4 x float> %299, i32 4, i32 4, i32 2, i32 %172, i32 3, i32 %176) + %302 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %234, <4 x float> %300, i32 4, i32 4, i32 3, i32 %172, i32 3, i32 %176) + %303 = sext i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32) to i64 + %304 = inttoptr i64 %303 to ptr addrspace(3) + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %305 = mul i32 %90, 4 + %306 = add i32 %95, %91 + %307 = mul i32 %90, 1024 + %308 = add i32 %307, %306 + %309 = extractelement <4 x float> %289, i64 0 + %310 = mul i32 %308, 4 + %311 = getelementptr i8, ptr addrspace(3) %304, i32 %310 + store float %309, ptr addrspace(3) %311, align 4 + %312 = add i32 %305, 1 + %313 = mul i32 %312, 256 + %314 = add i32 %313, %306 + %315 = extractelement <4 x float> %289, i64 1 + %316 = mul i32 %314, 4 + %317 = getelementptr i8, ptr addrspace(3) %304, i32 %316 + store float %315, ptr addrspace(3) %317, align 4 + %318 = add i32 %305, 2 + %319 = mul i32 %318, 256 + %320 = add i32 %319, %306 + %321 = extractelement <4 x float> %289, i64 2 + %322 = mul i32 %320, 4 + %323 = getelementptr i8, ptr addrspace(3) %304, i32 %322 + store float %321, ptr addrspace(3) %323, align 4 + %324 = add i32 %305, 3 + %325 = mul i32 %324, 256 + %326 = add i32 %325, %306 + %327 = extractelement <4 x float> %289, i64 3 + %328 = mul i32 %326, 4 + %329 = getelementptr i8, ptr addrspace(3) %304, i32 %328 + store float %327, ptr addrspace(3) %329, align 4 + %330 = add i32 %95, 16 + %331 = add i32 %330, %91 + %332 = add i32 %307, %331 + %333 = extractelement <4 x float> %293, i64 0 + %334 = mul i32 %332, 4 + %335 = getelementptr i8, ptr addrspace(3) %304, i32 %334 + store float %333, ptr addrspace(3) %335, align 4 + %336 = add i32 %313, %331 + %337 = extractelement <4 x float> %293, i64 1 + %338 = mul i32 %336, 4 + %339 = getelementptr i8, ptr addrspace(3) %304, i32 %338 + store float %337, ptr addrspace(3) %339, align 4 + %340 = add i32 %319, %331 + %341 = extractelement <4 x float> %293, i64 2 + %342 = mul i32 %340, 4 + %343 = getelementptr i8, ptr addrspace(3) %304, i32 %342 + store float %341, ptr addrspace(3) %343, align 4 + %344 = add i32 %325, %331 + %345 = extractelement <4 x float> %293, i64 3 + %346 = mul i32 %344, 4 + %347 = getelementptr i8, ptr addrspace(3) %304, i32 %346 + store float %345, ptr addrspace(3) %347, align 4 + %348 = add i32 %95, 32 + %349 = add i32 %348, %91 + %350 = add i32 %307, %349 + %351 = extractelement <4 x float> %297, i64 0 + %352 = mul i32 %350, 4 + %353 = getelementptr i8, ptr addrspace(3) %304, i32 %352 + store float %351, ptr addrspace(3) %353, align 4 + %354 = add i32 %313, %349 + %355 = extractelement <4 x float> %297, i64 1 + %356 = mul i32 %354, 4 + %357 = getelementptr i8, ptr addrspace(3) %304, i32 %356 + store float %355, ptr addrspace(3) %357, align 4 + %358 = add i32 %319, %349 + %359 = extractelement <4 x float> %297, i64 2 + %360 = mul i32 %358, 4 + %361 = getelementptr i8, ptr addrspace(3) %304, i32 %360 + store float %359, ptr addrspace(3) %361, align 4 + %362 = add i32 %325, %349 + %363 = extractelement <4 x float> %297, i64 3 + %364 = mul i32 %362, 4 + %365 = getelementptr i8, ptr addrspace(3) %304, i32 %364 + store float %363, ptr addrspace(3) %365, align 4 + %366 = add i32 %95, 48 + %367 = add i32 %366, %91 + %368 = add i32 %307, %367 + %369 = extractelement <4 x float> %301, i64 0 + %370 = mul i32 %368, 4 + %371 = getelementptr i8, ptr addrspace(3) %304, i32 %370 + store float %369, ptr addrspace(3) %371, align 4 + %372 = add i32 %313, %367 + %373 = extractelement <4 x float> %301, i64 1 + %374 = mul i32 %372, 4 + %375 = getelementptr i8, ptr addrspace(3) %304, i32 %374 + store float %373, ptr addrspace(3) %375, align 4 + %376 = add i32 %319, %367 + %377 = extractelement <4 x float> %301, i64 2 + %378 = mul i32 %376, 4 + %379 = getelementptr i8, ptr addrspace(3) %304, i32 %378 + store float %377, ptr addrspace(3) %379, align 4 + %380 = add i32 %325, %367 + %381 = extractelement <4 x float> %301, i64 3 + %382 = mul i32 %380, 4 + %383 = getelementptr i8, ptr addrspace(3) %304, i32 %382 + store float %381, ptr addrspace(3) %383, align 4 + %384 = add i32 %305, 16 + %385 = mul i32 %384, 256 + %386 = add i32 %385, %306 + %387 = extractelement <4 x float> %290, i64 0 + %388 = mul i32 %386, 4 + %389 = getelementptr i8, ptr addrspace(3) %304, i32 %388 + store float %387, ptr addrspace(3) %389, align 4 + %390 = add i32 %305, 17 + %391 = mul i32 %390, 256 + %392 = add i32 %391, %306 + %393 = extractelement <4 x float> %290, i64 1 + %394 = mul i32 %392, 4 + %395 = getelementptr i8, ptr addrspace(3) %304, i32 %394 + store float %393, ptr addrspace(3) %395, align 4 + %396 = add i32 %305, 18 + %397 = mul i32 %396, 256 + %398 = add i32 %397, %306 + %399 = extractelement <4 x float> %290, i64 2 + %400 = mul i32 %398, 4 + %401 = getelementptr i8, ptr addrspace(3) %304, i32 %400 + store float %399, ptr addrspace(3) %401, align 4 + %402 = add i32 %305, 19 + %403 = mul i32 %402, 256 + %404 = add i32 %403, %306 + %405 = extractelement <4 x float> %290, i64 3 + %406 = mul i32 %404, 4 + %407 = getelementptr i8, ptr addrspace(3) %304, i32 %406 + store float %405, ptr addrspace(3) %407, align 4 + %408 = add i32 %385, %331 + %409 = extractelement <4 x float> %294, i64 0 + %410 = mul i32 %408, 4 + %411 = getelementptr i8, ptr addrspace(3) %304, i32 %410 + store float %409, ptr addrspace(3) %411, align 4 + %412 = add i32 %391, %331 + %413 = extractelement <4 x float> %294, i64 1 + %414 = mul i32 %412, 4 + %415 = getelementptr i8, ptr addrspace(3) %304, i32 %414 + store float %413, ptr addrspace(3) %415, align 4 + %416 = add i32 %397, %331 + %417 = extractelement <4 x float> %294, i64 2 + %418 = mul i32 %416, 4 + %419 = getelementptr i8, ptr addrspace(3) %304, i32 %418 + store float %417, ptr addrspace(3) %419, align 4 + %420 = add i32 %403, %331 + %421 = extractelement <4 x float> %294, i64 3 + %422 = mul i32 %420, 4 + %423 = getelementptr i8, ptr addrspace(3) %304, i32 %422 + store float %421, ptr addrspace(3) %423, align 4 + %424 = add i32 %385, %349 + %425 = extractelement <4 x float> %298, i64 0 + %426 = mul i32 %424, 4 + %427 = getelementptr i8, ptr addrspace(3) %304, i32 %426 + store float %425, ptr addrspace(3) %427, align 4 + %428 = add i32 %391, %349 + %429 = extractelement <4 x float> %298, i64 1 + %430 = mul i32 %428, 4 + %431 = getelementptr i8, ptr addrspace(3) %304, i32 %430 + store float %429, ptr addrspace(3) %431, align 4 + %432 = add i32 %397, %349 + %433 = extractelement <4 x float> %298, i64 2 + %434 = mul i32 %432, 4 + %435 = getelementptr i8, ptr addrspace(3) %304, i32 %434 + store float %433, ptr addrspace(3) %435, align 4 + %436 = add i32 %403, %349 + %437 = extractelement <4 x float> %298, i64 3 + %438 = mul i32 %436, 4 + %439 = getelementptr i8, ptr addrspace(3) %304, i32 %438 + store float %437, ptr addrspace(3) %439, align 4 + %440 = add i32 %385, %367 + %441 = extractelement <4 x float> %302, i64 0 + %442 = mul i32 %440, 4 + %443 = getelementptr i8, ptr addrspace(3) %304, i32 %442 + store float %441, ptr addrspace(3) %443, align 4 + %444 = add i32 %391, %367 + %445 = extractelement <4 x float> %302, i64 1 + %446 = mul i32 %444, 4 + %447 = getelementptr i8, ptr addrspace(3) %304, i32 %446 + store float %445, ptr addrspace(3) %447, align 4 + %448 = add i32 %397, %367 + %449 = extractelement <4 x float> %302, i64 2 + %450 = mul i32 %448, 4 + %451 = getelementptr i8, ptr addrspace(3) %304, i32 %450 + store float %449, ptr addrspace(3) %451, align 4 + %452 = add i32 %403, %367 + %453 = extractelement <4 x float> %302, i64 3 + %454 = mul i32 %452, 4 + %455 = getelementptr i8, ptr addrspace(3) %304, i32 %454 + store float %453, ptr addrspace(3) %455, align 4 + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %456 = sdiv i32 %24, 32 + %457 = mul i32 %456, 32 + %458 = icmp ne i32 %24, %457 + %459 = icmp slt i32 %24, 0 + %460 = icmp ne i1 %459, false + %461 = and i1 %458, %460 + %462 = add i32 %456, -1 + %463 = select i1 %461, i32 %462, i32 %456 + %464 = srem i32 %24, 32 + %465 = mul i32 %464, 2 + %466 = ptrtoint ptr addrspace(1) %12 to i64 + %467 = inttoptr i64 %466 to ptr addrspace(1) + %468 = ptrtoint ptr addrspace(1) %14 to i64 + %469 = inttoptr i64 %468 to ptr addrspace(1) + %470 = ptrtoint ptr addrspace(1) %17 to i64 + %471 = inttoptr i64 %470 to ptr addrspace(1) + %472 = add i32 %65, %463 + %473 = mul i32 %472, 4 + %474 = getelementptr i8, ptr addrspace(1) %467, i32 %473 + %475 = load i32, ptr addrspace(1) %474, align 4 + %476 = and i32 %475, 16777215 + %477 = icmp slt i32 %476, %16 + %478 = getelementptr i8, ptr addrspace(1) %469, i32 %473 + %479 = load float, ptr addrspace(1) %478, align 4 + br i1 %477, label %480, label %552 + +480: ; preds = %49 + %481 = mul i32 %476, 7168 + %482 = add i32 %481, %93 + %483 = add i32 %482, %465 + %484 = mul i32 %463, 256 + %485 = add i32 %484, %465 + %486 = mul i32 %485, 4 + %487 = getelementptr i8, ptr addrspace(3) %304, i32 %486 + %488 = load float, ptr addrspace(3) %487, align 4 + %489 = fmul float %488, %479 + %490 = add i32 %485, 1 + %491 = mul i32 %490, 4 + %492 = getelementptr i8, ptr addrspace(3) %304, i32 %491 + %493 = load float, ptr addrspace(3) %492, align 4 + %494 = fmul float %493, %479 + %495 = insertelement <2 x float> poison, float %489, i64 0 + %496 = insertelement <2 x float> %495, float %494, i64 1 + %497 = fptrunc <2 x float> %496 to <2 x bfloat> + %498 = mul i32 %483, 2 + %499 = getelementptr i8, ptr addrspace(1) %471, i32 %498 + %500 = atomicrmw fadd ptr addrspace(1) %499, <2 x bfloat> %497 syncscope("agent") monotonic, align 4 + %501 = add i32 %485, 64 + %502 = mul i32 %501, 4 + %503 = getelementptr i8, ptr addrspace(3) %304, i32 %502 + %504 = load float, ptr addrspace(3) %503, align 4 + %505 = fmul float %504, %479 + %506 = add i32 %485, 65 + %507 = mul i32 %506, 4 + %508 = getelementptr i8, ptr addrspace(3) %304, i32 %507 + %509 = load float, ptr addrspace(3) %508, align 4 + %510 = fmul float %509, %479 + %511 = insertelement <2 x float> poison, float %505, i64 0 + %512 = insertelement <2 x float> %511, float %510, i64 1 + %513 = fptrunc <2 x float> %512 to <2 x bfloat> + %514 = add i32 %483, 64 + %515 = mul i32 %514, 2 + %516 = getelementptr i8, ptr addrspace(1) %471, i32 %515 + %517 = atomicrmw fadd ptr addrspace(1) %516, <2 x bfloat> %513 syncscope("agent") monotonic, align 4 + %518 = add i32 %485, 128 + %519 = mul i32 %518, 4 + %520 = getelementptr i8, ptr addrspace(3) %304, i32 %519 + %521 = load float, ptr addrspace(3) %520, align 4 + %522 = fmul float %521, %479 + %523 = add i32 %485, 129 + %524 = mul i32 %523, 4 + %525 = getelementptr i8, ptr addrspace(3) %304, i32 %524 + %526 = load float, ptr addrspace(3) %525, align 4 + %527 = fmul float %526, %479 + %528 = insertelement <2 x float> poison, float %522, i64 0 + %529 = insertelement <2 x float> %528, float %527, i64 1 + %530 = fptrunc <2 x float> %529 to <2 x bfloat> + %531 = add i32 %483, 128 + %532 = mul i32 %531, 2 + %533 = getelementptr i8, ptr addrspace(1) %471, i32 %532 + %534 = atomicrmw fadd ptr addrspace(1) %533, <2 x bfloat> %530 syncscope("agent") monotonic, align 4 + %535 = add i32 %485, 192 + %536 = mul i32 %535, 4 + %537 = getelementptr i8, ptr addrspace(3) %304, i32 %536 + %538 = load float, ptr addrspace(3) %537, align 4 + %539 = fmul float %538, %479 + %540 = add i32 %485, 193 + %541 = mul i32 %540, 4 + %542 = getelementptr i8, ptr addrspace(3) %304, i32 %541 + %543 = load float, ptr addrspace(3) %542, align 4 + %544 = fmul float %543, %479 + %545 = insertelement <2 x float> poison, float %539, i64 0 + %546 = insertelement <2 x float> %545, float %544, i64 1 + %547 = fptrunc <2 x float> %546 to <2 x bfloat> + %548 = add i32 %483, 192 + %549 = mul i32 %548, 2 + %550 = getelementptr i8, ptr addrspace(1) %471, i32 %549 + %551 = atomicrmw fadd ptr addrspace(1) %550, <2 x bfloat> %547 syncscope("agent") monotonic, align 4 + br label %552 + +552: ; preds = %480, %49 + %553 = add i32 %463, 8 + %554 = add i32 %65, %553 + %555 = mul i32 %554, 4 + %556 = getelementptr i8, ptr addrspace(1) %467, i32 %555 + %557 = load i32, ptr addrspace(1) %556, align 4 + %558 = and i32 %557, 16777215 + %559 = icmp slt i32 %558, %16 + %560 = getelementptr i8, ptr addrspace(1) %469, i32 %555 + %561 = load float, ptr addrspace(1) %560, align 4 + br i1 %559, label %562, label %634 + +562: ; preds = %552 + %563 = mul i32 %558, 7168 + %564 = add i32 %563, %93 + %565 = add i32 %564, %465 + %566 = mul i32 %553, 256 + %567 = add i32 %566, %465 + %568 = mul i32 %567, 4 + %569 = getelementptr i8, ptr addrspace(3) %304, i32 %568 + %570 = load float, ptr addrspace(3) %569, align 4 + %571 = fmul float %570, %561 + %572 = add i32 %567, 1 + %573 = mul i32 %572, 4 + %574 = getelementptr i8, ptr addrspace(3) %304, i32 %573 + %575 = load float, ptr addrspace(3) %574, align 4 + %576 = fmul float %575, %561 + %577 = insertelement <2 x float> poison, float %571, i64 0 + %578 = insertelement <2 x float> %577, float %576, i64 1 + %579 = fptrunc <2 x float> %578 to <2 x bfloat> + %580 = mul i32 %565, 2 + %581 = getelementptr i8, ptr addrspace(1) %471, i32 %580 + %582 = atomicrmw fadd ptr addrspace(1) %581, <2 x bfloat> %579 syncscope("agent") monotonic, align 4 + %583 = add i32 %567, 64 + %584 = mul i32 %583, 4 + %585 = getelementptr i8, ptr addrspace(3) %304, i32 %584 + %586 = load float, ptr addrspace(3) %585, align 4 + %587 = fmul float %586, %561 + %588 = add i32 %567, 65 + %589 = mul i32 %588, 4 + %590 = getelementptr i8, ptr addrspace(3) %304, i32 %589 + %591 = load float, ptr addrspace(3) %590, align 4 + %592 = fmul float %591, %561 + %593 = insertelement <2 x float> poison, float %587, i64 0 + %594 = insertelement <2 x float> %593, float %592, i64 1 + %595 = fptrunc <2 x float> %594 to <2 x bfloat> + %596 = add i32 %565, 64 + %597 = mul i32 %596, 2 + %598 = getelementptr i8, ptr addrspace(1) %471, i32 %597 + %599 = atomicrmw fadd ptr addrspace(1) %598, <2 x bfloat> %595 syncscope("agent") monotonic, align 4 + %600 = add i32 %567, 128 + %601 = mul i32 %600, 4 + %602 = getelementptr i8, ptr addrspace(3) %304, i32 %601 + %603 = load float, ptr addrspace(3) %602, align 4 + %604 = fmul float %603, %561 + %605 = add i32 %567, 129 + %606 = mul i32 %605, 4 + %607 = getelementptr i8, ptr addrspace(3) %304, i32 %606 + %608 = load float, ptr addrspace(3) %607, align 4 + %609 = fmul float %608, %561 + %610 = insertelement <2 x float> poison, float %604, i64 0 + %611 = insertelement <2 x float> %610, float %609, i64 1 + %612 = fptrunc <2 x float> %611 to <2 x bfloat> + %613 = add i32 %565, 128 + %614 = mul i32 %613, 2 + %615 = getelementptr i8, ptr addrspace(1) %471, i32 %614 + %616 = atomicrmw fadd ptr addrspace(1) %615, <2 x bfloat> %612 syncscope("agent") monotonic, align 4 + %617 = add i32 %567, 192 + %618 = mul i32 %617, 4 + %619 = getelementptr i8, ptr addrspace(3) %304, i32 %618 + %620 = load float, ptr addrspace(3) %619, align 4 + %621 = fmul float %620, %561 + %622 = add i32 %567, 193 + %623 = mul i32 %622, 4 + %624 = getelementptr i8, ptr addrspace(3) %304, i32 %623 + %625 = load float, ptr addrspace(3) %624, align 4 + %626 = fmul float %625, %561 + %627 = insertelement <2 x float> poison, float %621, i64 0 + %628 = insertelement <2 x float> %627, float %626, i64 1 + %629 = fptrunc <2 x float> %628 to <2 x bfloat> + %630 = add i32 %565, 192 + %631 = mul i32 %630, 2 + %632 = getelementptr i8, ptr addrspace(1) %471, i32 %631 + %633 = atomicrmw fadd ptr addrspace(1) %632, <2 x bfloat> %629 syncscope("agent") monotonic, align 4 + br label %634 + +634: ; preds = %562, %552 + %635 = add i32 %463, 16 + %636 = add i32 %65, %635 + %637 = mul i32 %636, 4 + %638 = getelementptr i8, ptr addrspace(1) %467, i32 %637 + %639 = load i32, ptr addrspace(1) %638, align 4 + %640 = and i32 %639, 16777215 + %641 = icmp slt i32 %640, %16 + %642 = getelementptr i8, ptr addrspace(1) %469, i32 %637 + %643 = load float, ptr addrspace(1) %642, align 4 + br i1 %641, label %644, label %716 + +644: ; preds = %634 + %645 = mul i32 %640, 7168 + %646 = add i32 %645, %93 + %647 = add i32 %646, %465 + %648 = mul i32 %635, 256 + %649 = add i32 %648, %465 + %650 = mul i32 %649, 4 + %651 = getelementptr i8, ptr addrspace(3) %304, i32 %650 + %652 = load float, ptr addrspace(3) %651, align 4 + %653 = fmul float %652, %643 + %654 = add i32 %649, 1 + %655 = mul i32 %654, 4 + %656 = getelementptr i8, ptr addrspace(3) %304, i32 %655 + %657 = load float, ptr addrspace(3) %656, align 4 + %658 = fmul float %657, %643 + %659 = insertelement <2 x float> poison, float %653, i64 0 + %660 = insertelement <2 x float> %659, float %658, i64 1 + %661 = fptrunc <2 x float> %660 to <2 x bfloat> + %662 = mul i32 %647, 2 + %663 = getelementptr i8, ptr addrspace(1) %471, i32 %662 + %664 = atomicrmw fadd ptr addrspace(1) %663, <2 x bfloat> %661 syncscope("agent") monotonic, align 4 + %665 = add i32 %649, 64 + %666 = mul i32 %665, 4 + %667 = getelementptr i8, ptr addrspace(3) %304, i32 %666 + %668 = load float, ptr addrspace(3) %667, align 4 + %669 = fmul float %668, %643 + %670 = add i32 %649, 65 + %671 = mul i32 %670, 4 + %672 = getelementptr i8, ptr addrspace(3) %304, i32 %671 + %673 = load float, ptr addrspace(3) %672, align 4 + %674 = fmul float %673, %643 + %675 = insertelement <2 x float> poison, float %669, i64 0 + %676 = insertelement <2 x float> %675, float %674, i64 1 + %677 = fptrunc <2 x float> %676 to <2 x bfloat> + %678 = add i32 %647, 64 + %679 = mul i32 %678, 2 + %680 = getelementptr i8, ptr addrspace(1) %471, i32 %679 + %681 = atomicrmw fadd ptr addrspace(1) %680, <2 x bfloat> %677 syncscope("agent") monotonic, align 4 + %682 = add i32 %649, 128 + %683 = mul i32 %682, 4 + %684 = getelementptr i8, ptr addrspace(3) %304, i32 %683 + %685 = load float, ptr addrspace(3) %684, align 4 + %686 = fmul float %685, %643 + %687 = add i32 %649, 129 + %688 = mul i32 %687, 4 + %689 = getelementptr i8, ptr addrspace(3) %304, i32 %688 + %690 = load float, ptr addrspace(3) %689, align 4 + %691 = fmul float %690, %643 + %692 = insertelement <2 x float> poison, float %686, i64 0 + %693 = insertelement <2 x float> %692, float %691, i64 1 + %694 = fptrunc <2 x float> %693 to <2 x bfloat> + %695 = add i32 %647, 128 + %696 = mul i32 %695, 2 + %697 = getelementptr i8, ptr addrspace(1) %471, i32 %696 + %698 = atomicrmw fadd ptr addrspace(1) %697, <2 x bfloat> %694 syncscope("agent") monotonic, align 4 + %699 = add i32 %649, 192 + %700 = mul i32 %699, 4 + %701 = getelementptr i8, ptr addrspace(3) %304, i32 %700 + %702 = load float, ptr addrspace(3) %701, align 4 + %703 = fmul float %702, %643 + %704 = add i32 %649, 193 + %705 = mul i32 %704, 4 + %706 = getelementptr i8, ptr addrspace(3) %304, i32 %705 + %707 = load float, ptr addrspace(3) %706, align 4 + %708 = fmul float %707, %643 + %709 = insertelement <2 x float> poison, float %703, i64 0 + %710 = insertelement <2 x float> %709, float %708, i64 1 + %711 = fptrunc <2 x float> %710 to <2 x bfloat> + %712 = add i32 %647, 192 + %713 = mul i32 %712, 2 + %714 = getelementptr i8, ptr addrspace(1) %471, i32 %713 + %715 = atomicrmw fadd ptr addrspace(1) %714, <2 x bfloat> %711 syncscope("agent") monotonic, align 4 + br label %716 + +716: ; preds = %644, %634 + %717 = add i32 %463, 24 + %718 = add i32 %65, %717 + %719 = mul i32 %718, 4 + %720 = getelementptr i8, ptr addrspace(1) %467, i32 %719 + %721 = load i32, ptr addrspace(1) %720, align 4 + %722 = and i32 %721, 16777215 + %723 = icmp slt i32 %722, %16 + %724 = getelementptr i8, ptr addrspace(1) %469, i32 %719 + %725 = load float, ptr addrspace(1) %724, align 4 + br i1 %723, label %726, label %798 + +726: ; preds = %716 + %727 = mul i32 %722, 7168 + %728 = add i32 %727, %93 + %729 = add i32 %728, %465 + %730 = mul i32 %717, 256 + %731 = add i32 %730, %465 + %732 = mul i32 %731, 4 + %733 = getelementptr i8, ptr addrspace(3) %304, i32 %732 + %734 = load float, ptr addrspace(3) %733, align 4 + %735 = fmul float %734, %725 + %736 = add i32 %731, 1 + %737 = mul i32 %736, 4 + %738 = getelementptr i8, ptr addrspace(3) %304, i32 %737 + %739 = load float, ptr addrspace(3) %738, align 4 + %740 = fmul float %739, %725 + %741 = insertelement <2 x float> poison, float %735, i64 0 + %742 = insertelement <2 x float> %741, float %740, i64 1 + %743 = fptrunc <2 x float> %742 to <2 x bfloat> + %744 = mul i32 %729, 2 + %745 = getelementptr i8, ptr addrspace(1) %471, i32 %744 + %746 = atomicrmw fadd ptr addrspace(1) %745, <2 x bfloat> %743 syncscope("agent") monotonic, align 4 + %747 = add i32 %731, 64 + %748 = mul i32 %747, 4 + %749 = getelementptr i8, ptr addrspace(3) %304, i32 %748 + %750 = load float, ptr addrspace(3) %749, align 4 + %751 = fmul float %750, %725 + %752 = add i32 %731, 65 + %753 = mul i32 %752, 4 + %754 = getelementptr i8, ptr addrspace(3) %304, i32 %753 + %755 = load float, ptr addrspace(3) %754, align 4 + %756 = fmul float %755, %725 + %757 = insertelement <2 x float> poison, float %751, i64 0 + %758 = insertelement <2 x float> %757, float %756, i64 1 + %759 = fptrunc <2 x float> %758 to <2 x bfloat> + %760 = add i32 %729, 64 + %761 = mul i32 %760, 2 + %762 = getelementptr i8, ptr addrspace(1) %471, i32 %761 + %763 = atomicrmw fadd ptr addrspace(1) %762, <2 x bfloat> %759 syncscope("agent") monotonic, align 4 + %764 = add i32 %731, 128 + %765 = mul i32 %764, 4 + %766 = getelementptr i8, ptr addrspace(3) %304, i32 %765 + %767 = load float, ptr addrspace(3) %766, align 4 + %768 = fmul float %767, %725 + %769 = add i32 %731, 129 + %770 = mul i32 %769, 4 + %771 = getelementptr i8, ptr addrspace(3) %304, i32 %770 + %772 = load float, ptr addrspace(3) %771, align 4 + %773 = fmul float %772, %725 + %774 = insertelement <2 x float> poison, float %768, i64 0 + %775 = insertelement <2 x float> %774, float %773, i64 1 + %776 = fptrunc <2 x float> %775 to <2 x bfloat> + %777 = add i32 %729, 128 + %778 = mul i32 %777, 2 + %779 = getelementptr i8, ptr addrspace(1) %471, i32 %778 + %780 = atomicrmw fadd ptr addrspace(1) %779, <2 x bfloat> %776 syncscope("agent") monotonic, align 4 + %781 = add i32 %731, 192 + %782 = mul i32 %781, 4 + %783 = getelementptr i8, ptr addrspace(3) %304, i32 %782 + %784 = load float, ptr addrspace(3) %783, align 4 + %785 = fmul float %784, %725 + %786 = add i32 %731, 193 + %787 = mul i32 %786, 4 + %788 = getelementptr i8, ptr addrspace(3) %304, i32 %787 + %789 = load float, ptr addrspace(3) %788, align 4 + %790 = fmul float %789, %725 + %791 = insertelement <2 x float> poison, float %785, i64 0 + %792 = insertelement <2 x float> %791, float %790, i64 1 + %793 = fptrunc <2 x float> %792 to <2 x bfloat> + %794 = add i32 %729, 192 + %795 = mul i32 %794, 2 + %796 = getelementptr i8, ptr addrspace(1) %471, i32 %795 + %797 = atomicrmw fadd ptr addrspace(1) %796, <2 x bfloat> %793 syncscope("agent") monotonic, align 4 + br label %798 + +798: ; preds = %726, %716 + br label %799 + +799: ; preds = %798, %19 + ret void +} + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) +declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 + +; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) +declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #3 + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #4 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.sched.barrier(i32 immarg) #5 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) +declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #7 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.s.barrier() #5 + +attributes #0 = { "amdgpu-flat-work-group-size"="256,256" "uniform-work-group-size" } +attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } +attributes #2 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } +attributes #3 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } +attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } +attributes #5 = { convergent nocallback nofree nounwind willreturn } +attributes #6 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } +attributes #7 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = !{i32 256, i32 1, i32 1} diff --git a/kernels/gemm2_port_ref/flydsl_port_v6.ll b/kernels/gemm2_port_ref/flydsl_port_v6.ll new file mode 100644 index 000000000..2c8f198bc --- /dev/null +++ b/kernels/gemm2_port_ref/flydsl_port_v6.ll @@ -0,0 +1,866 @@ +; ModuleID = 'LLVMDialectModule' +source_filename = "LLVMDialectModule" +target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" + +@gemm2port_smem = external addrspace(3) global [32768 x i8], align 1024 + +define amdgpu_kernel void @gemm2_a4w4_port_bm32_atomic(ptr addrspace(1) %0, <{ <{ i32, i32 }>, <{ i64 }> }> %1, ptr addrspace(1) %2, <{ <{ i32, i32 }>, <{ i64 }> }> %3, ptr addrspace(1) %4, <{ <{ i32, i32, i32 }>, <{ i64, i64 }> }> %5, ptr addrspace(1) %6, <{ <{ i32, i32 }>, <{ i64 }> }> %7, ptr addrspace(1) %8, <{ <{ i32 }> }> %9, ptr addrspace(1) %10, <{ <{ i32 }> }> %11, ptr addrspace(1) %12, <{ <{ i32 }> }> %13, ptr addrspace(1) %14, <{ <{ i32 }> }> %15, i32 %16, ptr addrspace(1) %17, <{ <{ i32, i32 }>, <{ i64 }> }> %18) #0 !reqd_work_group_size !1 { + %20 = call range(i32 0, 256) i32 @llvm.amdgcn.workitem.id.x() + %21 = sext i32 %20 to i64 + %22 = call i32 @llvm.amdgcn.workgroup.id.x() + %23 = sext i32 %22 to i64 + %24 = trunc i64 %21 to i32 + %25 = trunc i64 %23 to i32 + %26 = srem i32 %24, 64 + %27 = sdiv i32 %24, 64 + %28 = mul i32 %27, 64 + %29 = icmp ne i32 %24, %28 + %30 = icmp slt i32 %24, 0 + %31 = icmp ne i1 %30, false + %32 = and i1 %29, %31 + %33 = add i32 %27, -1 + %34 = select i1 %32, i32 %33, i32 %27 + %35 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %34) + %36 = ptrtoint ptr addrspace(1) %10 to i64 + %37 = inttoptr i64 %36 to ptr addrspace(1) + %38 = load i32, ptr addrspace(1) %37, align 4 + %39 = sdiv i32 %38, 32 + %40 = mul i32 %39, 32 + %41 = icmp ne i32 %38, %40 + %42 = icmp slt i32 %38, 0 + %43 = icmp ne i1 %42, false + %44 = and i1 %41, %43 + %45 = add i32 %39, -1 + %46 = select i1 %44, i32 %45, i32 %39 + %47 = mul i32 %46, 28 + %48 = icmp slt i32 %25, %47 + br i1 %48, label %49, label %767 + +49: ; preds = %19 + %50 = srem i32 %25, 28 + %51 = sdiv i32 %25, 28 + %52 = mul i32 %51, 28 + %53 = icmp ne i32 %25, %52 + %54 = icmp slt i32 %25, 0 + %55 = icmp ne i1 %54, false + %56 = and i1 %53, %55 + %57 = add i32 %51, -1 + %58 = select i1 %56, i32 %57, i32 %51 + %59 = mul i32 %58, 4 + %60 = ptrtoint ptr addrspace(1) %8 to i64 + %61 = inttoptr i64 %60 to ptr addrspace(1) + %62 = getelementptr i8, ptr addrspace(1) %61, i32 %59 + %63 = load i32, ptr addrspace(1) %62, align 4 + %64 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %63) + %65 = mul i32 %58, 32 + %66 = addrspacecast ptr addrspace(1) %0 to ptr + %67 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %66, i16 0, i64 167772160, i32 159744) + %68 = addrspacecast ptr addrspace(1) %2 to ptr + %69 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %68, i16 0, i64 10485760, i32 159744) + %70 = addrspacecast ptr addrspace(1) %4 to ptr + %71 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %70, i16 0, i64 706478080, i32 159744) + %72 = addrspacecast ptr addrspace(1) %6 to ptr + %73 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %72, i16 0, i64 44154880, i32 159744) + %74 = sdiv i32 %26, 8 + %75 = mul i32 %74, 8 + %76 = icmp ne i32 %26, %75 + %77 = icmp slt i32 %26, 0 + %78 = icmp ne i1 %77, false + %79 = and i1 %76, %78 + %80 = add i32 %74, -1 + %81 = select i1 %79, i32 %80, i32 %74 + %82 = srem i32 %26, 8 + %83 = sdiv i32 %26, 16 + %84 = mul i32 %83, 16 + %85 = icmp ne i32 %26, %84 + %86 = icmp slt i32 %26, 0 + %87 = icmp ne i1 %86, false + %88 = and i1 %85, %87 + %89 = add i32 %83, -1 + %90 = select i1 %88, i32 %89, i32 %83 + %91 = srem i32 %26, 16 + %92 = mul i32 %64, 7168 + %93 = mul i32 %50, 256 + %94 = add i32 %92, %93 + %95 = mul i32 %35, 64 + %96 = add i32 %94, %95 + %97 = mul i32 %96, 256 + %98 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %97) + %99 = add i32 %96, 16 + %100 = mul i32 %99, 256 + %101 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %100) + %102 = add i32 %96, 32 + %103 = mul i32 %102, 256 + %104 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %103) + %105 = add i32 %96, 48 + %106 = mul i32 %105, 256 + %107 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %106) + %108 = mul i32 %50, 8 + %109 = mul i32 %35, 2 + %110 = add i32 %108, %109 + %111 = mul i32 %64, 28672 + %112 = mul i32 %110, 128 + %113 = add i32 %111, %112 + %114 = mul i32 %113, 4 + %115 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %114) + %116 = add i32 %110, 1 + %117 = mul i32 %116, 128 + %118 = add i32 %111, %117 + %119 = mul i32 %118, 4 + %120 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %119) + %121 = sdiv i32 %65, 32 + %122 = mul i32 %121, 32 + %123 = icmp ne i32 %65, %122 + %124 = icmp slt i32 %65, 0 + %125 = icmp ne i1 %124, false + %126 = and i1 %123, %125 + %127 = add i32 %121, -1 + %128 = select i1 %126, i32 %127, i32 %121 + %129 = mul i32 %128, 512 + %130 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %129) + %131 = mul i32 %35, 8 + %132 = add i32 %65, %131 + %133 = add i32 %132, %81 + %134 = add i32 %131, %81 + %135 = and i32 %134, 14 + %136 = shl i32 %135, 3 + %137 = mul i32 %82, 16 + %138 = xor i32 %137, %136 + %139 = mul i32 %133, 256 + %140 = add i32 %138, %139 + %141 = mul i32 %35, 1024 + %142 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %141 + %143 = sext i32 %142 to i64 + %144 = inttoptr i64 %143 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %67, ptr addrspace(3) %144, i32 16, i32 %140, i32 0, i32 0, i32 0) + %145 = add i32 %141, 4096 + %146 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %145 + %147 = sext i32 %146 to i64 + %148 = inttoptr i64 %147 to ptr addrspace(3) + call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %67, ptr addrspace(3) %148, i32 16, i32 %140, i32 128, i32 0, i32 0) + call void @llvm.amdgcn.sched.barrier(i32 0) + %149 = mul i32 %90, 16 + %150 = add i32 %149, %91 + %151 = mul i32 %150, 4 + %152 = sdiv i32 %151, 4 + %153 = mul i32 %152, 4 + %154 = icmp ne i32 %151, %153 + %155 = icmp slt i32 %151, 0 + %156 = icmp ne i1 %155, false + %157 = and i1 %154, %156 + %158 = add i32 %152, -1 + %159 = select i1 %157, i32 %158, i32 %152 + %160 = mul i32 %159, 4 + %161 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %69, i32 %160, i32 %130, i32 0) + %162 = add i32 %151, 256 + %163 = sdiv i32 %162, 4 + %164 = mul i32 %163, 4 + %165 = icmp ne i32 %162, %164 + %166 = icmp slt i32 %162, 0 + %167 = icmp ne i1 %166, false + %168 = and i1 %165, %167 + %169 = add i32 %163, -1 + %170 = select i1 %168, i32 %169, i32 %163 + %171 = mul i32 %170, 4 + %172 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %69, i32 %171, i32 %130, i32 0) + %173 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %160, i32 %115, i32 0) + %174 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %160, i32 %120, i32 0) + %175 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %171, i32 %115, i32 0) + %176 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %171, i32 %120, i32 0) + %177 = mul i32 %90, 256 + %178 = mul i32 %91, 16 + %179 = add i32 %177, %178 + %180 = sdiv i32 %179, 4 + %181 = mul i32 %180, 4 + %182 = icmp ne i32 %179, %181 + %183 = icmp slt i32 %179, 0 + %184 = icmp ne i1 %183, false + %185 = and i1 %182, %184 + %186 = add i32 %180, -1 + %187 = select i1 %185, i32 %186, i32 %180 + %188 = mul i32 %187, 4 + %189 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %98, i32 0) + %190 = add i32 %179, 1024 + %191 = sdiv i32 %190, 4 + %192 = mul i32 %191, 4 + %193 = icmp ne i32 %190, %192 + %194 = icmp slt i32 %190, 0 + %195 = icmp ne i1 %194, false + %196 = and i1 %193, %195 + %197 = add i32 %191, -1 + %198 = select i1 %196, i32 %197, i32 %191 + %199 = mul i32 %198, 4 + %200 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %98, i32 0) + %201 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %101, i32 0) + %202 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %101, i32 0) + %203 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %104, i32 0) + %204 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %104, i32 0) + %205 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %107, i32 0) + %206 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %107, i32 0) + %207 = add i32 %179, 2048 + %208 = sdiv i32 %207, 4 + %209 = mul i32 %208, 4 + %210 = icmp ne i32 %207, %209 + %211 = icmp slt i32 %207, 0 + %212 = icmp ne i1 %211, false + %213 = and i1 %210, %212 + %214 = add i32 %208, -1 + %215 = select i1 %213, i32 %214, i32 %208 + %216 = mul i32 %215, 4 + %217 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %98, i32 0) + %218 = add i32 %179, 3072 + %219 = sdiv i32 %218, 4 + %220 = mul i32 %219, 4 + %221 = icmp ne i32 %218, %220 + %222 = icmp slt i32 %218, 0 + %223 = icmp ne i1 %222, false + %224 = and i1 %221, %223 + %225 = add i32 %219, -1 + %226 = select i1 %224, i32 %225, i32 %219 + %227 = mul i32 %226, 4 + %228 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %98, i32 0) + %229 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %101, i32 0) + %230 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %101, i32 0) + %231 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %104, i32 0) + %232 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %104, i32 0) + %233 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %107, i32 0) + %234 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %107, i32 0) + call void asm sideeffect "s_waitcnt vmcnt(23)", ""() + call void asm sideeffect "s_barrier", ""() + %235 = and i32 %91, 14 + %236 = shl i32 %235, 3 + %237 = sext i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32) to i64 + %238 = inttoptr i64 %237 to ptr addrspace(3) + %239 = xor i32 %149, %236 + %240 = mul i32 %91, 128 + %241 = add i32 %240, %239 + %242 = getelementptr i8, ptr addrspace(3) %238, i32 %241 + %243 = load <4 x i32>, ptr addrspace(3) %242, align 16 + %244 = add i32 %91, 16 + %245 = mul i32 %244, 128 + %246 = add i32 %245, %239 + %247 = getelementptr i8, ptr addrspace(3) %238, i32 %246 + %248 = load <4 x i32>, ptr addrspace(3) %247, align 16 + %249 = add i32 %149, 64 + %250 = xor i32 %249, %236 + %251 = add i32 %240, %250 + %252 = getelementptr i8, ptr addrspace(3) %238, i32 %251 + %253 = load <4 x i32>, ptr addrspace(3) %252, align 16 + %254 = add i32 %245, %250 + %255 = getelementptr i8, ptr addrspace(3) %238, i32 %254 + %256 = load <4 x i32>, ptr addrspace(3) %255, align 16 + %257 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %189, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 0, i32 %173) + %258 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %189, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 0, i32 %173) + %259 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %200, <4 x float> %257, i32 4, i32 4, i32 2, i32 %161, i32 2, i32 %173) + %260 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %200, <4 x float> %258, i32 4, i32 4, i32 3, i32 %161, i32 2, i32 %173) + %261 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %201, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 1, i32 %173) + %262 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %201, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 1, i32 %173) + %263 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %202, <4 x float> %261, i32 4, i32 4, i32 2, i32 %161, i32 3, i32 %173) + %264 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %202, <4 x float> %262, i32 4, i32 4, i32 3, i32 %161, i32 3, i32 %173) + %265 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %203, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 0, i32 %174) + %266 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %203, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 0, i32 %174) + %267 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %204, <4 x float> %265, i32 4, i32 4, i32 2, i32 %161, i32 2, i32 %174) + %268 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %204, <4 x float> %266, i32 4, i32 4, i32 3, i32 %161, i32 2, i32 %174) + %269 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %205, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 1, i32 %174) + %270 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %205, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 1, i32 %174) + %271 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %206, <4 x float> %269, i32 4, i32 4, i32 2, i32 %161, i32 3, i32 %174) + %272 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %206, <4 x float> %270, i32 4, i32 4, i32 3, i32 %161, i32 3, i32 %174) + call void asm sideeffect "s_waitcnt vmcnt(22)", ""() + call void asm sideeffect "s_barrier", ""() + %273 = add i32 %240, 4096 + %274 = add i32 %273, %239 + %275 = getelementptr i8, ptr addrspace(3) %238, i32 %274 + %276 = load <4 x i32>, ptr addrspace(3) %275, align 16 + %277 = add i32 %245, 4096 + %278 = add i32 %277, %239 + %279 = getelementptr i8, ptr addrspace(3) %238, i32 %278 + %280 = load <4 x i32>, ptr addrspace(3) %279, align 16 + %281 = add i32 %273, %250 + %282 = getelementptr i8, ptr addrspace(3) %238, i32 %281 + %283 = load <4 x i32>, ptr addrspace(3) %282, align 16 + %284 = add i32 %277, %250 + %285 = getelementptr i8, ptr addrspace(3) %238, i32 %284 + %286 = load <4 x i32>, ptr addrspace(3) %285, align 16 + %287 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %217, <4 x float> %259, i32 4, i32 4, i32 0, i32 %172, i32 0, i32 %175) + %288 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %217, <4 x float> %260, i32 4, i32 4, i32 1, i32 %172, i32 0, i32 %175) + %289 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %228, <4 x float> %287, i32 4, i32 4, i32 2, i32 %172, i32 2, i32 %175) + %290 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %228, <4 x float> %288, i32 4, i32 4, i32 3, i32 %172, i32 2, i32 %175) + %291 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %229, <4 x float> %263, i32 4, i32 4, i32 0, i32 %172, i32 1, i32 %175) + %292 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %229, <4 x float> %264, i32 4, i32 4, i32 1, i32 %172, i32 1, i32 %175) + %293 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %230, <4 x float> %291, i32 4, i32 4, i32 2, i32 %172, i32 3, i32 %175) + %294 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %230, <4 x float> %292, i32 4, i32 4, i32 3, i32 %172, i32 3, i32 %175) + %295 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %231, <4 x float> %267, i32 4, i32 4, i32 0, i32 %172, i32 0, i32 %176) + %296 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %231, <4 x float> %268, i32 4, i32 4, i32 1, i32 %172, i32 0, i32 %176) + %297 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %232, <4 x float> %295, i32 4, i32 4, i32 2, i32 %172, i32 2, i32 %176) + %298 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %232, <4 x float> %296, i32 4, i32 4, i32 3, i32 %172, i32 2, i32 %176) + %299 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %233, <4 x float> %271, i32 4, i32 4, i32 0, i32 %172, i32 1, i32 %176) + %300 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %233, <4 x float> %272, i32 4, i32 4, i32 1, i32 %172, i32 1, i32 %176) + %301 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %234, <4 x float> %299, i32 4, i32 4, i32 2, i32 %172, i32 3, i32 %176) + %302 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %234, <4 x float> %300, i32 4, i32 4, i32 3, i32 %172, i32 3, i32 %176) + %303 = sext i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32) to i64 + %304 = inttoptr i64 %303 to ptr addrspace(3) + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %305 = mul i32 %90, 4 + %306 = add i32 %95, %91 + %307 = mul i32 %90, 1024 + %308 = add i32 %307, %306 + %309 = extractelement <4 x float> %289, i64 0 + %310 = mul i32 %308, 4 + %311 = getelementptr i8, ptr addrspace(3) %304, i32 %310 + store float %309, ptr addrspace(3) %311, align 4 + %312 = add i32 %305, 1 + %313 = mul i32 %312, 256 + %314 = add i32 %313, %306 + %315 = extractelement <4 x float> %289, i64 1 + %316 = mul i32 %314, 4 + %317 = getelementptr i8, ptr addrspace(3) %304, i32 %316 + store float %315, ptr addrspace(3) %317, align 4 + %318 = add i32 %305, 2 + %319 = mul i32 %318, 256 + %320 = add i32 %319, %306 + %321 = extractelement <4 x float> %289, i64 2 + %322 = mul i32 %320, 4 + %323 = getelementptr i8, ptr addrspace(3) %304, i32 %322 + store float %321, ptr addrspace(3) %323, align 4 + %324 = add i32 %305, 3 + %325 = mul i32 %324, 256 + %326 = add i32 %325, %306 + %327 = extractelement <4 x float> %289, i64 3 + %328 = mul i32 %326, 4 + %329 = getelementptr i8, ptr addrspace(3) %304, i32 %328 + store float %327, ptr addrspace(3) %329, align 4 + %330 = add i32 %95, 16 + %331 = add i32 %330, %91 + %332 = add i32 %307, %331 + %333 = extractelement <4 x float> %293, i64 0 + %334 = mul i32 %332, 4 + %335 = getelementptr i8, ptr addrspace(3) %304, i32 %334 + store float %333, ptr addrspace(3) %335, align 4 + %336 = add i32 %313, %331 + %337 = extractelement <4 x float> %293, i64 1 + %338 = mul i32 %336, 4 + %339 = getelementptr i8, ptr addrspace(3) %304, i32 %338 + store float %337, ptr addrspace(3) %339, align 4 + %340 = add i32 %319, %331 + %341 = extractelement <4 x float> %293, i64 2 + %342 = mul i32 %340, 4 + %343 = getelementptr i8, ptr addrspace(3) %304, i32 %342 + store float %341, ptr addrspace(3) %343, align 4 + %344 = add i32 %325, %331 + %345 = extractelement <4 x float> %293, i64 3 + %346 = mul i32 %344, 4 + %347 = getelementptr i8, ptr addrspace(3) %304, i32 %346 + store float %345, ptr addrspace(3) %347, align 4 + %348 = add i32 %95, 32 + %349 = add i32 %348, %91 + %350 = add i32 %307, %349 + %351 = extractelement <4 x float> %297, i64 0 + %352 = mul i32 %350, 4 + %353 = getelementptr i8, ptr addrspace(3) %304, i32 %352 + store float %351, ptr addrspace(3) %353, align 4 + %354 = add i32 %313, %349 + %355 = extractelement <4 x float> %297, i64 1 + %356 = mul i32 %354, 4 + %357 = getelementptr i8, ptr addrspace(3) %304, i32 %356 + store float %355, ptr addrspace(3) %357, align 4 + %358 = add i32 %319, %349 + %359 = extractelement <4 x float> %297, i64 2 + %360 = mul i32 %358, 4 + %361 = getelementptr i8, ptr addrspace(3) %304, i32 %360 + store float %359, ptr addrspace(3) %361, align 4 + %362 = add i32 %325, %349 + %363 = extractelement <4 x float> %297, i64 3 + %364 = mul i32 %362, 4 + %365 = getelementptr i8, ptr addrspace(3) %304, i32 %364 + store float %363, ptr addrspace(3) %365, align 4 + %366 = add i32 %95, 48 + %367 = add i32 %366, %91 + %368 = add i32 %307, %367 + %369 = extractelement <4 x float> %301, i64 0 + %370 = mul i32 %368, 4 + %371 = getelementptr i8, ptr addrspace(3) %304, i32 %370 + store float %369, ptr addrspace(3) %371, align 4 + %372 = add i32 %313, %367 + %373 = extractelement <4 x float> %301, i64 1 + %374 = mul i32 %372, 4 + %375 = getelementptr i8, ptr addrspace(3) %304, i32 %374 + store float %373, ptr addrspace(3) %375, align 4 + %376 = add i32 %319, %367 + %377 = extractelement <4 x float> %301, i64 2 + %378 = mul i32 %376, 4 + %379 = getelementptr i8, ptr addrspace(3) %304, i32 %378 + store float %377, ptr addrspace(3) %379, align 4 + %380 = add i32 %325, %367 + %381 = extractelement <4 x float> %301, i64 3 + %382 = mul i32 %380, 4 + %383 = getelementptr i8, ptr addrspace(3) %304, i32 %382 + store float %381, ptr addrspace(3) %383, align 4 + %384 = add i32 %305, 16 + %385 = mul i32 %384, 256 + %386 = add i32 %385, %306 + %387 = extractelement <4 x float> %290, i64 0 + %388 = mul i32 %386, 4 + %389 = getelementptr i8, ptr addrspace(3) %304, i32 %388 + store float %387, ptr addrspace(3) %389, align 4 + %390 = add i32 %305, 17 + %391 = mul i32 %390, 256 + %392 = add i32 %391, %306 + %393 = extractelement <4 x float> %290, i64 1 + %394 = mul i32 %392, 4 + %395 = getelementptr i8, ptr addrspace(3) %304, i32 %394 + store float %393, ptr addrspace(3) %395, align 4 + %396 = add i32 %305, 18 + %397 = mul i32 %396, 256 + %398 = add i32 %397, %306 + %399 = extractelement <4 x float> %290, i64 2 + %400 = mul i32 %398, 4 + %401 = getelementptr i8, ptr addrspace(3) %304, i32 %400 + store float %399, ptr addrspace(3) %401, align 4 + %402 = add i32 %305, 19 + %403 = mul i32 %402, 256 + %404 = add i32 %403, %306 + %405 = extractelement <4 x float> %290, i64 3 + %406 = mul i32 %404, 4 + %407 = getelementptr i8, ptr addrspace(3) %304, i32 %406 + store float %405, ptr addrspace(3) %407, align 4 + %408 = add i32 %385, %331 + %409 = extractelement <4 x float> %294, i64 0 + %410 = mul i32 %408, 4 + %411 = getelementptr i8, ptr addrspace(3) %304, i32 %410 + store float %409, ptr addrspace(3) %411, align 4 + %412 = add i32 %391, %331 + %413 = extractelement <4 x float> %294, i64 1 + %414 = mul i32 %412, 4 + %415 = getelementptr i8, ptr addrspace(3) %304, i32 %414 + store float %413, ptr addrspace(3) %415, align 4 + %416 = add i32 %397, %331 + %417 = extractelement <4 x float> %294, i64 2 + %418 = mul i32 %416, 4 + %419 = getelementptr i8, ptr addrspace(3) %304, i32 %418 + store float %417, ptr addrspace(3) %419, align 4 + %420 = add i32 %403, %331 + %421 = extractelement <4 x float> %294, i64 3 + %422 = mul i32 %420, 4 + %423 = getelementptr i8, ptr addrspace(3) %304, i32 %422 + store float %421, ptr addrspace(3) %423, align 4 + %424 = add i32 %385, %349 + %425 = extractelement <4 x float> %298, i64 0 + %426 = mul i32 %424, 4 + %427 = getelementptr i8, ptr addrspace(3) %304, i32 %426 + store float %425, ptr addrspace(3) %427, align 4 + %428 = add i32 %391, %349 + %429 = extractelement <4 x float> %298, i64 1 + %430 = mul i32 %428, 4 + %431 = getelementptr i8, ptr addrspace(3) %304, i32 %430 + store float %429, ptr addrspace(3) %431, align 4 + %432 = add i32 %397, %349 + %433 = extractelement <4 x float> %298, i64 2 + %434 = mul i32 %432, 4 + %435 = getelementptr i8, ptr addrspace(3) %304, i32 %434 + store float %433, ptr addrspace(3) %435, align 4 + %436 = add i32 %403, %349 + %437 = extractelement <4 x float> %298, i64 3 + %438 = mul i32 %436, 4 + %439 = getelementptr i8, ptr addrspace(3) %304, i32 %438 + store float %437, ptr addrspace(3) %439, align 4 + %440 = add i32 %385, %367 + %441 = extractelement <4 x float> %302, i64 0 + %442 = mul i32 %440, 4 + %443 = getelementptr i8, ptr addrspace(3) %304, i32 %442 + store float %441, ptr addrspace(3) %443, align 4 + %444 = add i32 %391, %367 + %445 = extractelement <4 x float> %302, i64 1 + %446 = mul i32 %444, 4 + %447 = getelementptr i8, ptr addrspace(3) %304, i32 %446 + store float %445, ptr addrspace(3) %447, align 4 + %448 = add i32 %397, %367 + %449 = extractelement <4 x float> %302, i64 2 + %450 = mul i32 %448, 4 + %451 = getelementptr i8, ptr addrspace(3) %304, i32 %450 + store float %449, ptr addrspace(3) %451, align 4 + %452 = add i32 %403, %367 + %453 = extractelement <4 x float> %302, i64 3 + %454 = mul i32 %452, 4 + %455 = getelementptr i8, ptr addrspace(3) %304, i32 %454 + store float %453, ptr addrspace(3) %455, align 4 + fence syncscope("workgroup") release + call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + %456 = sdiv i32 %24, 32 + %457 = mul i32 %456, 32 + %458 = icmp ne i32 %24, %457 + %459 = icmp slt i32 %24, 0 + %460 = icmp ne i1 %459, false + %461 = and i1 %458, %460 + %462 = add i32 %456, -1 + %463 = select i1 %461, i32 %462, i32 %456 + %464 = srem i32 %24, 32 + %465 = mul i32 %464, 2 + %466 = ptrtoint ptr addrspace(1) %12 to i64 + %467 = inttoptr i64 %466 to ptr addrspace(1) + %468 = ptrtoint ptr addrspace(1) %14 to i64 + %469 = inttoptr i64 %468 to ptr addrspace(1) + %470 = ptrtoint ptr addrspace(1) %17 to i64 + %471 = inttoptr i64 %470 to ptr addrspace(1) + %472 = add i32 %65, %463 + %473 = mul i32 %472, 4 + %474 = getelementptr i8, ptr addrspace(1) %467, i32 %473 + %475 = load i32, ptr addrspace(1) %474, align 4 + %476 = and i32 %475, 16777215 + %477 = icmp slt i32 %476, %16 + %478 = getelementptr i8, ptr addrspace(1) %469, i32 %473 + %479 = load float, ptr addrspace(1) %478, align 4 + br i1 %477, label %480, label %544 + +480: ; preds = %49 + %481 = mul i32 %476, 7168 + %482 = add i32 %481, %93 + %483 = add i32 %482, %465 + %484 = mul i32 %463, 256 + %485 = add i32 %484, %465 + %486 = mul i32 %485, 4 + %487 = getelementptr i8, ptr addrspace(3) %304, i32 %486 + %488 = load <2 x float>, ptr addrspace(3) %487, align 8 + %489 = extractelement <2 x float> %488, i64 0 + %490 = fmul float %489, %479 + %491 = extractelement <2 x float> %488, i64 1 + %492 = fmul float %491, %479 + %493 = insertelement <2 x float> poison, float %490, i64 0 + %494 = insertelement <2 x float> %493, float %492, i64 1 + %495 = fptrunc <2 x float> %494 to <2 x bfloat> + %496 = mul i32 %483, 2 + %497 = getelementptr i8, ptr addrspace(1) %471, i32 %496 + %498 = atomicrmw fadd ptr addrspace(1) %497, <2 x bfloat> %495 syncscope("agent") monotonic, align 4 + %499 = add i32 %485, 64 + %500 = mul i32 %499, 4 + %501 = getelementptr i8, ptr addrspace(3) %304, i32 %500 + %502 = load <2 x float>, ptr addrspace(3) %501, align 8 + %503 = extractelement <2 x float> %502, i64 0 + %504 = fmul float %503, %479 + %505 = extractelement <2 x float> %502, i64 1 + %506 = fmul float %505, %479 + %507 = insertelement <2 x float> poison, float %504, i64 0 + %508 = insertelement <2 x float> %507, float %506, i64 1 + %509 = fptrunc <2 x float> %508 to <2 x bfloat> + %510 = add i32 %483, 64 + %511 = mul i32 %510, 2 + %512 = getelementptr i8, ptr addrspace(1) %471, i32 %511 + %513 = atomicrmw fadd ptr addrspace(1) %512, <2 x bfloat> %509 syncscope("agent") monotonic, align 4 + %514 = add i32 %485, 128 + %515 = mul i32 %514, 4 + %516 = getelementptr i8, ptr addrspace(3) %304, i32 %515 + %517 = load <2 x float>, ptr addrspace(3) %516, align 8 + %518 = extractelement <2 x float> %517, i64 0 + %519 = fmul float %518, %479 + %520 = extractelement <2 x float> %517, i64 1 + %521 = fmul float %520, %479 + %522 = insertelement <2 x float> poison, float %519, i64 0 + %523 = insertelement <2 x float> %522, float %521, i64 1 + %524 = fptrunc <2 x float> %523 to <2 x bfloat> + %525 = add i32 %483, 128 + %526 = mul i32 %525, 2 + %527 = getelementptr i8, ptr addrspace(1) %471, i32 %526 + %528 = atomicrmw fadd ptr addrspace(1) %527, <2 x bfloat> %524 syncscope("agent") monotonic, align 4 + %529 = add i32 %485, 192 + %530 = mul i32 %529, 4 + %531 = getelementptr i8, ptr addrspace(3) %304, i32 %530 + %532 = load <2 x float>, ptr addrspace(3) %531, align 8 + %533 = extractelement <2 x float> %532, i64 0 + %534 = fmul float %533, %479 + %535 = extractelement <2 x float> %532, i64 1 + %536 = fmul float %535, %479 + %537 = insertelement <2 x float> poison, float %534, i64 0 + %538 = insertelement <2 x float> %537, float %536, i64 1 + %539 = fptrunc <2 x float> %538 to <2 x bfloat> + %540 = add i32 %483, 192 + %541 = mul i32 %540, 2 + %542 = getelementptr i8, ptr addrspace(1) %471, i32 %541 + %543 = atomicrmw fadd ptr addrspace(1) %542, <2 x bfloat> %539 syncscope("agent") monotonic, align 4 + br label %544 + +544: ; preds = %480, %49 + %545 = add i32 %463, 8 + %546 = add i32 %65, %545 + %547 = mul i32 %546, 4 + %548 = getelementptr i8, ptr addrspace(1) %467, i32 %547 + %549 = load i32, ptr addrspace(1) %548, align 4 + %550 = and i32 %549, 16777215 + %551 = icmp slt i32 %550, %16 + %552 = getelementptr i8, ptr addrspace(1) %469, i32 %547 + %553 = load float, ptr addrspace(1) %552, align 4 + br i1 %551, label %554, label %618 + +554: ; preds = %544 + %555 = mul i32 %550, 7168 + %556 = add i32 %555, %93 + %557 = add i32 %556, %465 + %558 = mul i32 %545, 256 + %559 = add i32 %558, %465 + %560 = mul i32 %559, 4 + %561 = getelementptr i8, ptr addrspace(3) %304, i32 %560 + %562 = load <2 x float>, ptr addrspace(3) %561, align 8 + %563 = extractelement <2 x float> %562, i64 0 + %564 = fmul float %563, %553 + %565 = extractelement <2 x float> %562, i64 1 + %566 = fmul float %565, %553 + %567 = insertelement <2 x float> poison, float %564, i64 0 + %568 = insertelement <2 x float> %567, float %566, i64 1 + %569 = fptrunc <2 x float> %568 to <2 x bfloat> + %570 = mul i32 %557, 2 + %571 = getelementptr i8, ptr addrspace(1) %471, i32 %570 + %572 = atomicrmw fadd ptr addrspace(1) %571, <2 x bfloat> %569 syncscope("agent") monotonic, align 4 + %573 = add i32 %559, 64 + %574 = mul i32 %573, 4 + %575 = getelementptr i8, ptr addrspace(3) %304, i32 %574 + %576 = load <2 x float>, ptr addrspace(3) %575, align 8 + %577 = extractelement <2 x float> %576, i64 0 + %578 = fmul float %577, %553 + %579 = extractelement <2 x float> %576, i64 1 + %580 = fmul float %579, %553 + %581 = insertelement <2 x float> poison, float %578, i64 0 + %582 = insertelement <2 x float> %581, float %580, i64 1 + %583 = fptrunc <2 x float> %582 to <2 x bfloat> + %584 = add i32 %557, 64 + %585 = mul i32 %584, 2 + %586 = getelementptr i8, ptr addrspace(1) %471, i32 %585 + %587 = atomicrmw fadd ptr addrspace(1) %586, <2 x bfloat> %583 syncscope("agent") monotonic, align 4 + %588 = add i32 %559, 128 + %589 = mul i32 %588, 4 + %590 = getelementptr i8, ptr addrspace(3) %304, i32 %589 + %591 = load <2 x float>, ptr addrspace(3) %590, align 8 + %592 = extractelement <2 x float> %591, i64 0 + %593 = fmul float %592, %553 + %594 = extractelement <2 x float> %591, i64 1 + %595 = fmul float %594, %553 + %596 = insertelement <2 x float> poison, float %593, i64 0 + %597 = insertelement <2 x float> %596, float %595, i64 1 + %598 = fptrunc <2 x float> %597 to <2 x bfloat> + %599 = add i32 %557, 128 + %600 = mul i32 %599, 2 + %601 = getelementptr i8, ptr addrspace(1) %471, i32 %600 + %602 = atomicrmw fadd ptr addrspace(1) %601, <2 x bfloat> %598 syncscope("agent") monotonic, align 4 + %603 = add i32 %559, 192 + %604 = mul i32 %603, 4 + %605 = getelementptr i8, ptr addrspace(3) %304, i32 %604 + %606 = load <2 x float>, ptr addrspace(3) %605, align 8 + %607 = extractelement <2 x float> %606, i64 0 + %608 = fmul float %607, %553 + %609 = extractelement <2 x float> %606, i64 1 + %610 = fmul float %609, %553 + %611 = insertelement <2 x float> poison, float %608, i64 0 + %612 = insertelement <2 x float> %611, float %610, i64 1 + %613 = fptrunc <2 x float> %612 to <2 x bfloat> + %614 = add i32 %557, 192 + %615 = mul i32 %614, 2 + %616 = getelementptr i8, ptr addrspace(1) %471, i32 %615 + %617 = atomicrmw fadd ptr addrspace(1) %616, <2 x bfloat> %613 syncscope("agent") monotonic, align 4 + br label %618 + +618: ; preds = %554, %544 + %619 = add i32 %463, 16 + %620 = add i32 %65, %619 + %621 = mul i32 %620, 4 + %622 = getelementptr i8, ptr addrspace(1) %467, i32 %621 + %623 = load i32, ptr addrspace(1) %622, align 4 + %624 = and i32 %623, 16777215 + %625 = icmp slt i32 %624, %16 + %626 = getelementptr i8, ptr addrspace(1) %469, i32 %621 + %627 = load float, ptr addrspace(1) %626, align 4 + br i1 %625, label %628, label %692 + +628: ; preds = %618 + %629 = mul i32 %624, 7168 + %630 = add i32 %629, %93 + %631 = add i32 %630, %465 + %632 = mul i32 %619, 256 + %633 = add i32 %632, %465 + %634 = mul i32 %633, 4 + %635 = getelementptr i8, ptr addrspace(3) %304, i32 %634 + %636 = load <2 x float>, ptr addrspace(3) %635, align 8 + %637 = extractelement <2 x float> %636, i64 0 + %638 = fmul float %637, %627 + %639 = extractelement <2 x float> %636, i64 1 + %640 = fmul float %639, %627 + %641 = insertelement <2 x float> poison, float %638, i64 0 + %642 = insertelement <2 x float> %641, float %640, i64 1 + %643 = fptrunc <2 x float> %642 to <2 x bfloat> + %644 = mul i32 %631, 2 + %645 = getelementptr i8, ptr addrspace(1) %471, i32 %644 + %646 = atomicrmw fadd ptr addrspace(1) %645, <2 x bfloat> %643 syncscope("agent") monotonic, align 4 + %647 = add i32 %633, 64 + %648 = mul i32 %647, 4 + %649 = getelementptr i8, ptr addrspace(3) %304, i32 %648 + %650 = load <2 x float>, ptr addrspace(3) %649, align 8 + %651 = extractelement <2 x float> %650, i64 0 + %652 = fmul float %651, %627 + %653 = extractelement <2 x float> %650, i64 1 + %654 = fmul float %653, %627 + %655 = insertelement <2 x float> poison, float %652, i64 0 + %656 = insertelement <2 x float> %655, float %654, i64 1 + %657 = fptrunc <2 x float> %656 to <2 x bfloat> + %658 = add i32 %631, 64 + %659 = mul i32 %658, 2 + %660 = getelementptr i8, ptr addrspace(1) %471, i32 %659 + %661 = atomicrmw fadd ptr addrspace(1) %660, <2 x bfloat> %657 syncscope("agent") monotonic, align 4 + %662 = add i32 %633, 128 + %663 = mul i32 %662, 4 + %664 = getelementptr i8, ptr addrspace(3) %304, i32 %663 + %665 = load <2 x float>, ptr addrspace(3) %664, align 8 + %666 = extractelement <2 x float> %665, i64 0 + %667 = fmul float %666, %627 + %668 = extractelement <2 x float> %665, i64 1 + %669 = fmul float %668, %627 + %670 = insertelement <2 x float> poison, float %667, i64 0 + %671 = insertelement <2 x float> %670, float %669, i64 1 + %672 = fptrunc <2 x float> %671 to <2 x bfloat> + %673 = add i32 %631, 128 + %674 = mul i32 %673, 2 + %675 = getelementptr i8, ptr addrspace(1) %471, i32 %674 + %676 = atomicrmw fadd ptr addrspace(1) %675, <2 x bfloat> %672 syncscope("agent") monotonic, align 4 + %677 = add i32 %633, 192 + %678 = mul i32 %677, 4 + %679 = getelementptr i8, ptr addrspace(3) %304, i32 %678 + %680 = load <2 x float>, ptr addrspace(3) %679, align 8 + %681 = extractelement <2 x float> %680, i64 0 + %682 = fmul float %681, %627 + %683 = extractelement <2 x float> %680, i64 1 + %684 = fmul float %683, %627 + %685 = insertelement <2 x float> poison, float %682, i64 0 + %686 = insertelement <2 x float> %685, float %684, i64 1 + %687 = fptrunc <2 x float> %686 to <2 x bfloat> + %688 = add i32 %631, 192 + %689 = mul i32 %688, 2 + %690 = getelementptr i8, ptr addrspace(1) %471, i32 %689 + %691 = atomicrmw fadd ptr addrspace(1) %690, <2 x bfloat> %687 syncscope("agent") monotonic, align 4 + br label %692 + +692: ; preds = %628, %618 + %693 = add i32 %463, 24 + %694 = add i32 %65, %693 + %695 = mul i32 %694, 4 + %696 = getelementptr i8, ptr addrspace(1) %467, i32 %695 + %697 = load i32, ptr addrspace(1) %696, align 4 + %698 = and i32 %697, 16777215 + %699 = icmp slt i32 %698, %16 + %700 = getelementptr i8, ptr addrspace(1) %469, i32 %695 + %701 = load float, ptr addrspace(1) %700, align 4 + br i1 %699, label %702, label %766 + +702: ; preds = %692 + %703 = mul i32 %698, 7168 + %704 = add i32 %703, %93 + %705 = add i32 %704, %465 + %706 = mul i32 %693, 256 + %707 = add i32 %706, %465 + %708 = mul i32 %707, 4 + %709 = getelementptr i8, ptr addrspace(3) %304, i32 %708 + %710 = load <2 x float>, ptr addrspace(3) %709, align 8 + %711 = extractelement <2 x float> %710, i64 0 + %712 = fmul float %711, %701 + %713 = extractelement <2 x float> %710, i64 1 + %714 = fmul float %713, %701 + %715 = insertelement <2 x float> poison, float %712, i64 0 + %716 = insertelement <2 x float> %715, float %714, i64 1 + %717 = fptrunc <2 x float> %716 to <2 x bfloat> + %718 = mul i32 %705, 2 + %719 = getelementptr i8, ptr addrspace(1) %471, i32 %718 + %720 = atomicrmw fadd ptr addrspace(1) %719, <2 x bfloat> %717 syncscope("agent") monotonic, align 4 + %721 = add i32 %707, 64 + %722 = mul i32 %721, 4 + %723 = getelementptr i8, ptr addrspace(3) %304, i32 %722 + %724 = load <2 x float>, ptr addrspace(3) %723, align 8 + %725 = extractelement <2 x float> %724, i64 0 + %726 = fmul float %725, %701 + %727 = extractelement <2 x float> %724, i64 1 + %728 = fmul float %727, %701 + %729 = insertelement <2 x float> poison, float %726, i64 0 + %730 = insertelement <2 x float> %729, float %728, i64 1 + %731 = fptrunc <2 x float> %730 to <2 x bfloat> + %732 = add i32 %705, 64 + %733 = mul i32 %732, 2 + %734 = getelementptr i8, ptr addrspace(1) %471, i32 %733 + %735 = atomicrmw fadd ptr addrspace(1) %734, <2 x bfloat> %731 syncscope("agent") monotonic, align 4 + %736 = add i32 %707, 128 + %737 = mul i32 %736, 4 + %738 = getelementptr i8, ptr addrspace(3) %304, i32 %737 + %739 = load <2 x float>, ptr addrspace(3) %738, align 8 + %740 = extractelement <2 x float> %739, i64 0 + %741 = fmul float %740, %701 + %742 = extractelement <2 x float> %739, i64 1 + %743 = fmul float %742, %701 + %744 = insertelement <2 x float> poison, float %741, i64 0 + %745 = insertelement <2 x float> %744, float %743, i64 1 + %746 = fptrunc <2 x float> %745 to <2 x bfloat> + %747 = add i32 %705, 128 + %748 = mul i32 %747, 2 + %749 = getelementptr i8, ptr addrspace(1) %471, i32 %748 + %750 = atomicrmw fadd ptr addrspace(1) %749, <2 x bfloat> %746 syncscope("agent") monotonic, align 4 + %751 = add i32 %707, 192 + %752 = mul i32 %751, 4 + %753 = getelementptr i8, ptr addrspace(3) %304, i32 %752 + %754 = load <2 x float>, ptr addrspace(3) %753, align 8 + %755 = extractelement <2 x float> %754, i64 0 + %756 = fmul float %755, %701 + %757 = extractelement <2 x float> %754, i64 1 + %758 = fmul float %757, %701 + %759 = insertelement <2 x float> poison, float %756, i64 0 + %760 = insertelement <2 x float> %759, float %758, i64 1 + %761 = fptrunc <2 x float> %760 to <2 x bfloat> + %762 = add i32 %705, 192 + %763 = mul i32 %762, 2 + %764 = getelementptr i8, ptr addrspace(1) %471, i32 %763 + %765 = atomicrmw fadd ptr addrspace(1) %764, <2 x bfloat> %761 syncscope("agent") monotonic, align 4 + br label %766 + +766: ; preds = %702, %692 + br label %767 + +767: ; preds = %766, %19 + ret void +} + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) +declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 + +; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) +declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #3 + +; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #4 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.sched.barrier(i32 immarg) #5 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 + +; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) +declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #7 + +; Function Attrs: convergent nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.s.barrier() #5 + +attributes #0 = { "amdgpu-flat-work-group-size"="256,256" "uniform-work-group-size" } +attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } +attributes #2 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } +attributes #3 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } +attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } +attributes #5 = { convergent nocallback nofree nounwind willreturn } +attributes #6 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } +attributes #7 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } + +!llvm.module.flags = !{!0} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = !{i32 256, i32 1, i32 1} diff --git a/kernels/gemm2_port_ref/hip_gemm2_bm32.ll b/kernels/gemm2_port_ref/hip_gemm2_bm32.ll new file mode 100644 index 000000000..5f5ed7a9a --- /dev/null +++ b/kernels/gemm2_port_ref/hip_gemm2_bm32.ll @@ -0,0 +1,570 @@ +; ModuleID = '/tmp/aiter/aiter/jit/build/module_moe_mxfp4_gemm/blob/instances/mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC.cu' +source_filename = "/tmp/aiter/aiter/jit/build/module_moe_mxfp4_gemm/blob/instances/mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC.cu" +target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" +target triple = "amdgcn-amd-amdhsa" + +%"struct.aiter::mxfp4_moe::gemm2::LDSLayout" = type { %union.anon } +%union.anon = type { [8192 x float] } +%struct.__hip_bfloat16 = type { %union.anon.17 } +%union.anon.17 = type { i16 } + +$_ZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16Ph = comdat any + +$_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds = comdat any + +@_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds = linkonce_odr hidden addrspace(3) global %"struct.aiter::mxfp4_moe::gemm2::LDSLayout" undef, comdat, align 16 +@__hip_cuid_63e8a0938c35de0f = addrspace(1) global i8 0 +@llvm.compiler.used = appending addrspace(1) global [1 x ptr] [ptr addrspacecast (ptr addrspace(1) @__hip_cuid_63e8a0938c35de0f to ptr)], section "llvm.metadata" + +; Function Attrs: convergent mustprogress norecurse nounwind +define protected amdgpu_kernel void @_ZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16Ph(ptr addrspace(1) noalias noundef readonly captures(none) %0, ptr addrspace(1) noalias noundef readonly captures(none) %1, ptr addrspace(1) noalias noundef readonly captures(none) %2, ptr addrspace(1) noalias noundef readonly captures(none) %3, ptr addrspace(1) noalias noundef readonly captures(none) %4, ptr addrspace(1) noalias noundef readonly captures(none) %5, ptr addrspace(1) noalias noundef readonly captures(none) %6, ptr addrspace(1) noalias noundef readonly captures(none) %7, i32 noundef %8, ptr addrspace(1) noalias noundef captures(none) %9, ptr addrspace(1) noalias noundef readnone captures(none) %10) local_unnamed_addr #0 comdat { + %12 = tail call noundef i32 @llvm.amdgcn.workgroup.id.x() + %13 = tail call noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() + %14 = icmp samesign ult i32 %13, 256 + tail call void @llvm.assume(i1 %14) + %15 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %13) + %16 = load i32, ptr addrspace(1) %5, align 4, !tbaa !7 + %17 = sdiv i32 %16, 32 + %18 = mul nsw i32 %17, 28 + %19 = icmp slt i32 %12, %18 + br i1 %19, label %20, label %410 + +20: ; preds = %11 + %21 = tail call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p1(ptr addrspace(1) readnone %3, i16 0, i64 44154880, i32 131072) + %22 = tail call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p1(ptr addrspace(1) readnone %1, i16 0, i64 10485760, i32 131072) + %23 = tail call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p1(ptr addrspace(1) readnone %2, i16 0, i64 706478080, i32 131072) + %24 = tail call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p1(ptr addrspace(1) readnone %0, i16 0, i64 167772160, i32 131072) + %25 = and i32 %13, 63 + %26 = lshr i32 %15, 6 + %27 = sdiv i32 %12, 28 + %28 = mul i32 %27, 28 + %29 = sub i32 %12, %28 + %30 = sext i32 %27 to i64 + %31 = getelementptr inbounds i32, ptr addrspace(1) %4, i64 %30 + %32 = load i32, ptr addrspace(1) %31, align 4, !tbaa !7 + %33 = icmp samesign ult i32 %32, 385 + tail call void @llvm.assume(i1 %33) + %34 = shl nsw i32 %29, 16 + %35 = mul nuw nsw i32 %32, 1835008 + %36 = add nsw i32 %35, %34 + %37 = shl i32 %26, 14 + %38 = add i32 %36, %37 + %39 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %38) + %40 = or disjoint i32 %37, 4096 + %41 = add i32 %40, %36 + %42 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %41) + %43 = or disjoint i32 %37, 8192 + %44 = add i32 %43, %36 + %45 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %44) + %46 = or disjoint i32 %37, 12288 + %47 = add i32 %46, %36 + %48 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %47) + %49 = lshr i32 %25, 3 + %50 = shl nsw i32 %29, 12 + %51 = mul nuw nsw i32 %32, 114688 + %52 = shl i32 %26, 10 + %53 = add i32 %52, %50 + %54 = add i32 %51, %53 + %55 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %54) + %56 = or disjoint i32 %53, 512 + %57 = add i32 %56, %51 + %58 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %57) + %59 = shl nsw i32 %27, 5 + %60 = or disjoint i32 %49, %59 + %61 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 range(i32 -76695844, 67108863) %27) + %62 = shl nsw i32 %61, 9 + %63 = shl i32 %26, 11 + %64 = shl i32 %60, 8 + %65 = add i32 %63, %64 + %66 = shl nuw nsw i32 %26, 3 + %67 = or disjoint i32 %66, %49 + %68 = shl nuw i32 %67, 3 + %69 = shl nuw nsw i32 %13, 4 + %70 = xor i32 %68, %69 + %71 = and i32 %70, 112 + %72 = or disjoint i32 %71, %65 + %73 = getelementptr inbounds nuw [128 x i8], ptr addrspace(3) @_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds, i32 %66 + tail call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly %24, ptr addrspace(3) noundef %73, i32 noundef 16, i32 noundef %72, i32 noundef range(i32 0, 129) 0, i32 noundef 0, i32 noundef 0) #10 + %74 = getelementptr inbounds nuw [128 x i8], ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds, i32 4096), i32 %66 + tail call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly %24, ptr addrspace(3) noundef nonnull %74, i32 noundef 16, i32 noundef %72, i32 noundef range(i32 0, 129) 128, i32 noundef 0, i32 noundef 0) #10 + tail call void @llvm.amdgcn.sched.barrier(i32 0) + %75 = lshr i32 %25, 4 + %76 = and i32 %13, 15 + %77 = shl nuw nsw i32 %75, 6 + %78 = shl nuw nsw i32 %76, 2 + %79 = or disjoint i32 %77, %78 + %80 = or disjoint i32 %79, 256 + %81 = tail call noundef i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly %22, i32 %79, i32 %62, i32 0) + %82 = tail call noundef i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly %22, i32 %80, i32 %62, i32 0) + %83 = tail call noundef i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly %21, i32 %79, i32 %55, i32 0) + %84 = tail call noundef i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly %21, i32 %79, i32 %58, i32 0) + %85 = tail call noundef i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly %21, i32 %80, i32 %55, i32 0) + %86 = tail call noundef i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly %21, i32 %80, i32 %58, i32 0) + %87 = shl nuw nsw i32 %75, 8 + %88 = shl nuw nsw i32 %76, 4 + %89 = or disjoint i32 %87, %88 + %90 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %89, i32 %39, i32 0) + %91 = or disjoint i32 %89, 1024 + %92 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %91, i32 %39, i32 0) + %93 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %89, i32 %42, i32 0) + %94 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %91, i32 %42, i32 0) + %95 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %89, i32 %45, i32 0) + %96 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %91, i32 %45, i32 0) + %97 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %89, i32 %48, i32 0) + %98 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %91, i32 %48, i32 0) + %99 = or disjoint i32 %89, 2048 + %100 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %99, i32 %39, i32 0) + %101 = or disjoint i32 %89, 3072 + %102 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %101, i32 %39, i32 0) + %103 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %99, i32 %42, i32 0) + %104 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %101, i32 %42, i32 0) + %105 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %99, i32 %45, i32 0) + %106 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %101, i32 %45, i32 0) + %107 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %99, i32 %48, i32 0) + %108 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %101, i32 %48, i32 0) + tail call void asm sideeffect "s_waitcnt vmcnt(23)", "~{memory}"() #10, !srcloc !11 + tail call void @llvm.amdgcn.s.barrier() + %109 = and i32 %13, 48 + %110 = shl nuw nsw i32 %13, 3 + %111 = and i32 %110, 112 + %112 = getelementptr [128 x i8], ptr addrspace(3) @_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds, i32 %76 + %113 = xor i32 %111, %109 + %114 = getelementptr i8, ptr addrspace(3) %112, i32 %113 + %115 = load <4 x i32>, ptr addrspace(3) %114, align 16, !tbaa !12 + %116 = getelementptr i8, ptr addrspace(3) %114, i32 2048 + %117 = load <4 x i32>, ptr addrspace(3) %116, align 16, !tbaa !12 + %118 = or disjoint i32 %109, 64 + %119 = xor i32 %118, %111 + %120 = getelementptr i8, ptr addrspace(3) %112, i32 %119 + %121 = load <4 x i32>, ptr addrspace(3) %120, align 16, !tbaa !12 + %122 = getelementptr i8, ptr addrspace(3) %120, i32 2048 + %123 = load <4 x i32>, ptr addrspace(3) %122, align 16, !tbaa !12 + %124 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %115, <4 x i32> noundef %90, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %81, i32 noundef 0, i32 noundef %83) #10 + %125 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %117, <4 x i32> noundef %90, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %81, i32 noundef 0, i32 noundef %83) #10 + %126 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %121, <4 x i32> noundef %92, <4 x float> noundef %124, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %81, i32 noundef 2, i32 noundef %83) #10 + %127 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %123, <4 x i32> noundef %92, <4 x float> noundef %125, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %81, i32 noundef 2, i32 noundef %83) #10 + %128 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %115, <4 x i32> noundef %93, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %81, i32 noundef 1, i32 noundef %83) #10 + %129 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %117, <4 x i32> noundef %93, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %81, i32 noundef 1, i32 noundef %83) #10 + %130 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %121, <4 x i32> noundef %94, <4 x float> noundef %128, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %81, i32 noundef 3, i32 noundef %83) #10 + %131 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %123, <4 x i32> noundef %94, <4 x float> noundef %129, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %81, i32 noundef 3, i32 noundef %83) #10 + %132 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %115, <4 x i32> noundef %95, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %81, i32 noundef 0, i32 noundef %84) #10 + %133 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %117, <4 x i32> noundef %95, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %81, i32 noundef 0, i32 noundef %84) #10 + %134 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %121, <4 x i32> noundef %96, <4 x float> noundef %132, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %81, i32 noundef 2, i32 noundef %84) #10 + %135 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %123, <4 x i32> noundef %96, <4 x float> noundef %133, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %81, i32 noundef 2, i32 noundef %84) #10 + %136 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %115, <4 x i32> noundef %97, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %81, i32 noundef 1, i32 noundef %84) #10 + %137 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %117, <4 x i32> noundef %97, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %81, i32 noundef 1, i32 noundef %84) #10 + %138 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %121, <4 x i32> noundef %98, <4 x float> noundef %136, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %81, i32 noundef 3, i32 noundef %84) #10 + %139 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %123, <4 x i32> noundef %98, <4 x float> noundef %137, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %81, i32 noundef 3, i32 noundef %84) #10 + tail call void asm sideeffect "s_waitcnt vmcnt(22)", "~{memory}"() #10, !srcloc !13 + tail call void @llvm.amdgcn.s.barrier() + %140 = getelementptr [128 x i8], ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds, i32 4096), i32 %76 + %141 = getelementptr i8, ptr addrspace(3) %140, i32 %113 + %142 = load <4 x i32>, ptr addrspace(3) %141, align 16, !tbaa !12 + %143 = getelementptr i8, ptr addrspace(3) %141, i32 2048 + %144 = load <4 x i32>, ptr addrspace(3) %143, align 16, !tbaa !12 + %145 = getelementptr i8, ptr addrspace(3) %140, i32 %119 + %146 = load <4 x i32>, ptr addrspace(3) %145, align 16, !tbaa !12 + %147 = getelementptr i8, ptr addrspace(3) %145, i32 2048 + %148 = load <4 x i32>, ptr addrspace(3) %147, align 16, !tbaa !12 + %149 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %142, <4 x i32> noundef %100, <4 x float> noundef %126, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %82, i32 noundef 0, i32 noundef %85) #10 + %150 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %144, <4 x i32> noundef %100, <4 x float> noundef %127, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %82, i32 noundef 0, i32 noundef %85) #10 + %151 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %146, <4 x i32> noundef %102, <4 x float> noundef %149, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %82, i32 noundef 2, i32 noundef %85) #10 + %152 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %148, <4 x i32> noundef %102, <4 x float> noundef %150, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %82, i32 noundef 2, i32 noundef %85) #10 + %153 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %142, <4 x i32> noundef %103, <4 x float> noundef %130, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %82, i32 noundef 1, i32 noundef %85) #10 + %154 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %144, <4 x i32> noundef %103, <4 x float> noundef %131, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %82, i32 noundef 1, i32 noundef %85) #10 + %155 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %146, <4 x i32> noundef %104, <4 x float> noundef %153, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %82, i32 noundef 3, i32 noundef %85) #10 + %156 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %148, <4 x i32> noundef %104, <4 x float> noundef %154, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %82, i32 noundef 3, i32 noundef %85) #10 + %157 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %142, <4 x i32> noundef %105, <4 x float> noundef %134, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %82, i32 noundef 0, i32 noundef %86) #10 + %158 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %144, <4 x i32> noundef %105, <4 x float> noundef %135, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %82, i32 noundef 0, i32 noundef %86) #10 + %159 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %146, <4 x i32> noundef %106, <4 x float> noundef %157, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %82, i32 noundef 2, i32 noundef %86) #10 + %160 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %148, <4 x i32> noundef %106, <4 x float> noundef %158, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %82, i32 noundef 2, i32 noundef %86) #10 + %161 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %142, <4 x i32> noundef %107, <4 x float> noundef %138, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %82, i32 noundef 1, i32 noundef %86) #10 + %162 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %144, <4 x i32> noundef %107, <4 x float> noundef %139, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %82, i32 noundef 1, i32 noundef %86) #10 + %163 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %146, <4 x i32> noundef %108, <4 x float> noundef %161, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %82, i32 noundef 3, i32 noundef %86) #10 + %164 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %148, <4 x i32> noundef %108, <4 x float> noundef %162, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %82, i32 noundef 3, i32 noundef %86) #10 + fence syncscope("workgroup") release + tail call void @llvm.amdgcn.s.barrier() + fence syncscope("workgroup") acquire + tail call void @llvm.experimental.noalias.scope.decl(metadata !14) + tail call void @llvm.experimental.noalias.scope.decl(metadata !17) + tail call void @llvm.experimental.noalias.scope.decl(metadata !19) + %165 = shl nuw nsw i32 %75, 12 + %166 = shl i32 %26, 8 + %167 = getelementptr i8, ptr addrspace(3) @_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds, i32 %166 + %168 = getelementptr float, ptr addrspace(3) %167, i32 %76 + %169 = extractelement <4 x float> %151, i64 0 + %170 = getelementptr i8, ptr addrspace(3) %168, i32 %165 + store float %169, ptr addrspace(3) %170, align 4, !tbaa !21, !noalias !23 + %171 = extractelement <4 x float> %151, i64 1 + %172 = or disjoint i32 %165, 1024 + %173 = getelementptr i8, ptr addrspace(3) %168, i32 %172 + store float %171, ptr addrspace(3) %173, align 4, !tbaa !21, !noalias !23 + %174 = extractelement <4 x float> %151, i64 2 + %175 = or disjoint i32 %165, 2048 + %176 = getelementptr i8, ptr addrspace(3) %168, i32 %175 + store float %174, ptr addrspace(3) %176, align 4, !tbaa !21, !noalias !23 + %177 = extractelement <4 x float> %151, i64 3 + %178 = or disjoint i32 %165, 3072 + %179 = getelementptr i8, ptr addrspace(3) %168, i32 %178 + store float %177, ptr addrspace(3) %179, align 4, !tbaa !21, !noalias !23 + %180 = getelementptr i8, ptr addrspace(3) %168, i32 64 + %181 = extractelement <4 x float> %155, i64 0 + %182 = getelementptr i8, ptr addrspace(3) %180, i32 %165 + store float %181, ptr addrspace(3) %182, align 4, !tbaa !21, !noalias !23 + %183 = extractelement <4 x float> %155, i64 1 + %184 = getelementptr i8, ptr addrspace(3) %180, i32 %172 + store float %183, ptr addrspace(3) %184, align 4, !tbaa !21, !noalias !23 + %185 = extractelement <4 x float> %155, i64 2 + %186 = getelementptr i8, ptr addrspace(3) %180, i32 %175 + store float %185, ptr addrspace(3) %186, align 4, !tbaa !21, !noalias !23 + %187 = extractelement <4 x float> %155, i64 3 + %188 = getelementptr i8, ptr addrspace(3) %180, i32 %178 + store float %187, ptr addrspace(3) %188, align 4, !tbaa !21, !noalias !23 + %189 = getelementptr i8, ptr addrspace(3) %168, i32 128 + %190 = extractelement <4 x float> %159, i64 0 + %191 = getelementptr i8, ptr addrspace(3) %189, i32 %165 + store float %190, ptr addrspace(3) %191, align 4, !tbaa !21, !noalias !23 + %192 = extractelement <4 x float> %159, i64 1 + %193 = getelementptr i8, ptr addrspace(3) %189, i32 %172 + store float %192, ptr addrspace(3) %193, align 4, !tbaa !21, !noalias !23 + %194 = extractelement <4 x float> %159, i64 2 + %195 = getelementptr i8, ptr addrspace(3) %189, i32 %175 + store float %194, ptr addrspace(3) %195, align 4, !tbaa !21, !noalias !23 + %196 = extractelement <4 x float> %159, i64 3 + %197 = getelementptr i8, ptr addrspace(3) %189, i32 %178 + store float %196, ptr addrspace(3) %197, align 4, !tbaa !21, !noalias !23 + %198 = getelementptr i8, ptr addrspace(3) %168, i32 192 + %199 = extractelement <4 x float> %163, i64 0 + %200 = getelementptr i8, ptr addrspace(3) %198, i32 %165 + store float %199, ptr addrspace(3) %200, align 4, !tbaa !21, !noalias !23 + %201 = extractelement <4 x float> %163, i64 1 + %202 = getelementptr i8, ptr addrspace(3) %198, i32 %172 + store float %201, ptr addrspace(3) %202, align 4, !tbaa !21, !noalias !23 + %203 = extractelement <4 x float> %163, i64 2 + %204 = getelementptr i8, ptr addrspace(3) %198, i32 %175 + store float %203, ptr addrspace(3) %204, align 4, !tbaa !21, !noalias !23 + %205 = extractelement <4 x float> %163, i64 3 + %206 = getelementptr i8, ptr addrspace(3) %198, i32 %178 + store float %205, ptr addrspace(3) %206, align 4, !tbaa !21, !noalias !23 + %207 = extractelement <4 x float> %152, i64 0 + %208 = or disjoint i32 %165, 16384 + %209 = getelementptr i8, ptr addrspace(3) %168, i32 %208 + store float %207, ptr addrspace(3) %209, align 4, !tbaa !21, !noalias !23 + %210 = extractelement <4 x float> %152, i64 1 + %211 = or disjoint i32 %165, 17408 + %212 = getelementptr i8, ptr addrspace(3) %168, i32 %211 + store float %210, ptr addrspace(3) %212, align 4, !tbaa !21, !noalias !23 + %213 = extractelement <4 x float> %152, i64 2 + %214 = or disjoint i32 %165, 18432 + %215 = getelementptr i8, ptr addrspace(3) %168, i32 %214 + store float %213, ptr addrspace(3) %215, align 4, !tbaa !21, !noalias !23 + %216 = extractelement <4 x float> %152, i64 3 + %217 = or disjoint i32 %165, 19456 + %218 = getelementptr i8, ptr addrspace(3) %168, i32 %217 + store float %216, ptr addrspace(3) %218, align 4, !tbaa !21, !noalias !23 + %219 = extractelement <4 x float> %156, i64 0 + %220 = getelementptr i8, ptr addrspace(3) %180, i32 %208 + store float %219, ptr addrspace(3) %220, align 4, !tbaa !21, !noalias !23 + %221 = extractelement <4 x float> %156, i64 1 + %222 = getelementptr i8, ptr addrspace(3) %180, i32 %211 + store float %221, ptr addrspace(3) %222, align 4, !tbaa !21, !noalias !23 + %223 = extractelement <4 x float> %156, i64 2 + %224 = getelementptr i8, ptr addrspace(3) %180, i32 %214 + store float %223, ptr addrspace(3) %224, align 4, !tbaa !21, !noalias !23 + %225 = extractelement <4 x float> %156, i64 3 + %226 = getelementptr i8, ptr addrspace(3) %180, i32 %217 + store float %225, ptr addrspace(3) %226, align 4, !tbaa !21, !noalias !23 + %227 = extractelement <4 x float> %160, i64 0 + %228 = getelementptr i8, ptr addrspace(3) %189, i32 %208 + store float %227, ptr addrspace(3) %228, align 4, !tbaa !21, !noalias !23 + %229 = extractelement <4 x float> %160, i64 1 + %230 = getelementptr i8, ptr addrspace(3) %189, i32 %211 + store float %229, ptr addrspace(3) %230, align 4, !tbaa !21, !noalias !23 + %231 = extractelement <4 x float> %160, i64 2 + %232 = getelementptr i8, ptr addrspace(3) %189, i32 %214 + store float %231, ptr addrspace(3) %232, align 4, !tbaa !21, !noalias !23 + %233 = extractelement <4 x float> %160, i64 3 + %234 = getelementptr i8, ptr addrspace(3) %189, i32 %217 + store float %233, ptr addrspace(3) %234, align 4, !tbaa !21, !noalias !23 + %235 = extractelement <4 x float> %164, i64 0 + %236 = getelementptr i8, ptr addrspace(3) %198, i32 %208 + store float %235, ptr addrspace(3) %236, align 4, !tbaa !21, !noalias !23 + %237 = extractelement <4 x float> %164, i64 1 + %238 = getelementptr i8, ptr addrspace(3) %198, i32 %211 + store float %237, ptr addrspace(3) %238, align 4, !tbaa !21, !noalias !23 + %239 = extractelement <4 x float> %164, i64 2 + %240 = getelementptr i8, ptr addrspace(3) %198, i32 %214 + store float %239, ptr addrspace(3) %240, align 4, !tbaa !21, !noalias !23 + %241 = extractelement <4 x float> %164, i64 3 + %242 = getelementptr i8, ptr addrspace(3) %198, i32 %217 + store float %241, ptr addrspace(3) %242, align 4, !tbaa !21, !noalias !23 + fence syncscope("workgroup") release + tail call void @llvm.amdgcn.s.barrier(), !noalias !23 + fence syncscope("workgroup") acquire + %243 = lshr i32 %13, 5 + %244 = shl nuw nsw i32 %13, 1 + %245 = and i32 %244, 62 + %246 = getelementptr float, ptr addrspace(3) @_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds, i32 %245 + %247 = shl nsw i32 %29, 8 + %248 = sext i32 %247 to i64 + %249 = zext nneg i32 %245 to i64 + %250 = getelementptr %struct.__hip_bfloat16, ptr addrspace(1) %9, i64 %248 + %251 = getelementptr %struct.__hip_bfloat16, ptr addrspace(1) %250, i64 %249 + %252 = or disjoint i32 %59, %243 + %253 = sext i32 %252 to i64 + %254 = getelementptr inbounds i32, ptr addrspace(1) %6, i64 %253 + %255 = load i32, ptr addrspace(1) %254, align 4, !tbaa !7, !alias.scope !17, !noalias !24 + %256 = and i32 %255, 16777215 + %257 = icmp slt i32 %256, %8 + br i1 %257, label %258, label %290 + +258: ; preds = %20 + %259 = getelementptr inbounds float, ptr addrspace(1) %7, i64 %253 + %260 = load float, ptr addrspace(1) %259, align 4, !tbaa !21, !alias.scope !19, !noalias !25 + %261 = shl nuw nsw i32 %243, 10 + %262 = getelementptr i8, ptr addrspace(3) %246, i32 %261 + %263 = getelementptr i8, ptr addrspace(3) %262, i32 256 + %264 = getelementptr i8, ptr addrspace(3) %262, i32 512 + %265 = getelementptr i8, ptr addrspace(3) %262, i32 768 + %266 = zext nneg i32 %256 to i64 + %267 = mul nuw nsw i64 %266, 14336 + %268 = getelementptr i8, ptr addrspace(1) %251, i64 %267 + %269 = load <2 x float>, ptr addrspace(3) %262, align 8, !tbaa !21, !noalias !23 + %270 = insertelement <2 x float> poison, float %260, i64 0 + %271 = shufflevector <2 x float> %270, <2 x float> poison, <2 x i32> zeroinitializer + %272 = fmul contract <2 x float> %271, %269 + %273 = fptrunc <2 x float> %272 to <2 x bfloat> + %274 = atomicrmw fadd ptr addrspace(1) %268, <2 x bfloat> %273 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + %275 = load <2 x float>, ptr addrspace(3) %263, align 8, !tbaa !21, !noalias !23 + %276 = fmul contract <2 x float> %271, %275 + %277 = fptrunc <2 x float> %276 to <2 x bfloat> + %278 = getelementptr inbounds nuw i8, ptr addrspace(1) %268, i64 128 + %279 = atomicrmw fadd ptr addrspace(1) %278, <2 x bfloat> %277 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + %280 = load <2 x float>, ptr addrspace(3) %264, align 8, !tbaa !21, !noalias !23 + %281 = fmul contract <2 x float> %271, %280 + %282 = fptrunc <2 x float> %281 to <2 x bfloat> + %283 = getelementptr inbounds nuw i8, ptr addrspace(1) %268, i64 256 + %284 = atomicrmw fadd ptr addrspace(1) %283, <2 x bfloat> %282 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + %285 = load <2 x float>, ptr addrspace(3) %265, align 8, !tbaa !21, !noalias !23 + %286 = fmul contract <2 x float> %271, %285 + %287 = fptrunc <2 x float> %286 to <2 x bfloat> + %288 = getelementptr inbounds nuw i8, ptr addrspace(1) %268, i64 384 + %289 = atomicrmw fadd ptr addrspace(1) %288, <2 x bfloat> %287 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + br label %290 + +290: ; preds = %258, %20 + %291 = or disjoint i32 %243, 8 + %292 = or disjoint i32 %291, %59 + %293 = sext i32 %292 to i64 + %294 = getelementptr inbounds i32, ptr addrspace(1) %6, i64 %293 + %295 = load i32, ptr addrspace(1) %294, align 4, !tbaa !7, !alias.scope !17, !noalias !24 + %296 = and i32 %295, 16777215 + %297 = icmp slt i32 %296, %8 + br i1 %297, label %298, label %330 + +298: ; preds = %290 + %299 = getelementptr inbounds float, ptr addrspace(1) %7, i64 %293 + %300 = load float, ptr addrspace(1) %299, align 4, !tbaa !21, !alias.scope !19, !noalias !25 + %301 = shl nuw nsw i32 %291, 10 + %302 = getelementptr i8, ptr addrspace(3) %246, i32 %301 + %303 = getelementptr i8, ptr addrspace(3) %302, i32 256 + %304 = getelementptr i8, ptr addrspace(3) %302, i32 512 + %305 = getelementptr i8, ptr addrspace(3) %302, i32 768 + %306 = zext nneg i32 %296 to i64 + %307 = mul nuw nsw i64 %306, 14336 + %308 = getelementptr i8, ptr addrspace(1) %251, i64 %307 + %309 = load <2 x float>, ptr addrspace(3) %302, align 8, !tbaa !21, !noalias !23 + %310 = insertelement <2 x float> poison, float %300, i64 0 + %311 = shufflevector <2 x float> %310, <2 x float> poison, <2 x i32> zeroinitializer + %312 = fmul contract <2 x float> %311, %309 + %313 = fptrunc <2 x float> %312 to <2 x bfloat> + %314 = atomicrmw fadd ptr addrspace(1) %308, <2 x bfloat> %313 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + %315 = load <2 x float>, ptr addrspace(3) %303, align 8, !tbaa !21, !noalias !23 + %316 = fmul contract <2 x float> %311, %315 + %317 = fptrunc <2 x float> %316 to <2 x bfloat> + %318 = getelementptr inbounds nuw i8, ptr addrspace(1) %308, i64 128 + %319 = atomicrmw fadd ptr addrspace(1) %318, <2 x bfloat> %317 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + %320 = load <2 x float>, ptr addrspace(3) %304, align 8, !tbaa !21, !noalias !23 + %321 = fmul contract <2 x float> %311, %320 + %322 = fptrunc <2 x float> %321 to <2 x bfloat> + %323 = getelementptr inbounds nuw i8, ptr addrspace(1) %308, i64 256 + %324 = atomicrmw fadd ptr addrspace(1) %323, <2 x bfloat> %322 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + %325 = load <2 x float>, ptr addrspace(3) %305, align 8, !tbaa !21, !noalias !23 + %326 = fmul contract <2 x float> %311, %325 + %327 = fptrunc <2 x float> %326 to <2 x bfloat> + %328 = getelementptr inbounds nuw i8, ptr addrspace(1) %308, i64 384 + %329 = atomicrmw fadd ptr addrspace(1) %328, <2 x bfloat> %327 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + br label %330 + +330: ; preds = %298, %290 + %331 = or disjoint i32 %243, 16 + %332 = or disjoint i32 %331, %59 + %333 = sext i32 %332 to i64 + %334 = getelementptr inbounds i32, ptr addrspace(1) %6, i64 %333 + %335 = load i32, ptr addrspace(1) %334, align 4, !tbaa !7, !alias.scope !17, !noalias !24 + %336 = and i32 %335, 16777215 + %337 = icmp slt i32 %336, %8 + br i1 %337, label %338, label %370 + +338: ; preds = %330 + %339 = getelementptr inbounds float, ptr addrspace(1) %7, i64 %333 + %340 = load float, ptr addrspace(1) %339, align 4, !tbaa !21, !alias.scope !19, !noalias !25 + %341 = shl nuw nsw i32 %331, 10 + %342 = getelementptr i8, ptr addrspace(3) %246, i32 %341 + %343 = getelementptr i8, ptr addrspace(3) %342, i32 256 + %344 = getelementptr i8, ptr addrspace(3) %342, i32 512 + %345 = getelementptr i8, ptr addrspace(3) %342, i32 768 + %346 = zext nneg i32 %336 to i64 + %347 = mul nuw nsw i64 %346, 14336 + %348 = getelementptr i8, ptr addrspace(1) %251, i64 %347 + %349 = load <2 x float>, ptr addrspace(3) %342, align 8, !tbaa !21, !noalias !23 + %350 = insertelement <2 x float> poison, float %340, i64 0 + %351 = shufflevector <2 x float> %350, <2 x float> poison, <2 x i32> zeroinitializer + %352 = fmul contract <2 x float> %351, %349 + %353 = fptrunc <2 x float> %352 to <2 x bfloat> + %354 = atomicrmw fadd ptr addrspace(1) %348, <2 x bfloat> %353 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + %355 = load <2 x float>, ptr addrspace(3) %343, align 8, !tbaa !21, !noalias !23 + %356 = fmul contract <2 x float> %351, %355 + %357 = fptrunc <2 x float> %356 to <2 x bfloat> + %358 = getelementptr inbounds nuw i8, ptr addrspace(1) %348, i64 128 + %359 = atomicrmw fadd ptr addrspace(1) %358, <2 x bfloat> %357 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + %360 = load <2 x float>, ptr addrspace(3) %344, align 8, !tbaa !21, !noalias !23 + %361 = fmul contract <2 x float> %351, %360 + %362 = fptrunc <2 x float> %361 to <2 x bfloat> + %363 = getelementptr inbounds nuw i8, ptr addrspace(1) %348, i64 256 + %364 = atomicrmw fadd ptr addrspace(1) %363, <2 x bfloat> %362 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + %365 = load <2 x float>, ptr addrspace(3) %345, align 8, !tbaa !21, !noalias !23 + %366 = fmul contract <2 x float> %351, %365 + %367 = fptrunc <2 x float> %366 to <2 x bfloat> + %368 = getelementptr inbounds nuw i8, ptr addrspace(1) %348, i64 384 + %369 = atomicrmw fadd ptr addrspace(1) %368, <2 x bfloat> %367 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + br label %370 + +370: ; preds = %338, %330 + %371 = or disjoint i32 %243, 24 + %372 = or disjoint i32 %371, %59 + %373 = sext i32 %372 to i64 + %374 = getelementptr inbounds i32, ptr addrspace(1) %6, i64 %373 + %375 = load i32, ptr addrspace(1) %374, align 4, !tbaa !7, !alias.scope !17, !noalias !24 + %376 = and i32 %375, 16777215 + %377 = icmp slt i32 %376, %8 + br i1 %377, label %378, label %410 + +378: ; preds = %370 + %379 = getelementptr inbounds float, ptr addrspace(1) %7, i64 %373 + %380 = load float, ptr addrspace(1) %379, align 4, !tbaa !21, !alias.scope !19, !noalias !25 + %381 = shl nuw nsw i32 %371, 10 + %382 = getelementptr i8, ptr addrspace(3) %246, i32 %381 + %383 = getelementptr i8, ptr addrspace(3) %382, i32 256 + %384 = getelementptr i8, ptr addrspace(3) %382, i32 512 + %385 = getelementptr i8, ptr addrspace(3) %382, i32 768 + %386 = zext nneg i32 %376 to i64 + %387 = mul nuw nsw i64 %386, 14336 + %388 = getelementptr i8, ptr addrspace(1) %251, i64 %387 + %389 = load <2 x float>, ptr addrspace(3) %382, align 8, !tbaa !21, !noalias !23 + %390 = insertelement <2 x float> poison, float %380, i64 0 + %391 = shufflevector <2 x float> %390, <2 x float> poison, <2 x i32> zeroinitializer + %392 = fmul contract <2 x float> %391, %389 + %393 = fptrunc <2 x float> %392 to <2 x bfloat> + %394 = atomicrmw fadd ptr addrspace(1) %388, <2 x bfloat> %393 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + %395 = load <2 x float>, ptr addrspace(3) %383, align 8, !tbaa !21, !noalias !23 + %396 = fmul contract <2 x float> %391, %395 + %397 = fptrunc <2 x float> %396 to <2 x bfloat> + %398 = getelementptr inbounds nuw i8, ptr addrspace(1) %388, i64 128 + %399 = atomicrmw fadd ptr addrspace(1) %398, <2 x bfloat> %397 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + %400 = load <2 x float>, ptr addrspace(3) %384, align 8, !tbaa !21, !noalias !23 + %401 = fmul contract <2 x float> %391, %400 + %402 = fptrunc <2 x float> %401 to <2 x bfloat> + %403 = getelementptr inbounds nuw i8, ptr addrspace(1) %388, i64 256 + %404 = atomicrmw fadd ptr addrspace(1) %403, <2 x bfloat> %402 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + %405 = load <2 x float>, ptr addrspace(3) %385, align 8, !tbaa !21, !noalias !23 + %406 = fmul contract <2 x float> %391, %405 + %407 = fptrunc <2 x float> %406 to <2 x bfloat> + %408 = getelementptr inbounds nuw i8, ptr addrspace(1) %388, i64 384 + %409 = atomicrmw fadd ptr addrspace(1) %408, <2 x bfloat> %407 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 + br label %410 + +410: ; preds = %378, %370, %11 + ret void +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) +declare void @llvm.assume(i1 noundef) #1 + +; Function Attrs: convergent mustprogress nocallback nofree nounwind willreturn memory(none) +declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 + +; Function Attrs: convergent mustprogress nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.sched.barrier(i32 immarg) #3 + +; Function Attrs: mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) +declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #4 + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #5 + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: read) +declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #5 + +; Function Attrs: convergent mustprogress nocallback nofree nounwind willreturn +declare void @llvm.amdgcn.s.barrier() #3 + +; Function Attrs: convergent mustprogress nocallback nofree nosync nounwind willreturn memory(none) +declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #6 + +; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #7 + +; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare noundef i32 @llvm.amdgcn.workgroup.id.x() #7 + +; Function Attrs: nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) +declare void @llvm.experimental.noalias.scope.decl(metadata) #8 + +; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) +declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p1(ptr addrspace(1) readnone, i16, i64, i32) #9 + +attributes #0 = { convergent mustprogress norecurse nounwind "amdgpu-agpr-alloc"="0" "amdgpu-flat-work-group-size"="1,256" "amdgpu-no-cluster-id-x" "amdgpu-no-cluster-id-y" "amdgpu-no-cluster-id-z" "amdgpu-no-completion-action" "amdgpu-no-default-queue" "amdgpu-no-dispatch-id" "amdgpu-no-dispatch-ptr" "amdgpu-no-flat-scratch-init" "amdgpu-no-heap-ptr" "amdgpu-no-hostcall-ptr" "amdgpu-no-implicitarg-ptr" "amdgpu-no-lds-kernel-id" "amdgpu-no-multigrid-sync-arg" "amdgpu-no-queue-ptr" "amdgpu-no-workgroup-id-x" "amdgpu-no-workgroup-id-y" "amdgpu-no-workgroup-id-z" "amdgpu-no-workitem-id-x" "amdgpu-no-workitem-id-y" "amdgpu-no-workitem-id-z" "amdgpu-waves-per-eu"="2" "denormal-fp-math-f32"="preserve-sign,preserve-sign" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="gfx950" "target-features"="+16-bit-insts,+ashr-pk-insts,+atomic-buffer-global-pk-add-f16-insts,+atomic-buffer-pk-add-bf16-inst,+atomic-ds-pk-add-16-insts,+atomic-fadd-rtn-insts,+atomic-flat-pk-add-16-insts,+atomic-fmin-fmax-global-f64,+atomic-global-pk-add-bf16-inst,+bf8-cvt-scale-insts,+bitop3-insts,+ci-insts,+dl-insts,+dot1-insts,+dot10-insts,+dot12-insts,+dot13-insts,+dot2-insts,+dot3-insts,+dot4-insts,+dot5-insts,+dot6-insts,+dot7-insts,+dpp,+f16bf16-to-fp6bf6-cvt-scale-insts,+f32-to-f16bf16-cvt-sr-insts,+fp4-cvt-scale-insts,+fp6bf6-cvt-scale-insts,+fp8-conversion-insts,+fp8-cvt-scale-insts,+fp8-insts,+gfx8-insts,+gfx9-insts,+gfx90a-insts,+gfx940-insts,+gfx950-insts,+mai-insts,+permlane16-swap,+permlane32-swap,+prng-inst,+s-memrealtime,+s-memtime-inst,+wavefrontsize64" "uniform-work-group-size"="false" } +attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } +attributes #2 = { convergent mustprogress nocallback nofree nounwind willreturn memory(none) } +attributes #3 = { convergent mustprogress nocallback nofree nounwind willreturn } +attributes #4 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) } +attributes #5 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: read) } +attributes #6 = { convergent mustprogress nocallback nofree nosync nounwind willreturn memory(none) } +attributes #7 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) } +attributes #8 = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } +attributes #9 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } +attributes #10 = { convergent nounwind } + +!llvm.module.flags = !{!0, !1, !2, !3, !4} +!llvm.ident = !{!5} +!opencl.ocl.version = !{!6} + +!0 = !{i32 1, !"amdhsa_code_object_version", i32 600} +!1 = !{i32 1, !"amdgpu_printf_kind", !"hostcall"} +!2 = !{i32 1, !"wchar_size", i32 4} +!3 = !{i32 8, !"PIC Level", i32 2} +!4 = !{i32 1, !"Code Model", i32 4} +!5 = !{!"AMD clang version 22.0.0git (https://github.com/RadeonOpenCompute/llvm-project roc-7.2.3 26084 f58b06dce1f9c15707c5f808fd002e18c2accf7e)"} +!6 = !{i32 2, i32 0} +!7 = !{!8, !8, i64 0} +!8 = !{!"int", !9, i64 0} +!9 = !{!"omnipotent char", !10, i64 0} +!10 = !{!"Simple C++ TBAA"} +!11 = !{i64 7674843} +!12 = !{!9, !9, i64 0} +!13 = !{i64 7674938} +!14 = !{!15} +!15 = distinct !{!15, !16, !"_ZN5aiter9mxfp4_moe11gemm_common24apply_atomic_bf16_epilogILi7168ELi32EEEvRAqueqT0_Li16ELi1EdvT0_Li16E_A4_KDv4_fP14__hip_bfloat16PKiPKfiiiiiiPf: argument 0"} +!16 = distinct !{!16, !"_ZN5aiter9mxfp4_moe11gemm_common24apply_atomic_bf16_epilogILi7168ELi32EEEvRAqueqT0_Li16ELi1EdvT0_Li16E_A4_KDv4_fP14__hip_bfloat16PKiPKfiiiiiiPf"} +!17 = !{!18} +!18 = distinct !{!18, !16, !"_ZN5aiter9mxfp4_moe11gemm_common24apply_atomic_bf16_epilogILi7168ELi32EEEvRAqueqT0_Li16ELi1EdvT0_Li16E_A4_KDv4_fP14__hip_bfloat16PKiPKfiiiiiiPf: argument 1"} +!19 = !{!20} +!20 = distinct !{!20, !16, !"_ZN5aiter9mxfp4_moe11gemm_common24apply_atomic_bf16_epilogILi7168ELi32EEEvRAqueqT0_Li16ELi1EdvT0_Li16E_A4_KDv4_fP14__hip_bfloat16PKiPKfiiiiiiPf: argument 2"} +!21 = !{!22, !22, i64 0} +!22 = !{!"float", !9, i64 0} +!23 = !{!15, !18, !20} +!24 = !{!15, !20} +!25 = !{!15, !18} +!26 = !{!18, !20} +!27 = !{} diff --git a/tests/kernels/test_gemm2_a4w4_port.py b/tests/kernels/test_gemm2_a4w4_port.py new file mode 100644 index 000000000..9a0d981f7 --- /dev/null +++ b/tests/kernels/test_gemm2_a4w4_port.py @@ -0,0 +1,273 @@ +#!/usr/bin/env python3 + +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2025 FlyDSL Project Contributors + +"""Accuracy + performance test for the 1:1 HIP->FlyDSL port of aiter's +``gemm2_a4w4`` MXFP4 MoE down-proj kernel (gfx950, BM32 atomic instance). + +Kernel under test: ``kernels.gemm2_a4w4_port`` (mirrors aiter PR #3470 +``mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC``). + +Three tests: + * ``test_smoke`` — self-contained: compile + run, output finite/nonzero + (no aiter dependency). + * ``test_accuracy_vs_hip``— bit-exact vs aiter's HIP gemm2 on identical bytes + (requires aiter; this is how the port was validated). + * ``test_performance`` — wall-clock vs HIP at a GPU-saturating size + (requires aiter; loose regression bound + report). + +The kernel is hardcoded to the production Kimi-K2.5 shape, so B_q is ~706 MB — +these are heavy device tests (l2_device). +""" + +import logging +import os +import sys +import time + +import pytest +import torch + +import flydsl.compiler as flyc + +pytestmark = [pytest.mark.l2_device, pytest.mark.rocm_lower] + +_REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")) +for _p in (os.path.join(_REPO_ROOT, "build", "python_packages"), _REPO_ROOT): + if os.path.isdir(_p) and _p not in sys.path: + sys.path.insert(0, _p) + +from flydsl.runtime.device import get_rocm_arch # noqa: E402 +from kernels.gemm2_a4w4_port import ( # noqa: E402 + ASCALE_BYTES, + BM, + BSCALE_BYTES, + N_OUT, + NE, + K, + compile_gemm2_a4w4_port, +) + +logging.basicConfig(level=logging.INFO) +_LOG = logging.getLogger(__name__) + +if not torch.cuda.is_available(): + pytest.skip("CUDA/ROCm not available. Skipping GPU tests.", allow_module_level=True) + +ARCH = get_rocm_arch() +if "gfx95" not in ARCH: + pytest.skip( + f"gemm2_a4w4_port uses mfma_scale_f32_16x16x128_f8f6f4 (gfx950+); got {ARCH}", + allow_module_level=True, + ) + +try: + import aiter # noqa: F401 + from aiter.ops.mxfp4_moe import mxfp4_moe_gemm2_a4w4 + + HAS_AITER = True +except Exception: + HAS_AITER = False + +HIP_KERNEL_NAME = "mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC" + +# One compiled launcher reused across tests (compile is the expensive part). +_LAUNCH = None + + +def _launcher(): + global _LAUNCH + if _LAUNCH is None: + _LAUNCH = compile_gemm2_a4w4_port() + return _LAUNCH + + +def _make_inputs(srt: int, seed: int = 0, const_scale: bool = True): + """Build a valid input set. ``const_scale`` pins e8m0 scales to 127 (2^0) so + random fp4 data cannot overflow to inf/nan; unique sorted_token_ids + (one token per sorted row) make the bf16 atomic accumulation deterministic + so HIP and the port are comparable bit-for-bit. + """ + dev = "cuda" + g = torch.Generator(device=dev).manual_seed(seed) + assert srt % BM == 0 + mmb = srt // BM + M = srt + t = dict( + aq=torch.randint(0, 256, (srt, K // 2), dtype=torch.uint8, device=dev, generator=g), + ascale=torch.full((ASCALE_BYTES // 4, 4), 127, dtype=torch.uint8, device=dev), + bq=torch.randint(0, 256, (NE, N_OUT, K // 2), dtype=torch.uint8, device=dev, generator=g), + bscale=torch.full((BSCALE_BYTES // 4, 4), 127, dtype=torch.uint8, device=dev), + eids=torch.randint(0, NE, (mmb,), dtype=torch.int32, device=dev, generator=g), + cumsum=torch.tensor([srt], dtype=torch.int32, device=dev), + stids=torch.randperm(M, dtype=torch.int32, device=dev, generator=g), + sweights=(torch.rand(srt, dtype=torch.float32, device=dev, generator=g) + 0.5), + ) + if not const_scale: + t["ascale"] = torch.randint(0, 256, t["ascale"].shape, dtype=torch.uint8, device=dev) + t["bscale"] = torch.randint(0, 256, t["bscale"].shape, dtype=torch.uint8, device=dev) + t["M"] = M + t["mmb"] = mmb + return t + + +def _compile_port(t, out): + """flyc.compile EXECUTES the kernel once into the buffer it is given, so + compile against a throwaway buffer; the returned callable is then run into + the real (zeroed) output. The kernel atomic-accumulates, so reusing one + buffer for both compile and run would double the result.""" + throwaway = torch.zeros_like(out) + return flyc.compile( + _launcher(), + t["aq"], + t["ascale"], + t["bq"], + t["bscale"], + t["eids"], + t["cumsum"], + t["stids"], + t["sweights"], + t["M"], + t["mmb"], + throwaway, + torch.cuda.current_stream(), + ) + + +def _run_port(t, out=None): + if out is None: + out = torch.zeros(t["M"], N_OUT, dtype=torch.bfloat16, device="cuda") + launch = _compile_port(t, out) + out.zero_() + launch( + t["aq"], + t["ascale"], + t["bq"], + t["bscale"], + t["eids"], + t["cumsum"], + t["stids"], + t["sweights"], + t["M"], + t["mmb"], + out, + torch.cuda.current_stream(), + ) + torch.cuda.synchronize() + return out, launch + + +def _run_hip(t, out=None): + if out is None: + out = torch.zeros(t["M"], N_OUT, dtype=torch.bfloat16, device="cuda") + else: + out.zero_() + mxfp4_moe_gemm2_a4w4( + t["cumsum"], + t["aq"], + t["ascale"], + t["bq"], + t["bscale"], + t["stids"], + t["eids"], + t["sweights"], + out, + t["M"], + t["M"], + HIP_KERNEL_NAME, + ) + torch.cuda.synchronize() + return out + + +def _median_us(fn, warmup=15, iters=60): + for _ in range(warmup): + fn() + torch.cuda.synchronize() + ts = [] + for _ in range(iters): + s = time.perf_counter() + fn() + torch.cuda.synchronize() + ts.append(time.perf_counter() - s) + ts.sort() + return ts[len(ts) // 2] * 1e6 + + +def test_smoke(): + """Self-contained: the ported kernel compiles, runs, and produces a + finite, non-zero output (no aiter / no reference needed).""" + t = _make_inputs(srt=256, seed=1) + out, _ = _run_port(t) + assert torch.isfinite(out).all(), "port output has non-finite values" + assert out.abs().sum().item() > 0, "port output is all zero" + + +@pytest.mark.skipif(not HAS_AITER, reason="aiter required for the HIP gemm2 reference") +@pytest.mark.parametrize("srt", [256, 1024]) +def test_accuracy_vs_hip(srt): + """Bit-exact match against aiter's HIP gemm2 on identical input bytes.""" + t = _make_inputs(srt=srt, seed=2) + out_hip = _run_hip(t) + out_port, _ = _run_port(t) + + assert torch.isfinite(out_hip).all() and torch.isfinite(out_port).all() + if torch.equal(out_hip, out_port): + return # bit-exact + a = out_hip.float().reshape(-1) + b = out_port.float().reshape(-1) + cos = torch.nn.functional.cosine_similarity(a, b, dim=0).item() + max_abs = (a - b).abs().max().item() + raise AssertionError(f"port != HIP (srt={srt}): cosine={cos:.6f} max_abs_diff={max_abs:.6g}") + + +@pytest.mark.skipif(not HAS_AITER, reason="aiter required for the HIP gemm2 reference") +@pytest.mark.parametrize("srt", [4096]) +def test_performance(srt): + """Wall-clock vs HIP at a GPU-saturating size. Reports the ratio and guards + against a large regression (loose bound — wall-clock includes host launch + overhead; pure GPU-kernel time is closer/faster, see PORT_DESIGN.md).""" + t = _make_inputs(srt=srt, seed=3) + out = torch.zeros(t["M"], N_OUT, dtype=torch.bfloat16, device="cuda") + launch = _compile_port(t, out) + + def f_port(): + launch( + t["aq"], + t["ascale"], + t["bq"], + t["bscale"], + t["eids"], + t["cumsum"], + t["stids"], + t["sweights"], + t["M"], + t["mmb"], + out, + torch.cuda.current_stream(), + ) + + def f_hip(): + mxfp4_moe_gemm2_a4w4( + t["cumsum"], + t["aq"], + t["ascale"], + t["bq"], + t["bscale"], + t["stids"], + t["eids"], + t["sweights"], + out, + t["M"], + t["M"], + HIP_KERNEL_NAME, + ) + + hip_us = _median_us(f_hip) + port_us = _median_us(f_port) + ratio = port_us / hip_us + _LOG.info("gemm2 a4w4 srt=%d HIP=%.1f us port=%.1f us port/HIP=%.2fx", srt, hip_us, port_us, ratio) + # Loose regression guard (saturated wall-clock; port is typically <=1.05x and + # faster on pure GPU time). Fail only on a large regression. + assert ratio < 1.5, f"port too slow vs HIP: {ratio:.2f}x ({port_us:.1f} vs {hip_us:.1f} us)" From 9c3546b4a9f968c356b05802c0a5c3d81bd2f518 Mon Sep 17 00:00:00 2001 From: fsx950223 Date: Fri, 5 Jun 2026 05:03:46 +0000 Subject: [PATCH 2/5] perf(gemm2): Hide small-M latency in a4w4 port to reach HIP parity Two bit-exact latency-hiding changes close the small-M (M<=32) gap vs HIP: - Issue A->LDS before the cumsum-gated early-return branch. The raw.ptr.buffer.load.lds is side-effecting so it is not sunk back, letting its HBM latency overlap the cumsum/bound check. - Prefetch sorted_token_ids/sorted_weights (invariant) at epilog entry, before the cshuffle stores and both LDS barriers, so their latency overlaps the store+barriers instead of being exposed in the dependent atomic loop (the epilog is ~48% of small-M stalls). Result (cuda-graph unit-test timing, port/HIP): M=4 1.32x->0.92x, M=16 1.30x->0.92x, M=32 1.27x->0.95x; >=M=64 already 0.87-1.00x. Output stays bit-exact (4/4 accuracy/perf tests pass). test_performance now uses CUDA-graph GPU-event timing and is parametrized over test.py's KIMI M-list plus a large context (srt=147456). PORT_DESIGN.md documents the optimization and the interleaved measurement method. Signed-off-by: fsx950223 --- kernels/gemm2_a4w4_port.py | 109 ++++++++++++++------------ kernels/gemm2_port_ref/PORT_DESIGN.md | 30 +++++++ tests/kernels/test_gemm2_a4w4_port.py | 72 ++++++++++++----- 3 files changed, 142 insertions(+), 69 deletions(-) diff --git a/kernels/gemm2_a4w4_port.py b/kernels/gemm2_a4w4_port.py index dda3e80b1..617bcce84 100644 --- a/kernels/gemm2_a4w4_port.py +++ b/kernels/gemm2_a4w4_port.py @@ -137,6 +137,23 @@ def _lds_swizzle_mask(row): return (row & fx.Int32(14)) << fx.Int32(3) +def _issue_a_load_lds(aq_rsrc, saq, slot, kt, car0, lane, wave): + """Issue one A->LDS tile load (sub=0): ``raw.ptr.buffer.load.lds`` into + s_Aq[slot]. Pulled out of _gemm2_body so it can be issued before the + cumsum-gated branch (the op is side-effecting and cannot be sunk back).""" + lane_div_8 = lane // fx.Int32(8) + lane_mod_8 = lane % fx.Int32(8) + lds_row = wave * fx.Int32(BM // 4) + mask = _lds_swizzle_mask(lds_row + lane_div_8) + voffset = ((lane_mod_8 * fx.Int32(16)) ^ mask) + car0 * fx.Int32(K // 2) + base_i32 = fx.Int32(memref_dialect.extract_aligned_pointer_as_index(saq.get())) + off_i32 = fx.Int32(slot * SAQ_SLOT_BYTES) + lds_row * fx.Int32(KH_TILE) + lds_ptr = _lds_ptr3(base_i32, off_i32) + rocdl.raw_ptr_buffer_load_lds( + aq_rsrc, lds_ptr, fx.Int32(16), voffset, fx.Int32(kt * KH_TILE), fx.Int32(0), fx.Int32(0) + ) + + def compile_gemm2_a4w4_port(): allocator = SmemAllocator(None, arch="gfx950", global_sym_name="gemm2port_smem") lds_off = allocator._align(allocator.ptr, 16) @@ -163,6 +180,22 @@ def gemm2_kernel( lane = tx_i32 % fx.Int32(64) wave = rocdl.readfirstlane(T.i32, tx_i32 // fx.Int32(64)) # wave == wave_n + # ── issue A->LDS as early as possible, BEFORE the cumsum-gated branch ── + # raw.ptr.buffer.load.lds is side-effecting (writes LDS), so the compiler + # cannot sink it back into the then-block. Issuing it here overlaps the + # A->LDS HBM latency with the cumsum load + bound check, shrinking the + # K-loop's first cross-wave barrier wait for A (the dominant fixed + # per-workgroup cost in the latency-bound small-M regime). A->LDS depends + # only on bx/lane (not cumsum/eids); for padding blocks it loads + # harmlessly into LDS and the early-return below still skips all compute. + m_row0 = (bx_i32 // fx.Int32(NUM_N_BLOCKS)) * fx.Int32(BM) + car0 = m_row0 + wave * fx.Int32(BM // 4) + (lane // fx.Int32(8)) + aq_rsrc = buffer_ops.create_buffer_resource(arg_aq, max_size=False, num_records_bytes=fx.Index(AQ_BYTES)) + saq = SmemPtr(allocator.get_base(), lds_off, T.i8, shape=(kStages * SAQ_SLOT_BYTES,)) + _issue_a_load_lds(aq_rsrc, saq, 0, 0, car0, lane, wave) + _issue_a_load_lds(aq_rsrc, saq, 1, 1, car0, lane, wave) + rocdl.sched_barrier(0) + # total_m_blocks = cumsum[0] / BM ; bound = total_m_blocks * NUM_N_BLOCKS cumsum0 = llvm.load(T.i32, _global_ptr1(arg_cumsum, fx.Int32(0))) total_m_blocks = cumsum0 // fx.Int32(BM) @@ -174,7 +207,6 @@ def gemm2_kernel( _gemm2_body( allocator, lds_off, - arg_aq, arg_ascale, arg_bq, arg_bscale, @@ -230,7 +262,6 @@ def launch_gemm2( def _gemm2_body( allocator, lds_off, - arg_aq, arg_ascale, arg_bq, arg_bscale, @@ -243,8 +274,6 @@ def _gemm2_body( lane, wave, ): - c0 = fx.Int32(0) - # block -> (m_block_idx, n_block_idx) ; e = sorted_expert_ids[m_block_idx] n_block_idx = bx_i32 % fx.Int32(NUM_N_BLOCKS) m_block_idx = bx_i32 // fx.Int32(NUM_N_BLOCKS) @@ -253,7 +282,7 @@ def _gemm2_body( m_row = m_block_idx * fx.Int32(BM) # ── buffer resources (exact num_bytes) ────────────────────────────────── - aq_rsrc = buffer_ops.create_buffer_resource(arg_aq, max_size=False, num_records_bytes=fx.Index(AQ_BYTES)) + # (A_q resource + A->LDS loads are issued by the kernel before the branch.) ascale_rsrc = buffer_ops.create_buffer_resource( arg_ascale, max_size=False, num_records_bytes=fx.Index(ASCALE_BYTES) ) @@ -268,8 +297,6 @@ def _gemm2_body( saq = SmemPtr(lds_base, lds_off, T.i8, shape=(kStages * SAQ_SLOT_BYTES,)) lds_acc = SmemPtr(lds_base, lds_off, T.f32, shape=(LDS_ACC_FLOATS,)) - lane_div_8 = lane // fx.Int32(8) - lane_mod_8 = lane % fx.Int32(8) lane_div_16 = lane // fx.Int32(16) lane_mod_16 = lane % fx.Int32(16) @@ -293,32 +320,7 @@ def _gemm2_body( chunk_base = m_row // fx.Int32(32) a_scale_s_base0 = rocdl.readfirstlane(T.i32, chunk_base * fx.Int32(kAS_per_chunk_dw) * fx.Int32(4)) - # cached_actual_row[0] (sub=0): m_row + wave*(BM/4) + 0 + lane/8 - car0 = m_row + wave * fx.Int32(BM // 4) + lane_div_8 - - # ── issue_a_load_lds(slot, kt) ────────────────────────────────────────── - def issue_a_load_lds(slot, kt): - # sub=0: lds_row = wave*(BM/4) + 0 ; row_off = lane/8 - lds_row = wave * fx.Int32(BM // 4) - mask = _lds_swizzle_mask(lds_row + lane_div_8) - voffset = ((lane_mod_8 * fx.Int32(16)) ^ mask) + car0 * fx.Int32(K // 2) - # LDS dst pointer = base + slot*SAQ_SLOT_BYTES + lds_row*KH_TILE (bytes) - base_i32 = fx.Int32(memref_dialect.extract_aligned_pointer_as_index(saq.get())) - off_i32 = fx.Int32(slot * SAQ_SLOT_BYTES) + lds_row * fx.Int32(KH_TILE) - lds_ptr = _lds_ptr3(base_i32, off_i32) - rocdl.raw_ptr_buffer_load_lds( - aq_rsrc, - lds_ptr, - fx.Int32(16), - voffset, - fx.Int32(kt * KH_TILE), - c0, - c0, - ) - - issue_a_load_lds(0, 0) - issue_a_load_lds(1, 1) - rocdl.sched_barrier(0) + # (A->LDS for both slots is issued by the kernel before the in-range branch.) # ── a_scale (atomic) : v_voff = ((lane/16)*16 + lane%16)*4 ─────────────── v_voff_scale = ((lane_div_16 * fx.Int32(16)) + lane_mod_16) * fx.Int32(4) @@ -441,6 +443,28 @@ def _atomic_bf16_epilog(lds_acc, accm, arg_out, arg_stids, arg_sweights, m_row, lane_mod_16 = lane % fx.Int32(16) lds_base = _lds_base_ptr3(lds_acc.get()) + tx_i32 = arith.index_cast(T.i32, gpu.thread_id("x")) + m_lane = tx_i32 // fx.Int32(32) + n_lane = tx_i32 % fx.Int32(32) + col_start = n_lane * fx.Int32(2) + stids_base = _global_base_ptr1(arg_stids) + sweights_base = _global_base_ptr1(arg_sweights) + out_base = _global_base_ptr1(arg_out) + + M_REPS = BM // 8 # 4 + # Prefetch sorted_token_ids / sorted_weights BEFORE the cshuffle stores and + # both LDS barriers. These read-only loads depend only on m_row/tid, so + # issuing them up front (invariant => freely hoistable, matching HIP's + # const __restrict__ inputs) overlaps their global latency with the store + + # barriers instead of exposing it in the dependent atomic loop. The epilog + # is ~half of the small-M kernel stall, so this is the main small-M lever. + packed = [] + weight = [] + for mr in range_constexpr(M_REPS): + sorted_pos = m_row + fx.Int32(mr * 8) + m_lane + packed.append(llvm.load(T.i32, _gep1(stids_base, sorted_pos * fx.Int32(4)), invariant=True)) + weight.append(llvm.load(T.f32, _gep1(sweights_base, sorted_pos * fx.Int32(4)), invariant=True)) + # pre-store fence+barrier: all waves done reading s_Aq before lds_acc reuse # (HIP run_one __syncthreads() before apply_atomic_bf16_epilog). rocdl.barrier() @@ -457,24 +481,11 @@ def _atomic_bf16_epilog(lds_acc, accm, arg_out, arg_stids, arg_sweights, m_row, rocdl.barrier() - # read back + weighted atomic add - tx_i32 = arith.index_cast(T.i32, gpu.thread_id("x")) - m_lane = tx_i32 // fx.Int32(32) - n_lane = tx_i32 % fx.Int32(32) - col_start = n_lane * fx.Int32(2) - - stids_base = _global_base_ptr1(arg_stids) - sweights_base = _global_base_ptr1(arg_sweights) - out_base = _global_base_ptr1(arg_out) - - M_REPS = BM // 8 # 4 + # read back + weighted atomic add (token_id / weight prefetched above) for mr in range_constexpr(M_REPS): row_in_block = fx.Int32(mr * 8) + m_lane - sorted_pos = m_row + row_in_block - packed = llvm.load(T.i32, _gep1(stids_base, sorted_pos * fx.Int32(4))) - token_id = packed & fx.Int32(0x00FFFFFF) + token_id = packed[mr] & fx.Int32(0x00FFFFFF) valid = arith.cmpi(arith.CmpIPredicate.slt, token_id, i32_M) - weight = llvm.load(T.f32, _gep1(sweights_base, sorted_pos * fx.Int32(4))) if_op = scf.IfOp(valid, [], has_else=False) with ir.InsertionPoint(if_op.then_block): row_base_addr = token_id * fx.Int32(N_OUT) + n_block_idx * fx.Int32(BN) + col_start @@ -482,7 +493,7 @@ def _atomic_bf16_epilog(lds_acc, accm, arg_out, arg_stids, arg_sweights, m_row, # adjacent ee=0,1 are contiguous -> one <2xf32> load (as HIP vectorizes) idx0 = row_in_block * fx.Int32(BN) + col_start + fx.Int32(s * 64) v2 = Vec(llvm.load(T.vec(2, T.f32), _gep3(lds_base, idx0 * fx.Int32(4)))) - pk = Vec.from_elements([v2[0] * weight, v2[1] * weight], fx.Float32).to(fx.BFloat16) + pk = Vec.from_elements([v2[0] * weight[mr], v2[1] * weight[mr]], fx.Float32).to(fx.BFloat16) off = (row_base_addr + fx.Int32(s * 64)) * fx.Int32(2) # bf16 byte offset out_ptr = _gep1(out_base, off) llvm.AtomicRMWOp( diff --git a/kernels/gemm2_port_ref/PORT_DESIGN.md b/kernels/gemm2_port_ref/PORT_DESIGN.md index d9ed0756e..8f4efaba4 100644 --- a/kernels/gemm2_port_ref/PORT_DESIGN.md +++ b/kernels/gemm2_port_ref/PORT_DESIGN.md @@ -230,3 +230,33 @@ pattern: compile against a throwaway buffer, then zero the real out and call onc /tmp/iter_gemm2.sh → syncs kernel to remote, runs /tmp/run_compile_gemm2.sh (COMPILE_ONLY=1 + FLYDSL_DUMP_IR), dumps to /tmp/gemm2_dump/. Driver: /tmp/drive_gemm2.py. HIP ref rebuild: /tmp/emit_hip_ir.sh. + +## SMALL-M LATENCY OPTIMIZATION (post-port perf work) +The 1:1 port matched HIP structurally but was ~1.3× slower at tiny latency-bound +sizes (M≤32, kernels 4–6µs; crossover at M=64 where it already beat HIP). ATT +(rocprofv3 advanced_thread_trace + hotspot_analyzer) region breakdown showed the +**epilog = ~48% of small-M stalls** and the kernel is latency-bound (occupancy +LDS-bound at 5 waves/SIMD, identical to HIP). Two bit-exact latency-hiding +changes closed the gap: + +1. **Early A→LDS** — issue `raw.ptr.buffer.load.lds` before the cumsum-gated + early-return branch. The op is side-effecting so LLVM cannot sink it back + (pure resource-creation hoists ARE sunk by MachineSink — verified, inert); + this overlaps A→LDS HBM latency with the cumsum load + bound check. +2. **Epilog token/weight prefetch** — load `sorted_token_ids`/`sorted_weights` + (invariant, read-only) at epilog entry, before the cshuffle stores and both + LDS barriers, instead of in the dependent atomic loop. They depend only on + m_row/tid, so their global latency overlaps the store+barriers. **Main lever.** + +Result (interleaved same-process rocprofv3, port absolute median time): +M=4 5.92→4.96µs, M=16 6.36→5.32µs (~16% faster). port/HIP ratio: M=4 1.32→~1.0×, +M=16 1.30→~1.0×, M=32 1.27→~1.13× (M=32 is the awkward 252-wg/256-CU occupancy +point), M=64 0.96×, M=256 0.91→0.86×. Output still **bit-exact**; 4/4 pytest pass. + +Tried and reverted (no benefit): merging the 2 K-loop barriers (unsafe — HIP +comments them "correctness fence, not a perf knob" — and perf-neutral since the +kernel is memory-latency bound, not barrier-bound). + +**Measurement note:** per-process rocprofv3 at 4–6µs is dominated by GPU-clock +state (±10%); use an interleaved same-process driver (`port(); hip()` in one loop +under one trace) and track the port's absolute median as the stable signal. diff --git a/tests/kernels/test_gemm2_a4w4_port.py b/tests/kernels/test_gemm2_a4w4_port.py index 9a0d981f7..e16d8f9bb 100644 --- a/tests/kernels/test_gemm2_a4w4_port.py +++ b/tests/kernels/test_gemm2_a4w4_port.py @@ -24,7 +24,6 @@ import logging import os import sys -import time import pytest import torch @@ -181,18 +180,43 @@ def _run_hip(t, out=None): return out -def _median_us(fn, warmup=15, iters=60): - for _ in range(warmup): - fn() +def _graph_median_us(fn, warmup=8, replays=100, reps=20): + """Median per-replay GPU time (microseconds) using a HIP/CUDA graph. + + ``fn`` enqueues exactly one kernel on the current stream. We warm up on a + side stream (to finish any lazy init before capture), capture a single + ``fn()`` into a CUDA graph, then time batches of ``replays`` graph replays + with CUDA events. Graph replay removes per-launch host overhead, and event + timing measures pure GPU time, so this isolates the kernel itself. + + Note: the kernel atomic-accumulates into ``out`` and replays are not zeroed, + so the accumulator saturates to inf over many replays. That does not affect + the (data-independent) GEMM timing. + """ + s = torch.cuda.Stream() + s.wait_stream(torch.cuda.current_stream()) + with torch.cuda.stream(s): + for _ in range(warmup): + fn() + torch.cuda.current_stream().wait_stream(s) torch.cuda.synchronize() - ts = [] - for _ in range(iters): - s = time.perf_counter() + + g = torch.cuda.CUDAGraph() + with torch.cuda.graph(g): fn() - torch.cuda.synchronize() - ts.append(time.perf_counter() - s) - ts.sort() - return ts[len(ts) // 2] * 1e6 + + start = torch.cuda.Event(enable_timing=True) + end = torch.cuda.Event(enable_timing=True) + samples = [] + for _ in range(reps): + start.record() + for _ in range(replays): + g.replay() + end.record() + end.synchronize() + samples.append(start.elapsed_time(end) / replays * 1e3) # ms total -> us/replay + samples.sort() + return samples[len(samples) // 2] def test_smoke(): @@ -223,11 +247,14 @@ def test_accuracy_vs_hip(srt): @pytest.mark.skipif(not HAS_AITER, reason="aiter required for the HIP gemm2 reference") -@pytest.mark.parametrize("srt", [4096]) +# srt = roundup(M*TOPK, BM) for test.py's KIMI-K2.5 M-list {4,8,16,32,64,128,256} +# plus a large context (M=16384 tokens -> srt=147456). TOPK=9, BM=32: the gemm2 +# down-proj processes the expanded+padded tokens. +@pytest.mark.parametrize("srt", [64, 96, 160, 288, 576, 1152, 2304, 147456]) def test_performance(srt): - """Wall-clock vs HIP at a GPU-saturating size. Reports the ratio and guards - against a large regression (loose bound — wall-clock includes host launch - overhead; pure GPU-kernel time is closer/faster, see PORT_DESIGN.md).""" + """CUDA-graph (GPU-event timed) kernel performance vs HIP at a GPU-saturating + size. Graph replay removes host launch overhead so this reflects pure + GPU-kernel time. Reports the ratio and guards against a large regression.""" t = _make_inputs(srt=srt, seed=3) out = torch.zeros(t["M"], N_OUT, dtype=torch.bfloat16, device="cuda") launch = _compile_port(t, out) @@ -264,10 +291,15 @@ def f_hip(): HIP_KERNEL_NAME, ) - hip_us = _median_us(f_hip) - port_us = _median_us(f_port) + hip_us = _graph_median_us(f_hip) + port_us = _graph_median_us(f_port) ratio = port_us / hip_us - _LOG.info("gemm2 a4w4 srt=%d HIP=%.1f us port=%.1f us port/HIP=%.2fx", srt, hip_us, port_us, ratio) - # Loose regression guard (saturated wall-clock; port is typically <=1.05x and - # faster on pure GPU time). Fail only on a large regression. + _LOG.info( + "gemm2 a4w4 srt=%d HIP=%.1f us port=%.1f us port/HIP=%.2fx (cuda-graph)", + srt, + hip_us, + port_us, + ratio, + ) + # Loose regression guard. Fail only on a large regression. assert ratio < 1.5, f"port too slow vs HIP: {ratio:.2f}x ({port_us:.1f} vs {hip_us:.1f} us)" From d1d3514f2e184b63772dba7f079d1d2f2051f4bb Mon Sep 17 00:00:00 2001 From: fsx950223 Date: Fri, 5 Jun 2026 05:08:16 +0000 Subject: [PATCH 3/5] chore(gemm2): Drop gemm2_port_ref dev artifacts from the repo Remove the port's development reference directory (HIP/FlyDSL IR dumps + PORT_DESIGN.md) from version control; nothing imports or tests it. Also drop the two dangling docstring references to it. Files are kept locally (untracked). Signed-off-by: fsx950223 --- kernels/gemm2_a4w4_port.py | 3 - kernels/gemm2_port_ref/PORT_DESIGN.md | 262 ---- .../gemm2_port_ref/flydsl_gemm2_existing.ll | 1256 ----------------- kernels/gemm2_port_ref/flydsl_port_v1.ll | 892 ------------ kernels/gemm2_port_ref/flydsl_port_v2.ll | 956 ------------- kernels/gemm2_port_ref/flydsl_port_v3.ll | 1083 -------------- kernels/gemm2_port_ref/flydsl_port_v4.ll | 943 ------------- kernels/gemm2_port_ref/flydsl_port_v5.ll | 898 ------------ kernels/gemm2_port_ref/flydsl_port_v6.ll | 866 ------------ kernels/gemm2_port_ref/hip_gemm2_bm32.ll | 570 -------- 10 files changed, 7729 deletions(-) delete mode 100644 kernels/gemm2_port_ref/PORT_DESIGN.md delete mode 100644 kernels/gemm2_port_ref/flydsl_gemm2_existing.ll delete mode 100644 kernels/gemm2_port_ref/flydsl_port_v1.ll delete mode 100644 kernels/gemm2_port_ref/flydsl_port_v2.ll delete mode 100644 kernels/gemm2_port_ref/flydsl_port_v3.ll delete mode 100644 kernels/gemm2_port_ref/flydsl_port_v4.ll delete mode 100644 kernels/gemm2_port_ref/flydsl_port_v5.ll delete mode 100644 kernels/gemm2_port_ref/flydsl_port_v6.ll delete mode 100644 kernels/gemm2_port_ref/hip_gemm2_bm32.ll diff --git a/kernels/gemm2_a4w4_port.py b/kernels/gemm2_a4w4_port.py index 617bcce84..285364ffd 100644 --- a/kernels/gemm2_a4w4_port.py +++ b/kernels/gemm2_a4w4_port.py @@ -14,9 +14,6 @@ * ``s_waitcnt vmcnt(23/22)`` + ``s_barrier`` cross-wave fences. * K=512 = 2 K-tiles fully unrolled; 32 ``mfma.scale.f32.16x16x128.f8f6f4``. * atomic bf16 epilog: LDS cshuffle -> ``global.atomic.fadd.v2bf16`` * topk weight. - -Reference IR: kernels/gemm2_port_ref/hip_gemm2_bm32.ll -Design notes: kernels/gemm2_port_ref/PORT_DESIGN.md """ import flydsl.compiler as flyc diff --git a/kernels/gemm2_port_ref/PORT_DESIGN.md b/kernels/gemm2_port_ref/PORT_DESIGN.md deleted file mode 100644 index 8f4efaba4..000000000 --- a/kernels/gemm2_port_ref/PORT_DESIGN.md +++ /dev/null @@ -1,262 +0,0 @@ -# gemm2_a4w4 HIP → FlyDSL 1:1 port — design & status - -## Goal -Port aiter PR #3470 `gemm2_a4w4` (HIP) into FlyDSL (`kernels/`), driving the -FlyDSL-generated LLVM IR to match the HIP-generated LLVM IR as closely as the -two toolchains allow. Test on remote gfx950 (`dzm-mi355-gpu34-dev`). - -## Feasibility calibration (important) -Byte-identical LLVM across clang(HIP) and MLIR(FlyDSL) is **not achievable** -(SSA value names, basic-block order, metadata/TBAA, attribute sets, GEP -canonicalization all differ structurally between the two frontends). - -**Achievable bar = instruction-level equivalence**: same set of `amdgcn.*` -intrinsic calls with identical immediate operands, same LDS layout/size, same -control-flow skeleton. The census below proves this is within reach. - -## Target instance (pinned) -`mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC` -`launch_atomic` - -Constants: BN=256, BK=256, K_HALF=256, K_TILES_TOTAL=2, kStages=2, -kSubBlocks=1, kMChunks=2, num_n_blocks=N_OUT/256=28. -LDS = union{ s_Aq[2][32][128] fp4x2 (8KB), lds_acc[32*256] f32 (32KB) } = **32KB = [8192 x float]**. - -Scale layout consts: kBS_c_n1=224, kBS_c_k1=2, kBS_stride_k0_dw=64, -kBS_stride_n0_dw=128, kBS_per_expert_dw=28672; kAS_c_k1=2, kAS_per_chunk_dw=128. - -## HIP reference IR census (kernels/gemm2_port_ref/hip_gemm2_bm32.ll, 570 lines) -| intrinsic | count | immediates | -|---|---|---| -| `mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32` | 32 | cbsz=4, blgp=4, op_sel a/b per cluster | -| `make.buffer.rsrc.p8.p1` | 4 | i16 0, flags i32 131072(0x20000); num_bytes: A_q=167772160, A_scale=10485760, B_q=706478080, B_scale=44154880 | -| `raw.ptr.buffer.load.lds` | 2 | size=16, soffset imm 0 then 128 | -| `raw.ptr.buffer.load.v4i32` (B) | 16 | 4 j × {imm 0,1024} × 2 K_C | -| `raw.ptr.buffer.load.i32` (scales) | 6 | A_scale 2 (imm 0,256) + B_scale 4 | -| inline asm `s_waitcnt vmcnt(23)` / `vmcnt(22)` | 2 | cross-wave fence before s_barrier | -| `s.barrier` | 3 | 2 in K-loop + 1 epilog | -| `global.atomic.fadd.v2bf16` | 16 | 4 mr × 4 stride | -| LDS addrspace(3) refs | 126 | | - -Kernel attrs: target-cpu gfx950, `amdgpu-flat-work-group-size`="1,256", -`amdgpu-waves-per-eu`="2", `amdgpu-agpr-alloc`="0". - -## FlyDSL existing gemm2 census (flydsl_gemm2_existing.ll, 1256 lines) -`mfma_moe2_afp4_wfp4_bf16_cshuffle_t32x256x256_vscale_fix3_persist_cu256` -ALREADY matches at intrinsic level: mfma 32 ✓, buffer.load.lds 2 ✓, -buffer.load.v4i32 16 ✓, atomic v2bf16 16 ✓. -Differences (structural, the port must fix): -- make.buffer.rsrc 8 (2×) vs 4 — persistent loop re-creates rsrc. -- s.barrier 6 vs 3; no `s_waitcnt vmcnt` inline-asm fences (0 vs 2). -- IR 1256 vs 570 lines — persistent cu256 grid loop + CShuffle verbosity. -→ Port targets the **non-persistent atomic** structure (one tile/block + early -return), 4 rsrc, explicit vmcnt fences, K=512 2-stage unroll. - -## FlyDSL primitives (exact) -- raw MFMA: `rocdl.mfma_scale_f32_16x16x128_f8f6f4(vec4_f32, [a8xi32, b8xi32, acc, cbsz, blgp, opselA, scaleA_i32, opselB, scaleB_i32])` — rocdl/__init__.py:168 -- A→LDS: `rocdl.raw_ptr_buffer_load_lds(rsrc_p8, lds_p3, size, voffset, soffset, offset, aux)` — :495 -- B/scale loads: `buffer_ops.buffer_load(rsrc, offset_elems, vec_width, dtype, soffset_bytes=)` ; rsrc via `buffer_ops.create_buffer_resource(memref, max_size=False, num_records_bytes=N)` (-> p8) — buffer_ops.py:386 -- atomic pk bf16: `rocdl.raw_ptr_buffer_atomic_fadd(vdata_2xbf16, rsrc, offset, soffset, aux)` — :456 (or llvm.AtomicRMWOp fadd v2bf16, syncscope agent, moe_gemm_2stage.py:3100) -- LDS: SmemAllocator/SmemPtr (utils/smem_allocator.py); ds_read via vector.load on LDS memref -- inline asm fence: `_llvm.inline_asm(None, [], "s_waitcnt vmcnt(N)\ns_barrier", "", has_side_effects=True)` — fp8_gemm_utils.py:197 -- s.barrier: `rocdl.barrier()`; sched: `rocdl.sched_barrier(0)`; `rocdl.readfirstlane(T.i32, src)` -- fp4 pack: build vector<4xi64> via vector.from_elements (2 data + 2 zero i64) then vector.bitcast to vector<8xi32> — mixed_moe_gemm_2stage.py:1232 -- decorators: `@flyc.kernel(name=, known_block_size=[256,1,1])`, `@flyc.jit`; launch `.launch(grid=, block=(256,1,1), stream=)`; waves-per-eu via CompilationContext.compile_hints({"waves_per_eu":2}) - -## Iteration loop (remote gfx950) -Helper: /tmp/rmi.sh '' runs in container. FlyDSL env: -``` -FLY=/home/zhiming_ding_qle/sixifang/FlyDSL -PYTHONPATH=$FLY/build-fly/python_packages:$FLY/python -LD_LIBRARY_PATH=$FLY/build-fly/python_packages/flydsl/_mlir/_mlir_libs -FLYDSL_DUMP_IR=1 FLYDSL_DUMP_DIR=/tmp/flydsl_dump FLYDSL_RUNTIME_ENABLE_CACHE=0 -``` -Dumped final LLVM IR = `//NN_llvm_ir.ll`. -HIP reference rebuild: /tmp/emit_hip_ir.sh (hipcc --cuda-device-only -emit-llvm -S). - -## Status -- [x] worktree on latest main (f3c8ff5d) -- [x] HIP source fully understood (gemm2_a4w4.cuh + mfma_f4f4 + epilogs + common) -- [x] HIP reference IR captured + censused -- [x] FlyDSL existing gemm2 IR captured — intrinsic parity confirmed -- [x] FlyDSL API mapped -- [x] kernels/gemm2_a4w4_port.py written — **COMPILES** end-to-end (COMPILE_ONLY) on gfx950 -- [x] IR dump + census vs HIP — core compute matches intrinsic-for-intrinsic -- [ ] close peripheral gap (rsrc 9→4, i32 loads 12→6): use plain global loads - for cumsum/eids/stids/sweights and a global atomic for out (HIP only makes - buffer rsrc for the 4 main tensors A_q/A_scale/B_q/B_scale). -- [ ] correctness vs HIP on gfx950 (cosine), benchmark - -## port v1 census (flydsl_port_v1.ll, 892 lines vs HIP 570) -MATCHED: mfma.scale .v4i32.v4i32 = 32 ✓ (NOT the .v8i32 padded variant the -existing FlyDSL kernel uses), buffer.load.lds = 2 ✓, buffer.load.v4i32 = 16 ✓, -s_waitcnt vmcnt fences = 2 ✓. -GAP: make.buffer.rsrc 9 vs 4, buffer.load.i32 12 vs 6 — because the port routes -cumsum/eids/sorted_token_ids/sorted_weights/out through buffer resources while -HIP uses plain addrspace(1) loads + global.atomic.fadd.v2bf16. Fix = plain -global loads for those + global atomic for the epilog. - -## port v2 census (flydsl_port_v2.ll, 956 lines vs HIP 570) — FULL INTRINSIC MATCH -| metric | HIP | port v2 | -|---|---|---| -| mfma.scale .v4i32.v4i32 | 32 | 32 ✓ | -| raw.ptr.buffer.load.lds | 2 | 2 ✓ | -| raw.ptr.buffer.load.v4i32 (B) | 16 | 16 ✓ | -| raw.ptr.buffer.load.i32 (scale) | 6 | 6 ✓ | -| make.buffer.rsrc | 4 | 4 ✓ | -| s_waitcnt vmcnt fences | 2 | 2 ✓ | -| atomicrmw fadd <2xbf16> | 16 | 16 ✓ | -| plain load i32 addrspace(1) | 6 | 6 ✓ | - -Every hardware intrinsic and memory-op class matches. (HIP's -`__builtin_amdgcn_global_atomic_fadd_v2bf16` lowers to `atomicrmw fadd <2xbf16>` -in this LLVM, same as the port — no named global.atomic intrinsic on either side.) - -RESIDUAL (the unavoidable cross-frontend delta): addrspace(3) refs 160 vs 126, -fence syncscope 6 vs 4, total lines 956 vs 570. Source = FlyDSL emits -`vector.load/store` on memref views for the LDS cshuffle, generating more -GEP/index scaffolding than clang's raw pointer arithmetic; optimizes to the same -ISA. Byte-identical .ll across clang vs MLIR is not achievable (stated up front). -Next refinement to shrink this: hand-build ptr<3> + llvm.load/store for the -epilog cshuffle (as done for ds_read) instead of SmemPtr.store/.load; and compare -final ISA (21_final_isa.s) which should be far closer than the .ll. - -## FINAL ISA comparison (the decisive "same machine code" check) — port v3 -Both compiled to gfx950 ISA (HIP: hipcc -S; FlyDSL: 21_final_isa.s). Every -compute and memory instruction matches exactly: -| ISA instruction | HIP | port | -|---|---|---| -| v_mfma_scale_f32_16x16x128_f8f6f4 | 32 | 32 ✓ | -| buffer_load_dwordx4 (16 B + 2 A→LDS) | 18 | 18 ✓ | -| buffer_load_dword (scales) | 6 | 6 ✓ | -| ds_read_b128 (A from LDS) | 8 | 8 ✓ | -| s_barrier | 4 | 4 ✓ | -| s_waitcnt vmcnt | 22 | 23 (1 extra) | -| total .s lines | 548 | 625 | - -The 77-line ISA delta is entirely scalar address arithmetic in the epilog -(per-element inttoptr address math + 1 extra s_waitcnt); zero difference in -MFMA / buffer-load / ds-read / barrier instructions. This is the strongest -"identical generated code" result achievable across the clang(HIP) and MLIR -(FlyDSL) frontends — both feed the same AMDGPU backend and emit the same -machine instructions for the compute core. - -## v3 changes (fence + raw-ptr epilog) -- K-loop barrier: bare `s_barrier` inline-asm (fence-free) → fence count 6→4 (=HIP). -- epilog cshuffle: raw ptr<3> + llvm.store/load (scalar) → `store float` 32 (=HIP). -- added pre-epilog fenced barrier (HIP run_one __syncthreads()). -Residual .ll delta (addrspace(3) 224 vs 126, lines 1083 vs 570) is LDS-address -scaffolding (inttoptr-per-op + no scalar-load vectorization that clang does); -it does NOT affect the ISA compute/memory instruction counts above. - -## CORRECTNESS (Task #6) — BIT-EXACT vs HIP -Same random inputs fed to both aiter HIP `mxfp4_moe_gemm2_a4w4` (kernelName -...BM32_ATOMIC) and the ported FlyDSL kernel; e8m0 scales pinned to 127 (2^0) -to avoid overflow, unique sorted_token_ids to avoid atomic-order nondeterminism. -Result (M=64, srt=64): finite 458752/458752 both, cosine=1.000000, -max_abs_diff=0, **bitexact=True — EXACT MATCH**. -Driver: /tmp/verify_gemm2.py + /tmp/run_verify.sh. - -## FINAL (v6) — diff minimized to irreducible cross-frontend artifacts -Iteration v1→v6 progressively closed the gap. v6 result: -- LLVM .ll: 866 lines (HIP 570). ALL intrinsics + memory ops match: - mfma.scale.v4i32 32, buffer.load.lds 2, buffer.load.v4i32 16, buffer.load.i32 6, - make.buffer.rsrc 4, fence 4, atomicrmw 16, **load <2xf32> 16, load float 4, - store float 32, addrspace(3) 124≈126**. -- ISA .s: 575 lines (HIP 548). EVERY compute/memory machine instruction identical: - v_mfma_scale ×32, buffer_load_dwordx4 ×18, buffer_load_dword ×6, ds_read_b128 ×8, - s_barrier ×4. -- Output: **bit-exact** (cosine 1.0, max_abs_diff 0). - -The ONLY remaining .ll differences are provably irreducible across clang↔MLIR: -1. SSA value names (%0,%1,...) — two frontends never name values identically. - This alone makes byte-identical text impossible, independent of any effort. -2. inttoptr ×9 (vs HIP 0) — FlyDSL models LDS (SmemAllocator) and kernel args as - memrefs; obtaining raw addrspace(1/3) pointers requires ptrtoint→inttoptr. - clang has native addrspace pointers / the @lds addrspace(3) global symbol. - A FlyDSL-model difference, not an algorithm difference. -3. Integer address-math is spelled with explicit arith ops in MLIR where clang - folds constants; these optimize to the same ISA (the 27-line ISA delta). - -Conclusion: literal byte-identical .ll is physically unattainable (point 1). -Achieved instead: identical LLVM intrinsics+memory-ops, identical ISA compute -instructions, and bit-exact output — the maximum attainable fidelity. - -## PERFORMANCE (gemm2 standalone, gfx950/MI355, /tmp/bench_gemm2.py) -| sorted rows | M-blocks | HIP us | port us | port/HIP | -|---|---|---|---|---| -| 256 | 8 | 18.7 | 27.2 | 1.46x | -| 1024 | 32 | 31.7 | 40.7 | 1.28x | -| 4096 | 128 | 79.3 | 83.0 | 1.05x | -| 8192 | 256 | 143.5 | 139.8 | 0.97x | - -GPU-saturating sizes (>=4096, 256 CU): within 5%, slightly FASTER at 8192 — -confirms near-identical ISA => near-identical perf. Small/latency-bound sizes: -1.3-1.5x slower, from per-block fixed overhead (the +27 ISA scalar-address lines, -9 inttoptr address setup, FlyDSL host launch path) being amplified when the grid -is small and compute is short. - -## opt -O3 comparison (fair, same passes) + the decisive impossibility proof -Fair comparison must opt both at the same level (FlyDSL's 20_llvm_ir.ll is -PRE-LLVM-opt; HIP's -emit-llvm is POST-O3). After `opt -O3` on both: -- FLY 866->690 lines; HIP 570->569. -- inttoptr 9->2 (opt eliminated 7); mfma 33, buffer.load.lds 3, buffer.load.v4i32 - 17, atomicrmw 16, fence 4, load <4xi32> 8, store float 32 — all still match. -- residual: ~120 extra lines, addrspace(3) 160 vs 126 (standalone opt -O3 lacks - the AMDGPU-target load-vectorizer that clang's full pipeline applied to HIP). - -DECISIVE: the two toolchains use DIFFERENT LLVM versions — FlyDSL bundles LLVM -rev 554785 (emits attrs like `nocreateundeforpoison`); HIP uses ROCm 7.2.3's -LLVM (its opt cannot even parse FlyDSL's IR). Different LLVM + different frontend -=> byte-identical .ll text is impossible in principle, independent of the kernel. -Maximal attainable fidelity (intrinsics + ISA compute instrs + bit-exact output) -is achieved and verified. - -## Unit test (tests/kernels/test_gemm2_a4w4_port.py) -4 tests, all PASS on gfx950/MI355: -- test_smoke (no aiter): compile+run, output finite & nonzero. -- test_accuracy_vs_hip[256,1024] (needs aiter): bit-exact vs HIP gemm2. -- test_performance[4096] (needs aiter): wall-clock ratio + loose regression bound. -Run: `python3 -m pytest tests/kernels/test_gemm2_a4w4_port.py -v -s` -(markers l2_device + rocm_lower; module-skips if not gfx95 / no CUDA). - -GOTCHA: `flyc.compile(launch, ..., out, ...)` EXECUTES the kernel once into the -buffer passed to it. Since gemm2 atomic-accumulates, compiling and then calling -into the SAME un-zeroed `out` doubles the result (looks like a 2x bug). Correct -pattern: compile against a throwaway buffer, then zero the real out and call once -(see `_compile_port`/`_run_port`). - -## Iterate loop helper -/tmp/iter_gemm2.sh → syncs kernel to remote, runs /tmp/run_compile_gemm2.sh -(COMPILE_ONLY=1 + FLYDSL_DUMP_IR), dumps to /tmp/gemm2_dump/. -Driver: /tmp/drive_gemm2.py. HIP ref rebuild: /tmp/emit_hip_ir.sh. - -## SMALL-M LATENCY OPTIMIZATION (post-port perf work) -The 1:1 port matched HIP structurally but was ~1.3× slower at tiny latency-bound -sizes (M≤32, kernels 4–6µs; crossover at M=64 where it already beat HIP). ATT -(rocprofv3 advanced_thread_trace + hotspot_analyzer) region breakdown showed the -**epilog = ~48% of small-M stalls** and the kernel is latency-bound (occupancy -LDS-bound at 5 waves/SIMD, identical to HIP). Two bit-exact latency-hiding -changes closed the gap: - -1. **Early A→LDS** — issue `raw.ptr.buffer.load.lds` before the cumsum-gated - early-return branch. The op is side-effecting so LLVM cannot sink it back - (pure resource-creation hoists ARE sunk by MachineSink — verified, inert); - this overlaps A→LDS HBM latency with the cumsum load + bound check. -2. **Epilog token/weight prefetch** — load `sorted_token_ids`/`sorted_weights` - (invariant, read-only) at epilog entry, before the cshuffle stores and both - LDS barriers, instead of in the dependent atomic loop. They depend only on - m_row/tid, so their global latency overlaps the store+barriers. **Main lever.** - -Result (interleaved same-process rocprofv3, port absolute median time): -M=4 5.92→4.96µs, M=16 6.36→5.32µs (~16% faster). port/HIP ratio: M=4 1.32→~1.0×, -M=16 1.30→~1.0×, M=32 1.27→~1.13× (M=32 is the awkward 252-wg/256-CU occupancy -point), M=64 0.96×, M=256 0.91→0.86×. Output still **bit-exact**; 4/4 pytest pass. - -Tried and reverted (no benefit): merging the 2 K-loop barriers (unsafe — HIP -comments them "correctness fence, not a perf knob" — and perf-neutral since the -kernel is memory-latency bound, not barrier-bound). - -**Measurement note:** per-process rocprofv3 at 4–6µs is dominated by GPU-clock -state (±10%); use an interleaved same-process driver (`port(); hip()` in one loop -under one trace) and track the port's absolute median as the stable signal. diff --git a/kernels/gemm2_port_ref/flydsl_gemm2_existing.ll b/kernels/gemm2_port_ref/flydsl_gemm2_existing.ll deleted file mode 100644 index 8059c4f44..000000000 --- a/kernels/gemm2_port_ref/flydsl_gemm2_existing.ll +++ /dev/null @@ -1,1256 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" -target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" - -@smem0 = external addrspace(3) global [32896 x i8], align 1024 -@smem1 = external addrspace(3) global [4096 x i8], align 1024 - -define amdgpu_kernel void @mfma_moe2_afp4_wfp4_bf16_cshuffle_t32x256x256_vscale_fix3_persist_cu256(ptr addrspace(1) noalias %0, ptr addrspace(1) noalias %1, ptr addrspace(1) noalias %2, ptr addrspace(1) noalias %3, ptr addrspace(1) noalias %4, ptr addrspace(1) noalias %5, ptr addrspace(1) noalias %6, ptr addrspace(1) noalias %7, ptr addrspace(1) noalias %8, ptr addrspace(1) noalias %9, i32 %10, i32 %11, i32 %12, i32 %13) #0 { - %15 = sext i32 %10 to i64 - %16 = sext i32 %12 to i64 - %17 = sext i32 %13 to i64 - %18 = call i32 @llvm.amdgcn.workitem.id.x() - %19 = sext i32 %18 to i64 - %20 = call i32 @llvm.amdgcn.workgroup.id.x() - %21 = sext i32 %20 to i64 - %22 = call i32 @llvm.amdgcn.workgroup.id.y() - %23 = sext i32 %22 to i64 - %24 = mul i64 %15, 9 - %25 = mul i64 %24, %16 - %26 = lshr i64 %25, 1 - %27 = trunc i64 %26 to i32 - %28 = ptrtoint ptr addrspace(1) %1 to i64 - %29 = inttoptr i64 %28 to ptr - %30 = sext i32 %27 to i64 - %31 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %29, i16 0, i64 %30, i32 159744) - %32 = ptrtoint ptr addrspace(1) %2 to i64 - %33 = inttoptr i64 %32 to ptr - %34 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %33, i16 0, i64 706478080, i32 159744) - %35 = ptrtoint ptr addrspace(1) %8 to i64 - %36 = inttoptr i64 %35 to ptr - %37 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %36, i16 0, i64 4, i32 159744) - %38 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %37, i32 0, i32 0, i32 0) - %39 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %38) - %40 = sext i32 %39 to i64 - %41 = lshr i64 %16, 5 - %42 = mul i64 %40, %41 - %43 = trunc i64 %42 to i32 - %44 = ptrtoint ptr addrspace(1) %3 to i64 - %45 = inttoptr i64 %44 to ptr - %46 = sext i32 %43 to i64 - %47 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %45, i16 0, i64 %46, i32 159744) - %48 = mul i64 %41, 2759680 - %49 = trunc i64 %48 to i32 - %50 = ptrtoint ptr addrspace(1) %4 to i64 - %51 = inttoptr i64 %50 to ptr - %52 = sext i32 %49 to i64 - %53 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %51, i16 0, i64 %52, i32 159744) - %54 = mul i64 %17, 32 - %55 = mul i64 %17, 128 - %56 = trunc i64 %55 to i32 - %57 = ptrtoint ptr addrspace(1) %5 to i64 - %58 = inttoptr i64 %57 to ptr - %59 = sext i32 %56 to i64 - %60 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %58, i16 0, i64 %59, i32 159744) - %61 = ptrtoint ptr addrspace(1) %7 to i64 - %62 = inttoptr i64 %61 to ptr - %63 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %62, i16 0, i64 %59, i32 159744) - %64 = add i64 %54, 31 - %65 = lshr i64 %64, 5 - %66 = mul i64 %65, 4 - %67 = trunc i64 %66 to i32 - %68 = ptrtoint ptr addrspace(1) %6 to i64 - %69 = inttoptr i64 %68 to ptr - %70 = sext i32 %67 to i64 - %71 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %69, i16 0, i64 %70, i32 159744) - %72 = add i64 %40, 31 - %73 = udiv i64 %72, 32 - %74 = add i64 %73, 255 - %75 = udiv i64 %74, 256 - br label %76 - -76: ; preds = %1118, %14 - %77 = phi i64 [ %1119, %1118 ], [ 0, %14 ] - %78 = phi i1 [ %97, %1118 ], [ true, %14 ] - %79 = icmp slt i64 %77, %75 - br i1 %79, label %80, label %1120 - -80: ; preds = %76 - %81 = mul i64 %23, %75 - %82 = add i64 %81, %77 - %83 = mul i64 %82, 32 - %84 = trunc i64 %83 to i32 - %85 = icmp ult i32 %84, %39 - %86 = lshr i64 %83, 5 - %87 = trunc i64 %86 to i32 - %88 = mul i32 %87, 4 - %89 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %71, i32 %88, i32 0, i32 0) - %90 = sext i32 %89 to i64 - %91 = icmp ult i32 %89, 385 - %92 = mul i64 %90, 1835008 - %93 = mul i32 %84, 4 - %94 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %60, i32 %93, i32 0, i32 0) - %95 = and i32 %94, 16777215 - %96 = icmp ult i32 %95, %10 - %97 = and i1 %78, %85 - %98 = and i1 %91, %96 - %99 = and i1 %97, %98 - br i1 %99, label %100, label %1118 - -100: ; preds = %80 - %101 = mul i64 %90, 7168 - %102 = lshr i64 %16, 1 - %103 = lshr i64 %102, 2 - %104 = mul i64 %19, 4 - %105 = trunc i64 %104 to i32 - %106 = sdiv i32 %105, 32 - %107 = srem i32 %106, 32 - %108 = srem i32 %105, 32 - %109 = sext i32 %107 to i64 - %110 = sext i32 %108 to i64 - %111 = add i64 %83, %109 - %112 = trunc i64 %111 to i32 - %113 = mul i32 %112, 4 - %114 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %60, i32 %113, i32 0, i32 0) - %115 = and i32 %114, 16777215 - %116 = lshr i32 %114, 24 - %117 = mul i32 %115, 9 - %118 = add i32 %117, %116 - %119 = sext i32 %118 to i64 - %120 = mul i64 %119, %103 - %121 = lshr i64 %19, 6 - %122 = and i64 %121, 3 - %123 = and i64 %19, 63 - %124 = lshr i64 %123, 4 - %125 = and i64 %124, 3 - %126 = and i64 %123, 15 - %127 = mul i64 %125, 16 - %128 = mul i64 %122, 64 - %129 = mul i64 %21, 256 - %130 = add i64 %129, %128 - %131 = add i64 %130, %126 - %132 = lshr i64 %131, 4 - %133 = and i64 %131, 15 - %134 = add i64 %130, 16 - %135 = add i64 %134, %126 - %136 = lshr i64 %135, 4 - %137 = and i64 %135, 15 - %138 = add i64 %130, 32 - %139 = add i64 %138, %126 - %140 = lshr i64 %139, 4 - %141 = and i64 %139, 15 - %142 = add i64 %130, 48 - %143 = add i64 %142, %126 - %144 = lshr i64 %143, 4 - %145 = and i64 %143, 15 - call void @llvm.amdgcn.sched.barrier(i32 0) - %146 = icmp ult i64 %19, 32 - br i1 %146, label %147, label %154 - -147: ; preds = %100 - %148 = add i64 %83, %19 - %149 = trunc i64 %148 to i32 - %150 = mul i32 %149, 4 - %151 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %60, i32 %150, i32 0, i32 0) - %152 = insertelement <1 x i32> poison, i32 %151, i32 0 - %153 = getelementptr i32, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @smem0, i32 32768), i64 %19 - store <1 x i32> %152, ptr addrspace(3) %153, align 4 - br label %154 - -154: ; preds = %147, %100 - %155 = mul i64 %132, 4096 - %156 = add i64 %92, %155 - %157 = mul i64 %125, 256 - %158 = add i64 %156, %157 - %159 = mul i64 %133, 16 - %160 = add i64 %158, %159 - %161 = lshr i64 %160, 2 - %162 = trunc i64 %161 to i32 - %163 = mul i32 %162, 4 - %164 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %163, i32 0, i32 2) - %165 = bitcast <4 x i32> %164 to <2 x i64> - %166 = extractelement <2 x i64> %165, i64 0 - %167 = extractelement <2 x i64> %165, i64 1 - %168 = mul i64 %136, 4096 - %169 = add i64 %92, %168 - %170 = add i64 %169, %157 - %171 = mul i64 %137, 16 - %172 = add i64 %170, %171 - %173 = lshr i64 %172, 2 - %174 = trunc i64 %173 to i32 - %175 = mul i32 %174, 4 - %176 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %175, i32 0, i32 2) - %177 = bitcast <4 x i32> %176 to <2 x i64> - %178 = extractelement <2 x i64> %177, i64 0 - %179 = extractelement <2 x i64> %177, i64 1 - %180 = mul i64 %140, 4096 - %181 = add i64 %92, %180 - %182 = add i64 %181, %157 - %183 = mul i64 %141, 16 - %184 = add i64 %182, %183 - %185 = lshr i64 %184, 2 - %186 = trunc i64 %185 to i32 - %187 = mul i32 %186, 4 - %188 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %187, i32 0, i32 2) - %189 = bitcast <4 x i32> %188 to <2 x i64> - %190 = extractelement <2 x i64> %189, i64 0 - %191 = extractelement <2 x i64> %189, i64 1 - %192 = mul i64 %144, 4096 - %193 = add i64 %92, %192 - %194 = add i64 %193, %157 - %195 = mul i64 %145, 16 - %196 = add i64 %194, %195 - %197 = lshr i64 %196, 2 - %198 = trunc i64 %197 to i32 - %199 = mul i32 %198, 4 - %200 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %199, i32 0, i32 2) - %201 = bitcast <4 x i32> %200 to <2 x i64> - %202 = extractelement <2 x i64> %201, i64 0 - %203 = extractelement <2 x i64> %201, i64 1 - %204 = lshr i64 %83, 1 - %205 = lshr i64 %204, 4 - %206 = mul i64 %205, 128 - %207 = add i64 %206, %127 - %208 = add i64 %207, %126 - %209 = trunc i64 %208 to i32 - %210 = mul i32 %209, 4 - %211 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %47, i32 %210, i32 0, i32 0) - %212 = add i64 %101, %129 - %213 = add i64 %212, %128 - %214 = lshr i64 %213, 1 - %215 = lshr i64 %214, 4 - %216 = mul i64 %215, 128 - %217 = add i64 %216, %127 - %218 = add i64 %217, %126 - %219 = trunc i64 %218 to i32 - %220 = mul i32 %219, 4 - %221 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %53, i32 %220, i32 0, i32 0) - %222 = add i64 %215, 1 - %223 = mul i64 %222, 128 - %224 = add i64 %223, %127 - %225 = add i64 %224, %126 - %226 = trunc i64 %225 to i32 - %227 = mul i32 %226, 4 - %228 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %53, i32 %227, i32 0, i32 0) - call void @llvm.amdgcn.sched.barrier(i32 0) - %229 = mul i64 %110, 4 - %230 = and i64 %109, 7 - %231 = mul i64 %230, 16 - %232 = xor i64 %229, %231 - %233 = mul i64 %120, 4 - %234 = add i64 %233, %232 - %235 = trunc i64 %234 to i32 - %236 = mul i64 %122, 1024 - %237 = add i64 ptrtoint (ptr addrspace(3) @smem0 to i64), %236 - %238 = call i64 @llvm.amdgcn.readfirstlane.i64(i64 %237) - %239 = inttoptr i64 %238 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %31, ptr addrspace(3) %239, i32 16, i32 %235, i32 0, i32 0, i32 0) - call void @llvm.amdgcn.s.waitcnt(i32 0) - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %240 = and i64 %126, 7 - %241 = mul i64 %240, 16 - %242 = xor i64 %127, %241 - %243 = mul i64 %126, 128 - %244 = add i64 %243, %242 - %245 = getelementptr i8, ptr addrspace(3) @smem0, i64 %244 - %246 = load <16 x i8>, ptr addrspace(3) %245, align 1 - %247 = bitcast <16 x i8> %246 to <2 x i64> - %248 = extractelement <2 x i64> %247, i64 0 - %249 = extractelement <2 x i64> %247, i64 1 - %250 = add i64 %127, 64 - %251 = xor i64 %250, %241 - %252 = add i64 %243, %251 - %253 = getelementptr i8, ptr addrspace(3) @smem0, i64 %252 - %254 = load <16 x i8>, ptr addrspace(3) %253, align 1 - %255 = bitcast <16 x i8> %254 to <2 x i64> - %256 = extractelement <2 x i64> %255, i64 0 - %257 = extractelement <2 x i64> %255, i64 1 - %258 = add i64 %16, 255 - %259 = udiv i64 %258, 256 - %260 = mul i64 %259, 256 - %261 = sub i64 %260, 256 - %262 = udiv i64 %261, 2 - %263 = lshr i64 %261, 1 - %264 = lshr i64 %263, 2 - %265 = add i64 %120, %264 - %266 = mul i64 %265, 4 - %267 = add i64 %266, %232 - %268 = trunc i64 %267 to i32 - %269 = add i64 ptrtoint (ptr addrspace(3) @smem1 to i64), %236 - %270 = call i64 @llvm.amdgcn.readfirstlane.i64(i64 %269) - %271 = inttoptr i64 %270 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %31, ptr addrspace(3) %271, i32 16, i32 %268, i32 0, i32 0, i32 0) - %272 = lshr i64 %262, 6 - %273 = mul i64 %272, 1024 - %274 = add i64 %156, %273 - %275 = add i64 %274, %157 - %276 = add i64 %275, %159 - %277 = lshr i64 %276, 2 - %278 = trunc i64 %277 to i32 - %279 = mul i32 %278, 4 - %280 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %279, i32 0, i32 2) - %281 = bitcast <4 x i32> %280 to <2 x i64> - %282 = extractelement <2 x i64> %281, i64 0 - %283 = extractelement <2 x i64> %281, i64 1 - %284 = add i64 %169, %273 - %285 = add i64 %284, %157 - %286 = add i64 %285, %171 - %287 = lshr i64 %286, 2 - %288 = trunc i64 %287 to i32 - %289 = mul i32 %288, 4 - %290 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %289, i32 0, i32 2) - %291 = bitcast <4 x i32> %290 to <2 x i64> - %292 = extractelement <2 x i64> %291, i64 0 - %293 = extractelement <2 x i64> %291, i64 1 - %294 = add i64 %181, %273 - %295 = add i64 %294, %157 - %296 = add i64 %295, %183 - %297 = lshr i64 %296, 2 - %298 = trunc i64 %297 to i32 - %299 = mul i32 %298, 4 - %300 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %299, i32 0, i32 2) - %301 = bitcast <4 x i32> %300 to <2 x i64> - %302 = extractelement <2 x i64> %301, i64 0 - %303 = extractelement <2 x i64> %301, i64 1 - %304 = add i64 %193, %273 - %305 = add i64 %304, %157 - %306 = add i64 %305, %195 - %307 = lshr i64 %306, 2 - %308 = trunc i64 %307 to i32 - %309 = mul i32 %308, 4 - %310 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %309, i32 0, i32 2) - %311 = bitcast <4 x i32> %310 to <2 x i64> - %312 = extractelement <2 x i64> %311, i64 0 - %313 = extractelement <2 x i64> %311, i64 1 - %314 = add i64 %206, 64 - %315 = add i64 %314, %127 - %316 = add i64 %315, %126 - %317 = trunc i64 %316 to i32 - %318 = mul i32 %317, 4 - %319 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %47, i32 %318, i32 0, i32 0) - %320 = add i64 %216, 64 - %321 = add i64 %320, %127 - %322 = add i64 %321, %126 - %323 = trunc i64 %322 to i32 - %324 = mul i32 %323, 4 - %325 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %53, i32 %324, i32 0, i32 0) - %326 = add i64 %223, 64 - %327 = add i64 %326, %127 - %328 = add i64 %327, %126 - %329 = trunc i64 %328 to i32 - %330 = mul i32 %329, 4 - %331 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %53, i32 %330, i32 0, i32 0) - %332 = add i64 %156, 1024 - %333 = add i64 %332, %157 - %334 = add i64 %333, %159 - %335 = lshr i64 %334, 2 - %336 = trunc i64 %335 to i32 - %337 = mul i32 %336, 4 - %338 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %337, i32 0, i32 2) - %339 = bitcast <4 x i32> %338 to <2 x i64> - %340 = extractelement <2 x i64> %339, i64 0 - %341 = extractelement <2 x i64> %339, i64 1 - %342 = add i64 %169, 1024 - %343 = add i64 %342, %157 - %344 = add i64 %343, %171 - %345 = lshr i64 %344, 2 - %346 = trunc i64 %345 to i32 - %347 = mul i32 %346, 4 - %348 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %347, i32 0, i32 2) - %349 = bitcast <4 x i32> %348 to <2 x i64> - %350 = extractelement <2 x i64> %349, i64 0 - %351 = extractelement <2 x i64> %349, i64 1 - %352 = add i64 %181, 1024 - %353 = add i64 %352, %157 - %354 = add i64 %353, %183 - %355 = lshr i64 %354, 2 - %356 = trunc i64 %355 to i32 - %357 = mul i32 %356, 4 - %358 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %357, i32 0, i32 2) - %359 = bitcast <4 x i32> %358 to <2 x i64> - %360 = extractelement <2 x i64> %359, i64 0 - %361 = extractelement <2 x i64> %359, i64 1 - %362 = add i64 %193, 1024 - %363 = add i64 %362, %157 - %364 = add i64 %363, %195 - %365 = lshr i64 %364, 2 - %366 = trunc i64 %365 to i32 - %367 = mul i32 %366, 4 - %368 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %367, i32 0, i32 2) - %369 = bitcast <4 x i32> %368 to <2 x i64> - %370 = extractelement <2 x i64> %369, i64 0 - %371 = extractelement <2 x i64> %369, i64 1 - %372 = insertelement <4 x i64> poison, i64 %248, i64 0 - %373 = insertelement <4 x i64> %372, i64 %249, i64 1 - %374 = insertelement <4 x i64> %373, i64 0, i64 2 - %375 = insertelement <4 x i64> %374, i64 0, i64 3 - %376 = bitcast <4 x i64> %375 to <8 x i32> - %377 = insertelement <4 x i64> poison, i64 %166, i64 0 - %378 = insertelement <4 x i64> %377, i64 %167, i64 1 - %379 = insertelement <4 x i64> %378, i64 0, i64 2 - %380 = insertelement <4 x i64> %379, i64 0, i64 3 - %381 = bitcast <4 x i64> %380 to <8 x i32> - %382 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %376, <8 x i32> %381, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %211, i32 0, i32 %221) - %383 = insertelement <4 x i64> poison, i64 %178, i64 0 - %384 = insertelement <4 x i64> %383, i64 %179, i64 1 - %385 = insertelement <4 x i64> %384, i64 0, i64 2 - %386 = insertelement <4 x i64> %385, i64 0, i64 3 - %387 = bitcast <4 x i64> %386 to <8 x i32> - %388 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %376, <8 x i32> %387, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %211, i32 1, i32 %221) - %389 = add i64 %126, 16 - %390 = and i64 %389, 7 - %391 = mul i64 %390, 16 - %392 = xor i64 %127, %391 - %393 = mul i64 %389, 128 - %394 = add i64 %393, %392 - %395 = getelementptr i8, ptr addrspace(3) @smem0, i64 %394 - %396 = load <16 x i8>, ptr addrspace(3) %395, align 1 - %397 = bitcast <16 x i8> %396 to <2 x i64> - %398 = extractelement <2 x i64> %397, i64 0 - %399 = extractelement <2 x i64> %397, i64 1 - %400 = insertelement <4 x i64> poison, i64 %398, i64 0 - %401 = insertelement <4 x i64> %400, i64 %399, i64 1 - %402 = insertelement <4 x i64> %401, i64 0, i64 2 - %403 = insertelement <4 x i64> %402, i64 0, i64 3 - %404 = bitcast <4 x i64> %403 to <8 x i32> - %405 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %404, <8 x i32> %381, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %211, i32 0, i32 %221) - %406 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %404, <8 x i32> %387, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %211, i32 1, i32 %221) - %407 = insertelement <4 x i64> poison, i64 %190, i64 0 - %408 = insertelement <4 x i64> %407, i64 %191, i64 1 - %409 = insertelement <4 x i64> %408, i64 0, i64 2 - %410 = insertelement <4 x i64> %409, i64 0, i64 3 - %411 = bitcast <4 x i64> %410 to <8 x i32> - %412 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %376, <8 x i32> %411, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %211, i32 0, i32 %228) - %413 = insertelement <4 x i64> poison, i64 %202, i64 0 - %414 = insertelement <4 x i64> %413, i64 %203, i64 1 - %415 = insertelement <4 x i64> %414, i64 0, i64 2 - %416 = insertelement <4 x i64> %415, i64 0, i64 3 - %417 = bitcast <4 x i64> %416 to <8 x i32> - %418 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %376, <8 x i32> %417, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %211, i32 1, i32 %228) - %419 = getelementptr i8, ptr addrspace(3) @smem0, i64 %394 - %420 = load <16 x i8>, ptr addrspace(3) %419, align 1 - %421 = bitcast <16 x i8> %420 to <2 x i64> - %422 = extractelement <2 x i64> %421, i64 0 - %423 = extractelement <2 x i64> %421, i64 1 - %424 = insertelement <4 x i64> poison, i64 %422, i64 0 - %425 = insertelement <4 x i64> %424, i64 %423, i64 1 - %426 = insertelement <4 x i64> %425, i64 0, i64 2 - %427 = insertelement <4 x i64> %426, i64 0, i64 3 - %428 = bitcast <4 x i64> %427 to <8 x i32> - %429 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %428, <8 x i32> %411, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %211, i32 0, i32 %228) - %430 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %428, <8 x i32> %417, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %211, i32 1, i32 %228) - %431 = insertelement <4 x i64> poison, i64 %256, i64 0 - %432 = insertelement <4 x i64> %431, i64 %257, i64 1 - %433 = insertelement <4 x i64> %432, i64 0, i64 2 - %434 = insertelement <4 x i64> %433, i64 0, i64 3 - %435 = bitcast <4 x i64> %434 to <8 x i32> - %436 = insertelement <4 x i64> poison, i64 %340, i64 0 - %437 = insertelement <4 x i64> %436, i64 %341, i64 1 - %438 = insertelement <4 x i64> %437, i64 0, i64 2 - %439 = insertelement <4 x i64> %438, i64 0, i64 3 - %440 = bitcast <4 x i64> %439 to <8 x i32> - %441 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %435, <8 x i32> %440, <4 x float> %382, i32 4, i32 4, i32 2, i32 %211, i32 2, i32 %221) - %442 = insertelement <4 x i64> poison, i64 %350, i64 0 - %443 = insertelement <4 x i64> %442, i64 %351, i64 1 - %444 = insertelement <4 x i64> %443, i64 0, i64 2 - %445 = insertelement <4 x i64> %444, i64 0, i64 3 - %446 = bitcast <4 x i64> %445 to <8 x i32> - %447 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %435, <8 x i32> %446, <4 x float> %388, i32 4, i32 4, i32 2, i32 %211, i32 3, i32 %221) - %448 = xor i64 %250, %391 - %449 = add i64 %393, %448 - %450 = getelementptr i8, ptr addrspace(3) @smem0, i64 %449 - %451 = load <16 x i8>, ptr addrspace(3) %450, align 1 - %452 = bitcast <16 x i8> %451 to <2 x i64> - %453 = extractelement <2 x i64> %452, i64 0 - %454 = extractelement <2 x i64> %452, i64 1 - %455 = insertelement <4 x i64> poison, i64 %453, i64 0 - %456 = insertelement <4 x i64> %455, i64 %454, i64 1 - %457 = insertelement <4 x i64> %456, i64 0, i64 2 - %458 = insertelement <4 x i64> %457, i64 0, i64 3 - %459 = bitcast <4 x i64> %458 to <8 x i32> - %460 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %459, <8 x i32> %440, <4 x float> %405, i32 4, i32 4, i32 3, i32 %211, i32 2, i32 %221) - %461 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %459, <8 x i32> %446, <4 x float> %406, i32 4, i32 4, i32 3, i32 %211, i32 3, i32 %221) - %462 = insertelement <4 x i64> poison, i64 %360, i64 0 - %463 = insertelement <4 x i64> %462, i64 %361, i64 1 - %464 = insertelement <4 x i64> %463, i64 0, i64 2 - %465 = insertelement <4 x i64> %464, i64 0, i64 3 - %466 = bitcast <4 x i64> %465 to <8 x i32> - %467 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %435, <8 x i32> %466, <4 x float> %412, i32 4, i32 4, i32 2, i32 %211, i32 2, i32 %228) - %468 = insertelement <4 x i64> poison, i64 %370, i64 0 - %469 = insertelement <4 x i64> %468, i64 %371, i64 1 - %470 = insertelement <4 x i64> %469, i64 0, i64 2 - %471 = insertelement <4 x i64> %470, i64 0, i64 3 - %472 = bitcast <4 x i64> %471 to <8 x i32> - %473 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %435, <8 x i32> %472, <4 x float> %418, i32 4, i32 4, i32 2, i32 %211, i32 3, i32 %228) - %474 = getelementptr i8, ptr addrspace(3) @smem0, i64 %449 - %475 = load <16 x i8>, ptr addrspace(3) %474, align 1 - %476 = bitcast <16 x i8> %475 to <2 x i64> - %477 = extractelement <2 x i64> %476, i64 0 - %478 = extractelement <2 x i64> %476, i64 1 - %479 = insertelement <4 x i64> poison, i64 %477, i64 0 - %480 = insertelement <4 x i64> %479, i64 %478, i64 1 - %481 = insertelement <4 x i64> %480, i64 0, i64 2 - %482 = insertelement <4 x i64> %481, i64 0, i64 3 - %483 = bitcast <4 x i64> %482 to <8 x i32> - %484 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %483, <8 x i32> %466, <4 x float> %429, i32 4, i32 4, i32 3, i32 %211, i32 2, i32 %228) - %485 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %483, <8 x i32> %472, <4 x float> %430, i32 4, i32 4, i32 3, i32 %211, i32 3, i32 %228) - call void @llvm.amdgcn.s.waitcnt(i32 0) - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %486 = getelementptr i8, ptr addrspace(3) @smem1, i64 %244 - %487 = load <16 x i8>, ptr addrspace(3) %486, align 1 - %488 = bitcast <16 x i8> %487 to <2 x i64> - %489 = extractelement <2 x i64> %488, i64 0 - %490 = extractelement <2 x i64> %488, i64 1 - %491 = getelementptr i8, ptr addrspace(3) @smem1, i64 %252 - %492 = load <16 x i8>, ptr addrspace(3) %491, align 1 - %493 = bitcast <16 x i8> %492 to <2 x i64> - %494 = extractelement <2 x i64> %493, i64 0 - %495 = extractelement <2 x i64> %493, i64 1 - %496 = mul i64 %125, 4 - %497 = add i64 %83, %496 - %498 = trunc i64 %497 to i32 - %499 = mul i32 %498, 4 - %500 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %499, i32 0, i32 0) - %501 = add i64 %496, 1 - %502 = add i64 %83, %501 - %503 = trunc i64 %502 to i32 - %504 = mul i32 %503, 4 - %505 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %504, i32 0, i32 0) - %506 = add i64 %496, 2 - %507 = add i64 %83, %506 - %508 = trunc i64 %507 to i32 - %509 = mul i32 %508, 4 - %510 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %509, i32 0, i32 0) - %511 = add i64 %496, 3 - %512 = add i64 %83, %511 - %513 = trunc i64 %512 to i32 - %514 = mul i32 %513, 4 - %515 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %514, i32 0, i32 0) - %516 = add i64 %496, 16 - %517 = add i64 %83, %516 - %518 = trunc i64 %517 to i32 - %519 = mul i32 %518, 4 - %520 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %519, i32 0, i32 0) - %521 = add i64 %496, 17 - %522 = add i64 %83, %521 - %523 = trunc i64 %522 to i32 - %524 = mul i32 %523, 4 - %525 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %524, i32 0, i32 0) - %526 = add i64 %496, 18 - %527 = add i64 %83, %526 - %528 = trunc i64 %527 to i32 - %529 = mul i32 %528, 4 - %530 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %529, i32 0, i32 0) - %531 = add i64 %496, 19 - %532 = add i64 %83, %531 - %533 = trunc i64 %532 to i32 - %534 = mul i32 %533, 4 - %535 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %63, i32 %534, i32 0, i32 0) - %536 = add i64 %272, 1 - %537 = mul i64 %536, 1024 - %538 = add i64 %156, %537 - %539 = add i64 %538, %157 - %540 = add i64 %539, %159 - %541 = lshr i64 %540, 2 - %542 = trunc i64 %541 to i32 - %543 = mul i32 %542, 4 - %544 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %543, i32 0, i32 2) - %545 = bitcast <4 x i32> %544 to <2 x i64> - %546 = extractelement <2 x i64> %545, i64 0 - %547 = extractelement <2 x i64> %545, i64 1 - %548 = add i64 %169, %537 - %549 = add i64 %548, %157 - %550 = add i64 %549, %171 - %551 = lshr i64 %550, 2 - %552 = trunc i64 %551 to i32 - %553 = mul i32 %552, 4 - %554 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %553, i32 0, i32 2) - %555 = bitcast <4 x i32> %554 to <2 x i64> - %556 = extractelement <2 x i64> %555, i64 0 - %557 = extractelement <2 x i64> %555, i64 1 - %558 = add i64 %181, %537 - %559 = add i64 %558, %157 - %560 = add i64 %559, %183 - %561 = lshr i64 %560, 2 - %562 = trunc i64 %561 to i32 - %563 = mul i32 %562, 4 - %564 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %563, i32 0, i32 2) - %565 = bitcast <4 x i32> %564 to <2 x i64> - %566 = extractelement <2 x i64> %565, i64 0 - %567 = extractelement <2 x i64> %565, i64 1 - %568 = add i64 %193, %537 - %569 = add i64 %568, %157 - %570 = add i64 %569, %195 - %571 = lshr i64 %570, 2 - %572 = trunc i64 %571 to i32 - %573 = mul i32 %572, 4 - %574 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %34, i32 %573, i32 0, i32 2) - %575 = bitcast <4 x i32> %574 to <2 x i64> - %576 = extractelement <2 x i64> %575, i64 0 - %577 = extractelement <2 x i64> %575, i64 1 - %578 = insertelement <4 x i64> poison, i64 %489, i64 0 - %579 = insertelement <4 x i64> %578, i64 %490, i64 1 - %580 = insertelement <4 x i64> %579, i64 0, i64 2 - %581 = insertelement <4 x i64> %580, i64 0, i64 3 - %582 = bitcast <4 x i64> %581 to <8 x i32> - %583 = insertelement <4 x i64> poison, i64 %282, i64 0 - %584 = insertelement <4 x i64> %583, i64 %283, i64 1 - %585 = insertelement <4 x i64> %584, i64 0, i64 2 - %586 = insertelement <4 x i64> %585, i64 0, i64 3 - %587 = bitcast <4 x i64> %586 to <8 x i32> - %588 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %582, <8 x i32> %587, <4 x float> %441, i32 4, i32 4, i32 0, i32 %319, i32 0, i32 %325) - %589 = insertelement <4 x i64> poison, i64 %292, i64 0 - %590 = insertelement <4 x i64> %589, i64 %293, i64 1 - %591 = insertelement <4 x i64> %590, i64 0, i64 2 - %592 = insertelement <4 x i64> %591, i64 0, i64 3 - %593 = bitcast <4 x i64> %592 to <8 x i32> - %594 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %582, <8 x i32> %593, <4 x float> %447, i32 4, i32 4, i32 0, i32 %319, i32 1, i32 %325) - %595 = getelementptr i8, ptr addrspace(3) @smem1, i64 %394 - %596 = load <16 x i8>, ptr addrspace(3) %595, align 1 - %597 = bitcast <16 x i8> %596 to <2 x i64> - %598 = extractelement <2 x i64> %597, i64 0 - %599 = extractelement <2 x i64> %597, i64 1 - %600 = insertelement <4 x i64> poison, i64 %598, i64 0 - %601 = insertelement <4 x i64> %600, i64 %599, i64 1 - %602 = insertelement <4 x i64> %601, i64 0, i64 2 - %603 = insertelement <4 x i64> %602, i64 0, i64 3 - %604 = bitcast <4 x i64> %603 to <8 x i32> - %605 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %604, <8 x i32> %587, <4 x float> %460, i32 4, i32 4, i32 1, i32 %319, i32 0, i32 %325) - %606 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %604, <8 x i32> %593, <4 x float> %461, i32 4, i32 4, i32 1, i32 %319, i32 1, i32 %325) - %607 = insertelement <4 x i64> poison, i64 %302, i64 0 - %608 = insertelement <4 x i64> %607, i64 %303, i64 1 - %609 = insertelement <4 x i64> %608, i64 0, i64 2 - %610 = insertelement <4 x i64> %609, i64 0, i64 3 - %611 = bitcast <4 x i64> %610 to <8 x i32> - %612 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %582, <8 x i32> %611, <4 x float> %467, i32 4, i32 4, i32 0, i32 %319, i32 0, i32 %331) - %613 = insertelement <4 x i64> poison, i64 %312, i64 0 - %614 = insertelement <4 x i64> %613, i64 %313, i64 1 - %615 = insertelement <4 x i64> %614, i64 0, i64 2 - %616 = insertelement <4 x i64> %615, i64 0, i64 3 - %617 = bitcast <4 x i64> %616 to <8 x i32> - %618 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %582, <8 x i32> %617, <4 x float> %473, i32 4, i32 4, i32 0, i32 %319, i32 1, i32 %331) - %619 = getelementptr i8, ptr addrspace(3) @smem1, i64 %394 - %620 = load <16 x i8>, ptr addrspace(3) %619, align 1 - %621 = bitcast <16 x i8> %620 to <2 x i64> - %622 = extractelement <2 x i64> %621, i64 0 - %623 = extractelement <2 x i64> %621, i64 1 - %624 = insertelement <4 x i64> poison, i64 %622, i64 0 - %625 = insertelement <4 x i64> %624, i64 %623, i64 1 - %626 = insertelement <4 x i64> %625, i64 0, i64 2 - %627 = insertelement <4 x i64> %626, i64 0, i64 3 - %628 = bitcast <4 x i64> %627 to <8 x i32> - %629 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %628, <8 x i32> %611, <4 x float> %484, i32 4, i32 4, i32 1, i32 %319, i32 0, i32 %331) - %630 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %628, <8 x i32> %617, <4 x float> %485, i32 4, i32 4, i32 1, i32 %319, i32 1, i32 %331) - %631 = insertelement <4 x i64> poison, i64 %494, i64 0 - %632 = insertelement <4 x i64> %631, i64 %495, i64 1 - %633 = insertelement <4 x i64> %632, i64 0, i64 2 - %634 = insertelement <4 x i64> %633, i64 0, i64 3 - %635 = bitcast <4 x i64> %634 to <8 x i32> - %636 = insertelement <4 x i64> poison, i64 %546, i64 0 - %637 = insertelement <4 x i64> %636, i64 %547, i64 1 - %638 = insertelement <4 x i64> %637, i64 0, i64 2 - %639 = insertelement <4 x i64> %638, i64 0, i64 3 - %640 = bitcast <4 x i64> %639 to <8 x i32> - %641 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %635, <8 x i32> %640, <4 x float> %588, i32 4, i32 4, i32 2, i32 %319, i32 2, i32 %325) - %642 = insertelement <4 x i64> poison, i64 %556, i64 0 - %643 = insertelement <4 x i64> %642, i64 %557, i64 1 - %644 = insertelement <4 x i64> %643, i64 0, i64 2 - %645 = insertelement <4 x i64> %644, i64 0, i64 3 - %646 = bitcast <4 x i64> %645 to <8 x i32> - %647 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %635, <8 x i32> %646, <4 x float> %594, i32 4, i32 4, i32 2, i32 %319, i32 3, i32 %325) - %648 = getelementptr i8, ptr addrspace(3) @smem1, i64 %449 - %649 = load <16 x i8>, ptr addrspace(3) %648, align 1 - %650 = bitcast <16 x i8> %649 to <2 x i64> - %651 = extractelement <2 x i64> %650, i64 0 - %652 = extractelement <2 x i64> %650, i64 1 - %653 = insertelement <4 x i64> poison, i64 %651, i64 0 - %654 = insertelement <4 x i64> %653, i64 %652, i64 1 - %655 = insertelement <4 x i64> %654, i64 0, i64 2 - %656 = insertelement <4 x i64> %655, i64 0, i64 3 - %657 = bitcast <4 x i64> %656 to <8 x i32> - %658 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %657, <8 x i32> %640, <4 x float> %605, i32 4, i32 4, i32 3, i32 %319, i32 2, i32 %325) - %659 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %657, <8 x i32> %646, <4 x float> %606, i32 4, i32 4, i32 3, i32 %319, i32 3, i32 %325) - %660 = insertelement <4 x i64> poison, i64 %566, i64 0 - %661 = insertelement <4 x i64> %660, i64 %567, i64 1 - %662 = insertelement <4 x i64> %661, i64 0, i64 2 - %663 = insertelement <4 x i64> %662, i64 0, i64 3 - %664 = bitcast <4 x i64> %663 to <8 x i32> - %665 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %635, <8 x i32> %664, <4 x float> %612, i32 4, i32 4, i32 2, i32 %319, i32 2, i32 %331) - %666 = insertelement <4 x i64> poison, i64 %576, i64 0 - %667 = insertelement <4 x i64> %666, i64 %577, i64 1 - %668 = insertelement <4 x i64> %667, i64 0, i64 2 - %669 = insertelement <4 x i64> %668, i64 0, i64 3 - %670 = bitcast <4 x i64> %669 to <8 x i32> - %671 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %635, <8 x i32> %670, <4 x float> %618, i32 4, i32 4, i32 2, i32 %319, i32 3, i32 %331) - %672 = getelementptr i8, ptr addrspace(3) @smem1, i64 %449 - %673 = load <16 x i8>, ptr addrspace(3) %672, align 1 - %674 = bitcast <16 x i8> %673 to <2 x i64> - %675 = extractelement <2 x i64> %674, i64 0 - %676 = extractelement <2 x i64> %674, i64 1 - %677 = insertelement <4 x i64> poison, i64 %675, i64 0 - %678 = insertelement <4 x i64> %677, i64 %676, i64 1 - %679 = insertelement <4 x i64> %678, i64 0, i64 2 - %680 = insertelement <4 x i64> %679, i64 0, i64 3 - %681 = bitcast <4 x i64> %680 to <8 x i32> - %682 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %681, <8 x i32> %664, <4 x float> %629, i32 4, i32 4, i32 3, i32 %319, i32 2, i32 %331) - %683 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32> %681, <8 x i32> %670, <4 x float> %630, i32 4, i32 4, i32 3, i32 %319, i32 3, i32 %331) - %684 = ptrtoint ptr addrspace(1) %0 to i64 - %685 = add i64 %128, %126 - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %686 = mul i64 %125, 1024 - %687 = extractelement <4 x float> %641, i64 0 - %688 = extractelement <4 x float> %647, i64 0 - %689 = extractelement <4 x float> %665, i64 0 - %690 = extractelement <4 x float> %671, i64 0 - %691 = insertelement <4 x float> poison, float %687, i64 0 - %692 = insertelement <4 x float> %691, float %688, i64 1 - %693 = insertelement <4 x float> %692, float %689, i64 2 - %694 = insertelement <4 x float> %693, float %690, i64 3 - %695 = insertelement <4 x float> poison, float %500, i32 0 - %696 = shufflevector <4 x float> %695, <4 x float> poison, <4 x i32> zeroinitializer - %697 = fmul <4 x float> %694, %696 - %698 = extractelement <4 x float> %697, i64 0 - %699 = add i64 %686, %685 - %700 = insertelement <1 x float> poison, float %698, i32 0 - %701 = getelementptr float, ptr addrspace(3) @smem0, i64 %699 - store <1 x float> %700, ptr addrspace(3) %701, align 4 - %702 = add i64 %685, 16 - %703 = extractelement <4 x float> %697, i64 1 - %704 = add i64 %686, %702 - %705 = insertelement <1 x float> poison, float %703, i32 0 - %706 = getelementptr float, ptr addrspace(3) @smem0, i64 %704 - store <1 x float> %705, ptr addrspace(3) %706, align 4 - %707 = add i64 %685, 32 - %708 = extractelement <4 x float> %697, i64 2 - %709 = add i64 %686, %707 - %710 = insertelement <1 x float> poison, float %708, i32 0 - %711 = getelementptr float, ptr addrspace(3) @smem0, i64 %709 - store <1 x float> %710, ptr addrspace(3) %711, align 4 - %712 = add i64 %685, 48 - %713 = extractelement <4 x float> %697, i64 3 - %714 = add i64 %686, %712 - %715 = insertelement <1 x float> poison, float %713, i32 0 - %716 = getelementptr float, ptr addrspace(3) @smem0, i64 %714 - store <1 x float> %715, ptr addrspace(3) %716, align 4 - %717 = mul i64 %501, 256 - %718 = extractelement <4 x float> %641, i64 1 - %719 = extractelement <4 x float> %647, i64 1 - %720 = extractelement <4 x float> %665, i64 1 - %721 = extractelement <4 x float> %671, i64 1 - %722 = insertelement <4 x float> poison, float %718, i64 0 - %723 = insertelement <4 x float> %722, float %719, i64 1 - %724 = insertelement <4 x float> %723, float %720, i64 2 - %725 = insertelement <4 x float> %724, float %721, i64 3 - %726 = insertelement <4 x float> poison, float %505, i32 0 - %727 = shufflevector <4 x float> %726, <4 x float> poison, <4 x i32> zeroinitializer - %728 = fmul <4 x float> %725, %727 - %729 = extractelement <4 x float> %728, i64 0 - %730 = add i64 %717, %685 - %731 = insertelement <1 x float> poison, float %729, i32 0 - %732 = getelementptr float, ptr addrspace(3) @smem0, i64 %730 - store <1 x float> %731, ptr addrspace(3) %732, align 4 - %733 = extractelement <4 x float> %728, i64 1 - %734 = add i64 %717, %702 - %735 = insertelement <1 x float> poison, float %733, i32 0 - %736 = getelementptr float, ptr addrspace(3) @smem0, i64 %734 - store <1 x float> %735, ptr addrspace(3) %736, align 4 - %737 = extractelement <4 x float> %728, i64 2 - %738 = add i64 %717, %707 - %739 = insertelement <1 x float> poison, float %737, i32 0 - %740 = getelementptr float, ptr addrspace(3) @smem0, i64 %738 - store <1 x float> %739, ptr addrspace(3) %740, align 4 - %741 = extractelement <4 x float> %728, i64 3 - %742 = add i64 %717, %712 - %743 = insertelement <1 x float> poison, float %741, i32 0 - %744 = getelementptr float, ptr addrspace(3) @smem0, i64 %742 - store <1 x float> %743, ptr addrspace(3) %744, align 4 - %745 = mul i64 %506, 256 - %746 = extractelement <4 x float> %641, i64 2 - %747 = extractelement <4 x float> %647, i64 2 - %748 = extractelement <4 x float> %665, i64 2 - %749 = extractelement <4 x float> %671, i64 2 - %750 = insertelement <4 x float> poison, float %746, i64 0 - %751 = insertelement <4 x float> %750, float %747, i64 1 - %752 = insertelement <4 x float> %751, float %748, i64 2 - %753 = insertelement <4 x float> %752, float %749, i64 3 - %754 = insertelement <4 x float> poison, float %510, i32 0 - %755 = shufflevector <4 x float> %754, <4 x float> poison, <4 x i32> zeroinitializer - %756 = fmul <4 x float> %753, %755 - %757 = extractelement <4 x float> %756, i64 0 - %758 = add i64 %745, %685 - %759 = insertelement <1 x float> poison, float %757, i32 0 - %760 = getelementptr float, ptr addrspace(3) @smem0, i64 %758 - store <1 x float> %759, ptr addrspace(3) %760, align 4 - %761 = extractelement <4 x float> %756, i64 1 - %762 = add i64 %745, %702 - %763 = insertelement <1 x float> poison, float %761, i32 0 - %764 = getelementptr float, ptr addrspace(3) @smem0, i64 %762 - store <1 x float> %763, ptr addrspace(3) %764, align 4 - %765 = extractelement <4 x float> %756, i64 2 - %766 = add i64 %745, %707 - %767 = insertelement <1 x float> poison, float %765, i32 0 - %768 = getelementptr float, ptr addrspace(3) @smem0, i64 %766 - store <1 x float> %767, ptr addrspace(3) %768, align 4 - %769 = extractelement <4 x float> %756, i64 3 - %770 = add i64 %745, %712 - %771 = insertelement <1 x float> poison, float %769, i32 0 - %772 = getelementptr float, ptr addrspace(3) @smem0, i64 %770 - store <1 x float> %771, ptr addrspace(3) %772, align 4 - %773 = mul i64 %511, 256 - %774 = extractelement <4 x float> %641, i64 3 - %775 = extractelement <4 x float> %647, i64 3 - %776 = extractelement <4 x float> %665, i64 3 - %777 = extractelement <4 x float> %671, i64 3 - %778 = insertelement <4 x float> poison, float %774, i64 0 - %779 = insertelement <4 x float> %778, float %775, i64 1 - %780 = insertelement <4 x float> %779, float %776, i64 2 - %781 = insertelement <4 x float> %780, float %777, i64 3 - %782 = insertelement <4 x float> poison, float %515, i32 0 - %783 = shufflevector <4 x float> %782, <4 x float> poison, <4 x i32> zeroinitializer - %784 = fmul <4 x float> %781, %783 - %785 = extractelement <4 x float> %784, i64 0 - %786 = add i64 %773, %685 - %787 = insertelement <1 x float> poison, float %785, i32 0 - %788 = getelementptr float, ptr addrspace(3) @smem0, i64 %786 - store <1 x float> %787, ptr addrspace(3) %788, align 4 - %789 = extractelement <4 x float> %784, i64 1 - %790 = add i64 %773, %702 - %791 = insertelement <1 x float> poison, float %789, i32 0 - %792 = getelementptr float, ptr addrspace(3) @smem0, i64 %790 - store <1 x float> %791, ptr addrspace(3) %792, align 4 - %793 = extractelement <4 x float> %784, i64 2 - %794 = add i64 %773, %707 - %795 = insertelement <1 x float> poison, float %793, i32 0 - %796 = getelementptr float, ptr addrspace(3) @smem0, i64 %794 - store <1 x float> %795, ptr addrspace(3) %796, align 4 - %797 = extractelement <4 x float> %784, i64 3 - %798 = add i64 %773, %712 - %799 = insertelement <1 x float> poison, float %797, i32 0 - %800 = getelementptr float, ptr addrspace(3) @smem0, i64 %798 - store <1 x float> %799, ptr addrspace(3) %800, align 4 - %801 = mul i64 %516, 256 - %802 = extractelement <4 x float> %658, i64 0 - %803 = extractelement <4 x float> %659, i64 0 - %804 = extractelement <4 x float> %682, i64 0 - %805 = extractelement <4 x float> %683, i64 0 - %806 = insertelement <4 x float> poison, float %802, i64 0 - %807 = insertelement <4 x float> %806, float %803, i64 1 - %808 = insertelement <4 x float> %807, float %804, i64 2 - %809 = insertelement <4 x float> %808, float %805, i64 3 - %810 = insertelement <4 x float> poison, float %520, i32 0 - %811 = shufflevector <4 x float> %810, <4 x float> poison, <4 x i32> zeroinitializer - %812 = fmul <4 x float> %809, %811 - %813 = extractelement <4 x float> %812, i64 0 - %814 = add i64 %801, %685 - %815 = insertelement <1 x float> poison, float %813, i32 0 - %816 = getelementptr float, ptr addrspace(3) @smem0, i64 %814 - store <1 x float> %815, ptr addrspace(3) %816, align 4 - %817 = extractelement <4 x float> %812, i64 1 - %818 = add i64 %801, %702 - %819 = insertelement <1 x float> poison, float %817, i32 0 - %820 = getelementptr float, ptr addrspace(3) @smem0, i64 %818 - store <1 x float> %819, ptr addrspace(3) %820, align 4 - %821 = extractelement <4 x float> %812, i64 2 - %822 = add i64 %801, %707 - %823 = insertelement <1 x float> poison, float %821, i32 0 - %824 = getelementptr float, ptr addrspace(3) @smem0, i64 %822 - store <1 x float> %823, ptr addrspace(3) %824, align 4 - %825 = extractelement <4 x float> %812, i64 3 - %826 = add i64 %801, %712 - %827 = insertelement <1 x float> poison, float %825, i32 0 - %828 = getelementptr float, ptr addrspace(3) @smem0, i64 %826 - store <1 x float> %827, ptr addrspace(3) %828, align 4 - %829 = mul i64 %521, 256 - %830 = extractelement <4 x float> %658, i64 1 - %831 = extractelement <4 x float> %659, i64 1 - %832 = extractelement <4 x float> %682, i64 1 - %833 = extractelement <4 x float> %683, i64 1 - %834 = insertelement <4 x float> poison, float %830, i64 0 - %835 = insertelement <4 x float> %834, float %831, i64 1 - %836 = insertelement <4 x float> %835, float %832, i64 2 - %837 = insertelement <4 x float> %836, float %833, i64 3 - %838 = insertelement <4 x float> poison, float %525, i32 0 - %839 = shufflevector <4 x float> %838, <4 x float> poison, <4 x i32> zeroinitializer - %840 = fmul <4 x float> %837, %839 - %841 = extractelement <4 x float> %840, i64 0 - %842 = add i64 %829, %685 - %843 = insertelement <1 x float> poison, float %841, i32 0 - %844 = getelementptr float, ptr addrspace(3) @smem0, i64 %842 - store <1 x float> %843, ptr addrspace(3) %844, align 4 - %845 = extractelement <4 x float> %840, i64 1 - %846 = add i64 %829, %702 - %847 = insertelement <1 x float> poison, float %845, i32 0 - %848 = getelementptr float, ptr addrspace(3) @smem0, i64 %846 - store <1 x float> %847, ptr addrspace(3) %848, align 4 - %849 = extractelement <4 x float> %840, i64 2 - %850 = add i64 %829, %707 - %851 = insertelement <1 x float> poison, float %849, i32 0 - %852 = getelementptr float, ptr addrspace(3) @smem0, i64 %850 - store <1 x float> %851, ptr addrspace(3) %852, align 4 - %853 = extractelement <4 x float> %840, i64 3 - %854 = add i64 %829, %712 - %855 = insertelement <1 x float> poison, float %853, i32 0 - %856 = getelementptr float, ptr addrspace(3) @smem0, i64 %854 - store <1 x float> %855, ptr addrspace(3) %856, align 4 - %857 = mul i64 %526, 256 - %858 = extractelement <4 x float> %658, i64 2 - %859 = extractelement <4 x float> %659, i64 2 - %860 = extractelement <4 x float> %682, i64 2 - %861 = extractelement <4 x float> %683, i64 2 - %862 = insertelement <4 x float> poison, float %858, i64 0 - %863 = insertelement <4 x float> %862, float %859, i64 1 - %864 = insertelement <4 x float> %863, float %860, i64 2 - %865 = insertelement <4 x float> %864, float %861, i64 3 - %866 = insertelement <4 x float> poison, float %530, i32 0 - %867 = shufflevector <4 x float> %866, <4 x float> poison, <4 x i32> zeroinitializer - %868 = fmul <4 x float> %865, %867 - %869 = extractelement <4 x float> %868, i64 0 - %870 = add i64 %857, %685 - %871 = insertelement <1 x float> poison, float %869, i32 0 - %872 = getelementptr float, ptr addrspace(3) @smem0, i64 %870 - store <1 x float> %871, ptr addrspace(3) %872, align 4 - %873 = extractelement <4 x float> %868, i64 1 - %874 = add i64 %857, %702 - %875 = insertelement <1 x float> poison, float %873, i32 0 - %876 = getelementptr float, ptr addrspace(3) @smem0, i64 %874 - store <1 x float> %875, ptr addrspace(3) %876, align 4 - %877 = extractelement <4 x float> %868, i64 2 - %878 = add i64 %857, %707 - %879 = insertelement <1 x float> poison, float %877, i32 0 - %880 = getelementptr float, ptr addrspace(3) @smem0, i64 %878 - store <1 x float> %879, ptr addrspace(3) %880, align 4 - %881 = extractelement <4 x float> %868, i64 3 - %882 = add i64 %857, %712 - %883 = insertelement <1 x float> poison, float %881, i32 0 - %884 = getelementptr float, ptr addrspace(3) @smem0, i64 %882 - store <1 x float> %883, ptr addrspace(3) %884, align 4 - %885 = mul i64 %531, 256 - %886 = extractelement <4 x float> %658, i64 3 - %887 = extractelement <4 x float> %659, i64 3 - %888 = extractelement <4 x float> %682, i64 3 - %889 = extractelement <4 x float> %683, i64 3 - %890 = insertelement <4 x float> poison, float %886, i64 0 - %891 = insertelement <4 x float> %890, float %887, i64 1 - %892 = insertelement <4 x float> %891, float %888, i64 2 - %893 = insertelement <4 x float> %892, float %889, i64 3 - %894 = insertelement <4 x float> poison, float %535, i32 0 - %895 = shufflevector <4 x float> %894, <4 x float> poison, <4 x i32> zeroinitializer - %896 = fmul <4 x float> %893, %895 - %897 = extractelement <4 x float> %896, i64 0 - %898 = add i64 %885, %685 - %899 = insertelement <1 x float> poison, float %897, i32 0 - %900 = getelementptr float, ptr addrspace(3) @smem0, i64 %898 - store <1 x float> %899, ptr addrspace(3) %900, align 4 - %901 = extractelement <4 x float> %896, i64 1 - %902 = add i64 %885, %702 - %903 = insertelement <1 x float> poison, float %901, i32 0 - %904 = getelementptr float, ptr addrspace(3) @smem0, i64 %902 - store <1 x float> %903, ptr addrspace(3) %904, align 4 - %905 = extractelement <4 x float> %896, i64 2 - %906 = add i64 %885, %707 - %907 = insertelement <1 x float> poison, float %905, i32 0 - %908 = getelementptr float, ptr addrspace(3) @smem0, i64 %906 - store <1 x float> %907, ptr addrspace(3) %908, align 4 - %909 = extractelement <4 x float> %896, i64 3 - %910 = add i64 %885, %712 - %911 = insertelement <1 x float> poison, float %909, i32 0 - %912 = getelementptr float, ptr addrspace(3) @smem0, i64 %910 - store <1 x float> %911, ptr addrspace(3) %912, align 4 - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %913 = udiv i64 %19, 32 - %914 = urem i64 %19, 32 - %915 = getelementptr inbounds nuw i32, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @smem0, i32 32768), i64 %913 - %916 = load i32, ptr addrspace(3) %915, align 4 - %917 = and i32 %916, 16777215 - %918 = icmp ult i32 %917, %10 - %919 = sext i32 %917 to i64 - %920 = mul i64 %919, 14336 - %921 = add i64 %684, %920 - %922 = add i64 %913, 8 - %923 = getelementptr inbounds nuw i32, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @smem0, i32 32768), i64 %922 - %924 = load i32, ptr addrspace(3) %923, align 4 - %925 = and i32 %924, 16777215 - %926 = icmp ult i32 %925, %10 - %927 = sext i32 %925 to i64 - %928 = mul i64 %927, 14336 - %929 = add i64 %684, %928 - %930 = add i64 %913, 16 - %931 = getelementptr inbounds nuw i32, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @smem0, i32 32768), i64 %930 - %932 = load i32, ptr addrspace(3) %931, align 4 - %933 = and i32 %932, 16777215 - %934 = icmp ult i32 %933, %10 - %935 = sext i32 %933 to i64 - %936 = mul i64 %935, 14336 - %937 = add i64 %684, %936 - %938 = add i64 %913, 24 - %939 = getelementptr inbounds nuw i32, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @smem0, i32 32768), i64 %938 - %940 = load i32, ptr addrspace(3) %939, align 4 - %941 = and i32 %940, 16777215 - %942 = icmp ult i32 %941, %10 - %943 = sext i32 %941 to i64 - %944 = mul i64 %943, 14336 - %945 = add i64 %684, %944 - br i1 %918, label %946, label %988 - -946: ; preds = %154 - %947 = mul i64 %913, 256 - %948 = mul i64 %914, 2 - %949 = add i64 %947, %948 - %950 = getelementptr float, ptr addrspace(3) @smem0, i64 %949 - %951 = load <2 x float>, ptr addrspace(3) %950, align 4 - %952 = add i64 %129, %948 - %953 = fptrunc <2 x float> %951 to <2 x bfloat> - %954 = mul i64 %952, 2 - %955 = add i64 %921, %954 - %956 = inttoptr i64 %955 to ptr addrspace(1) - %957 = atomicrmw fadd ptr addrspace(1) %956, <2 x bfloat> %953 syncscope("agent") monotonic, align 4 - %958 = add i64 %948, 64 - %959 = add i64 %947, %958 - %960 = getelementptr float, ptr addrspace(3) @smem0, i64 %959 - %961 = load <2 x float>, ptr addrspace(3) %960, align 4 - %962 = add i64 %129, %958 - %963 = fptrunc <2 x float> %961 to <2 x bfloat> - %964 = mul i64 %962, 2 - %965 = add i64 %921, %964 - %966 = inttoptr i64 %965 to ptr addrspace(1) - %967 = atomicrmw fadd ptr addrspace(1) %966, <2 x bfloat> %963 syncscope("agent") monotonic, align 4 - %968 = add i64 %948, 128 - %969 = add i64 %947, %968 - %970 = getelementptr float, ptr addrspace(3) @smem0, i64 %969 - %971 = load <2 x float>, ptr addrspace(3) %970, align 4 - %972 = add i64 %129, %968 - %973 = fptrunc <2 x float> %971 to <2 x bfloat> - %974 = mul i64 %972, 2 - %975 = add i64 %921, %974 - %976 = inttoptr i64 %975 to ptr addrspace(1) - %977 = atomicrmw fadd ptr addrspace(1) %976, <2 x bfloat> %973 syncscope("agent") monotonic, align 4 - %978 = add i64 %948, 192 - %979 = add i64 %947, %978 - %980 = getelementptr float, ptr addrspace(3) @smem0, i64 %979 - %981 = load <2 x float>, ptr addrspace(3) %980, align 4 - %982 = add i64 %129, %978 - %983 = fptrunc <2 x float> %981 to <2 x bfloat> - %984 = mul i64 %982, 2 - %985 = add i64 %921, %984 - %986 = inttoptr i64 %985 to ptr addrspace(1) - %987 = atomicrmw fadd ptr addrspace(1) %986, <2 x bfloat> %983 syncscope("agent") monotonic, align 4 - br label %988 - -988: ; preds = %946, %154 - br i1 %926, label %989, label %1031 - -989: ; preds = %988 - %990 = mul i64 %922, 256 - %991 = mul i64 %914, 2 - %992 = add i64 %990, %991 - %993 = getelementptr float, ptr addrspace(3) @smem0, i64 %992 - %994 = load <2 x float>, ptr addrspace(3) %993, align 4 - %995 = add i64 %129, %991 - %996 = fptrunc <2 x float> %994 to <2 x bfloat> - %997 = mul i64 %995, 2 - %998 = add i64 %929, %997 - %999 = inttoptr i64 %998 to ptr addrspace(1) - %1000 = atomicrmw fadd ptr addrspace(1) %999, <2 x bfloat> %996 syncscope("agent") monotonic, align 4 - %1001 = add i64 %991, 64 - %1002 = add i64 %990, %1001 - %1003 = getelementptr float, ptr addrspace(3) @smem0, i64 %1002 - %1004 = load <2 x float>, ptr addrspace(3) %1003, align 4 - %1005 = add i64 %129, %1001 - %1006 = fptrunc <2 x float> %1004 to <2 x bfloat> - %1007 = mul i64 %1005, 2 - %1008 = add i64 %929, %1007 - %1009 = inttoptr i64 %1008 to ptr addrspace(1) - %1010 = atomicrmw fadd ptr addrspace(1) %1009, <2 x bfloat> %1006 syncscope("agent") monotonic, align 4 - %1011 = add i64 %991, 128 - %1012 = add i64 %990, %1011 - %1013 = getelementptr float, ptr addrspace(3) @smem0, i64 %1012 - %1014 = load <2 x float>, ptr addrspace(3) %1013, align 4 - %1015 = add i64 %129, %1011 - %1016 = fptrunc <2 x float> %1014 to <2 x bfloat> - %1017 = mul i64 %1015, 2 - %1018 = add i64 %929, %1017 - %1019 = inttoptr i64 %1018 to ptr addrspace(1) - %1020 = atomicrmw fadd ptr addrspace(1) %1019, <2 x bfloat> %1016 syncscope("agent") monotonic, align 4 - %1021 = add i64 %991, 192 - %1022 = add i64 %990, %1021 - %1023 = getelementptr float, ptr addrspace(3) @smem0, i64 %1022 - %1024 = load <2 x float>, ptr addrspace(3) %1023, align 4 - %1025 = add i64 %129, %1021 - %1026 = fptrunc <2 x float> %1024 to <2 x bfloat> - %1027 = mul i64 %1025, 2 - %1028 = add i64 %929, %1027 - %1029 = inttoptr i64 %1028 to ptr addrspace(1) - %1030 = atomicrmw fadd ptr addrspace(1) %1029, <2 x bfloat> %1026 syncscope("agent") monotonic, align 4 - br label %1031 - -1031: ; preds = %989, %988 - br i1 %934, label %1032, label %1074 - -1032: ; preds = %1031 - %1033 = mul i64 %930, 256 - %1034 = mul i64 %914, 2 - %1035 = add i64 %1033, %1034 - %1036 = getelementptr float, ptr addrspace(3) @smem0, i64 %1035 - %1037 = load <2 x float>, ptr addrspace(3) %1036, align 4 - %1038 = add i64 %129, %1034 - %1039 = fptrunc <2 x float> %1037 to <2 x bfloat> - %1040 = mul i64 %1038, 2 - %1041 = add i64 %937, %1040 - %1042 = inttoptr i64 %1041 to ptr addrspace(1) - %1043 = atomicrmw fadd ptr addrspace(1) %1042, <2 x bfloat> %1039 syncscope("agent") monotonic, align 4 - %1044 = add i64 %1034, 64 - %1045 = add i64 %1033, %1044 - %1046 = getelementptr float, ptr addrspace(3) @smem0, i64 %1045 - %1047 = load <2 x float>, ptr addrspace(3) %1046, align 4 - %1048 = add i64 %129, %1044 - %1049 = fptrunc <2 x float> %1047 to <2 x bfloat> - %1050 = mul i64 %1048, 2 - %1051 = add i64 %937, %1050 - %1052 = inttoptr i64 %1051 to ptr addrspace(1) - %1053 = atomicrmw fadd ptr addrspace(1) %1052, <2 x bfloat> %1049 syncscope("agent") monotonic, align 4 - %1054 = add i64 %1034, 128 - %1055 = add i64 %1033, %1054 - %1056 = getelementptr float, ptr addrspace(3) @smem0, i64 %1055 - %1057 = load <2 x float>, ptr addrspace(3) %1056, align 4 - %1058 = add i64 %129, %1054 - %1059 = fptrunc <2 x float> %1057 to <2 x bfloat> - %1060 = mul i64 %1058, 2 - %1061 = add i64 %937, %1060 - %1062 = inttoptr i64 %1061 to ptr addrspace(1) - %1063 = atomicrmw fadd ptr addrspace(1) %1062, <2 x bfloat> %1059 syncscope("agent") monotonic, align 4 - %1064 = add i64 %1034, 192 - %1065 = add i64 %1033, %1064 - %1066 = getelementptr float, ptr addrspace(3) @smem0, i64 %1065 - %1067 = load <2 x float>, ptr addrspace(3) %1066, align 4 - %1068 = add i64 %129, %1064 - %1069 = fptrunc <2 x float> %1067 to <2 x bfloat> - %1070 = mul i64 %1068, 2 - %1071 = add i64 %937, %1070 - %1072 = inttoptr i64 %1071 to ptr addrspace(1) - %1073 = atomicrmw fadd ptr addrspace(1) %1072, <2 x bfloat> %1069 syncscope("agent") monotonic, align 4 - br label %1074 - -1074: ; preds = %1032, %1031 - br i1 %942, label %1075, label %1117 - -1075: ; preds = %1074 - %1076 = mul i64 %938, 256 - %1077 = mul i64 %914, 2 - %1078 = add i64 %1076, %1077 - %1079 = getelementptr float, ptr addrspace(3) @smem0, i64 %1078 - %1080 = load <2 x float>, ptr addrspace(3) %1079, align 4 - %1081 = add i64 %129, %1077 - %1082 = fptrunc <2 x float> %1080 to <2 x bfloat> - %1083 = mul i64 %1081, 2 - %1084 = add i64 %945, %1083 - %1085 = inttoptr i64 %1084 to ptr addrspace(1) - %1086 = atomicrmw fadd ptr addrspace(1) %1085, <2 x bfloat> %1082 syncscope("agent") monotonic, align 4 - %1087 = add i64 %1077, 64 - %1088 = add i64 %1076, %1087 - %1089 = getelementptr float, ptr addrspace(3) @smem0, i64 %1088 - %1090 = load <2 x float>, ptr addrspace(3) %1089, align 4 - %1091 = add i64 %129, %1087 - %1092 = fptrunc <2 x float> %1090 to <2 x bfloat> - %1093 = mul i64 %1091, 2 - %1094 = add i64 %945, %1093 - %1095 = inttoptr i64 %1094 to ptr addrspace(1) - %1096 = atomicrmw fadd ptr addrspace(1) %1095, <2 x bfloat> %1092 syncscope("agent") monotonic, align 4 - %1097 = add i64 %1077, 128 - %1098 = add i64 %1076, %1097 - %1099 = getelementptr float, ptr addrspace(3) @smem0, i64 %1098 - %1100 = load <2 x float>, ptr addrspace(3) %1099, align 4 - %1101 = add i64 %129, %1097 - %1102 = fptrunc <2 x float> %1100 to <2 x bfloat> - %1103 = mul i64 %1101, 2 - %1104 = add i64 %945, %1103 - %1105 = inttoptr i64 %1104 to ptr addrspace(1) - %1106 = atomicrmw fadd ptr addrspace(1) %1105, <2 x bfloat> %1102 syncscope("agent") monotonic, align 4 - %1107 = add i64 %1077, 192 - %1108 = add i64 %1076, %1107 - %1109 = getelementptr float, ptr addrspace(3) @smem0, i64 %1108 - %1110 = load <2 x float>, ptr addrspace(3) %1109, align 4 - %1111 = add i64 %129, %1107 - %1112 = fptrunc <2 x float> %1110 to <2 x bfloat> - %1113 = mul i64 %1111, 2 - %1114 = add i64 %945, %1113 - %1115 = inttoptr i64 %1114 to ptr addrspace(1) - %1116 = atomicrmw fadd ptr addrspace(1) %1115, <2 x bfloat> %1112 syncscope("agent") monotonic, align 4 - br label %1117 - -1117: ; preds = %1075, %1074 - br label %1118 - -1118: ; preds = %1117, %80 - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %1119 = add i64 %77, 1 - br label %76 - -1120: ; preds = %76 - ret void -} - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef i32 @llvm.amdgcn.workgroup.id.y() #1 - -; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) -declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #2 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #3 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) -declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #4 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.sched.barrier(i32 immarg) #5 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #3 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) -declare i64 @llvm.amdgcn.readfirstlane.i64(i64) #4 - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #6 - -; Function Attrs: nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.s.waitcnt(i32 immarg) #7 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.s.barrier() #5 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) -declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v8i32.v8i32(<8 x i32>, <8 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #8 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #3 - -attributes #0 = { "amdgpu-flat-work-group-size"="1,256" "amdgpu-waves-per-eu"="4" "uniform-work-group-size" } -attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } -attributes #2 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } -attributes #3 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } -attributes #4 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } -attributes #5 = { convergent nocallback nofree nounwind willreturn } -attributes #6 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } -attributes #7 = { nocallback nofree nounwind willreturn } -attributes #8 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} diff --git a/kernels/gemm2_port_ref/flydsl_port_v1.ll b/kernels/gemm2_port_ref/flydsl_port_v1.ll deleted file mode 100644 index a13551384..000000000 --- a/kernels/gemm2_port_ref/flydsl_port_v1.ll +++ /dev/null @@ -1,892 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" -target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" - -@gemm2port_smem = external addrspace(3) global [32768 x i8], align 1024 - -define amdgpu_kernel void @gemm2_a4w4_port_bm32_atomic(ptr addrspace(1) %0, <{ <{ i32, i32 }>, <{ i64 }> }> %1, ptr addrspace(1) %2, <{ <{ i32, i32 }>, <{ i64 }> }> %3, ptr addrspace(1) %4, <{ <{ i32, i32, i32 }>, <{ i64, i64 }> }> %5, ptr addrspace(1) %6, <{ <{ i32, i32 }>, <{ i64 }> }> %7, ptr addrspace(1) %8, <{ <{ i32 }> }> %9, ptr addrspace(1) %10, <{ <{ i32 }> }> %11, ptr addrspace(1) %12, <{ <{ i32 }> }> %13, ptr addrspace(1) %14, <{ <{ i32 }> }> %15, i32 %16, ptr addrspace(1) %17, <{ <{ i32, i32 }>, <{ i64 }> }> %18) #0 !reqd_work_group_size !1 { - %20 = call range(i32 0, 256) i32 @llvm.amdgcn.workitem.id.x() - %21 = sext i32 %20 to i64 - %22 = call i32 @llvm.amdgcn.workgroup.id.x() - %23 = sext i32 %22 to i64 - %24 = trunc i64 %21 to i32 - %25 = trunc i64 %23 to i32 - %26 = srem i32 %24, 64 - %27 = sdiv i32 %24, 64 - %28 = mul i32 %27, 64 - %29 = icmp ne i32 %24, %28 - %30 = icmp slt i32 %24, 0 - %31 = icmp ne i1 %30, false - %32 = and i1 %29, %31 - %33 = add i32 %27, -1 - %34 = select i1 %32, i32 %33, i32 %27 - %35 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %34) - %36 = addrspacecast ptr addrspace(1) %10 to ptr - %37 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %36, i16 0, i64 4294967295, i32 159744) - %38 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %37, i32 0, i32 0, i32 0) - %39 = sdiv i32 %38, 32 - %40 = mul i32 %39, 32 - %41 = icmp ne i32 %38, %40 - %42 = icmp slt i32 %38, 0 - %43 = icmp ne i1 %42, false - %44 = and i1 %41, %43 - %45 = add i32 %39, -1 - %46 = select i1 %44, i32 %45, i32 %39 - %47 = mul i32 %46, 28 - %48 = icmp slt i32 %25, %47 - br i1 %48, label %49, label %786 - -49: ; preds = %19 - %50 = srem i32 %25, 28 - %51 = sdiv i32 %25, 28 - %52 = mul i32 %51, 28 - %53 = icmp ne i32 %25, %52 - %54 = icmp slt i32 %25, 0 - %55 = icmp ne i1 %54, false - %56 = and i1 %53, %55 - %57 = add i32 %51, -1 - %58 = select i1 %56, i32 %57, i32 %51 - %59 = addrspacecast ptr addrspace(1) %8 to ptr - %60 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %59, i16 0, i64 4294967295, i32 159744) - %61 = mul i32 %58, 4 - %62 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %60, i32 %61, i32 0, i32 0) - %63 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %62) - %64 = mul i32 %58, 32 - %65 = addrspacecast ptr addrspace(1) %0 to ptr - %66 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %65, i16 0, i64 167772160, i32 159744) - %67 = addrspacecast ptr addrspace(1) %2 to ptr - %68 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %67, i16 0, i64 10485760, i32 159744) - %69 = addrspacecast ptr addrspace(1) %4 to ptr - %70 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %69, i16 0, i64 706478080, i32 159744) - %71 = addrspacecast ptr addrspace(1) %6 to ptr - %72 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %71, i16 0, i64 44154880, i32 159744) - %73 = sdiv i32 %26, 8 - %74 = mul i32 %73, 8 - %75 = icmp ne i32 %26, %74 - %76 = icmp slt i32 %26, 0 - %77 = icmp ne i1 %76, false - %78 = and i1 %75, %77 - %79 = add i32 %73, -1 - %80 = select i1 %78, i32 %79, i32 %73 - %81 = srem i32 %26, 8 - %82 = sdiv i32 %26, 16 - %83 = mul i32 %82, 16 - %84 = icmp ne i32 %26, %83 - %85 = icmp slt i32 %26, 0 - %86 = icmp ne i1 %85, false - %87 = and i1 %84, %86 - %88 = add i32 %82, -1 - %89 = select i1 %87, i32 %88, i32 %82 - %90 = srem i32 %26, 16 - %91 = mul i32 %63, 7168 - %92 = mul i32 %50, 256 - %93 = add i32 %91, %92 - %94 = mul i32 %35, 64 - %95 = add i32 %93, %94 - %96 = mul i32 %95, 256 - %97 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %96) - %98 = add i32 %95, 16 - %99 = mul i32 %98, 256 - %100 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %99) - %101 = add i32 %95, 32 - %102 = mul i32 %101, 256 - %103 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %102) - %104 = add i32 %95, 48 - %105 = mul i32 %104, 256 - %106 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %105) - %107 = mul i32 %50, 8 - %108 = mul i32 %35, 2 - %109 = add i32 %107, %108 - %110 = mul i32 %63, 28672 - %111 = mul i32 %109, 128 - %112 = add i32 %110, %111 - %113 = mul i32 %112, 4 - %114 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %113) - %115 = add i32 %109, 1 - %116 = mul i32 %115, 128 - %117 = add i32 %110, %116 - %118 = mul i32 %117, 4 - %119 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %118) - %120 = sdiv i32 %64, 32 - %121 = mul i32 %120, 32 - %122 = icmp ne i32 %64, %121 - %123 = icmp slt i32 %64, 0 - %124 = icmp ne i1 %123, false - %125 = and i1 %122, %124 - %126 = add i32 %120, -1 - %127 = select i1 %125, i32 %126, i32 %120 - %128 = mul i32 %127, 512 - %129 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %128) - %130 = mul i32 %35, 8 - %131 = add i32 %64, %130 - %132 = add i32 %131, %80 - %133 = add i32 %130, %80 - %134 = and i32 %133, 14 - %135 = shl i32 %134, 3 - %136 = mul i32 %81, 16 - %137 = xor i32 %136, %135 - %138 = mul i32 %132, 256 - %139 = add i32 %137, %138 - %140 = mul i32 %35, 1024 - %141 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %140 - %142 = sext i32 %141 to i64 - %143 = inttoptr i64 %142 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %66, ptr addrspace(3) %143, i32 16, i32 %139, i32 0, i32 0, i32 0) - %144 = add i32 %140, 4096 - %145 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %144 - %146 = sext i32 %145 to i64 - %147 = inttoptr i64 %146 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %66, ptr addrspace(3) %147, i32 16, i32 %139, i32 128, i32 0, i32 0) - call void @llvm.amdgcn.sched.barrier(i32 0) - %148 = mul i32 %89, 16 - %149 = add i32 %148, %90 - %150 = mul i32 %149, 4 - %151 = sdiv i32 %150, 4 - %152 = mul i32 %151, 4 - %153 = icmp ne i32 %150, %152 - %154 = icmp slt i32 %150, 0 - %155 = icmp ne i1 %154, false - %156 = and i1 %153, %155 - %157 = add i32 %151, -1 - %158 = select i1 %156, i32 %157, i32 %151 - %159 = mul i32 %158, 4 - %160 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %68, i32 %159, i32 %129, i32 0) - %161 = add i32 %150, 256 - %162 = sdiv i32 %161, 4 - %163 = mul i32 %162, 4 - %164 = icmp ne i32 %161, %163 - %165 = icmp slt i32 %161, 0 - %166 = icmp ne i1 %165, false - %167 = and i1 %164, %166 - %168 = add i32 %162, -1 - %169 = select i1 %167, i32 %168, i32 %162 - %170 = mul i32 %169, 4 - %171 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %68, i32 %170, i32 %129, i32 0) - %172 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %72, i32 %159, i32 %114, i32 0) - %173 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %72, i32 %159, i32 %119, i32 0) - %174 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %72, i32 %170, i32 %114, i32 0) - %175 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %72, i32 %170, i32 %119, i32 0) - %176 = mul i32 %89, 256 - %177 = mul i32 %90, 16 - %178 = add i32 %176, %177 - %179 = sdiv i32 %178, 4 - %180 = mul i32 %179, 4 - %181 = icmp ne i32 %178, %180 - %182 = icmp slt i32 %178, 0 - %183 = icmp ne i1 %182, false - %184 = and i1 %181, %183 - %185 = add i32 %179, -1 - %186 = select i1 %184, i32 %185, i32 %179 - %187 = mul i32 %186, 4 - %188 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %187, i32 %97, i32 0) - %189 = add i32 %178, 1024 - %190 = sdiv i32 %189, 4 - %191 = mul i32 %190, 4 - %192 = icmp ne i32 %189, %191 - %193 = icmp slt i32 %189, 0 - %194 = icmp ne i1 %193, false - %195 = and i1 %192, %194 - %196 = add i32 %190, -1 - %197 = select i1 %195, i32 %196, i32 %190 - %198 = mul i32 %197, 4 - %199 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %198, i32 %97, i32 0) - %200 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %187, i32 %100, i32 0) - %201 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %198, i32 %100, i32 0) - %202 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %187, i32 %103, i32 0) - %203 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %198, i32 %103, i32 0) - %204 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %187, i32 %106, i32 0) - %205 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %198, i32 %106, i32 0) - %206 = add i32 %178, 2048 - %207 = sdiv i32 %206, 4 - %208 = mul i32 %207, 4 - %209 = icmp ne i32 %206, %208 - %210 = icmp slt i32 %206, 0 - %211 = icmp ne i1 %210, false - %212 = and i1 %209, %211 - %213 = add i32 %207, -1 - %214 = select i1 %212, i32 %213, i32 %207 - %215 = mul i32 %214, 4 - %216 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %215, i32 %97, i32 0) - %217 = add i32 %178, 3072 - %218 = sdiv i32 %217, 4 - %219 = mul i32 %218, 4 - %220 = icmp ne i32 %217, %219 - %221 = icmp slt i32 %217, 0 - %222 = icmp ne i1 %221, false - %223 = and i1 %220, %222 - %224 = add i32 %218, -1 - %225 = select i1 %223, i32 %224, i32 %218 - %226 = mul i32 %225, 4 - %227 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %226, i32 %97, i32 0) - %228 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %215, i32 %100, i32 0) - %229 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %226, i32 %100, i32 0) - %230 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %215, i32 %103, i32 0) - %231 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %226, i32 %103, i32 0) - %232 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %215, i32 %106, i32 0) - %233 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %70, i32 %226, i32 %106, i32 0) - call void asm sideeffect "s_waitcnt vmcnt(23)", ""() - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %234 = and i32 %90, 14 - %235 = shl i32 %234, 3 - %236 = xor i32 %148, %235 - %237 = mul i32 %90, 128 - %238 = add i32 %237, %236 - %239 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %238 - %240 = sext i32 %239 to i64 - %241 = inttoptr i64 %240 to ptr addrspace(3) - %242 = load <4 x i32>, ptr addrspace(3) %241, align 16 - %243 = add i32 %90, 16 - %244 = mul i32 %243, 128 - %245 = add i32 %244, %236 - %246 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %245 - %247 = sext i32 %246 to i64 - %248 = inttoptr i64 %247 to ptr addrspace(3) - %249 = load <4 x i32>, ptr addrspace(3) %248, align 16 - %250 = add i32 %148, 64 - %251 = xor i32 %250, %235 - %252 = add i32 %237, %251 - %253 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %252 - %254 = sext i32 %253 to i64 - %255 = inttoptr i64 %254 to ptr addrspace(3) - %256 = load <4 x i32>, ptr addrspace(3) %255, align 16 - %257 = add i32 %244, %251 - %258 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %257 - %259 = sext i32 %258 to i64 - %260 = inttoptr i64 %259 to ptr addrspace(3) - %261 = load <4 x i32>, ptr addrspace(3) %260, align 16 - %262 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %242, <4 x i32> %188, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %160, i32 0, i32 %172) - %263 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %188, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %160, i32 0, i32 %172) - %264 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %199, <4 x float> %262, i32 4, i32 4, i32 2, i32 %160, i32 2, i32 %172) - %265 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %261, <4 x i32> %199, <4 x float> %263, i32 4, i32 4, i32 3, i32 %160, i32 2, i32 %172) - %266 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %242, <4 x i32> %200, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %160, i32 1, i32 %172) - %267 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %200, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %160, i32 1, i32 %172) - %268 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %201, <4 x float> %266, i32 4, i32 4, i32 2, i32 %160, i32 3, i32 %172) - %269 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %261, <4 x i32> %201, <4 x float> %267, i32 4, i32 4, i32 3, i32 %160, i32 3, i32 %172) - %270 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %242, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %160, i32 0, i32 %173) - %271 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %160, i32 0, i32 %173) - %272 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %203, <4 x float> %270, i32 4, i32 4, i32 2, i32 %160, i32 2, i32 %173) - %273 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %261, <4 x i32> %203, <4 x float> %271, i32 4, i32 4, i32 3, i32 %160, i32 2, i32 %173) - %274 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %242, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %160, i32 1, i32 %173) - %275 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %160, i32 1, i32 %173) - %276 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %205, <4 x float> %274, i32 4, i32 4, i32 2, i32 %160, i32 3, i32 %173) - %277 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %261, <4 x i32> %205, <4 x float> %275, i32 4, i32 4, i32 3, i32 %160, i32 3, i32 %173) - call void asm sideeffect "s_waitcnt vmcnt(22)", ""() - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %278 = add i32 %237, 4096 - %279 = add i32 %278, %236 - %280 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %279 - %281 = sext i32 %280 to i64 - %282 = inttoptr i64 %281 to ptr addrspace(3) - %283 = load <4 x i32>, ptr addrspace(3) %282, align 16 - %284 = add i32 %244, 4096 - %285 = add i32 %284, %236 - %286 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %285 - %287 = sext i32 %286 to i64 - %288 = inttoptr i64 %287 to ptr addrspace(3) - %289 = load <4 x i32>, ptr addrspace(3) %288, align 16 - %290 = add i32 %278, %251 - %291 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %290 - %292 = sext i32 %291 to i64 - %293 = inttoptr i64 %292 to ptr addrspace(3) - %294 = load <4 x i32>, ptr addrspace(3) %293, align 16 - %295 = add i32 %284, %251 - %296 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %295 - %297 = sext i32 %296 to i64 - %298 = inttoptr i64 %297 to ptr addrspace(3) - %299 = load <4 x i32>, ptr addrspace(3) %298, align 16 - %300 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %216, <4 x float> %264, i32 4, i32 4, i32 0, i32 %171, i32 0, i32 %174) - %301 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %289, <4 x i32> %216, <4 x float> %265, i32 4, i32 4, i32 1, i32 %171, i32 0, i32 %174) - %302 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %294, <4 x i32> %227, <4 x float> %300, i32 4, i32 4, i32 2, i32 %171, i32 2, i32 %174) - %303 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %299, <4 x i32> %227, <4 x float> %301, i32 4, i32 4, i32 3, i32 %171, i32 2, i32 %174) - %304 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %228, <4 x float> %268, i32 4, i32 4, i32 0, i32 %171, i32 1, i32 %174) - %305 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %289, <4 x i32> %228, <4 x float> %269, i32 4, i32 4, i32 1, i32 %171, i32 1, i32 %174) - %306 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %294, <4 x i32> %229, <4 x float> %304, i32 4, i32 4, i32 2, i32 %171, i32 3, i32 %174) - %307 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %299, <4 x i32> %229, <4 x float> %305, i32 4, i32 4, i32 3, i32 %171, i32 3, i32 %174) - %308 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %230, <4 x float> %272, i32 4, i32 4, i32 0, i32 %171, i32 0, i32 %175) - %309 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %289, <4 x i32> %230, <4 x float> %273, i32 4, i32 4, i32 1, i32 %171, i32 0, i32 %175) - %310 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %294, <4 x i32> %231, <4 x float> %308, i32 4, i32 4, i32 2, i32 %171, i32 2, i32 %175) - %311 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %299, <4 x i32> %231, <4 x float> %309, i32 4, i32 4, i32 3, i32 %171, i32 2, i32 %175) - %312 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %232, <4 x float> %276, i32 4, i32 4, i32 0, i32 %171, i32 1, i32 %175) - %313 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %289, <4 x i32> %232, <4 x float> %277, i32 4, i32 4, i32 1, i32 %171, i32 1, i32 %175) - %314 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %294, <4 x i32> %233, <4 x float> %312, i32 4, i32 4, i32 2, i32 %171, i32 3, i32 %175) - %315 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %299, <4 x i32> %233, <4 x float> %313, i32 4, i32 4, i32 3, i32 %171, i32 3, i32 %175) - %316 = mul i32 %89, 4 - %317 = add i32 %94, %90 - %318 = mul i32 %89, 1024 - %319 = add i32 %318, %317 - %320 = extractelement <4 x float> %302, i64 0 - %321 = sext i32 %319 to i64 - %322 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %321 - store float %320, ptr addrspace(3) %322, align 4 - %323 = add i32 %316, 1 - %324 = mul i32 %323, 256 - %325 = add i32 %324, %317 - %326 = extractelement <4 x float> %302, i64 1 - %327 = sext i32 %325 to i64 - %328 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %327 - store float %326, ptr addrspace(3) %328, align 4 - %329 = add i32 %316, 2 - %330 = mul i32 %329, 256 - %331 = add i32 %330, %317 - %332 = extractelement <4 x float> %302, i64 2 - %333 = sext i32 %331 to i64 - %334 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %333 - store float %332, ptr addrspace(3) %334, align 4 - %335 = add i32 %316, 3 - %336 = mul i32 %335, 256 - %337 = add i32 %336, %317 - %338 = extractelement <4 x float> %302, i64 3 - %339 = sext i32 %337 to i64 - %340 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %339 - store float %338, ptr addrspace(3) %340, align 4 - %341 = add i32 %94, 16 - %342 = add i32 %341, %90 - %343 = add i32 %318, %342 - %344 = extractelement <4 x float> %306, i64 0 - %345 = sext i32 %343 to i64 - %346 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %345 - store float %344, ptr addrspace(3) %346, align 4 - %347 = add i32 %324, %342 - %348 = extractelement <4 x float> %306, i64 1 - %349 = sext i32 %347 to i64 - %350 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %349 - store float %348, ptr addrspace(3) %350, align 4 - %351 = add i32 %330, %342 - %352 = extractelement <4 x float> %306, i64 2 - %353 = sext i32 %351 to i64 - %354 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %353 - store float %352, ptr addrspace(3) %354, align 4 - %355 = add i32 %336, %342 - %356 = extractelement <4 x float> %306, i64 3 - %357 = sext i32 %355 to i64 - %358 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %357 - store float %356, ptr addrspace(3) %358, align 4 - %359 = add i32 %94, 32 - %360 = add i32 %359, %90 - %361 = add i32 %318, %360 - %362 = extractelement <4 x float> %310, i64 0 - %363 = sext i32 %361 to i64 - %364 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %363 - store float %362, ptr addrspace(3) %364, align 4 - %365 = add i32 %324, %360 - %366 = extractelement <4 x float> %310, i64 1 - %367 = sext i32 %365 to i64 - %368 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %367 - store float %366, ptr addrspace(3) %368, align 4 - %369 = add i32 %330, %360 - %370 = extractelement <4 x float> %310, i64 2 - %371 = sext i32 %369 to i64 - %372 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %371 - store float %370, ptr addrspace(3) %372, align 4 - %373 = add i32 %336, %360 - %374 = extractelement <4 x float> %310, i64 3 - %375 = sext i32 %373 to i64 - %376 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %375 - store float %374, ptr addrspace(3) %376, align 4 - %377 = add i32 %94, 48 - %378 = add i32 %377, %90 - %379 = add i32 %318, %378 - %380 = extractelement <4 x float> %314, i64 0 - %381 = sext i32 %379 to i64 - %382 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %381 - store float %380, ptr addrspace(3) %382, align 4 - %383 = add i32 %324, %378 - %384 = extractelement <4 x float> %314, i64 1 - %385 = sext i32 %383 to i64 - %386 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %385 - store float %384, ptr addrspace(3) %386, align 4 - %387 = add i32 %330, %378 - %388 = extractelement <4 x float> %314, i64 2 - %389 = sext i32 %387 to i64 - %390 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %389 - store float %388, ptr addrspace(3) %390, align 4 - %391 = add i32 %336, %378 - %392 = extractelement <4 x float> %314, i64 3 - %393 = sext i32 %391 to i64 - %394 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %393 - store float %392, ptr addrspace(3) %394, align 4 - %395 = add i32 %316, 16 - %396 = mul i32 %395, 256 - %397 = add i32 %396, %317 - %398 = extractelement <4 x float> %303, i64 0 - %399 = sext i32 %397 to i64 - %400 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %399 - store float %398, ptr addrspace(3) %400, align 4 - %401 = add i32 %316, 17 - %402 = mul i32 %401, 256 - %403 = add i32 %402, %317 - %404 = extractelement <4 x float> %303, i64 1 - %405 = sext i32 %403 to i64 - %406 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %405 - store float %404, ptr addrspace(3) %406, align 4 - %407 = add i32 %316, 18 - %408 = mul i32 %407, 256 - %409 = add i32 %408, %317 - %410 = extractelement <4 x float> %303, i64 2 - %411 = sext i32 %409 to i64 - %412 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %411 - store float %410, ptr addrspace(3) %412, align 4 - %413 = add i32 %316, 19 - %414 = mul i32 %413, 256 - %415 = add i32 %414, %317 - %416 = extractelement <4 x float> %303, i64 3 - %417 = sext i32 %415 to i64 - %418 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %417 - store float %416, ptr addrspace(3) %418, align 4 - %419 = add i32 %396, %342 - %420 = extractelement <4 x float> %307, i64 0 - %421 = sext i32 %419 to i64 - %422 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %421 - store float %420, ptr addrspace(3) %422, align 4 - %423 = add i32 %402, %342 - %424 = extractelement <4 x float> %307, i64 1 - %425 = sext i32 %423 to i64 - %426 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %425 - store float %424, ptr addrspace(3) %426, align 4 - %427 = add i32 %408, %342 - %428 = extractelement <4 x float> %307, i64 2 - %429 = sext i32 %427 to i64 - %430 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %429 - store float %428, ptr addrspace(3) %430, align 4 - %431 = add i32 %414, %342 - %432 = extractelement <4 x float> %307, i64 3 - %433 = sext i32 %431 to i64 - %434 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %433 - store float %432, ptr addrspace(3) %434, align 4 - %435 = add i32 %396, %360 - %436 = extractelement <4 x float> %311, i64 0 - %437 = sext i32 %435 to i64 - %438 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %437 - store float %436, ptr addrspace(3) %438, align 4 - %439 = add i32 %402, %360 - %440 = extractelement <4 x float> %311, i64 1 - %441 = sext i32 %439 to i64 - %442 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %441 - store float %440, ptr addrspace(3) %442, align 4 - %443 = add i32 %408, %360 - %444 = extractelement <4 x float> %311, i64 2 - %445 = sext i32 %443 to i64 - %446 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %445 - store float %444, ptr addrspace(3) %446, align 4 - %447 = add i32 %414, %360 - %448 = extractelement <4 x float> %311, i64 3 - %449 = sext i32 %447 to i64 - %450 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %449 - store float %448, ptr addrspace(3) %450, align 4 - %451 = add i32 %396, %378 - %452 = extractelement <4 x float> %315, i64 0 - %453 = sext i32 %451 to i64 - %454 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %453 - store float %452, ptr addrspace(3) %454, align 4 - %455 = add i32 %402, %378 - %456 = extractelement <4 x float> %315, i64 1 - %457 = sext i32 %455 to i64 - %458 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %457 - store float %456, ptr addrspace(3) %458, align 4 - %459 = add i32 %408, %378 - %460 = extractelement <4 x float> %315, i64 2 - %461 = sext i32 %459 to i64 - %462 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %461 - store float %460, ptr addrspace(3) %462, align 4 - %463 = add i32 %414, %378 - %464 = extractelement <4 x float> %315, i64 3 - %465 = sext i32 %463 to i64 - %466 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %465 - store float %464, ptr addrspace(3) %466, align 4 - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %467 = sdiv i32 %24, 32 - %468 = mul i32 %467, 32 - %469 = icmp ne i32 %24, %468 - %470 = icmp slt i32 %24, 0 - %471 = icmp ne i1 %470, false - %472 = and i1 %469, %471 - %473 = add i32 %467, -1 - %474 = select i1 %472, i32 %473, i32 %467 - %475 = srem i32 %24, 32 - %476 = mul i32 %475, 2 - %477 = addrspacecast ptr addrspace(1) %12 to ptr - %478 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %477, i16 0, i64 4294967295, i32 159744) - %479 = addrspacecast ptr addrspace(1) %14 to ptr - %480 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %479, i16 0, i64 4294967295, i32 159744) - %481 = addrspacecast ptr addrspace(1) %17 to ptr - %482 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %481, i16 0, i64 4294967295, i32 159744) - %483 = add i32 %64, %474 - %484 = mul i32 %483, 4 - %485 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %478, i32 %484, i32 0, i32 0) - %486 = and i32 %485, 16777215 - %487 = icmp slt i32 %486, %16 - %488 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %480, i32 %484, i32 0, i32 0) - br i1 %487, label %489, label %557 - -489: ; preds = %49 - %490 = mul i32 %486, 7168 - %491 = add i32 %490, %92 - %492 = add i32 %491, %476 - %493 = mul i32 %474, 256 - %494 = add i32 %493, %476 - %495 = sext i32 %494 to i64 - %496 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %495 - %497 = load float, ptr addrspace(3) %496, align 4 - %498 = fmul float %497, %488 - %499 = add i32 %494, 1 - %500 = sext i32 %499 to i64 - %501 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %500 - %502 = load float, ptr addrspace(3) %501, align 4 - %503 = fmul float %502, %488 - %504 = insertelement <2 x float> poison, float %498, i64 0 - %505 = insertelement <2 x float> %504, float %503, i64 1 - %506 = fptrunc <2 x float> %505 to <2 x bfloat> - %507 = mul i32 %492, 2 - %508 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %506, ptr addrspace(8) %482, i32 %507, i32 0, i32 0) - %509 = add i32 %494, 64 - %510 = sext i32 %509 to i64 - %511 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %510 - %512 = load float, ptr addrspace(3) %511, align 4 - %513 = fmul float %512, %488 - %514 = add i32 %494, 65 - %515 = sext i32 %514 to i64 - %516 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %515 - %517 = load float, ptr addrspace(3) %516, align 4 - %518 = fmul float %517, %488 - %519 = insertelement <2 x float> poison, float %513, i64 0 - %520 = insertelement <2 x float> %519, float %518, i64 1 - %521 = fptrunc <2 x float> %520 to <2 x bfloat> - %522 = add i32 %492, 64 - %523 = mul i32 %522, 2 - %524 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %521, ptr addrspace(8) %482, i32 %523, i32 0, i32 0) - %525 = add i32 %494, 128 - %526 = sext i32 %525 to i64 - %527 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %526 - %528 = load float, ptr addrspace(3) %527, align 4 - %529 = fmul float %528, %488 - %530 = add i32 %494, 129 - %531 = sext i32 %530 to i64 - %532 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %531 - %533 = load float, ptr addrspace(3) %532, align 4 - %534 = fmul float %533, %488 - %535 = insertelement <2 x float> poison, float %529, i64 0 - %536 = insertelement <2 x float> %535, float %534, i64 1 - %537 = fptrunc <2 x float> %536 to <2 x bfloat> - %538 = add i32 %492, 128 - %539 = mul i32 %538, 2 - %540 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %537, ptr addrspace(8) %482, i32 %539, i32 0, i32 0) - %541 = add i32 %494, 192 - %542 = sext i32 %541 to i64 - %543 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %542 - %544 = load float, ptr addrspace(3) %543, align 4 - %545 = fmul float %544, %488 - %546 = add i32 %494, 193 - %547 = sext i32 %546 to i64 - %548 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %547 - %549 = load float, ptr addrspace(3) %548, align 4 - %550 = fmul float %549, %488 - %551 = insertelement <2 x float> poison, float %545, i64 0 - %552 = insertelement <2 x float> %551, float %550, i64 1 - %553 = fptrunc <2 x float> %552 to <2 x bfloat> - %554 = add i32 %492, 192 - %555 = mul i32 %554, 2 - %556 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %553, ptr addrspace(8) %482, i32 %555, i32 0, i32 0) - br label %557 - -557: ; preds = %489, %49 - %558 = add i32 %474, 8 - %559 = add i32 %64, %558 - %560 = mul i32 %559, 4 - %561 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %478, i32 %560, i32 0, i32 0) - %562 = and i32 %561, 16777215 - %563 = icmp slt i32 %562, %16 - %564 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %480, i32 %560, i32 0, i32 0) - br i1 %563, label %565, label %633 - -565: ; preds = %557 - %566 = mul i32 %562, 7168 - %567 = add i32 %566, %92 - %568 = add i32 %567, %476 - %569 = mul i32 %558, 256 - %570 = add i32 %569, %476 - %571 = sext i32 %570 to i64 - %572 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %571 - %573 = load float, ptr addrspace(3) %572, align 4 - %574 = fmul float %573, %564 - %575 = add i32 %570, 1 - %576 = sext i32 %575 to i64 - %577 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %576 - %578 = load float, ptr addrspace(3) %577, align 4 - %579 = fmul float %578, %564 - %580 = insertelement <2 x float> poison, float %574, i64 0 - %581 = insertelement <2 x float> %580, float %579, i64 1 - %582 = fptrunc <2 x float> %581 to <2 x bfloat> - %583 = mul i32 %568, 2 - %584 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %582, ptr addrspace(8) %482, i32 %583, i32 0, i32 0) - %585 = add i32 %570, 64 - %586 = sext i32 %585 to i64 - %587 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %586 - %588 = load float, ptr addrspace(3) %587, align 4 - %589 = fmul float %588, %564 - %590 = add i32 %570, 65 - %591 = sext i32 %590 to i64 - %592 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %591 - %593 = load float, ptr addrspace(3) %592, align 4 - %594 = fmul float %593, %564 - %595 = insertelement <2 x float> poison, float %589, i64 0 - %596 = insertelement <2 x float> %595, float %594, i64 1 - %597 = fptrunc <2 x float> %596 to <2 x bfloat> - %598 = add i32 %568, 64 - %599 = mul i32 %598, 2 - %600 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %597, ptr addrspace(8) %482, i32 %599, i32 0, i32 0) - %601 = add i32 %570, 128 - %602 = sext i32 %601 to i64 - %603 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %602 - %604 = load float, ptr addrspace(3) %603, align 4 - %605 = fmul float %604, %564 - %606 = add i32 %570, 129 - %607 = sext i32 %606 to i64 - %608 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %607 - %609 = load float, ptr addrspace(3) %608, align 4 - %610 = fmul float %609, %564 - %611 = insertelement <2 x float> poison, float %605, i64 0 - %612 = insertelement <2 x float> %611, float %610, i64 1 - %613 = fptrunc <2 x float> %612 to <2 x bfloat> - %614 = add i32 %568, 128 - %615 = mul i32 %614, 2 - %616 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %613, ptr addrspace(8) %482, i32 %615, i32 0, i32 0) - %617 = add i32 %570, 192 - %618 = sext i32 %617 to i64 - %619 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %618 - %620 = load float, ptr addrspace(3) %619, align 4 - %621 = fmul float %620, %564 - %622 = add i32 %570, 193 - %623 = sext i32 %622 to i64 - %624 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %623 - %625 = load float, ptr addrspace(3) %624, align 4 - %626 = fmul float %625, %564 - %627 = insertelement <2 x float> poison, float %621, i64 0 - %628 = insertelement <2 x float> %627, float %626, i64 1 - %629 = fptrunc <2 x float> %628 to <2 x bfloat> - %630 = add i32 %568, 192 - %631 = mul i32 %630, 2 - %632 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %629, ptr addrspace(8) %482, i32 %631, i32 0, i32 0) - br label %633 - -633: ; preds = %565, %557 - %634 = add i32 %474, 16 - %635 = add i32 %64, %634 - %636 = mul i32 %635, 4 - %637 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %478, i32 %636, i32 0, i32 0) - %638 = and i32 %637, 16777215 - %639 = icmp slt i32 %638, %16 - %640 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %480, i32 %636, i32 0, i32 0) - br i1 %639, label %641, label %709 - -641: ; preds = %633 - %642 = mul i32 %638, 7168 - %643 = add i32 %642, %92 - %644 = add i32 %643, %476 - %645 = mul i32 %634, 256 - %646 = add i32 %645, %476 - %647 = sext i32 %646 to i64 - %648 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %647 - %649 = load float, ptr addrspace(3) %648, align 4 - %650 = fmul float %649, %640 - %651 = add i32 %646, 1 - %652 = sext i32 %651 to i64 - %653 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %652 - %654 = load float, ptr addrspace(3) %653, align 4 - %655 = fmul float %654, %640 - %656 = insertelement <2 x float> poison, float %650, i64 0 - %657 = insertelement <2 x float> %656, float %655, i64 1 - %658 = fptrunc <2 x float> %657 to <2 x bfloat> - %659 = mul i32 %644, 2 - %660 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %658, ptr addrspace(8) %482, i32 %659, i32 0, i32 0) - %661 = add i32 %646, 64 - %662 = sext i32 %661 to i64 - %663 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %662 - %664 = load float, ptr addrspace(3) %663, align 4 - %665 = fmul float %664, %640 - %666 = add i32 %646, 65 - %667 = sext i32 %666 to i64 - %668 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %667 - %669 = load float, ptr addrspace(3) %668, align 4 - %670 = fmul float %669, %640 - %671 = insertelement <2 x float> poison, float %665, i64 0 - %672 = insertelement <2 x float> %671, float %670, i64 1 - %673 = fptrunc <2 x float> %672 to <2 x bfloat> - %674 = add i32 %644, 64 - %675 = mul i32 %674, 2 - %676 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %673, ptr addrspace(8) %482, i32 %675, i32 0, i32 0) - %677 = add i32 %646, 128 - %678 = sext i32 %677 to i64 - %679 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %678 - %680 = load float, ptr addrspace(3) %679, align 4 - %681 = fmul float %680, %640 - %682 = add i32 %646, 129 - %683 = sext i32 %682 to i64 - %684 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %683 - %685 = load float, ptr addrspace(3) %684, align 4 - %686 = fmul float %685, %640 - %687 = insertelement <2 x float> poison, float %681, i64 0 - %688 = insertelement <2 x float> %687, float %686, i64 1 - %689 = fptrunc <2 x float> %688 to <2 x bfloat> - %690 = add i32 %644, 128 - %691 = mul i32 %690, 2 - %692 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %689, ptr addrspace(8) %482, i32 %691, i32 0, i32 0) - %693 = add i32 %646, 192 - %694 = sext i32 %693 to i64 - %695 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %694 - %696 = load float, ptr addrspace(3) %695, align 4 - %697 = fmul float %696, %640 - %698 = add i32 %646, 193 - %699 = sext i32 %698 to i64 - %700 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %699 - %701 = load float, ptr addrspace(3) %700, align 4 - %702 = fmul float %701, %640 - %703 = insertelement <2 x float> poison, float %697, i64 0 - %704 = insertelement <2 x float> %703, float %702, i64 1 - %705 = fptrunc <2 x float> %704 to <2 x bfloat> - %706 = add i32 %644, 192 - %707 = mul i32 %706, 2 - %708 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %705, ptr addrspace(8) %482, i32 %707, i32 0, i32 0) - br label %709 - -709: ; preds = %641, %633 - %710 = add i32 %474, 24 - %711 = add i32 %64, %710 - %712 = mul i32 %711, 4 - %713 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %478, i32 %712, i32 0, i32 0) - %714 = and i32 %713, 16777215 - %715 = icmp slt i32 %714, %16 - %716 = call float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) %480, i32 %712, i32 0, i32 0) - br i1 %715, label %717, label %785 - -717: ; preds = %709 - %718 = mul i32 %714, 7168 - %719 = add i32 %718, %92 - %720 = add i32 %719, %476 - %721 = mul i32 %710, 256 - %722 = add i32 %721, %476 - %723 = sext i32 %722 to i64 - %724 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %723 - %725 = load float, ptr addrspace(3) %724, align 4 - %726 = fmul float %725, %716 - %727 = add i32 %722, 1 - %728 = sext i32 %727 to i64 - %729 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %728 - %730 = load float, ptr addrspace(3) %729, align 4 - %731 = fmul float %730, %716 - %732 = insertelement <2 x float> poison, float %726, i64 0 - %733 = insertelement <2 x float> %732, float %731, i64 1 - %734 = fptrunc <2 x float> %733 to <2 x bfloat> - %735 = mul i32 %720, 2 - %736 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %734, ptr addrspace(8) %482, i32 %735, i32 0, i32 0) - %737 = add i32 %722, 64 - %738 = sext i32 %737 to i64 - %739 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %738 - %740 = load float, ptr addrspace(3) %739, align 4 - %741 = fmul float %740, %716 - %742 = add i32 %722, 65 - %743 = sext i32 %742 to i64 - %744 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %743 - %745 = load float, ptr addrspace(3) %744, align 4 - %746 = fmul float %745, %716 - %747 = insertelement <2 x float> poison, float %741, i64 0 - %748 = insertelement <2 x float> %747, float %746, i64 1 - %749 = fptrunc <2 x float> %748 to <2 x bfloat> - %750 = add i32 %720, 64 - %751 = mul i32 %750, 2 - %752 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %749, ptr addrspace(8) %482, i32 %751, i32 0, i32 0) - %753 = add i32 %722, 128 - %754 = sext i32 %753 to i64 - %755 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %754 - %756 = load float, ptr addrspace(3) %755, align 4 - %757 = fmul float %756, %716 - %758 = add i32 %722, 129 - %759 = sext i32 %758 to i64 - %760 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %759 - %761 = load float, ptr addrspace(3) %760, align 4 - %762 = fmul float %761, %716 - %763 = insertelement <2 x float> poison, float %757, i64 0 - %764 = insertelement <2 x float> %763, float %762, i64 1 - %765 = fptrunc <2 x float> %764 to <2 x bfloat> - %766 = add i32 %720, 128 - %767 = mul i32 %766, 2 - %768 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %765, ptr addrspace(8) %482, i32 %767, i32 0, i32 0) - %769 = add i32 %722, 192 - %770 = sext i32 %769 to i64 - %771 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %770 - %772 = load float, ptr addrspace(3) %771, align 4 - %773 = fmul float %772, %716 - %774 = add i32 %722, 193 - %775 = sext i32 %774 to i64 - %776 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %775 - %777 = load float, ptr addrspace(3) %776, align 4 - %778 = fmul float %777, %716 - %779 = insertelement <2 x float> poison, float %773, i64 0 - %780 = insertelement <2 x float> %779, float %778, i64 1 - %781 = fptrunc <2 x float> %780 to <2 x bfloat> - %782 = add i32 %720, 192 - %783 = mul i32 %782, 2 - %784 = call <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat> %781, ptr addrspace(8) %482, i32 %783, i32 0, i32 0) - br label %785 - -785: ; preds = %717, %709 - br label %786 - -786: ; preds = %785, %19 - ret void -} - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) -declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 - -; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) -declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #3 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #4 - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #5 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.sched.barrier(i32 immarg) #6 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #4 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.s.barrier() #6 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) -declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #7 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare float @llvm.amdgcn.raw.ptr.buffer.load.f32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #4 - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare <2 x bfloat> @llvm.amdgcn.raw.ptr.buffer.atomic.fadd.v2bf16(<2 x bfloat>, ptr addrspace(8) captures(none), i32, i32, i32 immarg) #5 - -attributes #0 = { "amdgpu-flat-work-group-size"="256,256" "uniform-work-group-size" } -attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } -attributes #2 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } -attributes #3 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } -attributes #4 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } -attributes #5 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } -attributes #6 = { convergent nocallback nofree nounwind willreturn } -attributes #7 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} -!1 = !{i32 256, i32 1, i32 1} diff --git a/kernels/gemm2_port_ref/flydsl_port_v2.ll b/kernels/gemm2_port_ref/flydsl_port_v2.ll deleted file mode 100644 index 1e0f7dce1..000000000 --- a/kernels/gemm2_port_ref/flydsl_port_v2.ll +++ /dev/null @@ -1,956 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" -target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" - -@gemm2port_smem = external addrspace(3) global [32768 x i8], align 1024 - -define amdgpu_kernel void @gemm2_a4w4_port_bm32_atomic(ptr addrspace(1) %0, <{ <{ i32, i32 }>, <{ i64 }> }> %1, ptr addrspace(1) %2, <{ <{ i32, i32 }>, <{ i64 }> }> %3, ptr addrspace(1) %4, <{ <{ i32, i32, i32 }>, <{ i64, i64 }> }> %5, ptr addrspace(1) %6, <{ <{ i32, i32 }>, <{ i64 }> }> %7, ptr addrspace(1) %8, <{ <{ i32 }> }> %9, ptr addrspace(1) %10, <{ <{ i32 }> }> %11, ptr addrspace(1) %12, <{ <{ i32 }> }> %13, ptr addrspace(1) %14, <{ <{ i32 }> }> %15, i32 %16, ptr addrspace(1) %17, <{ <{ i32, i32 }>, <{ i64 }> }> %18) #0 !reqd_work_group_size !1 { - %20 = call range(i32 0, 256) i32 @llvm.amdgcn.workitem.id.x() - %21 = sext i32 %20 to i64 - %22 = call i32 @llvm.amdgcn.workgroup.id.x() - %23 = sext i32 %22 to i64 - %24 = trunc i64 %21 to i32 - %25 = trunc i64 %23 to i32 - %26 = srem i32 %24, 64 - %27 = sdiv i32 %24, 64 - %28 = mul i32 %27, 64 - %29 = icmp ne i32 %24, %28 - %30 = icmp slt i32 %24, 0 - %31 = icmp ne i1 %30, false - %32 = and i1 %29, %31 - %33 = add i32 %27, -1 - %34 = select i1 %32, i32 %33, i32 %27 - %35 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %34) - %36 = ptrtoint ptr addrspace(1) %10 to i64 - %37 = inttoptr i64 %36 to ptr addrspace(1) - %38 = load i32, ptr addrspace(1) %37, align 4 - %39 = sdiv i32 %38, 32 - %40 = mul i32 %39, 32 - %41 = icmp ne i32 %38, %40 - %42 = icmp slt i32 %38, 0 - %43 = icmp ne i1 %42, false - %44 = and i1 %41, %43 - %45 = add i32 %39, -1 - %46 = select i1 %44, i32 %45, i32 %39 - %47 = mul i32 %46, 28 - %48 = icmp slt i32 %25, %47 - br i1 %48, label %49, label %856 - -49: ; preds = %19 - %50 = srem i32 %25, 28 - %51 = sdiv i32 %25, 28 - %52 = mul i32 %51, 28 - %53 = icmp ne i32 %25, %52 - %54 = icmp slt i32 %25, 0 - %55 = icmp ne i1 %54, false - %56 = and i1 %53, %55 - %57 = add i32 %51, -1 - %58 = select i1 %56, i32 %57, i32 %51 - %59 = mul i32 %58, 4 - %60 = ptrtoint ptr addrspace(1) %8 to i64 - %61 = sext i32 %59 to i64 - %62 = add i64 %60, %61 - %63 = inttoptr i64 %62 to ptr addrspace(1) - %64 = load i32, ptr addrspace(1) %63, align 4 - %65 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %64) - %66 = mul i32 %58, 32 - %67 = addrspacecast ptr addrspace(1) %0 to ptr - %68 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %67, i16 0, i64 167772160, i32 159744) - %69 = addrspacecast ptr addrspace(1) %2 to ptr - %70 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %69, i16 0, i64 10485760, i32 159744) - %71 = addrspacecast ptr addrspace(1) %4 to ptr - %72 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %71, i16 0, i64 706478080, i32 159744) - %73 = addrspacecast ptr addrspace(1) %6 to ptr - %74 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %73, i16 0, i64 44154880, i32 159744) - %75 = sdiv i32 %26, 8 - %76 = mul i32 %75, 8 - %77 = icmp ne i32 %26, %76 - %78 = icmp slt i32 %26, 0 - %79 = icmp ne i1 %78, false - %80 = and i1 %77, %79 - %81 = add i32 %75, -1 - %82 = select i1 %80, i32 %81, i32 %75 - %83 = srem i32 %26, 8 - %84 = sdiv i32 %26, 16 - %85 = mul i32 %84, 16 - %86 = icmp ne i32 %26, %85 - %87 = icmp slt i32 %26, 0 - %88 = icmp ne i1 %87, false - %89 = and i1 %86, %88 - %90 = add i32 %84, -1 - %91 = select i1 %89, i32 %90, i32 %84 - %92 = srem i32 %26, 16 - %93 = mul i32 %65, 7168 - %94 = mul i32 %50, 256 - %95 = add i32 %93, %94 - %96 = mul i32 %35, 64 - %97 = add i32 %95, %96 - %98 = mul i32 %97, 256 - %99 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %98) - %100 = add i32 %97, 16 - %101 = mul i32 %100, 256 - %102 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %101) - %103 = add i32 %97, 32 - %104 = mul i32 %103, 256 - %105 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %104) - %106 = add i32 %97, 48 - %107 = mul i32 %106, 256 - %108 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %107) - %109 = mul i32 %50, 8 - %110 = mul i32 %35, 2 - %111 = add i32 %109, %110 - %112 = mul i32 %65, 28672 - %113 = mul i32 %111, 128 - %114 = add i32 %112, %113 - %115 = mul i32 %114, 4 - %116 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %115) - %117 = add i32 %111, 1 - %118 = mul i32 %117, 128 - %119 = add i32 %112, %118 - %120 = mul i32 %119, 4 - %121 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %120) - %122 = sdiv i32 %66, 32 - %123 = mul i32 %122, 32 - %124 = icmp ne i32 %66, %123 - %125 = icmp slt i32 %66, 0 - %126 = icmp ne i1 %125, false - %127 = and i1 %124, %126 - %128 = add i32 %122, -1 - %129 = select i1 %127, i32 %128, i32 %122 - %130 = mul i32 %129, 512 - %131 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %130) - %132 = mul i32 %35, 8 - %133 = add i32 %66, %132 - %134 = add i32 %133, %82 - %135 = add i32 %132, %82 - %136 = and i32 %135, 14 - %137 = shl i32 %136, 3 - %138 = mul i32 %83, 16 - %139 = xor i32 %138, %137 - %140 = mul i32 %134, 256 - %141 = add i32 %139, %140 - %142 = mul i32 %35, 1024 - %143 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %142 - %144 = sext i32 %143 to i64 - %145 = inttoptr i64 %144 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %68, ptr addrspace(3) %145, i32 16, i32 %141, i32 0, i32 0, i32 0) - %146 = add i32 %142, 4096 - %147 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %146 - %148 = sext i32 %147 to i64 - %149 = inttoptr i64 %148 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %68, ptr addrspace(3) %149, i32 16, i32 %141, i32 128, i32 0, i32 0) - call void @llvm.amdgcn.sched.barrier(i32 0) - %150 = mul i32 %91, 16 - %151 = add i32 %150, %92 - %152 = mul i32 %151, 4 - %153 = sdiv i32 %152, 4 - %154 = mul i32 %153, 4 - %155 = icmp ne i32 %152, %154 - %156 = icmp slt i32 %152, 0 - %157 = icmp ne i1 %156, false - %158 = and i1 %155, %157 - %159 = add i32 %153, -1 - %160 = select i1 %158, i32 %159, i32 %153 - %161 = mul i32 %160, 4 - %162 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %70, i32 %161, i32 %131, i32 0) - %163 = add i32 %152, 256 - %164 = sdiv i32 %163, 4 - %165 = mul i32 %164, 4 - %166 = icmp ne i32 %163, %165 - %167 = icmp slt i32 %163, 0 - %168 = icmp ne i1 %167, false - %169 = and i1 %166, %168 - %170 = add i32 %164, -1 - %171 = select i1 %169, i32 %170, i32 %164 - %172 = mul i32 %171, 4 - %173 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %70, i32 %172, i32 %131, i32 0) - %174 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %161, i32 %116, i32 0) - %175 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %161, i32 %121, i32 0) - %176 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %172, i32 %116, i32 0) - %177 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %172, i32 %121, i32 0) - %178 = mul i32 %91, 256 - %179 = mul i32 %92, 16 - %180 = add i32 %178, %179 - %181 = sdiv i32 %180, 4 - %182 = mul i32 %181, 4 - %183 = icmp ne i32 %180, %182 - %184 = icmp slt i32 %180, 0 - %185 = icmp ne i1 %184, false - %186 = and i1 %183, %185 - %187 = add i32 %181, -1 - %188 = select i1 %186, i32 %187, i32 %181 - %189 = mul i32 %188, 4 - %190 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %99, i32 0) - %191 = add i32 %180, 1024 - %192 = sdiv i32 %191, 4 - %193 = mul i32 %192, 4 - %194 = icmp ne i32 %191, %193 - %195 = icmp slt i32 %191, 0 - %196 = icmp ne i1 %195, false - %197 = and i1 %194, %196 - %198 = add i32 %192, -1 - %199 = select i1 %197, i32 %198, i32 %192 - %200 = mul i32 %199, 4 - %201 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %99, i32 0) - %202 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %102, i32 0) - %203 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %102, i32 0) - %204 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %105, i32 0) - %205 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %105, i32 0) - %206 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %108, i32 0) - %207 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %108, i32 0) - %208 = add i32 %180, 2048 - %209 = sdiv i32 %208, 4 - %210 = mul i32 %209, 4 - %211 = icmp ne i32 %208, %210 - %212 = icmp slt i32 %208, 0 - %213 = icmp ne i1 %212, false - %214 = and i1 %211, %213 - %215 = add i32 %209, -1 - %216 = select i1 %214, i32 %215, i32 %209 - %217 = mul i32 %216, 4 - %218 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %99, i32 0) - %219 = add i32 %180, 3072 - %220 = sdiv i32 %219, 4 - %221 = mul i32 %220, 4 - %222 = icmp ne i32 %219, %221 - %223 = icmp slt i32 %219, 0 - %224 = icmp ne i1 %223, false - %225 = and i1 %222, %224 - %226 = add i32 %220, -1 - %227 = select i1 %225, i32 %226, i32 %220 - %228 = mul i32 %227, 4 - %229 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %99, i32 0) - %230 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %102, i32 0) - %231 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %102, i32 0) - %232 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %105, i32 0) - %233 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %105, i32 0) - %234 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %108, i32 0) - %235 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %108, i32 0) - call void asm sideeffect "s_waitcnt vmcnt(23)", ""() - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %236 = and i32 %92, 14 - %237 = shl i32 %236, 3 - %238 = xor i32 %150, %237 - %239 = mul i32 %92, 128 - %240 = add i32 %239, %238 - %241 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %240 - %242 = sext i32 %241 to i64 - %243 = inttoptr i64 %242 to ptr addrspace(3) - %244 = load <4 x i32>, ptr addrspace(3) %243, align 16 - %245 = add i32 %92, 16 - %246 = mul i32 %245, 128 - %247 = add i32 %246, %238 - %248 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %247 - %249 = sext i32 %248 to i64 - %250 = inttoptr i64 %249 to ptr addrspace(3) - %251 = load <4 x i32>, ptr addrspace(3) %250, align 16 - %252 = add i32 %150, 64 - %253 = xor i32 %252, %237 - %254 = add i32 %239, %253 - %255 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %254 - %256 = sext i32 %255 to i64 - %257 = inttoptr i64 %256 to ptr addrspace(3) - %258 = load <4 x i32>, ptr addrspace(3) %257, align 16 - %259 = add i32 %246, %253 - %260 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %259 - %261 = sext i32 %260 to i64 - %262 = inttoptr i64 %261 to ptr addrspace(3) - %263 = load <4 x i32>, ptr addrspace(3) %262, align 16 - %264 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %190, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 0, i32 %174) - %265 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %190, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 0, i32 %174) - %266 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %201, <4 x float> %264, i32 4, i32 4, i32 2, i32 %162, i32 2, i32 %174) - %267 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %201, <4 x float> %265, i32 4, i32 4, i32 3, i32 %162, i32 2, i32 %174) - %268 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 1, i32 %174) - %269 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 1, i32 %174) - %270 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %203, <4 x float> %268, i32 4, i32 4, i32 2, i32 %162, i32 3, i32 %174) - %271 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %203, <4 x float> %269, i32 4, i32 4, i32 3, i32 %162, i32 3, i32 %174) - %272 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 0, i32 %175) - %273 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 0, i32 %175) - %274 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %205, <4 x float> %272, i32 4, i32 4, i32 2, i32 %162, i32 2, i32 %175) - %275 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %205, <4 x float> %273, i32 4, i32 4, i32 3, i32 %162, i32 2, i32 %175) - %276 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %206, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 1, i32 %175) - %277 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %206, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 1, i32 %175) - %278 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %207, <4 x float> %276, i32 4, i32 4, i32 2, i32 %162, i32 3, i32 %175) - %279 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %207, <4 x float> %277, i32 4, i32 4, i32 3, i32 %162, i32 3, i32 %175) - call void asm sideeffect "s_waitcnt vmcnt(22)", ""() - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %280 = add i32 %239, 4096 - %281 = add i32 %280, %238 - %282 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %281 - %283 = sext i32 %282 to i64 - %284 = inttoptr i64 %283 to ptr addrspace(3) - %285 = load <4 x i32>, ptr addrspace(3) %284, align 16 - %286 = add i32 %246, 4096 - %287 = add i32 %286, %238 - %288 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %287 - %289 = sext i32 %288 to i64 - %290 = inttoptr i64 %289 to ptr addrspace(3) - %291 = load <4 x i32>, ptr addrspace(3) %290, align 16 - %292 = add i32 %280, %253 - %293 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %292 - %294 = sext i32 %293 to i64 - %295 = inttoptr i64 %294 to ptr addrspace(3) - %296 = load <4 x i32>, ptr addrspace(3) %295, align 16 - %297 = add i32 %286, %253 - %298 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %297 - %299 = sext i32 %298 to i64 - %300 = inttoptr i64 %299 to ptr addrspace(3) - %301 = load <4 x i32>, ptr addrspace(3) %300, align 16 - %302 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %218, <4 x float> %266, i32 4, i32 4, i32 0, i32 %173, i32 0, i32 %176) - %303 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %218, <4 x float> %267, i32 4, i32 4, i32 1, i32 %173, i32 0, i32 %176) - %304 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %229, <4 x float> %302, i32 4, i32 4, i32 2, i32 %173, i32 2, i32 %176) - %305 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %229, <4 x float> %303, i32 4, i32 4, i32 3, i32 %173, i32 2, i32 %176) - %306 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %230, <4 x float> %270, i32 4, i32 4, i32 0, i32 %173, i32 1, i32 %176) - %307 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %230, <4 x float> %271, i32 4, i32 4, i32 1, i32 %173, i32 1, i32 %176) - %308 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %231, <4 x float> %306, i32 4, i32 4, i32 2, i32 %173, i32 3, i32 %176) - %309 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %231, <4 x float> %307, i32 4, i32 4, i32 3, i32 %173, i32 3, i32 %176) - %310 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %232, <4 x float> %274, i32 4, i32 4, i32 0, i32 %173, i32 0, i32 %177) - %311 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %232, <4 x float> %275, i32 4, i32 4, i32 1, i32 %173, i32 0, i32 %177) - %312 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %233, <4 x float> %310, i32 4, i32 4, i32 2, i32 %173, i32 2, i32 %177) - %313 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %233, <4 x float> %311, i32 4, i32 4, i32 3, i32 %173, i32 2, i32 %177) - %314 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %234, <4 x float> %278, i32 4, i32 4, i32 0, i32 %173, i32 1, i32 %177) - %315 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %234, <4 x float> %279, i32 4, i32 4, i32 1, i32 %173, i32 1, i32 %177) - %316 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %235, <4 x float> %314, i32 4, i32 4, i32 2, i32 %173, i32 3, i32 %177) - %317 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %235, <4 x float> %315, i32 4, i32 4, i32 3, i32 %173, i32 3, i32 %177) - %318 = mul i32 %91, 4 - %319 = add i32 %96, %92 - %320 = mul i32 %91, 1024 - %321 = add i32 %320, %319 - %322 = extractelement <4 x float> %304, i64 0 - %323 = sext i32 %321 to i64 - %324 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %323 - store float %322, ptr addrspace(3) %324, align 4 - %325 = add i32 %318, 1 - %326 = mul i32 %325, 256 - %327 = add i32 %326, %319 - %328 = extractelement <4 x float> %304, i64 1 - %329 = sext i32 %327 to i64 - %330 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %329 - store float %328, ptr addrspace(3) %330, align 4 - %331 = add i32 %318, 2 - %332 = mul i32 %331, 256 - %333 = add i32 %332, %319 - %334 = extractelement <4 x float> %304, i64 2 - %335 = sext i32 %333 to i64 - %336 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %335 - store float %334, ptr addrspace(3) %336, align 4 - %337 = add i32 %318, 3 - %338 = mul i32 %337, 256 - %339 = add i32 %338, %319 - %340 = extractelement <4 x float> %304, i64 3 - %341 = sext i32 %339 to i64 - %342 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %341 - store float %340, ptr addrspace(3) %342, align 4 - %343 = add i32 %96, 16 - %344 = add i32 %343, %92 - %345 = add i32 %320, %344 - %346 = extractelement <4 x float> %308, i64 0 - %347 = sext i32 %345 to i64 - %348 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %347 - store float %346, ptr addrspace(3) %348, align 4 - %349 = add i32 %326, %344 - %350 = extractelement <4 x float> %308, i64 1 - %351 = sext i32 %349 to i64 - %352 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %351 - store float %350, ptr addrspace(3) %352, align 4 - %353 = add i32 %332, %344 - %354 = extractelement <4 x float> %308, i64 2 - %355 = sext i32 %353 to i64 - %356 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %355 - store float %354, ptr addrspace(3) %356, align 4 - %357 = add i32 %338, %344 - %358 = extractelement <4 x float> %308, i64 3 - %359 = sext i32 %357 to i64 - %360 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %359 - store float %358, ptr addrspace(3) %360, align 4 - %361 = add i32 %96, 32 - %362 = add i32 %361, %92 - %363 = add i32 %320, %362 - %364 = extractelement <4 x float> %312, i64 0 - %365 = sext i32 %363 to i64 - %366 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %365 - store float %364, ptr addrspace(3) %366, align 4 - %367 = add i32 %326, %362 - %368 = extractelement <4 x float> %312, i64 1 - %369 = sext i32 %367 to i64 - %370 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %369 - store float %368, ptr addrspace(3) %370, align 4 - %371 = add i32 %332, %362 - %372 = extractelement <4 x float> %312, i64 2 - %373 = sext i32 %371 to i64 - %374 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %373 - store float %372, ptr addrspace(3) %374, align 4 - %375 = add i32 %338, %362 - %376 = extractelement <4 x float> %312, i64 3 - %377 = sext i32 %375 to i64 - %378 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %377 - store float %376, ptr addrspace(3) %378, align 4 - %379 = add i32 %96, 48 - %380 = add i32 %379, %92 - %381 = add i32 %320, %380 - %382 = extractelement <4 x float> %316, i64 0 - %383 = sext i32 %381 to i64 - %384 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %383 - store float %382, ptr addrspace(3) %384, align 4 - %385 = add i32 %326, %380 - %386 = extractelement <4 x float> %316, i64 1 - %387 = sext i32 %385 to i64 - %388 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %387 - store float %386, ptr addrspace(3) %388, align 4 - %389 = add i32 %332, %380 - %390 = extractelement <4 x float> %316, i64 2 - %391 = sext i32 %389 to i64 - %392 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %391 - store float %390, ptr addrspace(3) %392, align 4 - %393 = add i32 %338, %380 - %394 = extractelement <4 x float> %316, i64 3 - %395 = sext i32 %393 to i64 - %396 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %395 - store float %394, ptr addrspace(3) %396, align 4 - %397 = add i32 %318, 16 - %398 = mul i32 %397, 256 - %399 = add i32 %398, %319 - %400 = extractelement <4 x float> %305, i64 0 - %401 = sext i32 %399 to i64 - %402 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %401 - store float %400, ptr addrspace(3) %402, align 4 - %403 = add i32 %318, 17 - %404 = mul i32 %403, 256 - %405 = add i32 %404, %319 - %406 = extractelement <4 x float> %305, i64 1 - %407 = sext i32 %405 to i64 - %408 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %407 - store float %406, ptr addrspace(3) %408, align 4 - %409 = add i32 %318, 18 - %410 = mul i32 %409, 256 - %411 = add i32 %410, %319 - %412 = extractelement <4 x float> %305, i64 2 - %413 = sext i32 %411 to i64 - %414 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %413 - store float %412, ptr addrspace(3) %414, align 4 - %415 = add i32 %318, 19 - %416 = mul i32 %415, 256 - %417 = add i32 %416, %319 - %418 = extractelement <4 x float> %305, i64 3 - %419 = sext i32 %417 to i64 - %420 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %419 - store float %418, ptr addrspace(3) %420, align 4 - %421 = add i32 %398, %344 - %422 = extractelement <4 x float> %309, i64 0 - %423 = sext i32 %421 to i64 - %424 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %423 - store float %422, ptr addrspace(3) %424, align 4 - %425 = add i32 %404, %344 - %426 = extractelement <4 x float> %309, i64 1 - %427 = sext i32 %425 to i64 - %428 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %427 - store float %426, ptr addrspace(3) %428, align 4 - %429 = add i32 %410, %344 - %430 = extractelement <4 x float> %309, i64 2 - %431 = sext i32 %429 to i64 - %432 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %431 - store float %430, ptr addrspace(3) %432, align 4 - %433 = add i32 %416, %344 - %434 = extractelement <4 x float> %309, i64 3 - %435 = sext i32 %433 to i64 - %436 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %435 - store float %434, ptr addrspace(3) %436, align 4 - %437 = add i32 %398, %362 - %438 = extractelement <4 x float> %313, i64 0 - %439 = sext i32 %437 to i64 - %440 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %439 - store float %438, ptr addrspace(3) %440, align 4 - %441 = add i32 %404, %362 - %442 = extractelement <4 x float> %313, i64 1 - %443 = sext i32 %441 to i64 - %444 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %443 - store float %442, ptr addrspace(3) %444, align 4 - %445 = add i32 %410, %362 - %446 = extractelement <4 x float> %313, i64 2 - %447 = sext i32 %445 to i64 - %448 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %447 - store float %446, ptr addrspace(3) %448, align 4 - %449 = add i32 %416, %362 - %450 = extractelement <4 x float> %313, i64 3 - %451 = sext i32 %449 to i64 - %452 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %451 - store float %450, ptr addrspace(3) %452, align 4 - %453 = add i32 %398, %380 - %454 = extractelement <4 x float> %317, i64 0 - %455 = sext i32 %453 to i64 - %456 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %455 - store float %454, ptr addrspace(3) %456, align 4 - %457 = add i32 %404, %380 - %458 = extractelement <4 x float> %317, i64 1 - %459 = sext i32 %457 to i64 - %460 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %459 - store float %458, ptr addrspace(3) %460, align 4 - %461 = add i32 %410, %380 - %462 = extractelement <4 x float> %317, i64 2 - %463 = sext i32 %461 to i64 - %464 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %463 - store float %462, ptr addrspace(3) %464, align 4 - %465 = add i32 %416, %380 - %466 = extractelement <4 x float> %317, i64 3 - %467 = sext i32 %465 to i64 - %468 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %467 - store float %466, ptr addrspace(3) %468, align 4 - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %469 = sdiv i32 %24, 32 - %470 = mul i32 %469, 32 - %471 = icmp ne i32 %24, %470 - %472 = icmp slt i32 %24, 0 - %473 = icmp ne i1 %472, false - %474 = and i1 %471, %473 - %475 = add i32 %469, -1 - %476 = select i1 %474, i32 %475, i32 %469 - %477 = srem i32 %24, 32 - %478 = mul i32 %477, 2 - %479 = add i32 %66, %476 - %480 = mul i32 %479, 4 - %481 = ptrtoint ptr addrspace(1) %12 to i64 - %482 = sext i32 %480 to i64 - %483 = add i64 %481, %482 - %484 = inttoptr i64 %483 to ptr addrspace(1) - %485 = load i32, ptr addrspace(1) %484, align 4 - %486 = and i32 %485, 16777215 - %487 = icmp slt i32 %486, %16 - %488 = ptrtoint ptr addrspace(1) %14 to i64 - %489 = add i64 %488, %482 - %490 = inttoptr i64 %489 to ptr addrspace(1) - %491 = load float, ptr addrspace(1) %490, align 4 - br i1 %487, label %492, label %573 - -492: ; preds = %49 - %493 = mul i32 %486, 7168 - %494 = add i32 %493, %94 - %495 = add i32 %494, %478 - %496 = mul i32 %476, 256 - %497 = add i32 %496, %478 - %498 = sext i32 %497 to i64 - %499 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %498 - %500 = load float, ptr addrspace(3) %499, align 4 - %501 = fmul float %500, %491 - %502 = add i32 %497, 1 - %503 = sext i32 %502 to i64 - %504 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %503 - %505 = load float, ptr addrspace(3) %504, align 4 - %506 = fmul float %505, %491 - %507 = insertelement <2 x float> poison, float %501, i64 0 - %508 = insertelement <2 x float> %507, float %506, i64 1 - %509 = fptrunc <2 x float> %508 to <2 x bfloat> - %510 = mul i32 %495, 2 - %511 = ptrtoint ptr addrspace(1) %17 to i64 - %512 = sext i32 %510 to i64 - %513 = add i64 %511, %512 - %514 = inttoptr i64 %513 to ptr addrspace(1) - %515 = atomicrmw fadd ptr addrspace(1) %514, <2 x bfloat> %509 syncscope("agent") monotonic, align 4 - %516 = add i32 %497, 64 - %517 = sext i32 %516 to i64 - %518 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %517 - %519 = load float, ptr addrspace(3) %518, align 4 - %520 = fmul float %519, %491 - %521 = add i32 %497, 65 - %522 = sext i32 %521 to i64 - %523 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %522 - %524 = load float, ptr addrspace(3) %523, align 4 - %525 = fmul float %524, %491 - %526 = insertelement <2 x float> poison, float %520, i64 0 - %527 = insertelement <2 x float> %526, float %525, i64 1 - %528 = fptrunc <2 x float> %527 to <2 x bfloat> - %529 = add i32 %495, 64 - %530 = mul i32 %529, 2 - %531 = sext i32 %530 to i64 - %532 = add i64 %511, %531 - %533 = inttoptr i64 %532 to ptr addrspace(1) - %534 = atomicrmw fadd ptr addrspace(1) %533, <2 x bfloat> %528 syncscope("agent") monotonic, align 4 - %535 = add i32 %497, 128 - %536 = sext i32 %535 to i64 - %537 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %536 - %538 = load float, ptr addrspace(3) %537, align 4 - %539 = fmul float %538, %491 - %540 = add i32 %497, 129 - %541 = sext i32 %540 to i64 - %542 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %541 - %543 = load float, ptr addrspace(3) %542, align 4 - %544 = fmul float %543, %491 - %545 = insertelement <2 x float> poison, float %539, i64 0 - %546 = insertelement <2 x float> %545, float %544, i64 1 - %547 = fptrunc <2 x float> %546 to <2 x bfloat> - %548 = add i32 %495, 128 - %549 = mul i32 %548, 2 - %550 = sext i32 %549 to i64 - %551 = add i64 %511, %550 - %552 = inttoptr i64 %551 to ptr addrspace(1) - %553 = atomicrmw fadd ptr addrspace(1) %552, <2 x bfloat> %547 syncscope("agent") monotonic, align 4 - %554 = add i32 %497, 192 - %555 = sext i32 %554 to i64 - %556 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %555 - %557 = load float, ptr addrspace(3) %556, align 4 - %558 = fmul float %557, %491 - %559 = add i32 %497, 193 - %560 = sext i32 %559 to i64 - %561 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %560 - %562 = load float, ptr addrspace(3) %561, align 4 - %563 = fmul float %562, %491 - %564 = insertelement <2 x float> poison, float %558, i64 0 - %565 = insertelement <2 x float> %564, float %563, i64 1 - %566 = fptrunc <2 x float> %565 to <2 x bfloat> - %567 = add i32 %495, 192 - %568 = mul i32 %567, 2 - %569 = sext i32 %568 to i64 - %570 = add i64 %511, %569 - %571 = inttoptr i64 %570 to ptr addrspace(1) - %572 = atomicrmw fadd ptr addrspace(1) %571, <2 x bfloat> %566 syncscope("agent") monotonic, align 4 - br label %573 - -573: ; preds = %492, %49 - %574 = add i32 %476, 8 - %575 = add i32 %66, %574 - %576 = mul i32 %575, 4 - %577 = sext i32 %576 to i64 - %578 = add i64 %481, %577 - %579 = inttoptr i64 %578 to ptr addrspace(1) - %580 = load i32, ptr addrspace(1) %579, align 4 - %581 = and i32 %580, 16777215 - %582 = icmp slt i32 %581, %16 - %583 = add i64 %488, %577 - %584 = inttoptr i64 %583 to ptr addrspace(1) - %585 = load float, ptr addrspace(1) %584, align 4 - br i1 %582, label %586, label %667 - -586: ; preds = %573 - %587 = mul i32 %581, 7168 - %588 = add i32 %587, %94 - %589 = add i32 %588, %478 - %590 = mul i32 %574, 256 - %591 = add i32 %590, %478 - %592 = sext i32 %591 to i64 - %593 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %592 - %594 = load float, ptr addrspace(3) %593, align 4 - %595 = fmul float %594, %585 - %596 = add i32 %591, 1 - %597 = sext i32 %596 to i64 - %598 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %597 - %599 = load float, ptr addrspace(3) %598, align 4 - %600 = fmul float %599, %585 - %601 = insertelement <2 x float> poison, float %595, i64 0 - %602 = insertelement <2 x float> %601, float %600, i64 1 - %603 = fptrunc <2 x float> %602 to <2 x bfloat> - %604 = mul i32 %589, 2 - %605 = ptrtoint ptr addrspace(1) %17 to i64 - %606 = sext i32 %604 to i64 - %607 = add i64 %605, %606 - %608 = inttoptr i64 %607 to ptr addrspace(1) - %609 = atomicrmw fadd ptr addrspace(1) %608, <2 x bfloat> %603 syncscope("agent") monotonic, align 4 - %610 = add i32 %591, 64 - %611 = sext i32 %610 to i64 - %612 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %611 - %613 = load float, ptr addrspace(3) %612, align 4 - %614 = fmul float %613, %585 - %615 = add i32 %591, 65 - %616 = sext i32 %615 to i64 - %617 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %616 - %618 = load float, ptr addrspace(3) %617, align 4 - %619 = fmul float %618, %585 - %620 = insertelement <2 x float> poison, float %614, i64 0 - %621 = insertelement <2 x float> %620, float %619, i64 1 - %622 = fptrunc <2 x float> %621 to <2 x bfloat> - %623 = add i32 %589, 64 - %624 = mul i32 %623, 2 - %625 = sext i32 %624 to i64 - %626 = add i64 %605, %625 - %627 = inttoptr i64 %626 to ptr addrspace(1) - %628 = atomicrmw fadd ptr addrspace(1) %627, <2 x bfloat> %622 syncscope("agent") monotonic, align 4 - %629 = add i32 %591, 128 - %630 = sext i32 %629 to i64 - %631 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %630 - %632 = load float, ptr addrspace(3) %631, align 4 - %633 = fmul float %632, %585 - %634 = add i32 %591, 129 - %635 = sext i32 %634 to i64 - %636 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %635 - %637 = load float, ptr addrspace(3) %636, align 4 - %638 = fmul float %637, %585 - %639 = insertelement <2 x float> poison, float %633, i64 0 - %640 = insertelement <2 x float> %639, float %638, i64 1 - %641 = fptrunc <2 x float> %640 to <2 x bfloat> - %642 = add i32 %589, 128 - %643 = mul i32 %642, 2 - %644 = sext i32 %643 to i64 - %645 = add i64 %605, %644 - %646 = inttoptr i64 %645 to ptr addrspace(1) - %647 = atomicrmw fadd ptr addrspace(1) %646, <2 x bfloat> %641 syncscope("agent") monotonic, align 4 - %648 = add i32 %591, 192 - %649 = sext i32 %648 to i64 - %650 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %649 - %651 = load float, ptr addrspace(3) %650, align 4 - %652 = fmul float %651, %585 - %653 = add i32 %591, 193 - %654 = sext i32 %653 to i64 - %655 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %654 - %656 = load float, ptr addrspace(3) %655, align 4 - %657 = fmul float %656, %585 - %658 = insertelement <2 x float> poison, float %652, i64 0 - %659 = insertelement <2 x float> %658, float %657, i64 1 - %660 = fptrunc <2 x float> %659 to <2 x bfloat> - %661 = add i32 %589, 192 - %662 = mul i32 %661, 2 - %663 = sext i32 %662 to i64 - %664 = add i64 %605, %663 - %665 = inttoptr i64 %664 to ptr addrspace(1) - %666 = atomicrmw fadd ptr addrspace(1) %665, <2 x bfloat> %660 syncscope("agent") monotonic, align 4 - br label %667 - -667: ; preds = %586, %573 - %668 = add i32 %476, 16 - %669 = add i32 %66, %668 - %670 = mul i32 %669, 4 - %671 = sext i32 %670 to i64 - %672 = add i64 %481, %671 - %673 = inttoptr i64 %672 to ptr addrspace(1) - %674 = load i32, ptr addrspace(1) %673, align 4 - %675 = and i32 %674, 16777215 - %676 = icmp slt i32 %675, %16 - %677 = add i64 %488, %671 - %678 = inttoptr i64 %677 to ptr addrspace(1) - %679 = load float, ptr addrspace(1) %678, align 4 - br i1 %676, label %680, label %761 - -680: ; preds = %667 - %681 = mul i32 %675, 7168 - %682 = add i32 %681, %94 - %683 = add i32 %682, %478 - %684 = mul i32 %668, 256 - %685 = add i32 %684, %478 - %686 = sext i32 %685 to i64 - %687 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %686 - %688 = load float, ptr addrspace(3) %687, align 4 - %689 = fmul float %688, %679 - %690 = add i32 %685, 1 - %691 = sext i32 %690 to i64 - %692 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %691 - %693 = load float, ptr addrspace(3) %692, align 4 - %694 = fmul float %693, %679 - %695 = insertelement <2 x float> poison, float %689, i64 0 - %696 = insertelement <2 x float> %695, float %694, i64 1 - %697 = fptrunc <2 x float> %696 to <2 x bfloat> - %698 = mul i32 %683, 2 - %699 = ptrtoint ptr addrspace(1) %17 to i64 - %700 = sext i32 %698 to i64 - %701 = add i64 %699, %700 - %702 = inttoptr i64 %701 to ptr addrspace(1) - %703 = atomicrmw fadd ptr addrspace(1) %702, <2 x bfloat> %697 syncscope("agent") monotonic, align 4 - %704 = add i32 %685, 64 - %705 = sext i32 %704 to i64 - %706 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %705 - %707 = load float, ptr addrspace(3) %706, align 4 - %708 = fmul float %707, %679 - %709 = add i32 %685, 65 - %710 = sext i32 %709 to i64 - %711 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %710 - %712 = load float, ptr addrspace(3) %711, align 4 - %713 = fmul float %712, %679 - %714 = insertelement <2 x float> poison, float %708, i64 0 - %715 = insertelement <2 x float> %714, float %713, i64 1 - %716 = fptrunc <2 x float> %715 to <2 x bfloat> - %717 = add i32 %683, 64 - %718 = mul i32 %717, 2 - %719 = sext i32 %718 to i64 - %720 = add i64 %699, %719 - %721 = inttoptr i64 %720 to ptr addrspace(1) - %722 = atomicrmw fadd ptr addrspace(1) %721, <2 x bfloat> %716 syncscope("agent") monotonic, align 4 - %723 = add i32 %685, 128 - %724 = sext i32 %723 to i64 - %725 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %724 - %726 = load float, ptr addrspace(3) %725, align 4 - %727 = fmul float %726, %679 - %728 = add i32 %685, 129 - %729 = sext i32 %728 to i64 - %730 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %729 - %731 = load float, ptr addrspace(3) %730, align 4 - %732 = fmul float %731, %679 - %733 = insertelement <2 x float> poison, float %727, i64 0 - %734 = insertelement <2 x float> %733, float %732, i64 1 - %735 = fptrunc <2 x float> %734 to <2 x bfloat> - %736 = add i32 %683, 128 - %737 = mul i32 %736, 2 - %738 = sext i32 %737 to i64 - %739 = add i64 %699, %738 - %740 = inttoptr i64 %739 to ptr addrspace(1) - %741 = atomicrmw fadd ptr addrspace(1) %740, <2 x bfloat> %735 syncscope("agent") monotonic, align 4 - %742 = add i32 %685, 192 - %743 = sext i32 %742 to i64 - %744 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %743 - %745 = load float, ptr addrspace(3) %744, align 4 - %746 = fmul float %745, %679 - %747 = add i32 %685, 193 - %748 = sext i32 %747 to i64 - %749 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %748 - %750 = load float, ptr addrspace(3) %749, align 4 - %751 = fmul float %750, %679 - %752 = insertelement <2 x float> poison, float %746, i64 0 - %753 = insertelement <2 x float> %752, float %751, i64 1 - %754 = fptrunc <2 x float> %753 to <2 x bfloat> - %755 = add i32 %683, 192 - %756 = mul i32 %755, 2 - %757 = sext i32 %756 to i64 - %758 = add i64 %699, %757 - %759 = inttoptr i64 %758 to ptr addrspace(1) - %760 = atomicrmw fadd ptr addrspace(1) %759, <2 x bfloat> %754 syncscope("agent") monotonic, align 4 - br label %761 - -761: ; preds = %680, %667 - %762 = add i32 %476, 24 - %763 = add i32 %66, %762 - %764 = mul i32 %763, 4 - %765 = sext i32 %764 to i64 - %766 = add i64 %481, %765 - %767 = inttoptr i64 %766 to ptr addrspace(1) - %768 = load i32, ptr addrspace(1) %767, align 4 - %769 = and i32 %768, 16777215 - %770 = icmp slt i32 %769, %16 - %771 = add i64 %488, %765 - %772 = inttoptr i64 %771 to ptr addrspace(1) - %773 = load float, ptr addrspace(1) %772, align 4 - br i1 %770, label %774, label %855 - -774: ; preds = %761 - %775 = mul i32 %769, 7168 - %776 = add i32 %775, %94 - %777 = add i32 %776, %478 - %778 = mul i32 %762, 256 - %779 = add i32 %778, %478 - %780 = sext i32 %779 to i64 - %781 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %780 - %782 = load float, ptr addrspace(3) %781, align 4 - %783 = fmul float %782, %773 - %784 = add i32 %779, 1 - %785 = sext i32 %784 to i64 - %786 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %785 - %787 = load float, ptr addrspace(3) %786, align 4 - %788 = fmul float %787, %773 - %789 = insertelement <2 x float> poison, float %783, i64 0 - %790 = insertelement <2 x float> %789, float %788, i64 1 - %791 = fptrunc <2 x float> %790 to <2 x bfloat> - %792 = mul i32 %777, 2 - %793 = ptrtoint ptr addrspace(1) %17 to i64 - %794 = sext i32 %792 to i64 - %795 = add i64 %793, %794 - %796 = inttoptr i64 %795 to ptr addrspace(1) - %797 = atomicrmw fadd ptr addrspace(1) %796, <2 x bfloat> %791 syncscope("agent") monotonic, align 4 - %798 = add i32 %779, 64 - %799 = sext i32 %798 to i64 - %800 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %799 - %801 = load float, ptr addrspace(3) %800, align 4 - %802 = fmul float %801, %773 - %803 = add i32 %779, 65 - %804 = sext i32 %803 to i64 - %805 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %804 - %806 = load float, ptr addrspace(3) %805, align 4 - %807 = fmul float %806, %773 - %808 = insertelement <2 x float> poison, float %802, i64 0 - %809 = insertelement <2 x float> %808, float %807, i64 1 - %810 = fptrunc <2 x float> %809 to <2 x bfloat> - %811 = add i32 %777, 64 - %812 = mul i32 %811, 2 - %813 = sext i32 %812 to i64 - %814 = add i64 %793, %813 - %815 = inttoptr i64 %814 to ptr addrspace(1) - %816 = atomicrmw fadd ptr addrspace(1) %815, <2 x bfloat> %810 syncscope("agent") monotonic, align 4 - %817 = add i32 %779, 128 - %818 = sext i32 %817 to i64 - %819 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %818 - %820 = load float, ptr addrspace(3) %819, align 4 - %821 = fmul float %820, %773 - %822 = add i32 %779, 129 - %823 = sext i32 %822 to i64 - %824 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %823 - %825 = load float, ptr addrspace(3) %824, align 4 - %826 = fmul float %825, %773 - %827 = insertelement <2 x float> poison, float %821, i64 0 - %828 = insertelement <2 x float> %827, float %826, i64 1 - %829 = fptrunc <2 x float> %828 to <2 x bfloat> - %830 = add i32 %777, 128 - %831 = mul i32 %830, 2 - %832 = sext i32 %831 to i64 - %833 = add i64 %793, %832 - %834 = inttoptr i64 %833 to ptr addrspace(1) - %835 = atomicrmw fadd ptr addrspace(1) %834, <2 x bfloat> %829 syncscope("agent") monotonic, align 4 - %836 = add i32 %779, 192 - %837 = sext i32 %836 to i64 - %838 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %837 - %839 = load float, ptr addrspace(3) %838, align 4 - %840 = fmul float %839, %773 - %841 = add i32 %779, 193 - %842 = sext i32 %841 to i64 - %843 = getelementptr inbounds nuw float, ptr addrspace(3) @gemm2port_smem, i64 %842 - %844 = load float, ptr addrspace(3) %843, align 4 - %845 = fmul float %844, %773 - %846 = insertelement <2 x float> poison, float %840, i64 0 - %847 = insertelement <2 x float> %846, float %845, i64 1 - %848 = fptrunc <2 x float> %847 to <2 x bfloat> - %849 = add i32 %777, 192 - %850 = mul i32 %849, 2 - %851 = sext i32 %850 to i64 - %852 = add i64 %793, %851 - %853 = inttoptr i64 %852 to ptr addrspace(1) - %854 = atomicrmw fadd ptr addrspace(1) %853, <2 x bfloat> %848 syncscope("agent") monotonic, align 4 - br label %855 - -855: ; preds = %774, %761 - br label %856 - -856: ; preds = %855, %19 - ret void -} - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) -declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 - -; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) -declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #3 - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #4 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.sched.barrier(i32 immarg) #5 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.s.barrier() #5 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) -declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #7 - -attributes #0 = { "amdgpu-flat-work-group-size"="256,256" "uniform-work-group-size" } -attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } -attributes #2 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } -attributes #3 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } -attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } -attributes #5 = { convergent nocallback nofree nounwind willreturn } -attributes #6 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } -attributes #7 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} -!1 = !{i32 256, i32 1, i32 1} diff --git a/kernels/gemm2_port_ref/flydsl_port_v3.ll b/kernels/gemm2_port_ref/flydsl_port_v3.ll deleted file mode 100644 index 6069aa524..000000000 --- a/kernels/gemm2_port_ref/flydsl_port_v3.ll +++ /dev/null @@ -1,1083 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" -target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" - -@gemm2port_smem = external addrspace(3) global [32768 x i8], align 1024 - -define amdgpu_kernel void @gemm2_a4w4_port_bm32_atomic(ptr addrspace(1) %0, <{ <{ i32, i32 }>, <{ i64 }> }> %1, ptr addrspace(1) %2, <{ <{ i32, i32 }>, <{ i64 }> }> %3, ptr addrspace(1) %4, <{ <{ i32, i32, i32 }>, <{ i64, i64 }> }> %5, ptr addrspace(1) %6, <{ <{ i32, i32 }>, <{ i64 }> }> %7, ptr addrspace(1) %8, <{ <{ i32 }> }> %9, ptr addrspace(1) %10, <{ <{ i32 }> }> %11, ptr addrspace(1) %12, <{ <{ i32 }> }> %13, ptr addrspace(1) %14, <{ <{ i32 }> }> %15, i32 %16, ptr addrspace(1) %17, <{ <{ i32, i32 }>, <{ i64 }> }> %18) #0 !reqd_work_group_size !1 { - %20 = call range(i32 0, 256) i32 @llvm.amdgcn.workitem.id.x() - %21 = sext i32 %20 to i64 - %22 = call i32 @llvm.amdgcn.workgroup.id.x() - %23 = sext i32 %22 to i64 - %24 = trunc i64 %21 to i32 - %25 = trunc i64 %23 to i32 - %26 = srem i32 %24, 64 - %27 = sdiv i32 %24, 64 - %28 = mul i32 %27, 64 - %29 = icmp ne i32 %24, %28 - %30 = icmp slt i32 %24, 0 - %31 = icmp ne i1 %30, false - %32 = and i1 %29, %31 - %33 = add i32 %27, -1 - %34 = select i1 %32, i32 %33, i32 %27 - %35 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %34) - %36 = ptrtoint ptr addrspace(1) %10 to i64 - %37 = inttoptr i64 %36 to ptr addrspace(1) - %38 = load i32, ptr addrspace(1) %37, align 4 - %39 = sdiv i32 %38, 32 - %40 = mul i32 %39, 32 - %41 = icmp ne i32 %38, %40 - %42 = icmp slt i32 %38, 0 - %43 = icmp ne i1 %42, false - %44 = and i1 %41, %43 - %45 = add i32 %39, -1 - %46 = select i1 %44, i32 %45, i32 %39 - %47 = mul i32 %46, 28 - %48 = icmp slt i32 %25, %47 - br i1 %48, label %49, label %984 - -49: ; preds = %19 - %50 = srem i32 %25, 28 - %51 = sdiv i32 %25, 28 - %52 = mul i32 %51, 28 - %53 = icmp ne i32 %25, %52 - %54 = icmp slt i32 %25, 0 - %55 = icmp ne i1 %54, false - %56 = and i1 %53, %55 - %57 = add i32 %51, -1 - %58 = select i1 %56, i32 %57, i32 %51 - %59 = mul i32 %58, 4 - %60 = ptrtoint ptr addrspace(1) %8 to i64 - %61 = sext i32 %59 to i64 - %62 = add i64 %60, %61 - %63 = inttoptr i64 %62 to ptr addrspace(1) - %64 = load i32, ptr addrspace(1) %63, align 4 - %65 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %64) - %66 = mul i32 %58, 32 - %67 = addrspacecast ptr addrspace(1) %0 to ptr - %68 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %67, i16 0, i64 167772160, i32 159744) - %69 = addrspacecast ptr addrspace(1) %2 to ptr - %70 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %69, i16 0, i64 10485760, i32 159744) - %71 = addrspacecast ptr addrspace(1) %4 to ptr - %72 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %71, i16 0, i64 706478080, i32 159744) - %73 = addrspacecast ptr addrspace(1) %6 to ptr - %74 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %73, i16 0, i64 44154880, i32 159744) - %75 = sdiv i32 %26, 8 - %76 = mul i32 %75, 8 - %77 = icmp ne i32 %26, %76 - %78 = icmp slt i32 %26, 0 - %79 = icmp ne i1 %78, false - %80 = and i1 %77, %79 - %81 = add i32 %75, -1 - %82 = select i1 %80, i32 %81, i32 %75 - %83 = srem i32 %26, 8 - %84 = sdiv i32 %26, 16 - %85 = mul i32 %84, 16 - %86 = icmp ne i32 %26, %85 - %87 = icmp slt i32 %26, 0 - %88 = icmp ne i1 %87, false - %89 = and i1 %86, %88 - %90 = add i32 %84, -1 - %91 = select i1 %89, i32 %90, i32 %84 - %92 = srem i32 %26, 16 - %93 = mul i32 %65, 7168 - %94 = mul i32 %50, 256 - %95 = add i32 %93, %94 - %96 = mul i32 %35, 64 - %97 = add i32 %95, %96 - %98 = mul i32 %97, 256 - %99 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %98) - %100 = add i32 %97, 16 - %101 = mul i32 %100, 256 - %102 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %101) - %103 = add i32 %97, 32 - %104 = mul i32 %103, 256 - %105 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %104) - %106 = add i32 %97, 48 - %107 = mul i32 %106, 256 - %108 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %107) - %109 = mul i32 %50, 8 - %110 = mul i32 %35, 2 - %111 = add i32 %109, %110 - %112 = mul i32 %65, 28672 - %113 = mul i32 %111, 128 - %114 = add i32 %112, %113 - %115 = mul i32 %114, 4 - %116 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %115) - %117 = add i32 %111, 1 - %118 = mul i32 %117, 128 - %119 = add i32 %112, %118 - %120 = mul i32 %119, 4 - %121 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %120) - %122 = sdiv i32 %66, 32 - %123 = mul i32 %122, 32 - %124 = icmp ne i32 %66, %123 - %125 = icmp slt i32 %66, 0 - %126 = icmp ne i1 %125, false - %127 = and i1 %124, %126 - %128 = add i32 %122, -1 - %129 = select i1 %127, i32 %128, i32 %122 - %130 = mul i32 %129, 512 - %131 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %130) - %132 = mul i32 %35, 8 - %133 = add i32 %66, %132 - %134 = add i32 %133, %82 - %135 = add i32 %132, %82 - %136 = and i32 %135, 14 - %137 = shl i32 %136, 3 - %138 = mul i32 %83, 16 - %139 = xor i32 %138, %137 - %140 = mul i32 %134, 256 - %141 = add i32 %139, %140 - %142 = mul i32 %35, 1024 - %143 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %142 - %144 = sext i32 %143 to i64 - %145 = inttoptr i64 %144 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %68, ptr addrspace(3) %145, i32 16, i32 %141, i32 0, i32 0, i32 0) - %146 = add i32 %142, 4096 - %147 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %146 - %148 = sext i32 %147 to i64 - %149 = inttoptr i64 %148 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %68, ptr addrspace(3) %149, i32 16, i32 %141, i32 128, i32 0, i32 0) - call void @llvm.amdgcn.sched.barrier(i32 0) - %150 = mul i32 %91, 16 - %151 = add i32 %150, %92 - %152 = mul i32 %151, 4 - %153 = sdiv i32 %152, 4 - %154 = mul i32 %153, 4 - %155 = icmp ne i32 %152, %154 - %156 = icmp slt i32 %152, 0 - %157 = icmp ne i1 %156, false - %158 = and i1 %155, %157 - %159 = add i32 %153, -1 - %160 = select i1 %158, i32 %159, i32 %153 - %161 = mul i32 %160, 4 - %162 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %70, i32 %161, i32 %131, i32 0) - %163 = add i32 %152, 256 - %164 = sdiv i32 %163, 4 - %165 = mul i32 %164, 4 - %166 = icmp ne i32 %163, %165 - %167 = icmp slt i32 %163, 0 - %168 = icmp ne i1 %167, false - %169 = and i1 %166, %168 - %170 = add i32 %164, -1 - %171 = select i1 %169, i32 %170, i32 %164 - %172 = mul i32 %171, 4 - %173 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %70, i32 %172, i32 %131, i32 0) - %174 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %161, i32 %116, i32 0) - %175 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %161, i32 %121, i32 0) - %176 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %172, i32 %116, i32 0) - %177 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %172, i32 %121, i32 0) - %178 = mul i32 %91, 256 - %179 = mul i32 %92, 16 - %180 = add i32 %178, %179 - %181 = sdiv i32 %180, 4 - %182 = mul i32 %181, 4 - %183 = icmp ne i32 %180, %182 - %184 = icmp slt i32 %180, 0 - %185 = icmp ne i1 %184, false - %186 = and i1 %183, %185 - %187 = add i32 %181, -1 - %188 = select i1 %186, i32 %187, i32 %181 - %189 = mul i32 %188, 4 - %190 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %99, i32 0) - %191 = add i32 %180, 1024 - %192 = sdiv i32 %191, 4 - %193 = mul i32 %192, 4 - %194 = icmp ne i32 %191, %193 - %195 = icmp slt i32 %191, 0 - %196 = icmp ne i1 %195, false - %197 = and i1 %194, %196 - %198 = add i32 %192, -1 - %199 = select i1 %197, i32 %198, i32 %192 - %200 = mul i32 %199, 4 - %201 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %99, i32 0) - %202 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %102, i32 0) - %203 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %102, i32 0) - %204 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %105, i32 0) - %205 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %105, i32 0) - %206 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %108, i32 0) - %207 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %108, i32 0) - %208 = add i32 %180, 2048 - %209 = sdiv i32 %208, 4 - %210 = mul i32 %209, 4 - %211 = icmp ne i32 %208, %210 - %212 = icmp slt i32 %208, 0 - %213 = icmp ne i1 %212, false - %214 = and i1 %211, %213 - %215 = add i32 %209, -1 - %216 = select i1 %214, i32 %215, i32 %209 - %217 = mul i32 %216, 4 - %218 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %99, i32 0) - %219 = add i32 %180, 3072 - %220 = sdiv i32 %219, 4 - %221 = mul i32 %220, 4 - %222 = icmp ne i32 %219, %221 - %223 = icmp slt i32 %219, 0 - %224 = icmp ne i1 %223, false - %225 = and i1 %222, %224 - %226 = add i32 %220, -1 - %227 = select i1 %225, i32 %226, i32 %220 - %228 = mul i32 %227, 4 - %229 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %99, i32 0) - %230 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %102, i32 0) - %231 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %102, i32 0) - %232 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %105, i32 0) - %233 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %105, i32 0) - %234 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %108, i32 0) - %235 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %108, i32 0) - call void asm sideeffect "s_waitcnt vmcnt(23)", ""() - call void asm sideeffect "s_barrier", ""() - %236 = and i32 %92, 14 - %237 = shl i32 %236, 3 - %238 = xor i32 %150, %237 - %239 = mul i32 %92, 128 - %240 = add i32 %239, %238 - %241 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %240 - %242 = sext i32 %241 to i64 - %243 = inttoptr i64 %242 to ptr addrspace(3) - %244 = load <4 x i32>, ptr addrspace(3) %243, align 16 - %245 = add i32 %92, 16 - %246 = mul i32 %245, 128 - %247 = add i32 %246, %238 - %248 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %247 - %249 = sext i32 %248 to i64 - %250 = inttoptr i64 %249 to ptr addrspace(3) - %251 = load <4 x i32>, ptr addrspace(3) %250, align 16 - %252 = add i32 %150, 64 - %253 = xor i32 %252, %237 - %254 = add i32 %239, %253 - %255 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %254 - %256 = sext i32 %255 to i64 - %257 = inttoptr i64 %256 to ptr addrspace(3) - %258 = load <4 x i32>, ptr addrspace(3) %257, align 16 - %259 = add i32 %246, %253 - %260 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %259 - %261 = sext i32 %260 to i64 - %262 = inttoptr i64 %261 to ptr addrspace(3) - %263 = load <4 x i32>, ptr addrspace(3) %262, align 16 - %264 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %190, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 0, i32 %174) - %265 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %190, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 0, i32 %174) - %266 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %201, <4 x float> %264, i32 4, i32 4, i32 2, i32 %162, i32 2, i32 %174) - %267 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %201, <4 x float> %265, i32 4, i32 4, i32 3, i32 %162, i32 2, i32 %174) - %268 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 1, i32 %174) - %269 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 1, i32 %174) - %270 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %203, <4 x float> %268, i32 4, i32 4, i32 2, i32 %162, i32 3, i32 %174) - %271 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %203, <4 x float> %269, i32 4, i32 4, i32 3, i32 %162, i32 3, i32 %174) - %272 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 0, i32 %175) - %273 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 0, i32 %175) - %274 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %205, <4 x float> %272, i32 4, i32 4, i32 2, i32 %162, i32 2, i32 %175) - %275 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %205, <4 x float> %273, i32 4, i32 4, i32 3, i32 %162, i32 2, i32 %175) - %276 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %206, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 1, i32 %175) - %277 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %251, <4 x i32> %206, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 1, i32 %175) - %278 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %258, <4 x i32> %207, <4 x float> %276, i32 4, i32 4, i32 2, i32 %162, i32 3, i32 %175) - %279 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %263, <4 x i32> %207, <4 x float> %277, i32 4, i32 4, i32 3, i32 %162, i32 3, i32 %175) - call void asm sideeffect "s_waitcnt vmcnt(22)", ""() - call void asm sideeffect "s_barrier", ""() - %280 = add i32 %239, 4096 - %281 = add i32 %280, %238 - %282 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %281 - %283 = sext i32 %282 to i64 - %284 = inttoptr i64 %283 to ptr addrspace(3) - %285 = load <4 x i32>, ptr addrspace(3) %284, align 16 - %286 = add i32 %246, 4096 - %287 = add i32 %286, %238 - %288 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %287 - %289 = sext i32 %288 to i64 - %290 = inttoptr i64 %289 to ptr addrspace(3) - %291 = load <4 x i32>, ptr addrspace(3) %290, align 16 - %292 = add i32 %280, %253 - %293 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %292 - %294 = sext i32 %293 to i64 - %295 = inttoptr i64 %294 to ptr addrspace(3) - %296 = load <4 x i32>, ptr addrspace(3) %295, align 16 - %297 = add i32 %286, %253 - %298 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %297 - %299 = sext i32 %298 to i64 - %300 = inttoptr i64 %299 to ptr addrspace(3) - %301 = load <4 x i32>, ptr addrspace(3) %300, align 16 - %302 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %218, <4 x float> %266, i32 4, i32 4, i32 0, i32 %173, i32 0, i32 %176) - %303 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %218, <4 x float> %267, i32 4, i32 4, i32 1, i32 %173, i32 0, i32 %176) - %304 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %229, <4 x float> %302, i32 4, i32 4, i32 2, i32 %173, i32 2, i32 %176) - %305 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %229, <4 x float> %303, i32 4, i32 4, i32 3, i32 %173, i32 2, i32 %176) - %306 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %230, <4 x float> %270, i32 4, i32 4, i32 0, i32 %173, i32 1, i32 %176) - %307 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %230, <4 x float> %271, i32 4, i32 4, i32 1, i32 %173, i32 1, i32 %176) - %308 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %231, <4 x float> %306, i32 4, i32 4, i32 2, i32 %173, i32 3, i32 %176) - %309 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %231, <4 x float> %307, i32 4, i32 4, i32 3, i32 %173, i32 3, i32 %176) - %310 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %232, <4 x float> %274, i32 4, i32 4, i32 0, i32 %173, i32 0, i32 %177) - %311 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %232, <4 x float> %275, i32 4, i32 4, i32 1, i32 %173, i32 0, i32 %177) - %312 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %233, <4 x float> %310, i32 4, i32 4, i32 2, i32 %173, i32 2, i32 %177) - %313 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %233, <4 x float> %311, i32 4, i32 4, i32 3, i32 %173, i32 2, i32 %177) - %314 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %285, <4 x i32> %234, <4 x float> %278, i32 4, i32 4, i32 0, i32 %173, i32 1, i32 %177) - %315 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %291, <4 x i32> %234, <4 x float> %279, i32 4, i32 4, i32 1, i32 %173, i32 1, i32 %177) - %316 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %296, <4 x i32> %235, <4 x float> %314, i32 4, i32 4, i32 2, i32 %173, i32 3, i32 %177) - %317 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %301, <4 x i32> %235, <4 x float> %315, i32 4, i32 4, i32 3, i32 %173, i32 3, i32 %177) - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %318 = mul i32 %91, 4 - %319 = add i32 %96, %92 - %320 = mul i32 %91, 1024 - %321 = add i32 %320, %319 - %322 = mul i32 %321, 4 - %323 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %322 - %324 = sext i32 %323 to i64 - %325 = inttoptr i64 %324 to ptr addrspace(3) - %326 = extractelement <4 x float> %304, i64 0 - store float %326, ptr addrspace(3) %325, align 4 - %327 = add i32 %318, 1 - %328 = mul i32 %327, 256 - %329 = add i32 %328, %319 - %330 = mul i32 %329, 4 - %331 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %330 - %332 = sext i32 %331 to i64 - %333 = inttoptr i64 %332 to ptr addrspace(3) - %334 = extractelement <4 x float> %304, i64 1 - store float %334, ptr addrspace(3) %333, align 4 - %335 = add i32 %318, 2 - %336 = mul i32 %335, 256 - %337 = add i32 %336, %319 - %338 = mul i32 %337, 4 - %339 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %338 - %340 = sext i32 %339 to i64 - %341 = inttoptr i64 %340 to ptr addrspace(3) - %342 = extractelement <4 x float> %304, i64 2 - store float %342, ptr addrspace(3) %341, align 4 - %343 = add i32 %318, 3 - %344 = mul i32 %343, 256 - %345 = add i32 %344, %319 - %346 = mul i32 %345, 4 - %347 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %346 - %348 = sext i32 %347 to i64 - %349 = inttoptr i64 %348 to ptr addrspace(3) - %350 = extractelement <4 x float> %304, i64 3 - store float %350, ptr addrspace(3) %349, align 4 - %351 = add i32 %96, 16 - %352 = add i32 %351, %92 - %353 = add i32 %320, %352 - %354 = mul i32 %353, 4 - %355 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %354 - %356 = sext i32 %355 to i64 - %357 = inttoptr i64 %356 to ptr addrspace(3) - %358 = extractelement <4 x float> %308, i64 0 - store float %358, ptr addrspace(3) %357, align 4 - %359 = add i32 %328, %352 - %360 = mul i32 %359, 4 - %361 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %360 - %362 = sext i32 %361 to i64 - %363 = inttoptr i64 %362 to ptr addrspace(3) - %364 = extractelement <4 x float> %308, i64 1 - store float %364, ptr addrspace(3) %363, align 4 - %365 = add i32 %336, %352 - %366 = mul i32 %365, 4 - %367 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %366 - %368 = sext i32 %367 to i64 - %369 = inttoptr i64 %368 to ptr addrspace(3) - %370 = extractelement <4 x float> %308, i64 2 - store float %370, ptr addrspace(3) %369, align 4 - %371 = add i32 %344, %352 - %372 = mul i32 %371, 4 - %373 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %372 - %374 = sext i32 %373 to i64 - %375 = inttoptr i64 %374 to ptr addrspace(3) - %376 = extractelement <4 x float> %308, i64 3 - store float %376, ptr addrspace(3) %375, align 4 - %377 = add i32 %96, 32 - %378 = add i32 %377, %92 - %379 = add i32 %320, %378 - %380 = mul i32 %379, 4 - %381 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %380 - %382 = sext i32 %381 to i64 - %383 = inttoptr i64 %382 to ptr addrspace(3) - %384 = extractelement <4 x float> %312, i64 0 - store float %384, ptr addrspace(3) %383, align 4 - %385 = add i32 %328, %378 - %386 = mul i32 %385, 4 - %387 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %386 - %388 = sext i32 %387 to i64 - %389 = inttoptr i64 %388 to ptr addrspace(3) - %390 = extractelement <4 x float> %312, i64 1 - store float %390, ptr addrspace(3) %389, align 4 - %391 = add i32 %336, %378 - %392 = mul i32 %391, 4 - %393 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %392 - %394 = sext i32 %393 to i64 - %395 = inttoptr i64 %394 to ptr addrspace(3) - %396 = extractelement <4 x float> %312, i64 2 - store float %396, ptr addrspace(3) %395, align 4 - %397 = add i32 %344, %378 - %398 = mul i32 %397, 4 - %399 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %398 - %400 = sext i32 %399 to i64 - %401 = inttoptr i64 %400 to ptr addrspace(3) - %402 = extractelement <4 x float> %312, i64 3 - store float %402, ptr addrspace(3) %401, align 4 - %403 = add i32 %96, 48 - %404 = add i32 %403, %92 - %405 = add i32 %320, %404 - %406 = mul i32 %405, 4 - %407 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %406 - %408 = sext i32 %407 to i64 - %409 = inttoptr i64 %408 to ptr addrspace(3) - %410 = extractelement <4 x float> %316, i64 0 - store float %410, ptr addrspace(3) %409, align 4 - %411 = add i32 %328, %404 - %412 = mul i32 %411, 4 - %413 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %412 - %414 = sext i32 %413 to i64 - %415 = inttoptr i64 %414 to ptr addrspace(3) - %416 = extractelement <4 x float> %316, i64 1 - store float %416, ptr addrspace(3) %415, align 4 - %417 = add i32 %336, %404 - %418 = mul i32 %417, 4 - %419 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %418 - %420 = sext i32 %419 to i64 - %421 = inttoptr i64 %420 to ptr addrspace(3) - %422 = extractelement <4 x float> %316, i64 2 - store float %422, ptr addrspace(3) %421, align 4 - %423 = add i32 %344, %404 - %424 = mul i32 %423, 4 - %425 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %424 - %426 = sext i32 %425 to i64 - %427 = inttoptr i64 %426 to ptr addrspace(3) - %428 = extractelement <4 x float> %316, i64 3 - store float %428, ptr addrspace(3) %427, align 4 - %429 = add i32 %318, 16 - %430 = mul i32 %429, 256 - %431 = add i32 %430, %319 - %432 = mul i32 %431, 4 - %433 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %432 - %434 = sext i32 %433 to i64 - %435 = inttoptr i64 %434 to ptr addrspace(3) - %436 = extractelement <4 x float> %305, i64 0 - store float %436, ptr addrspace(3) %435, align 4 - %437 = add i32 %318, 17 - %438 = mul i32 %437, 256 - %439 = add i32 %438, %319 - %440 = mul i32 %439, 4 - %441 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %440 - %442 = sext i32 %441 to i64 - %443 = inttoptr i64 %442 to ptr addrspace(3) - %444 = extractelement <4 x float> %305, i64 1 - store float %444, ptr addrspace(3) %443, align 4 - %445 = add i32 %318, 18 - %446 = mul i32 %445, 256 - %447 = add i32 %446, %319 - %448 = mul i32 %447, 4 - %449 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %448 - %450 = sext i32 %449 to i64 - %451 = inttoptr i64 %450 to ptr addrspace(3) - %452 = extractelement <4 x float> %305, i64 2 - store float %452, ptr addrspace(3) %451, align 4 - %453 = add i32 %318, 19 - %454 = mul i32 %453, 256 - %455 = add i32 %454, %319 - %456 = mul i32 %455, 4 - %457 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %456 - %458 = sext i32 %457 to i64 - %459 = inttoptr i64 %458 to ptr addrspace(3) - %460 = extractelement <4 x float> %305, i64 3 - store float %460, ptr addrspace(3) %459, align 4 - %461 = add i32 %430, %352 - %462 = mul i32 %461, 4 - %463 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %462 - %464 = sext i32 %463 to i64 - %465 = inttoptr i64 %464 to ptr addrspace(3) - %466 = extractelement <4 x float> %309, i64 0 - store float %466, ptr addrspace(3) %465, align 4 - %467 = add i32 %438, %352 - %468 = mul i32 %467, 4 - %469 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %468 - %470 = sext i32 %469 to i64 - %471 = inttoptr i64 %470 to ptr addrspace(3) - %472 = extractelement <4 x float> %309, i64 1 - store float %472, ptr addrspace(3) %471, align 4 - %473 = add i32 %446, %352 - %474 = mul i32 %473, 4 - %475 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %474 - %476 = sext i32 %475 to i64 - %477 = inttoptr i64 %476 to ptr addrspace(3) - %478 = extractelement <4 x float> %309, i64 2 - store float %478, ptr addrspace(3) %477, align 4 - %479 = add i32 %454, %352 - %480 = mul i32 %479, 4 - %481 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %480 - %482 = sext i32 %481 to i64 - %483 = inttoptr i64 %482 to ptr addrspace(3) - %484 = extractelement <4 x float> %309, i64 3 - store float %484, ptr addrspace(3) %483, align 4 - %485 = add i32 %430, %378 - %486 = mul i32 %485, 4 - %487 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %486 - %488 = sext i32 %487 to i64 - %489 = inttoptr i64 %488 to ptr addrspace(3) - %490 = extractelement <4 x float> %313, i64 0 - store float %490, ptr addrspace(3) %489, align 4 - %491 = add i32 %438, %378 - %492 = mul i32 %491, 4 - %493 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %492 - %494 = sext i32 %493 to i64 - %495 = inttoptr i64 %494 to ptr addrspace(3) - %496 = extractelement <4 x float> %313, i64 1 - store float %496, ptr addrspace(3) %495, align 4 - %497 = add i32 %446, %378 - %498 = mul i32 %497, 4 - %499 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %498 - %500 = sext i32 %499 to i64 - %501 = inttoptr i64 %500 to ptr addrspace(3) - %502 = extractelement <4 x float> %313, i64 2 - store float %502, ptr addrspace(3) %501, align 4 - %503 = add i32 %454, %378 - %504 = mul i32 %503, 4 - %505 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %504 - %506 = sext i32 %505 to i64 - %507 = inttoptr i64 %506 to ptr addrspace(3) - %508 = extractelement <4 x float> %313, i64 3 - store float %508, ptr addrspace(3) %507, align 4 - %509 = add i32 %430, %404 - %510 = mul i32 %509, 4 - %511 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %510 - %512 = sext i32 %511 to i64 - %513 = inttoptr i64 %512 to ptr addrspace(3) - %514 = extractelement <4 x float> %317, i64 0 - store float %514, ptr addrspace(3) %513, align 4 - %515 = add i32 %438, %404 - %516 = mul i32 %515, 4 - %517 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %516 - %518 = sext i32 %517 to i64 - %519 = inttoptr i64 %518 to ptr addrspace(3) - %520 = extractelement <4 x float> %317, i64 1 - store float %520, ptr addrspace(3) %519, align 4 - %521 = add i32 %446, %404 - %522 = mul i32 %521, 4 - %523 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %522 - %524 = sext i32 %523 to i64 - %525 = inttoptr i64 %524 to ptr addrspace(3) - %526 = extractelement <4 x float> %317, i64 2 - store float %526, ptr addrspace(3) %525, align 4 - %527 = add i32 %454, %404 - %528 = mul i32 %527, 4 - %529 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %528 - %530 = sext i32 %529 to i64 - %531 = inttoptr i64 %530 to ptr addrspace(3) - %532 = extractelement <4 x float> %317, i64 3 - store float %532, ptr addrspace(3) %531, align 4 - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %533 = sdiv i32 %24, 32 - %534 = mul i32 %533, 32 - %535 = icmp ne i32 %24, %534 - %536 = icmp slt i32 %24, 0 - %537 = icmp ne i1 %536, false - %538 = and i1 %535, %537 - %539 = add i32 %533, -1 - %540 = select i1 %538, i32 %539, i32 %533 - %541 = srem i32 %24, 32 - %542 = mul i32 %541, 2 - %543 = add i32 %66, %540 - %544 = mul i32 %543, 4 - %545 = ptrtoint ptr addrspace(1) %12 to i64 - %546 = sext i32 %544 to i64 - %547 = add i64 %545, %546 - %548 = inttoptr i64 %547 to ptr addrspace(1) - %549 = load i32, ptr addrspace(1) %548, align 4 - %550 = and i32 %549, 16777215 - %551 = icmp slt i32 %550, %16 - %552 = ptrtoint ptr addrspace(1) %14 to i64 - %553 = add i64 %552, %546 - %554 = inttoptr i64 %553 to ptr addrspace(1) - %555 = load float, ptr addrspace(1) %554, align 4 - br i1 %551, label %556, label %653 - -556: ; preds = %49 - %557 = mul i32 %550, 7168 - %558 = add i32 %557, %94 - %559 = add i32 %558, %542 - %560 = mul i32 %540, 256 - %561 = add i32 %560, %542 - %562 = mul i32 %561, 4 - %563 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %562 - %564 = sext i32 %563 to i64 - %565 = inttoptr i64 %564 to ptr addrspace(3) - %566 = load float, ptr addrspace(3) %565, align 4 - %567 = fmul float %566, %555 - %568 = add i32 %561, 1 - %569 = mul i32 %568, 4 - %570 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %569 - %571 = sext i32 %570 to i64 - %572 = inttoptr i64 %571 to ptr addrspace(3) - %573 = load float, ptr addrspace(3) %572, align 4 - %574 = fmul float %573, %555 - %575 = insertelement <2 x float> poison, float %567, i64 0 - %576 = insertelement <2 x float> %575, float %574, i64 1 - %577 = fptrunc <2 x float> %576 to <2 x bfloat> - %578 = mul i32 %559, 2 - %579 = ptrtoint ptr addrspace(1) %17 to i64 - %580 = sext i32 %578 to i64 - %581 = add i64 %579, %580 - %582 = inttoptr i64 %581 to ptr addrspace(1) - %583 = atomicrmw fadd ptr addrspace(1) %582, <2 x bfloat> %577 syncscope("agent") monotonic, align 4 - %584 = add i32 %561, 64 - %585 = mul i32 %584, 4 - %586 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %585 - %587 = sext i32 %586 to i64 - %588 = inttoptr i64 %587 to ptr addrspace(3) - %589 = load float, ptr addrspace(3) %588, align 4 - %590 = fmul float %589, %555 - %591 = add i32 %561, 65 - %592 = mul i32 %591, 4 - %593 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %592 - %594 = sext i32 %593 to i64 - %595 = inttoptr i64 %594 to ptr addrspace(3) - %596 = load float, ptr addrspace(3) %595, align 4 - %597 = fmul float %596, %555 - %598 = insertelement <2 x float> poison, float %590, i64 0 - %599 = insertelement <2 x float> %598, float %597, i64 1 - %600 = fptrunc <2 x float> %599 to <2 x bfloat> - %601 = add i32 %559, 64 - %602 = mul i32 %601, 2 - %603 = sext i32 %602 to i64 - %604 = add i64 %579, %603 - %605 = inttoptr i64 %604 to ptr addrspace(1) - %606 = atomicrmw fadd ptr addrspace(1) %605, <2 x bfloat> %600 syncscope("agent") monotonic, align 4 - %607 = add i32 %561, 128 - %608 = mul i32 %607, 4 - %609 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %608 - %610 = sext i32 %609 to i64 - %611 = inttoptr i64 %610 to ptr addrspace(3) - %612 = load float, ptr addrspace(3) %611, align 4 - %613 = fmul float %612, %555 - %614 = add i32 %561, 129 - %615 = mul i32 %614, 4 - %616 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %615 - %617 = sext i32 %616 to i64 - %618 = inttoptr i64 %617 to ptr addrspace(3) - %619 = load float, ptr addrspace(3) %618, align 4 - %620 = fmul float %619, %555 - %621 = insertelement <2 x float> poison, float %613, i64 0 - %622 = insertelement <2 x float> %621, float %620, i64 1 - %623 = fptrunc <2 x float> %622 to <2 x bfloat> - %624 = add i32 %559, 128 - %625 = mul i32 %624, 2 - %626 = sext i32 %625 to i64 - %627 = add i64 %579, %626 - %628 = inttoptr i64 %627 to ptr addrspace(1) - %629 = atomicrmw fadd ptr addrspace(1) %628, <2 x bfloat> %623 syncscope("agent") monotonic, align 4 - %630 = add i32 %561, 192 - %631 = mul i32 %630, 4 - %632 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %631 - %633 = sext i32 %632 to i64 - %634 = inttoptr i64 %633 to ptr addrspace(3) - %635 = load float, ptr addrspace(3) %634, align 4 - %636 = fmul float %635, %555 - %637 = add i32 %561, 193 - %638 = mul i32 %637, 4 - %639 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %638 - %640 = sext i32 %639 to i64 - %641 = inttoptr i64 %640 to ptr addrspace(3) - %642 = load float, ptr addrspace(3) %641, align 4 - %643 = fmul float %642, %555 - %644 = insertelement <2 x float> poison, float %636, i64 0 - %645 = insertelement <2 x float> %644, float %643, i64 1 - %646 = fptrunc <2 x float> %645 to <2 x bfloat> - %647 = add i32 %559, 192 - %648 = mul i32 %647, 2 - %649 = sext i32 %648 to i64 - %650 = add i64 %579, %649 - %651 = inttoptr i64 %650 to ptr addrspace(1) - %652 = atomicrmw fadd ptr addrspace(1) %651, <2 x bfloat> %646 syncscope("agent") monotonic, align 4 - br label %653 - -653: ; preds = %556, %49 - %654 = add i32 %540, 8 - %655 = add i32 %66, %654 - %656 = mul i32 %655, 4 - %657 = sext i32 %656 to i64 - %658 = add i64 %545, %657 - %659 = inttoptr i64 %658 to ptr addrspace(1) - %660 = load i32, ptr addrspace(1) %659, align 4 - %661 = and i32 %660, 16777215 - %662 = icmp slt i32 %661, %16 - %663 = add i64 %552, %657 - %664 = inttoptr i64 %663 to ptr addrspace(1) - %665 = load float, ptr addrspace(1) %664, align 4 - br i1 %662, label %666, label %763 - -666: ; preds = %653 - %667 = mul i32 %661, 7168 - %668 = add i32 %667, %94 - %669 = add i32 %668, %542 - %670 = mul i32 %654, 256 - %671 = add i32 %670, %542 - %672 = mul i32 %671, 4 - %673 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %672 - %674 = sext i32 %673 to i64 - %675 = inttoptr i64 %674 to ptr addrspace(3) - %676 = load float, ptr addrspace(3) %675, align 4 - %677 = fmul float %676, %665 - %678 = add i32 %671, 1 - %679 = mul i32 %678, 4 - %680 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %679 - %681 = sext i32 %680 to i64 - %682 = inttoptr i64 %681 to ptr addrspace(3) - %683 = load float, ptr addrspace(3) %682, align 4 - %684 = fmul float %683, %665 - %685 = insertelement <2 x float> poison, float %677, i64 0 - %686 = insertelement <2 x float> %685, float %684, i64 1 - %687 = fptrunc <2 x float> %686 to <2 x bfloat> - %688 = mul i32 %669, 2 - %689 = ptrtoint ptr addrspace(1) %17 to i64 - %690 = sext i32 %688 to i64 - %691 = add i64 %689, %690 - %692 = inttoptr i64 %691 to ptr addrspace(1) - %693 = atomicrmw fadd ptr addrspace(1) %692, <2 x bfloat> %687 syncscope("agent") monotonic, align 4 - %694 = add i32 %671, 64 - %695 = mul i32 %694, 4 - %696 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %695 - %697 = sext i32 %696 to i64 - %698 = inttoptr i64 %697 to ptr addrspace(3) - %699 = load float, ptr addrspace(3) %698, align 4 - %700 = fmul float %699, %665 - %701 = add i32 %671, 65 - %702 = mul i32 %701, 4 - %703 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %702 - %704 = sext i32 %703 to i64 - %705 = inttoptr i64 %704 to ptr addrspace(3) - %706 = load float, ptr addrspace(3) %705, align 4 - %707 = fmul float %706, %665 - %708 = insertelement <2 x float> poison, float %700, i64 0 - %709 = insertelement <2 x float> %708, float %707, i64 1 - %710 = fptrunc <2 x float> %709 to <2 x bfloat> - %711 = add i32 %669, 64 - %712 = mul i32 %711, 2 - %713 = sext i32 %712 to i64 - %714 = add i64 %689, %713 - %715 = inttoptr i64 %714 to ptr addrspace(1) - %716 = atomicrmw fadd ptr addrspace(1) %715, <2 x bfloat> %710 syncscope("agent") monotonic, align 4 - %717 = add i32 %671, 128 - %718 = mul i32 %717, 4 - %719 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %718 - %720 = sext i32 %719 to i64 - %721 = inttoptr i64 %720 to ptr addrspace(3) - %722 = load float, ptr addrspace(3) %721, align 4 - %723 = fmul float %722, %665 - %724 = add i32 %671, 129 - %725 = mul i32 %724, 4 - %726 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %725 - %727 = sext i32 %726 to i64 - %728 = inttoptr i64 %727 to ptr addrspace(3) - %729 = load float, ptr addrspace(3) %728, align 4 - %730 = fmul float %729, %665 - %731 = insertelement <2 x float> poison, float %723, i64 0 - %732 = insertelement <2 x float> %731, float %730, i64 1 - %733 = fptrunc <2 x float> %732 to <2 x bfloat> - %734 = add i32 %669, 128 - %735 = mul i32 %734, 2 - %736 = sext i32 %735 to i64 - %737 = add i64 %689, %736 - %738 = inttoptr i64 %737 to ptr addrspace(1) - %739 = atomicrmw fadd ptr addrspace(1) %738, <2 x bfloat> %733 syncscope("agent") monotonic, align 4 - %740 = add i32 %671, 192 - %741 = mul i32 %740, 4 - %742 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %741 - %743 = sext i32 %742 to i64 - %744 = inttoptr i64 %743 to ptr addrspace(3) - %745 = load float, ptr addrspace(3) %744, align 4 - %746 = fmul float %745, %665 - %747 = add i32 %671, 193 - %748 = mul i32 %747, 4 - %749 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %748 - %750 = sext i32 %749 to i64 - %751 = inttoptr i64 %750 to ptr addrspace(3) - %752 = load float, ptr addrspace(3) %751, align 4 - %753 = fmul float %752, %665 - %754 = insertelement <2 x float> poison, float %746, i64 0 - %755 = insertelement <2 x float> %754, float %753, i64 1 - %756 = fptrunc <2 x float> %755 to <2 x bfloat> - %757 = add i32 %669, 192 - %758 = mul i32 %757, 2 - %759 = sext i32 %758 to i64 - %760 = add i64 %689, %759 - %761 = inttoptr i64 %760 to ptr addrspace(1) - %762 = atomicrmw fadd ptr addrspace(1) %761, <2 x bfloat> %756 syncscope("agent") monotonic, align 4 - br label %763 - -763: ; preds = %666, %653 - %764 = add i32 %540, 16 - %765 = add i32 %66, %764 - %766 = mul i32 %765, 4 - %767 = sext i32 %766 to i64 - %768 = add i64 %545, %767 - %769 = inttoptr i64 %768 to ptr addrspace(1) - %770 = load i32, ptr addrspace(1) %769, align 4 - %771 = and i32 %770, 16777215 - %772 = icmp slt i32 %771, %16 - %773 = add i64 %552, %767 - %774 = inttoptr i64 %773 to ptr addrspace(1) - %775 = load float, ptr addrspace(1) %774, align 4 - br i1 %772, label %776, label %873 - -776: ; preds = %763 - %777 = mul i32 %771, 7168 - %778 = add i32 %777, %94 - %779 = add i32 %778, %542 - %780 = mul i32 %764, 256 - %781 = add i32 %780, %542 - %782 = mul i32 %781, 4 - %783 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %782 - %784 = sext i32 %783 to i64 - %785 = inttoptr i64 %784 to ptr addrspace(3) - %786 = load float, ptr addrspace(3) %785, align 4 - %787 = fmul float %786, %775 - %788 = add i32 %781, 1 - %789 = mul i32 %788, 4 - %790 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %789 - %791 = sext i32 %790 to i64 - %792 = inttoptr i64 %791 to ptr addrspace(3) - %793 = load float, ptr addrspace(3) %792, align 4 - %794 = fmul float %793, %775 - %795 = insertelement <2 x float> poison, float %787, i64 0 - %796 = insertelement <2 x float> %795, float %794, i64 1 - %797 = fptrunc <2 x float> %796 to <2 x bfloat> - %798 = mul i32 %779, 2 - %799 = ptrtoint ptr addrspace(1) %17 to i64 - %800 = sext i32 %798 to i64 - %801 = add i64 %799, %800 - %802 = inttoptr i64 %801 to ptr addrspace(1) - %803 = atomicrmw fadd ptr addrspace(1) %802, <2 x bfloat> %797 syncscope("agent") monotonic, align 4 - %804 = add i32 %781, 64 - %805 = mul i32 %804, 4 - %806 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %805 - %807 = sext i32 %806 to i64 - %808 = inttoptr i64 %807 to ptr addrspace(3) - %809 = load float, ptr addrspace(3) %808, align 4 - %810 = fmul float %809, %775 - %811 = add i32 %781, 65 - %812 = mul i32 %811, 4 - %813 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %812 - %814 = sext i32 %813 to i64 - %815 = inttoptr i64 %814 to ptr addrspace(3) - %816 = load float, ptr addrspace(3) %815, align 4 - %817 = fmul float %816, %775 - %818 = insertelement <2 x float> poison, float %810, i64 0 - %819 = insertelement <2 x float> %818, float %817, i64 1 - %820 = fptrunc <2 x float> %819 to <2 x bfloat> - %821 = add i32 %779, 64 - %822 = mul i32 %821, 2 - %823 = sext i32 %822 to i64 - %824 = add i64 %799, %823 - %825 = inttoptr i64 %824 to ptr addrspace(1) - %826 = atomicrmw fadd ptr addrspace(1) %825, <2 x bfloat> %820 syncscope("agent") monotonic, align 4 - %827 = add i32 %781, 128 - %828 = mul i32 %827, 4 - %829 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %828 - %830 = sext i32 %829 to i64 - %831 = inttoptr i64 %830 to ptr addrspace(3) - %832 = load float, ptr addrspace(3) %831, align 4 - %833 = fmul float %832, %775 - %834 = add i32 %781, 129 - %835 = mul i32 %834, 4 - %836 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %835 - %837 = sext i32 %836 to i64 - %838 = inttoptr i64 %837 to ptr addrspace(3) - %839 = load float, ptr addrspace(3) %838, align 4 - %840 = fmul float %839, %775 - %841 = insertelement <2 x float> poison, float %833, i64 0 - %842 = insertelement <2 x float> %841, float %840, i64 1 - %843 = fptrunc <2 x float> %842 to <2 x bfloat> - %844 = add i32 %779, 128 - %845 = mul i32 %844, 2 - %846 = sext i32 %845 to i64 - %847 = add i64 %799, %846 - %848 = inttoptr i64 %847 to ptr addrspace(1) - %849 = atomicrmw fadd ptr addrspace(1) %848, <2 x bfloat> %843 syncscope("agent") monotonic, align 4 - %850 = add i32 %781, 192 - %851 = mul i32 %850, 4 - %852 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %851 - %853 = sext i32 %852 to i64 - %854 = inttoptr i64 %853 to ptr addrspace(3) - %855 = load float, ptr addrspace(3) %854, align 4 - %856 = fmul float %855, %775 - %857 = add i32 %781, 193 - %858 = mul i32 %857, 4 - %859 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %858 - %860 = sext i32 %859 to i64 - %861 = inttoptr i64 %860 to ptr addrspace(3) - %862 = load float, ptr addrspace(3) %861, align 4 - %863 = fmul float %862, %775 - %864 = insertelement <2 x float> poison, float %856, i64 0 - %865 = insertelement <2 x float> %864, float %863, i64 1 - %866 = fptrunc <2 x float> %865 to <2 x bfloat> - %867 = add i32 %779, 192 - %868 = mul i32 %867, 2 - %869 = sext i32 %868 to i64 - %870 = add i64 %799, %869 - %871 = inttoptr i64 %870 to ptr addrspace(1) - %872 = atomicrmw fadd ptr addrspace(1) %871, <2 x bfloat> %866 syncscope("agent") monotonic, align 4 - br label %873 - -873: ; preds = %776, %763 - %874 = add i32 %540, 24 - %875 = add i32 %66, %874 - %876 = mul i32 %875, 4 - %877 = sext i32 %876 to i64 - %878 = add i64 %545, %877 - %879 = inttoptr i64 %878 to ptr addrspace(1) - %880 = load i32, ptr addrspace(1) %879, align 4 - %881 = and i32 %880, 16777215 - %882 = icmp slt i32 %881, %16 - %883 = add i64 %552, %877 - %884 = inttoptr i64 %883 to ptr addrspace(1) - %885 = load float, ptr addrspace(1) %884, align 4 - br i1 %882, label %886, label %983 - -886: ; preds = %873 - %887 = mul i32 %881, 7168 - %888 = add i32 %887, %94 - %889 = add i32 %888, %542 - %890 = mul i32 %874, 256 - %891 = add i32 %890, %542 - %892 = mul i32 %891, 4 - %893 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %892 - %894 = sext i32 %893 to i64 - %895 = inttoptr i64 %894 to ptr addrspace(3) - %896 = load float, ptr addrspace(3) %895, align 4 - %897 = fmul float %896, %885 - %898 = add i32 %891, 1 - %899 = mul i32 %898, 4 - %900 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %899 - %901 = sext i32 %900 to i64 - %902 = inttoptr i64 %901 to ptr addrspace(3) - %903 = load float, ptr addrspace(3) %902, align 4 - %904 = fmul float %903, %885 - %905 = insertelement <2 x float> poison, float %897, i64 0 - %906 = insertelement <2 x float> %905, float %904, i64 1 - %907 = fptrunc <2 x float> %906 to <2 x bfloat> - %908 = mul i32 %889, 2 - %909 = ptrtoint ptr addrspace(1) %17 to i64 - %910 = sext i32 %908 to i64 - %911 = add i64 %909, %910 - %912 = inttoptr i64 %911 to ptr addrspace(1) - %913 = atomicrmw fadd ptr addrspace(1) %912, <2 x bfloat> %907 syncscope("agent") monotonic, align 4 - %914 = add i32 %891, 64 - %915 = mul i32 %914, 4 - %916 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %915 - %917 = sext i32 %916 to i64 - %918 = inttoptr i64 %917 to ptr addrspace(3) - %919 = load float, ptr addrspace(3) %918, align 4 - %920 = fmul float %919, %885 - %921 = add i32 %891, 65 - %922 = mul i32 %921, 4 - %923 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %922 - %924 = sext i32 %923 to i64 - %925 = inttoptr i64 %924 to ptr addrspace(3) - %926 = load float, ptr addrspace(3) %925, align 4 - %927 = fmul float %926, %885 - %928 = insertelement <2 x float> poison, float %920, i64 0 - %929 = insertelement <2 x float> %928, float %927, i64 1 - %930 = fptrunc <2 x float> %929 to <2 x bfloat> - %931 = add i32 %889, 64 - %932 = mul i32 %931, 2 - %933 = sext i32 %932 to i64 - %934 = add i64 %909, %933 - %935 = inttoptr i64 %934 to ptr addrspace(1) - %936 = atomicrmw fadd ptr addrspace(1) %935, <2 x bfloat> %930 syncscope("agent") monotonic, align 4 - %937 = add i32 %891, 128 - %938 = mul i32 %937, 4 - %939 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %938 - %940 = sext i32 %939 to i64 - %941 = inttoptr i64 %940 to ptr addrspace(3) - %942 = load float, ptr addrspace(3) %941, align 4 - %943 = fmul float %942, %885 - %944 = add i32 %891, 129 - %945 = mul i32 %944, 4 - %946 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %945 - %947 = sext i32 %946 to i64 - %948 = inttoptr i64 %947 to ptr addrspace(3) - %949 = load float, ptr addrspace(3) %948, align 4 - %950 = fmul float %949, %885 - %951 = insertelement <2 x float> poison, float %943, i64 0 - %952 = insertelement <2 x float> %951, float %950, i64 1 - %953 = fptrunc <2 x float> %952 to <2 x bfloat> - %954 = add i32 %889, 128 - %955 = mul i32 %954, 2 - %956 = sext i32 %955 to i64 - %957 = add i64 %909, %956 - %958 = inttoptr i64 %957 to ptr addrspace(1) - %959 = atomicrmw fadd ptr addrspace(1) %958, <2 x bfloat> %953 syncscope("agent") monotonic, align 4 - %960 = add i32 %891, 192 - %961 = mul i32 %960, 4 - %962 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %961 - %963 = sext i32 %962 to i64 - %964 = inttoptr i64 %963 to ptr addrspace(3) - %965 = load float, ptr addrspace(3) %964, align 4 - %966 = fmul float %965, %885 - %967 = add i32 %891, 193 - %968 = mul i32 %967, 4 - %969 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %968 - %970 = sext i32 %969 to i64 - %971 = inttoptr i64 %970 to ptr addrspace(3) - %972 = load float, ptr addrspace(3) %971, align 4 - %973 = fmul float %972, %885 - %974 = insertelement <2 x float> poison, float %966, i64 0 - %975 = insertelement <2 x float> %974, float %973, i64 1 - %976 = fptrunc <2 x float> %975 to <2 x bfloat> - %977 = add i32 %889, 192 - %978 = mul i32 %977, 2 - %979 = sext i32 %978 to i64 - %980 = add i64 %909, %979 - %981 = inttoptr i64 %980 to ptr addrspace(1) - %982 = atomicrmw fadd ptr addrspace(1) %981, <2 x bfloat> %976 syncscope("agent") monotonic, align 4 - br label %983 - -983: ; preds = %886, %873 - br label %984 - -984: ; preds = %983, %19 - ret void -} - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) -declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 - -; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) -declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #3 - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #4 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.sched.barrier(i32 immarg) #5 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) -declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #7 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.s.barrier() #5 - -attributes #0 = { "amdgpu-flat-work-group-size"="256,256" "uniform-work-group-size" } -attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } -attributes #2 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } -attributes #3 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } -attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } -attributes #5 = { convergent nocallback nofree nounwind willreturn } -attributes #6 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } -attributes #7 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} -!1 = !{i32 256, i32 1, i32 1} diff --git a/kernels/gemm2_port_ref/flydsl_port_v4.ll b/kernels/gemm2_port_ref/flydsl_port_v4.ll deleted file mode 100644 index 7d427907f..000000000 --- a/kernels/gemm2_port_ref/flydsl_port_v4.ll +++ /dev/null @@ -1,943 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" -target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" - -@gemm2port_smem = external addrspace(3) global [32768 x i8], align 1024 - -define amdgpu_kernel void @gemm2_a4w4_port_bm32_atomic(ptr addrspace(1) %0, <{ <{ i32, i32 }>, <{ i64 }> }> %1, ptr addrspace(1) %2, <{ <{ i32, i32 }>, <{ i64 }> }> %3, ptr addrspace(1) %4, <{ <{ i32, i32, i32 }>, <{ i64, i64 }> }> %5, ptr addrspace(1) %6, <{ <{ i32, i32 }>, <{ i64 }> }> %7, ptr addrspace(1) %8, <{ <{ i32 }> }> %9, ptr addrspace(1) %10, <{ <{ i32 }> }> %11, ptr addrspace(1) %12, <{ <{ i32 }> }> %13, ptr addrspace(1) %14, <{ <{ i32 }> }> %15, i32 %16, ptr addrspace(1) %17, <{ <{ i32, i32 }>, <{ i64 }> }> %18) #0 !reqd_work_group_size !1 { - %20 = call range(i32 0, 256) i32 @llvm.amdgcn.workitem.id.x() - %21 = sext i32 %20 to i64 - %22 = call i32 @llvm.amdgcn.workgroup.id.x() - %23 = sext i32 %22 to i64 - %24 = trunc i64 %21 to i32 - %25 = trunc i64 %23 to i32 - %26 = srem i32 %24, 64 - %27 = sdiv i32 %24, 64 - %28 = mul i32 %27, 64 - %29 = icmp ne i32 %24, %28 - %30 = icmp slt i32 %24, 0 - %31 = icmp ne i1 %30, false - %32 = and i1 %29, %31 - %33 = add i32 %27, -1 - %34 = select i1 %32, i32 %33, i32 %27 - %35 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %34) - %36 = ptrtoint ptr addrspace(1) %10 to i64 - %37 = inttoptr i64 %36 to ptr addrspace(1) - %38 = load i32, ptr addrspace(1) %37, align 4 - %39 = sdiv i32 %38, 32 - %40 = mul i32 %39, 32 - %41 = icmp ne i32 %38, %40 - %42 = icmp slt i32 %38, 0 - %43 = icmp ne i1 %42, false - %44 = and i1 %41, %43 - %45 = add i32 %39, -1 - %46 = select i1 %44, i32 %45, i32 %39 - %47 = mul i32 %46, 28 - %48 = icmp slt i32 %25, %47 - br i1 %48, label %49, label %844 - -49: ; preds = %19 - %50 = srem i32 %25, 28 - %51 = sdiv i32 %25, 28 - %52 = mul i32 %51, 28 - %53 = icmp ne i32 %25, %52 - %54 = icmp slt i32 %25, 0 - %55 = icmp ne i1 %54, false - %56 = and i1 %53, %55 - %57 = add i32 %51, -1 - %58 = select i1 %56, i32 %57, i32 %51 - %59 = mul i32 %58, 4 - %60 = ptrtoint ptr addrspace(1) %8 to i64 - %61 = sext i32 %59 to i64 - %62 = add i64 %60, %61 - %63 = inttoptr i64 %62 to ptr addrspace(1) - %64 = load i32, ptr addrspace(1) %63, align 4 - %65 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %64) - %66 = mul i32 %58, 32 - %67 = addrspacecast ptr addrspace(1) %0 to ptr - %68 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %67, i16 0, i64 167772160, i32 159744) - %69 = addrspacecast ptr addrspace(1) %2 to ptr - %70 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %69, i16 0, i64 10485760, i32 159744) - %71 = addrspacecast ptr addrspace(1) %4 to ptr - %72 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %71, i16 0, i64 706478080, i32 159744) - %73 = addrspacecast ptr addrspace(1) %6 to ptr - %74 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %73, i16 0, i64 44154880, i32 159744) - %75 = sdiv i32 %26, 8 - %76 = mul i32 %75, 8 - %77 = icmp ne i32 %26, %76 - %78 = icmp slt i32 %26, 0 - %79 = icmp ne i1 %78, false - %80 = and i1 %77, %79 - %81 = add i32 %75, -1 - %82 = select i1 %80, i32 %81, i32 %75 - %83 = srem i32 %26, 8 - %84 = sdiv i32 %26, 16 - %85 = mul i32 %84, 16 - %86 = icmp ne i32 %26, %85 - %87 = icmp slt i32 %26, 0 - %88 = icmp ne i1 %87, false - %89 = and i1 %86, %88 - %90 = add i32 %84, -1 - %91 = select i1 %89, i32 %90, i32 %84 - %92 = srem i32 %26, 16 - %93 = mul i32 %65, 7168 - %94 = mul i32 %50, 256 - %95 = add i32 %93, %94 - %96 = mul i32 %35, 64 - %97 = add i32 %95, %96 - %98 = mul i32 %97, 256 - %99 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %98) - %100 = add i32 %97, 16 - %101 = mul i32 %100, 256 - %102 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %101) - %103 = add i32 %97, 32 - %104 = mul i32 %103, 256 - %105 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %104) - %106 = add i32 %97, 48 - %107 = mul i32 %106, 256 - %108 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %107) - %109 = mul i32 %50, 8 - %110 = mul i32 %35, 2 - %111 = add i32 %109, %110 - %112 = mul i32 %65, 28672 - %113 = mul i32 %111, 128 - %114 = add i32 %112, %113 - %115 = mul i32 %114, 4 - %116 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %115) - %117 = add i32 %111, 1 - %118 = mul i32 %117, 128 - %119 = add i32 %112, %118 - %120 = mul i32 %119, 4 - %121 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %120) - %122 = sdiv i32 %66, 32 - %123 = mul i32 %122, 32 - %124 = icmp ne i32 %66, %123 - %125 = icmp slt i32 %66, 0 - %126 = icmp ne i1 %125, false - %127 = and i1 %124, %126 - %128 = add i32 %122, -1 - %129 = select i1 %127, i32 %128, i32 %122 - %130 = mul i32 %129, 512 - %131 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %130) - %132 = mul i32 %35, 8 - %133 = add i32 %66, %132 - %134 = add i32 %133, %82 - %135 = add i32 %132, %82 - %136 = and i32 %135, 14 - %137 = shl i32 %136, 3 - %138 = mul i32 %83, 16 - %139 = xor i32 %138, %137 - %140 = mul i32 %134, 256 - %141 = add i32 %139, %140 - %142 = mul i32 %35, 1024 - %143 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %142 - %144 = sext i32 %143 to i64 - %145 = inttoptr i64 %144 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %68, ptr addrspace(3) %145, i32 16, i32 %141, i32 0, i32 0, i32 0) - %146 = add i32 %142, 4096 - %147 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %146 - %148 = sext i32 %147 to i64 - %149 = inttoptr i64 %148 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %68, ptr addrspace(3) %149, i32 16, i32 %141, i32 128, i32 0, i32 0) - call void @llvm.amdgcn.sched.barrier(i32 0) - %150 = mul i32 %91, 16 - %151 = add i32 %150, %92 - %152 = mul i32 %151, 4 - %153 = sdiv i32 %152, 4 - %154 = mul i32 %153, 4 - %155 = icmp ne i32 %152, %154 - %156 = icmp slt i32 %152, 0 - %157 = icmp ne i1 %156, false - %158 = and i1 %155, %157 - %159 = add i32 %153, -1 - %160 = select i1 %158, i32 %159, i32 %153 - %161 = mul i32 %160, 4 - %162 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %70, i32 %161, i32 %131, i32 0) - %163 = add i32 %152, 256 - %164 = sdiv i32 %163, 4 - %165 = mul i32 %164, 4 - %166 = icmp ne i32 %163, %165 - %167 = icmp slt i32 %163, 0 - %168 = icmp ne i1 %167, false - %169 = and i1 %166, %168 - %170 = add i32 %164, -1 - %171 = select i1 %169, i32 %170, i32 %164 - %172 = mul i32 %171, 4 - %173 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %70, i32 %172, i32 %131, i32 0) - %174 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %161, i32 %116, i32 0) - %175 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %161, i32 %121, i32 0) - %176 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %172, i32 %116, i32 0) - %177 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %74, i32 %172, i32 %121, i32 0) - %178 = mul i32 %91, 256 - %179 = mul i32 %92, 16 - %180 = add i32 %178, %179 - %181 = sdiv i32 %180, 4 - %182 = mul i32 %181, 4 - %183 = icmp ne i32 %180, %182 - %184 = icmp slt i32 %180, 0 - %185 = icmp ne i1 %184, false - %186 = and i1 %183, %185 - %187 = add i32 %181, -1 - %188 = select i1 %186, i32 %187, i32 %181 - %189 = mul i32 %188, 4 - %190 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %99, i32 0) - %191 = add i32 %180, 1024 - %192 = sdiv i32 %191, 4 - %193 = mul i32 %192, 4 - %194 = icmp ne i32 %191, %193 - %195 = icmp slt i32 %191, 0 - %196 = icmp ne i1 %195, false - %197 = and i1 %194, %196 - %198 = add i32 %192, -1 - %199 = select i1 %197, i32 %198, i32 %192 - %200 = mul i32 %199, 4 - %201 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %99, i32 0) - %202 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %102, i32 0) - %203 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %102, i32 0) - %204 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %105, i32 0) - %205 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %105, i32 0) - %206 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %189, i32 %108, i32 0) - %207 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %200, i32 %108, i32 0) - %208 = add i32 %180, 2048 - %209 = sdiv i32 %208, 4 - %210 = mul i32 %209, 4 - %211 = icmp ne i32 %208, %210 - %212 = icmp slt i32 %208, 0 - %213 = icmp ne i1 %212, false - %214 = and i1 %211, %213 - %215 = add i32 %209, -1 - %216 = select i1 %214, i32 %215, i32 %209 - %217 = mul i32 %216, 4 - %218 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %99, i32 0) - %219 = add i32 %180, 3072 - %220 = sdiv i32 %219, 4 - %221 = mul i32 %220, 4 - %222 = icmp ne i32 %219, %221 - %223 = icmp slt i32 %219, 0 - %224 = icmp ne i1 %223, false - %225 = and i1 %222, %224 - %226 = add i32 %220, -1 - %227 = select i1 %225, i32 %226, i32 %220 - %228 = mul i32 %227, 4 - %229 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %99, i32 0) - %230 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %102, i32 0) - %231 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %102, i32 0) - %232 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %105, i32 0) - %233 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %105, i32 0) - %234 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %217, i32 %108, i32 0) - %235 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %72, i32 %228, i32 %108, i32 0) - call void asm sideeffect "s_waitcnt vmcnt(23)", ""() - call void asm sideeffect "s_barrier", ""() - %236 = and i32 %92, 14 - %237 = shl i32 %236, 3 - %238 = sext i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32) to i64 - %239 = inttoptr i64 %238 to ptr addrspace(3) - %240 = xor i32 %150, %237 - %241 = mul i32 %92, 128 - %242 = add i32 %241, %240 - %243 = getelementptr i8, ptr addrspace(3) %239, i32 %242 - %244 = load <4 x i32>, ptr addrspace(3) %243, align 16 - %245 = add i32 %92, 16 - %246 = mul i32 %245, 128 - %247 = add i32 %246, %240 - %248 = getelementptr i8, ptr addrspace(3) %239, i32 %247 - %249 = load <4 x i32>, ptr addrspace(3) %248, align 16 - %250 = add i32 %150, 64 - %251 = xor i32 %250, %237 - %252 = add i32 %241, %251 - %253 = getelementptr i8, ptr addrspace(3) %239, i32 %252 - %254 = load <4 x i32>, ptr addrspace(3) %253, align 16 - %255 = add i32 %246, %251 - %256 = getelementptr i8, ptr addrspace(3) %239, i32 %255 - %257 = load <4 x i32>, ptr addrspace(3) %256, align 16 - %258 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %190, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 0, i32 %174) - %259 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %190, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 0, i32 %174) - %260 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %254, <4 x i32> %201, <4 x float> %258, i32 4, i32 4, i32 2, i32 %162, i32 2, i32 %174) - %261 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %257, <4 x i32> %201, <4 x float> %259, i32 4, i32 4, i32 3, i32 %162, i32 2, i32 %174) - %262 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 1, i32 %174) - %263 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %202, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 1, i32 %174) - %264 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %254, <4 x i32> %203, <4 x float> %262, i32 4, i32 4, i32 2, i32 %162, i32 3, i32 %174) - %265 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %257, <4 x i32> %203, <4 x float> %263, i32 4, i32 4, i32 3, i32 %162, i32 3, i32 %174) - %266 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 0, i32 %175) - %267 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %204, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 0, i32 %175) - %268 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %254, <4 x i32> %205, <4 x float> %266, i32 4, i32 4, i32 2, i32 %162, i32 2, i32 %175) - %269 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %257, <4 x i32> %205, <4 x float> %267, i32 4, i32 4, i32 3, i32 %162, i32 2, i32 %175) - %270 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %244, <4 x i32> %206, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %162, i32 1, i32 %175) - %271 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %249, <4 x i32> %206, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %162, i32 1, i32 %175) - %272 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %254, <4 x i32> %207, <4 x float> %270, i32 4, i32 4, i32 2, i32 %162, i32 3, i32 %175) - %273 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %257, <4 x i32> %207, <4 x float> %271, i32 4, i32 4, i32 3, i32 %162, i32 3, i32 %175) - call void asm sideeffect "s_waitcnt vmcnt(22)", ""() - call void asm sideeffect "s_barrier", ""() - %274 = add i32 %241, 4096 - %275 = add i32 %274, %240 - %276 = getelementptr i8, ptr addrspace(3) %239, i32 %275 - %277 = load <4 x i32>, ptr addrspace(3) %276, align 16 - %278 = add i32 %246, 4096 - %279 = add i32 %278, %240 - %280 = getelementptr i8, ptr addrspace(3) %239, i32 %279 - %281 = load <4 x i32>, ptr addrspace(3) %280, align 16 - %282 = add i32 %274, %251 - %283 = getelementptr i8, ptr addrspace(3) %239, i32 %282 - %284 = load <4 x i32>, ptr addrspace(3) %283, align 16 - %285 = add i32 %278, %251 - %286 = getelementptr i8, ptr addrspace(3) %239, i32 %285 - %287 = load <4 x i32>, ptr addrspace(3) %286, align 16 - %288 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %277, <4 x i32> %218, <4 x float> %260, i32 4, i32 4, i32 0, i32 %173, i32 0, i32 %176) - %289 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %281, <4 x i32> %218, <4 x float> %261, i32 4, i32 4, i32 1, i32 %173, i32 0, i32 %176) - %290 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %284, <4 x i32> %229, <4 x float> %288, i32 4, i32 4, i32 2, i32 %173, i32 2, i32 %176) - %291 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %287, <4 x i32> %229, <4 x float> %289, i32 4, i32 4, i32 3, i32 %173, i32 2, i32 %176) - %292 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %277, <4 x i32> %230, <4 x float> %264, i32 4, i32 4, i32 0, i32 %173, i32 1, i32 %176) - %293 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %281, <4 x i32> %230, <4 x float> %265, i32 4, i32 4, i32 1, i32 %173, i32 1, i32 %176) - %294 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %284, <4 x i32> %231, <4 x float> %292, i32 4, i32 4, i32 2, i32 %173, i32 3, i32 %176) - %295 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %287, <4 x i32> %231, <4 x float> %293, i32 4, i32 4, i32 3, i32 %173, i32 3, i32 %176) - %296 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %277, <4 x i32> %232, <4 x float> %268, i32 4, i32 4, i32 0, i32 %173, i32 0, i32 %177) - %297 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %281, <4 x i32> %232, <4 x float> %269, i32 4, i32 4, i32 1, i32 %173, i32 0, i32 %177) - %298 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %284, <4 x i32> %233, <4 x float> %296, i32 4, i32 4, i32 2, i32 %173, i32 2, i32 %177) - %299 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %287, <4 x i32> %233, <4 x float> %297, i32 4, i32 4, i32 3, i32 %173, i32 2, i32 %177) - %300 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %277, <4 x i32> %234, <4 x float> %272, i32 4, i32 4, i32 0, i32 %173, i32 1, i32 %177) - %301 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %281, <4 x i32> %234, <4 x float> %273, i32 4, i32 4, i32 1, i32 %173, i32 1, i32 %177) - %302 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %284, <4 x i32> %235, <4 x float> %300, i32 4, i32 4, i32 2, i32 %173, i32 3, i32 %177) - %303 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %287, <4 x i32> %235, <4 x float> %301, i32 4, i32 4, i32 3, i32 %173, i32 3, i32 %177) - %304 = sext i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32) to i64 - %305 = inttoptr i64 %304 to ptr addrspace(3) - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %306 = mul i32 %91, 4 - %307 = add i32 %96, %92 - %308 = mul i32 %91, 1024 - %309 = add i32 %308, %307 - %310 = extractelement <4 x float> %290, i64 0 - %311 = mul i32 %309, 4 - %312 = getelementptr i8, ptr addrspace(3) %305, i32 %311 - store float %310, ptr addrspace(3) %312, align 4 - %313 = add i32 %306, 1 - %314 = mul i32 %313, 256 - %315 = add i32 %314, %307 - %316 = extractelement <4 x float> %290, i64 1 - %317 = mul i32 %315, 4 - %318 = getelementptr i8, ptr addrspace(3) %305, i32 %317 - store float %316, ptr addrspace(3) %318, align 4 - %319 = add i32 %306, 2 - %320 = mul i32 %319, 256 - %321 = add i32 %320, %307 - %322 = extractelement <4 x float> %290, i64 2 - %323 = mul i32 %321, 4 - %324 = getelementptr i8, ptr addrspace(3) %305, i32 %323 - store float %322, ptr addrspace(3) %324, align 4 - %325 = add i32 %306, 3 - %326 = mul i32 %325, 256 - %327 = add i32 %326, %307 - %328 = extractelement <4 x float> %290, i64 3 - %329 = mul i32 %327, 4 - %330 = getelementptr i8, ptr addrspace(3) %305, i32 %329 - store float %328, ptr addrspace(3) %330, align 4 - %331 = add i32 %96, 16 - %332 = add i32 %331, %92 - %333 = add i32 %308, %332 - %334 = extractelement <4 x float> %294, i64 0 - %335 = mul i32 %333, 4 - %336 = getelementptr i8, ptr addrspace(3) %305, i32 %335 - store float %334, ptr addrspace(3) %336, align 4 - %337 = add i32 %314, %332 - %338 = extractelement <4 x float> %294, i64 1 - %339 = mul i32 %337, 4 - %340 = getelementptr i8, ptr addrspace(3) %305, i32 %339 - store float %338, ptr addrspace(3) %340, align 4 - %341 = add i32 %320, %332 - %342 = extractelement <4 x float> %294, i64 2 - %343 = mul i32 %341, 4 - %344 = getelementptr i8, ptr addrspace(3) %305, i32 %343 - store float %342, ptr addrspace(3) %344, align 4 - %345 = add i32 %326, %332 - %346 = extractelement <4 x float> %294, i64 3 - %347 = mul i32 %345, 4 - %348 = getelementptr i8, ptr addrspace(3) %305, i32 %347 - store float %346, ptr addrspace(3) %348, align 4 - %349 = add i32 %96, 32 - %350 = add i32 %349, %92 - %351 = add i32 %308, %350 - %352 = extractelement <4 x float> %298, i64 0 - %353 = mul i32 %351, 4 - %354 = getelementptr i8, ptr addrspace(3) %305, i32 %353 - store float %352, ptr addrspace(3) %354, align 4 - %355 = add i32 %314, %350 - %356 = extractelement <4 x float> %298, i64 1 - %357 = mul i32 %355, 4 - %358 = getelementptr i8, ptr addrspace(3) %305, i32 %357 - store float %356, ptr addrspace(3) %358, align 4 - %359 = add i32 %320, %350 - %360 = extractelement <4 x float> %298, i64 2 - %361 = mul i32 %359, 4 - %362 = getelementptr i8, ptr addrspace(3) %305, i32 %361 - store float %360, ptr addrspace(3) %362, align 4 - %363 = add i32 %326, %350 - %364 = extractelement <4 x float> %298, i64 3 - %365 = mul i32 %363, 4 - %366 = getelementptr i8, ptr addrspace(3) %305, i32 %365 - store float %364, ptr addrspace(3) %366, align 4 - %367 = add i32 %96, 48 - %368 = add i32 %367, %92 - %369 = add i32 %308, %368 - %370 = extractelement <4 x float> %302, i64 0 - %371 = mul i32 %369, 4 - %372 = getelementptr i8, ptr addrspace(3) %305, i32 %371 - store float %370, ptr addrspace(3) %372, align 4 - %373 = add i32 %314, %368 - %374 = extractelement <4 x float> %302, i64 1 - %375 = mul i32 %373, 4 - %376 = getelementptr i8, ptr addrspace(3) %305, i32 %375 - store float %374, ptr addrspace(3) %376, align 4 - %377 = add i32 %320, %368 - %378 = extractelement <4 x float> %302, i64 2 - %379 = mul i32 %377, 4 - %380 = getelementptr i8, ptr addrspace(3) %305, i32 %379 - store float %378, ptr addrspace(3) %380, align 4 - %381 = add i32 %326, %368 - %382 = extractelement <4 x float> %302, i64 3 - %383 = mul i32 %381, 4 - %384 = getelementptr i8, ptr addrspace(3) %305, i32 %383 - store float %382, ptr addrspace(3) %384, align 4 - %385 = add i32 %306, 16 - %386 = mul i32 %385, 256 - %387 = add i32 %386, %307 - %388 = extractelement <4 x float> %291, i64 0 - %389 = mul i32 %387, 4 - %390 = getelementptr i8, ptr addrspace(3) %305, i32 %389 - store float %388, ptr addrspace(3) %390, align 4 - %391 = add i32 %306, 17 - %392 = mul i32 %391, 256 - %393 = add i32 %392, %307 - %394 = extractelement <4 x float> %291, i64 1 - %395 = mul i32 %393, 4 - %396 = getelementptr i8, ptr addrspace(3) %305, i32 %395 - store float %394, ptr addrspace(3) %396, align 4 - %397 = add i32 %306, 18 - %398 = mul i32 %397, 256 - %399 = add i32 %398, %307 - %400 = extractelement <4 x float> %291, i64 2 - %401 = mul i32 %399, 4 - %402 = getelementptr i8, ptr addrspace(3) %305, i32 %401 - store float %400, ptr addrspace(3) %402, align 4 - %403 = add i32 %306, 19 - %404 = mul i32 %403, 256 - %405 = add i32 %404, %307 - %406 = extractelement <4 x float> %291, i64 3 - %407 = mul i32 %405, 4 - %408 = getelementptr i8, ptr addrspace(3) %305, i32 %407 - store float %406, ptr addrspace(3) %408, align 4 - %409 = add i32 %386, %332 - %410 = extractelement <4 x float> %295, i64 0 - %411 = mul i32 %409, 4 - %412 = getelementptr i8, ptr addrspace(3) %305, i32 %411 - store float %410, ptr addrspace(3) %412, align 4 - %413 = add i32 %392, %332 - %414 = extractelement <4 x float> %295, i64 1 - %415 = mul i32 %413, 4 - %416 = getelementptr i8, ptr addrspace(3) %305, i32 %415 - store float %414, ptr addrspace(3) %416, align 4 - %417 = add i32 %398, %332 - %418 = extractelement <4 x float> %295, i64 2 - %419 = mul i32 %417, 4 - %420 = getelementptr i8, ptr addrspace(3) %305, i32 %419 - store float %418, ptr addrspace(3) %420, align 4 - %421 = add i32 %404, %332 - %422 = extractelement <4 x float> %295, i64 3 - %423 = mul i32 %421, 4 - %424 = getelementptr i8, ptr addrspace(3) %305, i32 %423 - store float %422, ptr addrspace(3) %424, align 4 - %425 = add i32 %386, %350 - %426 = extractelement <4 x float> %299, i64 0 - %427 = mul i32 %425, 4 - %428 = getelementptr i8, ptr addrspace(3) %305, i32 %427 - store float %426, ptr addrspace(3) %428, align 4 - %429 = add i32 %392, %350 - %430 = extractelement <4 x float> %299, i64 1 - %431 = mul i32 %429, 4 - %432 = getelementptr i8, ptr addrspace(3) %305, i32 %431 - store float %430, ptr addrspace(3) %432, align 4 - %433 = add i32 %398, %350 - %434 = extractelement <4 x float> %299, i64 2 - %435 = mul i32 %433, 4 - %436 = getelementptr i8, ptr addrspace(3) %305, i32 %435 - store float %434, ptr addrspace(3) %436, align 4 - %437 = add i32 %404, %350 - %438 = extractelement <4 x float> %299, i64 3 - %439 = mul i32 %437, 4 - %440 = getelementptr i8, ptr addrspace(3) %305, i32 %439 - store float %438, ptr addrspace(3) %440, align 4 - %441 = add i32 %386, %368 - %442 = extractelement <4 x float> %303, i64 0 - %443 = mul i32 %441, 4 - %444 = getelementptr i8, ptr addrspace(3) %305, i32 %443 - store float %442, ptr addrspace(3) %444, align 4 - %445 = add i32 %392, %368 - %446 = extractelement <4 x float> %303, i64 1 - %447 = mul i32 %445, 4 - %448 = getelementptr i8, ptr addrspace(3) %305, i32 %447 - store float %446, ptr addrspace(3) %448, align 4 - %449 = add i32 %398, %368 - %450 = extractelement <4 x float> %303, i64 2 - %451 = mul i32 %449, 4 - %452 = getelementptr i8, ptr addrspace(3) %305, i32 %451 - store float %450, ptr addrspace(3) %452, align 4 - %453 = add i32 %404, %368 - %454 = extractelement <4 x float> %303, i64 3 - %455 = mul i32 %453, 4 - %456 = getelementptr i8, ptr addrspace(3) %305, i32 %455 - store float %454, ptr addrspace(3) %456, align 4 - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %457 = sdiv i32 %24, 32 - %458 = mul i32 %457, 32 - %459 = icmp ne i32 %24, %458 - %460 = icmp slt i32 %24, 0 - %461 = icmp ne i1 %460, false - %462 = and i1 %459, %461 - %463 = add i32 %457, -1 - %464 = select i1 %462, i32 %463, i32 %457 - %465 = srem i32 %24, 32 - %466 = mul i32 %465, 2 - %467 = add i32 %66, %464 - %468 = mul i32 %467, 4 - %469 = ptrtoint ptr addrspace(1) %12 to i64 - %470 = sext i32 %468 to i64 - %471 = add i64 %469, %470 - %472 = inttoptr i64 %471 to ptr addrspace(1) - %473 = load i32, ptr addrspace(1) %472, align 4 - %474 = and i32 %473, 16777215 - %475 = icmp slt i32 %474, %16 - %476 = ptrtoint ptr addrspace(1) %14 to i64 - %477 = add i64 %476, %470 - %478 = inttoptr i64 %477 to ptr addrspace(1) - %479 = load float, ptr addrspace(1) %478, align 4 - br i1 %475, label %480, label %561 - -480: ; preds = %49 - %481 = mul i32 %474, 7168 - %482 = add i32 %481, %94 - %483 = add i32 %482, %466 - %484 = mul i32 %464, 256 - %485 = add i32 %484, %466 - %486 = mul i32 %485, 4 - %487 = getelementptr i8, ptr addrspace(3) %305, i32 %486 - %488 = load float, ptr addrspace(3) %487, align 4 - %489 = fmul float %488, %479 - %490 = add i32 %485, 1 - %491 = mul i32 %490, 4 - %492 = getelementptr i8, ptr addrspace(3) %305, i32 %491 - %493 = load float, ptr addrspace(3) %492, align 4 - %494 = fmul float %493, %479 - %495 = insertelement <2 x float> poison, float %489, i64 0 - %496 = insertelement <2 x float> %495, float %494, i64 1 - %497 = fptrunc <2 x float> %496 to <2 x bfloat> - %498 = mul i32 %483, 2 - %499 = ptrtoint ptr addrspace(1) %17 to i64 - %500 = sext i32 %498 to i64 - %501 = add i64 %499, %500 - %502 = inttoptr i64 %501 to ptr addrspace(1) - %503 = atomicrmw fadd ptr addrspace(1) %502, <2 x bfloat> %497 syncscope("agent") monotonic, align 4 - %504 = add i32 %485, 64 - %505 = mul i32 %504, 4 - %506 = getelementptr i8, ptr addrspace(3) %305, i32 %505 - %507 = load float, ptr addrspace(3) %506, align 4 - %508 = fmul float %507, %479 - %509 = add i32 %485, 65 - %510 = mul i32 %509, 4 - %511 = getelementptr i8, ptr addrspace(3) %305, i32 %510 - %512 = load float, ptr addrspace(3) %511, align 4 - %513 = fmul float %512, %479 - %514 = insertelement <2 x float> poison, float %508, i64 0 - %515 = insertelement <2 x float> %514, float %513, i64 1 - %516 = fptrunc <2 x float> %515 to <2 x bfloat> - %517 = add i32 %483, 64 - %518 = mul i32 %517, 2 - %519 = sext i32 %518 to i64 - %520 = add i64 %499, %519 - %521 = inttoptr i64 %520 to ptr addrspace(1) - %522 = atomicrmw fadd ptr addrspace(1) %521, <2 x bfloat> %516 syncscope("agent") monotonic, align 4 - %523 = add i32 %485, 128 - %524 = mul i32 %523, 4 - %525 = getelementptr i8, ptr addrspace(3) %305, i32 %524 - %526 = load float, ptr addrspace(3) %525, align 4 - %527 = fmul float %526, %479 - %528 = add i32 %485, 129 - %529 = mul i32 %528, 4 - %530 = getelementptr i8, ptr addrspace(3) %305, i32 %529 - %531 = load float, ptr addrspace(3) %530, align 4 - %532 = fmul float %531, %479 - %533 = insertelement <2 x float> poison, float %527, i64 0 - %534 = insertelement <2 x float> %533, float %532, i64 1 - %535 = fptrunc <2 x float> %534 to <2 x bfloat> - %536 = add i32 %483, 128 - %537 = mul i32 %536, 2 - %538 = sext i32 %537 to i64 - %539 = add i64 %499, %538 - %540 = inttoptr i64 %539 to ptr addrspace(1) - %541 = atomicrmw fadd ptr addrspace(1) %540, <2 x bfloat> %535 syncscope("agent") monotonic, align 4 - %542 = add i32 %485, 192 - %543 = mul i32 %542, 4 - %544 = getelementptr i8, ptr addrspace(3) %305, i32 %543 - %545 = load float, ptr addrspace(3) %544, align 4 - %546 = fmul float %545, %479 - %547 = add i32 %485, 193 - %548 = mul i32 %547, 4 - %549 = getelementptr i8, ptr addrspace(3) %305, i32 %548 - %550 = load float, ptr addrspace(3) %549, align 4 - %551 = fmul float %550, %479 - %552 = insertelement <2 x float> poison, float %546, i64 0 - %553 = insertelement <2 x float> %552, float %551, i64 1 - %554 = fptrunc <2 x float> %553 to <2 x bfloat> - %555 = add i32 %483, 192 - %556 = mul i32 %555, 2 - %557 = sext i32 %556 to i64 - %558 = add i64 %499, %557 - %559 = inttoptr i64 %558 to ptr addrspace(1) - %560 = atomicrmw fadd ptr addrspace(1) %559, <2 x bfloat> %554 syncscope("agent") monotonic, align 4 - br label %561 - -561: ; preds = %480, %49 - %562 = add i32 %464, 8 - %563 = add i32 %66, %562 - %564 = mul i32 %563, 4 - %565 = sext i32 %564 to i64 - %566 = add i64 %469, %565 - %567 = inttoptr i64 %566 to ptr addrspace(1) - %568 = load i32, ptr addrspace(1) %567, align 4 - %569 = and i32 %568, 16777215 - %570 = icmp slt i32 %569, %16 - %571 = add i64 %476, %565 - %572 = inttoptr i64 %571 to ptr addrspace(1) - %573 = load float, ptr addrspace(1) %572, align 4 - br i1 %570, label %574, label %655 - -574: ; preds = %561 - %575 = mul i32 %569, 7168 - %576 = add i32 %575, %94 - %577 = add i32 %576, %466 - %578 = mul i32 %562, 256 - %579 = add i32 %578, %466 - %580 = mul i32 %579, 4 - %581 = getelementptr i8, ptr addrspace(3) %305, i32 %580 - %582 = load float, ptr addrspace(3) %581, align 4 - %583 = fmul float %582, %573 - %584 = add i32 %579, 1 - %585 = mul i32 %584, 4 - %586 = getelementptr i8, ptr addrspace(3) %305, i32 %585 - %587 = load float, ptr addrspace(3) %586, align 4 - %588 = fmul float %587, %573 - %589 = insertelement <2 x float> poison, float %583, i64 0 - %590 = insertelement <2 x float> %589, float %588, i64 1 - %591 = fptrunc <2 x float> %590 to <2 x bfloat> - %592 = mul i32 %577, 2 - %593 = ptrtoint ptr addrspace(1) %17 to i64 - %594 = sext i32 %592 to i64 - %595 = add i64 %593, %594 - %596 = inttoptr i64 %595 to ptr addrspace(1) - %597 = atomicrmw fadd ptr addrspace(1) %596, <2 x bfloat> %591 syncscope("agent") monotonic, align 4 - %598 = add i32 %579, 64 - %599 = mul i32 %598, 4 - %600 = getelementptr i8, ptr addrspace(3) %305, i32 %599 - %601 = load float, ptr addrspace(3) %600, align 4 - %602 = fmul float %601, %573 - %603 = add i32 %579, 65 - %604 = mul i32 %603, 4 - %605 = getelementptr i8, ptr addrspace(3) %305, i32 %604 - %606 = load float, ptr addrspace(3) %605, align 4 - %607 = fmul float %606, %573 - %608 = insertelement <2 x float> poison, float %602, i64 0 - %609 = insertelement <2 x float> %608, float %607, i64 1 - %610 = fptrunc <2 x float> %609 to <2 x bfloat> - %611 = add i32 %577, 64 - %612 = mul i32 %611, 2 - %613 = sext i32 %612 to i64 - %614 = add i64 %593, %613 - %615 = inttoptr i64 %614 to ptr addrspace(1) - %616 = atomicrmw fadd ptr addrspace(1) %615, <2 x bfloat> %610 syncscope("agent") monotonic, align 4 - %617 = add i32 %579, 128 - %618 = mul i32 %617, 4 - %619 = getelementptr i8, ptr addrspace(3) %305, i32 %618 - %620 = load float, ptr addrspace(3) %619, align 4 - %621 = fmul float %620, %573 - %622 = add i32 %579, 129 - %623 = mul i32 %622, 4 - %624 = getelementptr i8, ptr addrspace(3) %305, i32 %623 - %625 = load float, ptr addrspace(3) %624, align 4 - %626 = fmul float %625, %573 - %627 = insertelement <2 x float> poison, float %621, i64 0 - %628 = insertelement <2 x float> %627, float %626, i64 1 - %629 = fptrunc <2 x float> %628 to <2 x bfloat> - %630 = add i32 %577, 128 - %631 = mul i32 %630, 2 - %632 = sext i32 %631 to i64 - %633 = add i64 %593, %632 - %634 = inttoptr i64 %633 to ptr addrspace(1) - %635 = atomicrmw fadd ptr addrspace(1) %634, <2 x bfloat> %629 syncscope("agent") monotonic, align 4 - %636 = add i32 %579, 192 - %637 = mul i32 %636, 4 - %638 = getelementptr i8, ptr addrspace(3) %305, i32 %637 - %639 = load float, ptr addrspace(3) %638, align 4 - %640 = fmul float %639, %573 - %641 = add i32 %579, 193 - %642 = mul i32 %641, 4 - %643 = getelementptr i8, ptr addrspace(3) %305, i32 %642 - %644 = load float, ptr addrspace(3) %643, align 4 - %645 = fmul float %644, %573 - %646 = insertelement <2 x float> poison, float %640, i64 0 - %647 = insertelement <2 x float> %646, float %645, i64 1 - %648 = fptrunc <2 x float> %647 to <2 x bfloat> - %649 = add i32 %577, 192 - %650 = mul i32 %649, 2 - %651 = sext i32 %650 to i64 - %652 = add i64 %593, %651 - %653 = inttoptr i64 %652 to ptr addrspace(1) - %654 = atomicrmw fadd ptr addrspace(1) %653, <2 x bfloat> %648 syncscope("agent") monotonic, align 4 - br label %655 - -655: ; preds = %574, %561 - %656 = add i32 %464, 16 - %657 = add i32 %66, %656 - %658 = mul i32 %657, 4 - %659 = sext i32 %658 to i64 - %660 = add i64 %469, %659 - %661 = inttoptr i64 %660 to ptr addrspace(1) - %662 = load i32, ptr addrspace(1) %661, align 4 - %663 = and i32 %662, 16777215 - %664 = icmp slt i32 %663, %16 - %665 = add i64 %476, %659 - %666 = inttoptr i64 %665 to ptr addrspace(1) - %667 = load float, ptr addrspace(1) %666, align 4 - br i1 %664, label %668, label %749 - -668: ; preds = %655 - %669 = mul i32 %663, 7168 - %670 = add i32 %669, %94 - %671 = add i32 %670, %466 - %672 = mul i32 %656, 256 - %673 = add i32 %672, %466 - %674 = mul i32 %673, 4 - %675 = getelementptr i8, ptr addrspace(3) %305, i32 %674 - %676 = load float, ptr addrspace(3) %675, align 4 - %677 = fmul float %676, %667 - %678 = add i32 %673, 1 - %679 = mul i32 %678, 4 - %680 = getelementptr i8, ptr addrspace(3) %305, i32 %679 - %681 = load float, ptr addrspace(3) %680, align 4 - %682 = fmul float %681, %667 - %683 = insertelement <2 x float> poison, float %677, i64 0 - %684 = insertelement <2 x float> %683, float %682, i64 1 - %685 = fptrunc <2 x float> %684 to <2 x bfloat> - %686 = mul i32 %671, 2 - %687 = ptrtoint ptr addrspace(1) %17 to i64 - %688 = sext i32 %686 to i64 - %689 = add i64 %687, %688 - %690 = inttoptr i64 %689 to ptr addrspace(1) - %691 = atomicrmw fadd ptr addrspace(1) %690, <2 x bfloat> %685 syncscope("agent") monotonic, align 4 - %692 = add i32 %673, 64 - %693 = mul i32 %692, 4 - %694 = getelementptr i8, ptr addrspace(3) %305, i32 %693 - %695 = load float, ptr addrspace(3) %694, align 4 - %696 = fmul float %695, %667 - %697 = add i32 %673, 65 - %698 = mul i32 %697, 4 - %699 = getelementptr i8, ptr addrspace(3) %305, i32 %698 - %700 = load float, ptr addrspace(3) %699, align 4 - %701 = fmul float %700, %667 - %702 = insertelement <2 x float> poison, float %696, i64 0 - %703 = insertelement <2 x float> %702, float %701, i64 1 - %704 = fptrunc <2 x float> %703 to <2 x bfloat> - %705 = add i32 %671, 64 - %706 = mul i32 %705, 2 - %707 = sext i32 %706 to i64 - %708 = add i64 %687, %707 - %709 = inttoptr i64 %708 to ptr addrspace(1) - %710 = atomicrmw fadd ptr addrspace(1) %709, <2 x bfloat> %704 syncscope("agent") monotonic, align 4 - %711 = add i32 %673, 128 - %712 = mul i32 %711, 4 - %713 = getelementptr i8, ptr addrspace(3) %305, i32 %712 - %714 = load float, ptr addrspace(3) %713, align 4 - %715 = fmul float %714, %667 - %716 = add i32 %673, 129 - %717 = mul i32 %716, 4 - %718 = getelementptr i8, ptr addrspace(3) %305, i32 %717 - %719 = load float, ptr addrspace(3) %718, align 4 - %720 = fmul float %719, %667 - %721 = insertelement <2 x float> poison, float %715, i64 0 - %722 = insertelement <2 x float> %721, float %720, i64 1 - %723 = fptrunc <2 x float> %722 to <2 x bfloat> - %724 = add i32 %671, 128 - %725 = mul i32 %724, 2 - %726 = sext i32 %725 to i64 - %727 = add i64 %687, %726 - %728 = inttoptr i64 %727 to ptr addrspace(1) - %729 = atomicrmw fadd ptr addrspace(1) %728, <2 x bfloat> %723 syncscope("agent") monotonic, align 4 - %730 = add i32 %673, 192 - %731 = mul i32 %730, 4 - %732 = getelementptr i8, ptr addrspace(3) %305, i32 %731 - %733 = load float, ptr addrspace(3) %732, align 4 - %734 = fmul float %733, %667 - %735 = add i32 %673, 193 - %736 = mul i32 %735, 4 - %737 = getelementptr i8, ptr addrspace(3) %305, i32 %736 - %738 = load float, ptr addrspace(3) %737, align 4 - %739 = fmul float %738, %667 - %740 = insertelement <2 x float> poison, float %734, i64 0 - %741 = insertelement <2 x float> %740, float %739, i64 1 - %742 = fptrunc <2 x float> %741 to <2 x bfloat> - %743 = add i32 %671, 192 - %744 = mul i32 %743, 2 - %745 = sext i32 %744 to i64 - %746 = add i64 %687, %745 - %747 = inttoptr i64 %746 to ptr addrspace(1) - %748 = atomicrmw fadd ptr addrspace(1) %747, <2 x bfloat> %742 syncscope("agent") monotonic, align 4 - br label %749 - -749: ; preds = %668, %655 - %750 = add i32 %464, 24 - %751 = add i32 %66, %750 - %752 = mul i32 %751, 4 - %753 = sext i32 %752 to i64 - %754 = add i64 %469, %753 - %755 = inttoptr i64 %754 to ptr addrspace(1) - %756 = load i32, ptr addrspace(1) %755, align 4 - %757 = and i32 %756, 16777215 - %758 = icmp slt i32 %757, %16 - %759 = add i64 %476, %753 - %760 = inttoptr i64 %759 to ptr addrspace(1) - %761 = load float, ptr addrspace(1) %760, align 4 - br i1 %758, label %762, label %843 - -762: ; preds = %749 - %763 = mul i32 %757, 7168 - %764 = add i32 %763, %94 - %765 = add i32 %764, %466 - %766 = mul i32 %750, 256 - %767 = add i32 %766, %466 - %768 = mul i32 %767, 4 - %769 = getelementptr i8, ptr addrspace(3) %305, i32 %768 - %770 = load float, ptr addrspace(3) %769, align 4 - %771 = fmul float %770, %761 - %772 = add i32 %767, 1 - %773 = mul i32 %772, 4 - %774 = getelementptr i8, ptr addrspace(3) %305, i32 %773 - %775 = load float, ptr addrspace(3) %774, align 4 - %776 = fmul float %775, %761 - %777 = insertelement <2 x float> poison, float %771, i64 0 - %778 = insertelement <2 x float> %777, float %776, i64 1 - %779 = fptrunc <2 x float> %778 to <2 x bfloat> - %780 = mul i32 %765, 2 - %781 = ptrtoint ptr addrspace(1) %17 to i64 - %782 = sext i32 %780 to i64 - %783 = add i64 %781, %782 - %784 = inttoptr i64 %783 to ptr addrspace(1) - %785 = atomicrmw fadd ptr addrspace(1) %784, <2 x bfloat> %779 syncscope("agent") monotonic, align 4 - %786 = add i32 %767, 64 - %787 = mul i32 %786, 4 - %788 = getelementptr i8, ptr addrspace(3) %305, i32 %787 - %789 = load float, ptr addrspace(3) %788, align 4 - %790 = fmul float %789, %761 - %791 = add i32 %767, 65 - %792 = mul i32 %791, 4 - %793 = getelementptr i8, ptr addrspace(3) %305, i32 %792 - %794 = load float, ptr addrspace(3) %793, align 4 - %795 = fmul float %794, %761 - %796 = insertelement <2 x float> poison, float %790, i64 0 - %797 = insertelement <2 x float> %796, float %795, i64 1 - %798 = fptrunc <2 x float> %797 to <2 x bfloat> - %799 = add i32 %765, 64 - %800 = mul i32 %799, 2 - %801 = sext i32 %800 to i64 - %802 = add i64 %781, %801 - %803 = inttoptr i64 %802 to ptr addrspace(1) - %804 = atomicrmw fadd ptr addrspace(1) %803, <2 x bfloat> %798 syncscope("agent") monotonic, align 4 - %805 = add i32 %767, 128 - %806 = mul i32 %805, 4 - %807 = getelementptr i8, ptr addrspace(3) %305, i32 %806 - %808 = load float, ptr addrspace(3) %807, align 4 - %809 = fmul float %808, %761 - %810 = add i32 %767, 129 - %811 = mul i32 %810, 4 - %812 = getelementptr i8, ptr addrspace(3) %305, i32 %811 - %813 = load float, ptr addrspace(3) %812, align 4 - %814 = fmul float %813, %761 - %815 = insertelement <2 x float> poison, float %809, i64 0 - %816 = insertelement <2 x float> %815, float %814, i64 1 - %817 = fptrunc <2 x float> %816 to <2 x bfloat> - %818 = add i32 %765, 128 - %819 = mul i32 %818, 2 - %820 = sext i32 %819 to i64 - %821 = add i64 %781, %820 - %822 = inttoptr i64 %821 to ptr addrspace(1) - %823 = atomicrmw fadd ptr addrspace(1) %822, <2 x bfloat> %817 syncscope("agent") monotonic, align 4 - %824 = add i32 %767, 192 - %825 = mul i32 %824, 4 - %826 = getelementptr i8, ptr addrspace(3) %305, i32 %825 - %827 = load float, ptr addrspace(3) %826, align 4 - %828 = fmul float %827, %761 - %829 = add i32 %767, 193 - %830 = mul i32 %829, 4 - %831 = getelementptr i8, ptr addrspace(3) %305, i32 %830 - %832 = load float, ptr addrspace(3) %831, align 4 - %833 = fmul float %832, %761 - %834 = insertelement <2 x float> poison, float %828, i64 0 - %835 = insertelement <2 x float> %834, float %833, i64 1 - %836 = fptrunc <2 x float> %835 to <2 x bfloat> - %837 = add i32 %765, 192 - %838 = mul i32 %837, 2 - %839 = sext i32 %838 to i64 - %840 = add i64 %781, %839 - %841 = inttoptr i64 %840 to ptr addrspace(1) - %842 = atomicrmw fadd ptr addrspace(1) %841, <2 x bfloat> %836 syncscope("agent") monotonic, align 4 - br label %843 - -843: ; preds = %762, %749 - br label %844 - -844: ; preds = %843, %19 - ret void -} - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) -declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 - -; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) -declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #3 - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #4 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.sched.barrier(i32 immarg) #5 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) -declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #7 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.s.barrier() #5 - -attributes #0 = { "amdgpu-flat-work-group-size"="256,256" "uniform-work-group-size" } -attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } -attributes #2 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } -attributes #3 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } -attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } -attributes #5 = { convergent nocallback nofree nounwind willreturn } -attributes #6 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } -attributes #7 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} -!1 = !{i32 256, i32 1, i32 1} diff --git a/kernels/gemm2_port_ref/flydsl_port_v5.ll b/kernels/gemm2_port_ref/flydsl_port_v5.ll deleted file mode 100644 index 702f18afa..000000000 --- a/kernels/gemm2_port_ref/flydsl_port_v5.ll +++ /dev/null @@ -1,898 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" -target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" - -@gemm2port_smem = external addrspace(3) global [32768 x i8], align 1024 - -define amdgpu_kernel void @gemm2_a4w4_port_bm32_atomic(ptr addrspace(1) %0, <{ <{ i32, i32 }>, <{ i64 }> }> %1, ptr addrspace(1) %2, <{ <{ i32, i32 }>, <{ i64 }> }> %3, ptr addrspace(1) %4, <{ <{ i32, i32, i32 }>, <{ i64, i64 }> }> %5, ptr addrspace(1) %6, <{ <{ i32, i32 }>, <{ i64 }> }> %7, ptr addrspace(1) %8, <{ <{ i32 }> }> %9, ptr addrspace(1) %10, <{ <{ i32 }> }> %11, ptr addrspace(1) %12, <{ <{ i32 }> }> %13, ptr addrspace(1) %14, <{ <{ i32 }> }> %15, i32 %16, ptr addrspace(1) %17, <{ <{ i32, i32 }>, <{ i64 }> }> %18) #0 !reqd_work_group_size !1 { - %20 = call range(i32 0, 256) i32 @llvm.amdgcn.workitem.id.x() - %21 = sext i32 %20 to i64 - %22 = call i32 @llvm.amdgcn.workgroup.id.x() - %23 = sext i32 %22 to i64 - %24 = trunc i64 %21 to i32 - %25 = trunc i64 %23 to i32 - %26 = srem i32 %24, 64 - %27 = sdiv i32 %24, 64 - %28 = mul i32 %27, 64 - %29 = icmp ne i32 %24, %28 - %30 = icmp slt i32 %24, 0 - %31 = icmp ne i1 %30, false - %32 = and i1 %29, %31 - %33 = add i32 %27, -1 - %34 = select i1 %32, i32 %33, i32 %27 - %35 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %34) - %36 = ptrtoint ptr addrspace(1) %10 to i64 - %37 = inttoptr i64 %36 to ptr addrspace(1) - %38 = load i32, ptr addrspace(1) %37, align 4 - %39 = sdiv i32 %38, 32 - %40 = mul i32 %39, 32 - %41 = icmp ne i32 %38, %40 - %42 = icmp slt i32 %38, 0 - %43 = icmp ne i1 %42, false - %44 = and i1 %41, %43 - %45 = add i32 %39, -1 - %46 = select i1 %44, i32 %45, i32 %39 - %47 = mul i32 %46, 28 - %48 = icmp slt i32 %25, %47 - br i1 %48, label %49, label %799 - -49: ; preds = %19 - %50 = srem i32 %25, 28 - %51 = sdiv i32 %25, 28 - %52 = mul i32 %51, 28 - %53 = icmp ne i32 %25, %52 - %54 = icmp slt i32 %25, 0 - %55 = icmp ne i1 %54, false - %56 = and i1 %53, %55 - %57 = add i32 %51, -1 - %58 = select i1 %56, i32 %57, i32 %51 - %59 = mul i32 %58, 4 - %60 = ptrtoint ptr addrspace(1) %8 to i64 - %61 = inttoptr i64 %60 to ptr addrspace(1) - %62 = getelementptr i8, ptr addrspace(1) %61, i32 %59 - %63 = load i32, ptr addrspace(1) %62, align 4 - %64 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %63) - %65 = mul i32 %58, 32 - %66 = addrspacecast ptr addrspace(1) %0 to ptr - %67 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %66, i16 0, i64 167772160, i32 159744) - %68 = addrspacecast ptr addrspace(1) %2 to ptr - %69 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %68, i16 0, i64 10485760, i32 159744) - %70 = addrspacecast ptr addrspace(1) %4 to ptr - %71 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %70, i16 0, i64 706478080, i32 159744) - %72 = addrspacecast ptr addrspace(1) %6 to ptr - %73 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %72, i16 0, i64 44154880, i32 159744) - %74 = sdiv i32 %26, 8 - %75 = mul i32 %74, 8 - %76 = icmp ne i32 %26, %75 - %77 = icmp slt i32 %26, 0 - %78 = icmp ne i1 %77, false - %79 = and i1 %76, %78 - %80 = add i32 %74, -1 - %81 = select i1 %79, i32 %80, i32 %74 - %82 = srem i32 %26, 8 - %83 = sdiv i32 %26, 16 - %84 = mul i32 %83, 16 - %85 = icmp ne i32 %26, %84 - %86 = icmp slt i32 %26, 0 - %87 = icmp ne i1 %86, false - %88 = and i1 %85, %87 - %89 = add i32 %83, -1 - %90 = select i1 %88, i32 %89, i32 %83 - %91 = srem i32 %26, 16 - %92 = mul i32 %64, 7168 - %93 = mul i32 %50, 256 - %94 = add i32 %92, %93 - %95 = mul i32 %35, 64 - %96 = add i32 %94, %95 - %97 = mul i32 %96, 256 - %98 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %97) - %99 = add i32 %96, 16 - %100 = mul i32 %99, 256 - %101 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %100) - %102 = add i32 %96, 32 - %103 = mul i32 %102, 256 - %104 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %103) - %105 = add i32 %96, 48 - %106 = mul i32 %105, 256 - %107 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %106) - %108 = mul i32 %50, 8 - %109 = mul i32 %35, 2 - %110 = add i32 %108, %109 - %111 = mul i32 %64, 28672 - %112 = mul i32 %110, 128 - %113 = add i32 %111, %112 - %114 = mul i32 %113, 4 - %115 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %114) - %116 = add i32 %110, 1 - %117 = mul i32 %116, 128 - %118 = add i32 %111, %117 - %119 = mul i32 %118, 4 - %120 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %119) - %121 = sdiv i32 %65, 32 - %122 = mul i32 %121, 32 - %123 = icmp ne i32 %65, %122 - %124 = icmp slt i32 %65, 0 - %125 = icmp ne i1 %124, false - %126 = and i1 %123, %125 - %127 = add i32 %121, -1 - %128 = select i1 %126, i32 %127, i32 %121 - %129 = mul i32 %128, 512 - %130 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %129) - %131 = mul i32 %35, 8 - %132 = add i32 %65, %131 - %133 = add i32 %132, %81 - %134 = add i32 %131, %81 - %135 = and i32 %134, 14 - %136 = shl i32 %135, 3 - %137 = mul i32 %82, 16 - %138 = xor i32 %137, %136 - %139 = mul i32 %133, 256 - %140 = add i32 %138, %139 - %141 = mul i32 %35, 1024 - %142 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %141 - %143 = sext i32 %142 to i64 - %144 = inttoptr i64 %143 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %67, ptr addrspace(3) %144, i32 16, i32 %140, i32 0, i32 0, i32 0) - %145 = add i32 %141, 4096 - %146 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %145 - %147 = sext i32 %146 to i64 - %148 = inttoptr i64 %147 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %67, ptr addrspace(3) %148, i32 16, i32 %140, i32 128, i32 0, i32 0) - call void @llvm.amdgcn.sched.barrier(i32 0) - %149 = mul i32 %90, 16 - %150 = add i32 %149, %91 - %151 = mul i32 %150, 4 - %152 = sdiv i32 %151, 4 - %153 = mul i32 %152, 4 - %154 = icmp ne i32 %151, %153 - %155 = icmp slt i32 %151, 0 - %156 = icmp ne i1 %155, false - %157 = and i1 %154, %156 - %158 = add i32 %152, -1 - %159 = select i1 %157, i32 %158, i32 %152 - %160 = mul i32 %159, 4 - %161 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %69, i32 %160, i32 %130, i32 0) - %162 = add i32 %151, 256 - %163 = sdiv i32 %162, 4 - %164 = mul i32 %163, 4 - %165 = icmp ne i32 %162, %164 - %166 = icmp slt i32 %162, 0 - %167 = icmp ne i1 %166, false - %168 = and i1 %165, %167 - %169 = add i32 %163, -1 - %170 = select i1 %168, i32 %169, i32 %163 - %171 = mul i32 %170, 4 - %172 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %69, i32 %171, i32 %130, i32 0) - %173 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %160, i32 %115, i32 0) - %174 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %160, i32 %120, i32 0) - %175 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %171, i32 %115, i32 0) - %176 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %171, i32 %120, i32 0) - %177 = mul i32 %90, 256 - %178 = mul i32 %91, 16 - %179 = add i32 %177, %178 - %180 = sdiv i32 %179, 4 - %181 = mul i32 %180, 4 - %182 = icmp ne i32 %179, %181 - %183 = icmp slt i32 %179, 0 - %184 = icmp ne i1 %183, false - %185 = and i1 %182, %184 - %186 = add i32 %180, -1 - %187 = select i1 %185, i32 %186, i32 %180 - %188 = mul i32 %187, 4 - %189 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %98, i32 0) - %190 = add i32 %179, 1024 - %191 = sdiv i32 %190, 4 - %192 = mul i32 %191, 4 - %193 = icmp ne i32 %190, %192 - %194 = icmp slt i32 %190, 0 - %195 = icmp ne i1 %194, false - %196 = and i1 %193, %195 - %197 = add i32 %191, -1 - %198 = select i1 %196, i32 %197, i32 %191 - %199 = mul i32 %198, 4 - %200 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %98, i32 0) - %201 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %101, i32 0) - %202 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %101, i32 0) - %203 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %104, i32 0) - %204 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %104, i32 0) - %205 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %107, i32 0) - %206 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %107, i32 0) - %207 = add i32 %179, 2048 - %208 = sdiv i32 %207, 4 - %209 = mul i32 %208, 4 - %210 = icmp ne i32 %207, %209 - %211 = icmp slt i32 %207, 0 - %212 = icmp ne i1 %211, false - %213 = and i1 %210, %212 - %214 = add i32 %208, -1 - %215 = select i1 %213, i32 %214, i32 %208 - %216 = mul i32 %215, 4 - %217 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %98, i32 0) - %218 = add i32 %179, 3072 - %219 = sdiv i32 %218, 4 - %220 = mul i32 %219, 4 - %221 = icmp ne i32 %218, %220 - %222 = icmp slt i32 %218, 0 - %223 = icmp ne i1 %222, false - %224 = and i1 %221, %223 - %225 = add i32 %219, -1 - %226 = select i1 %224, i32 %225, i32 %219 - %227 = mul i32 %226, 4 - %228 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %98, i32 0) - %229 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %101, i32 0) - %230 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %101, i32 0) - %231 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %104, i32 0) - %232 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %104, i32 0) - %233 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %107, i32 0) - %234 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %107, i32 0) - call void asm sideeffect "s_waitcnt vmcnt(23)", ""() - call void asm sideeffect "s_barrier", ""() - %235 = and i32 %91, 14 - %236 = shl i32 %235, 3 - %237 = sext i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32) to i64 - %238 = inttoptr i64 %237 to ptr addrspace(3) - %239 = xor i32 %149, %236 - %240 = mul i32 %91, 128 - %241 = add i32 %240, %239 - %242 = getelementptr i8, ptr addrspace(3) %238, i32 %241 - %243 = load <4 x i32>, ptr addrspace(3) %242, align 16 - %244 = add i32 %91, 16 - %245 = mul i32 %244, 128 - %246 = add i32 %245, %239 - %247 = getelementptr i8, ptr addrspace(3) %238, i32 %246 - %248 = load <4 x i32>, ptr addrspace(3) %247, align 16 - %249 = add i32 %149, 64 - %250 = xor i32 %249, %236 - %251 = add i32 %240, %250 - %252 = getelementptr i8, ptr addrspace(3) %238, i32 %251 - %253 = load <4 x i32>, ptr addrspace(3) %252, align 16 - %254 = add i32 %245, %250 - %255 = getelementptr i8, ptr addrspace(3) %238, i32 %254 - %256 = load <4 x i32>, ptr addrspace(3) %255, align 16 - %257 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %189, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 0, i32 %173) - %258 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %189, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 0, i32 %173) - %259 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %200, <4 x float> %257, i32 4, i32 4, i32 2, i32 %161, i32 2, i32 %173) - %260 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %200, <4 x float> %258, i32 4, i32 4, i32 3, i32 %161, i32 2, i32 %173) - %261 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %201, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 1, i32 %173) - %262 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %201, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 1, i32 %173) - %263 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %202, <4 x float> %261, i32 4, i32 4, i32 2, i32 %161, i32 3, i32 %173) - %264 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %202, <4 x float> %262, i32 4, i32 4, i32 3, i32 %161, i32 3, i32 %173) - %265 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %203, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 0, i32 %174) - %266 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %203, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 0, i32 %174) - %267 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %204, <4 x float> %265, i32 4, i32 4, i32 2, i32 %161, i32 2, i32 %174) - %268 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %204, <4 x float> %266, i32 4, i32 4, i32 3, i32 %161, i32 2, i32 %174) - %269 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %205, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 1, i32 %174) - %270 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %205, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 1, i32 %174) - %271 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %206, <4 x float> %269, i32 4, i32 4, i32 2, i32 %161, i32 3, i32 %174) - %272 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %206, <4 x float> %270, i32 4, i32 4, i32 3, i32 %161, i32 3, i32 %174) - call void asm sideeffect "s_waitcnt vmcnt(22)", ""() - call void asm sideeffect "s_barrier", ""() - %273 = add i32 %240, 4096 - %274 = add i32 %273, %239 - %275 = getelementptr i8, ptr addrspace(3) %238, i32 %274 - %276 = load <4 x i32>, ptr addrspace(3) %275, align 16 - %277 = add i32 %245, 4096 - %278 = add i32 %277, %239 - %279 = getelementptr i8, ptr addrspace(3) %238, i32 %278 - %280 = load <4 x i32>, ptr addrspace(3) %279, align 16 - %281 = add i32 %273, %250 - %282 = getelementptr i8, ptr addrspace(3) %238, i32 %281 - %283 = load <4 x i32>, ptr addrspace(3) %282, align 16 - %284 = add i32 %277, %250 - %285 = getelementptr i8, ptr addrspace(3) %238, i32 %284 - %286 = load <4 x i32>, ptr addrspace(3) %285, align 16 - %287 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %217, <4 x float> %259, i32 4, i32 4, i32 0, i32 %172, i32 0, i32 %175) - %288 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %217, <4 x float> %260, i32 4, i32 4, i32 1, i32 %172, i32 0, i32 %175) - %289 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %228, <4 x float> %287, i32 4, i32 4, i32 2, i32 %172, i32 2, i32 %175) - %290 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %228, <4 x float> %288, i32 4, i32 4, i32 3, i32 %172, i32 2, i32 %175) - %291 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %229, <4 x float> %263, i32 4, i32 4, i32 0, i32 %172, i32 1, i32 %175) - %292 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %229, <4 x float> %264, i32 4, i32 4, i32 1, i32 %172, i32 1, i32 %175) - %293 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %230, <4 x float> %291, i32 4, i32 4, i32 2, i32 %172, i32 3, i32 %175) - %294 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %230, <4 x float> %292, i32 4, i32 4, i32 3, i32 %172, i32 3, i32 %175) - %295 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %231, <4 x float> %267, i32 4, i32 4, i32 0, i32 %172, i32 0, i32 %176) - %296 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %231, <4 x float> %268, i32 4, i32 4, i32 1, i32 %172, i32 0, i32 %176) - %297 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %232, <4 x float> %295, i32 4, i32 4, i32 2, i32 %172, i32 2, i32 %176) - %298 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %232, <4 x float> %296, i32 4, i32 4, i32 3, i32 %172, i32 2, i32 %176) - %299 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %233, <4 x float> %271, i32 4, i32 4, i32 0, i32 %172, i32 1, i32 %176) - %300 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %233, <4 x float> %272, i32 4, i32 4, i32 1, i32 %172, i32 1, i32 %176) - %301 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %234, <4 x float> %299, i32 4, i32 4, i32 2, i32 %172, i32 3, i32 %176) - %302 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %234, <4 x float> %300, i32 4, i32 4, i32 3, i32 %172, i32 3, i32 %176) - %303 = sext i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32) to i64 - %304 = inttoptr i64 %303 to ptr addrspace(3) - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %305 = mul i32 %90, 4 - %306 = add i32 %95, %91 - %307 = mul i32 %90, 1024 - %308 = add i32 %307, %306 - %309 = extractelement <4 x float> %289, i64 0 - %310 = mul i32 %308, 4 - %311 = getelementptr i8, ptr addrspace(3) %304, i32 %310 - store float %309, ptr addrspace(3) %311, align 4 - %312 = add i32 %305, 1 - %313 = mul i32 %312, 256 - %314 = add i32 %313, %306 - %315 = extractelement <4 x float> %289, i64 1 - %316 = mul i32 %314, 4 - %317 = getelementptr i8, ptr addrspace(3) %304, i32 %316 - store float %315, ptr addrspace(3) %317, align 4 - %318 = add i32 %305, 2 - %319 = mul i32 %318, 256 - %320 = add i32 %319, %306 - %321 = extractelement <4 x float> %289, i64 2 - %322 = mul i32 %320, 4 - %323 = getelementptr i8, ptr addrspace(3) %304, i32 %322 - store float %321, ptr addrspace(3) %323, align 4 - %324 = add i32 %305, 3 - %325 = mul i32 %324, 256 - %326 = add i32 %325, %306 - %327 = extractelement <4 x float> %289, i64 3 - %328 = mul i32 %326, 4 - %329 = getelementptr i8, ptr addrspace(3) %304, i32 %328 - store float %327, ptr addrspace(3) %329, align 4 - %330 = add i32 %95, 16 - %331 = add i32 %330, %91 - %332 = add i32 %307, %331 - %333 = extractelement <4 x float> %293, i64 0 - %334 = mul i32 %332, 4 - %335 = getelementptr i8, ptr addrspace(3) %304, i32 %334 - store float %333, ptr addrspace(3) %335, align 4 - %336 = add i32 %313, %331 - %337 = extractelement <4 x float> %293, i64 1 - %338 = mul i32 %336, 4 - %339 = getelementptr i8, ptr addrspace(3) %304, i32 %338 - store float %337, ptr addrspace(3) %339, align 4 - %340 = add i32 %319, %331 - %341 = extractelement <4 x float> %293, i64 2 - %342 = mul i32 %340, 4 - %343 = getelementptr i8, ptr addrspace(3) %304, i32 %342 - store float %341, ptr addrspace(3) %343, align 4 - %344 = add i32 %325, %331 - %345 = extractelement <4 x float> %293, i64 3 - %346 = mul i32 %344, 4 - %347 = getelementptr i8, ptr addrspace(3) %304, i32 %346 - store float %345, ptr addrspace(3) %347, align 4 - %348 = add i32 %95, 32 - %349 = add i32 %348, %91 - %350 = add i32 %307, %349 - %351 = extractelement <4 x float> %297, i64 0 - %352 = mul i32 %350, 4 - %353 = getelementptr i8, ptr addrspace(3) %304, i32 %352 - store float %351, ptr addrspace(3) %353, align 4 - %354 = add i32 %313, %349 - %355 = extractelement <4 x float> %297, i64 1 - %356 = mul i32 %354, 4 - %357 = getelementptr i8, ptr addrspace(3) %304, i32 %356 - store float %355, ptr addrspace(3) %357, align 4 - %358 = add i32 %319, %349 - %359 = extractelement <4 x float> %297, i64 2 - %360 = mul i32 %358, 4 - %361 = getelementptr i8, ptr addrspace(3) %304, i32 %360 - store float %359, ptr addrspace(3) %361, align 4 - %362 = add i32 %325, %349 - %363 = extractelement <4 x float> %297, i64 3 - %364 = mul i32 %362, 4 - %365 = getelementptr i8, ptr addrspace(3) %304, i32 %364 - store float %363, ptr addrspace(3) %365, align 4 - %366 = add i32 %95, 48 - %367 = add i32 %366, %91 - %368 = add i32 %307, %367 - %369 = extractelement <4 x float> %301, i64 0 - %370 = mul i32 %368, 4 - %371 = getelementptr i8, ptr addrspace(3) %304, i32 %370 - store float %369, ptr addrspace(3) %371, align 4 - %372 = add i32 %313, %367 - %373 = extractelement <4 x float> %301, i64 1 - %374 = mul i32 %372, 4 - %375 = getelementptr i8, ptr addrspace(3) %304, i32 %374 - store float %373, ptr addrspace(3) %375, align 4 - %376 = add i32 %319, %367 - %377 = extractelement <4 x float> %301, i64 2 - %378 = mul i32 %376, 4 - %379 = getelementptr i8, ptr addrspace(3) %304, i32 %378 - store float %377, ptr addrspace(3) %379, align 4 - %380 = add i32 %325, %367 - %381 = extractelement <4 x float> %301, i64 3 - %382 = mul i32 %380, 4 - %383 = getelementptr i8, ptr addrspace(3) %304, i32 %382 - store float %381, ptr addrspace(3) %383, align 4 - %384 = add i32 %305, 16 - %385 = mul i32 %384, 256 - %386 = add i32 %385, %306 - %387 = extractelement <4 x float> %290, i64 0 - %388 = mul i32 %386, 4 - %389 = getelementptr i8, ptr addrspace(3) %304, i32 %388 - store float %387, ptr addrspace(3) %389, align 4 - %390 = add i32 %305, 17 - %391 = mul i32 %390, 256 - %392 = add i32 %391, %306 - %393 = extractelement <4 x float> %290, i64 1 - %394 = mul i32 %392, 4 - %395 = getelementptr i8, ptr addrspace(3) %304, i32 %394 - store float %393, ptr addrspace(3) %395, align 4 - %396 = add i32 %305, 18 - %397 = mul i32 %396, 256 - %398 = add i32 %397, %306 - %399 = extractelement <4 x float> %290, i64 2 - %400 = mul i32 %398, 4 - %401 = getelementptr i8, ptr addrspace(3) %304, i32 %400 - store float %399, ptr addrspace(3) %401, align 4 - %402 = add i32 %305, 19 - %403 = mul i32 %402, 256 - %404 = add i32 %403, %306 - %405 = extractelement <4 x float> %290, i64 3 - %406 = mul i32 %404, 4 - %407 = getelementptr i8, ptr addrspace(3) %304, i32 %406 - store float %405, ptr addrspace(3) %407, align 4 - %408 = add i32 %385, %331 - %409 = extractelement <4 x float> %294, i64 0 - %410 = mul i32 %408, 4 - %411 = getelementptr i8, ptr addrspace(3) %304, i32 %410 - store float %409, ptr addrspace(3) %411, align 4 - %412 = add i32 %391, %331 - %413 = extractelement <4 x float> %294, i64 1 - %414 = mul i32 %412, 4 - %415 = getelementptr i8, ptr addrspace(3) %304, i32 %414 - store float %413, ptr addrspace(3) %415, align 4 - %416 = add i32 %397, %331 - %417 = extractelement <4 x float> %294, i64 2 - %418 = mul i32 %416, 4 - %419 = getelementptr i8, ptr addrspace(3) %304, i32 %418 - store float %417, ptr addrspace(3) %419, align 4 - %420 = add i32 %403, %331 - %421 = extractelement <4 x float> %294, i64 3 - %422 = mul i32 %420, 4 - %423 = getelementptr i8, ptr addrspace(3) %304, i32 %422 - store float %421, ptr addrspace(3) %423, align 4 - %424 = add i32 %385, %349 - %425 = extractelement <4 x float> %298, i64 0 - %426 = mul i32 %424, 4 - %427 = getelementptr i8, ptr addrspace(3) %304, i32 %426 - store float %425, ptr addrspace(3) %427, align 4 - %428 = add i32 %391, %349 - %429 = extractelement <4 x float> %298, i64 1 - %430 = mul i32 %428, 4 - %431 = getelementptr i8, ptr addrspace(3) %304, i32 %430 - store float %429, ptr addrspace(3) %431, align 4 - %432 = add i32 %397, %349 - %433 = extractelement <4 x float> %298, i64 2 - %434 = mul i32 %432, 4 - %435 = getelementptr i8, ptr addrspace(3) %304, i32 %434 - store float %433, ptr addrspace(3) %435, align 4 - %436 = add i32 %403, %349 - %437 = extractelement <4 x float> %298, i64 3 - %438 = mul i32 %436, 4 - %439 = getelementptr i8, ptr addrspace(3) %304, i32 %438 - store float %437, ptr addrspace(3) %439, align 4 - %440 = add i32 %385, %367 - %441 = extractelement <4 x float> %302, i64 0 - %442 = mul i32 %440, 4 - %443 = getelementptr i8, ptr addrspace(3) %304, i32 %442 - store float %441, ptr addrspace(3) %443, align 4 - %444 = add i32 %391, %367 - %445 = extractelement <4 x float> %302, i64 1 - %446 = mul i32 %444, 4 - %447 = getelementptr i8, ptr addrspace(3) %304, i32 %446 - store float %445, ptr addrspace(3) %447, align 4 - %448 = add i32 %397, %367 - %449 = extractelement <4 x float> %302, i64 2 - %450 = mul i32 %448, 4 - %451 = getelementptr i8, ptr addrspace(3) %304, i32 %450 - store float %449, ptr addrspace(3) %451, align 4 - %452 = add i32 %403, %367 - %453 = extractelement <4 x float> %302, i64 3 - %454 = mul i32 %452, 4 - %455 = getelementptr i8, ptr addrspace(3) %304, i32 %454 - store float %453, ptr addrspace(3) %455, align 4 - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %456 = sdiv i32 %24, 32 - %457 = mul i32 %456, 32 - %458 = icmp ne i32 %24, %457 - %459 = icmp slt i32 %24, 0 - %460 = icmp ne i1 %459, false - %461 = and i1 %458, %460 - %462 = add i32 %456, -1 - %463 = select i1 %461, i32 %462, i32 %456 - %464 = srem i32 %24, 32 - %465 = mul i32 %464, 2 - %466 = ptrtoint ptr addrspace(1) %12 to i64 - %467 = inttoptr i64 %466 to ptr addrspace(1) - %468 = ptrtoint ptr addrspace(1) %14 to i64 - %469 = inttoptr i64 %468 to ptr addrspace(1) - %470 = ptrtoint ptr addrspace(1) %17 to i64 - %471 = inttoptr i64 %470 to ptr addrspace(1) - %472 = add i32 %65, %463 - %473 = mul i32 %472, 4 - %474 = getelementptr i8, ptr addrspace(1) %467, i32 %473 - %475 = load i32, ptr addrspace(1) %474, align 4 - %476 = and i32 %475, 16777215 - %477 = icmp slt i32 %476, %16 - %478 = getelementptr i8, ptr addrspace(1) %469, i32 %473 - %479 = load float, ptr addrspace(1) %478, align 4 - br i1 %477, label %480, label %552 - -480: ; preds = %49 - %481 = mul i32 %476, 7168 - %482 = add i32 %481, %93 - %483 = add i32 %482, %465 - %484 = mul i32 %463, 256 - %485 = add i32 %484, %465 - %486 = mul i32 %485, 4 - %487 = getelementptr i8, ptr addrspace(3) %304, i32 %486 - %488 = load float, ptr addrspace(3) %487, align 4 - %489 = fmul float %488, %479 - %490 = add i32 %485, 1 - %491 = mul i32 %490, 4 - %492 = getelementptr i8, ptr addrspace(3) %304, i32 %491 - %493 = load float, ptr addrspace(3) %492, align 4 - %494 = fmul float %493, %479 - %495 = insertelement <2 x float> poison, float %489, i64 0 - %496 = insertelement <2 x float> %495, float %494, i64 1 - %497 = fptrunc <2 x float> %496 to <2 x bfloat> - %498 = mul i32 %483, 2 - %499 = getelementptr i8, ptr addrspace(1) %471, i32 %498 - %500 = atomicrmw fadd ptr addrspace(1) %499, <2 x bfloat> %497 syncscope("agent") monotonic, align 4 - %501 = add i32 %485, 64 - %502 = mul i32 %501, 4 - %503 = getelementptr i8, ptr addrspace(3) %304, i32 %502 - %504 = load float, ptr addrspace(3) %503, align 4 - %505 = fmul float %504, %479 - %506 = add i32 %485, 65 - %507 = mul i32 %506, 4 - %508 = getelementptr i8, ptr addrspace(3) %304, i32 %507 - %509 = load float, ptr addrspace(3) %508, align 4 - %510 = fmul float %509, %479 - %511 = insertelement <2 x float> poison, float %505, i64 0 - %512 = insertelement <2 x float> %511, float %510, i64 1 - %513 = fptrunc <2 x float> %512 to <2 x bfloat> - %514 = add i32 %483, 64 - %515 = mul i32 %514, 2 - %516 = getelementptr i8, ptr addrspace(1) %471, i32 %515 - %517 = atomicrmw fadd ptr addrspace(1) %516, <2 x bfloat> %513 syncscope("agent") monotonic, align 4 - %518 = add i32 %485, 128 - %519 = mul i32 %518, 4 - %520 = getelementptr i8, ptr addrspace(3) %304, i32 %519 - %521 = load float, ptr addrspace(3) %520, align 4 - %522 = fmul float %521, %479 - %523 = add i32 %485, 129 - %524 = mul i32 %523, 4 - %525 = getelementptr i8, ptr addrspace(3) %304, i32 %524 - %526 = load float, ptr addrspace(3) %525, align 4 - %527 = fmul float %526, %479 - %528 = insertelement <2 x float> poison, float %522, i64 0 - %529 = insertelement <2 x float> %528, float %527, i64 1 - %530 = fptrunc <2 x float> %529 to <2 x bfloat> - %531 = add i32 %483, 128 - %532 = mul i32 %531, 2 - %533 = getelementptr i8, ptr addrspace(1) %471, i32 %532 - %534 = atomicrmw fadd ptr addrspace(1) %533, <2 x bfloat> %530 syncscope("agent") monotonic, align 4 - %535 = add i32 %485, 192 - %536 = mul i32 %535, 4 - %537 = getelementptr i8, ptr addrspace(3) %304, i32 %536 - %538 = load float, ptr addrspace(3) %537, align 4 - %539 = fmul float %538, %479 - %540 = add i32 %485, 193 - %541 = mul i32 %540, 4 - %542 = getelementptr i8, ptr addrspace(3) %304, i32 %541 - %543 = load float, ptr addrspace(3) %542, align 4 - %544 = fmul float %543, %479 - %545 = insertelement <2 x float> poison, float %539, i64 0 - %546 = insertelement <2 x float> %545, float %544, i64 1 - %547 = fptrunc <2 x float> %546 to <2 x bfloat> - %548 = add i32 %483, 192 - %549 = mul i32 %548, 2 - %550 = getelementptr i8, ptr addrspace(1) %471, i32 %549 - %551 = atomicrmw fadd ptr addrspace(1) %550, <2 x bfloat> %547 syncscope("agent") monotonic, align 4 - br label %552 - -552: ; preds = %480, %49 - %553 = add i32 %463, 8 - %554 = add i32 %65, %553 - %555 = mul i32 %554, 4 - %556 = getelementptr i8, ptr addrspace(1) %467, i32 %555 - %557 = load i32, ptr addrspace(1) %556, align 4 - %558 = and i32 %557, 16777215 - %559 = icmp slt i32 %558, %16 - %560 = getelementptr i8, ptr addrspace(1) %469, i32 %555 - %561 = load float, ptr addrspace(1) %560, align 4 - br i1 %559, label %562, label %634 - -562: ; preds = %552 - %563 = mul i32 %558, 7168 - %564 = add i32 %563, %93 - %565 = add i32 %564, %465 - %566 = mul i32 %553, 256 - %567 = add i32 %566, %465 - %568 = mul i32 %567, 4 - %569 = getelementptr i8, ptr addrspace(3) %304, i32 %568 - %570 = load float, ptr addrspace(3) %569, align 4 - %571 = fmul float %570, %561 - %572 = add i32 %567, 1 - %573 = mul i32 %572, 4 - %574 = getelementptr i8, ptr addrspace(3) %304, i32 %573 - %575 = load float, ptr addrspace(3) %574, align 4 - %576 = fmul float %575, %561 - %577 = insertelement <2 x float> poison, float %571, i64 0 - %578 = insertelement <2 x float> %577, float %576, i64 1 - %579 = fptrunc <2 x float> %578 to <2 x bfloat> - %580 = mul i32 %565, 2 - %581 = getelementptr i8, ptr addrspace(1) %471, i32 %580 - %582 = atomicrmw fadd ptr addrspace(1) %581, <2 x bfloat> %579 syncscope("agent") monotonic, align 4 - %583 = add i32 %567, 64 - %584 = mul i32 %583, 4 - %585 = getelementptr i8, ptr addrspace(3) %304, i32 %584 - %586 = load float, ptr addrspace(3) %585, align 4 - %587 = fmul float %586, %561 - %588 = add i32 %567, 65 - %589 = mul i32 %588, 4 - %590 = getelementptr i8, ptr addrspace(3) %304, i32 %589 - %591 = load float, ptr addrspace(3) %590, align 4 - %592 = fmul float %591, %561 - %593 = insertelement <2 x float> poison, float %587, i64 0 - %594 = insertelement <2 x float> %593, float %592, i64 1 - %595 = fptrunc <2 x float> %594 to <2 x bfloat> - %596 = add i32 %565, 64 - %597 = mul i32 %596, 2 - %598 = getelementptr i8, ptr addrspace(1) %471, i32 %597 - %599 = atomicrmw fadd ptr addrspace(1) %598, <2 x bfloat> %595 syncscope("agent") monotonic, align 4 - %600 = add i32 %567, 128 - %601 = mul i32 %600, 4 - %602 = getelementptr i8, ptr addrspace(3) %304, i32 %601 - %603 = load float, ptr addrspace(3) %602, align 4 - %604 = fmul float %603, %561 - %605 = add i32 %567, 129 - %606 = mul i32 %605, 4 - %607 = getelementptr i8, ptr addrspace(3) %304, i32 %606 - %608 = load float, ptr addrspace(3) %607, align 4 - %609 = fmul float %608, %561 - %610 = insertelement <2 x float> poison, float %604, i64 0 - %611 = insertelement <2 x float> %610, float %609, i64 1 - %612 = fptrunc <2 x float> %611 to <2 x bfloat> - %613 = add i32 %565, 128 - %614 = mul i32 %613, 2 - %615 = getelementptr i8, ptr addrspace(1) %471, i32 %614 - %616 = atomicrmw fadd ptr addrspace(1) %615, <2 x bfloat> %612 syncscope("agent") monotonic, align 4 - %617 = add i32 %567, 192 - %618 = mul i32 %617, 4 - %619 = getelementptr i8, ptr addrspace(3) %304, i32 %618 - %620 = load float, ptr addrspace(3) %619, align 4 - %621 = fmul float %620, %561 - %622 = add i32 %567, 193 - %623 = mul i32 %622, 4 - %624 = getelementptr i8, ptr addrspace(3) %304, i32 %623 - %625 = load float, ptr addrspace(3) %624, align 4 - %626 = fmul float %625, %561 - %627 = insertelement <2 x float> poison, float %621, i64 0 - %628 = insertelement <2 x float> %627, float %626, i64 1 - %629 = fptrunc <2 x float> %628 to <2 x bfloat> - %630 = add i32 %565, 192 - %631 = mul i32 %630, 2 - %632 = getelementptr i8, ptr addrspace(1) %471, i32 %631 - %633 = atomicrmw fadd ptr addrspace(1) %632, <2 x bfloat> %629 syncscope("agent") monotonic, align 4 - br label %634 - -634: ; preds = %562, %552 - %635 = add i32 %463, 16 - %636 = add i32 %65, %635 - %637 = mul i32 %636, 4 - %638 = getelementptr i8, ptr addrspace(1) %467, i32 %637 - %639 = load i32, ptr addrspace(1) %638, align 4 - %640 = and i32 %639, 16777215 - %641 = icmp slt i32 %640, %16 - %642 = getelementptr i8, ptr addrspace(1) %469, i32 %637 - %643 = load float, ptr addrspace(1) %642, align 4 - br i1 %641, label %644, label %716 - -644: ; preds = %634 - %645 = mul i32 %640, 7168 - %646 = add i32 %645, %93 - %647 = add i32 %646, %465 - %648 = mul i32 %635, 256 - %649 = add i32 %648, %465 - %650 = mul i32 %649, 4 - %651 = getelementptr i8, ptr addrspace(3) %304, i32 %650 - %652 = load float, ptr addrspace(3) %651, align 4 - %653 = fmul float %652, %643 - %654 = add i32 %649, 1 - %655 = mul i32 %654, 4 - %656 = getelementptr i8, ptr addrspace(3) %304, i32 %655 - %657 = load float, ptr addrspace(3) %656, align 4 - %658 = fmul float %657, %643 - %659 = insertelement <2 x float> poison, float %653, i64 0 - %660 = insertelement <2 x float> %659, float %658, i64 1 - %661 = fptrunc <2 x float> %660 to <2 x bfloat> - %662 = mul i32 %647, 2 - %663 = getelementptr i8, ptr addrspace(1) %471, i32 %662 - %664 = atomicrmw fadd ptr addrspace(1) %663, <2 x bfloat> %661 syncscope("agent") monotonic, align 4 - %665 = add i32 %649, 64 - %666 = mul i32 %665, 4 - %667 = getelementptr i8, ptr addrspace(3) %304, i32 %666 - %668 = load float, ptr addrspace(3) %667, align 4 - %669 = fmul float %668, %643 - %670 = add i32 %649, 65 - %671 = mul i32 %670, 4 - %672 = getelementptr i8, ptr addrspace(3) %304, i32 %671 - %673 = load float, ptr addrspace(3) %672, align 4 - %674 = fmul float %673, %643 - %675 = insertelement <2 x float> poison, float %669, i64 0 - %676 = insertelement <2 x float> %675, float %674, i64 1 - %677 = fptrunc <2 x float> %676 to <2 x bfloat> - %678 = add i32 %647, 64 - %679 = mul i32 %678, 2 - %680 = getelementptr i8, ptr addrspace(1) %471, i32 %679 - %681 = atomicrmw fadd ptr addrspace(1) %680, <2 x bfloat> %677 syncscope("agent") monotonic, align 4 - %682 = add i32 %649, 128 - %683 = mul i32 %682, 4 - %684 = getelementptr i8, ptr addrspace(3) %304, i32 %683 - %685 = load float, ptr addrspace(3) %684, align 4 - %686 = fmul float %685, %643 - %687 = add i32 %649, 129 - %688 = mul i32 %687, 4 - %689 = getelementptr i8, ptr addrspace(3) %304, i32 %688 - %690 = load float, ptr addrspace(3) %689, align 4 - %691 = fmul float %690, %643 - %692 = insertelement <2 x float> poison, float %686, i64 0 - %693 = insertelement <2 x float> %692, float %691, i64 1 - %694 = fptrunc <2 x float> %693 to <2 x bfloat> - %695 = add i32 %647, 128 - %696 = mul i32 %695, 2 - %697 = getelementptr i8, ptr addrspace(1) %471, i32 %696 - %698 = atomicrmw fadd ptr addrspace(1) %697, <2 x bfloat> %694 syncscope("agent") monotonic, align 4 - %699 = add i32 %649, 192 - %700 = mul i32 %699, 4 - %701 = getelementptr i8, ptr addrspace(3) %304, i32 %700 - %702 = load float, ptr addrspace(3) %701, align 4 - %703 = fmul float %702, %643 - %704 = add i32 %649, 193 - %705 = mul i32 %704, 4 - %706 = getelementptr i8, ptr addrspace(3) %304, i32 %705 - %707 = load float, ptr addrspace(3) %706, align 4 - %708 = fmul float %707, %643 - %709 = insertelement <2 x float> poison, float %703, i64 0 - %710 = insertelement <2 x float> %709, float %708, i64 1 - %711 = fptrunc <2 x float> %710 to <2 x bfloat> - %712 = add i32 %647, 192 - %713 = mul i32 %712, 2 - %714 = getelementptr i8, ptr addrspace(1) %471, i32 %713 - %715 = atomicrmw fadd ptr addrspace(1) %714, <2 x bfloat> %711 syncscope("agent") monotonic, align 4 - br label %716 - -716: ; preds = %644, %634 - %717 = add i32 %463, 24 - %718 = add i32 %65, %717 - %719 = mul i32 %718, 4 - %720 = getelementptr i8, ptr addrspace(1) %467, i32 %719 - %721 = load i32, ptr addrspace(1) %720, align 4 - %722 = and i32 %721, 16777215 - %723 = icmp slt i32 %722, %16 - %724 = getelementptr i8, ptr addrspace(1) %469, i32 %719 - %725 = load float, ptr addrspace(1) %724, align 4 - br i1 %723, label %726, label %798 - -726: ; preds = %716 - %727 = mul i32 %722, 7168 - %728 = add i32 %727, %93 - %729 = add i32 %728, %465 - %730 = mul i32 %717, 256 - %731 = add i32 %730, %465 - %732 = mul i32 %731, 4 - %733 = getelementptr i8, ptr addrspace(3) %304, i32 %732 - %734 = load float, ptr addrspace(3) %733, align 4 - %735 = fmul float %734, %725 - %736 = add i32 %731, 1 - %737 = mul i32 %736, 4 - %738 = getelementptr i8, ptr addrspace(3) %304, i32 %737 - %739 = load float, ptr addrspace(3) %738, align 4 - %740 = fmul float %739, %725 - %741 = insertelement <2 x float> poison, float %735, i64 0 - %742 = insertelement <2 x float> %741, float %740, i64 1 - %743 = fptrunc <2 x float> %742 to <2 x bfloat> - %744 = mul i32 %729, 2 - %745 = getelementptr i8, ptr addrspace(1) %471, i32 %744 - %746 = atomicrmw fadd ptr addrspace(1) %745, <2 x bfloat> %743 syncscope("agent") monotonic, align 4 - %747 = add i32 %731, 64 - %748 = mul i32 %747, 4 - %749 = getelementptr i8, ptr addrspace(3) %304, i32 %748 - %750 = load float, ptr addrspace(3) %749, align 4 - %751 = fmul float %750, %725 - %752 = add i32 %731, 65 - %753 = mul i32 %752, 4 - %754 = getelementptr i8, ptr addrspace(3) %304, i32 %753 - %755 = load float, ptr addrspace(3) %754, align 4 - %756 = fmul float %755, %725 - %757 = insertelement <2 x float> poison, float %751, i64 0 - %758 = insertelement <2 x float> %757, float %756, i64 1 - %759 = fptrunc <2 x float> %758 to <2 x bfloat> - %760 = add i32 %729, 64 - %761 = mul i32 %760, 2 - %762 = getelementptr i8, ptr addrspace(1) %471, i32 %761 - %763 = atomicrmw fadd ptr addrspace(1) %762, <2 x bfloat> %759 syncscope("agent") monotonic, align 4 - %764 = add i32 %731, 128 - %765 = mul i32 %764, 4 - %766 = getelementptr i8, ptr addrspace(3) %304, i32 %765 - %767 = load float, ptr addrspace(3) %766, align 4 - %768 = fmul float %767, %725 - %769 = add i32 %731, 129 - %770 = mul i32 %769, 4 - %771 = getelementptr i8, ptr addrspace(3) %304, i32 %770 - %772 = load float, ptr addrspace(3) %771, align 4 - %773 = fmul float %772, %725 - %774 = insertelement <2 x float> poison, float %768, i64 0 - %775 = insertelement <2 x float> %774, float %773, i64 1 - %776 = fptrunc <2 x float> %775 to <2 x bfloat> - %777 = add i32 %729, 128 - %778 = mul i32 %777, 2 - %779 = getelementptr i8, ptr addrspace(1) %471, i32 %778 - %780 = atomicrmw fadd ptr addrspace(1) %779, <2 x bfloat> %776 syncscope("agent") monotonic, align 4 - %781 = add i32 %731, 192 - %782 = mul i32 %781, 4 - %783 = getelementptr i8, ptr addrspace(3) %304, i32 %782 - %784 = load float, ptr addrspace(3) %783, align 4 - %785 = fmul float %784, %725 - %786 = add i32 %731, 193 - %787 = mul i32 %786, 4 - %788 = getelementptr i8, ptr addrspace(3) %304, i32 %787 - %789 = load float, ptr addrspace(3) %788, align 4 - %790 = fmul float %789, %725 - %791 = insertelement <2 x float> poison, float %785, i64 0 - %792 = insertelement <2 x float> %791, float %790, i64 1 - %793 = fptrunc <2 x float> %792 to <2 x bfloat> - %794 = add i32 %729, 192 - %795 = mul i32 %794, 2 - %796 = getelementptr i8, ptr addrspace(1) %471, i32 %795 - %797 = atomicrmw fadd ptr addrspace(1) %796, <2 x bfloat> %793 syncscope("agent") monotonic, align 4 - br label %798 - -798: ; preds = %726, %716 - br label %799 - -799: ; preds = %798, %19 - ret void -} - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) -declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 - -; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) -declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #3 - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #4 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.sched.barrier(i32 immarg) #5 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) -declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #7 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.s.barrier() #5 - -attributes #0 = { "amdgpu-flat-work-group-size"="256,256" "uniform-work-group-size" } -attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } -attributes #2 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } -attributes #3 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } -attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } -attributes #5 = { convergent nocallback nofree nounwind willreturn } -attributes #6 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } -attributes #7 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} -!1 = !{i32 256, i32 1, i32 1} diff --git a/kernels/gemm2_port_ref/flydsl_port_v6.ll b/kernels/gemm2_port_ref/flydsl_port_v6.ll deleted file mode 100644 index 2c8f198bc..000000000 --- a/kernels/gemm2_port_ref/flydsl_port_v6.ll +++ /dev/null @@ -1,866 +0,0 @@ -; ModuleID = 'LLVMDialectModule' -source_filename = "LLVMDialectModule" -target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" - -@gemm2port_smem = external addrspace(3) global [32768 x i8], align 1024 - -define amdgpu_kernel void @gemm2_a4w4_port_bm32_atomic(ptr addrspace(1) %0, <{ <{ i32, i32 }>, <{ i64 }> }> %1, ptr addrspace(1) %2, <{ <{ i32, i32 }>, <{ i64 }> }> %3, ptr addrspace(1) %4, <{ <{ i32, i32, i32 }>, <{ i64, i64 }> }> %5, ptr addrspace(1) %6, <{ <{ i32, i32 }>, <{ i64 }> }> %7, ptr addrspace(1) %8, <{ <{ i32 }> }> %9, ptr addrspace(1) %10, <{ <{ i32 }> }> %11, ptr addrspace(1) %12, <{ <{ i32 }> }> %13, ptr addrspace(1) %14, <{ <{ i32 }> }> %15, i32 %16, ptr addrspace(1) %17, <{ <{ i32, i32 }>, <{ i64 }> }> %18) #0 !reqd_work_group_size !1 { - %20 = call range(i32 0, 256) i32 @llvm.amdgcn.workitem.id.x() - %21 = sext i32 %20 to i64 - %22 = call i32 @llvm.amdgcn.workgroup.id.x() - %23 = sext i32 %22 to i64 - %24 = trunc i64 %21 to i32 - %25 = trunc i64 %23 to i32 - %26 = srem i32 %24, 64 - %27 = sdiv i32 %24, 64 - %28 = mul i32 %27, 64 - %29 = icmp ne i32 %24, %28 - %30 = icmp slt i32 %24, 0 - %31 = icmp ne i1 %30, false - %32 = and i1 %29, %31 - %33 = add i32 %27, -1 - %34 = select i1 %32, i32 %33, i32 %27 - %35 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %34) - %36 = ptrtoint ptr addrspace(1) %10 to i64 - %37 = inttoptr i64 %36 to ptr addrspace(1) - %38 = load i32, ptr addrspace(1) %37, align 4 - %39 = sdiv i32 %38, 32 - %40 = mul i32 %39, 32 - %41 = icmp ne i32 %38, %40 - %42 = icmp slt i32 %38, 0 - %43 = icmp ne i1 %42, false - %44 = and i1 %41, %43 - %45 = add i32 %39, -1 - %46 = select i1 %44, i32 %45, i32 %39 - %47 = mul i32 %46, 28 - %48 = icmp slt i32 %25, %47 - br i1 %48, label %49, label %767 - -49: ; preds = %19 - %50 = srem i32 %25, 28 - %51 = sdiv i32 %25, 28 - %52 = mul i32 %51, 28 - %53 = icmp ne i32 %25, %52 - %54 = icmp slt i32 %25, 0 - %55 = icmp ne i1 %54, false - %56 = and i1 %53, %55 - %57 = add i32 %51, -1 - %58 = select i1 %56, i32 %57, i32 %51 - %59 = mul i32 %58, 4 - %60 = ptrtoint ptr addrspace(1) %8 to i64 - %61 = inttoptr i64 %60 to ptr addrspace(1) - %62 = getelementptr i8, ptr addrspace(1) %61, i32 %59 - %63 = load i32, ptr addrspace(1) %62, align 4 - %64 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %63) - %65 = mul i32 %58, 32 - %66 = addrspacecast ptr addrspace(1) %0 to ptr - %67 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %66, i16 0, i64 167772160, i32 159744) - %68 = addrspacecast ptr addrspace(1) %2 to ptr - %69 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %68, i16 0, i64 10485760, i32 159744) - %70 = addrspacecast ptr addrspace(1) %4 to ptr - %71 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %70, i16 0, i64 706478080, i32 159744) - %72 = addrspacecast ptr addrspace(1) %6 to ptr - %73 = call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr %72, i16 0, i64 44154880, i32 159744) - %74 = sdiv i32 %26, 8 - %75 = mul i32 %74, 8 - %76 = icmp ne i32 %26, %75 - %77 = icmp slt i32 %26, 0 - %78 = icmp ne i1 %77, false - %79 = and i1 %76, %78 - %80 = add i32 %74, -1 - %81 = select i1 %79, i32 %80, i32 %74 - %82 = srem i32 %26, 8 - %83 = sdiv i32 %26, 16 - %84 = mul i32 %83, 16 - %85 = icmp ne i32 %26, %84 - %86 = icmp slt i32 %26, 0 - %87 = icmp ne i1 %86, false - %88 = and i1 %85, %87 - %89 = add i32 %83, -1 - %90 = select i1 %88, i32 %89, i32 %83 - %91 = srem i32 %26, 16 - %92 = mul i32 %64, 7168 - %93 = mul i32 %50, 256 - %94 = add i32 %92, %93 - %95 = mul i32 %35, 64 - %96 = add i32 %94, %95 - %97 = mul i32 %96, 256 - %98 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %97) - %99 = add i32 %96, 16 - %100 = mul i32 %99, 256 - %101 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %100) - %102 = add i32 %96, 32 - %103 = mul i32 %102, 256 - %104 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %103) - %105 = add i32 %96, 48 - %106 = mul i32 %105, 256 - %107 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %106) - %108 = mul i32 %50, 8 - %109 = mul i32 %35, 2 - %110 = add i32 %108, %109 - %111 = mul i32 %64, 28672 - %112 = mul i32 %110, 128 - %113 = add i32 %111, %112 - %114 = mul i32 %113, 4 - %115 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %114) - %116 = add i32 %110, 1 - %117 = mul i32 %116, 128 - %118 = add i32 %111, %117 - %119 = mul i32 %118, 4 - %120 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %119) - %121 = sdiv i32 %65, 32 - %122 = mul i32 %121, 32 - %123 = icmp ne i32 %65, %122 - %124 = icmp slt i32 %65, 0 - %125 = icmp ne i1 %124, false - %126 = and i1 %123, %125 - %127 = add i32 %121, -1 - %128 = select i1 %126, i32 %127, i32 %121 - %129 = mul i32 %128, 512 - %130 = call i32 @llvm.amdgcn.readfirstlane.i32(i32 %129) - %131 = mul i32 %35, 8 - %132 = add i32 %65, %131 - %133 = add i32 %132, %81 - %134 = add i32 %131, %81 - %135 = and i32 %134, 14 - %136 = shl i32 %135, 3 - %137 = mul i32 %82, 16 - %138 = xor i32 %137, %136 - %139 = mul i32 %133, 256 - %140 = add i32 %138, %139 - %141 = mul i32 %35, 1024 - %142 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %141 - %143 = sext i32 %142 to i64 - %144 = inttoptr i64 %143 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %67, ptr addrspace(3) %144, i32 16, i32 %140, i32 0, i32 0, i32 0) - %145 = add i32 %141, 4096 - %146 = add i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32), %145 - %147 = sext i32 %146 to i64 - %148 = inttoptr i64 %147 to ptr addrspace(3) - call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) %67, ptr addrspace(3) %148, i32 16, i32 %140, i32 128, i32 0, i32 0) - call void @llvm.amdgcn.sched.barrier(i32 0) - %149 = mul i32 %90, 16 - %150 = add i32 %149, %91 - %151 = mul i32 %150, 4 - %152 = sdiv i32 %151, 4 - %153 = mul i32 %152, 4 - %154 = icmp ne i32 %151, %153 - %155 = icmp slt i32 %151, 0 - %156 = icmp ne i1 %155, false - %157 = and i1 %154, %156 - %158 = add i32 %152, -1 - %159 = select i1 %157, i32 %158, i32 %152 - %160 = mul i32 %159, 4 - %161 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %69, i32 %160, i32 %130, i32 0) - %162 = add i32 %151, 256 - %163 = sdiv i32 %162, 4 - %164 = mul i32 %163, 4 - %165 = icmp ne i32 %162, %164 - %166 = icmp slt i32 %162, 0 - %167 = icmp ne i1 %166, false - %168 = and i1 %165, %167 - %169 = add i32 %163, -1 - %170 = select i1 %168, i32 %169, i32 %163 - %171 = mul i32 %170, 4 - %172 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %69, i32 %171, i32 %130, i32 0) - %173 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %160, i32 %115, i32 0) - %174 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %160, i32 %120, i32 0) - %175 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %171, i32 %115, i32 0) - %176 = call i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) %73, i32 %171, i32 %120, i32 0) - %177 = mul i32 %90, 256 - %178 = mul i32 %91, 16 - %179 = add i32 %177, %178 - %180 = sdiv i32 %179, 4 - %181 = mul i32 %180, 4 - %182 = icmp ne i32 %179, %181 - %183 = icmp slt i32 %179, 0 - %184 = icmp ne i1 %183, false - %185 = and i1 %182, %184 - %186 = add i32 %180, -1 - %187 = select i1 %185, i32 %186, i32 %180 - %188 = mul i32 %187, 4 - %189 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %98, i32 0) - %190 = add i32 %179, 1024 - %191 = sdiv i32 %190, 4 - %192 = mul i32 %191, 4 - %193 = icmp ne i32 %190, %192 - %194 = icmp slt i32 %190, 0 - %195 = icmp ne i1 %194, false - %196 = and i1 %193, %195 - %197 = add i32 %191, -1 - %198 = select i1 %196, i32 %197, i32 %191 - %199 = mul i32 %198, 4 - %200 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %98, i32 0) - %201 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %101, i32 0) - %202 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %101, i32 0) - %203 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %104, i32 0) - %204 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %104, i32 0) - %205 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %188, i32 %107, i32 0) - %206 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %199, i32 %107, i32 0) - %207 = add i32 %179, 2048 - %208 = sdiv i32 %207, 4 - %209 = mul i32 %208, 4 - %210 = icmp ne i32 %207, %209 - %211 = icmp slt i32 %207, 0 - %212 = icmp ne i1 %211, false - %213 = and i1 %210, %212 - %214 = add i32 %208, -1 - %215 = select i1 %213, i32 %214, i32 %208 - %216 = mul i32 %215, 4 - %217 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %98, i32 0) - %218 = add i32 %179, 3072 - %219 = sdiv i32 %218, 4 - %220 = mul i32 %219, 4 - %221 = icmp ne i32 %218, %220 - %222 = icmp slt i32 %218, 0 - %223 = icmp ne i1 %222, false - %224 = and i1 %221, %223 - %225 = add i32 %219, -1 - %226 = select i1 %224, i32 %225, i32 %219 - %227 = mul i32 %226, 4 - %228 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %98, i32 0) - %229 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %101, i32 0) - %230 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %101, i32 0) - %231 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %104, i32 0) - %232 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %104, i32 0) - %233 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %216, i32 %107, i32 0) - %234 = call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) %71, i32 %227, i32 %107, i32 0) - call void asm sideeffect "s_waitcnt vmcnt(23)", ""() - call void asm sideeffect "s_barrier", ""() - %235 = and i32 %91, 14 - %236 = shl i32 %235, 3 - %237 = sext i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32) to i64 - %238 = inttoptr i64 %237 to ptr addrspace(3) - %239 = xor i32 %149, %236 - %240 = mul i32 %91, 128 - %241 = add i32 %240, %239 - %242 = getelementptr i8, ptr addrspace(3) %238, i32 %241 - %243 = load <4 x i32>, ptr addrspace(3) %242, align 16 - %244 = add i32 %91, 16 - %245 = mul i32 %244, 128 - %246 = add i32 %245, %239 - %247 = getelementptr i8, ptr addrspace(3) %238, i32 %246 - %248 = load <4 x i32>, ptr addrspace(3) %247, align 16 - %249 = add i32 %149, 64 - %250 = xor i32 %249, %236 - %251 = add i32 %240, %250 - %252 = getelementptr i8, ptr addrspace(3) %238, i32 %251 - %253 = load <4 x i32>, ptr addrspace(3) %252, align 16 - %254 = add i32 %245, %250 - %255 = getelementptr i8, ptr addrspace(3) %238, i32 %254 - %256 = load <4 x i32>, ptr addrspace(3) %255, align 16 - %257 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %189, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 0, i32 %173) - %258 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %189, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 0, i32 %173) - %259 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %200, <4 x float> %257, i32 4, i32 4, i32 2, i32 %161, i32 2, i32 %173) - %260 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %200, <4 x float> %258, i32 4, i32 4, i32 3, i32 %161, i32 2, i32 %173) - %261 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %201, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 1, i32 %173) - %262 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %201, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 1, i32 %173) - %263 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %202, <4 x float> %261, i32 4, i32 4, i32 2, i32 %161, i32 3, i32 %173) - %264 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %202, <4 x float> %262, i32 4, i32 4, i32 3, i32 %161, i32 3, i32 %173) - %265 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %203, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 0, i32 %174) - %266 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %203, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 0, i32 %174) - %267 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %204, <4 x float> %265, i32 4, i32 4, i32 2, i32 %161, i32 2, i32 %174) - %268 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %204, <4 x float> %266, i32 4, i32 4, i32 3, i32 %161, i32 2, i32 %174) - %269 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %243, <4 x i32> %205, <4 x float> zeroinitializer, i32 4, i32 4, i32 0, i32 %161, i32 1, i32 %174) - %270 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %248, <4 x i32> %205, <4 x float> zeroinitializer, i32 4, i32 4, i32 1, i32 %161, i32 1, i32 %174) - %271 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %253, <4 x i32> %206, <4 x float> %269, i32 4, i32 4, i32 2, i32 %161, i32 3, i32 %174) - %272 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %256, <4 x i32> %206, <4 x float> %270, i32 4, i32 4, i32 3, i32 %161, i32 3, i32 %174) - call void asm sideeffect "s_waitcnt vmcnt(22)", ""() - call void asm sideeffect "s_barrier", ""() - %273 = add i32 %240, 4096 - %274 = add i32 %273, %239 - %275 = getelementptr i8, ptr addrspace(3) %238, i32 %274 - %276 = load <4 x i32>, ptr addrspace(3) %275, align 16 - %277 = add i32 %245, 4096 - %278 = add i32 %277, %239 - %279 = getelementptr i8, ptr addrspace(3) %238, i32 %278 - %280 = load <4 x i32>, ptr addrspace(3) %279, align 16 - %281 = add i32 %273, %250 - %282 = getelementptr i8, ptr addrspace(3) %238, i32 %281 - %283 = load <4 x i32>, ptr addrspace(3) %282, align 16 - %284 = add i32 %277, %250 - %285 = getelementptr i8, ptr addrspace(3) %238, i32 %284 - %286 = load <4 x i32>, ptr addrspace(3) %285, align 16 - %287 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %217, <4 x float> %259, i32 4, i32 4, i32 0, i32 %172, i32 0, i32 %175) - %288 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %217, <4 x float> %260, i32 4, i32 4, i32 1, i32 %172, i32 0, i32 %175) - %289 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %228, <4 x float> %287, i32 4, i32 4, i32 2, i32 %172, i32 2, i32 %175) - %290 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %228, <4 x float> %288, i32 4, i32 4, i32 3, i32 %172, i32 2, i32 %175) - %291 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %229, <4 x float> %263, i32 4, i32 4, i32 0, i32 %172, i32 1, i32 %175) - %292 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %229, <4 x float> %264, i32 4, i32 4, i32 1, i32 %172, i32 1, i32 %175) - %293 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %230, <4 x float> %291, i32 4, i32 4, i32 2, i32 %172, i32 3, i32 %175) - %294 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %230, <4 x float> %292, i32 4, i32 4, i32 3, i32 %172, i32 3, i32 %175) - %295 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %231, <4 x float> %267, i32 4, i32 4, i32 0, i32 %172, i32 0, i32 %176) - %296 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %231, <4 x float> %268, i32 4, i32 4, i32 1, i32 %172, i32 0, i32 %176) - %297 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %232, <4 x float> %295, i32 4, i32 4, i32 2, i32 %172, i32 2, i32 %176) - %298 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %232, <4 x float> %296, i32 4, i32 4, i32 3, i32 %172, i32 2, i32 %176) - %299 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %276, <4 x i32> %233, <4 x float> %271, i32 4, i32 4, i32 0, i32 %172, i32 1, i32 %176) - %300 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %280, <4 x i32> %233, <4 x float> %272, i32 4, i32 4, i32 1, i32 %172, i32 1, i32 %176) - %301 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %283, <4 x i32> %234, <4 x float> %299, i32 4, i32 4, i32 2, i32 %172, i32 3, i32 %176) - %302 = call <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> %286, <4 x i32> %234, <4 x float> %300, i32 4, i32 4, i32 3, i32 %172, i32 3, i32 %176) - %303 = sext i32 ptrtoint (ptr addrspace(3) @gemm2port_smem to i32) to i64 - %304 = inttoptr i64 %303 to ptr addrspace(3) - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %305 = mul i32 %90, 4 - %306 = add i32 %95, %91 - %307 = mul i32 %90, 1024 - %308 = add i32 %307, %306 - %309 = extractelement <4 x float> %289, i64 0 - %310 = mul i32 %308, 4 - %311 = getelementptr i8, ptr addrspace(3) %304, i32 %310 - store float %309, ptr addrspace(3) %311, align 4 - %312 = add i32 %305, 1 - %313 = mul i32 %312, 256 - %314 = add i32 %313, %306 - %315 = extractelement <4 x float> %289, i64 1 - %316 = mul i32 %314, 4 - %317 = getelementptr i8, ptr addrspace(3) %304, i32 %316 - store float %315, ptr addrspace(3) %317, align 4 - %318 = add i32 %305, 2 - %319 = mul i32 %318, 256 - %320 = add i32 %319, %306 - %321 = extractelement <4 x float> %289, i64 2 - %322 = mul i32 %320, 4 - %323 = getelementptr i8, ptr addrspace(3) %304, i32 %322 - store float %321, ptr addrspace(3) %323, align 4 - %324 = add i32 %305, 3 - %325 = mul i32 %324, 256 - %326 = add i32 %325, %306 - %327 = extractelement <4 x float> %289, i64 3 - %328 = mul i32 %326, 4 - %329 = getelementptr i8, ptr addrspace(3) %304, i32 %328 - store float %327, ptr addrspace(3) %329, align 4 - %330 = add i32 %95, 16 - %331 = add i32 %330, %91 - %332 = add i32 %307, %331 - %333 = extractelement <4 x float> %293, i64 0 - %334 = mul i32 %332, 4 - %335 = getelementptr i8, ptr addrspace(3) %304, i32 %334 - store float %333, ptr addrspace(3) %335, align 4 - %336 = add i32 %313, %331 - %337 = extractelement <4 x float> %293, i64 1 - %338 = mul i32 %336, 4 - %339 = getelementptr i8, ptr addrspace(3) %304, i32 %338 - store float %337, ptr addrspace(3) %339, align 4 - %340 = add i32 %319, %331 - %341 = extractelement <4 x float> %293, i64 2 - %342 = mul i32 %340, 4 - %343 = getelementptr i8, ptr addrspace(3) %304, i32 %342 - store float %341, ptr addrspace(3) %343, align 4 - %344 = add i32 %325, %331 - %345 = extractelement <4 x float> %293, i64 3 - %346 = mul i32 %344, 4 - %347 = getelementptr i8, ptr addrspace(3) %304, i32 %346 - store float %345, ptr addrspace(3) %347, align 4 - %348 = add i32 %95, 32 - %349 = add i32 %348, %91 - %350 = add i32 %307, %349 - %351 = extractelement <4 x float> %297, i64 0 - %352 = mul i32 %350, 4 - %353 = getelementptr i8, ptr addrspace(3) %304, i32 %352 - store float %351, ptr addrspace(3) %353, align 4 - %354 = add i32 %313, %349 - %355 = extractelement <4 x float> %297, i64 1 - %356 = mul i32 %354, 4 - %357 = getelementptr i8, ptr addrspace(3) %304, i32 %356 - store float %355, ptr addrspace(3) %357, align 4 - %358 = add i32 %319, %349 - %359 = extractelement <4 x float> %297, i64 2 - %360 = mul i32 %358, 4 - %361 = getelementptr i8, ptr addrspace(3) %304, i32 %360 - store float %359, ptr addrspace(3) %361, align 4 - %362 = add i32 %325, %349 - %363 = extractelement <4 x float> %297, i64 3 - %364 = mul i32 %362, 4 - %365 = getelementptr i8, ptr addrspace(3) %304, i32 %364 - store float %363, ptr addrspace(3) %365, align 4 - %366 = add i32 %95, 48 - %367 = add i32 %366, %91 - %368 = add i32 %307, %367 - %369 = extractelement <4 x float> %301, i64 0 - %370 = mul i32 %368, 4 - %371 = getelementptr i8, ptr addrspace(3) %304, i32 %370 - store float %369, ptr addrspace(3) %371, align 4 - %372 = add i32 %313, %367 - %373 = extractelement <4 x float> %301, i64 1 - %374 = mul i32 %372, 4 - %375 = getelementptr i8, ptr addrspace(3) %304, i32 %374 - store float %373, ptr addrspace(3) %375, align 4 - %376 = add i32 %319, %367 - %377 = extractelement <4 x float> %301, i64 2 - %378 = mul i32 %376, 4 - %379 = getelementptr i8, ptr addrspace(3) %304, i32 %378 - store float %377, ptr addrspace(3) %379, align 4 - %380 = add i32 %325, %367 - %381 = extractelement <4 x float> %301, i64 3 - %382 = mul i32 %380, 4 - %383 = getelementptr i8, ptr addrspace(3) %304, i32 %382 - store float %381, ptr addrspace(3) %383, align 4 - %384 = add i32 %305, 16 - %385 = mul i32 %384, 256 - %386 = add i32 %385, %306 - %387 = extractelement <4 x float> %290, i64 0 - %388 = mul i32 %386, 4 - %389 = getelementptr i8, ptr addrspace(3) %304, i32 %388 - store float %387, ptr addrspace(3) %389, align 4 - %390 = add i32 %305, 17 - %391 = mul i32 %390, 256 - %392 = add i32 %391, %306 - %393 = extractelement <4 x float> %290, i64 1 - %394 = mul i32 %392, 4 - %395 = getelementptr i8, ptr addrspace(3) %304, i32 %394 - store float %393, ptr addrspace(3) %395, align 4 - %396 = add i32 %305, 18 - %397 = mul i32 %396, 256 - %398 = add i32 %397, %306 - %399 = extractelement <4 x float> %290, i64 2 - %400 = mul i32 %398, 4 - %401 = getelementptr i8, ptr addrspace(3) %304, i32 %400 - store float %399, ptr addrspace(3) %401, align 4 - %402 = add i32 %305, 19 - %403 = mul i32 %402, 256 - %404 = add i32 %403, %306 - %405 = extractelement <4 x float> %290, i64 3 - %406 = mul i32 %404, 4 - %407 = getelementptr i8, ptr addrspace(3) %304, i32 %406 - store float %405, ptr addrspace(3) %407, align 4 - %408 = add i32 %385, %331 - %409 = extractelement <4 x float> %294, i64 0 - %410 = mul i32 %408, 4 - %411 = getelementptr i8, ptr addrspace(3) %304, i32 %410 - store float %409, ptr addrspace(3) %411, align 4 - %412 = add i32 %391, %331 - %413 = extractelement <4 x float> %294, i64 1 - %414 = mul i32 %412, 4 - %415 = getelementptr i8, ptr addrspace(3) %304, i32 %414 - store float %413, ptr addrspace(3) %415, align 4 - %416 = add i32 %397, %331 - %417 = extractelement <4 x float> %294, i64 2 - %418 = mul i32 %416, 4 - %419 = getelementptr i8, ptr addrspace(3) %304, i32 %418 - store float %417, ptr addrspace(3) %419, align 4 - %420 = add i32 %403, %331 - %421 = extractelement <4 x float> %294, i64 3 - %422 = mul i32 %420, 4 - %423 = getelementptr i8, ptr addrspace(3) %304, i32 %422 - store float %421, ptr addrspace(3) %423, align 4 - %424 = add i32 %385, %349 - %425 = extractelement <4 x float> %298, i64 0 - %426 = mul i32 %424, 4 - %427 = getelementptr i8, ptr addrspace(3) %304, i32 %426 - store float %425, ptr addrspace(3) %427, align 4 - %428 = add i32 %391, %349 - %429 = extractelement <4 x float> %298, i64 1 - %430 = mul i32 %428, 4 - %431 = getelementptr i8, ptr addrspace(3) %304, i32 %430 - store float %429, ptr addrspace(3) %431, align 4 - %432 = add i32 %397, %349 - %433 = extractelement <4 x float> %298, i64 2 - %434 = mul i32 %432, 4 - %435 = getelementptr i8, ptr addrspace(3) %304, i32 %434 - store float %433, ptr addrspace(3) %435, align 4 - %436 = add i32 %403, %349 - %437 = extractelement <4 x float> %298, i64 3 - %438 = mul i32 %436, 4 - %439 = getelementptr i8, ptr addrspace(3) %304, i32 %438 - store float %437, ptr addrspace(3) %439, align 4 - %440 = add i32 %385, %367 - %441 = extractelement <4 x float> %302, i64 0 - %442 = mul i32 %440, 4 - %443 = getelementptr i8, ptr addrspace(3) %304, i32 %442 - store float %441, ptr addrspace(3) %443, align 4 - %444 = add i32 %391, %367 - %445 = extractelement <4 x float> %302, i64 1 - %446 = mul i32 %444, 4 - %447 = getelementptr i8, ptr addrspace(3) %304, i32 %446 - store float %445, ptr addrspace(3) %447, align 4 - %448 = add i32 %397, %367 - %449 = extractelement <4 x float> %302, i64 2 - %450 = mul i32 %448, 4 - %451 = getelementptr i8, ptr addrspace(3) %304, i32 %450 - store float %449, ptr addrspace(3) %451, align 4 - %452 = add i32 %403, %367 - %453 = extractelement <4 x float> %302, i64 3 - %454 = mul i32 %452, 4 - %455 = getelementptr i8, ptr addrspace(3) %304, i32 %454 - store float %453, ptr addrspace(3) %455, align 4 - fence syncscope("workgroup") release - call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - %456 = sdiv i32 %24, 32 - %457 = mul i32 %456, 32 - %458 = icmp ne i32 %24, %457 - %459 = icmp slt i32 %24, 0 - %460 = icmp ne i1 %459, false - %461 = and i1 %458, %460 - %462 = add i32 %456, -1 - %463 = select i1 %461, i32 %462, i32 %456 - %464 = srem i32 %24, 32 - %465 = mul i32 %464, 2 - %466 = ptrtoint ptr addrspace(1) %12 to i64 - %467 = inttoptr i64 %466 to ptr addrspace(1) - %468 = ptrtoint ptr addrspace(1) %14 to i64 - %469 = inttoptr i64 %468 to ptr addrspace(1) - %470 = ptrtoint ptr addrspace(1) %17 to i64 - %471 = inttoptr i64 %470 to ptr addrspace(1) - %472 = add i32 %65, %463 - %473 = mul i32 %472, 4 - %474 = getelementptr i8, ptr addrspace(1) %467, i32 %473 - %475 = load i32, ptr addrspace(1) %474, align 4 - %476 = and i32 %475, 16777215 - %477 = icmp slt i32 %476, %16 - %478 = getelementptr i8, ptr addrspace(1) %469, i32 %473 - %479 = load float, ptr addrspace(1) %478, align 4 - br i1 %477, label %480, label %544 - -480: ; preds = %49 - %481 = mul i32 %476, 7168 - %482 = add i32 %481, %93 - %483 = add i32 %482, %465 - %484 = mul i32 %463, 256 - %485 = add i32 %484, %465 - %486 = mul i32 %485, 4 - %487 = getelementptr i8, ptr addrspace(3) %304, i32 %486 - %488 = load <2 x float>, ptr addrspace(3) %487, align 8 - %489 = extractelement <2 x float> %488, i64 0 - %490 = fmul float %489, %479 - %491 = extractelement <2 x float> %488, i64 1 - %492 = fmul float %491, %479 - %493 = insertelement <2 x float> poison, float %490, i64 0 - %494 = insertelement <2 x float> %493, float %492, i64 1 - %495 = fptrunc <2 x float> %494 to <2 x bfloat> - %496 = mul i32 %483, 2 - %497 = getelementptr i8, ptr addrspace(1) %471, i32 %496 - %498 = atomicrmw fadd ptr addrspace(1) %497, <2 x bfloat> %495 syncscope("agent") monotonic, align 4 - %499 = add i32 %485, 64 - %500 = mul i32 %499, 4 - %501 = getelementptr i8, ptr addrspace(3) %304, i32 %500 - %502 = load <2 x float>, ptr addrspace(3) %501, align 8 - %503 = extractelement <2 x float> %502, i64 0 - %504 = fmul float %503, %479 - %505 = extractelement <2 x float> %502, i64 1 - %506 = fmul float %505, %479 - %507 = insertelement <2 x float> poison, float %504, i64 0 - %508 = insertelement <2 x float> %507, float %506, i64 1 - %509 = fptrunc <2 x float> %508 to <2 x bfloat> - %510 = add i32 %483, 64 - %511 = mul i32 %510, 2 - %512 = getelementptr i8, ptr addrspace(1) %471, i32 %511 - %513 = atomicrmw fadd ptr addrspace(1) %512, <2 x bfloat> %509 syncscope("agent") monotonic, align 4 - %514 = add i32 %485, 128 - %515 = mul i32 %514, 4 - %516 = getelementptr i8, ptr addrspace(3) %304, i32 %515 - %517 = load <2 x float>, ptr addrspace(3) %516, align 8 - %518 = extractelement <2 x float> %517, i64 0 - %519 = fmul float %518, %479 - %520 = extractelement <2 x float> %517, i64 1 - %521 = fmul float %520, %479 - %522 = insertelement <2 x float> poison, float %519, i64 0 - %523 = insertelement <2 x float> %522, float %521, i64 1 - %524 = fptrunc <2 x float> %523 to <2 x bfloat> - %525 = add i32 %483, 128 - %526 = mul i32 %525, 2 - %527 = getelementptr i8, ptr addrspace(1) %471, i32 %526 - %528 = atomicrmw fadd ptr addrspace(1) %527, <2 x bfloat> %524 syncscope("agent") monotonic, align 4 - %529 = add i32 %485, 192 - %530 = mul i32 %529, 4 - %531 = getelementptr i8, ptr addrspace(3) %304, i32 %530 - %532 = load <2 x float>, ptr addrspace(3) %531, align 8 - %533 = extractelement <2 x float> %532, i64 0 - %534 = fmul float %533, %479 - %535 = extractelement <2 x float> %532, i64 1 - %536 = fmul float %535, %479 - %537 = insertelement <2 x float> poison, float %534, i64 0 - %538 = insertelement <2 x float> %537, float %536, i64 1 - %539 = fptrunc <2 x float> %538 to <2 x bfloat> - %540 = add i32 %483, 192 - %541 = mul i32 %540, 2 - %542 = getelementptr i8, ptr addrspace(1) %471, i32 %541 - %543 = atomicrmw fadd ptr addrspace(1) %542, <2 x bfloat> %539 syncscope("agent") monotonic, align 4 - br label %544 - -544: ; preds = %480, %49 - %545 = add i32 %463, 8 - %546 = add i32 %65, %545 - %547 = mul i32 %546, 4 - %548 = getelementptr i8, ptr addrspace(1) %467, i32 %547 - %549 = load i32, ptr addrspace(1) %548, align 4 - %550 = and i32 %549, 16777215 - %551 = icmp slt i32 %550, %16 - %552 = getelementptr i8, ptr addrspace(1) %469, i32 %547 - %553 = load float, ptr addrspace(1) %552, align 4 - br i1 %551, label %554, label %618 - -554: ; preds = %544 - %555 = mul i32 %550, 7168 - %556 = add i32 %555, %93 - %557 = add i32 %556, %465 - %558 = mul i32 %545, 256 - %559 = add i32 %558, %465 - %560 = mul i32 %559, 4 - %561 = getelementptr i8, ptr addrspace(3) %304, i32 %560 - %562 = load <2 x float>, ptr addrspace(3) %561, align 8 - %563 = extractelement <2 x float> %562, i64 0 - %564 = fmul float %563, %553 - %565 = extractelement <2 x float> %562, i64 1 - %566 = fmul float %565, %553 - %567 = insertelement <2 x float> poison, float %564, i64 0 - %568 = insertelement <2 x float> %567, float %566, i64 1 - %569 = fptrunc <2 x float> %568 to <2 x bfloat> - %570 = mul i32 %557, 2 - %571 = getelementptr i8, ptr addrspace(1) %471, i32 %570 - %572 = atomicrmw fadd ptr addrspace(1) %571, <2 x bfloat> %569 syncscope("agent") monotonic, align 4 - %573 = add i32 %559, 64 - %574 = mul i32 %573, 4 - %575 = getelementptr i8, ptr addrspace(3) %304, i32 %574 - %576 = load <2 x float>, ptr addrspace(3) %575, align 8 - %577 = extractelement <2 x float> %576, i64 0 - %578 = fmul float %577, %553 - %579 = extractelement <2 x float> %576, i64 1 - %580 = fmul float %579, %553 - %581 = insertelement <2 x float> poison, float %578, i64 0 - %582 = insertelement <2 x float> %581, float %580, i64 1 - %583 = fptrunc <2 x float> %582 to <2 x bfloat> - %584 = add i32 %557, 64 - %585 = mul i32 %584, 2 - %586 = getelementptr i8, ptr addrspace(1) %471, i32 %585 - %587 = atomicrmw fadd ptr addrspace(1) %586, <2 x bfloat> %583 syncscope("agent") monotonic, align 4 - %588 = add i32 %559, 128 - %589 = mul i32 %588, 4 - %590 = getelementptr i8, ptr addrspace(3) %304, i32 %589 - %591 = load <2 x float>, ptr addrspace(3) %590, align 8 - %592 = extractelement <2 x float> %591, i64 0 - %593 = fmul float %592, %553 - %594 = extractelement <2 x float> %591, i64 1 - %595 = fmul float %594, %553 - %596 = insertelement <2 x float> poison, float %593, i64 0 - %597 = insertelement <2 x float> %596, float %595, i64 1 - %598 = fptrunc <2 x float> %597 to <2 x bfloat> - %599 = add i32 %557, 128 - %600 = mul i32 %599, 2 - %601 = getelementptr i8, ptr addrspace(1) %471, i32 %600 - %602 = atomicrmw fadd ptr addrspace(1) %601, <2 x bfloat> %598 syncscope("agent") monotonic, align 4 - %603 = add i32 %559, 192 - %604 = mul i32 %603, 4 - %605 = getelementptr i8, ptr addrspace(3) %304, i32 %604 - %606 = load <2 x float>, ptr addrspace(3) %605, align 8 - %607 = extractelement <2 x float> %606, i64 0 - %608 = fmul float %607, %553 - %609 = extractelement <2 x float> %606, i64 1 - %610 = fmul float %609, %553 - %611 = insertelement <2 x float> poison, float %608, i64 0 - %612 = insertelement <2 x float> %611, float %610, i64 1 - %613 = fptrunc <2 x float> %612 to <2 x bfloat> - %614 = add i32 %557, 192 - %615 = mul i32 %614, 2 - %616 = getelementptr i8, ptr addrspace(1) %471, i32 %615 - %617 = atomicrmw fadd ptr addrspace(1) %616, <2 x bfloat> %613 syncscope("agent") monotonic, align 4 - br label %618 - -618: ; preds = %554, %544 - %619 = add i32 %463, 16 - %620 = add i32 %65, %619 - %621 = mul i32 %620, 4 - %622 = getelementptr i8, ptr addrspace(1) %467, i32 %621 - %623 = load i32, ptr addrspace(1) %622, align 4 - %624 = and i32 %623, 16777215 - %625 = icmp slt i32 %624, %16 - %626 = getelementptr i8, ptr addrspace(1) %469, i32 %621 - %627 = load float, ptr addrspace(1) %626, align 4 - br i1 %625, label %628, label %692 - -628: ; preds = %618 - %629 = mul i32 %624, 7168 - %630 = add i32 %629, %93 - %631 = add i32 %630, %465 - %632 = mul i32 %619, 256 - %633 = add i32 %632, %465 - %634 = mul i32 %633, 4 - %635 = getelementptr i8, ptr addrspace(3) %304, i32 %634 - %636 = load <2 x float>, ptr addrspace(3) %635, align 8 - %637 = extractelement <2 x float> %636, i64 0 - %638 = fmul float %637, %627 - %639 = extractelement <2 x float> %636, i64 1 - %640 = fmul float %639, %627 - %641 = insertelement <2 x float> poison, float %638, i64 0 - %642 = insertelement <2 x float> %641, float %640, i64 1 - %643 = fptrunc <2 x float> %642 to <2 x bfloat> - %644 = mul i32 %631, 2 - %645 = getelementptr i8, ptr addrspace(1) %471, i32 %644 - %646 = atomicrmw fadd ptr addrspace(1) %645, <2 x bfloat> %643 syncscope("agent") monotonic, align 4 - %647 = add i32 %633, 64 - %648 = mul i32 %647, 4 - %649 = getelementptr i8, ptr addrspace(3) %304, i32 %648 - %650 = load <2 x float>, ptr addrspace(3) %649, align 8 - %651 = extractelement <2 x float> %650, i64 0 - %652 = fmul float %651, %627 - %653 = extractelement <2 x float> %650, i64 1 - %654 = fmul float %653, %627 - %655 = insertelement <2 x float> poison, float %652, i64 0 - %656 = insertelement <2 x float> %655, float %654, i64 1 - %657 = fptrunc <2 x float> %656 to <2 x bfloat> - %658 = add i32 %631, 64 - %659 = mul i32 %658, 2 - %660 = getelementptr i8, ptr addrspace(1) %471, i32 %659 - %661 = atomicrmw fadd ptr addrspace(1) %660, <2 x bfloat> %657 syncscope("agent") monotonic, align 4 - %662 = add i32 %633, 128 - %663 = mul i32 %662, 4 - %664 = getelementptr i8, ptr addrspace(3) %304, i32 %663 - %665 = load <2 x float>, ptr addrspace(3) %664, align 8 - %666 = extractelement <2 x float> %665, i64 0 - %667 = fmul float %666, %627 - %668 = extractelement <2 x float> %665, i64 1 - %669 = fmul float %668, %627 - %670 = insertelement <2 x float> poison, float %667, i64 0 - %671 = insertelement <2 x float> %670, float %669, i64 1 - %672 = fptrunc <2 x float> %671 to <2 x bfloat> - %673 = add i32 %631, 128 - %674 = mul i32 %673, 2 - %675 = getelementptr i8, ptr addrspace(1) %471, i32 %674 - %676 = atomicrmw fadd ptr addrspace(1) %675, <2 x bfloat> %672 syncscope("agent") monotonic, align 4 - %677 = add i32 %633, 192 - %678 = mul i32 %677, 4 - %679 = getelementptr i8, ptr addrspace(3) %304, i32 %678 - %680 = load <2 x float>, ptr addrspace(3) %679, align 8 - %681 = extractelement <2 x float> %680, i64 0 - %682 = fmul float %681, %627 - %683 = extractelement <2 x float> %680, i64 1 - %684 = fmul float %683, %627 - %685 = insertelement <2 x float> poison, float %682, i64 0 - %686 = insertelement <2 x float> %685, float %684, i64 1 - %687 = fptrunc <2 x float> %686 to <2 x bfloat> - %688 = add i32 %631, 192 - %689 = mul i32 %688, 2 - %690 = getelementptr i8, ptr addrspace(1) %471, i32 %689 - %691 = atomicrmw fadd ptr addrspace(1) %690, <2 x bfloat> %687 syncscope("agent") monotonic, align 4 - br label %692 - -692: ; preds = %628, %618 - %693 = add i32 %463, 24 - %694 = add i32 %65, %693 - %695 = mul i32 %694, 4 - %696 = getelementptr i8, ptr addrspace(1) %467, i32 %695 - %697 = load i32, ptr addrspace(1) %696, align 4 - %698 = and i32 %697, 16777215 - %699 = icmp slt i32 %698, %16 - %700 = getelementptr i8, ptr addrspace(1) %469, i32 %695 - %701 = load float, ptr addrspace(1) %700, align 4 - br i1 %699, label %702, label %766 - -702: ; preds = %692 - %703 = mul i32 %698, 7168 - %704 = add i32 %703, %93 - %705 = add i32 %704, %465 - %706 = mul i32 %693, 256 - %707 = add i32 %706, %465 - %708 = mul i32 %707, 4 - %709 = getelementptr i8, ptr addrspace(3) %304, i32 %708 - %710 = load <2 x float>, ptr addrspace(3) %709, align 8 - %711 = extractelement <2 x float> %710, i64 0 - %712 = fmul float %711, %701 - %713 = extractelement <2 x float> %710, i64 1 - %714 = fmul float %713, %701 - %715 = insertelement <2 x float> poison, float %712, i64 0 - %716 = insertelement <2 x float> %715, float %714, i64 1 - %717 = fptrunc <2 x float> %716 to <2 x bfloat> - %718 = mul i32 %705, 2 - %719 = getelementptr i8, ptr addrspace(1) %471, i32 %718 - %720 = atomicrmw fadd ptr addrspace(1) %719, <2 x bfloat> %717 syncscope("agent") monotonic, align 4 - %721 = add i32 %707, 64 - %722 = mul i32 %721, 4 - %723 = getelementptr i8, ptr addrspace(3) %304, i32 %722 - %724 = load <2 x float>, ptr addrspace(3) %723, align 8 - %725 = extractelement <2 x float> %724, i64 0 - %726 = fmul float %725, %701 - %727 = extractelement <2 x float> %724, i64 1 - %728 = fmul float %727, %701 - %729 = insertelement <2 x float> poison, float %726, i64 0 - %730 = insertelement <2 x float> %729, float %728, i64 1 - %731 = fptrunc <2 x float> %730 to <2 x bfloat> - %732 = add i32 %705, 64 - %733 = mul i32 %732, 2 - %734 = getelementptr i8, ptr addrspace(1) %471, i32 %733 - %735 = atomicrmw fadd ptr addrspace(1) %734, <2 x bfloat> %731 syncscope("agent") monotonic, align 4 - %736 = add i32 %707, 128 - %737 = mul i32 %736, 4 - %738 = getelementptr i8, ptr addrspace(3) %304, i32 %737 - %739 = load <2 x float>, ptr addrspace(3) %738, align 8 - %740 = extractelement <2 x float> %739, i64 0 - %741 = fmul float %740, %701 - %742 = extractelement <2 x float> %739, i64 1 - %743 = fmul float %742, %701 - %744 = insertelement <2 x float> poison, float %741, i64 0 - %745 = insertelement <2 x float> %744, float %743, i64 1 - %746 = fptrunc <2 x float> %745 to <2 x bfloat> - %747 = add i32 %705, 128 - %748 = mul i32 %747, 2 - %749 = getelementptr i8, ptr addrspace(1) %471, i32 %748 - %750 = atomicrmw fadd ptr addrspace(1) %749, <2 x bfloat> %746 syncscope("agent") monotonic, align 4 - %751 = add i32 %707, 192 - %752 = mul i32 %751, 4 - %753 = getelementptr i8, ptr addrspace(3) %304, i32 %752 - %754 = load <2 x float>, ptr addrspace(3) %753, align 8 - %755 = extractelement <2 x float> %754, i64 0 - %756 = fmul float %755, %701 - %757 = extractelement <2 x float> %754, i64 1 - %758 = fmul float %757, %701 - %759 = insertelement <2 x float> poison, float %756, i64 0 - %760 = insertelement <2 x float> %759, float %758, i64 1 - %761 = fptrunc <2 x float> %760 to <2 x bfloat> - %762 = add i32 %705, 192 - %763 = mul i32 %762, 2 - %764 = getelementptr i8, ptr addrspace(1) %471, i32 %763 - %765 = atomicrmw fadd ptr addrspace(1) %764, <2 x bfloat> %761 syncscope("agent") monotonic, align 4 - br label %766 - -766: ; preds = %702, %692 - br label %767 - -767: ; preds = %766, %19 - ret void -} - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #1 - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef i32 @llvm.amdgcn.workgroup.id.x() #1 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) -declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 - -; Function Attrs: nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) -declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p0(ptr readnone, i16, i64, i32) #3 - -; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #4 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.sched.barrier(i32 immarg) #5 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #6 - -; Function Attrs: convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) -declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #7 - -; Function Attrs: convergent nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.s.barrier() #5 - -attributes #0 = { "amdgpu-flat-work-group-size"="256,256" "uniform-work-group-size" } -attributes #1 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } -attributes #2 = { convergent nocallback nocreateundeforpoison nofree nounwind willreturn memory(none) } -attributes #3 = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } -attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } -attributes #5 = { convergent nocallback nofree nounwind willreturn } -attributes #6 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) } -attributes #7 = { convergent nocallback nocreateundeforpoison nofree nosync nounwind willreturn memory(none) } - -!llvm.module.flags = !{!0} - -!0 = !{i32 2, !"Debug Info Version", i32 3} -!1 = !{i32 256, i32 1, i32 1} diff --git a/kernels/gemm2_port_ref/hip_gemm2_bm32.ll b/kernels/gemm2_port_ref/hip_gemm2_bm32.ll deleted file mode 100644 index 5f5ed7a9a..000000000 --- a/kernels/gemm2_port_ref/hip_gemm2_bm32.ll +++ /dev/null @@ -1,570 +0,0 @@ -; ModuleID = '/tmp/aiter/aiter/jit/build/module_moe_mxfp4_gemm/blob/instances/mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC.cu' -source_filename = "/tmp/aiter/aiter/jit/build/module_moe_mxfp4_gemm/blob/instances/mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC.cu" -target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-p7:160:256:256:32-p8:128:128:128:48-p9:192:256:256:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-G1-ni:7:8:9" -target triple = "amdgcn-amd-amdhsa" - -%"struct.aiter::mxfp4_moe::gemm2::LDSLayout" = type { %union.anon } -%union.anon = type { [8192 x float] } -%struct.__hip_bfloat16 = type { %union.anon.17 } -%union.anon.17 = type { i16 } - -$_ZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16Ph = comdat any - -$_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds = comdat any - -@_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds = linkonce_odr hidden addrspace(3) global %"struct.aiter::mxfp4_moe::gemm2::LDSLayout" undef, comdat, align 16 -@__hip_cuid_63e8a0938c35de0f = addrspace(1) global i8 0 -@llvm.compiler.used = appending addrspace(1) global [1 x ptr] [ptr addrspacecast (ptr addrspace(1) @__hip_cuid_63e8a0938c35de0f to ptr)], section "llvm.metadata" - -; Function Attrs: convergent mustprogress norecurse nounwind -define protected amdgpu_kernel void @_ZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16Ph(ptr addrspace(1) noalias noundef readonly captures(none) %0, ptr addrspace(1) noalias noundef readonly captures(none) %1, ptr addrspace(1) noalias noundef readonly captures(none) %2, ptr addrspace(1) noalias noundef readonly captures(none) %3, ptr addrspace(1) noalias noundef readonly captures(none) %4, ptr addrspace(1) noalias noundef readonly captures(none) %5, ptr addrspace(1) noalias noundef readonly captures(none) %6, ptr addrspace(1) noalias noundef readonly captures(none) %7, i32 noundef %8, ptr addrspace(1) noalias noundef captures(none) %9, ptr addrspace(1) noalias noundef readnone captures(none) %10) local_unnamed_addr #0 comdat { - %12 = tail call noundef i32 @llvm.amdgcn.workgroup.id.x() - %13 = tail call noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() - %14 = icmp samesign ult i32 %13, 256 - tail call void @llvm.assume(i1 %14) - %15 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %13) - %16 = load i32, ptr addrspace(1) %5, align 4, !tbaa !7 - %17 = sdiv i32 %16, 32 - %18 = mul nsw i32 %17, 28 - %19 = icmp slt i32 %12, %18 - br i1 %19, label %20, label %410 - -20: ; preds = %11 - %21 = tail call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p1(ptr addrspace(1) readnone %3, i16 0, i64 44154880, i32 131072) - %22 = tail call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p1(ptr addrspace(1) readnone %1, i16 0, i64 10485760, i32 131072) - %23 = tail call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p1(ptr addrspace(1) readnone %2, i16 0, i64 706478080, i32 131072) - %24 = tail call ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p1(ptr addrspace(1) readnone %0, i16 0, i64 167772160, i32 131072) - %25 = and i32 %13, 63 - %26 = lshr i32 %15, 6 - %27 = sdiv i32 %12, 28 - %28 = mul i32 %27, 28 - %29 = sub i32 %12, %28 - %30 = sext i32 %27 to i64 - %31 = getelementptr inbounds i32, ptr addrspace(1) %4, i64 %30 - %32 = load i32, ptr addrspace(1) %31, align 4, !tbaa !7 - %33 = icmp samesign ult i32 %32, 385 - tail call void @llvm.assume(i1 %33) - %34 = shl nsw i32 %29, 16 - %35 = mul nuw nsw i32 %32, 1835008 - %36 = add nsw i32 %35, %34 - %37 = shl i32 %26, 14 - %38 = add i32 %36, %37 - %39 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %38) - %40 = or disjoint i32 %37, 4096 - %41 = add i32 %40, %36 - %42 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %41) - %43 = or disjoint i32 %37, 8192 - %44 = add i32 %43, %36 - %45 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %44) - %46 = or disjoint i32 %37, 12288 - %47 = add i32 %46, %36 - %48 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %47) - %49 = lshr i32 %25, 3 - %50 = shl nsw i32 %29, 12 - %51 = mul nuw nsw i32 %32, 114688 - %52 = shl i32 %26, 10 - %53 = add i32 %52, %50 - %54 = add i32 %51, %53 - %55 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %54) - %56 = or disjoint i32 %53, 512 - %57 = add i32 %56, %51 - %58 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 %57) - %59 = shl nsw i32 %27, 5 - %60 = or disjoint i32 %49, %59 - %61 = tail call i32 @llvm.amdgcn.readfirstlane.i32(i32 range(i32 -76695844, 67108863) %27) - %62 = shl nsw i32 %61, 9 - %63 = shl i32 %26, 11 - %64 = shl i32 %60, 8 - %65 = add i32 %63, %64 - %66 = shl nuw nsw i32 %26, 3 - %67 = or disjoint i32 %66, %49 - %68 = shl nuw i32 %67, 3 - %69 = shl nuw nsw i32 %13, 4 - %70 = xor i32 %68, %69 - %71 = and i32 %70, 112 - %72 = or disjoint i32 %71, %65 - %73 = getelementptr inbounds nuw [128 x i8], ptr addrspace(3) @_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds, i32 %66 - tail call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly %24, ptr addrspace(3) noundef %73, i32 noundef 16, i32 noundef %72, i32 noundef range(i32 0, 129) 0, i32 noundef 0, i32 noundef 0) #10 - %74 = getelementptr inbounds nuw [128 x i8], ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds, i32 4096), i32 %66 - tail call void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly %24, ptr addrspace(3) noundef nonnull %74, i32 noundef 16, i32 noundef %72, i32 noundef range(i32 0, 129) 128, i32 noundef 0, i32 noundef 0) #10 - tail call void @llvm.amdgcn.sched.barrier(i32 0) - %75 = lshr i32 %25, 4 - %76 = and i32 %13, 15 - %77 = shl nuw nsw i32 %75, 6 - %78 = shl nuw nsw i32 %76, 2 - %79 = or disjoint i32 %77, %78 - %80 = or disjoint i32 %79, 256 - %81 = tail call noundef i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly %22, i32 %79, i32 %62, i32 0) - %82 = tail call noundef i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly %22, i32 %80, i32 %62, i32 0) - %83 = tail call noundef i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly %21, i32 %79, i32 %55, i32 0) - %84 = tail call noundef i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly %21, i32 %79, i32 %58, i32 0) - %85 = tail call noundef i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly %21, i32 %80, i32 %55, i32 0) - %86 = tail call noundef i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly %21, i32 %80, i32 %58, i32 0) - %87 = shl nuw nsw i32 %75, 8 - %88 = shl nuw nsw i32 %76, 4 - %89 = or disjoint i32 %87, %88 - %90 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %89, i32 %39, i32 0) - %91 = or disjoint i32 %89, 1024 - %92 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %91, i32 %39, i32 0) - %93 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %89, i32 %42, i32 0) - %94 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %91, i32 %42, i32 0) - %95 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %89, i32 %45, i32 0) - %96 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %91, i32 %45, i32 0) - %97 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %89, i32 %48, i32 0) - %98 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %91, i32 %48, i32 0) - %99 = or disjoint i32 %89, 2048 - %100 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %99, i32 %39, i32 0) - %101 = or disjoint i32 %89, 3072 - %102 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %101, i32 %39, i32 0) - %103 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %99, i32 %42, i32 0) - %104 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %101, i32 %42, i32 0) - %105 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %99, i32 %45, i32 0) - %106 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %101, i32 %45, i32 0) - %107 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %99, i32 %48, i32 0) - %108 = tail call <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly %23, i32 %101, i32 %48, i32 0) - tail call void asm sideeffect "s_waitcnt vmcnt(23)", "~{memory}"() #10, !srcloc !11 - tail call void @llvm.amdgcn.s.barrier() - %109 = and i32 %13, 48 - %110 = shl nuw nsw i32 %13, 3 - %111 = and i32 %110, 112 - %112 = getelementptr [128 x i8], ptr addrspace(3) @_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds, i32 %76 - %113 = xor i32 %111, %109 - %114 = getelementptr i8, ptr addrspace(3) %112, i32 %113 - %115 = load <4 x i32>, ptr addrspace(3) %114, align 16, !tbaa !12 - %116 = getelementptr i8, ptr addrspace(3) %114, i32 2048 - %117 = load <4 x i32>, ptr addrspace(3) %116, align 16, !tbaa !12 - %118 = or disjoint i32 %109, 64 - %119 = xor i32 %118, %111 - %120 = getelementptr i8, ptr addrspace(3) %112, i32 %119 - %121 = load <4 x i32>, ptr addrspace(3) %120, align 16, !tbaa !12 - %122 = getelementptr i8, ptr addrspace(3) %120, i32 2048 - %123 = load <4 x i32>, ptr addrspace(3) %122, align 16, !tbaa !12 - %124 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %115, <4 x i32> noundef %90, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %81, i32 noundef 0, i32 noundef %83) #10 - %125 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %117, <4 x i32> noundef %90, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %81, i32 noundef 0, i32 noundef %83) #10 - %126 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %121, <4 x i32> noundef %92, <4 x float> noundef %124, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %81, i32 noundef 2, i32 noundef %83) #10 - %127 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %123, <4 x i32> noundef %92, <4 x float> noundef %125, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %81, i32 noundef 2, i32 noundef %83) #10 - %128 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %115, <4 x i32> noundef %93, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %81, i32 noundef 1, i32 noundef %83) #10 - %129 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %117, <4 x i32> noundef %93, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %81, i32 noundef 1, i32 noundef %83) #10 - %130 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %121, <4 x i32> noundef %94, <4 x float> noundef %128, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %81, i32 noundef 3, i32 noundef %83) #10 - %131 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %123, <4 x i32> noundef %94, <4 x float> noundef %129, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %81, i32 noundef 3, i32 noundef %83) #10 - %132 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %115, <4 x i32> noundef %95, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %81, i32 noundef 0, i32 noundef %84) #10 - %133 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %117, <4 x i32> noundef %95, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %81, i32 noundef 0, i32 noundef %84) #10 - %134 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %121, <4 x i32> noundef %96, <4 x float> noundef %132, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %81, i32 noundef 2, i32 noundef %84) #10 - %135 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %123, <4 x i32> noundef %96, <4 x float> noundef %133, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %81, i32 noundef 2, i32 noundef %84) #10 - %136 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %115, <4 x i32> noundef %97, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %81, i32 noundef 1, i32 noundef %84) #10 - %137 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %117, <4 x i32> noundef %97, <4 x float> noundef zeroinitializer, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %81, i32 noundef 1, i32 noundef %84) #10 - %138 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %121, <4 x i32> noundef %98, <4 x float> noundef %136, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %81, i32 noundef 3, i32 noundef %84) #10 - %139 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %123, <4 x i32> noundef %98, <4 x float> noundef %137, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %81, i32 noundef 3, i32 noundef %84) #10 - tail call void asm sideeffect "s_waitcnt vmcnt(22)", "~{memory}"() #10, !srcloc !13 - tail call void @llvm.amdgcn.s.barrier() - %140 = getelementptr [128 x i8], ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds, i32 4096), i32 %76 - %141 = getelementptr i8, ptr addrspace(3) %140, i32 %113 - %142 = load <4 x i32>, ptr addrspace(3) %141, align 16, !tbaa !12 - %143 = getelementptr i8, ptr addrspace(3) %141, i32 2048 - %144 = load <4 x i32>, ptr addrspace(3) %143, align 16, !tbaa !12 - %145 = getelementptr i8, ptr addrspace(3) %140, i32 %119 - %146 = load <4 x i32>, ptr addrspace(3) %145, align 16, !tbaa !12 - %147 = getelementptr i8, ptr addrspace(3) %145, i32 2048 - %148 = load <4 x i32>, ptr addrspace(3) %147, align 16, !tbaa !12 - %149 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %142, <4 x i32> noundef %100, <4 x float> noundef %126, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %82, i32 noundef 0, i32 noundef %85) #10 - %150 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %144, <4 x i32> noundef %100, <4 x float> noundef %127, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %82, i32 noundef 0, i32 noundef %85) #10 - %151 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %146, <4 x i32> noundef %102, <4 x float> noundef %149, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %82, i32 noundef 2, i32 noundef %85) #10 - %152 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %148, <4 x i32> noundef %102, <4 x float> noundef %150, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %82, i32 noundef 2, i32 noundef %85) #10 - %153 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %142, <4 x i32> noundef %103, <4 x float> noundef %130, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %82, i32 noundef 1, i32 noundef %85) #10 - %154 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %144, <4 x i32> noundef %103, <4 x float> noundef %131, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %82, i32 noundef 1, i32 noundef %85) #10 - %155 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %146, <4 x i32> noundef %104, <4 x float> noundef %153, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %82, i32 noundef 3, i32 noundef %85) #10 - %156 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %148, <4 x i32> noundef %104, <4 x float> noundef %154, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %82, i32 noundef 3, i32 noundef %85) #10 - %157 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %142, <4 x i32> noundef %105, <4 x float> noundef %134, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %82, i32 noundef 0, i32 noundef %86) #10 - %158 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %144, <4 x i32> noundef %105, <4 x float> noundef %135, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %82, i32 noundef 0, i32 noundef %86) #10 - %159 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %146, <4 x i32> noundef %106, <4 x float> noundef %157, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %82, i32 noundef 2, i32 noundef %86) #10 - %160 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %148, <4 x i32> noundef %106, <4 x float> noundef %158, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %82, i32 noundef 2, i32 noundef %86) #10 - %161 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %142, <4 x i32> noundef %107, <4 x float> noundef %138, i32 noundef 4, i32 noundef 4, i32 noundef 0, i32 noundef %82, i32 noundef 1, i32 noundef %86) #10 - %162 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %144, <4 x i32> noundef %107, <4 x float> noundef %139, i32 noundef 4, i32 noundef 4, i32 noundef 1, i32 noundef %82, i32 noundef 1, i32 noundef %86) #10 - %163 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %146, <4 x i32> noundef %108, <4 x float> noundef %161, i32 noundef 4, i32 noundef 4, i32 noundef 2, i32 noundef %82, i32 noundef 3, i32 noundef %86) #10 - %164 = tail call contract <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32> noundef %148, <4 x i32> noundef %108, <4 x float> noundef %162, i32 noundef 4, i32 noundef 4, i32 noundef 3, i32 noundef %82, i32 noundef 3, i32 noundef %86) #10 - fence syncscope("workgroup") release - tail call void @llvm.amdgcn.s.barrier() - fence syncscope("workgroup") acquire - tail call void @llvm.experimental.noalias.scope.decl(metadata !14) - tail call void @llvm.experimental.noalias.scope.decl(metadata !17) - tail call void @llvm.experimental.noalias.scope.decl(metadata !19) - %165 = shl nuw nsw i32 %75, 12 - %166 = shl i32 %26, 8 - %167 = getelementptr i8, ptr addrspace(3) @_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds, i32 %166 - %168 = getelementptr float, ptr addrspace(3) %167, i32 %76 - %169 = extractelement <4 x float> %151, i64 0 - %170 = getelementptr i8, ptr addrspace(3) %168, i32 %165 - store float %169, ptr addrspace(3) %170, align 4, !tbaa !21, !noalias !23 - %171 = extractelement <4 x float> %151, i64 1 - %172 = or disjoint i32 %165, 1024 - %173 = getelementptr i8, ptr addrspace(3) %168, i32 %172 - store float %171, ptr addrspace(3) %173, align 4, !tbaa !21, !noalias !23 - %174 = extractelement <4 x float> %151, i64 2 - %175 = or disjoint i32 %165, 2048 - %176 = getelementptr i8, ptr addrspace(3) %168, i32 %175 - store float %174, ptr addrspace(3) %176, align 4, !tbaa !21, !noalias !23 - %177 = extractelement <4 x float> %151, i64 3 - %178 = or disjoint i32 %165, 3072 - %179 = getelementptr i8, ptr addrspace(3) %168, i32 %178 - store float %177, ptr addrspace(3) %179, align 4, !tbaa !21, !noalias !23 - %180 = getelementptr i8, ptr addrspace(3) %168, i32 64 - %181 = extractelement <4 x float> %155, i64 0 - %182 = getelementptr i8, ptr addrspace(3) %180, i32 %165 - store float %181, ptr addrspace(3) %182, align 4, !tbaa !21, !noalias !23 - %183 = extractelement <4 x float> %155, i64 1 - %184 = getelementptr i8, ptr addrspace(3) %180, i32 %172 - store float %183, ptr addrspace(3) %184, align 4, !tbaa !21, !noalias !23 - %185 = extractelement <4 x float> %155, i64 2 - %186 = getelementptr i8, ptr addrspace(3) %180, i32 %175 - store float %185, ptr addrspace(3) %186, align 4, !tbaa !21, !noalias !23 - %187 = extractelement <4 x float> %155, i64 3 - %188 = getelementptr i8, ptr addrspace(3) %180, i32 %178 - store float %187, ptr addrspace(3) %188, align 4, !tbaa !21, !noalias !23 - %189 = getelementptr i8, ptr addrspace(3) %168, i32 128 - %190 = extractelement <4 x float> %159, i64 0 - %191 = getelementptr i8, ptr addrspace(3) %189, i32 %165 - store float %190, ptr addrspace(3) %191, align 4, !tbaa !21, !noalias !23 - %192 = extractelement <4 x float> %159, i64 1 - %193 = getelementptr i8, ptr addrspace(3) %189, i32 %172 - store float %192, ptr addrspace(3) %193, align 4, !tbaa !21, !noalias !23 - %194 = extractelement <4 x float> %159, i64 2 - %195 = getelementptr i8, ptr addrspace(3) %189, i32 %175 - store float %194, ptr addrspace(3) %195, align 4, !tbaa !21, !noalias !23 - %196 = extractelement <4 x float> %159, i64 3 - %197 = getelementptr i8, ptr addrspace(3) %189, i32 %178 - store float %196, ptr addrspace(3) %197, align 4, !tbaa !21, !noalias !23 - %198 = getelementptr i8, ptr addrspace(3) %168, i32 192 - %199 = extractelement <4 x float> %163, i64 0 - %200 = getelementptr i8, ptr addrspace(3) %198, i32 %165 - store float %199, ptr addrspace(3) %200, align 4, !tbaa !21, !noalias !23 - %201 = extractelement <4 x float> %163, i64 1 - %202 = getelementptr i8, ptr addrspace(3) %198, i32 %172 - store float %201, ptr addrspace(3) %202, align 4, !tbaa !21, !noalias !23 - %203 = extractelement <4 x float> %163, i64 2 - %204 = getelementptr i8, ptr addrspace(3) %198, i32 %175 - store float %203, ptr addrspace(3) %204, align 4, !tbaa !21, !noalias !23 - %205 = extractelement <4 x float> %163, i64 3 - %206 = getelementptr i8, ptr addrspace(3) %198, i32 %178 - store float %205, ptr addrspace(3) %206, align 4, !tbaa !21, !noalias !23 - %207 = extractelement <4 x float> %152, i64 0 - %208 = or disjoint i32 %165, 16384 - %209 = getelementptr i8, ptr addrspace(3) %168, i32 %208 - store float %207, ptr addrspace(3) %209, align 4, !tbaa !21, !noalias !23 - %210 = extractelement <4 x float> %152, i64 1 - %211 = or disjoint i32 %165, 17408 - %212 = getelementptr i8, ptr addrspace(3) %168, i32 %211 - store float %210, ptr addrspace(3) %212, align 4, !tbaa !21, !noalias !23 - %213 = extractelement <4 x float> %152, i64 2 - %214 = or disjoint i32 %165, 18432 - %215 = getelementptr i8, ptr addrspace(3) %168, i32 %214 - store float %213, ptr addrspace(3) %215, align 4, !tbaa !21, !noalias !23 - %216 = extractelement <4 x float> %152, i64 3 - %217 = or disjoint i32 %165, 19456 - %218 = getelementptr i8, ptr addrspace(3) %168, i32 %217 - store float %216, ptr addrspace(3) %218, align 4, !tbaa !21, !noalias !23 - %219 = extractelement <4 x float> %156, i64 0 - %220 = getelementptr i8, ptr addrspace(3) %180, i32 %208 - store float %219, ptr addrspace(3) %220, align 4, !tbaa !21, !noalias !23 - %221 = extractelement <4 x float> %156, i64 1 - %222 = getelementptr i8, ptr addrspace(3) %180, i32 %211 - store float %221, ptr addrspace(3) %222, align 4, !tbaa !21, !noalias !23 - %223 = extractelement <4 x float> %156, i64 2 - %224 = getelementptr i8, ptr addrspace(3) %180, i32 %214 - store float %223, ptr addrspace(3) %224, align 4, !tbaa !21, !noalias !23 - %225 = extractelement <4 x float> %156, i64 3 - %226 = getelementptr i8, ptr addrspace(3) %180, i32 %217 - store float %225, ptr addrspace(3) %226, align 4, !tbaa !21, !noalias !23 - %227 = extractelement <4 x float> %160, i64 0 - %228 = getelementptr i8, ptr addrspace(3) %189, i32 %208 - store float %227, ptr addrspace(3) %228, align 4, !tbaa !21, !noalias !23 - %229 = extractelement <4 x float> %160, i64 1 - %230 = getelementptr i8, ptr addrspace(3) %189, i32 %211 - store float %229, ptr addrspace(3) %230, align 4, !tbaa !21, !noalias !23 - %231 = extractelement <4 x float> %160, i64 2 - %232 = getelementptr i8, ptr addrspace(3) %189, i32 %214 - store float %231, ptr addrspace(3) %232, align 4, !tbaa !21, !noalias !23 - %233 = extractelement <4 x float> %160, i64 3 - %234 = getelementptr i8, ptr addrspace(3) %189, i32 %217 - store float %233, ptr addrspace(3) %234, align 4, !tbaa !21, !noalias !23 - %235 = extractelement <4 x float> %164, i64 0 - %236 = getelementptr i8, ptr addrspace(3) %198, i32 %208 - store float %235, ptr addrspace(3) %236, align 4, !tbaa !21, !noalias !23 - %237 = extractelement <4 x float> %164, i64 1 - %238 = getelementptr i8, ptr addrspace(3) %198, i32 %211 - store float %237, ptr addrspace(3) %238, align 4, !tbaa !21, !noalias !23 - %239 = extractelement <4 x float> %164, i64 2 - %240 = getelementptr i8, ptr addrspace(3) %198, i32 %214 - store float %239, ptr addrspace(3) %240, align 4, !tbaa !21, !noalias !23 - %241 = extractelement <4 x float> %164, i64 3 - %242 = getelementptr i8, ptr addrspace(3) %198, i32 %217 - store float %241, ptr addrspace(3) %242, align 4, !tbaa !21, !noalias !23 - fence syncscope("workgroup") release - tail call void @llvm.amdgcn.s.barrier(), !noalias !23 - fence syncscope("workgroup") acquire - %243 = lshr i32 %13, 5 - %244 = shl nuw nsw i32 %13, 1 - %245 = and i32 %244, 62 - %246 = getelementptr float, ptr addrspace(3) @_ZZN5aiter9mxfp4_moe5gemm26kernelILi655360ELi385ELi512ELi7168ELi9ELi32ELNS1_12EpilogPolicyE0ELb0ELi0ELb0EEEvPKhPKaS5_S7_PKiS9_S9_PKfiP14__hip_bfloat16PhE3lds, i32 %245 - %247 = shl nsw i32 %29, 8 - %248 = sext i32 %247 to i64 - %249 = zext nneg i32 %245 to i64 - %250 = getelementptr %struct.__hip_bfloat16, ptr addrspace(1) %9, i64 %248 - %251 = getelementptr %struct.__hip_bfloat16, ptr addrspace(1) %250, i64 %249 - %252 = or disjoint i32 %59, %243 - %253 = sext i32 %252 to i64 - %254 = getelementptr inbounds i32, ptr addrspace(1) %6, i64 %253 - %255 = load i32, ptr addrspace(1) %254, align 4, !tbaa !7, !alias.scope !17, !noalias !24 - %256 = and i32 %255, 16777215 - %257 = icmp slt i32 %256, %8 - br i1 %257, label %258, label %290 - -258: ; preds = %20 - %259 = getelementptr inbounds float, ptr addrspace(1) %7, i64 %253 - %260 = load float, ptr addrspace(1) %259, align 4, !tbaa !21, !alias.scope !19, !noalias !25 - %261 = shl nuw nsw i32 %243, 10 - %262 = getelementptr i8, ptr addrspace(3) %246, i32 %261 - %263 = getelementptr i8, ptr addrspace(3) %262, i32 256 - %264 = getelementptr i8, ptr addrspace(3) %262, i32 512 - %265 = getelementptr i8, ptr addrspace(3) %262, i32 768 - %266 = zext nneg i32 %256 to i64 - %267 = mul nuw nsw i64 %266, 14336 - %268 = getelementptr i8, ptr addrspace(1) %251, i64 %267 - %269 = load <2 x float>, ptr addrspace(3) %262, align 8, !tbaa !21, !noalias !23 - %270 = insertelement <2 x float> poison, float %260, i64 0 - %271 = shufflevector <2 x float> %270, <2 x float> poison, <2 x i32> zeroinitializer - %272 = fmul contract <2 x float> %271, %269 - %273 = fptrunc <2 x float> %272 to <2 x bfloat> - %274 = atomicrmw fadd ptr addrspace(1) %268, <2 x bfloat> %273 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - %275 = load <2 x float>, ptr addrspace(3) %263, align 8, !tbaa !21, !noalias !23 - %276 = fmul contract <2 x float> %271, %275 - %277 = fptrunc <2 x float> %276 to <2 x bfloat> - %278 = getelementptr inbounds nuw i8, ptr addrspace(1) %268, i64 128 - %279 = atomicrmw fadd ptr addrspace(1) %278, <2 x bfloat> %277 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - %280 = load <2 x float>, ptr addrspace(3) %264, align 8, !tbaa !21, !noalias !23 - %281 = fmul contract <2 x float> %271, %280 - %282 = fptrunc <2 x float> %281 to <2 x bfloat> - %283 = getelementptr inbounds nuw i8, ptr addrspace(1) %268, i64 256 - %284 = atomicrmw fadd ptr addrspace(1) %283, <2 x bfloat> %282 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - %285 = load <2 x float>, ptr addrspace(3) %265, align 8, !tbaa !21, !noalias !23 - %286 = fmul contract <2 x float> %271, %285 - %287 = fptrunc <2 x float> %286 to <2 x bfloat> - %288 = getelementptr inbounds nuw i8, ptr addrspace(1) %268, i64 384 - %289 = atomicrmw fadd ptr addrspace(1) %288, <2 x bfloat> %287 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - br label %290 - -290: ; preds = %258, %20 - %291 = or disjoint i32 %243, 8 - %292 = or disjoint i32 %291, %59 - %293 = sext i32 %292 to i64 - %294 = getelementptr inbounds i32, ptr addrspace(1) %6, i64 %293 - %295 = load i32, ptr addrspace(1) %294, align 4, !tbaa !7, !alias.scope !17, !noalias !24 - %296 = and i32 %295, 16777215 - %297 = icmp slt i32 %296, %8 - br i1 %297, label %298, label %330 - -298: ; preds = %290 - %299 = getelementptr inbounds float, ptr addrspace(1) %7, i64 %293 - %300 = load float, ptr addrspace(1) %299, align 4, !tbaa !21, !alias.scope !19, !noalias !25 - %301 = shl nuw nsw i32 %291, 10 - %302 = getelementptr i8, ptr addrspace(3) %246, i32 %301 - %303 = getelementptr i8, ptr addrspace(3) %302, i32 256 - %304 = getelementptr i8, ptr addrspace(3) %302, i32 512 - %305 = getelementptr i8, ptr addrspace(3) %302, i32 768 - %306 = zext nneg i32 %296 to i64 - %307 = mul nuw nsw i64 %306, 14336 - %308 = getelementptr i8, ptr addrspace(1) %251, i64 %307 - %309 = load <2 x float>, ptr addrspace(3) %302, align 8, !tbaa !21, !noalias !23 - %310 = insertelement <2 x float> poison, float %300, i64 0 - %311 = shufflevector <2 x float> %310, <2 x float> poison, <2 x i32> zeroinitializer - %312 = fmul contract <2 x float> %311, %309 - %313 = fptrunc <2 x float> %312 to <2 x bfloat> - %314 = atomicrmw fadd ptr addrspace(1) %308, <2 x bfloat> %313 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - %315 = load <2 x float>, ptr addrspace(3) %303, align 8, !tbaa !21, !noalias !23 - %316 = fmul contract <2 x float> %311, %315 - %317 = fptrunc <2 x float> %316 to <2 x bfloat> - %318 = getelementptr inbounds nuw i8, ptr addrspace(1) %308, i64 128 - %319 = atomicrmw fadd ptr addrspace(1) %318, <2 x bfloat> %317 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - %320 = load <2 x float>, ptr addrspace(3) %304, align 8, !tbaa !21, !noalias !23 - %321 = fmul contract <2 x float> %311, %320 - %322 = fptrunc <2 x float> %321 to <2 x bfloat> - %323 = getelementptr inbounds nuw i8, ptr addrspace(1) %308, i64 256 - %324 = atomicrmw fadd ptr addrspace(1) %323, <2 x bfloat> %322 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - %325 = load <2 x float>, ptr addrspace(3) %305, align 8, !tbaa !21, !noalias !23 - %326 = fmul contract <2 x float> %311, %325 - %327 = fptrunc <2 x float> %326 to <2 x bfloat> - %328 = getelementptr inbounds nuw i8, ptr addrspace(1) %308, i64 384 - %329 = atomicrmw fadd ptr addrspace(1) %328, <2 x bfloat> %327 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - br label %330 - -330: ; preds = %298, %290 - %331 = or disjoint i32 %243, 16 - %332 = or disjoint i32 %331, %59 - %333 = sext i32 %332 to i64 - %334 = getelementptr inbounds i32, ptr addrspace(1) %6, i64 %333 - %335 = load i32, ptr addrspace(1) %334, align 4, !tbaa !7, !alias.scope !17, !noalias !24 - %336 = and i32 %335, 16777215 - %337 = icmp slt i32 %336, %8 - br i1 %337, label %338, label %370 - -338: ; preds = %330 - %339 = getelementptr inbounds float, ptr addrspace(1) %7, i64 %333 - %340 = load float, ptr addrspace(1) %339, align 4, !tbaa !21, !alias.scope !19, !noalias !25 - %341 = shl nuw nsw i32 %331, 10 - %342 = getelementptr i8, ptr addrspace(3) %246, i32 %341 - %343 = getelementptr i8, ptr addrspace(3) %342, i32 256 - %344 = getelementptr i8, ptr addrspace(3) %342, i32 512 - %345 = getelementptr i8, ptr addrspace(3) %342, i32 768 - %346 = zext nneg i32 %336 to i64 - %347 = mul nuw nsw i64 %346, 14336 - %348 = getelementptr i8, ptr addrspace(1) %251, i64 %347 - %349 = load <2 x float>, ptr addrspace(3) %342, align 8, !tbaa !21, !noalias !23 - %350 = insertelement <2 x float> poison, float %340, i64 0 - %351 = shufflevector <2 x float> %350, <2 x float> poison, <2 x i32> zeroinitializer - %352 = fmul contract <2 x float> %351, %349 - %353 = fptrunc <2 x float> %352 to <2 x bfloat> - %354 = atomicrmw fadd ptr addrspace(1) %348, <2 x bfloat> %353 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - %355 = load <2 x float>, ptr addrspace(3) %343, align 8, !tbaa !21, !noalias !23 - %356 = fmul contract <2 x float> %351, %355 - %357 = fptrunc <2 x float> %356 to <2 x bfloat> - %358 = getelementptr inbounds nuw i8, ptr addrspace(1) %348, i64 128 - %359 = atomicrmw fadd ptr addrspace(1) %358, <2 x bfloat> %357 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - %360 = load <2 x float>, ptr addrspace(3) %344, align 8, !tbaa !21, !noalias !23 - %361 = fmul contract <2 x float> %351, %360 - %362 = fptrunc <2 x float> %361 to <2 x bfloat> - %363 = getelementptr inbounds nuw i8, ptr addrspace(1) %348, i64 256 - %364 = atomicrmw fadd ptr addrspace(1) %363, <2 x bfloat> %362 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - %365 = load <2 x float>, ptr addrspace(3) %345, align 8, !tbaa !21, !noalias !23 - %366 = fmul contract <2 x float> %351, %365 - %367 = fptrunc <2 x float> %366 to <2 x bfloat> - %368 = getelementptr inbounds nuw i8, ptr addrspace(1) %348, i64 384 - %369 = atomicrmw fadd ptr addrspace(1) %368, <2 x bfloat> %367 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - br label %370 - -370: ; preds = %338, %330 - %371 = or disjoint i32 %243, 24 - %372 = or disjoint i32 %371, %59 - %373 = sext i32 %372 to i64 - %374 = getelementptr inbounds i32, ptr addrspace(1) %6, i64 %373 - %375 = load i32, ptr addrspace(1) %374, align 4, !tbaa !7, !alias.scope !17, !noalias !24 - %376 = and i32 %375, 16777215 - %377 = icmp slt i32 %376, %8 - br i1 %377, label %378, label %410 - -378: ; preds = %370 - %379 = getelementptr inbounds float, ptr addrspace(1) %7, i64 %373 - %380 = load float, ptr addrspace(1) %379, align 4, !tbaa !21, !alias.scope !19, !noalias !25 - %381 = shl nuw nsw i32 %371, 10 - %382 = getelementptr i8, ptr addrspace(3) %246, i32 %381 - %383 = getelementptr i8, ptr addrspace(3) %382, i32 256 - %384 = getelementptr i8, ptr addrspace(3) %382, i32 512 - %385 = getelementptr i8, ptr addrspace(3) %382, i32 768 - %386 = zext nneg i32 %376 to i64 - %387 = mul nuw nsw i64 %386, 14336 - %388 = getelementptr i8, ptr addrspace(1) %251, i64 %387 - %389 = load <2 x float>, ptr addrspace(3) %382, align 8, !tbaa !21, !noalias !23 - %390 = insertelement <2 x float> poison, float %380, i64 0 - %391 = shufflevector <2 x float> %390, <2 x float> poison, <2 x i32> zeroinitializer - %392 = fmul contract <2 x float> %391, %389 - %393 = fptrunc <2 x float> %392 to <2 x bfloat> - %394 = atomicrmw fadd ptr addrspace(1) %388, <2 x bfloat> %393 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - %395 = load <2 x float>, ptr addrspace(3) %383, align 8, !tbaa !21, !noalias !23 - %396 = fmul contract <2 x float> %391, %395 - %397 = fptrunc <2 x float> %396 to <2 x bfloat> - %398 = getelementptr inbounds nuw i8, ptr addrspace(1) %388, i64 128 - %399 = atomicrmw fadd ptr addrspace(1) %398, <2 x bfloat> %397 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - %400 = load <2 x float>, ptr addrspace(3) %384, align 8, !tbaa !21, !noalias !23 - %401 = fmul contract <2 x float> %391, %400 - %402 = fptrunc <2 x float> %401 to <2 x bfloat> - %403 = getelementptr inbounds nuw i8, ptr addrspace(1) %388, i64 256 - %404 = atomicrmw fadd ptr addrspace(1) %403, <2 x bfloat> %402 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - %405 = load <2 x float>, ptr addrspace(3) %385, align 8, !tbaa !21, !noalias !23 - %406 = fmul contract <2 x float> %391, %405 - %407 = fptrunc <2 x float> %406 to <2 x bfloat> - %408 = getelementptr inbounds nuw i8, ptr addrspace(1) %388, i64 384 - %409 = atomicrmw fadd ptr addrspace(1) %408, <2 x bfloat> %407 syncscope("agent") monotonic, align 4, !alias.scope !14, !noalias !26, !amdgpu.no.fine.grained.memory !27 - br label %410 - -410: ; preds = %378, %370, %11 - ret void -} - -; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) -declare void @llvm.assume(i1 noundef) #1 - -; Function Attrs: convergent mustprogress nocallback nofree nounwind willreturn memory(none) -declare i32 @llvm.amdgcn.readfirstlane.i32(i32) #2 - -; Function Attrs: convergent mustprogress nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.sched.barrier(i32 immarg) #3 - -; Function Attrs: mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) -declare void @llvm.amdgcn.raw.ptr.buffer.load.lds(ptr addrspace(8) readonly captures(none), ptr addrspace(3) writeonly captures(none), i32 immarg, i32, i32, i32 immarg, i32 immarg) #4 - -; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare i32 @llvm.amdgcn.raw.ptr.buffer.load.i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #5 - -; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: read) -declare <4 x i32> @llvm.amdgcn.raw.ptr.buffer.load.v4i32(ptr addrspace(8) readonly captures(none), i32, i32, i32 immarg) #5 - -; Function Attrs: convergent mustprogress nocallback nofree nounwind willreturn -declare void @llvm.amdgcn.s.barrier() #3 - -; Function Attrs: convergent mustprogress nocallback nofree nosync nounwind willreturn memory(none) -declare <4 x float> @llvm.amdgcn.mfma.scale.f32.16x16x128.f8f6f4.v4i32.v4i32(<4 x i32>, <4 x i32>, <4 x float>, i32 immarg, i32 immarg, i32 immarg, i32, i32 immarg, i32) #6 - -; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef range(i32 0, 1024) i32 @llvm.amdgcn.workitem.id.x() #7 - -; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare noundef i32 @llvm.amdgcn.workgroup.id.x() #7 - -; Function Attrs: nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) -declare void @llvm.experimental.noalias.scope.decl(metadata) #8 - -; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none) -declare ptr addrspace(8) @llvm.amdgcn.make.buffer.rsrc.p8.p1(ptr addrspace(1) readnone, i16, i64, i32) #9 - -attributes #0 = { convergent mustprogress norecurse nounwind "amdgpu-agpr-alloc"="0" "amdgpu-flat-work-group-size"="1,256" "amdgpu-no-cluster-id-x" "amdgpu-no-cluster-id-y" "amdgpu-no-cluster-id-z" "amdgpu-no-completion-action" "amdgpu-no-default-queue" "amdgpu-no-dispatch-id" "amdgpu-no-dispatch-ptr" "amdgpu-no-flat-scratch-init" "amdgpu-no-heap-ptr" "amdgpu-no-hostcall-ptr" "amdgpu-no-implicitarg-ptr" "amdgpu-no-lds-kernel-id" "amdgpu-no-multigrid-sync-arg" "amdgpu-no-queue-ptr" "amdgpu-no-workgroup-id-x" "amdgpu-no-workgroup-id-y" "amdgpu-no-workgroup-id-z" "amdgpu-no-workitem-id-x" "amdgpu-no-workitem-id-y" "amdgpu-no-workitem-id-z" "amdgpu-waves-per-eu"="2" "denormal-fp-math-f32"="preserve-sign,preserve-sign" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="gfx950" "target-features"="+16-bit-insts,+ashr-pk-insts,+atomic-buffer-global-pk-add-f16-insts,+atomic-buffer-pk-add-bf16-inst,+atomic-ds-pk-add-16-insts,+atomic-fadd-rtn-insts,+atomic-flat-pk-add-16-insts,+atomic-fmin-fmax-global-f64,+atomic-global-pk-add-bf16-inst,+bf8-cvt-scale-insts,+bitop3-insts,+ci-insts,+dl-insts,+dot1-insts,+dot10-insts,+dot12-insts,+dot13-insts,+dot2-insts,+dot3-insts,+dot4-insts,+dot5-insts,+dot6-insts,+dot7-insts,+dpp,+f16bf16-to-fp6bf6-cvt-scale-insts,+f32-to-f16bf16-cvt-sr-insts,+fp4-cvt-scale-insts,+fp6bf6-cvt-scale-insts,+fp8-conversion-insts,+fp8-cvt-scale-insts,+fp8-insts,+gfx8-insts,+gfx9-insts,+gfx90a-insts,+gfx940-insts,+gfx950-insts,+mai-insts,+permlane16-swap,+permlane32-swap,+prng-inst,+s-memrealtime,+s-memtime-inst,+wavefrontsize64" "uniform-work-group-size"="false" } -attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) } -attributes #2 = { convergent mustprogress nocallback nofree nounwind willreturn memory(none) } -attributes #3 = { convergent mustprogress nocallback nofree nounwind willreturn } -attributes #4 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) } -attributes #5 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: read) } -attributes #6 = { convergent mustprogress nocallback nofree nosync nounwind willreturn memory(none) } -attributes #7 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) } -attributes #8 = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } -attributes #9 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } -attributes #10 = { convergent nounwind } - -!llvm.module.flags = !{!0, !1, !2, !3, !4} -!llvm.ident = !{!5} -!opencl.ocl.version = !{!6} - -!0 = !{i32 1, !"amdhsa_code_object_version", i32 600} -!1 = !{i32 1, !"amdgpu_printf_kind", !"hostcall"} -!2 = !{i32 1, !"wchar_size", i32 4} -!3 = !{i32 8, !"PIC Level", i32 2} -!4 = !{i32 1, !"Code Model", i32 4} -!5 = !{!"AMD clang version 22.0.0git (https://github.com/RadeonOpenCompute/llvm-project roc-7.2.3 26084 f58b06dce1f9c15707c5f808fd002e18c2accf7e)"} -!6 = !{i32 2, i32 0} -!7 = !{!8, !8, i64 0} -!8 = !{!"int", !9, i64 0} -!9 = !{!"omnipotent char", !10, i64 0} -!10 = !{!"Simple C++ TBAA"} -!11 = !{i64 7674843} -!12 = !{!9, !9, i64 0} -!13 = !{i64 7674938} -!14 = !{!15} -!15 = distinct !{!15, !16, !"_ZN5aiter9mxfp4_moe11gemm_common24apply_atomic_bf16_epilogILi7168ELi32EEEvRAqueqT0_Li16ELi1EdvT0_Li16E_A4_KDv4_fP14__hip_bfloat16PKiPKfiiiiiiPf: argument 0"} -!16 = distinct !{!16, !"_ZN5aiter9mxfp4_moe11gemm_common24apply_atomic_bf16_epilogILi7168ELi32EEEvRAqueqT0_Li16ELi1EdvT0_Li16E_A4_KDv4_fP14__hip_bfloat16PKiPKfiiiiiiPf"} -!17 = !{!18} -!18 = distinct !{!18, !16, !"_ZN5aiter9mxfp4_moe11gemm_common24apply_atomic_bf16_epilogILi7168ELi32EEEvRAqueqT0_Li16ELi1EdvT0_Li16E_A4_KDv4_fP14__hip_bfloat16PKiPKfiiiiiiPf: argument 1"} -!19 = !{!20} -!20 = distinct !{!20, !16, !"_ZN5aiter9mxfp4_moe11gemm_common24apply_atomic_bf16_epilogILi7168ELi32EEEvRAqueqT0_Li16ELi1EdvT0_Li16E_A4_KDv4_fP14__hip_bfloat16PKiPKfiiiiiiPf: argument 2"} -!21 = !{!22, !22, i64 0} -!22 = !{!"float", !9, i64 0} -!23 = !{!15, !18, !20} -!24 = !{!15, !20} -!25 = !{!15, !18} -!26 = !{!18, !20} -!27 = !{} From 007e2dc7f23e8c83ed264233087535f8bcb5f9cc Mon Sep 17 00:00:00 2001 From: fsx950223 Date: Fri, 5 Jun 2026 06:30:20 +0000 Subject: [PATCH 4/5] feat(gemm2): Add BM16+NT specialization to a4w4 gemm2 port Parametrize compile_gemm2_a4w4_port by (BM, use_nt) and add the BM16 + kUseNT path, mirroring aiter's production instance ...TOPK9_BM16_ATOMIC_NT: - BM16 tiling: kMChunks=1 (i0 only), A->LDS gated to wave --- kernels/gemm2_a4w4_port.py | 245 ++++++++++++++------------ tests/kernels/test_gemm2_a4w4_port.py | 139 ++++++++------- 2 files changed, 206 insertions(+), 178 deletions(-) diff --git a/kernels/gemm2_a4w4_port.py b/kernels/gemm2_a4w4_port.py index 285364ffd..8cb02e917 100644 --- a/kernels/gemm2_a4w4_port.py +++ b/kernels/gemm2_a4w4_port.py @@ -1,18 +1,19 @@ # SPDX-License-Identifier: Apache-2.0 # Copyright (c) 2025 FlyDSL Project Contributors -"""1:1 FlyDSL port of aiter PR #3470 ``gemm2_a4w4`` (MXFP4 MoE down-proj, gfx950). +"""FlyDSL port of aiter PR #3470 ``gemm2_a4w4`` (MXFP4 MoE down-proj, gfx950). -Target instance (pinned, hardcoded constants): - ``mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC`` - launch_atomic +Parametrized over the launch_atomic specialization: + ``launch_atomic`` +Supported instances (atomic path): + * BM=32, kUseNT=false -> ``...TOPK9_BM32_ATOMIC`` (compile_gemm2_a4w4_port(BM=32)) + * BM=16, kUseNT=true -> ``...TOPK9_BM16_ATOMIC_NT`` (compile_gemm2_a4w4_port(BM=16, use_nt=True)) The port mirrors gemm2_a4w4.cuh's atomic path instruction-for-instruction: * 4 ``make.buffer.rsrc`` (A_q, A_scale, B_q, B_scale) with exact num_bytes. - * A -> LDS via ``raw.ptr.buffer.load.lds`` (2 slots), swizzled. - * B / scales via ``raw.ptr.buffer.load.v4i32`` / ``.i32``. + * A -> LDS via ``raw.ptr.buffer.load.lds`` (2 slots), swizzled (BM16: 2 waves). + * B / scales via ``raw.ptr.buffer.load.v4i32`` / ``.i32`` (NT: B aux=2). * ``s_waitcnt vmcnt(23/22)`` + ``s_barrier`` cross-wave fences. - * K=512 = 2 K-tiles fully unrolled; 32 ``mfma.scale.f32.16x16x128.f8f6f4``. + * K=512 = 2 K-tiles fully unrolled; 32 (BM32) / 16 (BM16) MFMAs. * atomic bf16 epilog: LDS cshuffle -> ``global.atomic.fadd.v2bf16`` * topk weight. """ @@ -26,13 +27,12 @@ from flydsl.expr.typing import Vector as Vec from flydsl.utils.smem_allocator import SmemAllocator, SmemPtr -# ── pinned compile-time constants (BM32 atomic instance) ──────────────────── +# ── shape constants (BM-independent) ───────────────────────────────────────── MAX_M = 655360 NE = 385 K = 512 # gemm2 contraction = inter_dim N_OUT = 7168 # gemm2 output dim = model_dim TOPK = 9 -BM = 32 BN = 256 BK = 256 @@ -41,8 +41,7 @@ NUM_N_BLOCKS = N_OUT // 256 # 28 K_TILES_TOTAL = K // BK # 2 kStages = 2 -kSubBlocks = BM // 32 # 1 -kMChunks = BM // 16 # 2 +_A_ROWS_PER_WAVE = 8 # each loading wave streams 8 A rows into LDS # scale-layout consts (mirror gemm2_a4w4.cuh) kBS_c_k1 = (K // 32) // 4 // 2 # 2 @@ -53,16 +52,37 @@ kAS_c_k1 = (K // 32) // 4 // 2 # 2 kAS_per_chunk_dw = kAS_c_k1 * 64 # 128 -# buffer resource sizes (bytes) — must match HIP make.buffer.rsrc num_bytes +# BM-independent buffer resource sizes (bytes) — must match HIP make.buffer.rsrc AQ_BYTES = MAX_M * K_HALF # 167772160 -ASCALE_BYTES = (MAX_M // BM) * kAS_per_chunk_dw * 4 # 10485760 BQ_BYTES = NE * N_OUT * K_HALF # 706478080 BSCALE_BYTES = NE * kBS_per_expert_dw * 4 # 44154880 -# LDS: union{ s_Aq[2][32][128] (8KB) , lds_acc[32*256] f32 (32KB) } = 32KB -LDS_ACC_FLOATS = BM * BN # 8192 -SAQ_SLOT_BYTES = BM * KH_TILE # 32*128 = 4096 bytes per slot -LDS_BYTES = LDS_ACC_FLOATS * 4 # 32768 (union max) + +def ascale_bytes(BM): + """A_scale buffer-resource num_bytes for a given BM (kAS_bound_div=BM in + atomic mode): (MAX_M/BM) * kAS_per_chunk_dw * 4.""" + return (MAX_M // BM) * kAS_per_chunk_dw * 4 + + +def saq_slot_bytes(BM): + return BM * KH_TILE # s_Aq[slot] = BM rows x KH_TILE bytes + + +def lds_bytes(BM): + return BM * BN * 4 # union max: lds_acc[BM*BN] f32 (>= 2*saq_slot_bytes) + + +def kmchunks(BM): + return 1 if BM == 16 else BM // 16 + + +# Back-compat module constants (BM32 defaults; the test imports BM/ASCALE_BYTES). +BM = 32 +kMChunks = kmchunks(BM) +SAQ_SLOT_BYTES = saq_slot_bytes(BM) +LDS_ACC_FLOATS = BM * BN +LDS_BYTES = lds_bytes(BM) +ASCALE_BYTES = ascale_bytes(BM) _PTR3 = "!llvm.ptr<3>" @@ -82,14 +102,8 @@ def _lds_ptr3(base_i32, byte_off_i32): def _lds_base_ptr3(lds_view): - """One ptr<3> for the LDS base; offsets via GEP. - - FlyDSL allocates LDS as a ``memref.global`` (SmemAllocator), so the raw - addrspace(3) pointer is obtained via extract_aligned_pointer_as_index -> - inttoptr. (HIP uses ``getelementptr ... @lds`` on an llvm.mlir.global, which - has no inttoptr; ``llvm.addressof`` cannot reference a memref.global, so this - one bridge is forced by FlyDSL's LDS model — confirmed by verifier.) - """ + """One ptr<3> for the LDS base; offsets via GEP. (extract_aligned_pointer -> + inttoptr is forced by FlyDSL's memref.global LDS model.)""" base_i32 = fx.Int32(memref_dialect.extract_aligned_pointer_as_index(lds_view)) return llvm.inttoptr(ir.Type.parse(_PTR3), _raw(fx.Int64(base_i32))) @@ -106,12 +120,7 @@ def _s_barrier_bare(): def _global_base_ptr1(arg): - """One ptr<1> base for a global tensor (single memref->ptr conversion). - - Mirrors HIP, which addresses the index/scalar tensors via plain addrspace(1) - GEP+load from the kernel-arg pointer (only A_q/A_scale/B_q/B_scale get buffer - resources). One inttoptr per arg is the irreducible memref->raw-ptr bridge. - """ + """One ptr<1> base for a global tensor (single memref->ptr conversion).""" base_idx = buffer_ops.extract_base_index(arg, address_space=1) return llvm.inttoptr(ir.Type.parse("!llvm.ptr<1>"), _raw(fx.Int64(base_idx))) @@ -126,37 +135,47 @@ def _global_ptr1(arg, byte_off_i32): def _lds_swizzle_mask(row): - """lds_swizzle_mask(row): ((row & ((128/16-1)<<1)) << 3). - - kRowMask = ((128/16) - 1) << 1 = 7 << 1 = 14 (0xE). mask = (row & 14) << 3. - ``row`` is an fx Int32 expression. - """ + """lds_swizzle_mask(row): mask = (row & 14) << 3.""" return (row & fx.Int32(14)) << fx.Int32(3) -def _issue_a_load_lds(aq_rsrc, saq, slot, kt, car0, lane, wave): - """Issue one A->LDS tile load (sub=0): ``raw.ptr.buffer.load.lds`` into - s_Aq[slot]. Pulled out of _gemm2_body so it can be issued before the - cumsum-gated branch (the op is side-effecting and cannot be sunk back).""" +def _issue_a_load_lds(aq_rsrc, saq, slot, kt, car0, lane, wave, slot_bytes): + """Issue one A->LDS tile load: ``raw.ptr.buffer.load.lds`` into s_Aq[slot]. + Identical formula for BM16/BM32 (lds_row = wave*8); BM16 callers gate this on + ``wave < BM/8``. Side-effecting, so it can be issued before the cumsum branch + without the compiler sinking it back.""" lane_div_8 = lane // fx.Int32(8) lane_mod_8 = lane % fx.Int32(8) - lds_row = wave * fx.Int32(BM // 4) + lds_row = wave * fx.Int32(_A_ROWS_PER_WAVE) mask = _lds_swizzle_mask(lds_row + lane_div_8) voffset = ((lane_mod_8 * fx.Int32(16)) ^ mask) + car0 * fx.Int32(K // 2) base_i32 = fx.Int32(memref_dialect.extract_aligned_pointer_as_index(saq.get())) - off_i32 = fx.Int32(slot * SAQ_SLOT_BYTES) + lds_row * fx.Int32(KH_TILE) + off_i32 = fx.Int32(slot * slot_bytes) + lds_row * fx.Int32(KH_TILE) lds_ptr = _lds_ptr3(base_i32, off_i32) rocdl.raw_ptr_buffer_load_lds( aq_rsrc, lds_ptr, fx.Int32(16), voffset, fx.Int32(kt * KH_TILE), fx.Int32(0), fx.Int32(0) ) -def compile_gemm2_a4w4_port(): - allocator = SmemAllocator(None, arch="gfx950", global_sym_name="gemm2port_smem") +def compile_gemm2_a4w4_port(BM=32, use_nt=False): + """Compile the gemm2 a4w4 atomic port for the given BM / kUseNT specialization. + + BM=32, use_nt=False -> mirrors ...BM32_ATOMIC + BM=16, use_nt=True -> mirrors ...BM16_ATOMIC_NT (production fused-moe pick) + """ + _kMChunks = kmchunks(BM) + _slot_bytes = saq_slot_bytes(BM) + _lds_acc_floats = BM * BN + _lds_bytes = lds_bytes(BM) + _ascale_bytes = ascale_bytes(BM) + _n_load_waves = BM // _A_ROWS_PER_WAVE # BM16: 2, BM32: 4 + _name = f"gemm2_a4w4_port_bm{BM}{'_nt' if use_nt else ''}_atomic" + + allocator = SmemAllocator(None, arch="gfx950", global_sym_name=f"gemm2port_smem_bm{BM}{'_nt' if use_nt else ''}") lds_off = allocator._align(allocator.ptr, 16) - allocator.ptr = lds_off + LDS_BYTES + allocator.ptr = lds_off + _lds_bytes - @flyc.kernel(name="gemm2_a4w4_port_bm32_atomic", known_block_size=[256, 1, 1]) + @flyc.kernel(name=_name, known_block_size=[256, 1, 1]) def gemm2_kernel( arg_aq: fx.Tensor, arg_ascale: fx.Tensor, @@ -180,17 +199,27 @@ def gemm2_kernel( # ── issue A->LDS as early as possible, BEFORE the cumsum-gated branch ── # raw.ptr.buffer.load.lds is side-effecting (writes LDS), so the compiler # cannot sink it back into the then-block. Issuing it here overlaps the - # A->LDS HBM latency with the cumsum load + bound check, shrinking the - # K-loop's first cross-wave barrier wait for A (the dominant fixed - # per-workgroup cost in the latency-bound small-M regime). A->LDS depends - # only on bx/lane (not cumsum/eids); for padding blocks it loads - # harmlessly into LDS and the early-return below still skips all compute. + # A->LDS HBM latency with the cumsum load + bound check. A->LDS depends + # only on bx/lane (not cumsum/eids); padding blocks load harmlessly and + # the early-return below still skips all compute. BM16 loads only 16 rows + # (waves 0,1), so gate the issue on wave < BM/8. m_row0 = (bx_i32 // fx.Int32(NUM_N_BLOCKS)) * fx.Int32(BM) - car0 = m_row0 + wave * fx.Int32(BM // 4) + (lane // fx.Int32(8)) + car0 = m_row0 + wave * fx.Int32(_A_ROWS_PER_WAVE) + (lane // fx.Int32(8)) aq_rsrc = buffer_ops.create_buffer_resource(arg_aq, max_size=False, num_records_bytes=fx.Index(AQ_BYTES)) - saq = SmemPtr(allocator.get_base(), lds_off, T.i8, shape=(kStages * SAQ_SLOT_BYTES,)) - _issue_a_load_lds(aq_rsrc, saq, 0, 0, car0, lane, wave) - _issue_a_load_lds(aq_rsrc, saq, 1, 1, car0, lane, wave) + saq = SmemPtr(allocator.get_base(), lds_off, T.i8, shape=(kStages * _slot_bytes,)) + + def _issue_both_a_loads(): + _issue_a_load_lds(aq_rsrc, saq, 0, 0, car0, lane, wave, _slot_bytes) + _issue_a_load_lds(aq_rsrc, saq, 1, 1, car0, lane, wave, _slot_bytes) + + if const_expr(_n_load_waves < 4): # BM16: only waves 0,1 hold A rows + a_pred = arith.cmpi(arith.CmpIPredicate.slt, wave, fx.Int32(_n_load_waves)) + a_if = scf.IfOp(a_pred, [], has_else=False) + with ir.InsertionPoint(a_if.then_block): + _issue_both_a_loads() + scf.YieldOp([]) + else: + _issue_both_a_loads() rocdl.sched_barrier(0) # total_m_blocks = cumsum[0] / BM ; bound = total_m_blocks * NUM_N_BLOCKS @@ -215,6 +244,8 @@ def gemm2_kernel( bx_i32, lane, wave, + BM, + use_nt, ) scf.YieldOp([]) @@ -270,7 +301,15 @@ def _gemm2_body( bx_i32, lane, wave, + BM, + use_nt, ): + _kMChunks = kmchunks(BM) + _slot_bytes = saq_slot_bytes(BM) + _lds_acc_floats = BM * BN + _ascale_bytes = ascale_bytes(BM) + b_aux = 2 if use_nt else 0 # NT: B_q loads carry aux=2 (non-temporal hint) + # block -> (m_block_idx, n_block_idx) ; e = sorted_expert_ids[m_block_idx] n_block_idx = bx_i32 % fx.Int32(NUM_N_BLOCKS) m_block_idx = bx_i32 // fx.Int32(NUM_N_BLOCKS) @@ -281,7 +320,7 @@ def _gemm2_body( # ── buffer resources (exact num_bytes) ────────────────────────────────── # (A_q resource + A->LDS loads are issued by the kernel before the branch.) ascale_rsrc = buffer_ops.create_buffer_resource( - arg_ascale, max_size=False, num_records_bytes=fx.Index(ASCALE_BYTES) + arg_ascale, max_size=False, num_records_bytes=fx.Index(_ascale_bytes) ) bq_rsrc = buffer_ops.create_buffer_resource(arg_bq, max_size=False, num_records_bytes=fx.Index(BQ_BYTES)) bscale_rsrc = buffer_ops.create_buffer_resource( @@ -290,15 +329,13 @@ def _gemm2_body( # ── LDS base ──────────────────────────────────────────────────────────── lds_base = allocator.get_base() - # s_Aq view as bytes (i8); lds_acc view as f32 — same storage (union). - saq = SmemPtr(lds_base, lds_off, T.i8, shape=(kStages * SAQ_SLOT_BYTES,)) - lds_acc = SmemPtr(lds_base, lds_off, T.f32, shape=(LDS_ACC_FLOATS,)) + saq = SmemPtr(lds_base, lds_off, T.i8, shape=(kStages * _slot_bytes,)) + lds_acc = SmemPtr(lds_base, lds_off, T.f32, shape=(_lds_acc_floats,)) lane_div_16 = lane // fx.Int32(16) lane_mod_16 = lane % fx.Int32(16) # ── s_base computations (readfirstlane'd, uniform per wave) ────────────── - # b_load_s_base[j] = ((e*N_OUT + n_block_idx*BN + wave*(BN/4) + j*16) * K_HALF) b_load_s_base = [] for j in range_constexpr(4): v = (e * fx.Int32(N_OUT) + n_block_idx * fx.Int32(BN) + wave * fx.Int32(BN // 4) + fx.Int32(j * 16)) * fx.Int32( @@ -306,19 +343,16 @@ def _gemm2_body( ) b_load_s_base.append(rocdl.readfirstlane(T.i32, v)) - # b_scale_s_base[mw]: mni_base = n_block_idx*(BN/16/2) + wave*(BN/64/2) mni_base = n_block_idx * fx.Int32(BN // 16 // 2) + wave * fx.Int32(BN // 64 // 2) b_scale_s_base = [] for mw in range_constexpr(2): v = (e * fx.Int32(kBS_per_expert_dw) + (mni_base + fx.Int32(mw)) * fx.Int32(kBS_stride_n0_dw)) * fx.Int32(4) b_scale_s_base.append(rocdl.readfirstlane(T.i32, v)) - # a_scale_s_base[0]: chunk_base = m_row/32 (BM!=16); sub=0 - chunk_base = m_row // fx.Int32(32) + # a_scale_s_base[0]: chunk_base = m_row / BM (atomic kAS_bound_div = BM); sub=0 + chunk_base = m_row // fx.Int32(BM) a_scale_s_base0 = rocdl.readfirstlane(T.i32, chunk_base * fx.Int32(kAS_per_chunk_dw) * fx.Int32(4)) - # (A->LDS for both slots is issued by the kernel before the in-range branch.) - # ── a_scale (atomic) : v_voff = ((lane/16)*16 + lane%16)*4 ─────────────── v_voff_scale = ((lane_div_16 * fx.Int32(16)) + lane_mod_16) * fx.Int32(4) a_scale_v = [] @@ -332,7 +366,7 @@ def _gemm2_body( ) a_scale_v.append(v) - # ── b_scale ku0/ku1 : IMM = ku*(kBS_stride_k0_dw*4) ───────────────────── + # ── b_scale ku0/ku1 ────────────────────────────────────────────────────── b_scale_v = [[None, None], [None, None]] for ku in range_constexpr(2): imm = ku * (kBS_stride_k0_dw * 4) @@ -346,8 +380,7 @@ def _gemm2_body( ) b_scale_v[ku][mw] = v - # ── B loads : v_voff = (lane/16)*256 + (lane%16)*16 + K_BYTE ───────────── - # b[slot][j][half] = i32x4 (vector<4xi32>) + # ── B loads (NT: cache_modifier=2) : v_voff = (lane/16)*256 + (lane%16)*16 + K_BYTE b = [[[None, None] for _ in range(4)] for _ in range(2)] for kc in range_constexpr(2): k_byte = kc * 2048 @@ -360,62 +393,61 @@ def _gemm2_body( (v_voff_b + fx.Int32(imm)) // fx.Int32(4), vec_width=4, dtype=T.i32, + cache_modifier=b_aux, soffset_bytes=b_load_s_base[j], ) b[kc][j][half] = Vec(frag) - # ── ds_read(slot) -> a[i][k] (i32x4) ───────────────────────────────────── + # ── ds_read(slot) -> a[i][k] (i32x4) ; i in [0,kMChunks) ───────────────── def issue_a_ds_read(slot): lane_row = lane_mod_16 lane_col = lane_div_16 * fx.Int32(16) mask = _lds_swizzle_mask(lane_row) base_ptr = _lds_base_ptr3(saq.get()) - a = [[None, None] for _ in range(kMChunks)] + a = [[None, None] for _ in range(_kMChunks)] for k in range_constexpr(2): lds_col = (lane_col + fx.Int32(k * 64)) ^ mask - for i in range_constexpr(kMChunks): + for i in range_constexpr(_kMChunks): lds_row = lane_row + fx.Int32(i * 16) - byte_off = fx.Int32(slot * SAQ_SLOT_BYTES) + lds_row * fx.Int32(KH_TILE) + lds_col + byte_off = fx.Int32(slot * _slot_bytes) + lds_row * fx.Int32(KH_TILE) + lds_col a[i][k] = llvm.load(T.vec(4, T.i32), _gep3(base_ptr, byte_off)) # ds_read_b128 return a - # ── MFMA cluster ───────────────────────────────────────────────────────── + # ── MFMA cluster (BM16: kMChunks=1 -> i0 only) ─────────────────────────── mfma_res_ty = T.f32x4 zero4 = Vec.filled(4, 0.0, fx.Float32) - # HIP emits the .v4i32.v4i32 variant: A and B operands are passed as - # vector<4xi32> directly (no zero-padding to 8xi32). - - accm = [[None, None, None, None] for _ in range(kMChunks)] + accm = [[None, None, None, None] for _ in range(_kMChunks)] - def mfma_cluster(slot, a, a_scale_aiter, b_scale_slot, init): + def mfma_cluster(slot, a, sa, b_scale_slot, init): for J in range_constexpr(4): mni = J // 2 in_b = J % 2 sb = b_scale_slot[mni] - sa = a_scale_aiter # sub=0 -> a_scale_aiter[0] - i0, i1 = 0, 1 b_J0 = b[slot][J][0] b_J1 = b[slot][J][1] if const_expr(init): - accm[i0][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( - mfma_res_ty, [a[i0][0], b_J0, zero4, 4, 4, 0, sa, 0 + in_b, sb] - ) - accm[i1][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( - mfma_res_ty, [a[i1][0], b_J0, zero4, 4, 4, 1, sa, 0 + in_b, sb] + accm[0][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( + mfma_res_ty, [a[0][0], b_J0, zero4, 4, 4, 0, sa, 0 + in_b, sb] ) + if const_expr(_kMChunks > 1): + accm[1][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( + mfma_res_ty, [a[1][0], b_J0, zero4, 4, 4, 1, sa, 0 + in_b, sb] + ) else: - accm[i0][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( - mfma_res_ty, [a[i0][0], b_J0, accm[i0][J], 4, 4, 0, sa, 0 + in_b, sb] + accm[0][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( + mfma_res_ty, [a[0][0], b_J0, accm[0][J], 4, 4, 0, sa, 0 + in_b, sb] ) - accm[i1][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( - mfma_res_ty, [a[i1][0], b_J0, accm[i1][J], 4, 4, 1, sa, 0 + in_b, sb] - ) - accm[i0][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( - mfma_res_ty, [a[i0][1], b_J1, accm[i0][J], 4, 4, 2, sa, 2 + in_b, sb] - ) - accm[i1][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( - mfma_res_ty, [a[i1][1], b_J1, accm[i1][J], 4, 4, 3, sa, 2 + in_b, sb] + if const_expr(_kMChunks > 1): + accm[1][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( + mfma_res_ty, [a[1][0], b_J0, accm[1][J], 4, 4, 1, sa, 0 + in_b, sb] + ) + accm[0][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( + mfma_res_ty, [a[0][1], b_J1, accm[0][J], 4, 4, 2, sa, 2 + in_b, sb] ) + if const_expr(_kMChunks > 1): + accm[1][J] = rocdl.mfma_scale_f32_16x16x128_f8f6f4( + mfma_res_ty, [a[1][1], b_J1, accm[1][J], 4, 4, 3, sa, 2 + in_b, sb] + ) # ── K loop (2 stages, fully unrolled) ──────────────────────────────────── for S in range_constexpr(kStages): @@ -429,13 +461,15 @@ def mfma_cluster(slot, a, a_scale_aiter, b_scale_slot, init): a = issue_a_ds_read(slot) mfma_cluster(slot, a, a_scale_v[kt], b_scale_v[slot], init=(S == 0)) - # ── epilog: apply_atomic_bf16_epilog (BM=32) ──────────────────────────── + # ── epilog: apply_atomic_bf16_epilog ───────────────────────────────────── saq._view_cache = None lds_acc._view_cache = None - _atomic_bf16_epilog(lds_acc, accm, arg_out, arg_stids, arg_sweights, m_row, n_block_idx, wave, lane, i32_M) + _atomic_bf16_epilog(lds_acc, accm, arg_out, arg_stids, arg_sweights, m_row, n_block_idx, wave, lane, i32_M, BM) -def _atomic_bf16_epilog(lds_acc, accm, arg_out, arg_stids, arg_sweights, m_row, n_block_idx, wave, lane, i32_M): +def _atomic_bf16_epilog(lds_acc, accm, arg_out, arg_stids, arg_sweights, m_row, n_block_idx, wave, lane, i32_M, BM): + _kMChunks = kmchunks(BM) + M_REPS = BM // 8 # BM32: 4, BM16: 2 lane_div_16 = lane // fx.Int32(16) lane_mod_16 = lane % fx.Int32(16) lds_base = _lds_base_ptr3(lds_acc.get()) @@ -448,13 +482,9 @@ def _atomic_bf16_epilog(lds_acc, accm, arg_out, arg_stids, arg_sweights, m_row, sweights_base = _global_base_ptr1(arg_sweights) out_base = _global_base_ptr1(arg_out) - M_REPS = BM // 8 # 4 # Prefetch sorted_token_ids / sorted_weights BEFORE the cshuffle stores and - # both LDS barriers. These read-only loads depend only on m_row/tid, so - # issuing them up front (invariant => freely hoistable, matching HIP's - # const __restrict__ inputs) overlaps their global latency with the store + - # barriers instead of exposing it in the dependent atomic loop. The epilog - # is ~half of the small-M kernel stall, so this is the main small-M lever. + # both LDS barriers (invariant => freely hoistable), overlapping their global + # latency with the store + barriers instead of exposing it in the atomic loop. packed = [] weight = [] for mr in range_constexpr(M_REPS): @@ -462,12 +492,11 @@ def _atomic_bf16_epilog(lds_acc, accm, arg_out, arg_stids, arg_sweights, m_row, packed.append(llvm.load(T.i32, _gep1(stids_base, sorted_pos * fx.Int32(4)), invariant=True)) weight.append(llvm.load(T.f32, _gep1(sweights_base, sorted_pos * fx.Int32(4)), invariant=True)) - # pre-store fence+barrier: all waves done reading s_Aq before lds_acc reuse - # (HIP run_one __syncthreads() before apply_atomic_bf16_epilog). + # pre-store fence+barrier (HIP run_one __syncthreads() before the epilog). rocdl.barrier() # write accm -> lds_acc cshuffle (scalar f32 stores, as HIP does) - for i in range_constexpr(kMChunks): + for i in range_constexpr(_kMChunks): row_base = fx.Int32(i * 16) + lane_div_16 * fx.Int32(4) for J in range_constexpr(4): col = wave * fx.Int32(64) + fx.Int32(J * 16) + lane_mod_16 diff --git a/tests/kernels/test_gemm2_a4w4_port.py b/tests/kernels/test_gemm2_a4w4_port.py index e16d8f9bb..5d6fcc68f 100644 --- a/tests/kernels/test_gemm2_a4w4_port.py +++ b/tests/kernels/test_gemm2_a4w4_port.py @@ -3,22 +3,22 @@ # SPDX-License-Identifier: Apache-2.0 # Copyright (c) 2025 FlyDSL Project Contributors -"""Accuracy + performance test for the 1:1 HIP->FlyDSL port of aiter's -``gemm2_a4w4`` MXFP4 MoE down-proj kernel (gfx950, BM32 atomic instance). - -Kernel under test: ``kernels.gemm2_a4w4_port`` (mirrors aiter PR #3470 -``mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC``). - -Three tests: - * ``test_smoke`` — self-contained: compile + run, output finite/nonzero - (no aiter dependency). - * ``test_accuracy_vs_hip``— bit-exact vs aiter's HIP gemm2 on identical bytes - (requires aiter; this is how the port was validated). - * ``test_performance`` — wall-clock vs HIP at a GPU-saturating size - (requires aiter; loose regression bound + report). - -The kernel is hardcoded to the production Kimi-K2.5 shape, so B_q is ~706 MB — -these are heavy device tests (l2_device). +"""Accuracy + performance test for the FlyDSL port of aiter's ``gemm2_a4w4`` +MXFP4 MoE down-proj kernel (gfx950), over two specializations: + + * ``bm32`` -> ``mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC`` + * ``bm16nt`` -> ``mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM16_ATOMIC_NT`` + (the instance aiter's fused_moe actually selects in production) + +Kernel under test: ``kernels.gemm2_a4w4_port.compile_gemm2_a4w4_port(BM, use_nt)``. + +Tests (each parametrized over both variants): + * ``test_smoke`` — compile + run, output finite/nonzero (no aiter). + * ``test_accuracy_vs_hip``— bit-exact vs aiter's HIP gemm2 on identical bytes. + * ``test_performance`` — CUDA-graph GPU-event time vs HIP + regression bound. + +The kernel is pinned to the Kimi-K2.5 shape, so B_q is ~706 MB — heavy device +tests (l2_device). """ import logging @@ -39,12 +39,11 @@ from flydsl.runtime.device import get_rocm_arch # noqa: E402 from kernels.gemm2_a4w4_port import ( # noqa: E402 - ASCALE_BYTES, - BM, BSCALE_BYTES, N_OUT, NE, K, + ascale_bytes, compile_gemm2_a4w4_port, ) @@ -69,24 +68,28 @@ except Exception: HAS_AITER = False -HIP_KERNEL_NAME = "mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_BM32_ATOMIC" +_HIP = "mxfp4_moe_g2_a4w4_NE385_H7168_E512_TOPK9_" +# (BM, use_nt, hip_kernel_name) +VARIANTS = [ + pytest.param(32, False, _HIP + "BM32_ATOMIC", id="bm32"), + pytest.param(16, True, _HIP + "BM16_ATOMIC_NT", id="bm16nt"), +] -# One compiled launcher reused across tests (compile is the expensive part). -_LAUNCH = None +# Compiled launchers reused across tests, keyed by (BM, use_nt). +_LAUNCH = {} -def _launcher(): - global _LAUNCH - if _LAUNCH is None: - _LAUNCH = compile_gemm2_a4w4_port() - return _LAUNCH +def _launcher(BM, use_nt): + key = (BM, use_nt) + if key not in _LAUNCH: + _LAUNCH[key] = compile_gemm2_a4w4_port(BM=BM, use_nt=use_nt) + return _LAUNCH[key] -def _make_inputs(srt: int, seed: int = 0, const_scale: bool = True): - """Build a valid input set. ``const_scale`` pins e8m0 scales to 127 (2^0) so - random fp4 data cannot overflow to inf/nan; unique sorted_token_ids - (one token per sorted row) make the bf16 atomic accumulation deterministic - so HIP and the port are comparable bit-for-bit. +def _make_inputs(srt: int, BM: int, seed: int = 0, const_scale: bool = True): + """Build a valid input set for a given BM. ``const_scale`` pins e8m0 scales + to 127 (2^0) so random fp4 data cannot overflow; unique sorted_token_ids make + the bf16 atomic accumulation deterministic so HIP and the port are bit-exact. """ dev = "cuda" g = torch.Generator(device=dev).manual_seed(seed) @@ -95,7 +98,7 @@ def _make_inputs(srt: int, seed: int = 0, const_scale: bool = True): M = srt t = dict( aq=torch.randint(0, 256, (srt, K // 2), dtype=torch.uint8, device=dev, generator=g), - ascale=torch.full((ASCALE_BYTES // 4, 4), 127, dtype=torch.uint8, device=dev), + ascale=torch.full((ascale_bytes(BM) // 4, 4), 127, dtype=torch.uint8, device=dev), bq=torch.randint(0, 256, (NE, N_OUT, K // 2), dtype=torch.uint8, device=dev, generator=g), bscale=torch.full((BSCALE_BYTES // 4, 4), 127, dtype=torch.uint8, device=dev), eids=torch.randint(0, NE, (mmb,), dtype=torch.int32, device=dev, generator=g), @@ -111,14 +114,14 @@ def _make_inputs(srt: int, seed: int = 0, const_scale: bool = True): return t -def _compile_port(t, out): +def _compile_port(t, out, BM, use_nt): """flyc.compile EXECUTES the kernel once into the buffer it is given, so compile against a throwaway buffer; the returned callable is then run into the real (zeroed) output. The kernel atomic-accumulates, so reusing one buffer for both compile and run would double the result.""" throwaway = torch.zeros_like(out) return flyc.compile( - _launcher(), + _launcher(BM, use_nt), t["aq"], t["ascale"], t["bq"], @@ -134,10 +137,10 @@ def _compile_port(t, out): ) -def _run_port(t, out=None): +def _run_port(t, BM, use_nt, out=None): if out is None: out = torch.zeros(t["M"], N_OUT, dtype=torch.bfloat16, device="cuda") - launch = _compile_port(t, out) + launch = _compile_port(t, out, BM, use_nt) out.zero_() launch( t["aq"], @@ -157,7 +160,7 @@ def _run_port(t, out=None): return out, launch -def _run_hip(t, out=None): +def _run_hip(t, hip_name, out=None): if out is None: out = torch.zeros(t["M"], N_OUT, dtype=torch.bfloat16, device="cuda") else: @@ -174,25 +177,18 @@ def _run_hip(t, out=None): out, t["M"], t["M"], - HIP_KERNEL_NAME, + hip_name, ) torch.cuda.synchronize() return out def _graph_median_us(fn, warmup=8, replays=100, reps=20): - """Median per-replay GPU time (microseconds) using a HIP/CUDA graph. - - ``fn`` enqueues exactly one kernel on the current stream. We warm up on a - side stream (to finish any lazy init before capture), capture a single - ``fn()`` into a CUDA graph, then time batches of ``replays`` graph replays - with CUDA events. Graph replay removes per-launch host overhead, and event - timing measures pure GPU time, so this isolates the kernel itself. - - Note: the kernel atomic-accumulates into ``out`` and replays are not zeroed, - so the accumulator saturates to inf over many replays. That does not affect - the (data-independent) GEMM timing. - """ + """Median per-replay GPU time (us) via a CUDA graph. ``fn`` enqueues one + kernel on the current stream; we warm up on a side stream, capture one + ``fn()``, then time batches of graph replays with CUDA events (removes host + launch overhead, isolates GPU-kernel time). The atomic accumulator saturates + to inf over replays — does not affect the data-independent GEMM timing.""" s = torch.cuda.Stream() s.wait_stream(torch.cuda.current_stream()) with torch.cuda.stream(s): @@ -219,22 +215,24 @@ def _graph_median_us(fn, warmup=8, replays=100, reps=20): return samples[len(samples) // 2] -def test_smoke(): +@pytest.mark.parametrize("BM,use_nt,hip_name", VARIANTS) +def test_smoke(BM, use_nt, hip_name): """Self-contained: the ported kernel compiles, runs, and produces a finite, non-zero output (no aiter / no reference needed).""" - t = _make_inputs(srt=256, seed=1) - out, _ = _run_port(t) + t = _make_inputs(srt=256, BM=BM, seed=1) + out, _ = _run_port(t, BM, use_nt) assert torch.isfinite(out).all(), "port output has non-finite values" assert out.abs().sum().item() > 0, "port output is all zero" @pytest.mark.skipif(not HAS_AITER, reason="aiter required for the HIP gemm2 reference") +@pytest.mark.parametrize("BM,use_nt,hip_name", VARIANTS) @pytest.mark.parametrize("srt", [256, 1024]) -def test_accuracy_vs_hip(srt): - """Bit-exact match against aiter's HIP gemm2 on identical input bytes.""" - t = _make_inputs(srt=srt, seed=2) - out_hip = _run_hip(t) - out_port, _ = _run_port(t) +def test_accuracy_vs_hip(srt, BM, use_nt, hip_name): + """Bit-exact match against aiter's HIP gemm2 (same instance) on identical bytes.""" + t = _make_inputs(srt=srt, BM=BM, seed=2) + out_hip = _run_hip(t, hip_name) + out_port, _ = _run_port(t, BM, use_nt) assert torch.isfinite(out_hip).all() and torch.isfinite(out_port).all() if torch.equal(out_hip, out_port): @@ -243,21 +241,22 @@ def test_accuracy_vs_hip(srt): b = out_port.float().reshape(-1) cos = torch.nn.functional.cosine_similarity(a, b, dim=0).item() max_abs = (a - b).abs().max().item() - raise AssertionError(f"port != HIP (srt={srt}): cosine={cos:.6f} max_abs_diff={max_abs:.6g}") + raise AssertionError(f"port != HIP (BM={BM} nt={use_nt} srt={srt}): cosine={cos:.6f} max_abs_diff={max_abs:.6g}") @pytest.mark.skipif(not HAS_AITER, reason="aiter required for the HIP gemm2 reference") +@pytest.mark.parametrize("BM,use_nt,hip_name", VARIANTS) # srt = roundup(M*TOPK, BM) for test.py's KIMI-K2.5 M-list {4,8,16,32,64,128,256} -# plus a large context (M=16384 tokens -> srt=147456). TOPK=9, BM=32: the gemm2 -# down-proj processes the expanded+padded tokens. +# plus a large context (M=16384 -> srt=147456). TOPK=9; values are multiples of +# both 16 and 32 so they are valid for both BM specializations. @pytest.mark.parametrize("srt", [64, 96, 160, 288, 576, 1152, 2304, 147456]) -def test_performance(srt): - """CUDA-graph (GPU-event timed) kernel performance vs HIP at a GPU-saturating - size. Graph replay removes host launch overhead so this reflects pure - GPU-kernel time. Reports the ratio and guards against a large regression.""" - t = _make_inputs(srt=srt, seed=3) +def test_performance(srt, BM, use_nt, hip_name): + """CUDA-graph (GPU-event timed) kernel performance vs HIP. Graph replay + removes host launch overhead so this reflects pure GPU-kernel time. Reports + the ratio and guards against a large regression.""" + t = _make_inputs(srt=srt, BM=BM, seed=3) out = torch.zeros(t["M"], N_OUT, dtype=torch.bfloat16, device="cuda") - launch = _compile_port(t, out) + launch = _compile_port(t, out, BM, use_nt) def f_port(): launch( @@ -288,18 +287,18 @@ def f_hip(): out, t["M"], t["M"], - HIP_KERNEL_NAME, + hip_name, ) hip_us = _graph_median_us(f_hip) port_us = _graph_median_us(f_port) ratio = port_us / hip_us _LOG.info( - "gemm2 a4w4 srt=%d HIP=%.1f us port=%.1f us port/HIP=%.2fx (cuda-graph)", + "gemm2 a4w4 [%s] srt=%d HIP=%.1f us port=%.1f us port/HIP=%.2fx (cuda-graph)", + f"bm{BM}{'_nt' if use_nt else ''}", srt, hip_us, port_us, ratio, ) - # Loose regression guard. Fail only on a large regression. assert ratio < 1.5, f"port too slow vs HIP: {ratio:.2f}x ({port_us:.1f} vs {hip_us:.1f} us)" From ad14939acf823816cf4a15b28cb5d99b9b65f89f Mon Sep 17 00:00:00 2001 From: fsx950223 Date: Fri, 5 Jun 2026 07:19:01 +0000 Subject: [PATCH 5/5] test(gemm2): Add BM32+NT variant to a4w4 gemm2 port tests Add the bm32nt specialization (compile_gemm2_a4w4_port(BM=32, use_nt=True)) to the parametrized variants, validating bit-exact accuracy and cuda-graph perf vs HIP ...BM32_ATOMIC_NT (the instance fused_moe selects at larger M). Smoke + accuracy + performance now cover bm32, bm16nt, and bm32nt (33 cases, all pass on gfx950). Signed-off-by: fsx950223 --- tests/kernels/test_gemm2_a4w4_port.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/kernels/test_gemm2_a4w4_port.py b/tests/kernels/test_gemm2_a4w4_port.py index 5d6fcc68f..f72f2c661 100644 --- a/tests/kernels/test_gemm2_a4w4_port.py +++ b/tests/kernels/test_gemm2_a4w4_port.py @@ -73,6 +73,7 @@ VARIANTS = [ pytest.param(32, False, _HIP + "BM32_ATOMIC", id="bm32"), pytest.param(16, True, _HIP + "BM16_ATOMIC_NT", id="bm16nt"), + pytest.param(32, True, _HIP + "BM32_ATOMIC_NT", id="bm32nt"), ] # Compiled launchers reused across tests, keyed by (BM, use_nt).