diff --git a/runtime/src/iree/builtins/ukernel/common.c b/runtime/src/iree/builtins/ukernel/common.c
index 940f363..86af4c6 100644
--- a/runtime/src/iree/builtins/ukernel/common.c
+++ b/runtime/src/iree/builtins/ukernel/common.c
@@ -6,8 +6,11 @@
 
 #include "iree/builtins/ukernel/common.h"
 
+#ifdef IREE_UK_ENABLE_VALIDATION
 IREE_UK_EXPORT const char* iree_uk_status_message(iree_uk_status_t status) {
   switch (status) {
+    case iree_uk_status_ok:
+      return "OK";
     case iree_uk_status_bad_flags:
       return "bad mmt4d flags";
     case iree_uk_status_bad_type:
@@ -22,3 +25,4 @@
       return "unknown";
   }
 }
+#endif
diff --git a/runtime/src/iree/builtins/ukernel/common.h b/runtime/src/iree/builtins/ukernel/common.h
index 5a04e3b..f5e5c13 100644
--- a/runtime/src/iree/builtins/ukernel/common.h
+++ b/runtime/src/iree/builtins/ukernel/common.h
@@ -110,6 +110,19 @@
 // Attributes and metadata
 //===----------------------------------------------------------------------===//
 
+// Queries for [[attribute]] identifiers in modern compilers.
+#ifdef __has_attribute
+#define IREE_UK_HAVE_ATTRIBUTE(x) __has_attribute(x)
+#else
+#define IREE_UK_HAVE_ATTRIBUTE(x) 0
+#endif  // __has_attribute
+
+#ifdef __has_builtin
+#define IREE_UK_HAVE_BUILTIN(x) __has_builtin(x)
+#else
+#define IREE_UK_HAVE_BUILTIN(x) 0
+#endif  // __has_builtin
+
 // Tagged on functions that are part of the public API.
 // TODO(benvanik): use this to change symbol visibility? We don't want a library
 // that embeds this one to transitively export functions but may want to have
@@ -130,6 +143,58 @@
 #define IREE_UK_RESTRICT restrict
 #endif  // _MSC_VER
 
+// Same as LLVM_BUILTIN_UNREACHABLE. Extremely dangerous. Use only in locations
+// that are provably unreachable (+/- edge case of unreachable-past-assertions
+// discussed below).
+//
+// The potential benefit of UNREACHABLE statements is code size and/or speed
+// optimization. This is an arcane optimization. As such, each use must be
+// carefully justified.
+//
+// There is the edge case of locations that are provably unreachable when
+// optional validation code is enabled, but the validation code may also be
+// disabled, making the location technically reachable. Typically: assertions.
+// Use careful judgement for such cases.
+//
+// A typical use case in microkernels is as follows. A microkernel is
+// parametrized by type triples packed into uint32s, and needs to have a switch
+// statement on those:
+//
+// switch (params->type_triple) {
+//   case iree_uk_mykernel_f32f32f32:  // 0xf5f5f5
+//     return 123;
+//   case iree_uk_mykernel_i8i8i32:  // 0x232325
+//     return 321;
+//   default:
+//     return 0;
+// }
+//
+// As long as the microkernel has validation code (running at least as Debug
+// assertions) validating type_triple, and this code is already past that,
+// and this switch statement covers all valid cases, the `default:` case should
+// be unreachable. Adding an UNREACHABLE statement there can help with code
+// size. This would be negligible if the case constants were small enough to
+// fit in compare-with-immediate instructions, but the 24-bit type triple
+// constants here would typically not, so without UNREACHABLE, the compiler has
+// to fully implement each 24-bit literal separately.
+//
+// https://godbolt.org/z/hTv4qqbx9 shows a snipped similar as above where
+// the __builtin_unreachable shrinks the AArch64 code from 11 to 7 instructions.
+#if IREE_UK_HAVE_BUILTIN(__builtin_unreachable) || defined(__GNUC__)
+#define IREE_UK_ASSUME_UNREACHABLE __builtin_unreachable()
+#elif defined(_MSC_VER)
+#define IREE_UK_ASSUME_UNREACHABLE __assume(false)
+#else
+#define IREE_UK_ASSUME_UNREACHABLE
+#endif
+
+#if IREE_UK_HAVE_ATTRIBUTE(noinline) || \
+    (defined(__GNUC__) && !defined(__clang__))
+#define IREE_UK_ATTRIBUTE_NOINLINE __attribute__((noinline))
+#else
+#define IREE_UK_ATTRIBUTE_NOINLINE
+#endif  // IREE_UK_HAVE_ATTRIBUTE(noinline)
+
 //===----------------------------------------------------------------------===//
 // Local replacements for stdint.h types and constants
 // Refer to the comment at the top of this file for why we can't include
@@ -216,17 +281,56 @@
 // Status codes returned by microkernels.
 //===----------------------------------------------------------------------===//
 
+// When IREE_UK_ENABLE_VALIDATION is defined, ukernels validate their inputs and
+// may return statuses other than iree_uk_status_ok.
+//
+// When IREE_UK_ENABLE_VALIDATION is not defined, statuses other than
+// iree_uk_status_ok are not even defined.
+//
+// Currently IREE_UK_ENABLE_VALIDATION is defined if and only if NDEBUG is not,
+// that is, validation treated as assertions, disabling them in release.
+//
+// This actually enables more thorough validation as it removes optimization
+// concerns from the validation code. Microkernels take raw
+// pointers/sizes/strides anyway, so if params are incorrect, UB will happen no
+// matter how much we try to validate.
+#ifndef NDEBUG
+#define IREE_UK_ENABLE_VALIDATION
+#endif
+
+// Status codes that ukernels may return.
 typedef enum iree_uk_status_e {
   iree_uk_status_ok = 0,
+#ifdef IREE_UK_ENABLE_VALIDATION
   iree_uk_status_bad_type,
   iree_uk_status_bad_flags,
   iree_uk_status_unsupported_huge_or_negative_dimension,
   iree_uk_status_unsupported_generic_tile_size,
   iree_uk_status_shapes_mismatch,
+#endif
 } iree_uk_status_t;
 
+#ifdef IREE_UK_ENABLE_VALIDATION
 // Convert a status code to a human-readable string.
 IREE_UK_EXPORT const char* iree_uk_status_message(iree_uk_status_t status);
+#else
+static inline const char* iree_uk_status_message(iree_uk_status_t status) {
+  // Typical callers do:
+  //
+  //   iree_uk_status_t status = iree_uk_someukernel(&ukernel_params);
+  //   if (status != iree_uk_status_ok) {
+  //     return iree_make_status(IREE_STATUS_INTERNAL,
+  //                             iree_uk_status_message(status));
+  //   }
+  //
+  // The below UNREACHABLE actually helps Clang 16 elide the caller's
+  // `if (status != iree_uk_status_ok)` branch: https://godbolt.org/z/xoanddxrv
+  if (status != iree_uk_status_ok) {
+    IREE_UK_ASSUME_UNREACHABLE;
+  }
+  return "OK";
+}
+#endif
 
 #define IREE_UK_RETURN_IF_ERROR(X)     \
   do {                                 \
@@ -364,90 +468,33 @@
 }
 
 //===----------------------------------------------------------------------===//
-// Tuples of types, packed into a word.
+// Tuples of types, packed ("tied") into a word.
 //===----------------------------------------------------------------------===//
 
+// Note: the choice of word "tie" echoes C++ std::tie and generally tuple
+// terminology. We used to call that "pack" but that was confusing as that word
+// is also the name of a ukernel, iree_uk_pack.
+
 typedef iree_uk_uint16_t iree_uk_type_pair_t;
 typedef iree_uk_uint32_t iree_uk_type_triple_t;
 
-#define IREE_UK_PACK_2_TYPES(B0, B1) ((B0) + ((B1) << 8))
-#define IREE_UK_PACK_3_TYPES(B0, B1, B2) ((B0) + ((B1) << 8) + ((B2) << 16))
-#define IREE_UK_PACK_2_TYPES_LITERAL(T0, T1) \
-  IREE_UK_PACK_2_TYPES(IREE_UK_TYPE_##T0, IREE_UK_TYPE_##T1)
-#define IREE_UK_PACK_3_TYPES_LITERAL(T0, T1, T2) \
-  IREE_UK_PACK_3_TYPES(IREE_UK_TYPE_##T0, IREE_UK_TYPE_##T1, IREE_UK_TYPE_##T2)
+#define IREE_UK_TIE_2_TYPES(B0, B1) ((B0) + ((B1) << 8))
+#define IREE_UK_TIE_3_TYPES(B0, B1, B2) ((B0) + ((B1) << 8) + ((B2) << 16))
+#define IREE_UK_TIE_2_TYPES_LITERAL(T0, T1) \
+  IREE_UK_TIE_2_TYPES(IREE_UK_TYPE_##T0, IREE_UK_TYPE_##T1)
+#define IREE_UK_TIE_3_TYPES_LITERAL(T0, T1, T2) \
+  IREE_UK_TIE_3_TYPES(IREE_UK_TYPE_##T0, IREE_UK_TYPE_##T1, IREE_UK_TYPE_##T2)
 
-#define IREE_UK_UNPACK_TYPE(POS, WORD) (((WORD) >> (8 * (POS))) & 0xFF)
+#define IREE_UK_UNTIE_TYPE(POS, WORD) (((WORD) >> (8 * (POS))) & 0xFF)
 
-static inline iree_uk_type_t iree_uk_unpack_type(int pos,
-                                                 iree_uk_uint32_t word) {
-  return IREE_UK_UNPACK_TYPE(pos, word);
+static inline iree_uk_type_t iree_uk_untie_type(int pos,
+                                                iree_uk_uint32_t word) {
+  return IREE_UK_UNTIE_TYPE(pos, word);
 }
 
-#ifdef __has_builtin
-#define IREE_UK_HAS_BUILTIN(x) __has_builtin(x)
-#else
-#define IREE_UK_HAS_BUILTIN(x) 0
-#endif
-
-// Same as LLVM_BUILTIN_UNREACHABLE. Extremely dangerous. Use only in locations
-// that are provably unreachable (+/- edge case of unreachable-past-assertions
-// discussed below).
-//
-// The potential benefit of UNREACHABLE statements is code size and/or speed
-// optimization. This is an arcane optimization. As such, each use must be
-// carefully justified.
-//
-// There is the edge case of locations that are provably unreachable when
-// optional validation code is enabled, but the validation code may also be
-// disabled, making the location technically reachable. Typically: assertions.
-// Use careful judgement for such cases.
-//
-// A typical use case in microkernels is as follows. A microkernel is
-// parametrized by type triples packed into uint32s, and needs to have a switch
-// statement on those:
-//
-// switch (params->type_triple) {
-//   case iree_uk_mykernel_f32f32f32:  // 0xf5f5f5
-//     return 123;
-//   case iree_uk_mykernel_i8i8i32:  // 0x232325
-//     return 321;
-//   default:
-//     return 0;
-// }
-//
-// As long as the microkernel has validation code (running at least as Debug
-// assertions) validating type_triple, and this code is already past that,
-// and this switch statement covers all valid cases, the `default:` case should
-// be unreachable. Adding an UNREACHABLE statement there can help with code
-// size. This would be negligible if the case constants were small enough to
-// fit in compare-with-immediate instructions, but the 24-bit type triple
-// constants here would typically not, so without UNREACHABLE, the compiler has
-// to fully implement each 24-bit literal separately.
-//
-// https://godbolt.org/z/hTv4qqbx9 shows a snipped similar as above where
-// the __builtin_unreachable shrinks the AArch64 code from 11 to 7 instructions.
-#if IREE_UK_HAS_BUILTIN(__builtin_unreachable) || defined(__GNUC__)
-#define IREE_UK_ASSUME_UNREACHABLE __builtin_unreachable()
-#elif defined(_MSC_VER)
-#define IREE_UK_ASSUME_UNREACHABLE __assume(false)
-#else
-#define IREE_UK_ASSUME_UNREACHABLE
-#endif
-
-// Queries for [[attribute]] identifiers in modern compilers.
-#ifdef __has_attribute
-#define IREE_UK_HAVE_ATTRIBUTE(x) __has_attribute(x)
-#else
-#define IREE_UK_HAVE_ATTRIBUTE(x) 0
-#endif  // __has_attribute
-
-#if IREE_UK_HAVE_ATTRIBUTE(noinline) || \
-    (defined(__GNUC__) && !defined(__clang__))
-#define IREE_UK_ATTRIBUTE_NOINLINE __attribute__((noinline))
-#else
-#define IREE_UK_ATTRIBUTE_NOINLINE
-#endif  // IREE_UK_HAVE_ATTRIBUTE(noinline)
+//===----------------------------------------------------------------------===//
+// Local replacement for <string.h>
+//===----------------------------------------------------------------------===//
 
 // The `restrict` here have the effect of enabling the compiler to rewrite this
 // as a memcpy call, shrinking code size of the (slow anyway) generic code paths
@@ -459,6 +506,15 @@
     ((char*)dst)[i] = ((const char*)src)[i];
 }
 
+static inline void iree_uk_memset(void* buf, int val, iree_uk_ssize_t n) {
+  // No need for memset builtins: this naive loop is already transformed into a
+  // memset by both clang and gcc on ARM64. As __builtin_memset_inline requires
+  // a compile-time-constant size, it would require writing more complex code,
+  // which could actually prevent the optimization matching it as a single
+  // memset!
+  for (iree_uk_ssize_t i = 0; i < n; ++i) ((char*)buf)[i] = val;
+}
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus
diff --git a/runtime/src/iree/builtins/ukernel/mmt4d.c b/runtime/src/iree/builtins/ukernel/mmt4d.c
index 1e5cb9d..cb3364a 100644
--- a/runtime/src/iree/builtins/ukernel/mmt4d.c
+++ b/runtime/src/iree/builtins/ukernel/mmt4d.c
@@ -13,15 +13,7 @@
 
 static iree_uk_status_t iree_uk_mmt4d_validate(
     const iree_uk_mmt4d_params_t* params) {
-#ifdef NDEBUG
-  // Avoid validation code overhead (code size and latency) in release builds.
-  // This actually enables more thorough validation as it removes optimization
-  // concerns from the validation code.
-  // Microkernels take raw pointers/sizes/strides anyway, so if params are
-  // incorrect, UB will happen no matter how much we try to validate.
-  return iree_uk_status_ok;
-#endif
-
+#ifdef IREE_UK_ENABLE_VALIDATION
   if (params->flags & ~IREE_UK_FLAG_ACCUMULATE) {
     return iree_uk_status_bad_flags;
   }
@@ -52,7 +44,7 @@
   if (tile_bytes > iree_uk_mmt4d_tile_generic_max_bytes) {
     return iree_uk_status_unsupported_generic_tile_size;
   }
-
+#endif  // IREE_UK_ENABLE_VALIDATION
   return iree_uk_status_ok;
 }
 
@@ -105,17 +97,6 @@
   }
 }
 
-// A memset implementation that we can use here, as we can't #include <string.h>
-// as that brings in <stdint.h>. Special-cased for byte value 0.
-void iree_uk_memset_zero(void* buf, iree_uk_ssize_t n) {
-  // No need for memset builtins: this naive loop is already transformed into a
-  // memset by both clang and gcc on ARM64. As __builtin_memset_inline requires
-  // a compile-time-constant size, it would require writing more complex code,
-  // which could actually prevent the optimization matching it as a single
-  // memset!
-  for (iree_uk_ssize_t i = 0; i < n; ++i) ((char*)buf)[i] = 0;
-}
-
 // Helper for early-return path when K==0 and we just need to clear the output.
 static void iree_uk_mmt4d_zero_out(const iree_uk_mmt4d_params_t* params) {
   iree_uk_type_t out_type = iree_uk_mmt4d_out_type(params->type);
@@ -125,7 +106,7 @@
   iree_uk_ssize_t stride = params->out_stride << out_type_size_log2;
   char* out_ptr = params->out_buffer;
   for (iree_uk_ssize_t i = 0; i < params->M; ++i) {
-    iree_uk_memset_zero(out_ptr, contiguous_size);
+    iree_uk_memset(out_ptr, 0, contiguous_size);
     out_ptr += stride;
   }
 }
diff --git a/runtime/src/iree/builtins/ukernel/mmt4d_types.h b/runtime/src/iree/builtins/ukernel/mmt4d_types.h
index 2c2397b..723723f 100644
--- a/runtime/src/iree/builtins/ukernel/mmt4d_types.h
+++ b/runtime/src/iree/builtins/ukernel/mmt4d_types.h
@@ -11,21 +11,21 @@
 
 typedef enum iree_uk_mmt4d_type_t {
   iree_uk_mmt4d_type_f32f32f32 =
-      IREE_UK_PACK_3_TYPES_LITERAL(FLOAT_32, FLOAT_32, FLOAT_32),
+      IREE_UK_TIE_3_TYPES_LITERAL(FLOAT_32, FLOAT_32, FLOAT_32),
   iree_uk_mmt4d_type_i8i8i32 =
-      IREE_UK_PACK_3_TYPES_LITERAL(INT_8, INT_8, INT_32),
+      IREE_UK_TIE_3_TYPES_LITERAL(INT_8, INT_8, INT_32),
 } iree_uk_mmt4d_type_t;
 
 static inline iree_uk_type_t iree_uk_mmt4d_lhs_type(iree_uk_mmt4d_type_t type) {
-  return IREE_UK_UNPACK_TYPE(0, type);
+  return iree_uk_untie_type(0, type);
 }
 
 static inline iree_uk_type_t iree_uk_mmt4d_rhs_type(iree_uk_mmt4d_type_t type) {
-  return IREE_UK_UNPACK_TYPE(1, type);
+  return iree_uk_untie_type(1, type);
 }
 
 static inline iree_uk_type_t iree_uk_mmt4d_out_type(iree_uk_mmt4d_type_t type) {
-  return IREE_UK_UNPACK_TYPE(2, type);
+  return iree_uk_untie_type(2, type);
 }
 
 // Parameters for a mmt4d operation.
diff --git a/runtime/src/iree/builtins/ukernel/pack.c b/runtime/src/iree/builtins/ukernel/pack.c
index 10c06b6..7a1ce3a 100644
--- a/runtime/src/iree/builtins/ukernel/pack.c
+++ b/runtime/src/iree/builtins/ukernel/pack.c
@@ -11,14 +11,7 @@
 
 static iree_uk_status_t iree_uk_pack_validate(
     const iree_uk_pack_params_t* params) {
-#ifdef NDEBUG
-  // Avoid validation code overhead (code size and latency) in release builds.
-  // This actually enables more thorough validation as it removes optimization
-  // concerns from the validation code.
-  // Microkernels take raw pointers/sizes/strides anyway, so if params are
-  // incorrect, UB will happen no matter how much we try to validate.
-  return iree_uk_status_ok;
-#endif
+#ifdef IREE_UK_ENABLE_VALIDATION
   const iree_uk_uint32_t allflags =
       IREE_UK_FLAG_PACK_TRANSPOSE_INNER | IREE_UK_FLAG_PACK_TRANSPOSE_OUTER;
   if (params->flags & ~allflags) {
@@ -55,6 +48,7 @@
       (outer_size1 - 1) * tile_size1 >= params->in_size1) {
     return iree_uk_status_shapes_mismatch;
   }
+#endif  // IREE_UK_ENABLE_VALIDATION
   return iree_uk_status_ok;
 }
 
diff --git a/runtime/src/iree/builtins/ukernel/pack_types.h b/runtime/src/iree/builtins/ukernel/pack_types.h
index fdc7790..f0c4bc5 100644
--- a/runtime/src/iree/builtins/ukernel/pack_types.h
+++ b/runtime/src/iree/builtins/ukernel/pack_types.h
@@ -12,17 +12,17 @@
 #include "iree/builtins/ukernel/common.h"
 
 typedef enum iree_uk_pack_type_t {
-  iree_uk_pack_type_f32f32 = IREE_UK_PACK_2_TYPES_LITERAL(FLOAT_32, FLOAT_32),
-  iree_uk_pack_type_i8i8 = IREE_UK_PACK_2_TYPES_LITERAL(INT_8, INT_8),
-  iree_uk_pack_type_i32i32 = IREE_UK_PACK_2_TYPES_LITERAL(INT_32, INT_32),
+  iree_uk_pack_type_f32f32 = IREE_UK_TIE_2_TYPES_LITERAL(FLOAT_32, FLOAT_32),
+  iree_uk_pack_type_i8i8 = IREE_UK_TIE_2_TYPES_LITERAL(INT_8, INT_8),
+  iree_uk_pack_type_i32i32 = IREE_UK_TIE_2_TYPES_LITERAL(INT_32, INT_32),
 } iree_uk_pack_type_t;
 
 static inline iree_uk_type_t iree_uk_pack_in_type(iree_uk_pack_type_t type) {
-  return IREE_UK_UNPACK_TYPE(0, type);
+  return iree_uk_untie_type(0, type);
 }
 
 static inline iree_uk_type_t iree_uk_pack_out_type(iree_uk_pack_type_t type) {
-  return IREE_UK_UNPACK_TYPE(1, type);
+  return iree_uk_untie_type(1, type);
 }
 
 // Parameters for a pack operation.
diff --git a/runtime/src/iree/builtins/ukernel/tools/ukernel_test_utils.cc b/runtime/src/iree/builtins/ukernel/tools/ukernel_test_utils.cc
index e7e77d4..9e5211a 100644
--- a/runtime/src/iree/builtins/ukernel/tools/ukernel_test_utils.cc
+++ b/runtime/src/iree/builtins/ukernel/tools/ukernel_test_utils.cc
@@ -117,9 +117,9 @@
   char type0_buf[8];
   char type1_buf[8];
   iree_uk_test_type_str(type0_buf, sizeof type0_buf,
-                        iree_uk_unpack_type(0, pair));
+                        iree_uk_untie_type(0, pair));
   iree_uk_test_type_str(type1_buf, sizeof type1_buf,
-                        iree_uk_unpack_type(1, pair));
+                        iree_uk_untie_type(1, pair));
   return snprintf(buf, buf_length, "(%s,%s)", type0_buf, type1_buf);
 }
 
@@ -129,11 +129,11 @@
   char type1_buf[8];
   char type2_buf[8];
   iree_uk_test_type_str(type0_buf, sizeof type0_buf,
-                        iree_uk_unpack_type(0, triple));
+                        iree_uk_untie_type(0, triple));
   iree_uk_test_type_str(type1_buf, sizeof type1_buf,
-                        iree_uk_unpack_type(1, triple));
+                        iree_uk_untie_type(1, triple));
   iree_uk_test_type_str(type2_buf, sizeof type2_buf,
-                        iree_uk_unpack_type(2, triple));
+                        iree_uk_untie_type(2, triple));
   return snprintf(buf, buf_length, "(%s,%s,%s)", type0_buf, type1_buf,
                   type2_buf);
 }
diff --git a/runtime/src/iree/builtins/ukernel/unpack.c b/runtime/src/iree/builtins/ukernel/unpack.c
index ee5ea1a..bf6fdba 100644
--- a/runtime/src/iree/builtins/ukernel/unpack.c
+++ b/runtime/src/iree/builtins/ukernel/unpack.c
@@ -8,14 +8,7 @@
 
 static iree_uk_status_t iree_uk_unpack_validate(
     const iree_uk_unpack_params_t* params) {
-#ifdef NDEBUG
-  // Avoid validation code overhead (code size and latency) in release builds.
-  // This actually enables more thorough validation as it removes optimization
-  // concerns from the validation code.
-  // Microkernels take raw pointers/sizes/strides anyway, so if params are
-  // incorrect, UB will happen no matter how much we try to validate.
-  return iree_uk_status_ok;
-#endif
+#ifdef IREE_UK_ENABLE_VALIDATION
   const iree_uk_uint32_t allflags =
       IREE_UK_FLAG_UNPACK_TRANSPOSE_INNER | IREE_UK_FLAG_UNPACK_TRANSPOSE_OUTER;
   if (params->flags & ~allflags) {
@@ -52,6 +45,7 @@
       (outer_size1 - 1) * tile_size1 >= params->out_size1) {
     return iree_uk_status_shapes_mismatch;
   }
+#endif  // IREE_UK_ENABLE_VALIDATION
   return iree_uk_status_ok;
 }
 
diff --git a/runtime/src/iree/builtins/ukernel/unpack_types.h b/runtime/src/iree/builtins/ukernel/unpack_types.h
index 1a88d77..472b820 100644
--- a/runtime/src/iree/builtins/ukernel/unpack_types.h
+++ b/runtime/src/iree/builtins/ukernel/unpack_types.h
@@ -12,19 +12,19 @@
 #include "iree/builtins/ukernel/common.h"
 
 typedef enum iree_uk_unpack_type_t {
-  iree_uk_unpack_type_f32f32 = IREE_UK_PACK_2_TYPES_LITERAL(FLOAT_32, FLOAT_32),
-  iree_uk_unpack_type_i8i8 = IREE_UK_PACK_2_TYPES_LITERAL(INT_8, INT_8),
-  iree_uk_unpack_type_i32i32 = IREE_UK_PACK_2_TYPES_LITERAL(INT_32, INT_32),
+  iree_uk_unpack_type_f32f32 = IREE_UK_TIE_2_TYPES_LITERAL(FLOAT_32, FLOAT_32),
+  iree_uk_unpack_type_i8i8 = IREE_UK_TIE_2_TYPES_LITERAL(INT_8, INT_8),
+  iree_uk_unpack_type_i32i32 = IREE_UK_TIE_2_TYPES_LITERAL(INT_32, INT_32),
 } iree_uk_unpack_type_t;
 
 static inline iree_uk_type_t iree_uk_unpack_in_type(
     iree_uk_unpack_type_t type) {
-  return IREE_UK_UNPACK_TYPE(0, type);
+  return iree_uk_untie_type(0, type);
 }
 
 static inline iree_uk_type_t iree_uk_unpack_out_type(
     iree_uk_unpack_type_t type) {
-  return IREE_UK_UNPACK_TYPE(1, type);
+  return iree_uk_untie_type(1, type);
 }
 
 // Parameters for a unpack operation.