- Consolidate code into the old generation.

vm/code_generator.cc

 // Copyright (c) 2012, 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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 730 matching lines @@
 
 
 DEFINE_RUNTIME_ENTRY(ReThrow, 2) {
   ASSERT(arguments.Count() == kReThrowRuntimeEntry.argument_count());
   const Instance& exception = Instance::CheckedHandle(arguments.At(0));
   const Instance& stacktrace = Instance::CheckedHandle(arguments.At(1));
   Exceptions::ReThrow(exception, stacktrace);
 }
 
 
+static bool UpdateResolvedStaticCall(const Code& code,
+                              intptr_t offset,
+                              const Code& target_code) {
+  // PC offsets are mapped to the corresponding code object in the
+  // resolved_static_calls array. The array grows as static calls are being
+  // resolved.
+  const int kOffset = 0;
+  const int kCode = 1;
+  const int kEntrySize = 2;
+
+  GrowableObjectArray& resolved_static_calls =
+      GrowableObjectArray::Handle(code.resolved_static_calls());
+  intptr_t index = -1;
+  if (resolved_static_calls.IsNull()) {
+    resolved_static_calls = GrowableObjectArray::New(2, Heap::kOld);
+    code.set_resolved_static_calls(resolved_static_calls);
+  } else {
+    // Search for the offset in the resolved static calls.
+    const intptr_t len = resolved_static_calls.Length();
+    Object& off = Object::Handle();
+    for (intptr_t i = 0; i < len; i += kEntrySize) {
+      off = resolved_static_calls.At(i + kOffset);
+      if (Smi::Cast(off).Value() == offset) {
+        index = i;
+        break;
+      }
+    }
+  }
+  if (index == -1) {
+    // The static call with this offset is not yet present: Add it.
+    resolved_static_calls.Add(Smi::Handle(Smi::New(offset)));
+    resolved_static_calls.Add(target_code);
+  } else {
+    // Overwrite the currently recorded target.
+    resolved_static_calls.SetAt(index + kCode, target_code);
+  }
+  return index != -1;
+}
+
+
 DEFINE_RUNTIME_ENTRY(PatchStaticCall, 0) {
   // This function is called after successful resolving and compilation of
   // the target method.
   ASSERT(arguments.Count() == kPatchStaticCallRuntimeEntry.argument_count());
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   uword target = 0;
   Function& target_function = Function::Handle();
   CodePatcher::GetStaticCallAt(caller_frame->pc(), &target_function, &target);
   ASSERT(target_function.HasCode());
-  uword new_target = Code::Handle(target_function.CurrentCode()).EntryPoint();
+  const Code& target_code = Code::Handle(target_function.CurrentCode());
+  uword new_target = target_code.EntryPoint();
   // Verify that we are not patching repeatedly.
   ASSERT(target != new_target);
   CodePatcher::PatchStaticCallAt(caller_frame->pc(), new_target);
+  const Code& code = Code::Handle(caller_frame->LookupDartCode());
+  bool found = UpdateResolvedStaticCall(code,
+                                        caller_frame->pc() - code.EntryPoint(),
+                                        target_code);
+  ASSERT(!found);
   if (FLAG_trace_patching) {
     OS::Print("PatchStaticCall: patching from %#"Px" to '%s' %#"Px"\n",
         caller_frame->pc(),
         target_function.ToFullyQualifiedCString(),
         new_target);
   }
 }
 
 
 // Resolves and compiles the target function of an instance call, updates
@@ skipping 650 matching lines @@
   while (frame != NULL && (frame->IsStubFrame() || frame->IsExitFrame())) {
     frame = iterator.NextFrame();
   }
   ASSERT(frame != NULL);
   if (!frame->IsEntryFrame()) {
     ASSERT(frame->IsDartFrame());
     uword target = 0;
     Function& target_function = Function::Handle();
     CodePatcher::GetStaticCallAt(frame->pc(), &target_function, &target);
     ASSERT(target_function.HasCode());
-    const uword new_entry_point =
-        Code::Handle(function.CurrentCode()).EntryPoint();
+    ASSERT(target_function.raw() == function.raw());
+    const Code& target_code = Code::Handle(function.CurrentCode());
+    const uword new_entry_point = target_code.EntryPoint();
     ASSERT(target != new_entry_point);  // Why patch otherwise.
     CodePatcher::PatchStaticCallAt(frame->pc(), new_entry_point);
+    const Code& code = Code::Handle(frame->LookupDartCode());
+    bool found = UpdateResolvedStaticCall(code,
+                                          frame->pc() - code.EntryPoint(),
+                                          target_code);
+    ASSERT(found);
     if (FLAG_trace_patching) {
       OS::Print("FixCallersTarget: patching from %#"Px" to '%s' %#"Px"\n",
           frame->pc(),
           target_function.ToFullyQualifiedCString(),
           new_entry_point);
     }
   }
 }
 
 
@@ skipping 302 matching lines @@
     intptr_t line, column;
     script.GetTokenLocation(token_pos, &line, &column);
     String& line_string = String::Handle(script.GetLine(line));
     OS::Print("  Function: %s\n", top_function.ToFullyQualifiedCString());
     OS::Print("  Line %"Pd": '%s'\n", line, line_string.ToCString());
   }
 }
 
 
 }  // namespace dart