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

runtime/vm/compiler.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/compiler.h"
 
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/code_generator.h"
 #include "vm/code_index_table.h"
@@ skipping 143 matching lines @@
       }
       isolate->set_long_jump_base(old_base);
       // Currently, always fails and falls through to the old compiler.
     }
     CodeIndexTable* code_index_table = isolate->code_index_table();
     ASSERT(code_index_table != NULL);
     Assembler assembler;
     if (optimized) {
       // Transition to optimized code only from unoptimized code ... for now.
       ASSERT(function.HasCode());
-      ASSERT(!Code::Handle(function.code()).is_optimized());
-      // Do not use type feedback to optimize a function that was deoptimized.
+      ASSERT(!function.HasOptimizedCode());
+      // Do not use type feedback to optimize a function that was deoptimized
+      // too often.
       if (parsed_function.function().deoptimization_counter() <
           FLAG_deoptimization_counter_threshold) {
-        ExtractTypeFeedback(Code::Handle(parsed_function.function().code()),
-                            parsed_function.node_sequence());
+        ExtractTypeFeedback(
+            Code::Handle(parsed_function.function().unoptimized_code()),
+            parsed_function.node_sequence());
       }
       OptimizingCodeGenerator code_gen(&assembler, parsed_function);
       code_gen.GenerateCode();
       Code& code = Code::Handle(
           Code::FinalizeCode(function_fullname, &assembler));
       code.set_is_optimized(true);
       code_gen.FinalizePcDescriptors(code);
       code_gen.FinalizeExceptionHandlers(code);
       function.SetCode(code);
-      code_index_table->AddFunction(function);
+      code_index_table->AddCode(code);
       CodePatcher::PatchEntry(Code::Handle(function.unoptimized_code()));
       if (FLAG_trace_compiler) {
         OS::Print("--> patching entry 0x%x\n",
                   Code::Handle(function.unoptimized_code()).EntryPoint());
       }
     } else {
       // Unoptimized code.
       if (Code::Handle(function.unoptimized_code()).IsNull()) {
-        ASSERT(Code::Handle(function.code()).IsNull());
+        ASSERT(!function.HasCode());
         // Compiling first time.
         CodeGenerator code_gen(&assembler, parsed_function);
         code_gen.GenerateCode();
         const Code& code =
             Code::Handle(Code::FinalizeCode(function_fullname, &assembler));
         code.set_is_optimized(false);
         code_gen.FinalizePcDescriptors(code);
         code_gen.FinalizeVarDescriptors(code);
         code_gen.FinalizeExceptionHandlers(code);
         function.set_unoptimized_code(code);
         function.SetCode(code);
         ASSERT(CodePatcher::CodeIsPatchable(code));
-        code_index_table->AddFunction(function);
+        code_index_table->AddCode(code);
       } else {
         // Disable optimized code.
-        const Code& optimized_code = Code::Handle(function.code());
-        ASSERT(optimized_code.is_optimized());
-        CodePatcher::PatchEntry(Code::Handle(function.code()));
+        ASSERT(function.HasOptimizedCode());
+        // Patch entry of optimized code
+        CodePatcher::PatchEntry(Code::Handle(function.CurrentCode()));
         if (FLAG_trace_compiler) {
           OS::Print("--> patching entry 0x%x\n",
-                    Code::Handle(function.unoptimized_code()).EntryPoint());
+                    Code::Handle(function.CurrentCode()).EntryPoint());
         }
         // Use previously compiled code.
         function.SetCode(Code::Handle(function.unoptimized_code()));
         CodePatcher::RestoreEntry(Code::Handle(function.unoptimized_code()));
         if (FLAG_trace_compiler) {
           OS::Print("--> restoring entry at 0x%x\n",
                     Code::Handle(function.unoptimized_code()).EntryPoint());
         }
       }
     }
     if (FLAG_trace_compiler) {
       OS::Print("--> '%s' entry: 0x%x\n",
-                function_fullname, Code::Handle(function.code()).EntryPoint());
+                function_fullname,
+                Code::Handle(function.CurrentCode()).EntryPoint());
     }
     if (FLAG_disassemble) {
       OS::Print("Code for %sfunction '%s' {\n",
                 optimized ? "optimized " : "", function_fullname);
-      const Code& code = Code::Handle(function.code());
+      const Code& code = Code::Handle(function.CurrentCode());
       const Instructions& instructions =
           Instructions::Handle(code.instructions());
       uword start = instructions.EntryPoint();
       Disassembler::Disassemble(start, start + assembler.CodeSize());
       OS::Print("}\n");
       OS::Print("Pointer offsets for function: {\n");
       for (intptr_t i = 0; i < code.pointer_offsets_length(); i++) {
         const uword addr = code.GetPointerOffsetAt(i) + code.EntryPoint();
         Object& obj = Object::Handle();
         obj = *reinterpret_cast<RawObject**>(addr);
@@ skipping 115 matching lines @@
     parsed_function.set_default_parameter_values(Array::Handle());
 
     Assembler assembler;
     CodeGenerator code_gen(&assembler, parsed_function);
     code_gen.GenerateCode();
     const Code& code = Code::Handle(Code::FinalizeCode(kEvalConst, &assembler));
 
     func.SetCode(code);
     CodeIndexTable* code_index_table = isolate->code_index_table();
     ASSERT(code_index_table != NULL);
-    code_index_table->AddFunction(func);
+    code_index_table->AddCode(code);
     // TODO(hausner): We need a way to remove these one-time execution
     // functions from the global code description (PC mapping) tables so
     // we don't pollute the system unnecessarily with stale data.
     code_gen.FinalizePcDescriptors(code);
     code_gen.FinalizeExceptionHandlers(code);
 
     GrowableArray<const Object*> arguments;  // no arguments.
     const Array& kNoArgumentNames = Array::Handle();
     result = DartEntry::InvokeStatic(func,
                                      arguments,
                                      kNoArgumentNames);
   } else {
     result = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
   }
   isolate->set_long_jump_base(base);
   return result.raw();
 }
 
 
 }  // namespace dart