[cpu-profiler] Do not record empty stack trace.

src/profiler/tick-sample.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/profiler/tick-sample.h"
 
 #include "include/v8-profiler.h"
 #include "src/frames-inl.h"
 #include "src/msan.h"
 #include "src/simulator.h"
@@ skipping 127 matching lines @@
   // we have already entrered JavaScript again and the external callback
   // is not the top function.
   if (scope && scope->scope_address() < handler) {
     sample_info->external_callback_entry =
         *scope->callback_entrypoint_address();
   }
 
   i::SafeStackFrameIterator it(isolate, reinterpret_cast<i::Address>(regs.fp),
                                reinterpret_cast<i::Address>(regs.sp),
                                js_entry_sp);
+
+  // If at this point iterator does not see any frames,
+  // is usually means something is wrong with the FP,
+  // e.g. it is used as a general purpose register in the function.
+  // Bailout.
+  if (it.done()) return false;
+
   size_t i = 0;
-  if (record_c_entry_frame == kIncludeCEntryFrame && !it.done() &&
+  if (record_c_entry_frame == kIncludeCEntryFrame &&
       (it.top_frame_type() == internal::StackFrame::EXIT ||
        it.top_frame_type() == internal::StackFrame::BUILTIN_EXIT)) {
     frames[i++] = isolate->c_function();
   }
-  while (!it.done() && i < frames_limit) {
-    if (it.frame()->is_interpreted()) {
-      // For interpreted frames use the bytecode array pointer as the pc.
-      i::InterpretedFrame* frame =
-          static_cast<i::InterpretedFrame*>(it.frame());
-      // Since the sampler can interrupt execution at any point the
-      // bytecode_array might be garbage, so don't dereference it.
-      i::Address bytecode_array =
-          reinterpret_cast<i::Address>(frame->GetBytecodeArray()) -
-          i::kHeapObjectTag;
-      frames[i++] = bytecode_array + i::BytecodeArray::kHeaderSize +
-                    frame->GetBytecodeOffset();
-    } else {
+  for (; !it.done() && i < frames_limit; it.Advance()) {
+    if (!it.frame()->is_interpreted()) {
       frames[i++] = it.frame()->pc();
+      continue;
     }
-    it.Advance();
+    // For interpreted frames use the bytecode array pointer as the pc.
+    i::InterpretedFrame* frame = static_cast<i::InterpretedFrame*>(it.frame());
+    // Since the sampler can interrupt execution at any point the
+    // bytecode_array might be garbage, so don't dereference it.
+    i::Address bytecode_array =
+        reinterpret_cast<i::Address>(frame->GetBytecodeArray()) -
+        i::kHeapObjectTag;
+    frames[i++] = bytecode_array + i::BytecodeArray::kHeaderSize +
+                  frame->GetBytecodeOffset();
   }
   sample_info->frames_count = i;
   return true;
 }
 
 namespace internal {
 
 void TickSample::Init(Isolate* isolate, const v8::RegisterState& state,
                       RecordCEntryFrame record_c_entry_frame,
                       bool update_stats) {
@@ skipping 52 matching lines @@
     // it is not guaranteed to be atomic even when both host and target
     // are of same bitness.
     return false;
   }
   return true;
 }
 #endif  // USE_SIMULATOR
 
 }  // namespace internal
 }  // namespace v8