Revert change 6302 until the compiler warning is addressed.

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"
 #include "vm/code_patcher.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/disassembler.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
@@ skipping 101 matching lines @@
     const char* function_fullname = function.ToFullyQualifiedCString();
     if (FLAG_trace_compiler) {
       OS::Print("Compiling %sfunction: '%s' @ token %d\n",
                 (optimized ? "optimized " : ""),
                 function_fullname,
                 function.token_index());
     }
     Parser::ParseFunction(&parsed_function);
     parsed_function.AllocateVariables();
 
+    CodeIndexTable* code_index_table = isolate->code_index_table();
+    ASSERT(code_index_table != NULL);
     bool is_compiled = false;
     if (FLAG_use_new_compiler) {
       ASSERT(!optimized);
       LongJump* old_base = isolate->long_jump_base();
       LongJump bailout_jump;
       isolate->set_long_jump_base(&bailout_jump);
       if (setjmp(*bailout_jump.Set()) == 0) {
         FlowGraphBuilder graph_builder(parsed_function);
         graph_builder.BuildGraph();
 
@@ skipping 11 matching lines @@
         graph_compiler.CompileGraph();
         const Code& code =
             Code::Handle(Code::FinalizeCode(function_fullname, &assembler));
         code.set_is_optimized(false);
         graph_compiler.FinalizePcDescriptors(code);
         graph_compiler.FinalizeVarDescriptors(code);
         graph_compiler.FinalizeExceptionHandlers(code);
         function.set_unoptimized_code(code);
         function.SetCode(code);
         ASSERT(CodePatcher::CodeIsPatchable(code));
+        code_index_table->AddCode(code);
         is_compiled = true;
       } else {
         // We bailed out.
         Error& bailout_error = Error::Handle(
             isolate->object_store()->sticky_error());
         isolate->object_store()->clear_sticky_error();
         if (FLAG_trace_bailout) {
           OS::Print("%s\n", bailout_error.ToErrorCString());
         }
       }
@@ skipping 17 matching lines @@
         }
         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.FinalizeStackmaps(code);
         code_gen.FinalizeExceptionHandlers(code);
         function.SetCode(code);
+        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(!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.FinalizeStackmaps(code);
           code_gen.FinalizeVarDescriptors(code);
           code_gen.FinalizeExceptionHandlers(code);
           function.set_unoptimized_code(code);
           function.SetCode(code);
           ASSERT(CodePatcher::CodeIsPatchable(code));
+          code_index_table->AddCode(code);
         } else {
           // Disable optimized 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.CurrentCode()).EntryPoint());
           }
           // Use previously compiled code.
@@ skipping 134 matching lines @@
     ParsedFunction parsed_function(func);
     parsed_function.set_node_sequence(fragment);
     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->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.FinalizeStackmaps(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