Remove virtual functions on class InliningContext.

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 44 matching lines @@
     last_used_try_index_(CatchClauseNode::kInvalidTryIndex),
     try_index_(CatchClauseNode::kInvalidTryIndex),
     graph_entry_(NULL) { }
 
 
 void FlowGraphBuilder::AddCatchEntry(TargetEntryInstr* entry) {
   graph_entry_->AddCatchEntry(entry);
 }
 
 
-InliningContext* InliningContext::Create(Definition* call) {
-  return new ValueInliningContext();
-}
-
-
 void InliningContext::PrepareGraphs(FlowGraph* caller_graph,
                                     Definition* call,
                                     FlowGraph* callee_graph) {
   ASSERT(callee_graph->graph_entry()->SuccessorCount() == 1);
   ASSERT(callee_graph->max_block_id() > caller_graph->max_block_id());
   ASSERT(callee_graph->max_virtual_register_number() >
          caller_graph->max_virtual_register_number());
 
   // Adjust the caller's maximum block id and current SSA temp index.
   caller_graph->set_max_block_id(callee_graph->max_block_id());
@@ skipping 10 matching lines @@
       Instruction* instr = it.Current();
       // TODO(zerny): Avoid creating unnecessary environments. Note that some
       // optimizations need deoptimization info for non-deoptable instructions,
       // eg, LICM on GOTOs.
       if (instr->env() != NULL) call->env()->DeepCopyToOuter(instr);
     }
   }
 }
 
 
-void ValueInliningContext::AddExit(ReturnInstr* exit) {
+void InliningContext::AddExit(ReturnInstr* exit) {
   Data data = { NULL, exit };
   exits_.Add(data);
 }
 
 
-int ValueInliningContext::LowestBlockIdFirst(const Data* a, const Data* b) {
+int InliningContext::LowestBlockIdFirst(const Data* a, const Data* b) {
   return (a->exit_block->block_id() - b->exit_block->block_id());
 }
 
 
-void ValueInliningContext::SortExits() {
+void InliningContext::SortExits() {
   // Assign block entries here because we did not necessarily know them when
   // the return exit was added to the array.
   for (int i = 0; i < exits_.length(); ++i) {
     exits_[i].exit_block = exits_[i].exit_return->GetBlock();
   }
   exits_.Sort(LowestBlockIdFirst);
 }
 
 
-void ValueInliningContext::ReplaceCall(FlowGraph* caller_graph,
-                                       Definition* call,
-                                       FlowGraph* callee_graph) {
+void InliningContext::ReplaceCall(FlowGraph* caller_graph,
+                                  Definition* call,
+                                  FlowGraph* callee_graph) {
   ASSERT(call->previous() != NULL);
   ASSERT(call->next() != NULL);
   PrepareGraphs(caller_graph, call, callee_graph);
 
   BlockEntryInstr* caller_entry = call->GetBlock();
   TargetEntryInstr* callee_entry = callee_graph->graph_entry()->normal_entry();
 
   // Insert the callee graph into the caller graph.  First sort the list of
   // exits by block id (recording block entries as a side effect).
   SortExits();
@@ skipping 3164 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart