Move Throw and ReThrow to the location based code generation.

runtime/vm/intermediate_language_x64.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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "lib/error.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 
 #define __ compiler->assembler()->
 
 namespace dart {
 
 
+static LocationSummary* MakeSimpleLocationSummary(
+    intptr_t input_count, Location out) {
+  LocationSummary* summary = new LocationSummary(input_count, 0);
+  for (intptr_t i = 0; i < input_count; i++) {
+    summary->set_in(i, Location::RequiresRegister());
+  }
+  summary->set_out(out);
+  return summary;
+}
+
+
 // True iff. the arguments to a call will be properly pushed and can
 // be popped after the call.
 template <typename T> static bool VerifyCallComputation(T* comp) {
   // Argument values should be consecutive temps.
   //
   // TODO(kmillikin): implement stack height tracking so we can also assert
   // they are on top of the stack.
   intptr_t previous = -1;
   for (int i = 0; i < comp->ArgumentCount(); ++i) {
     Value* val = comp->ArgumentAt(i);
@@ skipping 15 matching lines @@
      v2->AsUse()->definition()->temp_index();
 }
 
 
 void BindInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   computation()->EmitNativeCode(compiler);
   __ pushq(locs()->out().reg());
 }
 
 
-static LocationSummary* MakeSimpleLocationSummary(
-    intptr_t input_count, Location out) {
-  LocationSummary* summary = new LocationSummary(input_count, 0);
-  for (intptr_t i = 0; i < input_count; i++) {
-    summary->set_in(i, Location::RequiresRegister());
-  }
-  summary->set_out(out);
-  return summary;
+LocationSummary* ThrowInstr::MakeLocationSummary() const {
+  const int kNumInputs = 0;
+  const int kNumTemps = 0;
+  return new LocationSummary(kNumInputs, kNumTemps);
 }
 
 
+void ThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  ASSERT(exception()->IsUse());
+  compiler->GenerateCallRuntime(cid(),
+                                token_index(),
+                                try_index(),
+                                kThrowRuntimeEntry);
+  __ int3();
+}
+
+
+LocationSummary* ReThrowInstr::MakeLocationSummary() const {
+  const int kNumInputs = 0;
+  const int kNumTemps = 0;
+  return new LocationSummary(kNumInputs, kNumTemps);
+}
+
+
+void ReThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  ASSERT(exception()->IsUse());
+  ASSERT(stack_trace()->IsUse());
+  compiler->GenerateCallRuntime(cid(),
+                                token_index(),
+                                try_index(),
+                                kReThrowRuntimeEntry);
+  __ int3();
+}
+
+
+LocationSummary* BranchInstr::MakeLocationSummary() const {
+  const int kNumInputs = 1;
+  const int kNumTemps = 1;
+  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+  locs->set_in(0, Location::RequiresRegister());
+  locs->set_temp(0, Location::RequiresRegister());
+  return locs;
+}
+
+
+void BranchInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register value = locs()->in(0).reg();
+  Register temp = locs()->temp(0).reg();
+
+  __ LoadObject(temp, Bool::ZoneHandle(Bool::True()));
+  __ cmpq(value, temp);
+  if (compiler->IsNextBlock(false_successor())) {
+    // If the next block is the false sucessor we will fall through to it if
+    // comparison with true fails.
+    __ j(EQUAL, compiler->GetBlockLabel(true_successor()));
+  } else {
+    // If the next block is the true sucessor we negate comparison and fall
+    // through to it.
+    __ j(NOT_EQUAL, compiler->GetBlockLabel(false_successor()));
+  }
+}
+
+
 LocationSummary* CurrentContextComp::MakeLocationSummary() const {
   return MakeSimpleLocationSummary(0, Location::RequiresRegister());
 }
 
 
 void CurrentContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ movq(locs()->out().reg(), CTX);
 }
 
 
@@ skipping 889 matching lines @@
   if (locs()->out().reg() != RAX) {
     __ movq(locs()->out().reg(), RAX);
   }
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64