[vm/oom] If unable to create OOM stack trace, report OOM without stack trace.

aam · Commit Queue · commit e0dc78bbf6ce · 2025-04-02T13:09:52.000-07:00
Fixes flaky out_of_memory tests failures. BUG=#60453 TEST=ci Change-Id: I5c9192c6cc25660e83f6c03d4293360c353b02d1 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/419583 Reviewed-by: Ryan Macnak <rmacnak@google.com> Commit-Queue: Alexander Aprelev <aam@google.com>
diff --git a/runtime/vm/compiler/backend/inliner_test.cc b/runtime/vm/compiler/backend/inliner_test.cc
@@ -475,7 +475,7 @@ void InspectStack(Dart_NativeArguments args) {
   EXPECT_EQ(3, frame_count);
   // Test something bigger than the preallocated size to verify nothing was
   // truncated.
-  EXPECT(102 > StackTrace::kPreallocatedStackdepth);
+  EXPECT(102 > StackTrace::kFixedOOMStackdepth);
 
   Dart_Handle function_name;
   Dart_Handle script_url;
diff --git a/runtime/vm/dart_api_impl_test.cc b/runtime/vm/dart_api_impl_test.cc
@@ -520,7 +520,7 @@ TEST_CASE(DartAPI_DeepStackTraceInfo) {
   EXPECT_EQ(101, frame_count);
   // Test something bigger than the preallocated size to verify nothing was
   // truncated.
-  EXPECT(101 > StackTrace::kPreallocatedStackdepth);
+  EXPECT(101 > StackTrace::kFixedOOMStackdepth);
 
   Dart_Handle function_name;
   Dart_Handle script_url;
@@ -598,7 +598,7 @@ void VerifyStackOverflowStackTraceInfo(const char* script,
   intptr_t frame_count = 0;
   result = Dart_StackTraceLength(stacktrace, &frame_count);
   EXPECT_VALID(result);
-  EXPECT_EQ(StackTrace::kPreallocatedStackdepth - 1, frame_count);
+  EXPECT_EQ(StackTrace::kFixedOOMStackdepth - 1, frame_count);
 
   Dart_Handle function_name;
   Dart_Handle script_url;
@@ -693,7 +693,7 @@ void CurrentStackTraceNative(Dart_NativeArguments args) {
   EXPECT_EQ(102, frame_count);
   // Test something bigger than the preallocated size to verify nothing was
   // truncated.
-  EXPECT(102 > StackTrace::kPreallocatedStackdepth);
+  EXPECT(102 > StackTrace::kFixedOOMStackdepth);
 
   Dart_Handle function_name;
   Dart_Handle script_url;
diff --git a/runtime/vm/exceptions.cc b/runtime/vm/exceptions.cc
@@ -46,7 +46,7 @@ class StackTraceBuilder : public ValueObject {
   void AddFrame(const Object& code, uword pc_offset);
 
  private:
-  static constexpr int kNumTopframes = StackTrace::kPreallocatedStackdepth / 2;
+  static constexpr int kNumTopframes = StackTrace::kFixedOOMStackdepth / 2;
 
   const StackTrace& stacktrace_;
   intptr_t cur_index_;
@@ -56,10 +56,10 @@ class StackTraceBuilder : public ValueObject {
 };
 
 void StackTraceBuilder::AddFrame(const Object& code, uword pc_offset) {
-  if (cur_index_ >= StackTrace::kPreallocatedStackdepth) {
+  if (cur_index_ >= StackTrace::kFixedOOMStackdepth) {
     // The number of frames is overflowing the preallocated stack trace object.
     Object& frame_code = Object::Handle();
-    intptr_t start = StackTrace::kPreallocatedStackdepth - (kNumTopframes - 1);
+    intptr_t start = StackTrace::kFixedOOMStackdepth - (kNumTopframes - 1);
     intptr_t null_slot = start - 2;
     // We are going to drop one frame.
     dropped_frames_++;
@@ -73,14 +73,14 @@ void StackTraceBuilder::AddFrame(const Object& code, uword pc_offset) {
     // Encode the number of dropped frames into the pc offset.
     stacktrace_.SetPcOffsetAtFrame(null_slot, dropped_frames_);
     // Move frames one slot down so that we can accommodate the new frame.
-    for (intptr_t i = start; i < StackTrace::kPreallocatedStackdepth; i++) {
+    for (intptr_t i = start; i < StackTrace::kFixedOOMStackdepth; i++) {
       intptr_t prev = (i - 1);
       frame_code = stacktrace_.CodeAtFrame(i);
       const uword frame_offset = stacktrace_.PcOffsetAtFrame(i);
       stacktrace_.SetCodeAtFrame(prev, frame_code);
       stacktrace_.SetPcOffsetAtFrame(prev, frame_offset);
     }
-    cur_index_ = (StackTrace::kPreallocatedStackdepth - 1);
+    cur_index_ = (StackTrace::kFixedOOMStackdepth - 1);
   }
   stacktrace_.SetCodeAtFrame(cur_index_, code);
   stacktrace_.SetPcOffsetAtFrame(cur_index_, pc_offset);
@@ -710,18 +710,46 @@ StackTracePtr Exceptions::CurrentStackTrace() {
 
 static StackTracePtr CreateStackTrace(Zone* zone) {
   const Array& code_array = Array::Handle(
-      zone, Array::New(StackTrace::kPreallocatedStackdepth, Heap::kOld));
+      zone, Array::New(StackTrace::kFixedOOMStackdepth, Heap::kOld));
+  if (code_array.IsNull()) {
+    return StackTrace::null();
+  }
   const TypedData& pc_offset_array = TypedData::Handle(
-      zone, TypedData::New(kUintPtrCid, StackTrace::kPreallocatedStackdepth,
-                           Heap::kOld));
+      zone,
+      TypedData::New(kUintPtrCid, StackTrace::kFixedOOMStackdepth, Heap::kOld));
+  if (pc_offset_array.IsNull()) {
+    return StackTrace::null();
+  }
   const StackTrace& stack_trace =
       StackTrace::Handle(zone, StackTrace::New(code_array, pc_offset_array));
   // Expansion of inlined functions requires additional memory at run time,
   // avoid it.
+  if (stack_trace.IsNull()) {
+    return StackTrace::null();
+  }
   stack_trace.set_expand_inlined(false);
   return stack_trace.ptr();
 }
 
+static UnhandledExceptionPtr CreateUnhandledExceptionOrUsePrecanned(
+    Thread* thread,
+    const Instance& exception,
+    const Instance& stacktrace) {
+  UnhandledException& unhandled = UnhandledException::Handle(thread->zone());
+  {
+    NoThrowOOMScope no_throw_oom_scope(thread);
+    unhandled ^= UnhandledException::New(Heap::kOld);
+  }
+  if (unhandled.IsNull()) {
+    // If we failed to create new instance, use pre-canned one.
+    unhandled ^= Object::unhandled_oom_exception().ptr();
+  } else {
+    unhandled.set_exception(exception);
+    unhandled.set_stacktrace(stacktrace);
+  }
+  return unhandled.ptr();
+}
+
 DART_NORETURN
 static void ThrowExceptionHelper(Thread* thread,
                                  const Instance& incoming_exception,
@@ -745,7 +773,7 @@ static void ThrowExceptionHelper(Thread* thread,
     }
   }
 #endif
-  bool use_preallocated_stacktrace = false;
+  bool create_stacktrace = false;
   Instance& exception = Instance::Handle(zone, incoming_exception.ptr());
   if (exception.IsNull()) {
     const Array& args = Array::Handle(zone, Array::New(4));
@@ -758,7 +786,7 @@ static void ThrowExceptionHelper(Thread* thread,
   } else if (existing_stacktrace.IsNull() &&
              (exception.ptr() == object_store->out_of_memory() ||
               exception.ptr() == object_store->stack_overflow())) {
-    use_preallocated_stacktrace = true;
+    create_stacktrace = true;
   }
   // Find the exception handler and determine if the handler needs a
   // stacktrace.
@@ -769,24 +797,32 @@ static void ThrowExceptionHelper(Thread* thread,
   uword handler_fp = finder.handler_fp;
   bool handler_needs_stacktrace = finder.needs_stacktrace;
   Instance& stacktrace = Instance::Handle(zone);
-  if (use_preallocated_stacktrace) {
-    stacktrace = CreateStackTrace(zone);
-    if (handler_pc == 0) {
-      // No Dart frame.
-      ASSERT(incoming_exception.ptr() == object_store->out_of_memory());
-      const UnhandledException& error = UnhandledException::Handle(
-          zone, UnhandledException::New(
-                    Instance::Handle(zone, object_store->out_of_memory()),
-                    stacktrace));
-      thread->long_jump_base()->Jump(1, error);
-      UNREACHABLE();
+  if (create_stacktrace) {
+    {
+      NoThrowOOMScope no_throw_oom_scope(thread);
+      stacktrace = CreateStackTrace(zone);
     }
-    StackTraceBuilder frame_builder(stacktrace);
-    ASSERT(existing_stacktrace.IsNull() ||
-           (existing_stacktrace.ptr() == stacktrace.ptr()));
-    ASSERT(existing_stacktrace.IsNull() || is_rethrow);
-    if (handler_needs_stacktrace && existing_stacktrace.IsNull()) {
-      BuildStackTrace(&frame_builder);
+    // Ensure we have enough memory to create stacktrace,
+    // otherwise fallback to reporting OOM without stacktrace.
+    if (!stacktrace.IsNull()) {
+      if (handler_pc == 0) {
+        // No Dart frame.
+        ASSERT(incoming_exception.ptr() == object_store->out_of_memory());
+        UnhandledException& error = UnhandledException::Handle(
+            zone,
+            CreateUnhandledExceptionOrUsePrecanned(
+                thread, Instance::Handle(zone, object_store->out_of_memory()),
+                stacktrace));
+        thread->long_jump_base()->Jump(1, error);
+        UNREACHABLE();
+      }
+      StackTraceBuilder frame_builder(stacktrace);
+      ASSERT(existing_stacktrace.IsNull() ||
+             (existing_stacktrace.ptr() == stacktrace.ptr()));
+      ASSERT(existing_stacktrace.IsNull() || is_rethrow);
+      if (handler_needs_stacktrace && existing_stacktrace.IsNull()) {
+        BuildStackTrace(&frame_builder);
+      }
     }
   } else {
     if (!existing_stacktrace.IsNull()) {
@@ -839,7 +875,8 @@ static void ThrowExceptionHelper(Thread* thread,
     // the isolate etc.). This can happen in the compiler, which is not
     // allowed to allocate in new space, so we pass the kOld argument.
     const UnhandledException& unhandled_exception = UnhandledException::Handle(
-        zone, UnhandledException::New(exception, stacktrace, Heap::kOld));
+        zone,
+        CreateUnhandledExceptionOrUsePrecanned(thread, exception, stacktrace));
     stacktrace = StackTrace::null();
     JumpToExceptionHandler(thread, handler_pc, handler_sp, handler_fp,
                            unhandled_exception, stacktrace);
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
@@ -1283,6 +1283,8 @@ void Object::Init(IsolateGroup* isolate_group) {
   error_str = String::New("Out of memory", Heap::kOld);
   *out_of_memory_error_ =
       LanguageError::New(error_str, Report::kError, Heap::kOld);
+  *unhandled_oom_exception_ =
+      UnhandledException::New(error_str, StackTrace::Handle(), Heap::kOld);
 
   // Allocate the parameter types and names for synthetic getters.
   *synthetic_getter_parameter_types_ = Array::New(1, Heap::kOld);
@@ -1407,6 +1409,8 @@ void Object::Init(IsolateGroup* isolate_group) {
   ASSERT(background_compilation_error_->IsLanguageError());
   ASSERT(!out_of_memory_error_->IsSmi());
   ASSERT(out_of_memory_error_->IsLanguageError());
+  ASSERT(!unhandled_oom_exception_->IsSmi());
+  ASSERT(unhandled_oom_exception_->IsUnhandledException());
   ASSERT(!vm_isolate_snapshot_object_table_->IsSmi());
   ASSERT(vm_isolate_snapshot_object_table_->IsArray());
   ASSERT(!synthetic_getter_parameter_types_->IsSmi());
@@ -2887,6 +2891,9 @@ ObjectPtr Object::Allocate(intptr_t cls_id,
       Report::LongJump(Object::out_of_memory_error());
       UNREACHABLE();
     } else if (thread->top_exit_frame_info() != 0) {
+      if (thread->IsInNoThrowOOMScope()) {
+        return Object::null();
+      }
       Exceptions::ThrowOOM();
       UNREACHABLE();
     } else {
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
@@ -515,6 +515,7 @@ class Object {
   V(LanguageError, background_compilation_error)                               \
   V(LanguageError, no_debuggable_code_error)                                   \
   V(LanguageError, out_of_memory_error)                                        \
+  V(UnhandledException, unhandled_oom_exception)                               \
   V(Array, vm_isolate_snapshot_object_table)                                   \
   V(Type, dynamic_type)                                                        \
   V(Type, void_type)                                                           \
@@ -8246,11 +8247,13 @@ class LanguageError : public Error {
 class UnhandledException : public Error {
  public:
   InstancePtr exception() const { return untag()->exception(); }
+  void set_exception(const Instance& exception) const;
   static intptr_t exception_offset() {
     return OFFSET_OF(UntaggedUnhandledException, exception_);
   }
 
   InstancePtr stacktrace() const { return untag()->stacktrace(); }
+  void set_stacktrace(const Instance& stacktrace) const;
   static intptr_t stacktrace_offset() {
     return OFFSET_OF(UntaggedUnhandledException, stacktrace_);
   }
@@ -8262,15 +8265,11 @@ class UnhandledException : public Error {
   static UnhandledExceptionPtr New(const Instance& exception,
                                    const Instance& stacktrace,
                                    Heap::Space space = Heap::kNew);
+  static UnhandledExceptionPtr New(Heap::Space space = Heap::kNew);
 
   virtual const char* ToErrorCString() const;
 
  private:
-  static UnhandledExceptionPtr New(Heap::Space space = Heap::kNew);
-
-  void set_exception(const Instance& exception) const;
-  void set_stacktrace(const Instance& stacktrace) const;
-
   FINAL_HEAP_OBJECT_IMPLEMENTATION(UnhandledException, Error);
   friend class Class;
   friend class ObjectStore;
@@ -12620,7 +12619,7 @@ class DebuggerStackTrace;
 // Internal stacktrace object used in exceptions for printing stack traces.
 class StackTrace : public Instance {
  public:
-  static constexpr int kPreallocatedStackdepth = 90;
+  static constexpr int kFixedOOMStackdepth = 90;
 
   intptr_t Length() const;
 
diff --git a/runtime/vm/thread.h b/runtime/vm/thread.h
@@ -759,6 +759,8 @@ class Thread : public ThreadState {
     return stopped_mutators_scope_depth_ > 0;
   }
 
+  bool IsInNoThrowOOMScope() const { return no_throw_oom_scope_depth_ > 0; }
+
 #define DEFINE_OFFSET_METHOD(type_name, member_name, expr, default_init_value) \
   static intptr_t member_name##offset() {                                      \
     return OFFSET_OF(Thread, member_name);                                     \
@@ -1437,6 +1439,7 @@ class Thread : public ThreadState {
   VMHandles reusable_handles_;
   int32_t stack_overflow_count_;
   uint32_t runtime_call_count_ = 0;
+  intptr_t no_throw_oom_scope_depth_ = 0;
 
   // Deoptimization of stack frames.
   RuntimeCallDeoptAbility runtime_call_deopt_ability_ =
@@ -1610,6 +1613,7 @@ class Thread : public ThreadState {
   friend class Simulator;
   friend class StackZone;
   friend class StoppedMutatorsScope;
+  friend class NoThrowOOMScope;
   friend class ThreadRegistry;
   friend class CompilerState;
   friend class compiler::target::Thread;
@@ -1838,6 +1842,22 @@ class LeaveCompilerScope : public ValueObject {
 };
 #endif  // defined(DEBUG)
 
+class NoThrowOOMScope : public ThreadStackResource {
+ public:
+  explicit NoThrowOOMScope(Thread* thread) : ThreadStackResource(thread) {
+    thread->no_throw_oom_scope_depth_++;
+    ASSERT(thread->no_throw_oom_scope_depth_ >= 0);
+  }
+
+  ~NoThrowOOMScope() {
+    thread()->no_throw_oom_scope_depth_ -= 1;
+    ASSERT(thread()->no_throw_oom_scope_depth_ >= 0);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NoThrowOOMScope);
+};
+
 }  // namespace dart
 
 #endif  // RUNTIME_VM_THREAD_H_
