Finishing iree_vm_list_set_variant/iree_vm_list_push_variant impls.
diff --git a/compiler/src/iree/compiler/ConstEval/Runtime.cpp b/compiler/src/iree/compiler/ConstEval/Runtime.cpp index d14198a..7ba471a 100644 --- a/compiler/src/iree/compiler/ConstEval/Runtime.cpp +++ b/compiler/src/iree/compiler/ConstEval/Runtime.cpp
@@ -145,7 +145,8 @@ << " got " << iree_vm_list_size(outputs); } iree_vm_variant_t variant = iree_vm_variant_empty(); - IREE_CHECK_OK(iree_vm_list_get_variant(outputs, 0, &variant)); + IREE_CHECK_OK( + iree_vm_list_get_variant_assign(outputs, 0, &variant)); result = convertVariantToAttribute(loc, variant); return success(result != nullptr); }))) {
diff --git a/experimental/web/sample_dynamic/main.c b/experimental/web/sample_dynamic/main.c index 17bb4be..8f75a40 100644 --- a/experimental/web/sample_dynamic/main.c +++ b/experimental/web/sample_dynamic/main.c
@@ -283,8 +283,9 @@ iree_vm_list_t* variants_list = iree_runtime_call_outputs(call); for (iree_host_size_t i = 0; i < iree_vm_list_size(variants_list); ++i) { iree_vm_variant_t variant = iree_vm_variant_empty(); - IREE_RETURN_IF_ERROR(iree_vm_list_get_variant(variants_list, i, &variant), - "variant %" PRIhsz " not present", i); + IREE_RETURN_IF_ERROR( + iree_vm_list_get_variant_assign(variants_list, i, &variant), + "variant %" PRIhsz " not present", i); if (iree_vm_variant_is_value(variant)) { switch (variant.type.value_type) {
diff --git a/runtime/bindings/python/vm.cc b/runtime/bindings/python/vm.cc index 41e979b..70e5f53 100644 --- a/runtime/bindings/python/vm.cc +++ b/runtime/bindings/python/vm.cc
@@ -255,7 +255,7 @@ py::object VmVariantList::GetVariant(int index) { iree_vm_variant_t v = iree_vm_variant_empty(); - CheckApiStatus(iree_vm_list_get_variant(raw_ptr(), index, &v), + CheckApiStatus(iree_vm_list_get_variant_assign(raw_ptr(), index, &v), "Could not access list element"); if (iree_vm_type_def_is_value(&v.type)) { // Convert a value type. @@ -288,7 +288,7 @@ py::object VmVariantList::GetAsSerializedTraceValue(int index) { iree_vm_variant_t v = iree_vm_variant_empty(); - CheckApiStatus(iree_vm_list_get_variant(raw_ptr(), index, &v), + CheckApiStatus(iree_vm_list_get_variant_assign(raw_ptr(), index, &v), "Could not access list element"); if (iree_vm_type_def_is_value(&v.type)) { // Convert a value type. @@ -398,7 +398,7 @@ py::object VmVariantList::GetAsRef(int index) { iree_vm_variant_t v = iree_vm_variant_empty(); - CheckApiStatus(iree_vm_list_get_variant(raw_ptr(), index, &v), + CheckApiStatus(iree_vm_list_get_variant_assign(raw_ptr(), index, &v), "Could not access list element"); if (!iree_vm_variant_is_ref(v)) { throw std::invalid_argument("list element is not a ref"); @@ -432,7 +432,7 @@ std::unordered_set<iree_vm_list_t*>& visited) { for (iree_host_size_t i = 0, e = iree_vm_list_size(list); i < e; ++i) { iree_vm_variant_t variant = iree_vm_variant_empty(); - iree_status_t status = iree_vm_list_get_variant(list, i, &variant); + iree_status_t status = iree_vm_list_get_variant_assign(list, i, &variant); if (!iree_status_is_ok(status)) { iree_status_ignore(status); out.append("Error");
diff --git a/runtime/src/iree/tooling/comparison.cc b/runtime/src/iree/tooling/comparison.cc index 7cc3c76..b01e3c9 100644 --- a/runtime/src/iree/tooling/comparison.cc +++ b/runtime/src/iree/tooling/comparison.cc
@@ -244,9 +244,10 @@ for (iree_host_size_t i = 0; i < iree_vm_list_size(expected_list); ++i) { iree_vm_variant_t expected_variant = iree_vm_variant_empty(); IREE_CHECK_OK( - iree_vm_list_get_variant(expected_list, i, &expected_variant)); + iree_vm_list_get_variant_assign(expected_list, i, &expected_variant)); iree_vm_variant_t actual_variant = iree_vm_variant_empty(); - IREE_CHECK_OK(iree_vm_list_get_variant(actual_list, i, &actual_variant)); + IREE_CHECK_OK( + iree_vm_list_get_variant_assign(actual_list, i, &actual_variant)); bool did_match = iree_tooling_compare_variants( (int)i, expected_variant, actual_variant, host_allocator, /*max_element_count=*/1024, builder);
diff --git a/runtime/src/iree/tooling/trace_replay.c b/runtime/src/iree/tooling/trace_replay.c index 67760a1..64fe7a3 100644 --- a/runtime/src/iree/tooling/trace_replay.c +++ b/runtime/src/iree/tooling/trace_replay.c
@@ -387,7 +387,7 @@ iree_vm_variant_t variant = iree_vm_variant_empty(); variant.type.value_type = IREE_VM_VALUE_TYPE_I8; variant.i8 = (int8_t)value; - return iree_vm_list_push_variant(target_list, &variant); + return iree_vm_list_push_variant_move(target_list, &variant); } IREE_RETURN_IF_ERROR(iree_yaml_mapping_try_find(document, value_node, IREE_SV("i16"), &data_node)); @@ -402,7 +402,7 @@ iree_vm_variant_t variant = iree_vm_variant_empty(); variant.type.value_type = IREE_VM_VALUE_TYPE_I16; variant.i16 = (int16_t)value; - return iree_vm_list_push_variant(target_list, &variant); + return iree_vm_list_push_variant_move(target_list, &variant); } IREE_RETURN_IF_ERROR(iree_yaml_mapping_try_find(document, value_node, IREE_SV("i32"), &data_node)); @@ -415,7 +415,7 @@ IREE_STATUS_INVALID_ARGUMENT, "failed to parse i32 value: '%.*s'", (int)data_node->data.scalar.length, data_node->data.scalar.value); } - return iree_vm_list_push_variant(target_list, &variant); + return iree_vm_list_push_variant_move(target_list, &variant); } IREE_RETURN_IF_ERROR(iree_yaml_mapping_try_find(document, value_node, IREE_SV("i64"), &data_node)); @@ -428,7 +428,7 @@ IREE_STATUS_INVALID_ARGUMENT, "failed to parse i64 value: '%.*s'", (int)data_node->data.scalar.length, data_node->data.scalar.value); } - return iree_vm_list_push_variant(target_list, &variant); + return iree_vm_list_push_variant_move(target_list, &variant); } IREE_RETURN_IF_ERROR(iree_yaml_mapping_try_find(document, value_node, IREE_SV("f32"), &data_node)); @@ -441,7 +441,7 @@ IREE_STATUS_INVALID_ARGUMENT, "failed to parse f32 value: '%.*s'", (int)data_node->data.scalar.length, data_node->data.scalar.value); } - return iree_vm_list_push_variant(target_list, &variant); + return iree_vm_list_push_variant_move(target_list, &variant); } IREE_RETURN_IF_ERROR(iree_yaml_mapping_try_find(document, value_node, IREE_SV("f64"), &data_node)); @@ -454,7 +454,7 @@ IREE_STATUS_INVALID_ARGUMENT, "failed to parse f64 value: '%.*s'", (int)data_node->data.scalar.length, data_node->data.scalar.value); } - return iree_vm_list_push_variant(target_list, &variant); + return iree_vm_list_push_variant_move(target_list, &variant); } return iree_make_status(IREE_STATUS_UNIMPLEMENTED, "(%zu): unimplemented scalar type parser", @@ -937,7 +937,7 @@ iree_string_view_t type = iree_yaml_node_as_string(type_node); if (iree_string_view_equal(type, IREE_SV("null"))) { iree_vm_variant_t null_value = iree_vm_variant_empty(); - return iree_vm_list_push_variant(target_list, &null_value); + return iree_vm_list_push_variant_move(target_list, &null_value); } else if (iree_string_view_equal(type, IREE_SV("value"))) { return iree_trace_replay_parse_scalar(replay, document, value_node, target_list); @@ -1007,7 +1007,7 @@ iree_vm_list_t* list, iree_allocator_t host_allocator) { for (iree_host_size_t i = 0; i < iree_vm_list_size(list); ++i) { iree_vm_variant_t variant = iree_vm_variant_empty(); - IREE_RETURN_IF_ERROR(iree_vm_list_get_variant(list, i, &variant), + IREE_RETURN_IF_ERROR(iree_vm_list_get_variant_assign(list, i, &variant), "variant %zu not present", i); IREE_RETURN_IF_ERROR( iree_trace_replay_print_item(&variant, host_allocator));
diff --git a/runtime/src/iree/tooling/vm_util.c b/runtime/src/iree/tooling/vm_util.c index 3052b9b..39dd4f5 100644 --- a/runtime/src/iree/tooling/vm_util.c +++ b/runtime/src/iree/tooling/vm_util.c
@@ -376,7 +376,7 @@ for (iree_host_size_t i = 0; i < iree_vm_list_size(list); ++i) { iree_vm_variant_t variant = iree_vm_variant_empty(); IREE_RETURN_AND_END_ZONE_IF_ERROR( - z0, iree_vm_list_get_variant(list, i, &variant), + z0, iree_vm_list_get_variant_assign(list, i, &variant), "variant %zu not present", i); iree_string_builder_append_format(builder, "result[%zu]: ", i); IREE_RETURN_AND_END_ZONE_IF_ERROR( @@ -482,7 +482,7 @@ for (iree_host_size_t i = 0; i < output_strings_count; ++i) { iree_vm_variant_t variant = iree_vm_variant_empty(); IREE_RETURN_AND_END_ZONE_IF_ERROR( - z0, iree_vm_list_get_variant(list, i, &variant)); + z0, iree_vm_list_get_variant_assign(list, i, &variant)); IREE_RETURN_AND_END_ZONE_IF_ERROR( z0, iree_tooling_output_variant(variant, output_strings[i], max_element_count, file));
diff --git a/runtime/src/iree/vm/BUILD b/runtime/src/iree/vm/BUILD index 1fac929..3969e8d 100644 --- a/runtime/src/iree/vm/BUILD +++ b/runtime/src/iree/vm/BUILD
@@ -75,6 +75,7 @@ "stack.h", "type_def.h", "value.h", + "variant.h", ], deps = [ "//runtime/src/iree/base",
diff --git a/runtime/src/iree/vm/CMakeLists.txt b/runtime/src/iree/vm/CMakeLists.txt index b0447c3..48013b5 100644 --- a/runtime/src/iree/vm/CMakeLists.txt +++ b/runtime/src/iree/vm/CMakeLists.txt
@@ -51,6 +51,7 @@ "stack.h" "type_def.h" "value.h" + "variant.h" SRCS "buffer.c" "context.c"
diff --git a/runtime/src/iree/vm/api.h b/runtime/src/iree/vm/api.h index 87e5750..45a0d39 100644 --- a/runtime/src/iree/vm/api.h +++ b/runtime/src/iree/vm/api.h
@@ -20,5 +20,6 @@ #include "iree/vm/stack.h" // IWYU pragma: export #include "iree/vm/type_def.h" // IWYU pragma: export #include "iree/vm/value.h" // IWYU pragma: export +#include "iree/vm/variant.h" // IWYU pragma: export #endif // IREE_VM_API_H_
diff --git a/runtime/src/iree/vm/list.c b/runtime/src/iree/vm/list.c index 0dafa55..cc4b703 100644 --- a/runtime/src/iree/vm/list.c +++ b/runtime/src/iree/vm/list.c
@@ -925,34 +925,60 @@ return iree_ok_status(); } -IREE_API_EXPORT iree_status_t -iree_vm_list_get_variant(const iree_vm_list_t* list, iree_host_size_t i, - iree_vm_variant_t* out_value) { +typedef enum { + IREE_VM_LIST_REF_ASSIGN = 0, + IREE_VM_LIST_REF_RETAIN, + IREE_VM_LIST_REF_MOVE, +} iree_vm_list_ref_mode_t; + +static void iree_vm_list_ref_op(iree_vm_list_ref_mode_t mode, + iree_vm_ref_t* ref, iree_vm_ref_t* out_ref) { + switch (mode) { + case IREE_VM_LIST_REF_ASSIGN: + iree_vm_ref_assign(ref, out_ref); + break; + case IREE_VM_LIST_REF_RETAIN: + iree_vm_ref_retain(ref, out_ref); + break; + case IREE_VM_LIST_REF_MOVE: + iree_vm_ref_move(ref, out_ref); + break; + } +} + +static iree_status_t iree_vm_list_get_variant(const iree_vm_list_t* list, + iree_host_size_t i, + iree_vm_list_ref_mode_t ref_mode, + iree_vm_variant_t* out_variant) { + IREE_ASSERT_ARGUMENT(list); + IREE_ASSERT_ARGUMENT(out_variant); if (i >= list->count) { return iree_make_status(IREE_STATUS_OUT_OF_RANGE, "index %zu out of bounds (%zu)", i, list->count); } + iree_vm_variant_reset(out_variant); uintptr_t element_ptr = (uintptr_t)list->storage + i * list->element_size; switch (list->storage_mode) { case IREE_VM_LIST_STORAGE_MODE_VALUE: { - out_value->type = list->element_type; - memcpy(out_value->value_storage, (void*)element_ptr, list->element_size); + out_variant->type = list->element_type; + memcpy(out_variant->value_storage, (void*)element_ptr, + list->element_size); break; } case IREE_VM_LIST_STORAGE_MODE_REF: { iree_vm_ref_t* element_ref = (iree_vm_ref_t*)element_ptr; - out_value->type.ref_type = element_ref->type; - out_value->type.value_type = IREE_VM_VALUE_TYPE_NONE; - iree_vm_ref_assign(element_ref, &out_value->ref); + out_variant->type.ref_type = element_ref->type; + out_variant->type.value_type = IREE_VM_VALUE_TYPE_NONE; + iree_vm_list_ref_op(ref_mode, element_ref, &out_variant->ref); break; } case IREE_VM_LIST_STORAGE_MODE_VARIANT: { iree_vm_variant_t* variant = (iree_vm_variant_t*)element_ptr; - out_value->type = variant->type; + out_variant->type = variant->type; if (iree_vm_type_def_is_ref(&variant->type)) { - iree_vm_ref_assign(&variant->ref, &out_value->ref); + iree_vm_list_ref_op(ref_mode, &variant->ref, &out_variant->ref); } else { - memcpy(out_value->value_storage, variant->value_storage, + memcpy(out_variant->value_storage, variant->value_storage, sizeof(variant->value_storage)); } break; @@ -963,17 +989,80 @@ return iree_ok_status(); } -IREE_API_EXPORT iree_status_t iree_vm_list_set_variant( - iree_vm_list_t* list, iree_host_size_t i, const iree_vm_variant_t* value) { - return iree_make_status(IREE_STATUS_UNIMPLEMENTED, - "iree_vm_list_set_variant unimplemented"); +IREE_API_EXPORT iree_status_t +iree_vm_list_get_variant_assign(const iree_vm_list_t* list, iree_host_size_t i, + iree_vm_variant_t* out_variant) { + return iree_vm_list_get_variant(list, i, IREE_VM_LIST_REF_ASSIGN, + out_variant); } -IREE_API_EXPORT iree_status_t iree_vm_list_push_variant( - iree_vm_list_t* list, const iree_vm_variant_t* value) { +IREE_API_EXPORT iree_status_t +iree_vm_list_get_variant_retain(const iree_vm_list_t* list, iree_host_size_t i, + iree_vm_variant_t* out_variant) { + return iree_vm_list_get_variant(list, i, IREE_VM_LIST_REF_RETAIN, + out_variant); +} + +IREE_API_EXPORT iree_status_t +iree_vm_list_get_variant_move(const iree_vm_list_t* list, iree_host_size_t i, + iree_vm_variant_t* out_variant) { + return iree_vm_list_get_variant(list, i, IREE_VM_LIST_REF_MOVE, out_variant); +} + +static iree_status_t iree_vm_list_set_variant(iree_vm_list_t* list, + iree_host_size_t i, bool is_move, + iree_vm_variant_t* variant) { + if (iree_vm_type_def_is_variant(&variant->type)) { + iree_vm_value_t value = iree_vm_variant_value(*variant); + return iree_vm_list_set_value(list, i, &value); + } else if (iree_vm_type_def_is_value(&variant->type)) { + iree_vm_value_t value = { + .type = variant->type.value_type, + }; + memcpy(value.value_storage, variant->value_storage, + sizeof(value.value_storage)); + return iree_vm_list_set_value(list, i, &value); + } else if (iree_vm_type_def_is_ref(&variant->type)) { + iree_status_t status = + iree_vm_list_set_ref(list, i, is_move, &variant->ref); + if (iree_status_is_ok(status) && is_move) { + variant->type.ref_type = IREE_VM_REF_TYPE_NULL; + } + return status; + } else { + return iree_make_status(IREE_STATUS_UNIMPLEMENTED, + "unhandled variant value type"); + } +} + +IREE_API_EXPORT iree_status_t +iree_vm_list_set_variant_retain(iree_vm_list_t* list, iree_host_size_t i, + const iree_vm_variant_t* variant) { + return iree_vm_list_set_variant(list, i, /*is_move=*/false, + (iree_vm_variant_t*)variant); +} + +IREE_API_EXPORT iree_status_t iree_vm_list_set_variant_move( + iree_vm_list_t* list, iree_host_size_t i, iree_vm_variant_t* variant) { + return iree_vm_list_set_variant(list, i, /*is_move=*/true, variant); +} + +static iree_status_t iree_vm_list_push_variant( + iree_vm_list_t* list, bool is_move, const iree_vm_variant_t* variant) { iree_host_size_t i = iree_vm_list_size(list); IREE_RETURN_IF_ERROR(iree_vm_list_resize(list, i + 1)); - return iree_vm_list_set_variant(list, i, value); + return iree_vm_list_set_variant(list, i, is_move, + (iree_vm_variant_t*)variant); +} + +IREE_API_EXPORT iree_status_t iree_vm_list_push_variant_retain( + iree_vm_list_t* list, const iree_vm_variant_t* variant) { + return iree_vm_list_push_variant(list, /*is_move=*/false, variant); +} + +IREE_API_EXPORT iree_status_t iree_vm_list_push_variant_move( + iree_vm_list_t* list, iree_vm_variant_t* variant) { + return iree_vm_list_push_variant(list, /*is_move=*/true, variant); } iree_status_t iree_vm_list_register_types(iree_vm_instance_t* instance) {
diff --git a/runtime/src/iree/vm/list.h b/runtime/src/iree/vm/list.h index b7d2ba3..3b9b176 100644 --- a/runtime/src/iree/vm/list.h +++ b/runtime/src/iree/vm/list.h
@@ -13,6 +13,7 @@ #include "iree/vm/ref.h" #include "iree/vm/type_def.h" #include "iree/vm/value.h" +#include "iree/vm/variant.h" #ifdef __cplusplus extern "C" { @@ -202,22 +203,48 @@ // a ref it will *not* be retained and the caller must retain it to extend its // lifetime. IREE_API_EXPORT iree_status_t -iree_vm_list_get_variant(const iree_vm_list_t* list, iree_host_size_t i, - iree_vm_variant_t* out_value); +iree_vm_list_get_variant_assign(const iree_vm_list_t* list, iree_host_size_t i, + iree_vm_variant_t* out_variant); + +// Returns the value of the element at the given index. +// If the variant is a ref then it will be retained. +IREE_API_EXPORT iree_status_t +iree_vm_list_get_variant_retain(const iree_vm_list_t* list, iree_host_size_t i, + iree_vm_variant_t* out_variant); + +// Returns the value of the element at the given index. +// If the variant is a ref then it will be moved. +IREE_API_EXPORT iree_status_t +iree_vm_list_get_variant_move(const iree_vm_list_t* list, iree_host_size_t i, + iree_vm_variant_t* out_variant); // Sets the value of the element at the given index. If the specified |value| // type differs from the list storage type the value will be converted using the // value type semantics (such as sign/zero extend, etc). If the variant is a ref // then it will be retained. -IREE_API_EXPORT iree_status_t iree_vm_list_set_variant( - iree_vm_list_t* list, iree_host_size_t i, const iree_vm_variant_t* value); +IREE_API_EXPORT iree_status_t iree_vm_list_set_variant_retain( + iree_vm_list_t* list, iree_host_size_t i, const iree_vm_variant_t* variant); + +// Sets the value of the element at the given index. If the specified |value| +// type differs from the list storage type the value will be converted using the +// value type semantics (such as sign/zero extend, etc). If the variant is a ref +// then it will be moved. +IREE_API_EXPORT iree_status_t iree_vm_list_set_variant_move( + iree_vm_list_t* list, iree_host_size_t i, iree_vm_variant_t* variant); // Pushes the value of the element to the end of the list. If the specified -// |value| type differs from the list storage type the value will be converted +// |variant| type differs from the list storage type the value will be converted // using the value type semantics (such as sign/zero extend, etc). If the // variant is a ref then it will be retained. -IREE_API_EXPORT iree_status_t -iree_vm_list_push_variant(iree_vm_list_t* list, const iree_vm_variant_t* value); +IREE_API_EXPORT iree_status_t iree_vm_list_push_variant_retain( + iree_vm_list_t* list, const iree_vm_variant_t* variant); + +// Pushes the value of the element to the end of the list. If the specified +// |variant| type differs from the list storage type the value will be converted +// using the value type semantics (such as sign/zero extend, etc). If the +// variant is a ref then it will be moved. +IREE_API_EXPORT iree_status_t iree_vm_list_push_variant_move( + iree_vm_list_t* list, iree_vm_variant_t* variant); #ifdef __cplusplus } // extern "C"
diff --git a/runtime/src/iree/vm/list_test.cc b/runtime/src/iree/vm/list_test.cc index f20bc06..a18c4f5 100644 --- a/runtime/src/iree/vm/list_test.cc +++ b/runtime/src/iree/vm/list_test.cc
@@ -101,7 +101,7 @@ result.resize(iree_vm_list_size(list)); for (iree_host_size_t i = 0; i < result.size(); ++i) { iree_vm_variant_t variant = iree_vm_variant_empty(); - IREE_CHECK_OK(iree_vm_list_get_variant(list, i, &variant)); + IREE_CHECK_OK(iree_vm_list_get_variant_assign(list, i, &variant)); if (iree_vm_type_def_is_value(&variant.type)) { result[i].type = variant.type.value_type; memcpy(result[i].value_storage, variant.value_storage, @@ -622,7 +622,7 @@ IREE_ASSERT_OK(iree_vm_list_resize(list, 5)); for (iree_host_size_t i = 0; i < 5; ++i) { iree_vm_variant_t value = iree_vm_variant_empty(); - IREE_ASSERT_OK(iree_vm_list_get_variant(list, i, &value)); + IREE_ASSERT_OK(iree_vm_list_get_variant_assign(list, i, &value)); EXPECT_TRUE(iree_vm_variant_is_empty(value)); } @@ -655,7 +655,7 @@ } for (iree_host_size_t i = 2; i < 5; ++i) { iree_vm_variant_t value = iree_vm_variant_empty(); - IREE_ASSERT_OK(iree_vm_list_get_variant(list, i, &value)); + IREE_ASSERT_OK(iree_vm_list_get_variant_assign(list, i, &value)); EXPECT_TRUE(iree_vm_variant_is_empty(value)); }
diff --git a/runtime/src/iree/vm/type_def.h b/runtime/src/iree/vm/type_def.h index d8cc8b6..3de996c 100644 --- a/runtime/src/iree/vm/type_def.h +++ b/runtime/src/iree/vm/type_def.h
@@ -58,32 +58,6 @@ ((v)->value_type == IREE_VM_VALUE_TYPE_NONE && \ (v)->ref_type == IREE_VM_REF_TYPE_NULL) -// An variant value that can be either a primitive value type or a ref type. -// Each variant value stores its type but users are required to check the type -// prior to accessing any of the data. -typedef struct iree_vm_variant_t { - iree_vm_type_def_t type; - union { - // TODO(benvanik): replace with iree_vm_value_t. - int8_t i8; - int16_t i16; - int32_t i32; - int64_t i64; - float f32; - double f64; - iree_vm_ref_t ref; - - uint8_t value_storage[IREE_VM_VALUE_STORAGE_SIZE]; // max size of all value - // types - }; -} iree_vm_variant_t; - -#define iree_vm_variant_empty() \ - { {IREE_VM_VALUE_TYPE_NONE, IREE_VM_REF_TYPE_NULL}, {0}, } -#define iree_vm_variant_is_value(v) iree_vm_type_def_is_value(&(v).type) -#define iree_vm_variant_is_ref(v) iree_vm_type_def_is_ref(&(v).type) -#define iree_vm_variant_is_empty(v) iree_vm_type_def_is_variant(&(v).type) - #ifdef __cplusplus } // extern "C" #endif // __cplusplus
diff --git a/runtime/src/iree/vm/variant.h b/runtime/src/iree/vm/variant.h new file mode 100644 index 0000000..dfff9ed --- /dev/null +++ b/runtime/src/iree/vm/variant.h
@@ -0,0 +1,103 @@ +// Copyright 2023 The IREE Authors +// +// Licensed under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception + +#ifndef IREE_VM_VARIANT_H_ +#define IREE_VM_VARIANT_H_ + +#include "iree/vm/ref.h" +#include "iree/vm/value.h" + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +// An variant value that can be either a primitive value type or a ref type. +// Each variant value stores its type but users are required to check the type +// prior to accessing any of the data. +typedef struct iree_vm_variant_t { + iree_vm_type_def_t type; + union { + // TODO(benvanik): replace with iree_vm_value_t. Don't want to pay for 2x + // the type storage, though. + int8_t i8; + int16_t i16; + int32_t i32; + int64_t i64; + float f32; + double f64; + iree_vm_ref_t ref; + uint8_t value_storage[IREE_VM_VALUE_STORAGE_SIZE]; // max size of all value + // types + }; +} iree_vm_variant_t; + +// Returns an empty variant. +static inline iree_vm_variant_t iree_vm_variant_empty(void) { + iree_vm_variant_t result; + result.type = iree_vm_type_def_make_variant_type(); + result.ref = iree_vm_ref_null(); + return result; +} + +// Returns true if |variant| is empty (no value/NULL ref). +static inline bool iree_vm_variant_is_empty(iree_vm_variant_t variant) { + return iree_vm_type_def_is_variant(&variant.type); +} + +// Returns true if |variant| represents a primitive value. +static inline bool iree_vm_variant_is_value(iree_vm_variant_t variant) { + return iree_vm_type_def_is_value(&variant.type); +} + +// Returns true if |variant| represents a non-NULL ref type. +static inline bool iree_vm_variant_is_ref(iree_vm_variant_t variant) { + return iree_vm_type_def_is_ref(&variant.type); +} + +// Makes a variant containing the given primitive |value|. +static inline iree_vm_variant_t iree_vm_make_variant_value( + iree_vm_value_t value) { + iree_vm_variant_t result = iree_vm_variant_empty(); + result.type.value_type = value.type; + memcpy(result.value_storage, value.value_storage, + sizeof(result.value_storage)); + return result; +} + +// Makes a variant containing the given |ref| type with assignment semantics. +static inline iree_vm_variant_t iree_vm_make_variant_ref_assign( + iree_vm_ref_t ref) { + iree_vm_variant_t result = iree_vm_variant_empty(); + result.type.ref_type = ref.type; + result.ref = ref; + return result; +} + +// Returns the primitive value contained within |variant|, if any. +// If the variant is not a value type the return will be the same as +// iree_vm_value_make_none. +static inline iree_vm_value_t iree_vm_variant_value(iree_vm_variant_t variant) { + iree_vm_value_t value; + value.type = variant.type.value_type; + memcpy(value.value_storage, variant.value_storage, + sizeof(value.value_storage)); + return value; +} + +// Resets |variant| to empty in-place and releases the contained ref, if set. +static inline void iree_vm_variant_reset(iree_vm_variant_t* variant) { + if (!variant) return; + if (iree_vm_variant_is_ref(*variant)) { + iree_vm_ref_release(&variant->ref); + } + *variant = iree_vm_variant_empty(); +} + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif // IREE_VM_VARIANT_H_
diff --git a/tools/iree-e2e-matmul-test.c b/tools/iree-e2e-matmul-test.c index e77a89c..3615249 100644 --- a/tools/iree-e2e-matmul-test.c +++ b/tools/iree-e2e-matmul-test.c
@@ -166,7 +166,7 @@ iree_vm_list_t* list, iree_host_size_t i, iree_hal_buffer_view_t** out_value) { iree_vm_variant_t variant = iree_vm_variant_empty(); - IREE_RETURN_IF_ERROR(iree_vm_list_get_variant(list, i, &variant)); + IREE_RETURN_IF_ERROR(iree_vm_list_get_variant_assign(list, i, &variant)); if (!iree_vm_variant_is_ref(variant)) { return iree_make_status(IREE_STATUS_INVALID_ARGUMENT, "expected list item %zu to be a ref", i);