fix(runtime): guard null operator overload and named data key dereferences

Guard against null pointer dereferences when logging KernelCall errors
in Method::execute_instruction and when resolving keys in FlatTensorDataMap.

- runtime/executor/method.cpp: Check op and op->overload() before invoking
  c_str() in the KernelCall failure log. Operators with no overload string
  now format cleanly as op_name without segfaulting.
- extension/flat_tensor/flat_tensor_data_map.cpp: In get_named_data, verify
  entry and entry->key() are non-null before comparison. In get_key, validate
  index bounds and check entry and entry->key() are non-null before returning,
  returning InvalidExternalData on malformed entries instead of faulting.
- extension/flat_tensor/test/flat_tensor_data_map_test.cpp: Add test coverage
  for out-of-bounds key access.

Fixes #23955.

Author: AhmadHassan-BTed

extension/flat_tensor/flat_tensor_data_map.cpp

@@ -63,12 +63,16 @@ Result<const flat_tensor_flatbuffer::NamedData*> get_named_data(
     return Error::InvalidExternalData;
   }
   for (flatbuffers::uoffset_t i = 0; i < named_data->size(); ++i) {
-    if (key.size() == named_data->Get(i)->key()->size() &&
+    const auto* entry = named_data->Get(i);
+    if (entry == nullptr || entry->key() == nullptr) {
+      continue;
+    }
+    if (key.size() == entry->key()->size() &&
         std::strncmp(
-            named_data->Get(i)->key()->c_str(),
+            entry->key()->c_str(),
             key.data(),
-            named_data->Get(i)->key()->size()) == 0) {
-      const auto* found = named_data->Get(i);
+            entry->key()->size()) == 0) {
+      const auto* found = entry;
       // Validate the named_data.
       const flatbuffers::uoffset_t segment_index = found->segment_index();
       ET_CHECK_OR_RETURN_ERROR(
@@ -249,19 +253,37 @@ ET_NODISCARD Error FlatTensorDataMap::load_data_into(
 }
 
 ET_NODISCARD Result<uint32_t> FlatTensorDataMap::get_num_keys() const {
+  if (flat_tensor_ == nullptr || flat_tensor_->named_data() == nullptr) {
+    return 0;
+  }
   return flat_tensor_->named_data()->size();
 }
 
 ET_NODISCARD Result<const char*> FlatTensorDataMap::get_key(
     uint32_t index) const {
-  uint32_t num_keys = get_num_keys().get();
+  Result<uint32_t> num_keys_res = get_num_keys();
+  if (!num_keys_res.ok()) {
+    return num_keys_res.error();
+  }
+  uint32_t num_keys = num_keys_res.get();
   ET_CHECK_OR_RETURN_ERROR(
       index < num_keys,
       InvalidArgument,
       "Index %" PRIu32 " out of range of size %" PRIu32,
       index,
       num_keys);
-  return flat_tensor_->named_data()->Get(index)->key()->c_str();
+  const auto* named_data = flat_tensor_->named_data();
+  ET_CHECK_OR_RETURN_ERROR(
+      named_data != nullptr,
+      InvalidExternalData,
+      "Named data is null");
+  const auto* entry = named_data->Get(index);
+  ET_CHECK_OR_RETURN_ERROR(
+      entry != nullptr && entry->key() != nullptr,
+      InvalidExternalData,
+      "Named data entry or key at index %u is null",
+      index);
+  return entry->key()->c_str();
 }
 
 /* static */ Result<FlatTensorDataMap> FlatTensorDataMap::load(

extension/flat_tensor/test/flat_tensor_data_map_test.cpp

@@ -134,6 +134,9 @@ TEST_F(FlatTensorDataMapTest, GetKeys) {
   // Check get_key fails when out of bounds.
   Result<const char*> key2_res = data_map->get_key(2);
   EXPECT_EQ(key2_res.error(), Error::InvalidArgument);
+  EXPECT_EQ(
+      data_map->get_key(std::numeric_limits<uint32_t>::max()).error(),
+      Error::InvalidArgument);
 }
 
 TEST_F(FlatTensorDataMapTest, LoadInto) {

runtime/executor/method.cpp

@@ -1732,14 +1732,21 @@ Error Method::execute_instruction() {
         // checked at init time.
         auto op_index = instruction->instr_args_as_KernelCall()->op_index();
         ET_UNUSED auto op = serialization_plan_->operators()->Get(op_index);
+        const char* const op_name =
+            (op != nullptr && op->name() != nullptr) ? op->name()->c_str() : "unknown";
+        const bool has_overload =
+            op != nullptr && op->overload() != nullptr && op->overload()->size() > 0;
+        const char* const op_overload =
+            has_overload ? op->overload()->c_str() : "";
         ET_LOG(
             Error,
             "KernelCall failed at instruction %" ET_PRIsize_t ":%" ET_PRIsize_t
-            " in operator %s.%s: 0x%x",
+            " in operator %s%s%s: 0x%x",
             step_state_.chain_idx,
             step_state_.instr_idx,
-            op->name()->c_str(),
-            op->overload()->c_str(),
+            op_name,
+            has_overload ? "." : "",
+            op_overload,
             (unsigned int)err);
         for (size_t i = 0; i < args.size(); ++i) {
           ET_LOG(