Put additional information onto the stack when crashing in Debug::Break.

src/debug.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 874 matching lines @@
   Debug::set_interrupts_pending(PREEMPT);
 }
 
 
 void Debug::Iterate(ObjectVisitor* v) {
   v->VisitPointer(BitCast<Object**>(&(debug_break_return_)));
   v->VisitPointer(BitCast<Object**>(&(debug_break_slot_)));
 }
 
 
+// TODO(131642): Remove this when fixed.
 void Debug::PutValuesOnStackAndDie(int start,
                                    Address c_entry_fp,
                                    Address last_fp,
                                    Address larger_fp,
                                    int count,
                                    char* stack,
                                    int end) {
   OS::PrintError("start:       %d\n", start);
   OS::PrintError("c_entry_fp:  %p\n", static_cast<void*>(c_entry_fp));
   OS::PrintError("last_fp:     %p\n", static_cast<void*>(last_fp));
@@ skipping 97 matching lines @@
     // and keep step count queued up in the meantime.
     if (step_action == StepNext && frame->fp() < thread_local_.last_fp_) {
       // Count frames until target frame
       int count = 0;
       JavaScriptFrameIterator it(isolate_);
       while (!it.done() && it.frame()->fp() < thread_local_.last_fp_) {
         count++;
         it.Advance();
       }
 
+      // TODO(131642): Remove this when fixed.
       // Catch the cases that would lead to crashes and capture
       // - C entry FP at which to start stack crawl.
       // - FP of the frame at which we plan to stop stepping out (last FP).
       // - current FP that's larger than last FP.
       // - Counter for the number of steps to step out.
       // - stack trace string.
       if (it.done()) {
         // We crawled the entire stack, never reaching last_fp_.
+        Handle<String> stack = isolate_->StackTraceString();
+        char buffer[8192];
+        int length = Min(8192, stack->length());
+        String::WriteToFlat(*stack, buffer, 0, length - 1);
         PutValuesOnStackAndDie(0xBEEEEEEE,
                                frame->fp(),
                                thread_local_.last_fp_,
                                reinterpret_cast<Address>(0xDEADDEAD),
                                count,
-                               NULL,
+                               buffer,
                                0xCEEEEEEE);
       } else if (it.frame()->fp() != thread_local_.last_fp_) {
         // We crawled over last_fp_, without getting a match.
         Handle<String> stack = isolate_->StackTraceString();
         char buffer[8192];
-        String::WriteToFlat(*stack, buffer, 0, 8191);
+        int length = Min(8192, stack->length());
+        String::WriteToFlat(*stack, buffer, 0, length - 1);
         PutValuesOnStackAndDie(0xDEEEEEEE,
                                frame->fp(),
                                thread_local_.last_fp_,
                                it.frame()->fp(),
                                count,
                                buffer,
                                0xFEEEEEEE);
       }
 
       // If we found original frame
@@ skipping 2662 matching lines @@
     {
       Locker locker;
       Isolate::Current()->debugger()->CallMessageDispatchHandler();
     }
   }
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal