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

runtime/vm/debugger.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/debugger.h"
 
 #include "vm/code_index_table.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 13 matching lines @@
 static const bool verbose = false;
 
 
 Breakpoint::Breakpoint(const Function& func, intptr_t pc_desc_index)
     : function_(func.raw()),
       pc_desc_index_(pc_desc_index),
       pc_(0),
       saved_bytes_(0),
       line_number_(-1),
       next_(NULL) {
-  Code& code = Code::Handle(func.code());
+  ASSERT(!func.HasOptimizedCode());
+  Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());  // Function must be compiled.
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   ASSERT(pc_desc_index < desc.Length());
   this->token_index_ = desc.TokenIndex(pc_desc_index);
   ASSERT(this->token_index_ > 0);
   this->pc_ = desc.PC(pc_desc_index);
   ASSERT(this->pc_ != 0);
 }
 
 
@@ skipping 35 matching lines @@
       var_descriptors_(NULL),
       desc_indices_(8) {
 }
 
 
 const Function& ActivationFrame::DartFunction() {
   if (function_.IsNull()) {
     ASSERT(Isolate::Current() != NULL);
     CodeIndexTable* code_index_table = Isolate::Current()->code_index_table();
     ASSERT(code_index_table != NULL);
-    function_ = code_index_table->LookupFunction(pc_);
+    const Code& code = Code::Handle(code_index_table->LookupCode(pc_));
+    function_ = code.function();
   }
   return function_;
 }
 
 
 const char* Debugger::QualifiedFunctionName(const Function& func) {
   const String& func_name = String::Handle(func.name());
   Class& func_class = Class::Handle(func.owner());
   String& class_name = String::Handle(func_class.Name());
 
@@ skipping 28 matching lines @@
 RawScript* ActivationFrame::SourceScript() {
   const Function& func = DartFunction();
   const Class& cls = Class::Handle(func.owner());
   return cls.script();
 }
 
 
 intptr_t ActivationFrame::TokenIndex() {
   if (token_index_ < 0) {
     const Function& func = DartFunction();
-    Code& code = Code::Handle(func.code());
+    ASSERT(!func.HasOptimizedCode());
+    Code& code = Code::Handle(func.unoptimized_code());
     ASSERT(!code.IsNull());
     PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
     for (int i = 0; i < desc.Length(); i++) {
       if (desc.PC(i) == pc_) {
         token_index_ = desc.TokenIndex(i);
         break;
       }
     }
     ASSERT(token_index_ >= 0);
   }
   return token_index_;
 }
 
 
 intptr_t ActivationFrame::LineNumber() {
   // Compute line number lazily since it causes scanning of the script.
   if (line_number_ < 0) {
     const Script& script = Script::Handle(SourceScript());
     intptr_t ignore_column;
     script.GetTokenLocation(TokenIndex(), &line_number_, &ignore_column);
   }
   return line_number_;
 }
 
 
 void ActivationFrame::GetDescIndices() {
   if (var_descriptors_ == NULL) {
-    const Code& code = Code::Handle(DartFunction().code());
+    ASSERT(!DartFunction().HasOptimizedCode());
+    const Code& code = Code::Handle(DartFunction().unoptimized_code());
     var_descriptors_ =
         &LocalVarDescriptors::ZoneHandle(code.var_descriptors());
     GrowableArray<String*> var_names(8);
     intptr_t activation_token_pos = TokenIndex();
     intptr_t var_desc_len = var_descriptors_->Length();
     for (int cur_idx = 0; cur_idx < var_desc_len; cur_idx++) {
       ASSERT(var_names.length() == desc_indices_.length());
       intptr_t scope_id, begin_pos, end_pos;
       var_descriptors_->GetScopeInfo(cur_idx, &scope_id, &begin_pos, &end_pos);
       if ((begin_pos <= activation_token_pos) &&
@@ skipping 176 matching lines @@
       (target_function.end_token_index() <= token_index)) {
     // The given token position is not within the target function.
     return NULL;
   }
   if (!target_function.HasCode()) {
     *error = Compiler::CompileFunction(target_function);
     if (!error->IsNull()) {
       return NULL;
     }
   }
-  Code& code = Code::Handle(target_function.code());
+  ASSERT(!target_function.HasOptimizedCode());
+  Code& code = Code::Handle(target_function.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   for (int i = 0; i < desc.Length(); i++) {
     if (desc.TokenIndex(i) < token_index) {
       continue;
     }
     PcDescriptors::Kind kind = desc.DescriptorKind(i);
     Breakpoint* bpt = NULL;
     if (kind == PcDescriptors::kIcCall) {
       bpt = GetBreakpoint(desc.PC(i));
@@ skipping 13 matching lines @@
       if ((desc.TokenIndex(i) > 0) && CodePatcher::IsDartCall(desc.PC(i))) {
         bpt = GetBreakpoint(desc.PC(i));
         if (bpt != NULL) {
           // There is an existing breakpoint at this token position.
           break;
         }
         bpt = new Breakpoint(target_function, i);
         Function& func = Function::Handle();
         CodePatcher::GetStaticCallAt(desc.PC(i), &func, &bpt->saved_bytes_);
         CodePatcher::PatchStaticCallAt(
-          desc.PC(i), StubCode::BreakpointStaticEntryPoint());
+            desc.PC(i), StubCode::BreakpointStaticEntryPoint());
         RegisterBreakpoint(bpt);
       }
     }
     if (bpt != NULL) {
       if (verbose) {
         OS::Print("Setting breakpoint at '%s' line %d  (PC %p)\n",
                   String::Handle(bpt->SourceUrl()).ToCString(),
                   bpt->LineNumber(),
                   bpt->pc());
       }
       return bpt;
     }
   }
   return NULL;
 }
 
 
 void Debugger::UnsetBreakpoint(Breakpoint* bpt) {
   const Function& func = Function::Handle(bpt->function());
-  const Code& code = Code::Handle(func.code());
+  ASSERT(!func.HasOptimizedCode());
+  const Code& code = Code::Handle(func.unoptimized_code());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   intptr_t desc_index = bpt->pc_desc_index();
   ASSERT(desc_index < desc.Length());
   ASSERT(bpt->pc() == desc.PC(desc_index));
   PcDescriptors::Kind kind = desc.DescriptorKind(desc_index);
   if (kind == PcDescriptors::kIcCall) {
     CodePatcher::PatchInstanceCallAt(desc.PC(desc_index), bpt->saved_bytes_);
   } else {
     CodePatcher::PatchStaticCallAt(desc.PC(desc_index), bpt->saved_bytes_);
   }
@@ skipping 261 matching lines @@
 
 
 void Debugger::RegisterBreakpoint(Breakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(this->breakpoints_);
   this->breakpoints_ = bpt;
 }
 
 
 }  // namespace dart