Add name inference for anonymous functions to facilitate debugging and profiling of JS code.

src/frames.cc

 // Copyright 2006-2008 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 68 matching lines @@
 StackFrameIterator::StackFrameIterator(bool use_top, Address fp, Address sp)
     : STACK_FRAME_TYPE_LIST(INITIALIZE_SINGLETON)
       frame_(NULL), handler_(NULL),
       thread_(use_top ? Top::GetCurrentThread() : NULL),
       fp_(use_top ? NULL : fp), sp_(sp),
       advance_(use_top ? &StackFrameIterator::AdvanceWithHandler :
                &StackFrameIterator::AdvanceWithoutHandler) {
   if (use_top || fp != NULL) {
     Reset();
   }
-  JavaScriptFrame_.DisableHeapAccess();
 }
 
 #undef INITIALIZE_SINGLETON
 
 
 void StackFrameIterator::AdvanceWithHandler() {
   ASSERT(!done());
   // Compute the state of the calling frame before restoring
   // callee-saved registers and unwinding handlers. This allows the
   // frame code that computes the caller state to access the top
@@ skipping 125 matching lines @@
 bool SafeStackFrameIterator::CanIterateHandles(StackFrame* frame,
                                                StackHandler* handler) {
   // If StackIterator iterates over StackHandles, verify that
   // StackHandlerIterator can be instantiated (see StackHandlerIterator
   // constructor.)
   return !is_valid_top_ || (frame->sp() <= handler->address());
 }
 
 
 bool SafeStackFrameIterator::IsValidFrame(StackFrame* frame) const {
-  return IsValidStackAddress(frame->sp()) && IsValidStackAddress(frame->fp());
+  return IsValidStackAddress(frame->sp()) && IsValidStackAddress(frame->fp()) &&
+      // JavaScriptFrame uses function shared info to advance, hence it must
+      // point to a valid function object.
+      (!frame->is_java_script() ||
+       reinterpret_cast<JavaScriptFrame*>(frame)->is_at_function());
 }
 
 
 bool SafeStackFrameIterator::IsValidCaller(StackFrame* frame) {
   StackFrame::State state;
   if (frame->is_entry() || frame->is_entry_construct()) {
     // See EntryFrame::GetCallerState. It computes the caller FP address
     // and calls ExitFrame::GetStateForFramePointer on it. We need to be
     // sure that caller FP address is valid.
     Address caller_fp = Memory::Address_at(
@@ skipping 25 matching lines @@
 }
 
 
 // -------------------------------------------------------------------------
 
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 SafeStackTraceFrameIterator::SafeStackTraceFrameIterator(
     Address fp, Address sp, Address low_bound, Address high_bound) :
     SafeJavaScriptFrameIterator(fp, sp, low_bound, high_bound) {
-  if (!done() && !frame()->is_java_script()) Advance();
+  if (!done() && !frame()->is_at_function()) Advance();
 }
 
 
 void SafeStackTraceFrameIterator::Advance() {
   while (true) {
     SafeJavaScriptFrameIterator::Advance();
     if (done()) return;
-    if (frame()->is_java_script()) return;
+    if (frame()->is_at_function()) return;
   }
 }
 #endif
 
 
 // -------------------------------------------------------------------------
 
 
 void StackHandler::Cook(Code* code) {
   ASSERT(MarkCompactCollector::IsCompacting());
@@ skipping 431 matching lines @@
         reg_code[i++] = r;
 
     ASSERT(i == kNumJSCallerSaved);
   }
   ASSERT(0 <= n && n < kNumJSCallerSaved);
   return reg_code[n];
 }
 
 
 } }  // namespace v8::internal