Revert "Introduce Goto instructions to the flow graph."

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 240 matching lines @@
 
 void ThrowInstr::SetInputAt(intptr_t i, Value* value) {
   if (i == 0) {
     exception_ = value;
     return;
   }
   UNREACHABLE();
 }
 
 
-intptr_t GotoInstr::InputCount() const {
-  return 0;
-}
-
-
-Value* GotoInstr::InputAt(intptr_t i) const {
-  UNREACHABLE();
-  return NULL;
-}
-
-
-void GotoInstr::SetInputAt(intptr_t i, Value* value) {
-  UNREACHABLE();
-}
-
-
 intptr_t ReturnInstr::InputCount() const {
   return 1;
 }
 
 
 Value* ReturnInstr::InputAt(intptr_t i) const {
   if (i == 0) return value();
   UNREACHABLE();
   return NULL;
 }
@@ skipping 209 matching lines @@
   ASSERT(next() != NULL);
   Instruction* next_instr = next();
   if (next_instr->IsBlockEntry()) {
     set_last_instruction(this);
   } else {
     while ((next_instr != NULL) &&
            !next_instr->IsBlockEntry() &&
            !next_instr->IsBranch()) {
       if (vars != NULL) next_instr->RecordAssignedVars(vars);
       set_last_instruction(next_instr);
-      GotoInstr* goto_instr = next_instr->AsGoto();
-      next_instr =
-          (goto_instr != NULL) ? goto_instr->successor() : next_instr->next();
+      next_instr = next_instr->next();
     }
   }
   if (next_instr != NULL) {
     next_instr->DiscoverBlocks(this, preorder, postorder,
                                parent, assigned_vars, variable_count);
   }
 
   // 6. Assign postorder number and add the block entry to the list.
   set_postorder_number(postorder->length());
   postorder->Add(this);
@@ skipping 31 matching lines @@
       phis_->Add(NULL);
     }
   }
   ASSERT((*phis_)[var_index] == NULL);
   (*phis_)[var_index] = new PhiInstr(PredecessorCount());
   phi_count_++;
 }
 
 
 intptr_t Instruction::SuccessorCount() const {
-  return 0;
+  ASSERT(next() == NULL || next()->IsBlockEntry());
+  return (next() != NULL) ? 1 : 0;
 }
 
 
 BlockEntryInstr* Instruction::SuccessorAt(intptr_t index) const {
-  // Called only if index is in range.  Only control-transfer instructions
-  // can have non-zero successor counts and they override this function.
-  UNREACHABLE();
-  return NULL;
+  return next()->AsBlockEntry();
 }
 
 
 intptr_t GraphEntryInstr::SuccessorCount() const {
   return 1 + catch_entries_.length();
 }
 
 
 BlockEntryInstr* GraphEntryInstr::SuccessorAt(intptr_t index) const {
   if (index == 0) return normal_entry_;
   return catch_entries_[index - 1];
 }
 
 
 intptr_t BranchInstr::SuccessorCount() const {
   return 2;
 }
 
 
 BlockEntryInstr* BranchInstr::SuccessorAt(intptr_t index) const {
   if (index == 0) return true_successor_;
   if (index == 1) return false_successor_;
   UNREACHABLE();
   return NULL;
 }
 
 
-intptr_t GotoInstr::SuccessorCount() const {
-  return 1;
-}
-
-
-BlockEntryInstr* GotoInstr::SuccessorAt(intptr_t index) const {
-  ASSERT(index == 0);
-  return successor();
-}
-
-
-void Instruction::Goto(JoinEntryInstr* entry) {
-  set_next(new GotoInstr(entry));
-}
-
-
 // ==== Support for propagating static type.
 RawAbstractType* ConstantVal::StaticType() const {
   if (value().IsInstance()) {
     return Instance::Cast(value()).GetType();
   } else {
     UNREACHABLE();
     return AbstractType::null();
   }
 }
 
@@ skipping 394 matching lines @@
   ASSERT(exception()->IsUse());
   ASSERT(stack_trace()->IsUse());
   compiler->GenerateCallRuntime(cid(),
                                 token_pos(),
                                 try_index(),
                                 kReThrowRuntimeEntry);
   __ int3();
 }
 
 
-LocationSummary* GotoInstr::MakeLocationSummary() const {
-  return new LocationSummary(0, 0);
-}
-
-
-void GotoInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  // We can fall through if the successor is the next block in the list.
-  // Otherwise, we need a jump.
-  if (!compiler->IsNextBlock(successor())) {
-    __ jmp(compiler->GetBlockLabel(successor()));
-  }
-}
-
-
 LocationSummary* BranchInstr::MakeLocationSummary() const {
   if (is_fused_with_comparison()) {
     return fused_with_comparison_->locs();
   } else {
     const int kNumInputs = 1;
     const int kNumTemps = 0;
     LocationSummary* locs = new LocationSummary(kNumInputs,
                                                 kNumTemps,
                                                 LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
@@ skipping 308 matching lines @@
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_pos(), try_index(), &label,
                          PcDescriptors::kOther);
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 
 #undef __
 
 }  // namespace dart