Switching vm.buffer.fill to index with elements. This makes it consistent with the load/store ops that already do this.
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/UtilToVM/ConvertBufferOps.cpp b/compiler/src/iree/compiler/Dialect/VM/Conversion/UtilToVM/ConvertBufferOps.cpp index 73bd4b0..4e07f63 100644 --- a/compiler/src/iree/compiler/Dialect/VM/Conversion/UtilToVM/ConvertBufferOps.cpp +++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/UtilToVM/ConvertBufferOps.cpp
@@ -154,6 +154,14 @@ } }; +static Value unscaleOffset(Location loc, Value offset, int64_t scale, + OpBuilder &builder) { + if (scale == 1) return offset; + return builder.createOrFold<IREE::VM::DivI64SOp>( + loc, offset.getType(), offset, + builder.create<IREE::VM::ConstI64Op>(loc, scale)); +} + struct BufferFillOpConversion : public OpConversionPattern<IREE::Util::BufferFillOp> { using OpConversionPattern::OpConversionPattern; @@ -168,6 +176,11 @@ } auto byteOffset = castToI64(adaptor.getTargetOffset(), rewriter); auto byteLength = castToI64(adaptor.getLength(), rewriter); + int64_t elementSize = IREE::Util::getRoundedElementByteWidth(oldType); + auto elementOffset = + unscaleOffset(fillOp.getLoc(), byteOffset, elementSize, rewriter); + auto elementLength = + unscaleOffset(fillOp.getLoc(), byteLength, elementSize, rewriter); auto pattern = adaptor.getPattern(); if (auto integerType = oldType.dyn_cast<IntegerType>()) { if (integerType.isInteger(1) || integerType.isInteger(8)) { @@ -175,23 +188,23 @@ fillOp, adaptor.getTarget(), byteOffset, byteLength, pattern); } else if (integerType.isInteger(16)) { rewriter.replaceOpWithNewOp<IREE::VM::BufferFillI16Op>( - fillOp, adaptor.getTarget(), byteOffset, byteLength, pattern); + fillOp, adaptor.getTarget(), elementOffset, elementLength, pattern); } else if (integerType.isInteger(32)) { rewriter.replaceOpWithNewOp<IREE::VM::BufferFillI32Op>( - fillOp, adaptor.getTarget(), byteOffset, byteLength, pattern); + fillOp, adaptor.getTarget(), elementOffset, elementLength, pattern); } else if (integerType.isInteger(64)) { rewriter.replaceOpWithNewOp<IREE::VM::BufferFillI64Op>( - fillOp, adaptor.getTarget(), byteOffset, byteLength, pattern); + fillOp, adaptor.getTarget(), elementOffset, elementLength, pattern); } else { return rewriter.notifyMatchFailure( fillOp, "invalid integer buffer element type"); } } else if (oldType.isF32()) { rewriter.replaceOpWithNewOp<IREE::VM::BufferFillF32Op>( - fillOp, adaptor.getTarget(), byteOffset, byteLength, pattern); + fillOp, adaptor.getTarget(), elementOffset, elementLength, pattern); } else if (oldType.isF64()) { rewriter.replaceOpWithNewOp<IREE::VM::BufferFillF64Op>( - fillOp, adaptor.getTarget(), byteOffset, byteLength, pattern); + fillOp, adaptor.getTarget(), elementOffset, elementLength, pattern); } else { return rewriter.notifyMatchFailure(fillOp, "invalid float buffer element type"); @@ -200,14 +213,6 @@ } }; -static Value unscaleOffset(Location loc, Value offset, int64_t scale, - OpBuilder &builder) { - if (scale == 1) return offset; - return builder.createOrFold<IREE::VM::DivI64SOp>( - loc, offset.getType(), offset, - builder.create<IREE::VM::ConstI64Op>(loc, scale)); -} - struct BufferLoadOpConversion : public OpConversionPattern<IREE::Util::BufferLoadOp> { using OpConversionPattern::OpConversionPattern; @@ -220,6 +225,9 @@ oldType = newType; } auto byteOffset = castToI64(adaptor.getSourceOffset(), rewriter); + int64_t elementSize = IREE::Util::getRoundedElementByteWidth(oldType); + auto elementOffset = + unscaleOffset(loadOp.getLoc(), byteOffset, elementSize, rewriter); if (auto integerType = oldType.dyn_cast<IntegerType>()) { if (integerType.isInteger(1) || integerType.isInteger(8)) { if (integerType.isSigned() || integerType.isSignless()) { @@ -232,33 +240,27 @@ } else if (integerType.isInteger(16)) { if (integerType.isSigned() || integerType.isSignless()) { rewriter.replaceOpWithNewOp<IREE::VM::BufferLoadI16SOp>( - loadOp, newType, adaptor.getSource(), - unscaleOffset(loadOp.getLoc(), byteOffset, 2, rewriter)); + loadOp, newType, adaptor.getSource(), elementOffset); } else { rewriter.replaceOpWithNewOp<IREE::VM::BufferLoadI16UOp>( - loadOp, newType, adaptor.getSource(), - unscaleOffset(loadOp.getLoc(), byteOffset, 2, rewriter)); + loadOp, newType, adaptor.getSource(), elementOffset); } } else if (integerType.isInteger(32)) { rewriter.replaceOpWithNewOp<IREE::VM::BufferLoadI32Op>( - loadOp, newType, adaptor.getSource(), - unscaleOffset(loadOp.getLoc(), byteOffset, 4, rewriter)); + loadOp, newType, adaptor.getSource(), elementOffset); } else if (integerType.isInteger(64)) { rewriter.replaceOpWithNewOp<IREE::VM::BufferLoadI64Op>( - loadOp, newType, adaptor.getSource(), - unscaleOffset(loadOp.getLoc(), byteOffset, 8, rewriter)); + loadOp, newType, adaptor.getSource(), elementOffset); } else { return rewriter.notifyMatchFailure( loadOp, "invalid integer buffer element type"); } } else if (oldType.isF32()) { rewriter.replaceOpWithNewOp<IREE::VM::BufferLoadF32Op>( - loadOp, newType, adaptor.getSource(), - unscaleOffset(loadOp.getLoc(), byteOffset, 4, rewriter)); + loadOp, newType, adaptor.getSource(), elementOffset); } else if (oldType.isF64()) { rewriter.replaceOpWithNewOp<IREE::VM::BufferLoadF64Op>( - loadOp, newType, adaptor.getSource(), - unscaleOffset(loadOp.getLoc(), byteOffset, 8, rewriter)); + loadOp, newType, adaptor.getSource(), elementOffset); } else { return rewriter.notifyMatchFailure(loadOp, "invalid float buffer element type"); @@ -279,34 +281,27 @@ oldType = newType; } auto byteOffset = castToI64(adaptor.getTargetOffset(), rewriter); + int64_t elementSize = IREE::Util::getRoundedElementByteWidth(oldType); + auto elementOffset = + unscaleOffset(storeOp.getLoc(), byteOffset, elementSize, rewriter); if (oldType.isInteger(1) || oldType.isInteger(8)) { rewriter.replaceOpWithNewOp<IREE::VM::BufferStoreI8Op>( storeOp, adaptor.getTarget(), byteOffset, adaptor.getSource()); } else if (oldType.isInteger(16)) { rewriter.replaceOpWithNewOp<IREE::VM::BufferStoreI16Op>( - storeOp, adaptor.getTarget(), - unscaleOffset(storeOp.getLoc(), byteOffset, 2, rewriter), - adaptor.getSource()); + storeOp, adaptor.getTarget(), elementOffset, adaptor.getSource()); } else if (oldType.isInteger(32)) { rewriter.replaceOpWithNewOp<IREE::VM::BufferStoreI32Op>( - storeOp, adaptor.getTarget(), - unscaleOffset(storeOp.getLoc(), byteOffset, 4, rewriter), - adaptor.getSource()); + storeOp, adaptor.getTarget(), elementOffset, adaptor.getSource()); } else if (oldType.isInteger(64)) { rewriter.replaceOpWithNewOp<IREE::VM::BufferStoreI64Op>( - storeOp, adaptor.getTarget(), - unscaleOffset(storeOp.getLoc(), byteOffset, 8, rewriter), - adaptor.getSource()); + storeOp, adaptor.getTarget(), elementOffset, adaptor.getSource()); } else if (oldType.isF32()) { rewriter.replaceOpWithNewOp<IREE::VM::BufferStoreF32Op>( - storeOp, adaptor.getTarget(), - unscaleOffset(storeOp.getLoc(), byteOffset, 4, rewriter), - adaptor.getSource()); + storeOp, adaptor.getTarget(), elementOffset, adaptor.getSource()); } else if (oldType.isF64()) { rewriter.replaceOpWithNewOp<IREE::VM::BufferStoreF64Op>( - storeOp, adaptor.getTarget(), - unscaleOffset(storeOp.getLoc(), byteOffset, 8, rewriter), - adaptor.getSource()); + storeOp, adaptor.getTarget(), elementOffset, adaptor.getSource()); } else { return rewriter.notifyMatchFailure(storeOp, "invalid buffer element type");
diff --git a/compiler/src/iree/compiler/Dialect/VM/Conversion/UtilToVM/test/buffer_ops.mlir b/compiler/src/iree/compiler/Dialect/VM/Conversion/UtilToVM/test/buffer_ops.mlir index b6eb2ef..901ef16 100644 --- a/compiler/src/iree/compiler/Dialect/VM/Conversion/UtilToVM/test/buffer_ops.mlir +++ b/compiler/src/iree/compiler/Dialect/VM/Conversion/UtilToVM/test/buffer_ops.mlir
@@ -139,10 +139,10 @@ func.func @buffer_fill_i32(%arg0: !util.buffer, %arg1: index, %arg2: i32) { %c100 = arith.constant 100 : index %c200 = arith.constant 200 : index - // CHECK-32-DAG: %[[C100:.+]] = vm.const.i64 100 - // CHECK-32-DAG: %[[C200:.+]] = vm.const.i64 200 - // CHECK-32: vm.buffer.fill.i32 %arg0, %[[C100]], %[[C200]], %arg2 : i32 -> !vm.buffer - // CHECK-64: vm.buffer.fill.i32 %arg0, %c100, %c200, %arg2 : i32 -> !vm.buffer + // CHECK-32-DAG: %[[C25:.+]] = vm.const.i64 25 + // CHECK-32-DAG: %[[C50:.+]] = vm.const.i64 50 + // CHECK-32: vm.buffer.fill.i32 %arg0, %[[C25]], %[[C50]], %arg2 : i32 -> !vm.buffer + // CHECK-64: vm.buffer.fill.i32 %arg0, %c25, %c50, %arg2 : i32 -> !vm.buffer util.buffer.fill %arg2, %arg0[%c100 for %c200] : i32 -> !util.buffer{%arg1} return } @@ -151,13 +151,13 @@ // CHECK-LABEL: @buffer_fill_i64 func.func @buffer_fill_i64(%arg0: !util.buffer, %arg1: index, %arg2: i64) { - %c100 = arith.constant 100 : index - %c200 = arith.constant 200 : index - // CHECK-32-DAG: %[[C100:.+]] = vm.const.i64 100 - // CHECK-32-DAG: %[[C200:.+]] = vm.const.i64 200 - // CHECK-32: vm.buffer.fill.i64 %arg0, %[[C100]], %[[C200]], %arg2 : i64 -> !vm.buffer - // CHECK-64: vm.buffer.fill.i64 %arg0, %c100, %c200, %arg2 : i64 -> !vm.buffer - util.buffer.fill %arg2, %arg0[%c100 for %c200] : i64 -> !util.buffer{%arg1} + %c104 = arith.constant 104 : index + %c208 = arith.constant 208 : index + // CHECK-32-DAG: %[[C13:.+]] = vm.const.i64 13 + // CHECK-32-DAG: %[[C26:.+]] = vm.const.i64 26 + // CHECK-32: vm.buffer.fill.i64 %arg0, %[[C13]], %[[C26]], %arg2 : i64 -> !vm.buffer + // CHECK-64: vm.buffer.fill.i64 %arg0, %c13, %c26, %arg2 : i64 -> !vm.buffer + util.buffer.fill %arg2, %arg0[%c104 for %c208] : i64 -> !util.buffer{%arg1} return }
diff --git a/compiler/src/iree/compiler/Dialect/VM/IR/VMOps.td b/compiler/src/iree/compiler/Dialect/VM/IR/VMOps.td index 8276dc5..5f916c0 100644 --- a/compiler/src/iree/compiler/Dialect/VM/IR/VMOps.td +++ b/compiler/src/iree/compiler/Dialect/VM/IR/VMOps.td
@@ -1306,7 +1306,7 @@ MemoryEffects<[MemWrite]>, ])> { let description = [{ - Fills a range of the buffer with the given value, like memset. + Fills an element range of the buffer with the given value, like memset. }]; let arguments = (ins @@ -1364,9 +1364,7 @@ MemoryEffects<[MemRead]>, ])> { let description = [{ - Loads a value from the buffer at the given offset. Offsets must match the - natural alignment of the loaded type and will be coerced to the alignment - at runtime automatically. + Loads a value from the buffer at the given element offset. }]; let arguments = (ins @@ -1397,9 +1395,7 @@ MemoryEffects<[MemWrite]>, ])> { let description = [{ - Stores a value to the buffer at the given offset. Offsets must match the - natural alignment of the loaded type and will be coerced to the alignment - at runtime automatically. + Stores a value to the buffer at the given element offset. }]; let arguments = (ins
diff --git a/runtime/src/iree/vm/buffer.c b/runtime/src/iree/vm/buffer.c index 8427a07..1882126 100644 --- a/runtime/src/iree/vm/buffer.c +++ b/runtime/src/iree/vm/buffer.c
@@ -231,9 +231,9 @@ const void* value) { IREE_ASSERT_ARGUMENT(target_buffer); iree_byte_span_t span; - IREE_RETURN_IF_ERROR(iree_vm_buffer_map_rw(target_buffer, target_offset, - element_count * element_length, - element_length, &span)); + IREE_RETURN_IF_ERROR(iree_vm_buffer_map_rw( + target_buffer, target_offset * element_length, + element_count * element_length, element_length, &span)); switch (element_length) { case 1: { const uint8_t pattern_value = *(const uint8_t*)value; @@ -275,9 +275,9 @@ iree_host_size_t element_length) { IREE_ASSERT_ARGUMENT(source_buffer); iree_const_byte_span_t source_span; - IREE_RETURN_IF_ERROR(iree_vm_buffer_map_ro(source_buffer, source_offset, - element_count * element_length, - element_length, &source_span)); + IREE_RETURN_IF_ERROR(iree_vm_buffer_map_ro( + source_buffer, source_offset * element_length, + element_count * element_length, element_length, &source_span)); memcpy(target_ptr, source_span.data, source_span.data_length); return iree_ok_status(); } @@ -289,9 +289,9 @@ IREE_ASSERT_ARGUMENT(source_ptr); IREE_ASSERT_ARGUMENT(target_buffer); iree_byte_span_t target_span; - IREE_RETURN_IF_ERROR(iree_vm_buffer_map_rw(target_buffer, target_offset, - element_count * element_length, - element_length, &target_span)); + IREE_RETURN_IF_ERROR(iree_vm_buffer_map_rw( + target_buffer, target_offset * element_length, + element_count * element_length, element_length, &target_span)); memcpy(target_span.data, source_ptr, target_span.data_length); return iree_ok_status(); }
diff --git a/runtime/src/iree/vm/bytecode/module_benchmark.mlir b/runtime/src/iree/vm/bytecode/module_benchmark.mlir index 10c7fd4..a2b8c85 100644 --- a/runtime/src/iree/vm/bytecode/module_benchmark.mlir +++ b/runtime/src/iree/vm/bytecode/module_benchmark.mlir
@@ -86,9 +86,9 @@ %c1 = vm.const.i64 1 %c4 = vm.const.i64 4 %count_i64 = vm.ext.i32.i64.u %count : i32 -> i64 - %max = vm.mul.i64 %count_i64, %c4 : i64 - %buf = vm.buffer.alloc %max : !vm.buffer - vm.buffer.fill.i32 %buf, %c0, %max, %pattern : i32 -> !vm.buffer + %count_bytes = vm.mul.i64 %count_i64, %c4 : i64 + %buf = vm.buffer.alloc %count_bytes : !vm.buffer + vm.buffer.fill.i32 %buf, %c0, %count_i64, %pattern : i32 -> !vm.buffer vm.br ^loop(%c0, %c0_i32 : i64, i32) ^loop(%i : i64, %sum : i32): %element = vm.buffer.load.i32 %buf[%i] : !vm.buffer -> i32 @@ -109,9 +109,9 @@ %c1 = vm.const.i64 1 %c4 = vm.const.i64 4 %count_i64 = vm.ext.i32.i64.u %count : i32 -> i64 - %max = vm.mul.i64 %count_i64, %c4 : i64 - %buf = vm.buffer.alloc %max : !vm.buffer - vm.buffer.fill.i32 %buf, %c0, %max, %pattern : i32 -> !vm.buffer + %count_bytes = vm.mul.i64 %count_i64, %c4 : i64 + %buf = vm.buffer.alloc %count_bytes : !vm.buffer + vm.buffer.fill.i32 %buf, %c0, %count_i64, %pattern : i32 -> !vm.buffer %sum_init = vm.const.i32.zero vm.br ^loop(%c0, %sum_init : i64, i32) ^loop(%i0 : i64, %sum : i32):
diff --git a/runtime/src/iree/vm/ops.h b/runtime/src/iree/vm/ops.h index 9728330..9351420 100644 --- a/runtime/src/iree/vm/ops.h +++ b/runtime/src/iree/vm/ops.h
@@ -63,32 +63,32 @@ iree_host_size_t offset, iree_host_size_t length, uint8_t value) { - return iree_vm_buffer_fill_elements(buffer, offset, length / sizeof(value), - sizeof(value), &value); + return iree_vm_buffer_fill_elements(buffer, offset, length, sizeof(value), + &value); } static inline iree_status_t vm_buffer_fill_i16(iree_vm_buffer_t* buffer, iree_host_size_t offset, iree_host_size_t length, uint16_t value) { - return iree_vm_buffer_fill_elements(buffer, offset, length / sizeof(value), - sizeof(value), &value); + return iree_vm_buffer_fill_elements(buffer, offset, length, sizeof(value), + &value); } static inline iree_status_t vm_buffer_fill_i32(iree_vm_buffer_t* buffer, iree_host_size_t offset, iree_host_size_t length, uint32_t value) { - return iree_vm_buffer_fill_elements(buffer, offset, length / sizeof(value), - sizeof(value), &value); + return iree_vm_buffer_fill_elements(buffer, offset, length, sizeof(value), + &value); } static inline iree_status_t vm_buffer_fill_i64(iree_vm_buffer_t* buffer, iree_host_size_t offset, iree_host_size_t length, uint64_t value) { - return iree_vm_buffer_fill_elements(buffer, offset, length / sizeof(value), - sizeof(value), &value); + return iree_vm_buffer_fill_elements(buffer, offset, length, sizeof(value), + &value); } static inline iree_status_t vm_buffer_load_i8u(iree_vm_buffer_t* buffer, @@ -115,8 +115,8 @@ iree_host_size_t offset, int32_t* result) { uint16_t result_x16 = 0; - IREE_RETURN_IF_ERROR(iree_vm_buffer_read_elements( - buffer, offset * sizeof(result_x16), &result_x16, 1, sizeof(result_x16))); + IREE_RETURN_IF_ERROR(iree_vm_buffer_read_elements(buffer, offset, &result_x16, + 1, sizeof(result_x16))); *result = vm_ext_i16i32u(result_x16); return iree_ok_status(); } @@ -125,8 +125,8 @@ iree_host_size_t offset, int32_t* result) { int16_t result_x16 = 0; - IREE_RETURN_IF_ERROR(iree_vm_buffer_read_elements( - buffer, offset * sizeof(result_x16), &result_x16, 1, sizeof(result_x16))); + IREE_RETURN_IF_ERROR(iree_vm_buffer_read_elements(buffer, offset, &result_x16, + 1, sizeof(result_x16))); *result = vm_ext_i16i32s(result_x16); return iree_ok_status(); } @@ -134,43 +134,43 @@ static inline iree_status_t vm_buffer_load_i32(iree_vm_buffer_t* buffer, iree_host_size_t offset, int32_t* result) { - return iree_vm_buffer_read_elements(buffer, offset * sizeof(*result), result, - 1, sizeof(*result)); + return iree_vm_buffer_read_elements(buffer, offset, result, 1, + sizeof(*result)); } static inline iree_status_t vm_buffer_load_i64(iree_vm_buffer_t* buffer, iree_host_size_t offset, int64_t* result) { - return iree_vm_buffer_read_elements(buffer, offset * sizeof(*result), result, - 1, sizeof(*result)); + return iree_vm_buffer_read_elements(buffer, offset, result, 1, + sizeof(*result)); } static inline iree_status_t vm_buffer_store_i8(iree_vm_buffer_t* buffer, iree_host_size_t offset, uint8_t value) { - return iree_vm_buffer_write_elements(&value, buffer, offset * sizeof(value), - 1, sizeof(value)); + return iree_vm_buffer_write_elements(&value, buffer, offset, 1, + sizeof(value)); } static inline iree_status_t vm_buffer_store_i16(iree_vm_buffer_t* buffer, iree_host_size_t offset, uint16_t value) { - return iree_vm_buffer_write_elements(&value, buffer, offset * sizeof(value), - 1, sizeof(value)); + return iree_vm_buffer_write_elements(&value, buffer, offset, 1, + sizeof(value)); } static inline iree_status_t vm_buffer_store_i32(iree_vm_buffer_t* buffer, iree_host_size_t offset, uint32_t value) { - return iree_vm_buffer_write_elements(&value, buffer, offset * sizeof(value), - 1, sizeof(value)); + return iree_vm_buffer_write_elements(&value, buffer, offset, 1, + sizeof(value)); } static inline iree_status_t vm_buffer_store_i64(iree_vm_buffer_t* buffer, iree_host_size_t offset, uint64_t value) { - return iree_vm_buffer_write_elements(&value, buffer, offset * sizeof(value), - 1, sizeof(value)); + return iree_vm_buffer_write_elements(&value, buffer, offset, 1, + sizeof(value)); } //===------------------------------------------------------------------===// @@ -415,22 +415,22 @@ iree_host_size_t offset, iree_host_size_t length, float value) { - return iree_vm_buffer_fill_elements(buffer, offset, length / sizeof(value), - sizeof(value), &value); + return iree_vm_buffer_fill_elements(buffer, offset, length, sizeof(value), + &value); } static inline iree_status_t vm_buffer_load_f32(iree_vm_buffer_t* buffer, iree_host_size_t offset, float* result) { - return iree_vm_buffer_read_elements(buffer, offset * sizeof(*result), result, - 1, sizeof(*result)); + return iree_vm_buffer_read_elements(buffer, offset, result, 1, + sizeof(*result)); } static inline iree_status_t vm_buffer_store_f32(iree_vm_buffer_t* buffer, iree_host_size_t offset, float value) { - return iree_vm_buffer_write_elements(&value, buffer, offset * sizeof(value), - 1, sizeof(value)); + return iree_vm_buffer_write_elements(&value, buffer, offset, 1, + sizeof(value)); } //===------------------------------------------------------------------===//
diff --git a/runtime/src/iree/vm/test/buffer_ops.mlir b/runtime/src/iree/vm/test/buffer_ops.mlir index 277595a..ddbf648 100644 --- a/runtime/src/iree/vm/test/buffer_ops.mlir +++ b/runtime/src/iree/vm/test/buffer_ops.mlir
@@ -280,10 +280,8 @@ // Fill the middle two elements. %c2 = vm.const.i64 1 %c4 = vm.const.i64 2 - %c2_byte = vm.mul.i64 %c2, %element_size : i64 - %c4_byte = vm.mul.i64 %c4, %element_size : i64 %value = vm.const.f32 42.0 - vm.buffer.fill.f32 %buf_dno, %c2_byte, %c4_byte, %value : f32 -> !vm.buffer + vm.buffer.fill.f32 %buf_dno, %c2, %c4, %value : f32 -> !vm.buffer // Compare to reference. %c0 = vm.const.i64 0 @@ -295,7 +293,7 @@ } vm.rodata private @test_fill_i8_ref dense<[0, 102, 102, 0]> : tensor<4xi8> - + // Tests filling a buffer with 8-bit values. vm.export @test_fill_i8 vm.func @test_fill_i8() { @@ -310,10 +308,8 @@ // Fill the middle two elements. %c2 = vm.const.i64 1 %c4 = vm.const.i64 2 - %c2_byte = vm.mul.i64 %c2, %element_size : i64 - %c4_byte = vm.mul.i64 %c4, %element_size : i64 %value = vm.const.i32 102 - vm.buffer.fill.i8 %buf_dno, %c2_byte, %c4_byte, %value : i32 -> !vm.buffer + vm.buffer.fill.i8 %buf_dno, %c2, %c4, %value : i32 -> !vm.buffer // Compare to reference. %c0 = vm.const.i64 0 @@ -325,7 +321,7 @@ } vm.rodata private @test_fill_i16_ref dense<[0, 51966, 51966, 0]> : tensor<4xi16> - + // Tests filling a buffer with 16-bit values. vm.export @test_fill_i16 vm.func @test_fill_i16() { @@ -340,10 +336,8 @@ // Fill the middle two elements. %c2 = vm.const.i64 1 %c4 = vm.const.i64 2 - %c2_byte = vm.mul.i64 %c2, %element_size : i64 - %c4_byte = vm.mul.i64 %c4, %element_size : i64 %value = vm.const.i32 0xCAFE - vm.buffer.fill.i16 %buf_dno, %c2_byte, %c4_byte, %value : i32 -> !vm.buffer + vm.buffer.fill.i16 %buf_dno, %c2, %c4, %value : i32 -> !vm.buffer // Compare to reference. %c0 = vm.const.i64 0 @@ -355,7 +349,7 @@ } vm.rodata private @test_fill_i32_ref dense<[0, 0xFFFF0000, 0xFFFF0000, 0]> : tensor<4xi32> - + // Tests filling a buffer with 32-bit values. vm.export @test_fill_i32 vm.func @test_fill_i32() { @@ -370,10 +364,8 @@ // Fill the middle two elements. %c2 = vm.const.i64 1 %c4 = vm.const.i64 2 - %c2_byte = vm.mul.i64 %c2, %element_size : i64 - %c4_byte = vm.mul.i64 %c4, %element_size : i64 %value = vm.const.i32 0xFFFF0000 - vm.buffer.fill.i32 %buf_dno, %c2_byte, %c4_byte, %value : i32 -> !vm.buffer + vm.buffer.fill.i32 %buf_dno, %c2, %c4, %value : i32 -> !vm.buffer // Compare to reference. %c0 = vm.const.i64 0 @@ -385,7 +377,7 @@ } vm.rodata private @test_fill_i64_ref dense<[0, 0x100000000, 0x100000000, 0]> : tensor<4xi64> - + // Tests filling a buffer with 64-bit values. vm.export @test_fill_i64 vm.func @test_fill_i64() { @@ -400,10 +392,8 @@ // Fill the middle two elements. %c2 = vm.const.i64 1 %c4 = vm.const.i64 2 - %c2_byte = vm.mul.i64 %c2, %element_size : i64 - %c4_byte = vm.mul.i64 %c4, %element_size : i64 %value = vm.const.i64 0x100000000 - vm.buffer.fill.i64 %buf_dno, %c2_byte, %c4_byte, %value : i64 -> !vm.buffer + vm.buffer.fill.i64 %buf_dno, %c2, %c4, %value : i64 -> !vm.buffer // Compare to reference. %c0 = vm.const.i64 0 @@ -414,55 +404,6 @@ vm.return } - vm.rodata private @test_fill_i16_misaligned_offset_ref dense<[0xCAFE, 0xCAFE, 0, 0]> : tensor<4xi16> - - // Tests that misaligned fill offsets will succeed but round down. - vm.export @test_fill_i16_misaligned_offset - vm.func @test_fill_i16_misaligned_offset() { - // Allocate zeroed buffer. - %c8 = vm.const.i64 8 - %buf = vm.buffer.alloc %c8 : !vm.buffer - %buf_dno = util.optimization_barrier %buf : !vm.buffer - - // Try filling from offset 1, which is not i16-aligned. - %c1 = vm.const.i64 1 - %c4 = vm.const.i64 4 - %cafe = vm.const.i32 0xCAFE - vm.buffer.fill.i16 %buf_dno, %c1, %c4, %cafe : i32 -> !vm.buffer - - // Compare to reference - should have written at offset 0. - %c0 = vm.const.i64 0 - %rodata_ref = vm.const.ref.rodata @test_fill_i16_misaligned_offset_ref : !vm.buffer - %cmp = vm.buffer.compare %rodata_ref, %c0, %buf_dno, %c0, %c8 : !vm.buffer, !vm.buffer - vm.check.nz %cmp, "buffer should match reference" : i32 - - vm.return - } - - vm.rodata private @test_fill_i16_misaligned_length_ref dense<[0, 0, 0, 0]> : tensor<4xi16> - - // Tests that misaligned fill lengths will succeed but round down. - vm.export @test_fill_i16_misaligned_length - vm.func @test_fill_i16_misaligned_length() { - // Allocate zeroed buffer. - %c8 = vm.const.i64 8 - %buf = vm.buffer.alloc %c8 : !vm.buffer - %buf_dno = util.optimization_barrier %buf : !vm.buffer - - // Try filling for length 1, which is not i16-aligned. - %c0 = vm.const.i64 0 - %c1 = vm.const.i64 1 - %cafe = vm.const.i32 0xCAFE - vm.buffer.fill.i16 %buf_dno, %c0, %c1, %cafe : i32 -> !vm.buffer - - // Compare to reference - should have written 0 bytes. - %rodata_ref = vm.const.ref.rodata @test_fill_i16_misaligned_length_ref : !vm.buffer - %cmp = vm.buffer.compare %rodata_ref, %c0, %buf_dno, %c0, %c8 : !vm.buffer, !vm.buffer - vm.check.nz %cmp, "buffer should match reference" : i32 - - vm.return - } - // Tests that trying to fill .rodata will fail. vm.export @fail_fill_i16_rodata vm.func @fail_fill_i16_rodata() {