Add code comment to ia32 disassembly as well, bug fix new ia32 compiler, remove use of TMP register…

runtime/vm/intermediate_language_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 282 matching lines @@
   __ Bind(&done);
 }
 
 
 static Condition TokenKindToDoubleCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQUAL;
     case Token::kLT: return BELOW;
     case Token::kGT: return ABOVE;
     case Token::kLTE: return BELOW_EQUAL;
+    case Token::kGTE: return ABOVE_EQUAL;
     default:
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 static void EmitDoubleRelationalOp(FlowGraphCompiler* compiler,
                                    RelationalOpComp* comp) {
   Register left = comp->locs()->in(0).reg();
@@ skipping 328 matching lines @@
   __ popl(result);  // Pop new instance.
 }
 
 
 LocationSummary* LoadVMFieldComp::MakeLocationSummary() const {
   return LocationSummary::Make(1, Location::RequiresRegister());
 }
 
 
 void LoadVMFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Register obj = locs()->in(0).reg();
+  Register instance = locs()->in(0).reg();
   Register result = locs()->out().reg();
+  if (class_ids() != NULL) {
+    ASSERT(original() != NULL);
+    Label* deopt = compiler->AddDeoptStub(original()->cid(),
+                                          original()->token_index(),
+                                          original()->try_index(),
+                                          kDeoptInstanceGetterSameTarget,
+                                          instance,
+                                          kNoRegister);
+    // Smis do not have instance fields (Smi class is always first).
+    // Use 'result' as temporary register.
+    ASSERT(result != instance);
+    compiler->EmitClassChecksNoSmi(*class_ids(), instance, result, deopt);
+  }
 
-  __ movl(result, FieldAddress(obj, offset_in_bytes()));
+  __ movl(result, FieldAddress(instance, offset_in_bytes()));
 }
 
 
 LocationSummary* InstantiateTypeArgumentsComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
@@ skipping 255 matching lines @@
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kStackOverflowRuntimeEntry);
   __ Bind(&no_stack_overflow);
 }
 
 
 LocationSummary* BinaryOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
-  const intptr_t kNumTemps = 0;
   if (operands_type() == kDoubleOperands) {
+    const intptr_t kNumTemps = 1;
     LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
-    summary->set_out(Location::SameAsFirstInput());
+    summary->set_out(Location::RegisterLocation(EAX));
+    summary->set_temp(0, Location::RequiresRegister());
     return summary;
   }
   ASSERT(operands_type() == kSmiOperands);
   if (op_kind() == Token::kTRUNCDIV) {
     const intptr_t kNumTemps = 3;
     LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
     summary->set_in(0, Location::RegisterLocation(EAX));
     summary->set_in(1, Location::RegisterLocation(ECX));
     summary->set_out(Location::SameAsFirstInput());
     summary->set_temp(0, Location::RegisterLocation(EBX));
@@ skipping 157 matching lines @@
     }
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 static void EmitDoubleBinaryOp(FlowGraphCompiler* compiler,
                                BinaryOpComp* comp) {
-  // TODO(srdjan): Remove this code once BinaryOpComp has been implemeneted
-  // for all intended operations.
   Register left = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
+  Register temp = comp->locs()->temp(0).reg();
+  Register result = comp->locs()->out().reg();
+
+  const Class& double_class =
+      Class::ZoneHandle(Isolate::Current()->object_store()->double_class());
+  const Code& stub =
+    Code::Handle(StubCode::GetAllocationStubForClass(double_class));
+  const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
   __ pushl(left);
   __ pushl(right);
-  InstanceCallComp* instance_call_comp = comp->instance_call();
-  instance_call_comp->EmitNativeCode(compiler);
-  __ MoveRegister(comp->locs()->out().reg(), EAX);
+  compiler->GenerateCall(comp->instance_call()->token_index(),
+                         comp->instance_call()->try_index(),
+                         &label,
+                         PcDescriptors::kOther);
+  // Newly allocated object is now in the result register (RAX).
+  ASSERT(result == EAX);
+  __ popl(right);
+  __ popl(left);
+
+  Label* deopt = compiler->AddDeoptStub(comp->instance_call()->cid(),
+                                        comp->instance_call()->token_index(),
+                                        comp->instance_call()->try_index(),
+                                        kDeoptDoubleBinaryOp,
+                                        left,
+                                        right);
+
+  compiler->LoadDoubleOrSmiToXmm(XMM0, left, temp, deopt);
+  compiler->LoadDoubleOrSmiToXmm(XMM1, right, temp, deopt);
+
+  switch (comp->op_kind()) {
+    case Token::kADD: __ addsd(XMM0, XMM1); break;
+    case Token::kSUB: __ subsd(XMM0, XMM1); break;
+    case Token::kMUL: __ mulsd(XMM0, XMM1); break;
+    case Token::kDIV: __ divsd(XMM0, XMM1); break;
+    default: UNREACHABLE();
+  }
+
+  __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
 }
 
 
 void BinaryOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   switch (operands_type()) {
     case kSmiOperands:
       EmitSmiBinaryOp(compiler, this);
       break;
 
     case kDoubleOperands:
@@ skipping 115 matching lines @@
     UNREACHABLE();
   }
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64