diff --git a/extension/kernel_util/test/make_boxed_from_unboxed_functor_test.cpp b/extension/kernel_util/test/make_boxed_from_unboxed_functor_test.cpp
index b9176cfc826..3bf4e65ffc6 100644
--- a/extension/kernel_util/test/make_boxed_from_unboxed_functor_test.cpp
+++ b/extension/kernel_util/test/make_boxed_from_unboxed_functor_test.cpp
@@ -25,6 +25,7 @@ using executorch::runtime::EValue;
 using executorch::runtime::get_op_function_from_registry;
 using executorch::runtime::KernelRuntimeContext;
 using executorch::runtime::registry_has_op_function;
+using executorch::runtime::Span;
 using std::optional;
 
 Tensor& my_op_out(KernelRuntimeContext& ctx, const Tensor& a, Tensor& out) {
@@ -117,7 +118,7 @@ TEST_F(MakeBoxedFromUnboxedFunctorTest, UnboxLogicWorks) {
   EValue* stack[1];
   stack[0] = &values[0];
 
-  (*fn)(context, stack);
+  (*fn)(context, Span<EValue*>(stack));
 
   // check result
   EXPECT_EQ(a.const_data_ptr<int32_t>()[0], 1);
@@ -144,7 +145,7 @@ TEST_F(MakeBoxedFromUnboxedFunctorTest, UnboxArrayRef) {
   KernelRuntimeContext context;
   EValue values[2] = {boxed_array_ref, out};
   EValue* stack[2] = {&values[0], &values[1]};
-  (*fn)(context, stack);
+  (*fn)(context, Span<EValue*>(stack));
 
   // check result.
   for (int i = 0; i < 5; i++) {
@@ -170,7 +171,7 @@ TEST_F(MakeBoxedFromUnboxedFunctorTest, UnboxOptional) {
   KernelRuntimeContext context;
   EValue values[3] = {scalar, scalar_none, out};
   EValue* stack[3] = {&values[0], &values[1], &values[2]};
-  (*fn)(context, stack);
+  (*fn)(context, Span<EValue*>(stack));
 
   // check result.
   EXPECT_EQ(stack[2]->toTensor().const_data_ptr<int32_t>()[0], 4);
@@ -197,7 +198,7 @@ TEST_F(MakeBoxedFromUnboxedFunctorTest, UnboxOptionalArrayRef) {
   KernelRuntimeContext context;
   EValue values[2] = {boxed_array_ref, out};
   EValue* stack[2] = {&values[0], &values[1]};
-  (*fn)(context, stack);
+  (*fn)(context, Span<EValue*>(stack));
 
   // check result.
   for (int i = 0; i < 5; i++) {
diff --git a/kernels/prim_ops/test/prim_ops_test.cpp b/kernels/prim_ops/test/prim_ops_test.cpp
index ff0d633fd94..37a4e8b157a 100644
--- a/kernels/prim_ops/test/prim_ops_test.cpp
+++ b/kernels/prim_ops/test/prim_ops_test.cpp
@@ -23,6 +23,7 @@
 using executorch::aten::SizesType;
 using torch::executor::Error;
 using torch::executor::resize_tensor;
+using torch::executor::Span;
 
 namespace torch {
 namespace executor {
@@ -57,7 +58,7 @@ TEST_F(RegisterPrimOpsTest, SymSizeReturnsCorrectValue) {
     stack[i] = &values[i];
   }
 
-  getOpsFn("aten::sym_size.int")(context_, stack);
+  getOpsFn("aten::sym_size.int")(context_, Span<EValue*>(stack));
 
   int64_t expected = 5;
   EXPECT_EQ(stack[2]->toInt(), expected);
@@ -77,7 +78,7 @@ TEST_F(RegisterPrimOpsTest, SymNumelReturnsCorrectValue) {
     stack[i] = &values[i];
   }
 
-  getOpsFn("aten::sym_numel")(context_, stack);
+  getOpsFn("aten::sym_numel")(context_, Span<EValue*>(stack));
 
   int64_t expected = 15;
   EXPECT_EQ(stack[1]->toInt(), expected);
@@ -97,21 +98,21 @@ TEST_F(RegisterPrimOpsTest, SymMaxReturnsCorrectValue) {
     stack[i] = &values[i];
   }
 
-  getOpsFn("executorch_prim::sym_max.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::sym_max.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), 5);
 
   // Test with swapped values
   values[0] = EValue(b);
   values[1] = EValue(a);
   values[2] = EValue(out);
-  getOpsFn("executorch_prim::sym_max.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::sym_max.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), 5);
 
   // Test with equal values
   values[0] = EValue(a);
   values[1] = EValue(a);
   values[2] = EValue(out);
-  getOpsFn("executorch_prim::sym_max.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::sym_max.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), 5);
 
   // Test with negative values
@@ -120,7 +121,7 @@ TEST_F(RegisterPrimOpsTest, SymMaxReturnsCorrectValue) {
   values[0] = EValue(a);
   values[1] = EValue(b);
   values[2] = EValue(out);
-  getOpsFn("executorch_prim::sym_max.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::sym_max.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), -2);
 }
 
@@ -138,21 +139,21 @@ TEST_F(RegisterPrimOpsTest, SymMinReturnsCorrectValue) {
     stack[i] = &values[i];
   }
 
-  getOpsFn("executorch_prim::sym_min.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::sym_min.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), 3);
 
   // Test with swapped values
   values[0] = EValue(b);
   values[1] = EValue(a);
   values[2] = EValue(out);
-  getOpsFn("executorch_prim::sym_min.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::sym_min.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), 3);
 
   // Test with equal values
   values[0] = EValue(a);
   values[1] = EValue(a);
   values[2] = EValue(out);
-  getOpsFn("executorch_prim::sym_min.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::sym_min.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), 5);
 
   // Test with negative values
@@ -161,7 +162,7 @@ TEST_F(RegisterPrimOpsTest, SymMinReturnsCorrectValue) {
   values[0] = EValue(a);
   values[1] = EValue(b);
   values[2] = EValue(out);
-  getOpsFn("executorch_prim::sym_min.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::sym_min.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), -5);
 }
 
@@ -181,28 +182,29 @@ TEST_F(RegisterPrimOpsTest, TestAlgebraOps) {
 
   EValue* stack2[2] = {&values[0], &values[1]};
 
-  getOpsFn("executorch_prim::add.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::add.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), 7);
 
-  getOpsFn("executorch_prim::sub.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::sub.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), -1);
 
-  getOpsFn("executorch_prim::mul.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::mul.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), 12);
 
-  getOpsFn("executorch_prim::floordiv.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::floordiv.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), 0);
 
-  getOpsFn("executorch_prim::truediv.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::truediv.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_FLOAT_EQ(stack[2]->toDouble(), 0.75);
 
-  getOpsFn("executorch_prim::mod.int")(context_, stack);
+  getOpsFn("executorch_prim::mod.int")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), 3);
 
-  getOpsFn("executorch_prim::mod.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::mod.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toInt(), 3);
 
-  getOpsFn("executorch_prim::sym_float.Scalar")(context_, stack2);
+  getOpsFn("executorch_prim::sym_float.Scalar")(
+      context_, Span<EValue*>(stack2));
   EXPECT_FLOAT_EQ(stack[1]->toDouble(), 3.0);
 }
 
@@ -239,7 +241,8 @@ TEST_F(RegisterPrimOpsTest, TestETCopyIndex) {
   stack[2] = &values[2];
 
   // Simple test to copy to index 0.
-  getOpsFn("executorch_prim::et_copy_index.tensor")(context_, stack);
+  getOpsFn("executorch_prim::et_copy_index.tensor")(
+      context_, Span<EValue*>(stack));
 
   EXPECT_EQ(copy_to.sizes()[0], 1);
   EXPECT_EQ(copy_to.sizes()[1], 2);
@@ -248,7 +251,8 @@ TEST_F(RegisterPrimOpsTest, TestETCopyIndex) {
   values[1] = tf.make({2}, {5, 6});
   values[2] = EValue((int64_t)1);
   // Copy to the next index, 1.
-  getOpsFn("executorch_prim::et_copy_index.tensor")(context_, stack);
+  getOpsFn("executorch_prim::et_copy_index.tensor")(
+      context_, Span<EValue*>(stack));
 
   EXPECT_EQ(copy_to.sizes()[0], 2);
   EXPECT_EQ(copy_to.sizes()[1], 2);
@@ -278,7 +282,8 @@ TEST_F(RegisterPrimOpsTest, TestETCopyIndexMismatchShape) {
   // which is a pre-requisite for this operator.
   ET_EXPECT_KERNEL_FAILURE(
       context_,
-      getOpsFn("executorch_prim::et_copy_index.tensor")(context_, stack));
+      getOpsFn("executorch_prim::et_copy_index.tensor")(
+          context_, Span<EValue*>(stack)));
 }
 
 TEST_F(RegisterPrimOpsTest, TestBooleanOps) {
@@ -295,19 +300,19 @@ TEST_F(RegisterPrimOpsTest, TestBooleanOps) {
     stack[i] = &values[i];
   }
 
-  getOpsFn("executorch_prim::ge.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::ge.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toBool(), false);
 
-  getOpsFn("executorch_prim::gt.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::gt.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toBool(), false);
 
-  getOpsFn("executorch_prim::le.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::le.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toBool(), true);
 
-  getOpsFn("executorch_prim::lt.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::lt.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toBool(), true);
 
-  getOpsFn("executorch_prim::eq.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::eq.Scalar")(context_, Span<EValue*>(stack));
   EXPECT_EQ(stack[2]->toBool(), false);
 }
 
@@ -326,7 +331,7 @@ TEST_F(RegisterPrimOpsTest, LocalScalarDenseReturnsCorrectValue) {
     stack[i] = &values[i];
   }
 
-  getOpsFn("aten::_local_scalar_dense")(context_, stack);
+  getOpsFn("aten::_local_scalar_dense")(context_, Span<EValue*>(stack));
 
   int64_t expected = 1;
   EXPECT_EQ(stack[1]->toInt(), expected);
@@ -344,7 +349,7 @@ TEST_F(RegisterPrimOpsTest, NegScalarReturnsCorrectValue) {
     stack[i] = &values[i];
   }
 
-  getOpsFn("executorch_prim::neg.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::neg.Scalar")(context_, Span<EValue*>(stack));
 
   EXPECT_EQ(stack[1]->toDouble(), -5.0f);
 
@@ -354,7 +359,7 @@ TEST_F(RegisterPrimOpsTest, NegScalarReturnsCorrectValue) {
   values[0] = EValue(a);
   values[1] = EValue(b);
 
-  getOpsFn("executorch_prim::neg.Scalar")(context_, stack);
+  getOpsFn("executorch_prim::neg.Scalar")(context_, Span<EValue*>(stack));
 
   EXPECT_EQ(stack[1]->toInt(), -5l);
 }
@@ -377,7 +382,8 @@ TEST_F(RegisterPrimOpsTest, TestNegScalarWithTensorFails) {
 
   // Try to negate a tensor, which should cause a runtime error.
   ET_EXPECT_KERNEL_FAILURE(
-      context_, getOpsFn("executorch_prim::neg.Scalar")(context_, stack));
+      context_,
+      getOpsFn("executorch_prim::neg.Scalar")(context_, Span<EValue*>(stack)));
 }
 
 TEST_F(RegisterPrimOpsTest, TestETView) {
@@ -465,7 +471,8 @@ TEST_F(RegisterPrimOpsTest, TestETView) {
   for (int i = 0; i < N_BAD_STACKS; i++) {
     ET_EXPECT_KERNEL_FAILURE(
         context_,
-        getOpsFn("executorch_prim::et_view.default")(context_, bad_stacks[i]));
+        getOpsFn("executorch_prim::et_view.default")(
+            context_, Span<EValue*>(bad_stacks[i])));
   }
 
   constexpr int N_GOOD_STACKS = N_GOOD_OUTS;
@@ -475,7 +482,8 @@ TEST_F(RegisterPrimOpsTest, TestETView) {
 
   // Good outs expect no death and correct output
   for (int i = 0; i < N_GOOD_STACKS; i++) {
-    getOpsFn("executorch_prim::et_view.default")(context_, good_out_stacks[i]);
+    getOpsFn("executorch_prim::et_view.default")(
+        context_, Span<EValue*>(good_out_stacks[i]));
     EXPECT_TENSOR_EQ(good_outs[i], tf.make({1, 3, 2}, {1, 2, 3, 4, 5, 6}));
     EXPECT_EQ(good_outs[i].const_data_ptr(), self.const_data_ptr());
   }
@@ -510,7 +518,7 @@ TEST_F(RegisterPrimOpsTest, TestETViewDynamic) {
 
   EValue* stack[3] = {&self_evalue, &size_int_list_evalue, &out_evalue};
 
-  getOpsFn("executorch_prim::et_view.default")(context_, stack);
+  getOpsFn("executorch_prim::et_view.default")(context_, Span<EValue*>(stack));
 
   EXPECT_TENSOR_EQ(out, tf.make({1, 3, 1}, {1, 2, 3}));
   EXPECT_EQ(out.const_data_ptr(), self.const_data_ptr());
@@ -549,7 +557,7 @@ TEST_F(RegisterPrimOpsTest, TestETViewEmpty) {
 
   // good size test
   EValue* stack[3] = {&self_evalue, &size_int_list_evalue, &out_evalue};
-  getOpsFn("executorch_prim::et_view.default")(context_, stack);
+  getOpsFn("executorch_prim::et_view.default")(context_, Span<EValue*>(stack));
   EXPECT_TENSOR_EQ(out, tf.make({3, 1, 0}, {}));
   EXPECT_EQ(out.const_data_ptr(), self.const_data_ptr());
 
@@ -557,7 +565,8 @@ TEST_F(RegisterPrimOpsTest, TestETViewEmpty) {
   EValue* bad_stack[3] = {&self_evalue, &bad_size_int_list_evalue, &out_evalue};
   ET_EXPECT_KERNEL_FAILURE(
       context_,
-      getOpsFn("executorch_prim::et_view.default")(context_, bad_stack));
+      getOpsFn("executorch_prim::et_view.default")(
+          context_, Span<EValue*>(bad_stack)));
 }
 
 TEST_F(RegisterPrimOpsTest, TestCeil) {
@@ -575,7 +584,7 @@ TEST_F(RegisterPrimOpsTest, TestCeil) {
       stack[j] = &values[j];
     }
 
-    getOpsFn("executorch_prim::ceil.Scalar")(context_, stack);
+    getOpsFn("executorch_prim::ceil.Scalar")(context_, Span<EValue*>(stack));
     EXPECT_EQ(stack[1]->toInt(), expected[i]);
   }
 }
@@ -596,7 +605,7 @@ TEST_F(RegisterPrimOpsTest, TestRound) {
       stack[j] = &values[j];
     }
 
-    getOpsFn("executorch_prim::round.Scalar")(context_, stack);
+    getOpsFn("executorch_prim::round.Scalar")(context_, Span<EValue*>(stack));
     EXPECT_EQ(stack[1]->toInt(), expected[i]);
   }
 }
@@ -616,7 +625,7 @@ TEST_F(RegisterPrimOpsTest, TestTrunc) {
       stack[j] = &values[j];
     }
 
-    getOpsFn("executorch_prim::trunc.Scalar")(context_, stack);
+    getOpsFn("executorch_prim::trunc.Scalar")(context_, Span<EValue*>(stack));
     EXPECT_EQ(stack[1]->toInt(), expected[i]);
   }
 }
@@ -639,7 +648,8 @@ TEST_F(RegisterPrimOpsTest, TestInvalidProgramErrorOnShortStack) {
     }
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("aten::sym_size.int")(context_, stack));
+        context_,
+        getOpsFn("aten::sym_size.int")(context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), torch::executor::Error::InvalidProgram);
   }
 
@@ -654,7 +664,7 @@ TEST_F(RegisterPrimOpsTest, TestInvalidProgramErrorOnShortStack) {
     stack[0] = &values[0];
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("aten::sym_numel")(context_, stack));
+        context_, getOpsFn("aten::sym_numel")(context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), torch::executor::Error::InvalidProgram);
   }
 
@@ -673,7 +683,9 @@ TEST_F(RegisterPrimOpsTest, TestInvalidProgramErrorOnShortStack) {
     }
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::sym_max.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::sym_max.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
   }
 
@@ -692,7 +704,9 @@ TEST_F(RegisterPrimOpsTest, TestInvalidProgramErrorOnShortStack) {
     }
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::sym_min.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::sym_min.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
   }
 
@@ -710,32 +724,44 @@ TEST_F(RegisterPrimOpsTest, TestInvalidProgramErrorOnShortStack) {
     }
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::add.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::add.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::sub.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::sub.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::mul.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::mul.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
 
     ET_EXPECT_KERNEL_FAILURE(
         context_,
-        getOpsFn("executorch_prim::floordiv.Scalar")(context_, stack));
+        getOpsFn("executorch_prim::floordiv.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::truediv.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::truediv.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::mod.int")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::mod.int")(context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::mod.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::mod.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
   }
 
@@ -751,7 +777,8 @@ TEST_F(RegisterPrimOpsTest, TestInvalidProgramErrorOnShortStack) {
 
     ET_EXPECT_KERNEL_FAILURE(
         context_,
-        getOpsFn("executorch_prim::sym_float.Scalar")(context_, stack));
+        getOpsFn("executorch_prim::sym_float.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
   }
 
@@ -769,23 +796,28 @@ TEST_F(RegisterPrimOpsTest, TestInvalidProgramErrorOnShortStack) {
     }
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::ge.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::ge.Scalar")(context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::gt.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::gt.Scalar")(context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::le.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::le.Scalar")(context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::lt.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::lt.Scalar")(context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::eq.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::eq.Scalar")(context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
   }
 
@@ -800,7 +832,8 @@ TEST_F(RegisterPrimOpsTest, TestInvalidProgramErrorOnShortStack) {
     stack[0] = &values[0];
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("aten::_local_scalar_dense")(context_, stack));
+        context_,
+        getOpsFn("aten::_local_scalar_dense")(context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
   }
 
@@ -813,7 +846,9 @@ TEST_F(RegisterPrimOpsTest, TestInvalidProgramErrorOnShortStack) {
     stack[0] = &values[0];
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::neg.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::neg.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
   }
 
@@ -834,7 +869,8 @@ TEST_F(RegisterPrimOpsTest, TestInvalidProgramErrorOnShortStack) {
 
     ET_EXPECT_KERNEL_FAILURE(
         context_,
-        getOpsFn("executorch_prim::et_copy_index.tensor")(context_, stack));
+        getOpsFn("executorch_prim::et_copy_index.tensor")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
   }
 
@@ -859,7 +895,8 @@ TEST_F(RegisterPrimOpsTest, TestInvalidProgramErrorOnShortStack) {
 
     ET_EXPECT_KERNEL_FAILURE(
         context_,
-        getOpsFn("executorch_prim::et_view.default")(context_, stack));
+        getOpsFn("executorch_prim::et_view.default")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
   }
 
@@ -872,15 +909,21 @@ TEST_F(RegisterPrimOpsTest, TestInvalidProgramErrorOnShortStack) {
     stack[0] = &values[0];
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::ceil.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::ceil.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::round.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::round.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
 
     ET_EXPECT_KERNEL_FAILURE(
-        context_, getOpsFn("executorch_prim::trunc.Scalar")(context_, stack));
+        context_,
+        getOpsFn("executorch_prim::trunc.Scalar")(
+            context_, Span<EValue*>(stack)));
     EXPECT_EQ(context_.failure_state(), Error::InvalidProgram);
   }
 }
diff --git a/runtime/executor/test/executor_test.cpp b/runtime/executor/test/executor_test.cpp
index f52020bec3a..de5597af0f9 100644
--- a/runtime/executor/test/executor_test.cpp
+++ b/runtime/executor/test/executor_test.cpp
@@ -111,7 +111,7 @@ TEST_F(ExecutorTest, RegistryLookupAndCall) {
   kernel_args[4] = &evalues[3];
 
   KernelRuntimeContext context{};
-  (*func)(context, kernel_args);
+  (*func)(context, Span<EValue*>(kernel_args));
   auto c_ptr = evalues[3].toTensor().const_data_ptr<int32_t>();
   ASSERT_EQ(c_ptr[3], 12);
 }
@@ -199,7 +199,7 @@ TEST_F(ExecutorTest, OpRegistrationWithContext) {
   EValue* kernels[1];
   kernels[0] = &values[0];
   KernelRuntimeContext context{};
-  (*func)(context, kernels);
+  (*func)(context, Span<EValue*>(kernels));
 
   auto val = values[0].toScalar().to<int64_t>();
   ASSERT_EQ(val, 100);
diff --git a/runtime/kernel/test/operator_registry_test.cpp b/runtime/kernel/test/operator_registry_test.cpp
index ece1f8ab862..b06633d146d 100644
--- a/runtime/kernel/test/operator_registry_test.cpp
+++ b/runtime/kernel/test/operator_registry_test.cpp
@@ -304,7 +304,7 @@ TEST_F(OperatorRegistryTest, RegisterKernels) {
   EValue* kernels[1];
   kernels[0] = &values[0];
   KernelRuntimeContext context{};
-  (*func)(context, kernels);
+  (*func)(context, Span<EValue*>(kernels));
 
   auto val = values[0].toScalar().to<int64_t>();
   ASSERT_EQ(val, 100);
@@ -370,7 +370,7 @@ TEST_F(OperatorRegistryTest, RegisterTwoKernels) {
   Result<OpFunction> func_1 =
       get_op_function_from_registry("test::bar", user_kernel_key_1);
   EXPECT_EQ(func_1.error(), Error::Ok);
-  (*func_1)(context, evalues);
+  (*func_1)(context, Span<EValue*>(evalues));
 
   auto val_1 = values[0].toScalar().to<int64_t>();
   ASSERT_EQ(val_1, 100);
@@ -381,7 +381,7 @@ TEST_F(OperatorRegistryTest, RegisterTwoKernels) {
       get_op_function_from_registry("test::bar", user_kernel_key_2);
   EXPECT_EQ(func_2.error(), Error::Ok);
   values[0] = Scalar(0);
-  (*func_2)(context, evalues);
+  (*func_2)(context, Span<EValue*>(evalues));
 
   auto val_2 = values[0].toScalar().to<int64_t>();
   ASSERT_EQ(val_2, 50);
@@ -482,7 +482,7 @@ TEST_F(OperatorRegistryTest, ExecutorUsesKernel) {
   EValue* kernels[1];
   kernels[0] = &values[0];
   KernelRuntimeContext context{};
-  (*func)(context, kernels);
+  (*func)(context, Span<EValue*>(kernels));
 
   auto val = values[0].toScalar().to<int64_t>();
   ASSERT_EQ(val, 100);
@@ -510,7 +510,7 @@ TEST_F(OperatorRegistryTest, ExecutorUsesFallbackKernel) {
   EValue* kernels[1];
   kernels[0] = &values[0];
   KernelRuntimeContext context{};
-  (*func)(context, kernels);
+  (*func)(context, Span<EValue*>(kernels));
 
   auto val = values[0].toScalar().to<int64_t>();
   ASSERT_EQ(val, 100);