[Interpreter]: Basic support for iterating interpreter stack frames for GC.

src/frames.cc

 // Copyright 2012 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/frames.h"
 
 #include <sstream>
 
 #include "src/ast.h"
 #include "src/base/bits.h"
@@ skipping 421 matching lines @@
   Code* code_obj = GetContainingCode(iterator->isolate(), *(state->pc_address));
 
   Object* marker =
       Memory::Object_at(state->fp + StandardFrameConstants::kMarkerOffset);
   if (code_obj != nullptr) {
     switch (code_obj->kind()) {
       case Code::FUNCTION:
         return JAVA_SCRIPT;
       case Code::OPTIMIZED_FUNCTION:
         return OPTIMIZED;
+      case Code::BUILTIN:

[titzer, 2015/10/15 17:01:55]

Are interpreter frames really only identifiable through the marker being a SMI,
or is there a more reliable way to detect them? E.g. by marking a bit on the
code object?

[rmcilroy, 2015/10/15 19:47:47]

The marker is not a SMI (it's a tagged JSFunction object, like other JavaScript
frames).  It is identified by the fact that the return address always points to
the InterpreterEntryTrampoline builtin for interpreted frames. 

If you want to make it more robust I could do the same trick as the
ArgumentsAdapter (put a SMI marker in the context slot and push the context
separately. Would this be better? What was your plan for WASM frames?

+        if (!marker->IsSmi()) {
+          if (StandardFrame::IsArgumentsAdaptorFrame(state->fp)) {
+            // An adapter frame has a special SMI constant for the context and
+            // is not distinguished through the marker.
+            return ARGUMENTS_ADAPTOR;
+          } else {
+            // The interpreter entry trampoline has a non-SMI marker.
+            DCHECK(code_obj->is_interpreter_entry_trampoline());
+            return INTERPRETED;
+          }
+        }
+        break;  // Marker encodes the frame type.
       case Code::HANDLER:
         if (!marker->IsSmi()) {
           // Only hydrogen code stub handlers can have a non-SMI marker.
           DCHECK(code_obj->is_hydrogen_stub());
           return OPTIMIZED;
         }
         break;  // Marker encodes the frame type.
       default:
         break;  // Marker encodes the frame type.
     }
   }
 
-  if (StandardFrame::IsArgumentsAdaptorFrame(state->fp)) {
-    // An adapter frame has a special SMI constant for the context and
-    // is not distinguished through the marker.
-    return ARGUMENTS_ADAPTOR;
-  }
-
   // Didn't find a code object, or the code kind wasn't specific enough.
   // The marker should encode the frame type.
   return static_cast<StackFrame::Type>(Smi::cast(marker)->value());
 }
 
 
 #ifdef DEBUG
 bool StackFrame::can_access_heap_objects() const {
   return iterator_->can_access_heap_objects_;
 }
@@ skipping 1115 matching lines @@
   for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
     StackFrame* frame = AllocateFrameCopy(it.frame(), zone);
     list.Add(frame, zone);
   }
   return list.ToVector();
 }
 
 
 }  // namespace internal
 }  // namespace v8