Remove support for non-ssa optimizing code generation.

runtime/vm/flow_graph_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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
@@ skipping 59 matching lines @@
   }
 
   const DeoptInfo& deopt_info = DeoptInfo::Handle(builder.CreateDeoptInfo());
   return deopt_info.raw();
 }
 
 
 FlowGraphCompiler::FlowGraphCompiler(Assembler* assembler,
                                      const FlowGraph& flow_graph,
                                      bool is_optimizing,
-                                     bool is_ssa,
                                      bool is_leaf)
     : assembler_(assembler),
       parsed_function_(flow_graph.parsed_function()),
       block_order_(flow_graph.reverse_postorder()),
       current_block_(NULL),
       exception_handlers_list_(NULL),
       pc_descriptors_list_(NULL),
       stackmap_table_builder_(NULL),
       block_info_(block_order_.length()),
       deopt_stubs_(),
       object_table_(GrowableObjectArray::Handle(GrowableObjectArray::New())),
       is_optimizing_(is_optimizing),
-      is_ssa_(is_ssa),
       is_dart_leaf_(is_leaf),
       bool_true_(Bool::ZoneHandle(Bool::True())),
       bool_false_(Bool::ZoneHandle(Bool::False())),
       double_class_(Class::ZoneHandle(
           Isolate::Current()->object_store()->double_class())),
-      frame_register_allocator_(this, is_optimizing, is_ssa),
       parallel_move_resolver_(this) {
   ASSERT(assembler != NULL);
-  ASSERT(is_optimizing_ || !is_ssa_);
-  if (is_ssa_) {
+  if (is_optimizing_) {
     stackmap_table_builder_ = new StackmapTableBuilder(StackSize());
   }
 }
 
 
 FlowGraphCompiler::~FlowGraphCompiler() {
   // BlockInfos are zone-allocated, so their destructors are not called.
   // Verify the labels explicitly here.
   for (int i = 0; i < block_info_.length(); ++i) {
     ASSERT(!block_info_[i]->label.IsLinked());
@@ skipping 26 matching lines @@
 
 bool FlowGraphCompiler::CanOptimize() {
   return !FLAG_report_usage_count &&
          (FLAG_optimization_counter_threshold >= 0) &&
          !Isolate::Current()->debugger()->IsActive();
 }
 
 
 void FlowGraphCompiler::VisitBlocks() {
   for (intptr_t i = 0; i < block_order().length(); ++i) {
-    ASSERT(frame_register_allocator()->IsSpilled());
     assembler()->Comment("B%d", i);
     // Compile the block entry.
     BlockEntryInstr* entry = block_order()[i];
     set_current_block(entry);
     entry->PrepareEntry(this);
     // Compile all successors until an exit, branch, or a block entry.
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       Instruction* instr = it.Current();
       if (FLAG_code_comments) EmitComment(instr);
       if (instr->IsParallelMove()) {
@@ skipping 15 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);
 }
 
 
 intptr_t FlowGraphCompiler::StackSize() const {
-  if (is_ssa_) {
+  if (is_optimizing_) {
     return block_order_[0]->AsGraphEntry()->spill_slot_count();
   } else {
     return parsed_function_.stack_local_count() +
         parsed_function_.copied_parameter_count();
   }
 }
 
 
 Label* FlowGraphCompiler::GetBlockLabel(
     BlockEntryInstr* block_entry) const {
@@ skipping 49 matching lines @@
                                             intptr_t pc_offset) {
   exception_handlers_list_->AddHandler(try_index, pc_offset);
 }
 
 
 // Uses current pc position and try-index.
 void FlowGraphCompiler::AddCurrentDescriptor(PcDescriptors::Kind kind,
                                              intptr_t deopt_id,
                                              intptr_t token_pos,
                                              intptr_t try_index) {
-  ASSERT((kind != PcDescriptors::kDeopt) ||
-         frame_register_allocator()->IsSpilled());
   pc_descriptors_list()->AddDescriptor(kind,
                                        assembler()->CodeSize(),
                                        deopt_id,
                                        token_pos,
                                        try_index);
 }
 
 
 Label* FlowGraphCompiler::AddDeoptStub(intptr_t deopt_id,
                                        intptr_t try_index,
-                                       DeoptReasonId reason,
-                                       Register reg1,
-                                       Register reg2,
-                                       Register reg3) {
+                                       DeoptReasonId reason) {
   DeoptimizationStub* stub =
       new DeoptimizationStub(deopt_id, try_index, reason);
-  if (pending_deoptimization_env_ == NULL) {
-    ASSERT(!is_ssa_);
-    frame_register_allocator()->SpillInDeoptStub(stub);
-    if (reg1 != kNoRegister) stub->Push(reg1);
-    if (reg2 != kNoRegister) stub->Push(reg2);
-    if (reg3 != kNoRegister) stub->Push(reg3);
-  } else {
-    ASSERT(pending_deoptimization_env_ != NULL);
-    stub->set_deoptimization_env(pending_deoptimization_env_);
-  }
+  ASSERT(is_optimizing_);
+  ASSERT(pending_deoptimization_env_ != NULL);
+  stub->set_deoptimization_env(pending_deoptimization_env_);
   deopt_stubs_.Add(stub);
   return stub->entry_label();
 }
 
 
 void FlowGraphCompiler::FinalizeExceptionHandlers(const Code& code) {
   ASSERT(exception_handlers_list_ != NULL);
   const ExceptionHandlers& handlers = ExceptionHandlers::Handle(
       exception_handlers_list_->FinalizeExceptionHandlers(code.EntryPoint()));
   code.set_exception_handlers(handlers);
@@ skipping 24 matching lines @@
 
 
 void FlowGraphCompiler::FinalizeStackmaps(const Code& code) {
   if (stackmap_table_builder_ == NULL) {
     // The unoptimizing compiler has no stack maps.
     code.set_stackmaps(Array::Handle());
   } else {
     // Finalize the stack map array and add it to the code object.
     code.set_stackmaps(
         Array::Handle(stackmap_table_builder_->FinalizeStackmaps(code)));
-    ASSERT(is_ssa() && is_optimizing());
+    ASSERT(is_optimizing());
   }
 }
 
 
 void FlowGraphCompiler::FinalizeVarDescriptors(const Code& code) {
   const LocalVarDescriptors& var_descs = LocalVarDescriptors::Handle(
           parsed_function_.node_sequence()->scope()->GetVarDescriptors(
               parsed_function_.function()));
   code.set_var_descriptors(var_descs);
 }
@@ skipping 48 matching lines @@
 void FlowGraphCompiler::GenerateInstanceCall(
     intptr_t deopt_id,
     intptr_t token_pos,
     intptr_t try_index,
     const String& function_name,
     intptr_t argument_count,
     const Array& argument_names,
     intptr_t checked_argument_count,
     BitmapBuilder* stack_bitmap) {
   ASSERT(!IsLeaf());
-  ASSERT(frame_register_allocator()->IsSpilled());
   ICData& ic_data =
       ICData::ZoneHandle(ICData::New(parsed_function().function(),
                                      function_name,
                                      deopt_id,
                                      checked_argument_count));
   const Array& arguments_descriptor =
       DartEntry::ArgumentsDescriptor(argument_count, argument_names);
   uword label_address = 0;
   switch (checked_argument_count) {
     case 1:
       label_address = StubCode::OneArgCheckInlineCacheEntryPoint();
       break;
     case 2:
       label_address = StubCode::TwoArgsCheckInlineCacheEntryPoint();
       break;
     default:
       UNIMPLEMENTED();
   }
   ExternalLabel target_label("InlineCache", label_address);
 
   const intptr_t descr_offset = EmitInstanceCall(&target_label,
                                                  ic_data,
                                                  arguments_descriptor,
                                                  argument_count);
-  if (is_ssa() && (stack_bitmap != NULL)) {
+  if (is_optimizing() && (stack_bitmap != NULL)) {
     stackmap_table_builder_->AddEntry(descr_offset, stack_bitmap);
   }
   pc_descriptors_list()->AddDescriptor(PcDescriptors::kIcCall,
                                        descr_offset,
                                        deopt_id,
                                        token_pos,
                                        try_index);
 }
 
 
 void FlowGraphCompiler::GenerateStaticCall(intptr_t deopt_id,
                                            intptr_t token_pos,
                                            intptr_t try_index,
                                            const Function& function,
                                            intptr_t argument_count,
                                            const Array& argument_names,
                                            BitmapBuilder* stack_bitmap) {
-  ASSERT(frame_register_allocator()->IsSpilled());
-
   const Array& arguments_descriptor =
       DartEntry::ArgumentsDescriptor(argument_count, argument_names);
   const intptr_t descr_offset = EmitStaticCall(function,
                                                arguments_descriptor,
                                                argument_count);
-  if (is_ssa() && (stack_bitmap != NULL)) {
+  if (is_optimizing() && (stack_bitmap != NULL)) {
     stackmap_table_builder_->AddEntry(descr_offset, stack_bitmap);
   }
   pc_descriptors_list()->AddDescriptor(PcDescriptors::kFuncCall,
                                        descr_offset,
                                        deopt_id,
                                        token_pos,
                                        try_index);
 }
 
 
@@ skipping 115 matching lines @@
   assembler()->j(true_condition, &is_true, Assembler::kNearJump);
   assembler()->Bind(&is_false);
   assembler()->LoadObject(result, bool_false());
   assembler()->jmp(&done);
   assembler()->Bind(&is_true);
   assembler()->LoadObject(result, bool_true());
   assembler()->Bind(&done);
 }
 
 
-Register FrameRegisterAllocator::AllocateFreeRegister(bool* blocked_registers) {
+// Allocate a register that is not explicitly blocked.
+static Register AllocateFreeRegister(bool* blocked_registers) {
   for (intptr_t regno = 0; regno < kNumberOfCpuRegisters; regno++) {
-    if (!blocked_registers[regno] && (registers_[regno] == NULL)) {
+    if (!blocked_registers[regno]) {
       blocked_registers[regno] = true;
       return static_cast<Register>(regno);
     }
   }
-  return SpillFirst();
+  UNREACHABLE();
+  return kNoRegister;
 }
 
 
-Register FrameRegisterAllocator::SpillFirst() {
-  ASSERT(!stack_.is_empty());
-  Register reg = stack_[0];
-  stack_.RemoveFirst();
-  compiler()->assembler()->PushRegister(reg);
-  registers_[reg] = NULL;
-  return reg;
-}
-
-
-void FrameRegisterAllocator::SpillRegister(Register reg) {
-  while (registers_[reg] != NULL) SpillFirst();
-}
-
-
-void FrameRegisterAllocator::AllocateRegisters(Instruction* instr) {
-  if (is_ssa_) return;
+void FlowGraphCompiler::AllocateRegistersLocally(Instruction* instr) {
+  ASSERT(!is_optimizing());
 
   LocationSummary* locs = instr->locs();
 
   bool blocked_registers[kNumberOfCpuRegisters];
-  bool blocked_temp_registers[kNumberOfCpuRegisters];
-
-  bool spill = false;
 
   // Mark all available registers free.
   for (intptr_t i = 0; i < kNumberOfCpuRegisters; i++) {
     blocked_registers[i] = false;
-    blocked_temp_registers[i] = false;
   }
 
   // Mark all fixed input, temp and output registers as used.
   for (intptr_t i = 0; i < locs->input_count(); i++) {
     Location loc = locs->in(i);
     if (loc.IsRegister()) {
       ASSERT(!blocked_registers[loc.reg()]);
       blocked_registers[loc.reg()] = true;
-      if (registers_[loc.reg()] != NULL) {
-        intptr_t stack_index = stack_.length() - (locs->input_count() - i);
-        if ((stack_index < 0) || (stack_[stack_index] != loc.reg())) {
-          spill = true;
-        }
-      }
     }
   }
 
-  if (spill) Spill();
-
   for (intptr_t i = 0; i < locs->temp_count(); i++) {
     Location loc = locs->temp(i);
     if (loc.IsRegister()) {
       ASSERT(!blocked_registers[loc.reg()]);
       blocked_registers[loc.reg()] = true;
-      blocked_temp_registers[loc.reg()] = true;
     }
   }
 
   if (locs->out().IsRegister()) {
     // Fixed output registers are allowed to overlap with
     // temps and inputs.
     blocked_registers[locs->out().reg()] = true;
   }
 
   // Do not allocate known registers.
   blocked_registers[CTX] = true;
   blocked_registers[SPREG] = true;
   blocked_registers[FPREG] = true;
   if (TMP != kNoRegister) {
     blocked_registers[TMP] = true;
   }
 
   // Allocate all unallocated input locations.
+  const bool should_pop = !instr->IsPushArgument();
   for (intptr_t i = locs->input_count() - 1; i >= 0; i--) {
     Location loc = locs->in(i);
     Register reg = kNoRegister;
     if (loc.IsRegister()) {
       reg = loc.reg();
     } else if (loc.IsUnallocated()) {
       ASSERT(loc.policy() == Location::kRequiresRegister);
-      if (!stack_.is_empty() && !blocked_temp_registers[stack_.Last()]) {
-        reg = stack_.Last();
-        blocked_registers[reg] = true;
-      } else {
-        reg = AllocateFreeRegister(blocked_registers);
-      }
+      reg = AllocateFreeRegister(blocked_registers);
       locs->set_in(i, Location::RegisterLocation(reg));
     }
 
     // Inputs are consumed from the simulated frame. In case of a call argument
     // we leave it until the call instruction.
-    if (!instr->IsPushArgument()) Pop(reg, instr->InputAt(i));
-  }
-
-  // If this instruction is call spill everything that was not consumed by
-  // input locations.
-  if (locs->can_call() || instr->IsBranch() || instr->IsGoto()) {
-    Spill();
+    if (should_pop) {
+      assembler()->PopRegister(reg);
+    }
   }
 
   // Allocate all unallocated temp locations.
   for (intptr_t i = 0; i < locs->temp_count(); i++) {
     Location loc = locs->temp(i);
     if (loc.IsUnallocated()) {
       ASSERT(loc.policy() == Location::kRequiresRegister);
       loc = Location::RegisterLocation(
         AllocateFreeRegister(blocked_registers));
       locs->set_temp(i, loc);
     }
-    SpillRegister(loc.reg());
   }
 
   Location result_location = locs->out();
   if (result_location.IsUnallocated()) {
     switch (result_location.policy()) {
       case Location::kAny:
       case Location::kPrefersRegister:
       case Location::kRequiresRegister:
         result_location = Location::RegisterLocation(
             AllocateFreeRegister(blocked_registers));
         break;
       case Location::kSameAsFirstInput:
         result_location = locs->in(0);
         break;
     }
     locs->set_out(result_location);
   }
-
-  if (result_location.IsRegister()) {
-    SpillRegister(result_location.reg());
-  }
 }
 
 
-void FrameRegisterAllocator::Pop(Register dst, Value* val) {
-  if (is_ssa_) return;
-
-  if (!stack_.is_empty()) {
-    ASSERT(keep_values_in_registers_);
-    Register src = stack_.Last();
-    ASSERT(val->AsUse()->definition() == registers_[src]);
-    stack_.RemoveLast();
-    registers_[src] = NULL;
-    compiler()->assembler()->MoveRegister(dst, src);
-  } else {
-    compiler()->assembler()->PopRegister(dst);
-  }
-}
-
-
-void FrameRegisterAllocator::Push(Register reg, BindInstr* val) {
-  if (is_ssa_) return;
-
-  ASSERT(registers_[reg] == NULL);
-  if (keep_values_in_registers_) {
-    registers_[reg] = val;
-    stack_.Add(reg);
-  } else {
-    compiler()->assembler()->PushRegister(reg);
-  }
-}
-
-
-void FrameRegisterAllocator::Spill() {
-  if (is_ssa_) return;
-
-  for (int i = 0; i < stack_.length(); i++) {
-    Register r = stack_[i];
-    registers_[r] = NULL;
-    compiler()->assembler()->PushRegister(r);
-  }
-  stack_.Clear();
-}
-
-
-void FrameRegisterAllocator::SpillInDeoptStub(DeoptimizationStub* stub) {
-  if (is_ssa_) return;
-
-  for (int i = 0; i < stack_.length(); i++) {
-    stub->Push(stack_[i]);
-  }
-}
-
-
 ParallelMoveResolver::ParallelMoveResolver(FlowGraphCompiler* compiler)
     : compiler_(compiler), moves_(32) {}
 
 
 void ParallelMoveResolver::EmitNativeCode(ParallelMoveInstr* parallel_move) {
   ASSERT(moves_.is_empty());
   // Build up a worklist of moves.
   BuildInitialMoveList(parallel_move);
 
   for (int i = 0; i < moves_.length(); ++i) {
@@ skipping 89 matching lines @@
       return;
     }
   }
 
   // This move is not blocked.
   EmitMove(index);
 }
 
 
 }  // namespace dart