First part of static call cleanup: store static call targets into code object, referenced by code-o…

runtime/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 752 matching lines @@
 
 
 DEFINE_RUNTIME_ENTRY(ReThrow, 2) {
   ASSERT(arguments.ArgCount() == kReThrowRuntimeEntry.argument_count());
   const Instance& exception = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& stacktrace = Instance::CheckedHandle(arguments.ArgAt(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.ArgCount() == 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());
   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);
+  code.SetStaticCallTargetCodeAt(caller_frame->pc(), target_code);
   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 740 matching lines @@
     uword target = 0;
     Function& target_function = Function::Handle();
     CodePatcher::GetStaticCallAt(frame->pc(), &target_function, &target);
     ASSERT(target_function.HasCode());
     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);
+    code.SetStaticCallTargetCodeAt(frame->pc(), target_code);
     if (FLAG_trace_patching) {
       OS::Print("FixCallersTarget: patching from %#"Px" to '%s' %#"Px"\n",
           frame->pc(),
           target_function.ToFullyQualifiedCString(),
           new_entry_point);
     }
   }
 }
 
 
@@ skipping 336 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