Fix asserts in StackFrameIterator which were effectively disabled

runtime/vm/runtime_entry.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/runtime_entry.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 202 matching lines @@
   args.SetAt(0, length);
   args.SetAt(1, Integer::Handle(Integer::New(0)));
   args.SetAt(2, Integer::Handle(Integer::New(Array::kMaxElements)));
   args.SetAt(3, Symbols::Length());
   Exceptions::ThrowByType(Exceptions::kRange, args);
 }
 
 
 // Helper returning the token position of the Dart caller.
 static TokenPosition GetCallerLocation() {
-  DartFrameIterator iterator;
+  DartFrameIterator iterator(Thread::Current(),
+                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   return caller_frame->GetTokenPos();
 }
 
 
 // Allocate a new object.
 // Arg0: class of the object that needs to be allocated.
 // Arg1: type arguments of the object that needs to be allocated.
 // Return value: newly allocated object.
@@ skipping 141 matching lines @@
 }
 
 
 // Helper routine for tracing a type check.
 static void PrintTypeCheck(const char* message,
                            const Instance& instance,
                            const AbstractType& type,
                            const TypeArguments& instantiator_type_arguments,
                            const TypeArguments& function_type_arguments,
                            const Bool& result) {
-  DartFrameIterator iterator;
+  DartFrameIterator iterator(Thread::Current(),
+                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
 
   const AbstractType& instance_type =
       AbstractType::Handle(instance.GetType(Heap::kNew));
   ASSERT(instance_type.IsInstantiated());
   if (type.IsInstantiated()) {
     OS::PrintErr("%s: '%s' %" Pd " %s '%s' %" Pd " (pc: %#" Px ").\n", message,
                  String::Handle(instance_type.Name()).ToCString(),
                  Class::Handle(instance_type.type_class()).id(),
@@ skipping 353 matching lines @@
   const Instance& exception = Instance::CheckedHandle(zone, arguments.ArgAt(0));
   const Instance& stacktrace =
       Instance::CheckedHandle(zone, arguments.ArgAt(1));
   Exceptions::ReThrow(thread, exception, stacktrace);
 }
 
 
 // Patches static call in optimized code with the target's entry point.
 // Compiles target if necessary.
 DEFINE_RUNTIME_ENTRY(PatchStaticCall, 0) {
-  DartFrameIterator iterator;
+  DartFrameIterator iterator(thread,
+                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
   ASSERT(!caller_code.IsNull());
   ASSERT(caller_code.is_optimized());
   const Function& target_function = Function::Handle(
       zone, caller_code.GetStaticCallTargetFunctionAt(caller_frame->pc()));
   const Code& target_code = Code::Handle(zone, target_function.EnsureHasCode());
   // Before patching verify that we are not repeatedly patching to the same
   // target.
@@ skipping 23 matching lines @@
 
 
 #if !defined(TARGET_ARCH_DBC)
 // Gets called from debug stub when code reaches a breakpoint
 // set on a runtime stub call.
 DEFINE_RUNTIME_ENTRY(BreakpointRuntimeHandler, 0) {
   if (!FLAG_support_debugger) {
     UNREACHABLE();
     return;
   }
-  DartFrameIterator iterator;
+  DartFrameIterator iterator(thread,
+                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& orig_stub = Code::Handle(
       zone, isolate->debugger()->GetPatchedStubAddress(caller_frame->pc()));
   const Error& error =
       Error::Handle(zone, isolate->debugger()->PauseBreakpoint());
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
     UNREACHABLE();
   }
@@ skipping 150 matching lines @@
     ic_data.AddReceiverCheck(args[0]->GetClassId(), target_function);
   } else {
     GrowableArray<intptr_t> class_ids(args.length());
     ASSERT(ic_data.NumArgsTested() == args.length());
     for (intptr_t i = 0; i < args.length(); i++) {
       class_ids.Add(args[i]->GetClassId());
     }
     ic_data.AddCheck(class_ids, target_function);
   }
   if (FLAG_trace_ic_miss_in_optimized || FLAG_trace_ic) {
-    DartFrameIterator iterator;
+    DartFrameIterator iterator(Thread::Current(),
+                               StackFrameIterator::kNoCrossThreadIteration);
     StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
     if (FLAG_trace_ic_miss_in_optimized) {
       const Code& caller = Code::Handle(Code::LookupCode(caller_frame->pc()));
       if (caller.is_optimized()) {
         OS::PrintErr("IC miss in optimized code; call %s -> %s\n",
                      Function::Handle(caller.function()).ToCString(),
                      target_function.ToCString());
       }
     }
@@ skipping 52 matching lines @@
 DEFINE_RUNTIME_ENTRY(StaticCallMissHandlerOneArg, 2) {
   const Instance& arg = Instance::CheckedHandle(arguments.ArgAt(0));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
   // IC data for static call is prepopulated with the statically known target.
   ASSERT(ic_data.NumberOfChecksIs(1));
   const Function& target = Function::Handle(ic_data.GetTargetAt(0));
   target.EnsureHasCode();
   ASSERT(!target.IsNull() && target.HasCode());
   ic_data.AddReceiverCheck(arg.GetClassId(), target, 1);
   if (FLAG_trace_ic) {
-    DartFrameIterator iterator;
+    DartFrameIterator iterator(thread,
+                               StackFrameIterator::kNoCrossThreadIteration);
     StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
     OS::PrintErr("StaticCallMissHandler at %#" Px " target %s (%" Pd ")\n",
                  caller_frame->pc(), target.ToCString(), arg.GetClassId());
   }
   arguments.SetReturn(target);
 }
 
 
 // Handles a static call in unoptimized code that has two argument types not
 // seen before. Compile the target if necessary and update the ICData.
 // Arg0: argument 0.
 // Arg1: argument 1.
 // Arg2: IC data object.
 DEFINE_RUNTIME_ENTRY(StaticCallMissHandlerTwoArgs, 3) {
   const Instance& arg0 = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& arg1 = Instance::CheckedHandle(arguments.ArgAt(1));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(2));
   // IC data for static call is prepopulated with the statically known target.
   ASSERT(!ic_data.NumberOfChecksIs(0));
   const Function& target = Function::Handle(ic_data.GetTargetAt(0));
   target.EnsureHasCode();
   GrowableArray<intptr_t> cids(2);
   cids.Add(arg0.GetClassId());
   cids.Add(arg1.GetClassId());
   ic_data.AddCheck(cids, target);
   if (FLAG_trace_ic) {
-    DartFrameIterator iterator;
+    DartFrameIterator iterator(thread,
+                               StackFrameIterator::kNoCrossThreadIteration);
     StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
     OS::PrintErr("StaticCallMissHandler at %#" Px " target %s (%" Pd ", %" Pd
                  ")\n",
                  caller_frame->pc(), target.ToCString(), cids[0], cids[1]);
   }
   arguments.SetReturn(target);
 }
 
 
@@ skipping 26 matching lines @@
 // Handle a miss of a single target cache.
 //   Arg0: Receiver.
 //   Returns: the ICData used to continue with a polymorphic call.
 DEFINE_RUNTIME_ENTRY(SingleTargetMiss, 1) {
 #if defined(TARGET_ARCH_DBC)
   // DBC does not use switchable calls.
   UNREACHABLE();
 #else
   const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
 
-  DartFrameIterator iterator;
+  DartFrameIterator iterator(thread,
+                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame->IsDartFrame());
   const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
   const Function& caller_function =
       Function::Handle(zone, caller_frame->LookupDartFunction());
 
   SingleTargetCache& cache = SingleTargetCache::Handle(zone);
   cache ^=
       CodePatcher::GetSwitchableCallDataAt(caller_frame->pc(), caller_code);
   Code& old_target_code = Code::Handle(zone, cache.target());
@@ skipping 65 matching lines @@
 
 DEFINE_RUNTIME_ENTRY(UnlinkedCall, 2) {
 #if defined(TARGET_ARCH_DBC)
   // DBC does not use switchable calls.
   UNREACHABLE();
 #else
   const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
   const UnlinkedCall& unlinked =
       UnlinkedCall::CheckedHandle(zone, arguments.ArgAt(1));
 
-  DartFrameIterator iterator;
+  DartFrameIterator iterator(thread,
+                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame->IsDartFrame());
   const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
   const Function& caller_function =
       Function::Handle(zone, caller_frame->LookupDartFunction());
 
   const String& name = String::Handle(zone, unlinked.target_name());
   const Array& descriptor = Array::Handle(zone, unlinked.args_descriptor());
   const ICData& ic_data =
       ICData::Handle(zone, ICData::New(caller_function, name, descriptor,
@@ skipping 45 matching lines @@
 // Handle a miss of a megamorphic cache.
 //   Arg0: Receiver.
 //   Returns: the ICData used to continue with a polymorphic call.
 DEFINE_RUNTIME_ENTRY(MonomorphicMiss, 1) {
 #if defined(TARGET_ARCH_DBC)
   // DBC does not use switchable calls.
   UNREACHABLE();
 #else
   const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0));
 
-  DartFrameIterator iterator;
+  DartFrameIterator iterator(thread,
+                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame->IsDartFrame());
   const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
   const Function& caller_function =
       Function::Handle(zone, caller_frame->LookupDartFunction());
 
   Smi& old_expected_cid = Smi::Handle(zone);
   old_expected_cid ^=
       CodePatcher::GetSwitchableCallDataAt(caller_frame->pc(), caller_code);
   const Code& old_target_code = Code::Handle(
@@ skipping 119 matching lines @@
       // This call site is unlinked: transition to a monomorphic direct call.
       // Note we cannot do this if the target has optional parameters because
       // the monomorphic direct call does not load the arguments descriptor.
       // We cannot do this if we are still in the middle of precompiling because
       // the monomorphic case hides an live instance selector from the
       // treeshaker.
 
       const Code& target_code =
           Code::Handle(zone, target_function.EnsureHasCode());
 
-      DartFrameIterator iterator;
+      DartFrameIterator iterator(thread,
+                                 StackFrameIterator::kNoCrossThreadIteration);
       StackFrame* miss_function_frame = iterator.NextFrame();
       ASSERT(miss_function_frame->IsDartFrame());
       StackFrame* caller_frame = iterator.NextFrame();
       ASSERT(caller_frame->IsDartFrame());
       const Code& caller_code =
           Code::Handle(zone, caller_frame->LookupDartCode());
       const Smi& expected_cid =
           Smi::Handle(zone, Smi::New(receiver.GetClassId()));
 
       CodePatcher::PatchSwitchableCallAt(caller_frame->pc(), caller_code,
                                          expected_cid, target_code);
     } else {
       ic_data.AddReceiverCheck(receiver.GetClassId(), target_function);
       if (number_of_checks > FLAG_max_polymorphic_checks) {
         // Switch to megamorphic call.
         const MegamorphicCache& cache = MegamorphicCache::Handle(
             zone, MegamorphicCacheTable::Lookup(isolate, name, descriptor));
-        DartFrameIterator iterator;
+        DartFrameIterator iterator(thread,
+                                   StackFrameIterator::kNoCrossThreadIteration);
         StackFrame* miss_function_frame = iterator.NextFrame();
         ASSERT(miss_function_frame->IsDartFrame());
         StackFrame* caller_frame = iterator.NextFrame();
         ASSERT(caller_frame->IsDartFrame());
         const Code& caller_code =
             Code::Handle(zone, caller_frame->LookupDartCode());
         const Code& stub =
             Code::Handle(zone, StubCode::MegamorphicCall_entry()->code());
 
         CodePatcher::PatchSwitchableCallAt(caller_frame->pc(), caller_code,
@@ skipping 219 matching lines @@
     }
     if (FLAG_stacktrace_every > 0 && (count % FLAG_stacktrace_every) == 0) {
       do_stacktrace = true;
     }
     if ((isolate_reload_every > 0) && (count % isolate_reload_every) == 0) {
       do_reload = isolate->CanReload();
     }
   }
   if ((FLAG_deoptimize_filter != NULL) || (FLAG_stacktrace_filter != NULL) ||
       FLAG_reload_every_optimized) {
-    DartFrameIterator iterator;
+    DartFrameIterator iterator(thread,
+                               StackFrameIterator::kNoCrossThreadIteration);
     StackFrame* frame = iterator.NextFrame();
     ASSERT(frame != NULL);
     const Code& code = Code::Handle(frame->LookupDartCode());
     ASSERT(!code.IsNull());
     const Function& function = Function::Handle(code.function());
     ASSERT(!function.IsNull());
     const char* function_name = function.ToFullyQualifiedCString();
     ASSERT(function_name != NULL);
     if (!code.is_optimized() && FLAG_reload_every_optimized) {
       // Don't do the reload if we aren't inside optimized code.
@@ skipping 62 matching lines @@
   }
 
   const Error& error = Error::Handle(thread->HandleInterrupts());
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
     UNREACHABLE();
   }
 
   if ((stack_overflow_flags & Thread::kOsrRequest) != 0) {
     ASSERT(isolate->use_osr());
-    DartFrameIterator iterator;
+    DartFrameIterator iterator(thread,
+                               StackFrameIterator::kNoCrossThreadIteration);
     StackFrame* frame = iterator.NextFrame();
     ASSERT(frame != NULL);
     const Code& code = Code::ZoneHandle(frame->LookupDartCode());
     ASSERT(!code.IsNull());
     ASSERT(!code.is_optimized());
     const Function& function = Function::Handle(code.function());
     ASSERT(!function.IsNull());
 
     // If the code of the frame does not match the function's unoptimized code,
     // we bail out since the code was reset by an isolate reload.
@@ skipping 38 matching lines @@
       frame->set_pc(optimized_entry);
       frame->set_pc_marker(code.raw());
     }
   }
 }
 
 
 DEFINE_RUNTIME_ENTRY(TraceICCall, 2) {
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(0));
   const Function& function = Function::CheckedHandle(arguments.ArgAt(1));
-  DartFrameIterator iterator;
+  DartFrameIterator iterator(thread,
+                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL);
   OS::PrintErr("IC call @%#" Px ": ICData: %p cnt:%" Pd " nchecks: %" Pd
                " %s\n",
                frame->pc(), ic_data.raw(), function.usage_counter(),
                ic_data.NumberOfChecks(), function.ToFullyQualifiedCString());
 }
 
 
 // This is called from function that needs to be optimized.
@@ skipping 59 matching lines @@
   arguments.SetReturn(function);
 #else
   UNREACHABLE();
 #endif  // !DART_PRECOMPILED_RUNTIME
 }
 
 
 // The caller must be a static call in a Dart frame, or an entry frame.
 // Patch static call to point to valid code's entry point.
 DEFINE_RUNTIME_ENTRY(FixCallersTarget, 0) {
-  StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
+  StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames, thread,
+                              StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL);
   while (frame->IsStubFrame() || frame->IsExitFrame()) {
     frame = iterator.NextFrame();
     ASSERT(frame != NULL);
   }
   if (frame->IsEntryFrame()) {
     // Since function's current code is always unpatched, the entry frame always
     // calls to unpatched code.
     UNREACHABLE();
@@ skipping 17 matching lines @@
   }
   ASSERT(!current_target_code.IsDisabled());
   arguments.SetReturn(current_target_code);
 }
 
 
 // The caller tried to allocate an instance via an invalidated allocation
 // stub.
 DEFINE_RUNTIME_ENTRY(FixAllocationStubTarget, 0) {
 #if !defined(DART_PRECOMPILED_RUNTIME)
-  StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
+  StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames, thread,
+                              StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL);
   while (frame->IsStubFrame() || frame->IsExitFrame()) {
     frame = iterator.NextFrame();
     ASSERT(frame != NULL);
   }
   if (frame->IsEntryFrame()) {
     // There must be a valid Dart frame.
     UNREACHABLE();
   }
@@ skipping 107 matching lines @@
 #endif  // !DBC
 
   // Mark code as dead (do not GC its embedded objects).
   optimized_code.set_is_alive(false);
 }
 
 
 // Currently checks only that all optimized frames have kDeoptIndex
 // and unoptimized code has the kDeoptAfter.
 void DeoptimizeFunctionsOnStack() {
-  DartFrameIterator iterator;
+  DartFrameIterator iterator(Thread::Current(),
+                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* frame = iterator.NextFrame();
   Code& optimized_code = Code::Handle();
   while (frame != NULL) {
     optimized_code = frame->LookupDartCode();
     if (optimized_code.is_optimized()) {
       DeoptimizeAt(optimized_code, frame);
     }
     frame = iterator.NextFrame();
   }
 }
@@ skipping 50 matching lines @@
   StackZone zone(thread);
   HANDLESCOPE(thread);
 
   // All registers have been saved below last-fp as if they were locals.
   const uword last_fp = saved_registers_address +
                         (kNumberOfSavedCpuRegisters * kWordSize) +
                         (kNumberOfSavedFpuRegisters * kFpuRegisterSize) -
                         ((kFirstLocalSlotFromFp + 1) * kWordSize);
 
   // Get optimized code and frame that need to be deoptimized.
-  DartFrameIterator iterator(last_fp);
+  DartFrameIterator iterator(last_fp, thread,
+                             StackFrameIterator::kNoCrossThreadIteration);
 
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& optimized_code = Code::Handle(caller_frame->LookupDartCode());
   ASSERT(optimized_code.is_optimized());
   const Function& top_function =
       Function::Handle(thread->zone(), optimized_code.function());
   const bool deoptimizing_code = top_function.HasOptimizedCode();
   if (FLAG_trace_deoptimization) {
     const Function& function = Function::Handle(optimized_code.function());
@@ skipping 49 matching lines @@
 // The stack has been adjusted to fit all values for unoptimized frame.
 // Fill the unoptimized frame.
 DEFINE_LEAF_RUNTIME_ENTRY(void, DeoptimizeFillFrame, 1, uword last_fp) {
 #if !defined(DART_PRECOMPILED_RUNTIME)
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   StackZone zone(thread);
   HANDLESCOPE(thread);
 
   DeoptContext* deopt_context = isolate->deopt_context();
-  DartFrameIterator iterator(last_fp);
+  DartFrameIterator iterator(last_fp, thread,
+                             StackFrameIterator::kNoCrossThreadIteration);
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
 
 #if defined(DEBUG)
   {
     // The code from the deopt_context.
     const Code& code = Code::Handle(deopt_context->code());
 
     // The code from our frame.
     const Code& optimized_code = Code::Handle(caller_frame->LookupDartCode());
@@ skipping 113 matching lines @@
   const intptr_t new_size = 2 * old_size;
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 }  // namespace dart