Cleaned up usage of Function::code, since it may be misunderstood that it points to the only Code o…

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/code_index_table.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
@@ skipping 405 matching lines @@
   // This function is called after successful resolving and compilation of
   // the target method.
   ASSERT(arguments.Count() == kPatchStaticCallRuntimeEntry.argument_count());
   DartFrameIterator iterator;
   DartFrame* 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.code()).EntryPoint();
+  uword new_target = Code::Handle(target_function.CurrentCode()).EntryPoint();
   // Verify that we are not patching repeatedly.
   ASSERT(target != new_target);
   CodePatcher::PatchStaticCallAt(caller_frame->pc(), new_target);
   if (FLAG_trace_patching) {
     OS::Print("PatchStaticCall: patching from 0x%x to '%s' 0x%x\n",
         caller_frame->pc(),
         target_function.ToFullyQualifiedCString(),
         new_target);
   }
 }
@@ skipping 44 matching lines @@
   } else {
     if (!function.HasCode()) {
       const Error& error = Error::Handle(Compiler::CompileFunction(function));
       if (!error.IsNull()) {
         Exceptions::PropagateError(error);
       }
     }
     functions_cache.AddCompiledFunction(function,
                                         num_arguments,
                                         num_named_arguments);
-    return function.code();
+    return function.CurrentCode();
   }
 }
 
 
 // Result of an invoke may be an unhandled exception, in which case we
 // rethrow it.
 static void CheckResultError(const Object& result) {
   if (result.IsError()) {
     Exceptions::PropagateError(result);
   }
@@ skipping 300 matching lines @@
   const Array& func_arguments = Array::CheckedHandle(arguments.At(2));
   const Function& function = Function::Handle(closure.function());
   ASSERT(!function.IsNull());
   if (!function.HasCode()) {
     const Error& error = Error::Handle(Compiler::CompileFunction(function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
   const Context& context = Context::Handle(closure.context());
-  const Code& code = Code::Handle(function.code());
+  const Code& code = Code::Handle(function.CurrentCode());
   ASSERT(!code.IsNull());
   const Instructions& instrs = Instructions::Handle(code.instructions());
   ASSERT(!instrs.IsNull());
 
   // Adjust arguments descriptor array to account for removal of the receiver
   // parameter. Since the arguments descriptor array is canonicalized, create a
   // new one instead of patching the original one.
   const intptr_t len = arg_descriptor.Length();
   const intptr_t num_named_args = (len - 3) / 2;
   const Array& adjusted_arg_descriptor = Array::Handle(Array::New(len));
@@ skipping 146 matching lines @@
 DEFINE_RUNTIME_ENTRY(OptimizeInvokedFunction, 1) {
   ASSERT(arguments.Count() ==
          kOptimizeInvokedFunctionRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.At(0));
   if (function.deoptimization_counter() >=
       FLAG_deoptimization_counter_threshold) {
     // TODO(srdjan): Investigate excessive deoptimization.
     function.set_usage_counter(0);
     return;
   }
-  if (Code::Handle(function.code()).is_optimized()) {
+  if (function.HasOptimizedCode()) {
     // The caller has been already optimized.
     // TODO(srdjan): This is a significant slowdown, the caller is probably in
     // a loop. Maybe test if the code has been optimized before calling.
     // If this happens from optimized code, then it means that the optimized
     // code needs to be reoptimized.
     function.set_usage_counter(0);
     return;
   }
   if (function.is_optimizable()) {
-    ASSERT(!Code::Handle(function.code()).is_optimized());
-    const Code& unoptimized_code = Code::Handle(function.code());
+    ASSERT(!function.HasOptimizedCode());
+    const Code& unoptimized_code = Code::Handle(function.unoptimized_code());
     // Compilation patches the entry of unoptimized code.
     const Error& error =
         Error::Handle(Compiler::CompileOptimizedFunction(function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
-    const Code& optimized_code = Code::Handle(function.code());
+    const Code& optimized_code = Code::Handle(function.CurrentCode());
     ASSERT(!optimized_code.IsNull());
     ASSERT(!unoptimized_code.IsNull());
   } else {
     // TODO(5442338): Abort as this should not happen.
     function.set_usage_counter(0);
   }
 }
 
 
 // The caller must be a static call in a Dart frame, or an entry frame.
 // Patch static call to point to 'new_entry_point'.
 DEFINE_RUNTIME_ENTRY(FixCallersTarget, 1) {
   ASSERT(arguments.Count() == kFixCallersTargetRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.At(0));
   ASSERT(!function.IsNull());
   ASSERT(function.HasCode());
 
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = iterator.NextFrame();
   while (frame != NULL && !frame->IsDartFrame() && !frame->IsEntryFrame()) {
     frame = iterator.NextFrame();
   }
   ASSERT(frame != NULL);
   if (frame->IsDartFrame()) {
     uword target = 0;
     Function& target_function = Function::Handle();
     CodePatcher::GetStaticCallAt(frame->pc(), &target_function, &target);
-    const uword new_entry_point = Code::Handle(function.code()).EntryPoint();
+    ASSERT(target_function.HasCode());
+    const uword new_entry_point =
+        Code::Handle(function.CurrentCode()).EntryPoint();
     ASSERT(target != new_entry_point);  // Why patch otherwise.
-    ASSERT(target_function.HasCode());
     CodePatcher::PatchStaticCallAt(frame->pc(), new_entry_point);
     if (FLAG_trace_patching) {
       OS::Print("FixCallersTarget: patching from 0x%x to '%s' 0x%x\n",
           frame->pc(),
           target_function.ToFullyQualifiedCString(),
           new_entry_point);
     }
   }
 }
 
@@ skipping 52 matching lines @@
   }
   caller_frame->set_pc(continue_at_pc);
   // Clear invocation counter so that the function gets optimized after
   // types/classes have been collected.
   function.set_usage_counter(0);
   function.set_deoptimization_counter(function.deoptimization_counter() + 1);
 
   // We have to skip the following otherwise the compiler will complain
   // when it attempts to install unoptimized code into a function that
   // was already deoptimized.
-  if (Code::Handle(function.code()).is_optimized()) {
+  if (function.HasOptimizedCode()) {
     // Get unoptimized code. Compilation restores (reenables) the entry of
     // unoptimized code.
     const Error& error = Error::Handle(Compiler::CompileFunction(function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
   // TODO(srdjan): Handle better complex cases, e.g. when an older optimized
   // code is alive on frame and gets deoptimized after the function was
   // optimized a second time.
@@ skipping 64 matching lines @@
     if (function_name.Equals(test_name)) {
       Smi& smi = Smi::Handle();
       smi ^= cache.At(i + FunctionsCache::kArgCount);
       if (num_arguments == smi.Value()) {
         smi ^= cache.At(i + FunctionsCache::kNamedArgCount);
         if (num_named_arguments == smi.Value()) {
           Function& result = Function::Handle();
           result ^= cache.At(i + FunctionsCache::kFunction);
           ASSERT(!result.IsNull());
           ASSERT(result.HasCode());
-          return result.code();
+          return result.CurrentCode();
         }
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart