Use a reserved stack local variable to store the Code object so that it can be looked up easily whe…

vm/stack_frame.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/stack_frame.h"
 
+#include "vm/assembler_macros.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
+#include "vm/parser.h"
 #include "vm/raw_object.h"
 #include "vm/stub_code.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
-bool StackFrame::FindRawCodeVisitor::FindObject(RawObject* obj) {
-  return RawInstructions::ContainsPC(obj, pc_);
+
+bool StackFrame::IsStubFrame() const {
+  ASSERT(!(IsEntryFrame() || IsExitFrame()));
+  uword saved_pc = *(reinterpret_cast<uword*>(fp() - kWordSize));
+  return (saved_pc == 0);
 }
 
 
-bool StackFrame::IsStubFrame() const {
-  if (Dart::vm_isolate()->heap()->StubCodeContains(pc())) {
-    return true;  // Common stub code is generated in the VM heap.
-  }
-  if (Isolate::Current()->heap()->StubCodeContains(pc())) {
-    return true;  // Common stub code is generated in the VM heap.
-  }
-  return false;
-}
-
-
 void StackFrame::Print() const {
   OS::Print("[%-8s : sp(%p) ]\n", GetName(), sp());
 }
 
 
-RawCode* StackFrame::LookupCode(Isolate* isolate, uword pc) {
-  // TODO(asiva): Need to add a data structure for storing a (pc, code
-  // object) map in order to do a quick lookup and avoid having to
-  // traverse the code heap.
-  ASSERT(isolate != NULL);
-  // We add a no gc scope to ensure that the code below does not trigger
-  // a GC as we are handling raw object references here. It is possible
-  // that the code is called while a GC is in progress, that is ok.
-  NoGCScope no_gc;
-  FindRawCodeVisitor visitor(pc);
-  RawInstructions* instr = isolate->heap()->FindObjectInCodeSpace(&visitor);
-  if (instr != Instructions::null()) {
-    return instr->ptr()->code_;
-  }
-  return Code::null();
-}
-
-
 void ExitFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   // There are no objects to visit in this frame.
 }
 
 
 void EntryFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   // Visit objects between SP and (FP - callee_save_area).
   ASSERT(visitor != NULL);
   RawObject** start = reinterpret_cast<RawObject**>(sp());
   RawObject** end = reinterpret_cast<RawObject**>(
@@ skipping 30 matching lines @@
         }
         bit_offset += 1;
       }
       return;
     }
   }
   // No stack maps are present in the code object which means this
   // frame relies on tagged pointers and hence we visit each entry
   // on the frame between SP and FP.
   ASSERT(visitor != NULL);
-  visitor->VisitPointers(reinterpret_cast<RawObject**>(sp()),
-                         reinterpret_cast<RawObject**>(fp() - kWordSize));
+  RawObject** start = reinterpret_cast<RawObject**>(sp());
+  RawObject** end = reinterpret_cast<RawObject**>(
+      fp() + (ParsedFunction::kFirstLocalSlotIndex * kWordSize));
+  visitor->VisitPointers(start, end);
 }
 
 
 RawFunction* StackFrame::LookupDartFunction() const {
   const Code& code = Code::Handle(LookupDartCode());
   if (!code.IsNull()) {
     return code.function();
   }
   return Function::null();
 }
 
 
 RawCode* StackFrame::LookupDartCode() const {
   // We add a no gc scope to ensure that the code below does not trigger
   // a GC as we are handling raw object references here. It is possible
   // that the code is called while a GC is in progress, that is ok.
   NoGCScope no_gc;
-  Isolate* isolate = Isolate::Current();
-  RawCode* code = StackFrame::LookupCode(isolate, pc());
-  if ((code != Code::null()) && (code->ptr()->function_ != Function::null())) {
-    return code;
+  RawCode* code = GetCodeObject();
+  ASSERT(code == Code::null() || code->ptr()->function_ != Function::null());
+  return code;
+}
+
+
+RawCode* StackFrame::GetCodeObject() const {
+  // We add a no gc scope to ensure that the code below does not trigger
+  // a GC as we are handling raw object references here. It is possible
+  // that the code is called while a GC is in progress, that is ok.
+  NoGCScope no_gc;
+  uword saved_pc = *(reinterpret_cast<uword*>(fp() - kWordSize));
+  if (saved_pc != 0) {
+    uword entry_point =
+        (saved_pc - AssemblerMacros::kOffsetOfSavedPCfromEntrypoint);
+    RawInstructions* instr = Instructions::FromEntryPoint(entry_point);
+    if (instr != Instructions::null()) {
+      return instr->ptr()->code_;
+    }
   }
   return Code::null();
 }
 
 
 bool StackFrame::FindExceptionHandler(uword* handler_pc) const {
   const Code& code = Code::Handle(LookupDartCode());
   if (code.IsNull()) {
     return false;  // Stub frames do not have exception handlers.
   }
@@ skipping 22 matching lines @@
     }
   }
   return false;
 }
 
 
 bool StackFrame::IsValid() const {
   if (IsEntryFrame() || IsExitFrame() || IsStubFrame()) {
     return true;
   }
-  return (StackFrame::LookupCode(Isolate::Current(), pc()) != Code::null());
+  return (LookupDartCode() != Code::null());
 }
 
 
 StackFrameIterator::StackFrameIterator(bool validate)
     : validate_(validate), entry_(), exit_(), current_frame_(NULL) {
   SetupLastExitFrameData();  // Setup data for last exit frame.
 }
 
 
 StackFrame* StackFrameIterator::NextFrame() {
@@ skipping 63 matching lines @@
 EntryFrame* StackFrameIterator::NextEntryFrame() {
   ASSERT(!frames_.HasNext());
   entry_.sp_ = frames_.sp_;
   entry_.fp_ = frames_.fp_;
   SetupNextExitFrameData();  // Setup data for next exit frame in chain.
   ASSERT(entry_.IsValid());
   return &entry_;
 }
 
 }  // namespace dart