First step toward an optimizing compiler:

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 "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
+#include "vm/object_store.h"
 #include "vm/stub_code.h"
 
 #define __ compiler->assembler()->
 
 namespace dart {
 
 
 // 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) {
@@ skipping 110 matching lines @@
 }
 
 
 LocationSummary* InstanceCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void InstanceCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(VerifyCallComputation(this));
+  compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
+                                 cid(),
+                                 token_index(),
+                                 try_index());
   compiler->EmitInstanceCall(cid(),
                              token_index(),
                              try_index(),
                              function_name(),
                              ArgumentCount(),
                              argument_names(),
                              checked_argument_count());
 }
 
 
@@ skipping 327 matching lines @@
 void CatchEntryComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* CatchEntryComp::MakeLocationSummary() const {
   return NULL;
 }
 
 
+LocationSummary* BinaryOpComp::MakeLocationSummary() const {
+  return MakeSimpleLocationSummary(2, Location::SameAsFirstInput());
+}
+
+
+// TODO(srdjan): Implement variations.
+static bool EmitSmiBinaryOp(FlowGraphCompiler* compiler,
+                            BinaryOpComp* comp) {
+  ASSERT((comp->ic_data() != NULL));
+  const ICData& ic_data = *comp->ic_data();
+  if (ic_data.IsNull()) return false;
+  if (ic_data.num_args_tested() != 2) return false;
+  if (ic_data.NumberOfChecks() != 1) return false;
+  Function& target = Function::Handle();
+  GrowableArray<const Class*> classes;
+  ic_data.GetCheckAt(0, &classes, &target);
+  const Class& smi_class =
+      Class::Handle(Isolate::Current()->object_store()->smi_class());
+  if ((classes[0]->raw() != smi_class.raw()) ||
+      (classes[1]->raw() != smi_class.raw())) {
+    return false;
+  }
+  // TODO(srdjan): need to allocate a temporary register (now using r10)
+  Register left = comp->locs()->in(0).reg();
+  Register right = comp->locs()->in(1).reg();
+  Register result = comp->locs()->out().reg();
+  Register kTemp = R10;

[Florian Schneider, 2012/05/24 00:20:39]

It is a little confusing to use "k" as prefix for registers. Maybe just 

Register temp = R10;

+  Label* deopt = compiler->AddDeoptStub(comp->instance_call()->cid(),
+                                        comp->instance_call()->token_index(),
+                                        comp->instance_call()->try_index(),
+                                        kDeoptSmiBinaryOp,
+                                        kTemp,
+                                        right);
+  __ movq(kTemp, left);
+  __ orq(left, right);
+  __ testq(left, Immediate(kSmiTagMask));
+  __ j(NOT_ZERO, deopt);
+  __ movq(left, kTemp);
+  switch (comp->op_kind()) {
+    case Token::kADD: {
+      __ addq(left, right);
+      __ j(OVERFLOW, deopt);
+      if (result != left) {
+        __ movq(result, left);
+      }
+      break;
+    }
+    default:
+      UNREACHABLE();
+  }
+  return true;
+}
+
+void BinaryOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+  if (EmitSmiBinaryOp(compiler, this)) {

[Florian Schneider, 2012/05/24 00:20:39]

Maybe rename it to TryEmitSmiBinaryOp to indicate that it may fail.

[srdjan, 2012/05/24 01:36:26]

Done.

+    // Operation inlined.
+    return;
+  }
+  Register left = locs()->in(0).reg();
+  Register right = locs()->in(1).reg();
+  __ pushq(left);
+  __ pushq(right);
+  InstanceCallComp* instance_call_comp = instance_call();
+  instance_call_comp->EmitNativeCode(compiler);
+  if (locs()->out().reg() != RAX) {
+    __ movq(locs()->out().reg(), RAX);
+  }
+}
+
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64