diff --git a/bindings/java/com/google/iree/native/instance_wrapper.cc b/bindings/java/com/google/iree/native/instance_wrapper.cc index 3a25893d6f6a..ebfdd3cef0a9 100644 --- a/bindings/java/com/google/iree/native/instance_wrapper.cc +++ b/bindings/java/com/google/iree/native/instance_wrapper.cc @@ -33,10 +33,10 @@ void SetupVm() { int argc = 1; InitializeEnvironment(&argc, &aargv); - CHECK_EQ(IREE_STATUS_OK, iree_vm_register_builtin_types()); - CHECK_EQ(IREE_STATUS_OK, iree_hal_module_register_types()); - CHECK_EQ(IREE_STATUS_OK, iree_tensorlist_module_register_types()); - CHECK_EQ(IREE_STATUS_OK, iree_strings_module_register_types()); + IREE_CHECK_OK(iree_vm_register_builtin_types()); + IREE_CHECK_OK(iree_hal_module_register_types()); + IREE_CHECK_OK(iree_tensorlist_module_register_types()); + IREE_CHECK_OK(iree_strings_module_register_types()); } } // namespace diff --git a/bindings/python/pyiree/common/status_utils.cc b/bindings/python/pyiree/common/status_utils.cc index e1b7a931c9a3..e4f0a9b9f8f1 100644 --- a/bindings/python/pyiree/common/status_utils.cc +++ b/bindings/python/pyiree/common/status_utils.cc @@ -57,9 +57,11 @@ pybind11::error_already_set StatusToPyExc(const Status& status) { pybind11::error_already_set ApiStatusToPyExc(iree_status_t status, const char* message) { - assert(status != IREE_STATUS_OK); - auto full_message = absl::StrCat(message, ": ", static_cast(status)); + assert(!iree_status_is_ok(status)); + auto full_message = absl::StrCat( + message, ": ", iree_status_code_string(iree_status_code(status))); PyErr_SetString(ApiStatusToPyExcClass(status), full_message.c_str()); + iree_status_ignore(status); return pybind11::error_already_set(); } diff --git a/bindings/python/pyiree/common/status_utils.h b/bindings/python/pyiree/common/status_utils.h index 3f4956d47a90..a6a1ececb33c 100644 --- a/bindings/python/pyiree/common/status_utils.h +++ b/bindings/python/pyiree/common/status_utils.h @@ -57,7 +57,7 @@ pybind11::error_already_set ApiStatusToPyExc(iree_status_t status, const char* message); inline void CheckApiStatus(iree_status_t status, const char* message) { - if (status == IREE_STATUS_OK) { + if (iree_status_is_ok(status)) { return; } throw ApiStatusToPyExc(status, message); diff --git a/bindings/python/pyiree/rt/hal.cc b/bindings/python/pyiree/rt/hal.cc index 5c3fe0855040..f2710711442a 100644 --- a/bindings/python/pyiree/rt/hal.cc +++ b/bindings/python/pyiree/rt/hal.cc @@ -32,7 +32,7 @@ class HalMappedMemory { ~HalMappedMemory() { if (bv_) { iree_hal_buffer_t* buffer = iree_hal_buffer_view_buffer(bv_); - CHECK_EQ(iree_hal_buffer_unmap(buffer, &mapped_memory_), IREE_STATUS_OK); + IREE_CHECK_OK(iree_hal_buffer_unmap(buffer, &mapped_memory_)); iree_hal_buffer_view_release(bv_); } } diff --git a/bindings/python/pyiree/rt/vm.cc b/bindings/python/pyiree/rt/vm.cc index 0f7909983c1a..a46088ad1a32 100644 --- a/bindings/python/pyiree/rt/vm.cc +++ b/bindings/python/pyiree/rt/vm.cc @@ -117,7 +117,8 @@ std::unique_ptr VmContext::CreateFunctionAbi( attrs.push_back({}); auto status = iree_vm_get_function_reflection_attr( f, i, &attrs.back().first, &attrs.back().second); - if (status == IREE_STATUS_NOT_FOUND) { + if (iree_status_is_not_found(status) { + iree_status_ignore(status); attrs.pop_back(); break; } @@ -165,7 +166,7 @@ VmModule VmModule::FromFlatbufferBlob(py::buffer flatbuffer_blob) { {static_cast(buffer_info.ptr), static_cast(buffer_info.size)}, deallocator, IREE_ALLOCATOR_SYSTEM, &module); - if (status != IREE_STATUS_OK) { + if (!iree_status_is_ok(status)) { deallocator.free(raw_ptr, nullptr); } @@ -178,7 +179,8 @@ absl::optional VmModule::LookupFunction( iree_vm_function_t f; auto status = iree_vm_module_lookup_function_by_name( raw_ptr(), linkage, {name.data(), name.size()}, &f); - if (status == IREE_STATUS_NOT_FOUND) { + if (iree_status_is_not_found(status)) { + iree_status_ignore(status); return absl::nullopt; } CheckApiStatus(status, "Error looking up function"); @@ -236,10 +238,10 @@ std::string VmVariantList::DebugString() const { } void SetupVmBindings(pybind11::module m) { - CHECK_EQ(IREE_STATUS_OK, iree_vm_register_builtin_types()); - CHECK_EQ(IREE_STATUS_OK, iree_hal_module_register_types()); - CHECK_EQ(IREE_STATUS_OK, iree_tensorlist_module_register_types()); - CHECK_EQ(IREE_STATUS_OK, iree_strings_module_register_types()); + IREE_CHECK_OK(iree_vm_register_builtin_types()); + IREE_CHECK_OK(iree_hal_module_register_types()); + IREE_CHECK_OK(iree_tensorlist_module_register_types()); + IREE_CHECK_OK(iree_strings_module_register_types()); // Built-in module creation. m.def("create_hal_module", &CreateHalModule); diff --git a/iree/base/api.cc b/iree/base/api.cc index c988e457f2bf..222ef815fab0 100644 --- a/iree/base/api.cc +++ b/iree/base/api.cc @@ -285,14 +285,18 @@ iree_api_version_check(iree_api_version_t expected_version, iree_api_version_t* out_actual_version) { iree_api_version_t actual_version = IREE_API_VERSION_0; *out_actual_version = actual_version; - return expected_version == actual_version ? IREE_STATUS_OK - : IREE_STATUS_OUT_OF_RANGE; + return expected_version == actual_version + ? iree_ok_status() + : iree_make_status(IREE_STATUS_OUT_OF_RANGE, + "IREE version mismatch; application expected " + "%d but IREE is compiled as %d", + expected_version, actual_version); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_api_init(int* argc, char*** argv) { InitializeEnvironment(argc, argv); - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -319,14 +323,14 @@ iree_relative_timeout_to_deadline_ns(iree_duration_t timeout_ns) { IREE_API_EXPORT iree_status_t IREE_API_CALL iree_allocator_malloc( iree_allocator_t allocator, iree_host_size_t byte_length, void** out_ptr) { - if (!allocator.alloc) return IREE_STATUS_INVALID_ARGUMENT; + if (!allocator.alloc) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); return allocator.alloc(allocator.self, IREE_ALLOCATION_MODE_ZERO_CONTENTS, byte_length, out_ptr); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_allocator_realloc( iree_allocator_t allocator, iree_host_size_t byte_length, void** out_ptr) { - if (!allocator.alloc) return IREE_STATUS_INVALID_ARGUMENT; + if (!allocator.alloc) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); return allocator.alloc(allocator.self, IREE_ALLOCATION_MODE_TRY_REUSE_EXISTING, byte_length, out_ptr); @@ -345,9 +349,9 @@ iree_allocator_system_allocate(void* self, iree_allocation_mode_t mode, IREE_TRACE_SCOPE0("iree_allocator_system_allocate"); if (!out_ptr) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } else if (byte_length <= 0) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } void* existing_ptr = *out_ptr; @@ -366,7 +370,7 @@ iree_allocator_system_allocate(void* self, iree_allocation_mode_t mode, } } if (!ptr) { - return IREE_STATUS_RESOURCE_EXHAUSTED; + return iree_make_status(IREE_STATUS_RESOURCE_EXHAUSTED); } if (existing_ptr) { @@ -375,7 +379,7 @@ iree_allocator_system_allocate(void* self, iree_allocation_mode_t mode, IREE_TRACE_ALLOC(ptr, byte_length); *out_ptr = ptr; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT void IREE_API_CALL iree_allocator_system_free(void* self, @@ -397,7 +401,7 @@ iree_file_mapping_open_read(iree_string_view_t path, iree_allocator_t allocator, IREE_TRACE_SCOPE0("iree_file_mapping_open_read"); if (!out_file_mapping) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_file_mapping = nullptr; @@ -408,7 +412,7 @@ iree_file_mapping_open_read(iree_string_view_t path, iree_allocator_t allocator, *out_file_mapping = reinterpret_cast(file_mapping.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL @@ -416,10 +420,10 @@ iree_file_mapping_retain(iree_file_mapping_t* file_mapping) { IREE_TRACE_SCOPE0("iree_file_mapping_retain"); auto* handle = reinterpret_cast(file_mapping); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } handle->AddReference(); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL @@ -427,10 +431,10 @@ iree_file_mapping_release(iree_file_mapping_t* file_mapping) { IREE_TRACE_SCOPE0("iree_file_mapping_release"); auto* handle = reinterpret_cast(file_mapping); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } handle->ReleaseReference(); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_byte_span_t IREE_API_CALL diff --git a/iree/hal/api.cc b/iree/hal/api.cc index c5dd1304a8b0..21f2fd1ae205 100644 --- a/iree/hal/api.cc +++ b/iree/hal/api.cc @@ -64,13 +64,13 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_parse_shape( iree_string_view_t value, iree_host_size_t shape_capacity, iree_hal_dim_t* out_shape, iree_host_size_t* out_shape_rank) { if (!out_shape_rank) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_shape_rank = 0; auto str_value = absl::string_view(value.data, value.size); if (str_value.empty()) { - return IREE_STATUS_OK; + return iree_ok_status(); } absl::InlinedVector dims; @@ -79,11 +79,11 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_parse_shape( if (!absl::SimpleAtoi(dim_str, &dim_value)) { LOG(ERROR) << "Invalid shape dimension '" << dim_str << "' while parsing shape '" << str_value << "'"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (dim_value < 0) { LOG(ERROR) << "Unsupported shape dimension '" << dim_str << "'"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } dims.push_back(dim_value); } @@ -91,12 +91,12 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_parse_shape( *out_shape_rank = dims.size(); } if (dims.size() > shape_capacity) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } if (out_shape) { std::memcpy(out_shape, dims.data(), dims.size() * sizeof(*out_shape)); } - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL @@ -112,7 +112,7 @@ iree_hal_format_shape(const iree_hal_dim_t* shape, iree_host_size_t shape_rank, buffer ? buffer_capacity - buffer_length : 0, (i < shape_rank - 1) ? "%dx" : "%d", shape[i]); if (n < 0) { - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } else if (buffer && n >= buffer_capacity - buffer_length) { buffer = nullptr; } @@ -121,13 +121,13 @@ iree_hal_format_shape(const iree_hal_dim_t* shape, iree_host_size_t shape_rank, if (out_buffer_length) { *out_buffer_length = buffer_length; } - return buffer ? IREE_STATUS_OK : IREE_STATUS_OUT_OF_RANGE; + return buffer ? iree_ok_status() : iree_make_status(IREE_STATUS_OUT_OF_RANGE); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_parse_element_type( iree_string_view_t value, iree_hal_element_type_t* out_element_type) { if (!out_element_type) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_element_type = IREE_HAL_ELEMENT_TYPE_NONE; @@ -148,16 +148,16 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_parse_element_type( numerical_type = IREE_HAL_NUMERICAL_TYPE_UNKNOWN; str_value.remove_prefix(1); } else { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } uint32_t bit_count = 0; if (!absl::SimpleAtoi(str_value, &bit_count) || bit_count > 0xFFu) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_element_type = iree_hal_make_element_type(numerical_type, bit_count); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_format_element_type( @@ -185,12 +185,13 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_format_element_type( buffer, buffer_capacity, "%s%d", prefix, static_cast(iree_hal_element_bit_count(element_type))); if (n < 0) { - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } if (out_buffer_length) { *out_buffer_length = n; } - return n >= buffer_capacity ? IREE_STATUS_OUT_OF_RANGE : IREE_STATUS_OK; + return n >= buffer_capacity ? iree_make_status(IREE_STATUS_OUT_OF_RANGE) + : iree_ok_status(); } // Parses a string of two character pairs representing hex numbers into bytes. @@ -311,11 +312,11 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_parse_element( if (data_ptr.data_length < element_size) { LOG(ERROR) << "Output data buffer overflow (needed " << element_size << ", have " << data_ptr.data_length << ")"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } return iree_hal_parse_element_unsafe(data_str, element_type, data_ptr.data) - ? IREE_STATUS_OK - : IREE_STATUS_INVALID_ARGUMENT; + ? iree_ok_status() + : iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // Converts a sequence of bytes into hex number strings. @@ -351,7 +352,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_format_element( iree_host_size_t element_size = iree_hal_element_byte_count(element_type); if (data.data_length < element_size) { LOG(ERROR) << "Data buffer underflow on element format"; - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } int n = 0; switch (element_type) { @@ -389,7 +390,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_format_element( break; case IREE_HAL_ELEMENT_TYPE_FLOAT_16: LOG(ERROR) << "Unimplemented parser for element format FLOAT_16"; - return IREE_STATUS_UNIMPLEMENTED; + return iree_make_status(IREE_STATUS_UNIMPLEMENTED); case IREE_HAL_ELEMENT_TYPE_FLOAT_32: n = std::snprintf(buffer, buffer ? buffer_capacity : 0, "%G", *reinterpret_cast(data.data)); @@ -408,14 +409,14 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_format_element( } } if (n < 0) { - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } else if (buffer && n >= buffer_capacity) { buffer = nullptr; } if (out_buffer_length) { *out_buffer_length = n; } - return buffer ? IREE_STATUS_OK : IREE_STATUS_OUT_OF_RANGE; + return buffer ? iree_ok_status() : iree_make_status(IREE_STATUS_OUT_OF_RANGE); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_parse_buffer_elements( @@ -426,7 +427,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_parse_buffer_elements( iree_host_size_t element_capacity = data_ptr.data_length / element_size; if (iree_string_view_is_empty(data_str)) { memset(data_ptr.data, 0, data_ptr.data_length); - return IREE_STATUS_OK; + return iree_ok_status(); } size_t src_i = 0; size_t dst_i = 0; @@ -447,13 +448,13 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_parse_buffer_elements( LOG(ERROR) << "Output data buffer overflow (too many elements present, have >= " << dst_i << ", expected " << element_capacity << ")"; - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } if (!iree_hal_parse_element_unsafe( iree_string_view_t{data_str.data + token_start, src_i - 2 - token_start + 1}, element_type, data_ptr.data + dst_i * element_size)) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } ++dst_i; token_start = std::string::npos; @@ -463,13 +464,13 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_parse_buffer_elements( LOG(ERROR) << "Output data buffer overflow (too many elements present, have > " << dst_i << ", expected " << element_capacity << ")"; - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } if (!iree_hal_parse_element_unsafe( iree_string_view_t{data_str.data + token_start, data_str.size - token_start}, element_type, data_ptr.data + dst_i * element_size)) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } ++dst_i; } @@ -484,9 +485,9 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_parse_buffer_elements( << "Input data string contains fewer elements than the underlying " "buffer (expected " << element_capacity << ", have " << dst_i << ")"; - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } - return IREE_STATUS_OK; + return iree_ok_status(); } static iree_status_t iree_hal_format_buffer_elements_recursive( @@ -522,7 +523,7 @@ static iree_status_t iree_hal_format_buffer_elements_recursive( iree_device_size_t dim_stride = dim_length * iree_hal_element_byte_count(element_type); if (data.data_length < dim_stride * shape[0]) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } iree_const_byte_span_t subdata; subdata.data = data.data; @@ -550,7 +551,7 @@ static iree_status_t iree_hal_format_buffer_elements_recursive( iree_device_size_t element_stride = iree_hal_element_byte_count(element_type); if (data.data_length < max_count * element_stride) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } *max_element_count -= max_count; iree_const_byte_span_t subdata; @@ -579,7 +580,7 @@ static iree_status_t iree_hal_format_buffer_elements_recursive( if (out_buffer_length) { *out_buffer_length = buffer_length; } - return buffer ? IREE_STATUS_OK : IREE_STATUS_OUT_OF_RANGE; + return buffer ? iree_ok_status() : iree_make_status(IREE_STATUS_OUT_OF_RANGE); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_format_buffer_elements( @@ -610,11 +611,11 @@ iree_hal_allocator_create_host_local(iree_allocator_t allocator, iree_hal_allocator** out_allocator) { IREE_TRACE_SCOPE0("iree_hal_allocator_create_host_local"); if (!out_allocator) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_allocator = reinterpret_cast(new host::HostLocalAllocator()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_compute_size( @@ -622,11 +623,11 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_compute_size( iree_host_size_t shape_rank, iree_hal_element_type_t element_type, iree_device_size_t* out_allocation_size) { if (!out_allocation_size) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_allocation_size = 0; if (!allocator) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // TODO(benvanik): layout/padding. @@ -635,7 +636,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_compute_size( byte_length *= shape[i]; } *out_allocation_size = byte_length; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_compute_offset( @@ -644,21 +645,21 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_compute_offset( const iree_hal_dim_t* indices, iree_host_size_t indices_count, iree_device_size_t* out_offset) { if (!out_offset) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_offset = 0; if (!allocator) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (shape_rank != indices_count) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // TODO(benvanik): layout/padding. iree_device_size_t offset = 0; for (int i = 0; i < indices_count; ++i) { if (indices[i] >= shape[i]) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } iree_device_size_t axis_offset = indices[i]; for (int j = i + 1; j < shape_rank; ++j) { @@ -669,7 +670,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_compute_offset( offset *= iree_hal_element_byte_count(element_type); *out_offset = offset; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_compute_range( @@ -679,15 +680,15 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_compute_range( const iree_hal_dim_t* lengths, iree_host_size_t lengths_count, iree_device_size_t* out_start_offset, iree_device_size_t* out_length) { if (!out_start_offset || !out_length) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_start_offset = 0; *out_length = 0; if (!allocator) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (indices_count != lengths_count || indices_count != shape_rank) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // TODO(benvanik): layout/padding. @@ -712,12 +713,12 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_compute_range( // we have strides. auto offset_length = end_byte_offset - start_byte_offset + element_size; if (subspan_length != offset_length) { - return IREE_STATUS_UNIMPLEMENTED; + return iree_make_status(IREE_STATUS_UNIMPLEMENTED); } *out_start_offset = start_byte_offset; *out_length = subspan_length; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_allocate_buffer( @@ -726,12 +727,12 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_allocate_buffer( iree_hal_buffer_t** out_buffer) { IREE_TRACE_SCOPE0("iree_hal_allocator_allocate_buffer"); if (!out_buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_buffer = nullptr; auto* handle = reinterpret_cast(allocator); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_ASSIGN_OR_RETURN( @@ -741,7 +742,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_allocate_buffer( allocation_size)); *out_buffer = reinterpret_cast(buffer.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_wrap_buffer( @@ -751,12 +752,12 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_wrap_buffer( iree_hal_buffer_t** out_buffer) { IREE_TRACE_SCOPE0("iree_hal_allocator_wrap_buffer"); if (!out_buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_buffer = nullptr; auto* handle = reinterpret_cast(allocator); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_ASSIGN_OR_RETURN( @@ -767,7 +768,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_allocator_wrap_buffer( data.data, data.data_length)); *out_buffer = reinterpret_cast(buffer.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -783,12 +784,12 @@ IREE_API_EXPORT iree_status_t iree_hal_buffer_subspan( IREE_TRACE_SCOPE0("iree_hal_buffer_subspan"); if (!out_buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_buffer = nullptr; if (!buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } auto handle = add_ref(reinterpret_cast(buffer)); @@ -797,7 +798,7 @@ IREE_API_EXPORT iree_status_t iree_hal_buffer_subspan( *out_buffer = reinterpret_cast(new_handle.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_hal_allocator_t* IREE_API_CALL @@ -820,10 +821,10 @@ iree_hal_buffer_zero(iree_hal_buffer_t* buffer, iree_device_size_t byte_offset, IREE_TRACE_SCOPE0("iree_hal_buffer_zero"); auto* handle = reinterpret_cast(buffer); if (!buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_RETURN_IF_ERROR(handle->Fill8(byte_offset, byte_length, 0)); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t @@ -833,11 +834,11 @@ iree_hal_buffer_fill(iree_hal_buffer_t* buffer, iree_device_size_t byte_offset, IREE_TRACE_SCOPE0("iree_hal_buffer_fill"); auto* handle = reinterpret_cast(buffer); if (!buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_RETURN_IF_ERROR( handle->Fill(byte_offset, byte_length, pattern, pattern_length)); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t iree_hal_buffer_read_data( @@ -846,11 +847,11 @@ IREE_API_EXPORT iree_status_t iree_hal_buffer_read_data( IREE_TRACE_SCOPE0("iree_hal_buffer_read_data"); auto* handle = reinterpret_cast(buffer); if (!buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_RETURN_IF_ERROR( handle->ReadData(source_offset, target_buffer, data_length)); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t iree_hal_buffer_write_data( @@ -859,11 +860,11 @@ IREE_API_EXPORT iree_status_t iree_hal_buffer_write_data( IREE_TRACE_SCOPE0("iree_hal_buffer_write_data"); auto* handle = reinterpret_cast(buffer); if (!buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_RETURN_IF_ERROR( handle->WriteData(target_offset, source_buffer, data_length)); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t iree_hal_buffer_map( @@ -874,13 +875,13 @@ IREE_API_EXPORT iree_status_t iree_hal_buffer_map( if (!out_mapped_memory) { LOG(ERROR) << "output mapped memory not set"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } std::memset(out_mapped_memory, 0, sizeof(*out_mapped_memory)); if (!buffer) { LOG(ERROR) << "buffer not set"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } auto* buffer_handle = reinterpret_cast(buffer); @@ -900,7 +901,7 @@ IREE_API_EXPORT iree_status_t iree_hal_buffer_map( out_mapped_memory->contents = {mapping_storage->unsafe_data(), mapping_storage->size()}; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t iree_hal_buffer_unmap( @@ -908,7 +909,7 @@ IREE_API_EXPORT iree_status_t iree_hal_buffer_unmap( IREE_TRACE_SCOPE0("iree_hal_buffer_map"); auto* buffer_handle = reinterpret_cast(buffer); if (!buffer_handle || !mapped_memory) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } auto* mapping = @@ -916,7 +917,7 @@ IREE_API_EXPORT iree_status_t iree_hal_buffer_unmap( mapping->reset(); std::memset(mapped_memory, 0, sizeof(*mapped_memory)); - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -930,12 +931,12 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_heap_buffer_allocate( IREE_TRACE_SCOPE0("iree_hal_heap_buffer_allocate"); if (!out_buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_buffer = nullptr; if (!allocation_size) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } auto handle = HeapBuffer::Allocate( @@ -945,7 +946,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_heap_buffer_allocate( *out_buffer = reinterpret_cast( static_cast(handle.release())); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_heap_buffer_allocate_copy( @@ -956,12 +957,12 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_heap_buffer_allocate_copy( IREE_TRACE_SCOPE0("iree_hal_heap_buffer_allocate_copy"); if (!out_buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_buffer = nullptr; if (!contents.data || !contents.data_length) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } auto handle = HeapBuffer::AllocateCopy( @@ -970,7 +971,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_heap_buffer_allocate_copy( contents.data_length); *out_buffer = reinterpret_cast(handle.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_heap_buffer_wrap( @@ -980,12 +981,12 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_heap_buffer_wrap( IREE_TRACE_SCOPE0("iree_hal_heap_buffer_wrap"); if (!out_buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_buffer = nullptr; if (!contents.data || !contents.data_length) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } auto handle = @@ -995,7 +996,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_heap_buffer_wrap( contents.data, contents.data_length); *out_buffer = reinterpret_cast(handle.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -1011,12 +1012,12 @@ IREE_API_EXPORT iree_status_t iree_hal_buffer_view_create( IREE_TRACE_SCOPE0("iree_hal_buffer_view_create"); if (!out_buffer_view) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_buffer_view = nullptr; if (!buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // Allocate and initialize the iree_hal_buffer_view struct. @@ -1039,7 +1040,7 @@ IREE_API_EXPORT iree_status_t iree_hal_buffer_view_create( } *out_buffer_view = buffer_view; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_buffer_view_subview( @@ -1048,7 +1049,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_buffer_view_subview( const iree_hal_dim_t* lengths, iree_host_size_t lengths_count, iree_allocator_t allocator, iree_hal_buffer_view_t** out_buffer_view) { if (!out_buffer_view) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // NOTE: we rely on the compute range call to do parameter validation. @@ -1108,21 +1109,21 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_buffer_view_shape( *out_shape_rank = 0; } if (!buffer_view || !out_shape) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (out_shape_rank) { *out_shape_rank = buffer_view->shape_rank; } if (rank_capacity < buffer_view->shape_rank) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } for (int i = 0; i < buffer_view->shape_rank; ++i) { out_shape[i] = buffer_view->shape[i]; } - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_hal_element_type_t IREE_API_CALL @@ -1147,7 +1148,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_buffer_view_compute_offset( const iree_hal_buffer_view_t* buffer_view, const iree_hal_dim_t* indices, iree_host_size_t indices_count, iree_device_size_t* out_offset) { if (!buffer_view) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } return iree_hal_allocator_compute_offset( iree_hal_buffer_allocator(buffer_view->buffer), buffer_view->shape, @@ -1161,7 +1162,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_buffer_view_compute_range( const iree_hal_dim_t* lengths, iree_host_size_t lengths_count, iree_device_size_t* out_start_offset, iree_device_size_t* out_length) { if (!buffer_view) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } return iree_hal_allocator_compute_range( iree_hal_buffer_allocator(buffer_view->buffer), buffer_view->shape, @@ -1182,7 +1183,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_buffer_view_parse( if (string_view.empty()) { // Empty lines are invalid; need at least the shape/type information. *out_buffer_view = nullptr; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // The part of the string corresponding to the shape, e.g. 1x2x3. @@ -1283,7 +1284,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_buffer_view_format( buffer[0] = 0; } if (!buffer_view) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } iree_status_t status; @@ -1308,7 +1309,8 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_buffer_view_format( buffer ? buffer + buffer_length : nullptr, &shape_length); buffer_length += shape_length; - if (status == IREE_STATUS_OUT_OF_RANGE) { + if (iree_status_is_out_of_range(status)) { + status = iree_status_ignore(status); buffer = nullptr; } else if (!iree_status_is_ok(status)) { return status; @@ -1324,7 +1326,8 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_buffer_view_format( buffer_view->element_type, buffer ? buffer_capacity - buffer_length : 0, buffer ? buffer + buffer_length : nullptr, &element_type_length); buffer_length += element_type_length; - if (status == IREE_STATUS_OUT_OF_RANGE) { + if (iree_status_is_out_of_range(status)) { + status = iree_status_ignore(status); buffer = nullptr; } else if (!iree_status_is_ok(status)) { return status; @@ -1347,7 +1350,8 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_buffer_view_format( buffer ? buffer + buffer_length : nullptr, &elements_length); buffer_length += elements_length; iree_hal_buffer_unmap(buffer_view->buffer, &mapped_buffer); - if (status == IREE_STATUS_OUT_OF_RANGE) { + if (iree_status_is_out_of_range(status)) { + status = iree_status_ignore(status); buffer = nullptr; } else if (!iree_status_is_ok(status)) { return status; @@ -1356,7 +1360,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_buffer_view_format( if (out_buffer_length) { *out_buffer_length = buffer_length; } - return buffer ? IREE_STATUS_OK : IREE_STATUS_OUT_OF_RANGE; + return buffer ? iree_ok_status() : iree_make_status(IREE_STATUS_OUT_OF_RANGE); } //===----------------------------------------------------------------------===// @@ -1371,12 +1375,12 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_command_buffer_create( iree_hal_command_buffer_t** out_command_buffer) { IREE_TRACE_SCOPE0("iree_hal_command_buffer_create"); if (!out_command_buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_command_buffer = nullptr; auto* handle = reinterpret_cast(device); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_ASSIGN_OR_RETURN( @@ -1387,7 +1391,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_command_buffer_create( *out_command_buffer = reinterpret_cast(command_buffer.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t @@ -1395,7 +1399,7 @@ iree_hal_command_buffer_begin(iree_hal_command_buffer_t* command_buffer) { IREE_TRACE_SCOPE0("iree_hal_command_buffer_begin"); auto* handle = reinterpret_cast(command_buffer); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } return ToApiStatus(handle->Begin()); } @@ -1405,7 +1409,7 @@ iree_hal_command_buffer_end(iree_hal_command_buffer_t* command_buffer) { IREE_TRACE_SCOPE0("iree_hal_command_buffer_end"); auto* handle = reinterpret_cast(command_buffer); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } return ToApiStatus(handle->End()); } @@ -1422,7 +1426,7 @@ iree_hal_command_buffer_execution_barrier( IREE_TRACE_SCOPE0("iree_hal_command_buffer_execution_barrier"); auto* handle = reinterpret_cast(command_buffer); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // TODO(benvanik): refactor the C++ types to use the C types for storage so // that we can safely map between the two. For now assume size equality @@ -1449,7 +1453,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_command_buffer_fill_buffer( IREE_TRACE_SCOPE0("iree_hal_command_buffer_fill_buffer"); auto* handle = reinterpret_cast(command_buffer); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } return ToApiStatus( handle->FillBuffer(reinterpret_cast(target_buffer), @@ -1466,7 +1470,7 @@ iree_hal_command_buffer_update_buffer(iree_hal_command_buffer_t* command_buffer, IREE_TRACE_SCOPE0("iree_hal_command_buffer_update_buffer"); auto* handle = reinterpret_cast(command_buffer); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } return ToApiStatus(handle->UpdateBuffer( source_buffer, source_offset, reinterpret_cast(target_buffer), @@ -1480,7 +1484,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_command_buffer_copy_buffer( IREE_TRACE_SCOPE0("iree_hal_command_buffer_copy_buffer"); auto* handle = reinterpret_cast(command_buffer); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } return ToApiStatus(handle->CopyBuffer( reinterpret_cast(source_buffer), source_offset, @@ -1495,12 +1499,12 @@ iree_hal_command_buffer_push_constants( IREE_TRACE_SCOPE0("iree_hal_command_buffer_push_constants"); auto* handle = reinterpret_cast(command_buffer); if (!handle || !executable_layout || !values) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } else if (values_length == 0) { - return IREE_STATUS_OK; + return iree_ok_status(); } if ((values_length % 4) != 0) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } return ToApiStatus(handle->PushConstants( reinterpret_cast(executable_layout), offset, @@ -1517,13 +1521,13 @@ iree_hal_command_buffer_push_descriptor_set( IREE_TRACE_SCOPE0("iree_hal_command_buffer_push_descriptor_set"); auto* handle = reinterpret_cast(command_buffer); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (!executable_layout) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (binding_count && !bindings) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // TODO(benvanik): refactor the C++ types to use the C types for storage so @@ -1549,13 +1553,13 @@ iree_hal_command_buffer_bind_descriptor_set( IREE_TRACE_SCOPE0("iree_hal_command_buffer_bind_descriptor_set"); auto* handle = reinterpret_cast(command_buffer); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (!executable_layout) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (dynamic_offset_count && !dynamic_offsets) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } static_assert(sizeof(iree_device_size_t) == sizeof(device_size_t), "Device sizes must match"); @@ -1572,10 +1576,10 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_command_buffer_dispatch( IREE_TRACE_SCOPE0("iree_hal_command_buffer_dispatch"); auto* handle = reinterpret_cast(command_buffer); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (!executable) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } return ToApiStatus(handle->Dispatch(reinterpret_cast(executable), entry_point, @@ -1591,10 +1595,10 @@ iree_hal_command_buffer_dispatch_indirect( IREE_TRACE_SCOPE0("iree_hal_command_buffer_dispatch_indirect"); auto* handle = reinterpret_cast(command_buffer); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (!executable || workgroups_buffer) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } return ToApiStatus(handle->DispatchIndirect( reinterpret_cast(executable), entry_point, @@ -1615,18 +1619,18 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_descriptor_set_create( iree_hal_descriptor_set_t** out_descriptor_set) { IREE_TRACE_SCOPE0("iree_hal_descriptor_set_create"); if (!out_descriptor_set) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_descriptor_set = nullptr; if (!set_layout) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (binding_count && !bindings) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } auto* handle = reinterpret_cast(device); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // TODO(benvanik): refactor the C++ types to use the C types for storage so @@ -1645,7 +1649,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_descriptor_set_create( *out_descriptor_set = reinterpret_cast(descriptor_set.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -1664,15 +1668,15 @@ iree_hal_descriptor_set_layout_create( iree_hal_descriptor_set_layout_t** out_descriptor_set_layout) { IREE_TRACE_SCOPE0("iree_hal_descriptor_set_layout_create"); if (!out_descriptor_set_layout) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_descriptor_set_layout = nullptr; if (binding_count && !bindings) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } auto* handle = reinterpret_cast(device); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // TODO(benvanik): refactor the C++ types to use the C types for storage so @@ -1692,7 +1696,7 @@ iree_hal_descriptor_set_layout_create( *out_descriptor_set_layout = reinterpret_cast( descriptor_set_layout.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -1711,7 +1715,7 @@ iree_hal_device_allocator(iree_hal_device_t* device) { IREE_API_EXPORT iree_string_view_t IREE_API_CALL iree_hal_device_id(iree_hal_device_t* device) { auto* handle = reinterpret_cast(device); - if (!handle) return IREE_STRING_VIEW_EMPTY; + if (!handle) return iree_string_view_empty(); const auto& id = handle->info().id(); return iree_string_view_t{id.data(), id.size()}; } @@ -1722,8 +1726,9 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_device_queue_submit( const iree_hal_submission_batch_t* batches) { IREE_TRACE_SCOPE0("iree_hal_device_queue_submit"); auto* handle = reinterpret_cast(device); - if (!handle) return IREE_STATUS_INVALID_ARGUMENT; - if (batch_count > 0 && !batches) return IREE_STATUS_INVALID_ARGUMENT; + if (!handle) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); + if (batch_count > 0 && !batches) + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); // We need to allocate storage to marshal in the semaphores. Ideally we'd // change the C++ API to make this 1:1 with a reinterpret_cast, however that @@ -1780,8 +1785,8 @@ iree_hal_device_wait_semaphores_with_deadline( const iree_hal_semaphore_list_t* semaphore_list, iree_time_t deadline_ns) { IREE_TRACE_SCOPE0("iree_hal_device_wait_semaphores_with_deadline"); auto* handle = reinterpret_cast(device); - if (!handle) return IREE_STATUS_INVALID_ARGUMENT; - if (!semaphore_list || semaphore_list->count == 0) return IREE_STATUS_OK; + if (!handle) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); + if (!semaphore_list || semaphore_list->count == 0) return iree_ok_status(); absl::InlinedVector semaphore_values( semaphore_list->count); @@ -1803,13 +1808,13 @@ iree_hal_device_wait_semaphores_with_deadline( .status(); break; default: - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // NOTE: we avoid capturing stack traces on deadline exceeded as it's not a // real error. if (IsDeadlineExceeded(wait_status)) { - return iree_make_status(IREE_STATUS_DEADLINE_EXCEEDED); + return IREE_STATUS_DEADLINE_EXCEEDED; } return ToApiStatus(wait_status); } @@ -1837,15 +1842,15 @@ iree_hal_driver_query_available_devices( iree_host_size_t* out_device_info_count) { IREE_TRACE_SCOPE0("iree_hal_driver_query_available_devices"); if (!out_device_info_count) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_device_info_count = 0; if (!out_device_infos) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } auto* handle = reinterpret_cast(driver); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_ASSIGN_OR_RETURN(auto device_infos, @@ -1875,7 +1880,7 @@ iree_hal_driver_query_available_devices( } *out_device_infos = device_info_storage; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_driver_create_device( @@ -1883,18 +1888,18 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_driver_create_device( iree_allocator_t allocator, iree_hal_device_t** out_device) { IREE_TRACE_SCOPE0("iree_hal_driver_create_device"); if (!out_device) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_device = nullptr; auto* handle = reinterpret_cast(driver); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_ASSIGN_OR_RETURN(auto device, handle->CreateDevice(device_id)); *out_device = reinterpret_cast(device.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL @@ -1903,17 +1908,17 @@ iree_hal_driver_create_default_device(iree_hal_driver_t* driver, iree_hal_device_t** out_device) { IREE_TRACE_SCOPE0("iree_hal_driver_create_default_device"); if (!out_device) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_device = nullptr; auto* handle = reinterpret_cast(driver); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_ASSIGN_OR_RETURN(auto device, handle->CreateDefaultDevice()); *out_device = reinterpret_cast(device.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -1932,11 +1937,11 @@ iree_hal_driver_registry_query_available_drivers( iree_host_size_t* out_driver_count) { IREE_TRACE_SCOPE0("iree_hal_driver_registry_query_available_drivers"); if (!out_driver_count) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_driver_count = 0; if (!out_driver_names) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } auto* registry = DriverRegistry::shared_registry(); @@ -1965,7 +1970,7 @@ iree_hal_driver_registry_query_available_drivers( } *out_driver_names = driver_name_storage; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL @@ -1974,7 +1979,7 @@ iree_hal_driver_registry_create_driver(iree_string_view_t driver_name, iree_hal_driver_t** out_driver) { IREE_TRACE_SCOPE0("iree_hal_driver_registry_create_driver"); if (!out_driver) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_driver = nullptr; @@ -1984,7 +1989,7 @@ iree_hal_driver_registry_create_driver(iree_string_view_t driver_name, registry->Create(absl::string_view(driver_name.data, driver_name.size))); *out_driver = reinterpret_cast(driver.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -2005,19 +2010,19 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_executable_cache_create( iree_hal_executable_cache_t** out_executable_cache) { IREE_TRACE_SCOPE0("iree_hal_executable_cache_create"); if (!out_executable_cache) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_executable_cache = nullptr; auto* handle = reinterpret_cast(device); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } auto executable_cache = handle->CreateExecutableCache(); *out_executable_cache = reinterpret_cast( executable_cache.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT bool IREE_API_CALL iree_hal_executable_cache_can_prepare_format( @@ -2039,15 +2044,15 @@ iree_hal_executable_cache_prepare_executable( iree_hal_executable_t** out_executable) { IREE_TRACE_SCOPE0("iree_hal_executable_cache_prepare_executable"); if (!out_executable) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_executable = nullptr; auto* handle = reinterpret_cast(executable_cache); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (!executable_layout) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } ExecutableSpec spec; @@ -2060,7 +2065,7 @@ iree_hal_executable_cache_prepare_executable( *out_executable = reinterpret_cast(executable.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -2076,15 +2081,15 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_executable_layout_create( iree_hal_executable_layout_t** out_executable_layout) { IREE_TRACE_SCOPE0("iree_hal_executable_layout_create"); if (!out_executable_layout) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_executable_layout = nullptr; if (set_layout_count && !set_layouts) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } auto* handle = reinterpret_cast(device); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_ASSIGN_OR_RETURN( @@ -2097,7 +2102,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_executable_layout_create( *out_executable_layout = reinterpret_cast( executable_layout.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -2111,38 +2116,38 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_semaphore_create( iree_allocator_t allocator, iree_hal_semaphore_t** out_semaphore) { IREE_TRACE_SCOPE0("iree_hal_semaphore_create"); if (!out_semaphore) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_semaphore = nullptr; auto* handle = reinterpret_cast(device); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_ASSIGN_OR_RETURN(auto semaphore, handle->CreateSemaphore(initial_value)); *out_semaphore = reinterpret_cast(semaphore.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_semaphore_query(iree_hal_semaphore_t* semaphore, uint64_t* out_value) { - if (!out_value) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_value) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); *out_value = 0; auto* handle = reinterpret_cast(semaphore); - if (!handle) return IREE_STATUS_INVALID_ARGUMENT; + if (!handle) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); auto result = handle->Query(); if (!result.ok()) return ToApiStatus(std::move(result).status()); *out_value = result.value(); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_semaphore_signal(iree_hal_semaphore_t* semaphore, uint64_t new_value) { IREE_TRACE_SCOPE0("iree_hal_semaphore_signal"); auto* handle = reinterpret_cast(semaphore); - if (!handle) return IREE_STATUS_INVALID_ARGUMENT; + if (!handle) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); return ToApiStatus(handle->Signal(new_value)); } @@ -2159,7 +2164,7 @@ iree_hal_semaphore_wait_with_deadline(iree_hal_semaphore_t* semaphore, uint64_t value, iree_time_t deadline_ns) { IREE_TRACE_SCOPE0("iree_hal_semaphore_wait_with_deadline"); auto* handle = reinterpret_cast(semaphore); - if (!handle) return IREE_STATUS_INVALID_ARGUMENT; + if (!handle) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); return ToApiStatus(handle->Wait(value, Time(deadline_ns))); } @@ -2169,7 +2174,7 @@ iree_hal_semaphore_wait_with_timeout(iree_hal_semaphore_t* semaphore, iree_duration_t timeout_ns) { IREE_TRACE_SCOPE0("iree_hal_semaphore_wait_with_timeout"); auto* handle = reinterpret_cast(semaphore); - if (!handle) return IREE_STATUS_INVALID_ARGUMENT; + if (!handle) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); return ToApiStatus(handle->Wait(value, Duration(timeout_ns))); } diff --git a/iree/hal/vulkan/api.cc b/iree/hal/vulkan/api.cc index 76a200a5eaeb..1a02ce4fffc7 100644 --- a/iree/hal/vulkan/api.cc +++ b/iree/hal/vulkan/api.cc @@ -34,7 +34,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_syms_create( void* vkGetInstanceProcAddr_fn, iree_hal_vulkan_syms_t** out_syms) { IREE_TRACE_SCOPE0("iree_hal_vulkan_syms_create"); if (!out_syms) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_syms = nullptr; @@ -51,7 +51,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_syms_create( })); *out_syms = reinterpret_cast(syms.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL @@ -59,14 +59,14 @@ iree_hal_vulkan_syms_create_from_system_loader( iree_hal_vulkan_syms_t** out_syms) { IREE_TRACE_SCOPE0("iree_hal_vulkan_syms_create_from_system_loader"); if (!out_syms) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_syms = nullptr; IREE_API_ASSIGN_OR_RETURN(auto syms, DynamicSymbols::CreateFromSystemLoader()); *out_syms = reinterpret_cast(syms.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t @@ -74,10 +74,10 @@ iree_hal_vulkan_syms_release(iree_hal_vulkan_syms_t* syms) { IREE_TRACE_SCOPE0("iree_hal_vulkan_syms_release"); auto* handle = reinterpret_cast(syms); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } handle->ReleaseReference(); - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -135,7 +135,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_get_extensions( iree_hal_vulkan_features_t features, iree_host_size_t extensions_capacity, const char** out_extensions, iree_host_size_t* out_extensions_count) { if (!out_extensions_count) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_extensions_count = 0; @@ -149,11 +149,11 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_get_extensions( // Return early if only querying number of extensions in this configuration. if (!out_extensions) { - return IREE_STATUS_OK; + return iree_ok_status(); } if (extensions_capacity < *out_extensions_count) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } const std::vector& extensions = @@ -162,7 +162,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_get_extensions( out_extensions[i] = extensions[i]; } - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_get_layers( @@ -170,13 +170,13 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_get_layers( iree_hal_vulkan_features_t features, iree_host_size_t layers_capacity, const char** out_layers, iree_host_size_t* out_layers_count) { if (!out_layers_count) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_layers_count = 0; // Device layers are deprecated and unsupported here. if (!(extensibility_set & IREE_HAL_VULKAN_INSTANCE_BIT)) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } bool is_required = extensibility_set & IREE_HAL_VULKAN_REQUIRED_BIT; @@ -187,11 +187,11 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_get_layers( // Return early if only querying number of layers in this configuration. if (!out_layers) { - return IREE_STATUS_OK; + return iree_ok_status(); } if (layers_capacity < *out_layers_count) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } const std::vector& layers = @@ -200,7 +200,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_get_layers( out_layers[i] = layers[i]; } - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -227,7 +227,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_driver_create( iree_hal_driver_t** out_driver) { IREE_TRACE_SCOPE0("iree_hal_vulkan_driver_create"); if (!out_driver) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_driver = nullptr; @@ -236,7 +236,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_driver_create( VulkanDriver::Create(ConvertDriverOptions(options), add_ref(reinterpret_cast(syms)))); *out_driver = reinterpret_cast(driver.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL @@ -245,7 +245,7 @@ iree_hal_vulkan_driver_create_using_instance( VkInstance instance, iree_hal_driver_t** out_driver) { IREE_TRACE_SCOPE0("iree_hal_vulkan_driver_create_using_instance"); if (!out_driver) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_driver = nullptr; @@ -255,7 +255,7 @@ iree_hal_vulkan_driver_create_using_instance( ConvertDriverOptions(options), add_ref(reinterpret_cast(syms)), instance)); *out_driver = reinterpret_cast(driver.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL @@ -263,13 +263,13 @@ iree_hal_vulkan_driver_create_default_device(iree_hal_driver_t* driver, iree_hal_device_t** out_device) { IREE_TRACE_SCOPE0("iree_hal_vulkan_driver_create_default_device"); if (!out_device) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_device = nullptr; auto* handle = reinterpret_cast(driver); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } LOG(INFO) << "Enumerating available Vulkan devices..."; @@ -284,7 +284,7 @@ iree_hal_vulkan_driver_create_default_device(iree_hal_driver_t* driver, *out_device = reinterpret_cast(device.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_driver_wrap_device( @@ -294,13 +294,13 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_driver_wrap_device( iree_hal_device_t** out_device) { IREE_TRACE_SCOPE0("iree_hal_vulkan_driver_create_device"); if (!out_device) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_device = nullptr; auto* handle = reinterpret_cast(driver); if (!handle) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } LOG(INFO) << "Creating VulkanDevice..."; @@ -317,7 +317,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_vulkan_driver_wrap_device( *out_device = reinterpret_cast(device.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } } // namespace vulkan diff --git a/iree/modules/check/native_module.cc b/iree/modules/check/native_module.cc index 4647643c07e3..de4fd79957b9 100644 --- a/iree/modules/check/native_module.cc +++ b/iree/modules/check/native_module.cc @@ -399,12 +399,12 @@ class CheckModule final : public vm::NativeModule { // module as a C instance. This hides the details of our implementation. extern "C" iree_status_t check_native_module_create( iree_allocator_t allocator, iree_vm_module_t** out_module) { - if (!out_module) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_module) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); *out_module = NULL; auto module = std::make_unique( "check", allocator, absl::MakeConstSpan(kCheckModuleFunctions)); *out_module = module.release()->interface(); - return IREE_STATUS_OK; + return iree_ok_status(); } } // namespace iree diff --git a/iree/modules/hal/hal_module.cc b/iree/modules/hal/hal_module.cc index e51938f38fab..a8b9a774f2d2 100644 --- a/iree/modules/hal/hal_module.cc +++ b/iree/modules/hal/hal_module.cc @@ -50,7 +50,7 @@ static iree_vm_ref_type_descriptor_t iree_hal_semaphore_descriptor = {0}; IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_module_register_types() { static bool has_registered = false; - if (has_registered) return IREE_STATUS_OK; + if (has_registered) return iree_ok_status(); IREE_VM_REGISTER_CC_TYPE(Allocator, "hal.allocator", iree_hal_allocator_descriptor); @@ -74,7 +74,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_module_register_types() { iree_hal_semaphore_descriptor); has_registered = true; - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -988,13 +988,13 @@ class HALModule final : public vm::NativeModule { IREE_API_EXPORT iree_status_t IREE_API_CALL iree_hal_module_create(iree_hal_device_t* device, iree_allocator_t allocator, iree_vm_module_t** out_module) { - if (!out_module) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_module) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); *out_module = nullptr; auto module = std::make_unique( allocator, add_ref(reinterpret_cast(device))); IREE_API_RETURN_IF_ERROR(module->Initialize()); *out_module = module.release()->interface(); - return IREE_STATUS_OK; + return iree_ok_status(); } } // namespace diff --git a/iree/modules/strings/api.cc b/iree/modules/strings/api.cc index 51b8affb7cbd..6c6983e79dbb 100644 --- a/iree/modules/strings/api.cc +++ b/iree/modules/strings/api.cc @@ -44,7 +44,7 @@ extern "C" iree_status_t strings_string_create(iree_string_view_t value, message->value.size = value.size; memcpy((void*)message->value.data, value.data, message->value.size); *out_message = message; - return IREE_STATUS_OK; + return iree_ok_status(); } extern "C" iree_status_t strings_string_tensor_create( @@ -61,7 +61,7 @@ extern "C" iree_status_t strings_string_tensor_create( } if (count != value_count) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // Compute our total memory requirements @@ -109,17 +109,17 @@ extern "C" iree_status_t strings_string_tensor_create( } *out_message = message; - return IREE_STATUS_OK; + return iree_ok_status(); } // Returns the count of elements in the tensor. iree_status_t strings_string_tensor_get_count( const strings_string_tensor_t* tensor, size_t* count) { if (!tensor) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *count = tensor->count; - return IREE_STATUS_OK; + return iree_ok_status(); } // returns the list of stored string views. @@ -127,36 +127,36 @@ iree_status_t strings_string_tensor_get_elements( const strings_string_tensor_t* tensor, iree_string_view_t* strs, size_t count, size_t offset) { if (!tensor || offset < 0 || offset + count > tensor->count) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } for (size_t i = 0; i < count; i++) { strs[i] = tensor->values[i + offset]; } - return IREE_STATUS_OK; + return iree_ok_status(); } // Returns the rank of the tensor. iree_status_t strings_string_tensor_get_rank( const strings_string_tensor_t* tensor, int32_t* rank) { if (!tensor || !rank) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *rank = tensor->rank; - return IREE_STATUS_OK; + return iree_ok_status(); } // Returns the shape of the tensor. iree_status_t strings_string_tensor_get_shape( const strings_string_tensor_t* tensor, int32_t* shape, size_t rank) { if (!tensor || (!shape && rank != 0) || rank != tensor->rank) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } for (int i = 0; i < rank; i++) { shape[i] = tensor->shape[i]; } - return IREE_STATUS_OK; + return iree_ok_status(); } // Returns the store string view using the provided indices. @@ -164,20 +164,20 @@ iree_status_t strings_string_tensor_get_element( const strings_string_tensor_t* tensor, int32_t* indices, size_t rank, iree_string_view_t* str) { if (!tensor || !indices || rank != tensor->rank) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } size_t index = 0; for (int i = 0; i < rank; i++) { if (indices[i] >= tensor->shape[i]) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } index = index * tensor->shape[i] + indices[i]; } *str = tensor->values[index]; - return IREE_STATUS_OK; + return iree_ok_status(); } void strings_string_destroy(void* ptr) { diff --git a/iree/modules/strings/strings_module.cc b/iree/modules/strings/strings_module.cc index abd07eeed492..8f2a8220c8bb 100644 --- a/iree/modules/strings/strings_module.cc +++ b/iree/modules/strings/strings_module.cc @@ -199,7 +199,8 @@ class StringsModuleState final { break; default: - return FromApiStatus(IREE_STATUS_UNIMPLEMENTED, IREE_LOC); + return FromApiStatus(iree_make_status(IREE_STATUS_UNIMPLEMENTED), + IREE_LOC); } // Unmap used buffer. @@ -231,7 +232,8 @@ class StringsModuleState final { // The dict must be a simple list, and the indices must be integers. if (dict->rank != 1 || iree_hal_buffer_view_element_type(ids.get()) != IREE_HAL_ELEMENT_TYPE_SINT_32) { - return FromApiStatus(IREE_STATUS_INVALID_ARGUMENT, IREE_LOC); + return FromApiStatus(iree_make_status(IREE_STATUS_INVALID_ARGUMENT), + IREE_LOC); } const size_t rank = iree_hal_buffer_view_shape_rank(ids.get()); @@ -375,7 +377,7 @@ class StringsModule final : public vm::NativeModule { extern "C" iree_status_t iree_strings_module_register_types() { if (strings_string_descriptor.type) { - return IREE_STATUS_OK; // Already registered. + return iree_ok_status(); // Already registered. } // Register strings.string @@ -395,12 +397,12 @@ extern "C" iree_status_t iree_strings_module_register_types() { IREE_RETURN_IF_ERROR( iree_vm_ref_register_type(&strings_string_tensor_descriptor)); - return IREE_STATUS_OK; + return iree_ok_status(); } extern "C" iree_status_t iree_strings_module_create( iree_allocator_t allocator, iree_vm_module_t** out_module) { - if (!out_module) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_module) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); *out_module = NULL; auto module = std::make_unique( "strings", allocator, absl::MakeConstSpan(iree::kStringsModuleFunctions)); @@ -409,5 +411,5 @@ extern "C" iree_status_t iree_strings_module_create( return iree::ToApiStatus(status); } *out_module = module.release()->interface(); - return IREE_STATUS_OK; + return iree_ok_status(); } diff --git a/iree/modules/tensorlist/native_module.cc b/iree/modules/tensorlist/native_module.cc index 9ca5c0ab8845..616822e95362 100644 --- a/iree/modules/tensorlist/native_module.cc +++ b/iree/modules/tensorlist/native_module.cc @@ -333,10 +333,10 @@ struct ref_type_descriptor { extern "C" iree_status_t iree_tensorlist_module_register_types() { static bool has_registered = false; - if (has_registered) return IREE_STATUS_OK; + if (has_registered) return iree_ok_status(); IREE_VM_REGISTER_CC_TYPE(TensorList, "tensorlist.list", iree_tensorlist_descriptor); - return IREE_STATUS_OK; + return iree_ok_status(); } //===----------------------------------------------------------------------===// @@ -472,12 +472,12 @@ class TensorListModule final : public vm::NativeModule { extern "C" iree_status_t iree_tensorlist_module_create( iree_allocator_t allocator, iree_vm_module_t** out_module) { - if (!out_module) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_module) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); *out_module = NULL; auto module = std::make_unique( "tensorlist", allocator, absl::MakeConstSpan(kTensorListModuleFunctions)); *out_module = module.release()->interface(); - return IREE_STATUS_OK; + return iree_ok_status(); } } // namespace iree diff --git a/iree/samples/custom_modules/native_module.cc b/iree/samples/custom_modules/native_module.cc index ade2f9c6b594..fe5f0d49d2e6 100644 --- a/iree/samples/custom_modules/native_module.cc +++ b/iree/samples/custom_modules/native_module.cc @@ -63,7 +63,7 @@ iree_status_t iree_custom_message_create(iree_string_view_t value, message->value.size = value.size; memcpy((void*)message->value.data, value.data, message->value.size); *out_message = message; - return IREE_STATUS_OK; + return iree_ok_status(); } iree_status_t iree_custom_message_wrap(iree_string_view_t value, @@ -76,7 +76,7 @@ iree_status_t iree_custom_message_wrap(iree_string_view_t value, message->allocator = allocator; message->value = value; // Unowned. *out_message = message; - return IREE_STATUS_OK; + return iree_ok_status(); } void iree_custom_message_destroy(void* ptr) { @@ -88,16 +88,16 @@ iree_status_t iree_custom_message_read_value(iree_custom_message_t* message, char* buffer, size_t buffer_capacity) { if (buffer_capacity < message->value.size + 1) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } memcpy(buffer, message->value.data, message->value.size); buffer[message->value.size] = 0; - return IREE_STATUS_OK; + return iree_ok_status(); } iree_status_t iree_custom_native_module_register_types() { if (iree_custom_message_descriptor.type) { - return IREE_STATUS_OK; // Already registered. + return iree_ok_status(); // Already registered. } iree_custom_message_descriptor.type_name = iree_make_cstring_view("custom.message"); @@ -289,7 +289,7 @@ class CustomModule final : public vm::NativeModule { // module as a C instance. This hides the details of our implementation. extern "C" iree_status_t iree_custom_native_module_create( iree_allocator_t allocator, iree_vm_module_t** out_module) { - if (!out_module) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_module) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); *out_module = NULL; auto module = std::make_unique( "custom", allocator, absl::MakeConstSpan(kCustomModuleFunctions)); @@ -298,7 +298,7 @@ extern "C" iree_status_t iree_custom_native_module_create( return ToApiStatus(status); } *out_module = module.release()->interface(); - return IREE_STATUS_OK; + return iree_ok_status(); } } // namespace samples diff --git a/iree/samples/simple_embedding/simple_embedding_test.cc b/iree/samples/simple_embedding/simple_embedding_test.cc index 489ac33f1687..a7e0f433fd86 100644 --- a/iree/samples/simple_embedding/simple_embedding_test.cc +++ b/iree/samples/simple_embedding/simple_embedding_test.cc @@ -32,8 +32,6 @@ namespace iree { namespace samples { namespace { -#define ASSERT_API_OK(expr) IREE_ASSERT_OK((expr)) - struct TestParams { // HAL driver to use for the test. std::string driver_name; @@ -76,14 +74,14 @@ TEST_P(SimpleEmbeddingTest, RunOnce) { const auto& driver_name = GetParam().driver_name; LOG(INFO) << "Creating driver '" << driver_name << "'..."; iree_hal_driver_t* driver = nullptr; - ASSERT_API_OK(iree_hal_driver_registry_create_driver( + IREE_ASSERT_OK(iree_hal_driver_registry_create_driver( iree_string_view_t{driver_name.data(), driver_name.size()}, IREE_ALLOCATOR_SYSTEM, &driver)); iree_hal_device_t* device = nullptr; - ASSERT_API_OK(iree_hal_driver_create_default_device( + IREE_ASSERT_OK(iree_hal_driver_create_default_device( driver, IREE_ALLOCATOR_SYSTEM, &device)); iree_vm_module_t* hal_module = nullptr; - ASSERT_API_OK( + IREE_ASSERT_OK( iree_hal_module_create(device, IREE_ALLOCATOR_SYSTEM, &hal_module)); iree_hal_driver_release(driver); @@ -91,7 +89,7 @@ TEST_P(SimpleEmbeddingTest, RunOnce) { LOG(INFO) << "Loading simple_module_test.mlir..."; const auto* module_file_toc = simple_embedding_test_bytecode_module_create(); iree_vm_module_t* bytecode_module = nullptr; - ASSERT_API_OK(iree_vm_bytecode_module_create( + IREE_ASSERT_OK(iree_vm_bytecode_module_create( iree_const_byte_span_t{ reinterpret_cast(module_file_toc->data), module_file_toc->size}, @@ -112,10 +110,8 @@ TEST_P(SimpleEmbeddingTest, RunOnce) { // erased buffers. const char kMainFunctionName[] = "module.simple_mul$raw"; iree_vm_function_t main_function; - CHECK_EQ( - IREE_STATUS_OK, - iree_vm_context_resolve_function( - context, iree_make_cstring_view(kMainFunctionName), &main_function)) + IREE_ASSERT_OK(iree_vm_context_resolve_function( + context, iree_make_cstring_view(kMainFunctionName), &main_function)) << "Exported function '" << kMainFunctionName << "' not found"; // Allocate buffers that can be mapped on the CPU and that can also be used @@ -124,12 +120,12 @@ TEST_P(SimpleEmbeddingTest, RunOnce) { constexpr int kElementCount = 4; iree_hal_buffer_t* arg0_buffer = nullptr; iree_hal_buffer_t* arg1_buffer = nullptr; - ASSERT_API_OK(iree_hal_allocator_allocate_buffer( + IREE_ASSERT_OK(iree_hal_allocator_allocate_buffer( iree_hal_device_allocator(device), iree_hal_memory_type_t(IREE_HAL_MEMORY_TYPE_HOST_LOCAL | IREE_HAL_MEMORY_TYPE_DEVICE_VISIBLE), IREE_HAL_BUFFER_USAGE_ALL, sizeof(float) * kElementCount, &arg0_buffer)); - ASSERT_API_OK(iree_hal_allocator_allocate_buffer( + IREE_ASSERT_OK(iree_hal_allocator_allocate_buffer( iree_hal_device_allocator(device), iree_hal_memory_type_t(IREE_HAL_MEMORY_TYPE_HOST_LOCAL | IREE_HAL_MEMORY_TYPE_DEVICE_VISIBLE), @@ -138,10 +134,10 @@ TEST_P(SimpleEmbeddingTest, RunOnce) { // Populate initial values for 4 * 2 = 8. float kFloat4 = 4.0f; float kFloat2 = 2.0f; - ASSERT_API_OK(iree_hal_buffer_fill(arg0_buffer, 0, IREE_WHOLE_BUFFER, - &kFloat4, sizeof(float))); - ASSERT_API_OK(iree_hal_buffer_fill(arg1_buffer, 0, IREE_WHOLE_BUFFER, - &kFloat2, sizeof(float))); + IREE_ASSERT_OK(iree_hal_buffer_fill(arg0_buffer, 0, IREE_WHOLE_BUFFER, + &kFloat4, sizeof(float))); + IREE_ASSERT_OK(iree_hal_buffer_fill(arg1_buffer, 0, IREE_WHOLE_BUFFER, + &kFloat2, sizeof(float))); // Setup call inputs with our buffers. // TODO(benvanik): make a macro/magic. @@ -174,13 +170,13 @@ TEST_P(SimpleEmbeddingTest, RunOnce) { // Read back the results and ensure we got the right values. LOG(INFO) << "Reading back results..."; iree_hal_mapped_memory_t mapped_memory; - ASSERT_API_OK(iree_hal_buffer_map(ret_buffer, IREE_HAL_MEMORY_ACCESS_READ, 0, - IREE_WHOLE_BUFFER, &mapped_memory)); + IREE_ASSERT_OK(iree_hal_buffer_map(ret_buffer, IREE_HAL_MEMORY_ACCESS_READ, 0, + IREE_WHOLE_BUFFER, &mapped_memory)); ASSERT_THAT(absl::Span( reinterpret_cast(mapped_memory.contents.data), mapped_memory.contents.data_length / sizeof(float)), ::testing::ElementsAreArray({8.0f, 8.0f, 8.0f, 8.0f})); - ASSERT_API_OK(iree_hal_buffer_unmap(ret_buffer, &mapped_memory)); + IREE_ASSERT_OK(iree_hal_buffer_unmap(ret_buffer, &mapped_memory)); LOG(INFO) << "Results match!"; inputs.reset(); diff --git a/iree/samples/vulkan/vulkan_inference_gui.cc b/iree/samples/vulkan/vulkan_inference_gui.cc index d939a76db354..55a2ab26e26e 100644 --- a/iree/samples/vulkan/vulkan_inference_gui.cc +++ b/iree/samples/vulkan/vulkan_inference_gui.cc @@ -73,8 +73,6 @@ static void check_vk_result(VkResult err) { LOG(FATAL) << "VkResult: " << err; } -#define CHECK_IREE_OK(status) CHECK_EQ(IREE_STATUS_OK, (status)) - static std::vector GetIreeLayers( iree_hal_vulkan_extensibility_set_t extensibility_set, iree_hal_vulkan_features_t features) { @@ -535,30 +533,30 @@ int iree::IreeMain(int argc, char** argv) { // Setup IREE. // This call to |iree_api_init| is not technically required, but it is // included for completeness. - CHECK_IREE_OK(iree_api_init(&argc, &argv)); + IREE_CHECK_OK(iree_api_init(&argc, &argv)); // Check API version. iree_api_version_t actual_version; iree_status_t status = iree_api_version_check(IREE_API_VERSION_LATEST, &actual_version); - if (status != IREE_STATUS_OK) { - LOG(FATAL) << "Unsupported runtime API version " << actual_version; - } else { + if (iree_status_is_ok(status)) { LOG(INFO) << "IREE runtime API version " << actual_version; + } else { + LOG(FATAL) << "Unsupported runtime API version " << actual_version; } // Register HAL module types. - CHECK_IREE_OK(iree_hal_module_register_types()); + IREE_CHECK_OK(iree_hal_module_register_types()); // Create a runtime Instance. iree_vm_instance_t* iree_instance = nullptr; - CHECK_IREE_OK(iree_vm_instance_create(IREE_ALLOCATOR_SYSTEM, &iree_instance)); + IREE_CHECK_OK(iree_vm_instance_create(IREE_ALLOCATOR_SYSTEM, &iree_instance)); // Create IREE Vulkan Driver and Device, sharing our VkInstance/VkDevice. LOG(INFO) << "Creating Vulkan driver/device"; // Load symbols from our static `vkGetInstanceProcAddr` for IREE to use. iree_hal_vulkan_syms_t* iree_vk_syms = nullptr; - CHECK_IREE_OK(iree_hal_vulkan_syms_create( + IREE_CHECK_OK(iree_hal_vulkan_syms_create( reinterpret_cast(&vkGetInstanceProcAddr), &iree_vk_syms)); // Create the driver sharing our VkInstance. iree_hal_driver_t* iree_vk_driver = nullptr; @@ -567,7 +565,7 @@ int iree::IreeMain(int argc, char** argv) { options.features = static_cast( IREE_HAL_VULKAN_ENABLE_DEBUG_UTILS | IREE_HAL_VULKAN_ENABLE_PUSH_DESCRIPTORS); - CHECK_IREE_OK(iree_hal_vulkan_driver_create_using_instance( + IREE_CHECK_OK(iree_hal_vulkan_driver_create_using_instance( options, iree_vk_syms, g_Instance, &iree_vk_driver)); // Create a device sharing our VkDevice and queue. // We could also create a separate (possibly low priority) compute queue for @@ -578,12 +576,12 @@ int iree::IreeMain(int argc, char** argv) { iree_hal_vulkan_queue_set_t transfer_queue_set; transfer_queue_set.queue_indices = 0; iree_hal_device_t* iree_vk_device = nullptr; - CHECK_IREE_OK(iree_hal_vulkan_driver_wrap_device( + IREE_CHECK_OK(iree_hal_vulkan_driver_wrap_device( iree_vk_driver, g_PhysicalDevice, g_Device, compute_queue_set, transfer_queue_set, &iree_vk_device)); // Create a HAL module using the HAL device. iree_vm_module_t* hal_module = nullptr; - CHECK_IREE_OK(iree_hal_module_create(iree_vk_device, IREE_ALLOCATOR_SYSTEM, + IREE_CHECK_OK(iree_hal_module_create(iree_vk_device, IREE_ALLOCATOR_SYSTEM, &hal_module)); // Load bytecode module from embedded data. @@ -591,7 +589,7 @@ int iree::IreeMain(int argc, char** argv) { const auto* module_file_toc = iree::samples::vulkan::simple_mul_bytecode_module_create(); iree_vm_module_t* bytecode_module = nullptr; - CHECK_IREE_OK(iree_vm_bytecode_module_create( + IREE_CHECK_OK(iree_vm_bytecode_module_create( iree_const_byte_span_t{ reinterpret_cast(module_file_toc->data), module_file_toc->size}, @@ -600,7 +598,7 @@ int iree::IreeMain(int argc, char** argv) { // Allocate a context that will hold the module state across invocations. iree_vm_context_t* iree_context = nullptr; std::vector modules = {hal_module, bytecode_module}; - CHECK_IREE_OK(iree_vm_context_create_with_modules( + IREE_CHECK_OK(iree_vm_context_create_with_modules( iree_instance, modules.data(), modules.size(), IREE_ALLOCATOR_SYSTEM, &iree_context)); LOG(INFO) << "Module loaded and context is ready for use"; @@ -608,7 +606,7 @@ int iree::IreeMain(int argc, char** argv) { // Lookup the entry point function. iree_vm_function_t main_function; const char kMainFunctionName[] = "module.simple_mul"; - CHECK_IREE_OK(iree_vm_context_resolve_function( + IREE_CHECK_OK(iree_vm_context_resolve_function( iree_context, iree_string_view_t{kMainFunctionName, sizeof(kMainFunctionName) - 1}, &main_function)); @@ -700,24 +698,24 @@ int iree::IreeMain(int argc, char** argv) { iree_hal_buffer_usage_t input_buffer_usage = static_cast( IREE_HAL_BUFFER_USAGE_ALL | IREE_HAL_BUFFER_USAGE_CONSTANT); - CHECK_IREE_OK(iree_hal_allocator_allocate_buffer( + IREE_CHECK_OK(iree_hal_allocator_allocate_buffer( allocator, input_memory_type, input_buffer_usage, sizeof(float) * kElementCount, &input0_buffer)); - CHECK_IREE_OK(iree_hal_allocator_allocate_buffer( + IREE_CHECK_OK(iree_hal_allocator_allocate_buffer( allocator, input_memory_type, input_buffer_usage, sizeof(float) * kElementCount, &input1_buffer)); - CHECK_IREE_OK(iree_hal_buffer_write_data(input0_buffer, 0, &input_x, + IREE_CHECK_OK(iree_hal_buffer_write_data(input0_buffer, 0, &input_x, sizeof(input_x))); - CHECK_IREE_OK(iree_hal_buffer_write_data(input1_buffer, 0, &input_y, + IREE_CHECK_OK(iree_hal_buffer_write_data(input1_buffer, 0, &input_y, sizeof(input_y))); // Wrap input buffers in buffer views. iree_hal_buffer_view_t* input0_buffer_view = nullptr; iree_hal_buffer_view_t* input1_buffer_view = nullptr; - CHECK_IREE_OK(iree_hal_buffer_view_create( + IREE_CHECK_OK(iree_hal_buffer_view_create( input0_buffer, /*shape=*/&kElementCount, /*shape_rank=*/1, IREE_HAL_ELEMENT_TYPE_FLOAT_32, IREE_ALLOCATOR_SYSTEM, &input0_buffer_view)); - CHECK_IREE_OK(iree_hal_buffer_view_create( + IREE_CHECK_OK(iree_hal_buffer_view_create( input1_buffer, /*shape=*/&kElementCount, /*shape_rank=*/1, IREE_HAL_ELEMENT_TYPE_FLOAT_32, IREE_ALLOCATOR_SYSTEM, &input1_buffer_view)); @@ -725,25 +723,25 @@ int iree::IreeMain(int argc, char** argv) { iree_hal_buffer_release(input1_buffer); // Marshal input buffer views through a VM variant list. vm::ref inputs; - CHECK_IREE_OK(iree_vm_list_create(/*element_type=*/nullptr, 2, + IREE_CHECK_OK(iree_vm_list_create(/*element_type=*/nullptr, 2, IREE_ALLOCATOR_SYSTEM, &inputs)); auto input0_buffer_view_ref = iree_hal_buffer_view_move_ref(input0_buffer_view); auto input1_buffer_view_ref = iree_hal_buffer_view_move_ref(input1_buffer_view); - CHECK_IREE_OK( + IREE_CHECK_OK( iree_vm_list_push_ref_move(inputs.get(), &input0_buffer_view_ref)); - CHECK_IREE_OK( + IREE_CHECK_OK( iree_vm_list_push_ref_move(inputs.get(), &input1_buffer_view_ref)); // Prepare outputs list to accept results from the invocation. vm::ref outputs; - CHECK_IREE_OK(iree_vm_list_create(/*element_type=*/nullptr, + IREE_CHECK_OK(iree_vm_list_create(/*element_type=*/nullptr, kElementCount * sizeof(float), IREE_ALLOCATOR_SYSTEM, &outputs)); // Synchronously invoke the function. - CHECK_IREE_OK(iree_vm_invoke(iree_context, main_function, + IREE_CHECK_OK(iree_vm_invoke(iree_context, main_function, /*policy=*/nullptr, inputs.get(), outputs.get(), IREE_ALLOCATOR_SYSTEM)); @@ -754,7 +752,7 @@ int iree::IreeMain(int argc, char** argv) { iree_hal_buffer_view_get_descriptor())); auto* output_buffer = iree_hal_buffer_view_buffer(output_buffer_view); iree_hal_mapped_memory_t mapped_memory; - CHECK_IREE_OK(iree_hal_buffer_map(output_buffer, + IREE_CHECK_OK(iree_hal_buffer_map(output_buffer, IREE_HAL_MEMORY_ACCESS_READ, 0, IREE_WHOLE_BUFFER, &mapped_memory)); memcpy(&latest_output, mapped_memory.contents.data, diff --git a/iree/vm/builtin_types.c b/iree/vm/builtin_types.c index 4b16555f2cc0..85951542f96d 100644 --- a/iree/vm/builtin_types.c +++ b/iree/vm/builtin_types.c @@ -38,7 +38,7 @@ iree_status_t iree_vm_list_register_types(); IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_register_builtin_types() { if (iree_vm_ro_byte_buffer_descriptor.type != IREE_VM_REF_TYPE_NULL) { - return IREE_STATUS_OK; + return iree_ok_status(); } iree_vm_ro_byte_buffer_descriptor.destroy = iree_vm_ro_byte_buffer_destroy; @@ -59,5 +59,5 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_register_builtin_types() { IREE_RETURN_IF_ERROR(iree_vm_list_register_types()); - return IREE_STATUS_OK; + return iree_ok_status(); } diff --git a/iree/vm/bytecode_dispatch.c b/iree/vm/bytecode_dispatch.c index 63b8366a8b94..b8c6d7eeace2 100644 --- a/iree/vm/bytecode_dispatch.c +++ b/iree/vm/bytecode_dispatch.c @@ -93,7 +93,7 @@ iree_status_t iree_vm_bytecode_dispatch( int32_t byte_offset = VM_DecGlobalAttr("global"); if (byte_offset < 0 || byte_offset >= module_state->rwdata_storage.data_length) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } int32_t* value = VM_DecResultRegI32("value"); const int32_t* global_ptr = @@ -105,7 +105,7 @@ iree_status_t iree_vm_bytecode_dispatch( int32_t byte_offset = VM_DecGlobalAttr("global"); if (byte_offset < 0 || byte_offset >= module_state->rwdata_storage.data_length) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } int32_t value = VM_DecOperandRegI32("value"); int32_t* global_ptr = @@ -117,7 +117,7 @@ iree_status_t iree_vm_bytecode_dispatch( int32_t byte_offset = VM_DecOperandRegI32("global"); if (byte_offset < 0 || byte_offset >= module_state->rwdata_storage.data_length) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } int32_t* value = VM_DecResultRegI32("value"); const int32_t* global_ptr = @@ -129,7 +129,7 @@ iree_status_t iree_vm_bytecode_dispatch( int32_t byte_offset = VM_DecOperandRegI32("global"); if (byte_offset < 0 || byte_offset >= module_state->rwdata_storage.data_length) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } int32_t value = VM_DecOperandRegI32("value"); int32_t* global_ptr = @@ -140,7 +140,7 @@ iree_status_t iree_vm_bytecode_dispatch( DISPATCH_OP(CORE, GlobalLoadRef, { int32_t global = VM_DecGlobalAttr("global"); if (global < 0 || global >= module_state->global_ref_count) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } const iree_vm_type_def_t* type_def = VM_DecTypeOf("value"); bool result_is_move; @@ -153,7 +153,7 @@ iree_status_t iree_vm_bytecode_dispatch( DISPATCH_OP(CORE, GlobalStoreRef, { int32_t global = VM_DecGlobalAttr("global"); if (global < 0 || global >= module_state->global_ref_count) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } const iree_vm_type_def_t* type_def = VM_DecTypeOf("value"); bool value_is_move; @@ -166,7 +166,7 @@ iree_status_t iree_vm_bytecode_dispatch( DISPATCH_OP(CORE, GlobalLoadIndirectRef, { int32_t global = VM_DecGlobalAttr("global"); if (global < 0 || global >= module_state->global_ref_count) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } const iree_vm_type_def_t* type_def = VM_DecTypeOf("value"); bool result_is_move; @@ -179,7 +179,7 @@ iree_status_t iree_vm_bytecode_dispatch( DISPATCH_OP(CORE, GlobalStoreIndirectRef, { int32_t global = VM_DecGlobalAttr("global"); if (global < 0 || global >= module_state->global_ref_count) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } const iree_vm_type_def_t* type_def = VM_DecTypeOf("value"); bool value_is_move; @@ -214,7 +214,7 @@ iree_status_t iree_vm_bytecode_dispatch( int32_t rodata_ordinal = VM_DecRodataAttr("rodata"); if (rodata_ordinal < 0 || rodata_ordinal >= module_state->rodata_ref_count) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } bool result_is_move; iree_vm_ref_t* result = VM_DecResultRegRef("value", &result_is_move); @@ -242,7 +242,7 @@ iree_status_t iree_vm_bytecode_dispatch( bool list_is_move; iree_vm_ref_t* list_ref = VM_DecOperandRegRef("list", &list_is_move); iree_vm_list_t* list = iree_vm_list_deref(list_ref); - if (!list) return IREE_STATUS_INVALID_ARGUMENT; + if (!list) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); int32_t minimum_capacity = VM_DecOperandRegI32("minimum_capacity"); IREE_RETURN_IF_ERROR(iree_vm_list_reserve(list, minimum_capacity)); }); @@ -251,7 +251,7 @@ iree_status_t iree_vm_bytecode_dispatch( bool list_is_move; iree_vm_ref_t* list_ref = VM_DecOperandRegRef("list", &list_is_move); iree_vm_list_t* list = iree_vm_list_deref(list_ref); - if (!list) return IREE_STATUS_INVALID_ARGUMENT; + if (!list) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); int32_t* result = VM_DecResultRegI32("result"); *result = (int32_t)iree_vm_list_size(list); }); @@ -260,7 +260,7 @@ iree_status_t iree_vm_bytecode_dispatch( bool list_is_move; iree_vm_ref_t* list_ref = VM_DecOperandRegRef("list", &list_is_move); iree_vm_list_t* list = iree_vm_list_deref(list_ref); - if (!list) return IREE_STATUS_INVALID_ARGUMENT; + if (!list) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); int32_t new_size = VM_DecOperandRegI32("new_size"); IREE_RETURN_IF_ERROR(iree_vm_list_resize(list, new_size)); }); @@ -269,7 +269,7 @@ iree_status_t iree_vm_bytecode_dispatch( bool list_is_move; iree_vm_ref_t* list_ref = VM_DecOperandRegRef("list", &list_is_move); iree_vm_list_t* list = iree_vm_list_deref(list_ref); - if (!list) return IREE_STATUS_INVALID_ARGUMENT; + if (!list) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); int32_t index = VM_DecOperandRegI32("index"); int32_t* result = VM_DecResultRegI32("result"); iree_vm_value_t value; @@ -282,7 +282,7 @@ iree_status_t iree_vm_bytecode_dispatch( bool list_is_move; iree_vm_ref_t* list_ref = VM_DecOperandRegRef("list", &list_is_move); iree_vm_list_t* list = iree_vm_list_deref(list_ref); - if (!list) return IREE_STATUS_INVALID_ARGUMENT; + if (!list) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); int32_t index = VM_DecOperandRegI32("index"); int32_t raw_value = VM_DecOperandRegI32("raw_value"); iree_vm_value_t value = iree_vm_value_make_i32(raw_value); @@ -293,21 +293,21 @@ iree_status_t iree_vm_bytecode_dispatch( // bool list_is_move; // iree_vm_ref_t* list_ref = VM_DecOperandRegRef("list", &list_is_move); // iree_vm_list_t* list = iree_vm_list_deref(list_ref); - // if (!list) return IREE_STATUS_INVALID_ARGUMENT; + // if (!list) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); // int32_t index = VM_DecOperandRegI32("index"); // iree_vm_ref_t* result = VM_DecResultRegRef("result"); - return IREE_STATUS_UNIMPLEMENTED; + return iree_make_status(IREE_STATUS_UNIMPLEMENTED); }); DISPATCH_OP(CORE, ListSetRef, { // bool list_is_move; // iree_vm_ref_t* list_ref = VM_DecOperandRegRef("list", &list_is_move); // iree_vm_list_t* list = iree_vm_list_deref(list_ref); - // if (!list) return IREE_STATUS_INVALID_ARGUMENT; + // if (!list) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); // int32_t index = VM_DecOperandRegI32("index"); // bool operand_is_move = VM_DecOperandRegRefIsMove("value"); // iree_vm_ref_t* operand = VM_DecOperandRegRef("value"); - return IREE_STATUS_UNIMPLEMENTED; + return iree_make_status(IREE_STATUS_UNIMPLEMENTED); }); //===------------------------------------------------------------------===// @@ -599,7 +599,7 @@ iree_status_t iree_vm_bytecode_dispatch( int is_import = (function_ordinal & 0x80000000u) != 0; if (!is_import) { // Variadic calls are currently only supported for import functions. - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } // Import that we can fetch from the module state. @@ -632,7 +632,7 @@ iree_status_t iree_vm_bytecode_dispatch( if (!current_frame || current_frame->depth < entry_frame_depth) { // Return from the top-level entry frame - return back to call(). // TODO(benvanik): clear execution results. - return IREE_STATUS_OK; + return iree_ok_status(); } // Reset dispatch state so we can continue executing in the caller. @@ -648,12 +648,11 @@ iree_status_t iree_vm_bytecode_dispatch( uint32_t status_code = VM_DecOperandRegI32("status"); iree_string_view_t message; VM_DecStrAttr("message", &message); - // TODO(benvanik): attach string and stack. if (status_code == 0) { // Shouldn't happen; we expect to die here, so there's no way to no-op. - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } - return iree_make_status(status_code); + return iree_status_allocate(status_code, "", 0, message); }); //===------------------------------------------------------------------===// @@ -662,7 +661,7 @@ iree_status_t iree_vm_bytecode_dispatch( DISPATCH_OP(CORE, Yield, { // TODO(benvanik): yield with execution results. - return IREE_STATUS_OK; + return iree_ok_status(); }); //===------------------------------------------------------------------===// @@ -722,7 +721,7 @@ iree_status_t iree_vm_bytecode_dispatch( int32_t byte_offset = VM_DecGlobalAttr("global"); if (byte_offset < 0 || byte_offset >= module_state->rwdata_storage.data_length) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } int64_t* value = VM_DecResultRegI64("value"); const int64_t* global_ptr = @@ -734,7 +733,7 @@ iree_status_t iree_vm_bytecode_dispatch( int32_t byte_offset = VM_DecGlobalAttr("global"); if (byte_offset < 0 || byte_offset >= module_state->rwdata_storage.data_length) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } int64_t value = VM_DecOperandRegI64("value"); int64_t* global_ptr = @@ -746,7 +745,7 @@ iree_status_t iree_vm_bytecode_dispatch( int32_t byte_offset = VM_DecOperandRegI32("global"); if (byte_offset < 0 || byte_offset >= module_state->rwdata_storage.data_length) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } int64_t* value = VM_DecResultRegI64("value"); const int64_t* global_ptr = @@ -758,7 +757,7 @@ iree_status_t iree_vm_bytecode_dispatch( int32_t byte_offset = VM_DecOperandRegI32("global"); if (byte_offset < 0 || byte_offset >= module_state->rwdata_storage.data_length) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } int64_t value = VM_DecOperandRegI64("value"); int64_t* global_ptr = @@ -789,7 +788,7 @@ iree_status_t iree_vm_bytecode_dispatch( bool list_is_move; iree_vm_ref_t* list_ref = VM_DecOperandRegRef("list", &list_is_move); iree_vm_list_t* list = iree_vm_list_deref(list_ref); - if (!list) return IREE_STATUS_INVALID_ARGUMENT; + if (!list) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); int32_t index = VM_DecOperandRegI32("index"); int64_t* result = VM_DecResultRegI64("result"); iree_vm_value_t value; @@ -802,7 +801,7 @@ iree_status_t iree_vm_bytecode_dispatch( bool list_is_move; iree_vm_ref_t* list_ref = VM_DecOperandRegRef("list", &list_is_move); iree_vm_list_t* list = iree_vm_list_deref(list_ref); - if (!list) return IREE_STATUS_INVALID_ARGUMENT; + if (!list) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); int32_t index = VM_DecOperandRegI32("index"); int64_t raw_value = VM_DecOperandRegI64("value"); iree_vm_value_t value = iree_vm_value_make_i64(raw_value); @@ -919,14 +918,16 @@ iree_status_t iree_vm_bytecode_dispatch( *result = (operand != 0) ? 1 : 0; }); #else - return IREE_STATUS_UNIMPLEMENTED; + return iree_make_status(IREE_STATUS_UNIMPLEMENTED); #endif // IREE_VM_EXT_I64_ENABLE } END_DISPATCH_PREFIX(); - DISPATCH_OP(CORE, PrefixExtF32, { return IREE_STATUS_UNIMPLEMENTED; }); + DISPATCH_OP(CORE, PrefixExtF32, + { return iree_make_status(IREE_STATUS_UNIMPLEMENTED); }); - DISPATCH_OP(CORE, PrefixExtF64, { return IREE_STATUS_UNIMPLEMENTED; }); + DISPATCH_OP(CORE, PrefixExtF64, + { return iree_make_status(IREE_STATUS_UNIMPLEMENTED); }); // NOLINTNEXTLINE(misc-static-assert) DISPATCH_UNHANDLED_CORE(); diff --git a/iree/vm/bytecode_dispatch_util.h b/iree/vm/bytecode_dispatch_util.h index 747272da061f..e0c6c0ebd5f9 100644 --- a/iree/vm/bytecode_dispatch_util.h +++ b/iree/vm/bytecode_dispatch_util.h @@ -234,7 +234,7 @@ static const int kRegSize = sizeof(uint16_t); #define DISPATCH_UNHANDLED_CORE() \ _dispatch_unhandled: \ VMCHECK(0); \ - return IREE_STATUS_UNIMPLEMENTED; + return iree_make_status(IREE_STATUS_UNIMPLEMENTED); #define DISPATCH_UNHANDLED_EXT() #define DISPATCH_OP(ext, op_name, body) \ @@ -259,17 +259,20 @@ static const int kRegSize = sizeof(uint16_t); #define DEFINE_DISPATCH_TABLES() -#define DISPATCH_UNHANDLED_CORE() \ - default: \ - VMCHECK(0); \ - return IREE_STATUS_UNIMPLEMENTED; +#define DISPATCH_UNHANDLED_CORE() \ + default: { \ + VMCHECK(0); \ + return iree_make_status(IREE_STATUS_UNIMPLEMENTED, \ + "unhandled core " \ + "opcode"); \ + } #define DISPATCH_UNHANDLED_EXT DISPATCH_UNHANDLED_CORE #define DISPATCH_OP(ext, op_name, body) \ - case IREE_VM_OP_##ext##_##op_name: \ + case IREE_VM_OP_##ext##_##op_name: { \ IREE_DISPATCH_LOG_OPCODE(#op_name); \ body; \ - break; + } break; #define BEGIN_DISPATCH_PREFIX(op_name, ext) \ case IREE_VM_OP_CORE_##op_name: { \ diff --git a/iree/vm/bytecode_module.cc b/iree/vm/bytecode_module.cc index cec96fdc0278..38ee8a99b37e 100644 --- a/iree/vm/bytecode_module.cc +++ b/iree/vm/bytecode_module.cc @@ -86,10 +86,10 @@ static iree_status_t iree_vm_bytecode_module_resolve_types( if (!iree_vm_type_def_is_valid(type_table[i])) { LOG(ERROR) << "no type registered with name '" << iree_vm_TypeDef_full_name(type_def) << "'"; - return IREE_STATUS_NOT_FOUND; + return iree_make_status(IREE_STATUS_NOT_FOUND); } } - return IREE_STATUS_OK; + return iree_ok_status(); } // Verifies the structure of the flatbuffer so that we can avoid doing so during @@ -100,7 +100,7 @@ static iree_status_t iree_vm_bytecode_module_flatbuffer_verify( iree_const_byte_span_t flatbuffer_data) { if (!flatbuffer_data.data || flatbuffer_data.data_length < 16) { LOG(ERROR) << "Flatbuffer data is not present or less than 16 bytes"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // Run flatcc generated verification. This ensures all pointers are in-bounds @@ -110,7 +110,7 @@ static iree_status_t iree_vm_bytecode_module_flatbuffer_verify( flatbuffer_data.data, flatbuffer_data.data_length); if (verify_ret != flatcc_verify_ok) { LOG(ERROR) << flatcc_verify_error_string(verify_ret); - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } iree_vm_BytecodeModuleDef_table_t module_def = @@ -119,7 +119,7 @@ static iree_status_t iree_vm_bytecode_module_flatbuffer_verify( flatbuffers_string_t name = iree_vm_BytecodeModuleDef_name(module_def); if (!flatbuffers_string_len(name)) { LOG(ERROR) << "module name missing"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } iree_vm_TypeDef_vec_t types = iree_vm_BytecodeModuleDef_types(module_def); @@ -127,12 +127,12 @@ static iree_status_t iree_vm_bytecode_module_flatbuffer_verify( iree_vm_TypeDef_table_t type_def = iree_vm_TypeDef_vec_at(types, i); if (!type_def) { LOG(ERROR) << "type def missing body"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } flatbuffers_string_t full_name = iree_vm_TypeDef_full_name(type_def); if (flatbuffers_string_len(full_name) <= 0) { LOG(ERROR) << "type def missing full_name"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } } @@ -149,7 +149,7 @@ static iree_status_t iree_vm_bytecode_module_flatbuffer_verify( flatbuffers_vec_len(function_descriptors)) { LOG(ERROR) << "mismatched internal_functions and function_descriptors vectors"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } for (size_t i = 0; i < iree_vm_ImportFunctionDef_vec_len(imported_functions); @@ -158,17 +158,17 @@ static iree_status_t iree_vm_bytecode_module_flatbuffer_verify( iree_vm_ImportFunctionDef_vec_at(imported_functions, i); if (!import_def) { LOG(ERROR) << "import def missing body"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } flatbuffers_string_t full_name = iree_vm_ImportFunctionDef_full_name(import_def); if (!flatbuffers_string_len(full_name)) { LOG(ERROR) << "import def missing full_name"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (!iree_vm_ImportFunctionDef_signature(import_def)) { LOG(ERROR) << "import def missing a function signature"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } } @@ -178,17 +178,17 @@ static iree_status_t iree_vm_bytecode_module_flatbuffer_verify( iree_vm_ExportFunctionDef_vec_at(exported_functions, i); if (!export_def) { LOG(ERROR) << "export def missing body"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } flatbuffers_string_t local_name = iree_vm_ExportFunctionDef_local_name(export_def); if (!flatbuffers_string_len(local_name)) { LOG(ERROR) << "export def missing local_name"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (!iree_vm_ExportFunctionDef_signature(export_def)) { LOG(ERROR) << "export def missing a function signature"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } int32_t internal_ordinal = iree_vm_ExportFunctionDef_internal_ordinal(export_def); @@ -196,7 +196,7 @@ static iree_status_t iree_vm_bytecode_module_flatbuffer_verify( internal_ordinal >= iree_vm_InternalFunctionDef_vec_len(internal_functions)) { LOG(ERROR) << "export def internal_ordinal out of bounds"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } } @@ -208,11 +208,11 @@ static iree_status_t iree_vm_bytecode_module_flatbuffer_verify( iree_vm_InternalFunctionDef_vec_at(internal_functions, i); if (!function_def) { LOG(ERROR) << "function def missing body"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (!iree_vm_InternalFunctionDef_signature(function_def)) { LOG(ERROR) << "function def missing signature"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } iree_vm_FunctionDescriptor_struct_t function_descriptor = @@ -222,18 +222,18 @@ static iree_status_t iree_vm_bytecode_module_flatbuffer_verify( function_descriptor->bytecode_length > flatbuffers_uint8_vec_len(bytecode_data)) { LOG(ERROR) << "function descriptor bytecode span out of range"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (function_descriptor->i32_register_count > IREE_I32_REGISTER_COUNT || function_descriptor->ref_register_count > IREE_REF_REGISTER_COUNT) { LOG(ERROR) << "function descriptor register out of range"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // TODO(benvanik): run bytecode verifier on contents. } - return IREE_STATUS_OK; + return iree_ok_status(); } static void iree_vm_bytecode_module_destroy(void* self) { @@ -289,7 +289,7 @@ static iree_status_t iree_vm_bytecode_module_get_function( iree_vm_BytecodeModuleDef_imported_functions(module->def); if (ordinal < 0 || ordinal >= iree_vm_ImportFunctionDef_vec_len(imported_functions)) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } iree_vm_ImportFunctionDef_table_t import_def = iree_vm_ImportFunctionDef_vec_at(imported_functions, ordinal); @@ -305,7 +305,7 @@ static iree_status_t iree_vm_bytecode_module_get_function( iree_vm_BytecodeModuleDef_exported_functions(module->def); if (ordinal < 0 || ordinal >= iree_vm_ExportFunctionDef_vec_len(exported_functions)) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } iree_vm_ExportFunctionDef_table_t export_def = iree_vm_ExportFunctionDef_vec_at(exported_functions, ordinal); @@ -329,7 +329,7 @@ static iree_status_t iree_vm_bytecode_module_get_function( iree_vm_BytecodeModuleDef_internal_functions(module->def); if (ordinal < 0 || ordinal >= iree_vm_InternalFunctionDef_vec_len(internal_functions)) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } iree_vm_InternalFunctionDef_table_t function_def = iree_vm_InternalFunctionDef_vec_at(internal_functions, ordinal); @@ -360,7 +360,7 @@ static iree_status_t iree_vm_bytecode_module_get_function( iree_vm_FunctionSignatureDef_result_types(signature)); } - return IREE_STATUS_OK; + return iree_ok_status(); } static iree_status_t iree_vm_bytecode_module_get_function_reflection_attr( @@ -380,7 +380,7 @@ static iree_status_t iree_vm_bytecode_module_get_function_reflection_attr( if (ordinal < 0 || ordinal >= iree_vm_InternalFunctionDef_vec_len(internal_functions)) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } iree_vm_InternalFunctionDef_table_t function_def = @@ -391,7 +391,7 @@ static iree_status_t iree_vm_bytecode_module_get_function_reflection_attr( iree_vm_FunctionSignatureDef_reflection_attrs(signature); if (index < 0 || index >= iree_vm_ReflectionAttrDef_vec_len(reflection_attrs)) { - return IREE_STATUS_NOT_FOUND; + return iree_make_status(IREE_STATUS_NOT_FOUND); } iree_vm_ReflectionAttrDef_table_t attr = iree_vm_ReflectionAttrDef_vec_at(reflection_attrs, index); @@ -402,7 +402,7 @@ static iree_status_t iree_vm_bytecode_module_get_function_reflection_attr( // Because reflection metadata should not impose any overhead for the // non reflection case, we do not eagerly validate in on load -- instead // verify it structurally as needed. - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } key->data = attr_key; @@ -410,16 +410,17 @@ static iree_status_t iree_vm_bytecode_module_get_function_reflection_attr( value->data = attr_value; value->size = flatbuffers_string_len(attr_value); - return IREE_STATUS_OK; + return iree_ok_status(); } static iree_status_t iree_vm_bytecode_module_lookup_function( void* self, iree_vm_function_linkage_t linkage, iree_string_view_t name, iree_vm_function_t* out_function) { - if (!out_function) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_function) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); memset(out_function, 0, sizeof(iree_vm_function_t)); - if (iree_string_view_is_empty(name)) return IREE_STATUS_INVALID_ARGUMENT; + if (iree_string_view_is_empty(name)) + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); // NOTE: we could organize imports/exports alphabetically so we could bsearch. iree_vm_bytecode_module_t* module = (iree_vm_bytecode_module_t*)self; @@ -437,7 +438,7 @@ static iree_status_t iree_vm_bytecode_module_lookup_function( out_function, NULL, NULL); } } - return IREE_STATUS_NOT_FOUND; + return iree_make_status(IREE_STATUS_NOT_FOUND); } else if (linkage == IREE_VM_FUNCTION_LINKAGE_EXPORT) { iree_vm_ExportFunctionDef_vec_t exported_functions = iree_vm_BytecodeModuleDef_exported_functions(module->def); @@ -454,7 +455,7 @@ static iree_status_t iree_vm_bytecode_module_lookup_function( out_function, NULL, NULL); } } - return IREE_STATUS_NOT_FOUND; + return iree_make_status(IREE_STATUS_NOT_FOUND); } else { iree_vm_InternalFunctionDef_vec_t internal_functions = iree_vm_BytecodeModuleDef_internal_functions(module->def); @@ -471,7 +472,7 @@ static iree_status_t iree_vm_bytecode_module_lookup_function( NULL, NULL); } } - return IREE_STATUS_NOT_FOUND; + return iree_make_status(IREE_STATUS_NOT_FOUND); } } @@ -529,7 +530,7 @@ static iree_host_size_t iree_vm_bytecode_module_layout_state( static iree_status_t iree_vm_bytecode_module_alloc_state( void* self, iree_allocator_t allocator, iree_vm_module_state_t** out_module_state) { - if (!out_module_state) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_module_state) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); *out_module_state = NULL; iree_vm_bytecode_module_t* module = (iree_vm_bytecode_module_t*)self; @@ -562,7 +563,7 @@ static iree_status_t iree_vm_bytecode_module_alloc_state( } *out_module_state = (iree_vm_module_state_t*)state; - return IREE_STATUS_OK; + return iree_ok_status(); } static void iree_vm_bytecode_module_free_state( @@ -585,13 +586,13 @@ static iree_status_t iree_vm_bytecode_module_resolve_import( iree_vm_function_t function) { iree_vm_bytecode_module_state_t* state = (iree_vm_bytecode_module_state_t*)module_state; - if (!state) return IREE_STATUS_INVALID_ARGUMENT; + if (!state) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); if (ordinal < 0 || ordinal >= state->import_count) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // TODO(benvanik): verify signature. state->import_table[ordinal] = function; - return IREE_STATUS_OK; + return iree_ok_status(); } static iree_status_t iree_vm_bytecode_module_begin_call( @@ -601,9 +602,9 @@ static iree_status_t iree_vm_bytecode_module_begin_call( // much work or touching too many unlikely-to-be-cached structures (such as // walking the FlatBuffer, which may cause page faults). - if (!out_result) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_result) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); memset(out_result, 0, sizeof(iree_vm_execution_result_t)); - if (!stack) return IREE_STATUS_INVALID_ARGUMENT; + if (!stack) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); // Only internal functions store the information needed for execution. We // allow exports here as well to make things easier to call externally. @@ -617,7 +618,7 @@ static iree_status_t iree_vm_bytecode_module_begin_call( if (function.ordinal < 0 || function.ordinal >= module->function_descriptor_count) { // Invalid function ordinal. - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } // Enter function (as this is the initial call). @@ -639,7 +640,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_bytecode_module_create( iree_const_byte_span_t flatbuffer_data, iree_allocator_t flatbuffer_allocator, iree_allocator_t allocator, iree_vm_module_t** out_module) { - if (!out_module) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_module) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); *out_module = NULL; IREE_RETURN_IF_ERROR( @@ -651,7 +652,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_bytecode_module_create( LOG(ERROR) << "failed getting root from flatbuffer data; expected " "identifier " iree_vm_BytecodeModuleDef_file_identifier " not found"; - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } iree_vm_TypeDef_vec_t type_defs = iree_vm_BytecodeModuleDef_types(module_def); @@ -703,5 +704,5 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_bytecode_module_create( iree_vm_bytecode_module_get_function_reflection_attr; *out_module = &module->interface; - return IREE_STATUS_OK; + return iree_ok_status(); } diff --git a/iree/vm/bytecode_module_benchmark.cc b/iree/vm/bytecode_module_benchmark.cc index ae3cf47c16e3..42730a41b010 100644 --- a/iree/vm/bytecode_module_benchmark.cc +++ b/iree/vm/bytecode_module_benchmark.cc @@ -43,7 +43,7 @@ static iree_status_t IREE_API_CALL SimpleAddExecute( iree_vm_register_list_t list; } result_registers = {{1, 0}}; iree_vm_stack_function_leave(stack, &result_registers.list, NULL); - return IREE_STATUS_OK; + return iree_ok_status(); } // Benchmarks the given exported function, optionally passing in arguments. @@ -80,7 +80,7 @@ static iree_status_t RunFunction(benchmark::State& state, +[](void* state_resolver, iree_vm_module_t* module, iree_vm_module_state_t** out_module_state) -> iree_status_t { *out_module_state = (iree_vm_module_state_t*)state_resolver; - return IREE_STATUS_OK; + return iree_ok_status(); }}; iree_vm_function_t function; @@ -131,7 +131,7 @@ static iree_status_t RunFunction(benchmark::State& state, module->free_state(module->self, module_state); module->destroy(module->self); - return IREE_STATUS_OK; + return iree_ok_status(); } static void BM_ModuleCreate(benchmark::State& state) { diff --git a/iree/vm/context.c b/iree/vm/context.c index 3af6f09968d1..cc8450d13d51 100644 --- a/iree/vm/context.c +++ b/iree/vm/context.c @@ -51,7 +51,7 @@ static iree_status_t iree_vm_context_run_function( if (iree_status_is_not_found(status)) { // Function doesn't exist; that's ok as this was an optional call. IREE_TRACE_ZONE_END(z0); - return IREE_STATUS_OK; + return iree_ok_status(); } else if (!iree_status_is_ok(status)) { IREE_TRACE_ZONE_END(z0); return status; @@ -69,7 +69,7 @@ static iree_status_t iree_vm_context_run_function( static iree_status_t iree_vm_context_query_module_state( void* state_resolver, iree_vm_module_t* module, iree_vm_module_state_t** out_module_state) { - if (!state_resolver) return IREE_STATUS_INVALID_ARGUMENT; + if (!state_resolver) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); iree_vm_context_t* context = (iree_vm_context_t*)state_resolver; // NOTE: this is a linear scan, but given that the list of modules should be // N<4 this is faster than just about anything else we could do. @@ -77,10 +77,10 @@ static iree_status_t iree_vm_context_query_module_state( for (int i = 0; i < context->list.count; ++i) { if (context->list.modules[i] == module) { *out_module_state = context->list.module_states[i]; - return IREE_STATUS_OK; + return iree_ok_status(); } } - return IREE_STATUS_NOT_FOUND; + return iree_make_status(IREE_STATUS_NOT_FOUND); } static iree_status_t iree_vm_context_resolve_module_imports( @@ -112,7 +112,7 @@ static iree_status_t iree_vm_context_resolve_module_imports( IREE_RETURN_IF_ERROR( module->resolve_import(module->self, module_state, i, import_function)); } - return IREE_STATUS_OK; + return iree_ok_status(); } static void iree_vm_context_release_modules(iree_vm_context_t* context, @@ -168,19 +168,19 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_context_create_with_modules( iree_host_size_t module_count, iree_allocator_t allocator, iree_vm_context_t** out_context) { if (!out_context) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_context = NULL; if (!instance) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (!modules && module_count > 0) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } for (int i = 0; i < module_count; ++i) { if (!modules[i]) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } } @@ -215,7 +215,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_context_create_with_modules( } *out_context = context; - return IREE_STATUS_OK; + return iree_ok_status(); } static void iree_vm_context_destroy(iree_vm_context_t* context) { @@ -286,21 +286,21 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_context_register_modules( iree_vm_context_t* context, iree_vm_module_t** modules, iree_host_size_t module_count) { if (!context) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (!modules && module_count > 1) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } for (int i = 0; i < module_count; ++i) { if (!modules[i]) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } } // Try growing both our storage lists first, if needed. if (context->list.count + module_count > context->list.capacity) { if (context->is_static) { - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } iree_host_size_t new_capacity = context->list.capacity + module_count; if (new_capacity < context->list.capacity * 2) { @@ -337,7 +337,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_context_register_modules( // Retain all modules and allocate their state. assert(context->list.capacity >= context->list.count + module_count); iree_host_size_t original_count = context->list.count; - iree_status_t status = IREE_STATUS_OK; + iree_status_t status = iree_ok_status(); iree_host_size_t i = 0; for (i = 0; i < module_count; ++i) { iree_vm_module_t* module = modules[i]; @@ -394,7 +394,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_context_resolve_function( const iree_vm_context_t* context, iree_string_view_t full_name, iree_vm_function_t* out_function) { if (!out_function) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } memset(out_function, 0, sizeof(iree_vm_function_t)); @@ -402,7 +402,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_context_resolve_function( iree_string_view_t function_name; if (iree_string_view_split(full_name, '.', &module_name, &function_name) == -1) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } for (int i = (int)context->list.count - 1; i >= 0; --i) { @@ -414,5 +414,5 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_context_resolve_function( } } - return IREE_STATUS_NOT_FOUND; + return iree_make_status(IREE_STATUS_NOT_FOUND); } diff --git a/iree/vm/instance.c b/iree/vm/instance.c index fc40bf80d279..7a728cb132ee 100644 --- a/iree/vm/instance.c +++ b/iree/vm/instance.c @@ -25,7 +25,7 @@ struct iree_vm_instance { IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_instance_create( iree_allocator_t allocator, iree_vm_instance_t** out_instance) { if (!out_instance) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } *out_instance = NULL; @@ -38,7 +38,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_instance_create( iree_atomic_store(&instance->ref_count, 1); *out_instance = instance; - return IREE_STATUS_OK; + return iree_ok_status(); } static void iree_vm_instance_destroy(iree_vm_instance_t* instance) { diff --git a/iree/vm/invocation.c b/iree/vm/invocation.c index f8cf3f9bcba2..93248f35211e 100644 --- a/iree/vm/invocation.c +++ b/iree/vm/invocation.c @@ -44,7 +44,7 @@ static iree_status_t iree_vm_stack_frame_marshal_inputs( dst_regs.i32[i32_reg++] = variant.i32; } } - return IREE_STATUS_OK; + return iree_ok_status(); } // Marshals callee return registers into a variant list. @@ -63,7 +63,7 @@ static iree_status_t iree_vm_stack_frame_marshal_outputs( IREE_RETURN_IF_ERROR(iree_vm_list_push_value(outputs, &value)); } } - return IREE_STATUS_OK; + return iree_ok_status(); } // TODO(benvanik): implement this as an iree_vm_invocation_t sequence. @@ -79,16 +79,16 @@ static iree_status_t iree_vm_invoke_within( // iree_vm_function_signature_t signature = // iree_vm_function_signature(&function); // if (input_count != signature.argument_count) { - // return IREE_STATUS_INVALID_ARGUMENT; + // return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); // } else if (!outputs && signature.result_count > 0) { - // return IREE_STATUS_INVALID_ARGUMENT; + // return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); // } // Keep the I/O count reasonable to limit stack usage. If we end up passing // this many things (such as for nested variadic lists/etc) we should instead // use list objects as they'll be significantly more efficient. if (input_count > 1024 || output_count > 1024) { - return IREE_STATUS_RESOURCE_EXHAUSTED; + return iree_make_status(IREE_STATUS_RESOURCE_EXHAUSTED); } // Allocate storage for marshaling arguments into the callee stack frame. diff --git a/iree/vm/list.c b/iree/vm/list.c index ac1785e54174..88a2b71b9a18 100644 --- a/iree/vm/list.c +++ b/iree/vm/list.c @@ -130,7 +130,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_initialize( iree_host_size_t required_storage_size = storage_offset + iree_align(capacity * element_size, 8); if (storage.data_length < required_storage_size) { - return IREE_STATUS_OUT_OF_RANGE; + return iree_make_status(IREE_STATUS_OUT_OF_RANGE); } memset(storage.data, 0, required_storage_size); @@ -145,7 +145,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_initialize( list->storage = storage.data + storage_offset; *out_list = list; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT void IREE_API_CALL @@ -185,7 +185,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_create( } *out_list = list; - return IREE_STATUS_OK; + return iree_ok_status(); } static void iree_vm_list_destroy(void* ptr) { @@ -206,7 +206,7 @@ IREE_API_EXPORT void IREE_API_CALL iree_vm_list_release(iree_vm_list_t* list) { IREE_API_EXPORT iree_status_t iree_vm_list_element_type( const iree_vm_list_t* list, iree_vm_type_def_t* out_element_type) { *out_element_type = list->element_type; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_host_size_t IREE_API_CALL @@ -217,7 +217,7 @@ iree_vm_list_capacity(const iree_vm_list_t* list) { IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_reserve(iree_vm_list_t* list, iree_host_size_t minimum_capacity) { if (list->capacity >= minimum_capacity) { - return IREE_STATUS_OK; + return iree_ok_status(); } iree_host_size_t old_capacity = list->capacity; iree_host_size_t new_capacity = iree_align(minimum_capacity, 64); @@ -226,7 +226,7 @@ iree_vm_list_reserve(iree_vm_list_t* list, iree_host_size_t minimum_capacity) { memset((void*)((uintptr_t)list->storage + old_capacity * list->element_size), 0, (new_capacity - old_capacity) * list->element_size); list->capacity = new_capacity; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_host_size_t IREE_API_CALL @@ -237,7 +237,7 @@ iree_vm_list_size(const iree_vm_list_t* list) { IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_resize(iree_vm_list_t* list, iree_host_size_t new_size) { if (new_size == list->count) { - return IREE_STATUS_OK; + return iree_ok_status(); } else if (new_size < list->count) { // Truncating. iree_vm_list_reset_range(list, new_size + 1, list->count - new_size); @@ -247,7 +247,7 @@ iree_vm_list_resize(iree_vm_list_t* list, iree_host_size_t new_size) { IREE_RETURN_IF_ERROR(iree_vm_list_reserve(list, new_size)); } list->count = new_size; - return IREE_STATUS_OK; + return iree_ok_status(); } static void iree_vm_list_convert_value_type( @@ -324,7 +324,7 @@ static void iree_vm_list_convert_value_type( IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_get_value(const iree_vm_list_t* list, iree_host_size_t i, iree_vm_value_t* out_value) { - if (i >= list->count) return IREE_STATUS_OUT_OF_RANGE; + if (i >= list->count) return iree_make_status(IREE_STATUS_OUT_OF_RANGE); uintptr_t element_ptr = (uintptr_t)list->storage + i * list->element_size; memset(out_value, 0, sizeof(*out_value)); switch (list->storage_mode) { @@ -350,7 +350,7 @@ iree_vm_list_get_value(const iree_vm_list_t* list, iree_host_size_t i, case IREE_VM_LIST_STORAGE_MODE_VARIANT: { iree_vm_variant_t* variant = (iree_vm_variant_t*)element_ptr; if (!iree_vm_type_def_is_value(&variant->type)) { - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } out_value->type = variant->type.value_type; memcpy(out_value->value_storage, variant->value_storage, @@ -358,15 +358,15 @@ iree_vm_list_get_value(const iree_vm_list_t* list, iree_host_size_t i, break; } default: - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_get_value_as( const iree_vm_list_t* list, iree_host_size_t i, iree_vm_value_type_t value_type, iree_vm_value_t* out_value) { - if (i >= list->count) return IREE_STATUS_OUT_OF_RANGE; + if (i >= list->count) return iree_make_status(IREE_STATUS_OUT_OF_RANGE); uintptr_t element_ptr = (uintptr_t)list->storage + i * list->element_size; iree_vm_value_t value; value.i64 = 0; @@ -393,7 +393,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_get_value_as( case IREE_VM_LIST_STORAGE_MODE_VARIANT: { iree_vm_variant_t* variant = (iree_vm_variant_t*)element_ptr; if (!iree_vm_type_def_is_value(&variant->type)) { - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } value.type = variant->type.value_type; memcpy(value.value_storage, variant->value_storage, @@ -401,15 +401,15 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_get_value_as( break; } default: - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } iree_vm_list_convert_value_type(&value, value_type, out_value); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_set_value( iree_vm_list_t* list, iree_host_size_t i, const iree_vm_value_t* value) { - if (i >= list->count) return IREE_STATUS_OUT_OF_RANGE; + if (i >= list->count) return iree_make_status(IREE_STATUS_OUT_OF_RANGE); iree_vm_value_type_t target_type; switch (list->storage_mode) { case IREE_VM_LIST_STORAGE_MODE_VALUE: { @@ -421,7 +421,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_set_value( break; } default: - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } iree_vm_value_t converted_value; iree_vm_list_convert_value_type(value, target_type, &converted_value); @@ -457,9 +457,9 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_set_value( break; } default: - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL @@ -484,7 +484,7 @@ IREE_API_EXPORT void* iree_vm_list_get_ref_deref( IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_get_ref_assign( const iree_vm_list_t* list, iree_host_size_t i, iree_vm_ref_t* out_value) { - if (i >= list->count) return IREE_STATUS_OUT_OF_RANGE; + if (i >= list->count) return iree_make_status(IREE_STATUS_OUT_OF_RANGE); uintptr_t element_ptr = (uintptr_t)list->storage + i * list->element_size; switch (list->storage_mode) { case IREE_VM_LIST_STORAGE_MODE_REF: { @@ -495,29 +495,29 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_get_ref_assign( case IREE_VM_LIST_STORAGE_MODE_VARIANT: { iree_vm_variant_t* variant = (iree_vm_variant_t*)element_ptr; if (!iree_vm_type_def_is_ref(&variant->type)) { - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } iree_vm_ref_assign(&variant->ref, out_value); break; } default: - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_get_ref_retain( const iree_vm_list_t* list, iree_host_size_t i, iree_vm_ref_t* out_value) { IREE_RETURN_IF_ERROR(iree_vm_list_get_ref_assign(list, i, out_value)); iree_vm_ref_retain(out_value, out_value); - return IREE_STATUS_OK; + return iree_ok_status(); } static iree_status_t IREE_API_CALL iree_vm_list_set_ref(iree_vm_list_t* list, iree_host_size_t i, bool is_move, iree_vm_ref_t* value) { - if (i >= list->count) return IREE_STATUS_OUT_OF_RANGE; + if (i >= list->count) return iree_make_status(IREE_STATUS_OUT_OF_RANGE); uintptr_t element_ptr = (uintptr_t)list->storage + i * list->element_size; switch (list->storage_mode) { case IREE_VM_LIST_STORAGE_MODE_REF: { @@ -537,9 +537,9 @@ static iree_status_t IREE_API_CALL iree_vm_list_set_ref(iree_vm_list_t* list, break; } default: - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_set_ref_retain( @@ -570,7 +570,7 @@ iree_vm_list_push_ref_move(iree_vm_list_t* list, iree_vm_ref_t* value) { IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_get_variant(const iree_vm_list_t* list, iree_host_size_t i, iree_vm_variant_t* out_value) { - if (i >= list->count) return IREE_STATUS_OUT_OF_RANGE; + if (i >= list->count) return iree_make_status(IREE_STATUS_OUT_OF_RANGE); uintptr_t element_ptr = (uintptr_t)list->storage + i * list->element_size; switch (list->storage_mode) { case IREE_VM_LIST_STORAGE_MODE_VALUE: { @@ -597,14 +597,14 @@ iree_vm_list_get_variant(const iree_vm_list_t* list, iree_host_size_t i, break; } default: - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_set_variant( iree_vm_list_t* list, iree_host_size_t i, const iree_vm_variant_t* value) { - return IREE_STATUS_UNIMPLEMENTED; + return iree_make_status(IREE_STATUS_UNIMPLEMENTED); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_list_push_variant( diff --git a/iree/vm/module.c b/iree/vm/module.c index e9e9ad3222a2..b05d29bb8465 100644 --- a/iree/vm/module.c +++ b/iree/vm/module.c @@ -23,7 +23,7 @@ iree_vm_module_initialize(iree_vm_module_t* module, void* self) { memset(module, 0, sizeof(iree_vm_module_t)); module->self = self; iree_atomic_store(&module->ref_count, 1); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT void IREE_API_CALL @@ -105,7 +105,7 @@ iree_vm_function_signature(const iree_vm_function_t* function) { IREE_API_EXPORT iree_string_view_t IREE_API_CALL iree_vm_function_reflection_attr(const iree_vm_function_t* function, iree_string_view_t key) { - iree_string_view_t empty_string = IREE_STRING_VIEW_EMPTY; + iree_string_view_t empty_string = iree_string_view_empty(); iree_vm_module_t* module = function->module; if (!module->get_function_reflection_attr) { return empty_string; @@ -128,7 +128,7 @@ iree_vm_get_function_reflection_attr(iree_vm_function_t function, int32_t index, iree_string_view_t* key, iree_string_view_t* value) { if (!function.module->get_function_reflection_attr) { - return IREE_STATUS_NOT_FOUND; + return iree_make_status(IREE_STATUS_NOT_FOUND); } return function.module->get_function_reflection_attr( function.module->self, function.linkage, function.ordinal, index, key, diff --git a/iree/vm/module_abi_cc.h b/iree/vm/module_abi_cc.h index 53d508f00bd9..39ce88dc8ba2 100644 --- a/iree/vm/module_abi_cc.h +++ b/iree/vm/module_abi_cc.h @@ -142,7 +142,7 @@ class NativeModule { } auto* module = FromModulePointer(self); if (ordinal < 0 || ordinal > module->dispatch_table_.size()) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (out_function) { out_function->module = module->interface(); @@ -153,16 +153,17 @@ class NativeModule { const auto& dispatch_function = module->dispatch_table_[ordinal]; *out_name = iree_make_cstring_view(dispatch_function.name); } - return IREE_STATUS_OK; + return iree_ok_status(); } static iree_status_t ModuleLookupFunction(void* self, iree_vm_function_linkage_t linkage, iree_string_view_t name, iree_vm_function_t* out_function) { - if (!out_function) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_function) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); std::memset(out_function, 0, sizeof(*out_function)); - if (!name.data || !name.size) return IREE_STATUS_INVALID_ARGUMENT; + if (!name.data || !name.size) + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); auto* module = FromModulePointer(self); out_function->module = module->interface(); @@ -172,16 +173,17 @@ class NativeModule { name, iree_make_cstring_view(module->dispatch_table_[i].name)) == 0) { out_function->ordinal = i; - return IREE_STATUS_OK; + return iree_ok_status(); } } - return IREE_STATUS_NOT_FOUND; + return iree_make_status(IREE_STATUS_NOT_FOUND); } static iree_status_t ModuleAllocState( void* self, iree_allocator_t allocator, iree_vm_module_state_t** out_module_state) { - if (!out_module_state) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_module_state) + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); *out_module_state = nullptr; auto* module = FromModulePointer(self); @@ -193,7 +195,7 @@ class NativeModule { *out_module_state = reinterpret_cast(module_state.release()); - return IREE_STATUS_OK; + return iree_ok_status(); } static void ModuleFreeState(void* self, @@ -206,19 +208,19 @@ class NativeModule { int32_t ordinal, iree_vm_function_t function) { // C++ API does not yet support imports. - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } static iree_status_t ModuleBeginCall(void* self, iree_vm_stack_t* stack, const iree_vm_function_call_t* call, iree_vm_execution_result_t* out_result) { - if (!out_result) return IREE_STATUS_INVALID_ARGUMENT; + if (!out_result) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); std::memset(out_result, 0, sizeof(*out_result)); - if (!stack) return IREE_STATUS_INVALID_ARGUMENT; + if (!stack) return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); auto* module = FromModulePointer(self); if (call->function.ordinal < 0 || call->function.ordinal >= module->dispatch_table_.size()) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } const auto& info = module->dispatch_table_[call->function.ordinal]; diff --git a/iree/vm/ref.c b/iree/vm/ref.c index 7a1b40adce0b..f27d355dedef 100644 --- a/iree/vm/ref.c +++ b/iree/vm/ref.c @@ -76,12 +76,12 @@ iree_vm_ref_register_type(iree_vm_ref_type_descriptor_t* descriptor) { if (!iree_vm_ref_type_descriptors[i]) { iree_vm_ref_type_descriptors[i] = descriptor; descriptor->type = i; - return IREE_STATUS_OK; + return iree_ok_status(); } } // Too many user-defined types registered; need to increase // IREE_VM_MAX_TYPE_ID. - return IREE_STATUS_RESOURCE_EXHAUSTED; + return iree_make_status(IREE_STATUS_RESOURCE_EXHAUSTED); } IREE_API_EXPORT iree_string_view_t IREE_API_CALL @@ -110,7 +110,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_ref_wrap_assign( iree_vm_ref_get_type_descriptor(type); if (!type_descriptor) { // Type not registered. - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } if (out_ref->ptr != NULL) { @@ -124,7 +124,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_ref_wrap_assign( out_ref->offsetof_counter = type_descriptor->offsetof_counter; out_ref->type = type; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_ref_wrap_retain( @@ -134,12 +134,13 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_ref_wrap_retain( volatile iree_atomic_intptr_t* counter = IREE_GET_REF_COUNTER_PTR(out_ref); iree_atomic_fetch_add(counter, 1); } - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_ref_check(iree_vm_ref_t* ref, iree_vm_ref_type_t type) { - return ref->type == type ? IREE_STATUS_OK : IREE_STATUS_INVALID_ARGUMENT; + return ref->type == type ? iree_ok_status() + : iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_API_EXPORT void IREE_API_CALL iree_vm_ref_retain(iree_vm_ref_t* ref, @@ -163,10 +164,10 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_ref_retain_checked( iree_vm_ref_t* ref, iree_vm_ref_type_t type, iree_vm_ref_t* out_ref) { if (ref->type != IREE_VM_REF_TYPE_NULL && ref->type != type) { // Make no changes on failure. - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } iree_vm_ref_retain(ref, out_ref); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT void IREE_API_CALL iree_vm_ref_retain_or_move( @@ -195,10 +196,10 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_ref_retain_or_move_checked( iree_vm_ref_t* out_ref) { if (ref->type != IREE_VM_REF_TYPE_NULL && ref->type != type) { // Make no changes on failure. - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } iree_vm_ref_retain_or_move(is_move, ref, out_ref); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT void IREE_API_CALL iree_vm_ref_release(iree_vm_ref_t* ref) { diff --git a/iree/vm/stack.c b/iree/vm/stack.c index 0a07f8321e73..795437661283 100644 --- a/iree/vm/stack.c +++ b/iree/vm/stack.c @@ -323,7 +323,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_stack_initialize( iree_allocator_t allocator, iree_vm_stack_t** out_stack) { *out_stack = NULL; if (storage.data_length < IREE_VM_STACK_MIN_SIZE) { - return IREE_STATUS_INVALID_ARGUMENT; + return iree_make_status(IREE_STATUS_INVALID_ARGUMENT); } IREE_TRACE_ZONE_BEGIN(z0); @@ -345,7 +345,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_stack_initialize( *out_stack = stack; IREE_TRACE_ZONE_END(z0); - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT void IREE_API_CALL @@ -423,7 +423,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_stack_query_module_state( static iree_status_t iree_vm_stack_grow(iree_vm_stack_t* stack, iree_host_size_t minimum_capacity) { if (stack->allocator.alloc == NULL) { - return IREE_STATUS_RESOURCE_EXHAUSTED; + return iree_make_status(IREE_STATUS_RESOURCE_EXHAUSTED); } // Ensure we grow at least as much as required. @@ -432,7 +432,7 @@ static iree_status_t iree_vm_stack_grow(iree_vm_stack_t* stack, new_capacity *= IREE_VM_STACK_GROWTH_FACTOR; } while (new_capacity < minimum_capacity); if (new_capacity > IREE_VM_STACK_MAX_SIZE) { - return IREE_STATUS_RESOURCE_EXHAUSTED; + return iree_make_status(IREE_STATUS_RESOURCE_EXHAUSTED); } IREE_TRACE_ZONE_BEGIN(z0); @@ -484,7 +484,7 @@ static iree_status_t iree_vm_stack_grow(iree_vm_stack_t* stack, } IREE_TRACE_ZONE_END(z0); - return IREE_STATUS_OK; + return iree_ok_status(); } // Remaps argument/result registers from a source list in the caller/callee @@ -588,7 +588,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_stack_function_enter( ref_register_count > IREE_REF_REGISTER_MASK) { // Register count overflow. A valid compiler should never produce files that // hit this. - return IREE_STATUS_RESOURCE_EXHAUSTED; + return iree_make_status(IREE_STATUS_RESOURCE_EXHAUSTED); } // NOTE: >> by the bit width is undefined so we use a 64bit mask here to // ensure we are ok. @@ -652,7 +652,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_stack_function_enter( } if (out_callee_frame) *out_callee_frame = callee_frame; - return IREE_STATUS_OK; + return iree_ok_status(); } // The external caller doesn't know the register types that it's going to be @@ -684,7 +684,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_stack_function_leave( iree_vm_stack_t* stack, const iree_vm_register_list_t* result_registers, iree_vm_stack_frame_t** out_caller_frame) { if (!stack->top) { - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } iree_vm_stack_frame_header_t* frame_header = stack->top; @@ -721,7 +721,7 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_stack_function_leave( stack->frame_storage_size -= frame_header->frame_size; if (out_caller_frame) *out_caller_frame = caller_frame; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_stack_external_enter( @@ -736,15 +736,15 @@ IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_stack_external_enter( stack, external_function, NULL, NULL, out_callee_frame)); stack->top->type = IREE_VM_STACK_FRAME_EXTERNAL; - return IREE_STATUS_OK; + return iree_ok_status(); } IREE_API_EXPORT iree_status_t IREE_API_CALL iree_vm_stack_external_leave(iree_vm_stack_t* stack) { if (!stack->top) { - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } else if (stack->top->type != IREE_VM_STACK_FRAME_EXTERNAL) { - return IREE_STATUS_FAILED_PRECONDITION; + return iree_make_status(IREE_STATUS_FAILED_PRECONDITION); } return iree_vm_stack_function_leave(stack, NULL, NULL); } diff --git a/iree/vm/stack_test.cc b/iree/vm/stack_test.cc index 809d43ae72d9..ff2ec26355c6 100644 --- a/iree/vm/stack_test.cc +++ b/iree/vm/stack_test.cc @@ -36,13 +36,13 @@ static iree_status_t SentinelStateResolver( if (module == MODULE_A_SENTINEL) { ++module_a_state_resolve_count; *out_module_state = MODULE_A_STATE_SENTINEL; - return IREE_STATUS_OK; + return iree_ok_status(); } else if (module == MODULE_B_SENTINEL) { ++module_b_state_resolve_count; *out_module_state = MODULE_B_STATE_SENTINEL; - return IREE_STATUS_OK; + return iree_ok_status(); } - return IREE_STATUS_NOT_FOUND; + return iree_make_status(IREE_STATUS_NOT_FOUND); } // Tests simple stack usage, mainly just for demonstration. @@ -187,7 +187,7 @@ TEST(VMStackTest, ModuleStateQueryFailure) { +[](void* state_resolver, iree_vm_module_t* module, iree_vm_module_state_t** out_module_state) -> iree_status_t { // NOTE: always failing. - return IREE_STATUS_INTERNAL; + return iree_make_status(IREE_STATUS_INTERNAL); }}; IREE_VM_INLINE_STACK_INITIALIZE(stack, state_resolver, IREE_ALLOCATOR_SYSTEM); @@ -195,8 +195,9 @@ TEST(VMStackTest, ModuleStateQueryFailure) { iree_vm_function_t function_a = {MODULE_A_SENTINEL, IREE_VM_FUNCTION_LINKAGE_INTERNAL, 0}; iree_vm_stack_frame_t* frame_a = nullptr; - EXPECT_EQ(IREE_STATUS_INTERNAL, iree_vm_stack_function_enter( - stack, function_a, NULL, NULL, &frame_a)); + IREE_EXPECT_STATUS_IS( + IREE_STATUS_INTERNAL, + iree_vm_stack_function_enter(stack, function_a, NULL, NULL, &frame_a)); iree_vm_stack_deinitialize(stack); }