Implemented in ia32: branch, strict compare, instance setter, instanceof and assertassigneable with…

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 "vm/flow_graph_compiler.h"
@@ skipping 138 matching lines @@
   return NULL;
 }
 
 
 void ReThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* BranchInstr::MakeLocationSummary() const {
-  return NULL;
+  const int kNumInputs = 1;
+  const int kNumTemps = 0;
+  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+  locs->set_in(0, Location::RequiresRegister());
+  return locs;
 }
 
 
 void BranchInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  Register value = locs()->in(0).reg();
+  __ CompareObject(value,  Bool::ZoneHandle(Bool::True()));
+  if (compiler->IsNextBlock(false_successor())) {
+    // If the next block is the false successor we will fall through to it if
+    // comparison with true fails.
+    __ j(EQUAL, compiler->GetBlockLabel(true_successor()));
+  } else {
+    ASSERT(compiler->IsNextBlock(true_successor()));
+    // If the next block is the true successor we negate comparison and fall
+    // through to it.
+    __ j(NOT_EQUAL, compiler->GetBlockLabel(false_successor()));
+  }
 }
 
 
 LocationSummary* CurrentContextComp::MakeLocationSummary() const {
   return LocationSummary::Make(0, Location::RequiresRegister());
 }
 
 
 void CurrentContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ movl(locs()->out().reg(), CTX);
 }
 
 
 LocationSummary* StoreContextComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
   summary->set_in(0, Location::RegisterLocation(CTX));
   return summary;
 }
 
 
 void StoreContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Nothing to do.  Context register were loaded by register allocator.
   ASSERT(locs()->in(0).reg() == CTX);
 }
 
 
 LocationSummary* StrictCompareComp::MakeLocationSummary() const {
-  return NULL;
+  return LocationSummary::Make(2, Location::SameAsFirstInput());
 }
 
 
 void StrictCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
+  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
+
+  Register left = locs()->in(0).reg();
+  Register right = locs()->in(1).reg();
+  Register result = locs()->out().reg();
+
+  __ cmpl(left, right);
+  Label load_true, done;
+  if (kind() == Token::kEQ_STRICT) {
+    __ j(EQUAL, &load_true, Assembler::kNearJump);
+  } else {
+    ASSERT(kind() == Token::kNE_STRICT);
+    __ j(NOT_EQUAL, &load_true, Assembler::kNearJump);
+  }
+  __ LoadObject(result, bool_false);
+  __ jmp(&done, Assembler::kNearJump);
+  __ Bind(&load_true);
+  __ LoadObject(result, bool_true);
+  __ Bind(&done);
 }
 
 
 LocationSummary* ClosureCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void ClosureCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(VerifyCallComputation(this));
@@ skipping 94 matching lines @@
   return NULL;
 }
 
 
 void UseVal::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* AssertAssignableComp::MakeLocationSummary() const {
-  return NULL;
+  LocationSummary* summary = new LocationSummary(3, 0);
+  summary->set_in(0, Location::RegisterLocation(EAX));
+  summary->set_in(1, Location::RegisterLocation(ECX));
+  summary->set_in(2, Location::RegisterLocation(EDX));
+  summary->set_out(Location::RegisterLocation(EAX));
+  return summary;
 }
 
 
 void AssertAssignableComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  ASSERT(locs()->in(0).reg() == EAX);  // Value.
+  ASSERT(locs()->in(1).reg() == ECX);  // Instantiator.
+  ASSERT(locs()->in(2).reg() == EDX);  // Instantiator type arguments.
+
+  compiler->GenerateAssertAssignable(cid(),
+                                     token_index(),
+                                     try_index(),
+                                     dst_type(),
+                                     dst_name());
+  ASSERT(locs()->in(0).reg() == locs()->out().reg());
 }
 
 
 LocationSummary* AssertBooleanComp::MakeLocationSummary() const {
   return NULL;
 }
 
 
 void AssertBooleanComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
@@ skipping 48 matching lines @@
   return NULL;
 }
 
 
 void StoreIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* InstanceSetterComp::MakeLocationSummary() const {
+  const intptr_t kNumInputs = 2;
+  return LocationSummary::Make(kNumInputs, Location::RequiresRegister());
   return NULL;
 }
 
 
 void InstanceSetterComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  Register receiver = locs()->in(0).reg();
+  Register value = locs()->in(1).reg();
+  Register result = locs()->out().reg();
+
+  // Preserve the value (second argument) under the arguments as the result
+  // of the computation, then call the setter.
+  const String& function_name =
+      String::ZoneHandle(Field::SetterSymbol(field_name()));
+
+  // Insert a copy of the second (last) argument under the arguments.
+  // TODO(fschneider): Avoid preserving the value if the result is not used.
+  __ pushl(value);
+  __ pushl(receiver);
+  __ pushl(value);
+  const intptr_t kArgumentCount = 2;
+  const intptr_t kCheckedArgumentCount = 1;
+  compiler->GenerateInstanceCall(cid(),
+                                 token_index(),
+                                 try_index(),
+                                 function_name,
+                                 kArgumentCount,
+                                 Array::ZoneHandle(),
+                                 kCheckedArgumentCount);
+  __ popl(result);
 }
 
 
 LocationSummary* StaticSetterComp::MakeLocationSummary() const {
   return NULL;
 }
 
 
 void StaticSetterComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
@@ skipping 44 matching lines @@
   return NULL;
 }
 
 
 void BooleanNegateComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* InstanceOfComp::MakeLocationSummary() const {
-  return NULL;
+  LocationSummary* summary = new LocationSummary(3, 0);
+  summary->set_in(0, Location::RegisterLocation(EAX));
+  summary->set_in(1, Location::RegisterLocation(ECX));
+  summary->set_in(2, Location::RegisterLocation(EDX));
+  summary->set_out(Location::RegisterLocation(EAX));
+  return summary;
 }
 
 
 void InstanceOfComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  ASSERT(locs()->in(0).reg() == EAX);  // Value.
+  ASSERT(locs()->in(1).reg() == ECX);  // Instantiator.
+  ASSERT(locs()->in(2).reg() == EDX);  // Instantiator type arguments.
+
+  compiler->GenerateInstanceOf(cid(),
+                               token_index(),
+                               try_index(),
+                               type(),
+                               negate_result());
+  ASSERT(locs()->out().reg() == EAX);
 }
 
 
 LocationSummary* CreateArrayComp::MakeLocationSummary() const {
   return NULL;
 }
 
 
 void CreateArrayComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
@@ skipping 379 matching lines @@
     UNREACHABLE();
   }
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64