Initial SIMDBC interpreter.

runtime/vm/intermediate_language.cc

 // Copyright (c) 2013, 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/bootstrap.h"
 #include "vm/compiler.h"
 #include "vm/constant_propagator.h"
@@ skipping 15 matching lines @@
 #include "vm/symbols.h"
 
 #include "vm/il_printer.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, propagate_ic_data, true,
     "Propagate IC data from unoptimized to optimized IC calls.");
 DEFINE_FLAG(bool, two_args_smi_icd, true,
     "Generate special IC stubs for two args Smi operations");
-DEFINE_FLAG(bool, unbox_numeric_fields, true,
+DEFINE_FLAG(bool, unbox_numeric_fields, !USING_DBC,
     "Support unboxed double and float32x4 fields.");
 DECLARE_FLAG(bool, eliminate_type_checks);
 
 
 #if defined(DEBUG)
 void Instruction::CheckField(const Field& field) const {
   ASSERT(field.IsZoneHandle());
   ASSERT(!Compiler::IsBackgroundCompilation() || !field.IsOriginal());
 }
 #endif  // DEBUG
@@ skipping 2701 matching lines @@
 LocationSummary* TargetEntryInstr::MakeLocationSummary(Zone* zone,
                                                        bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void TargetEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   if (!compiler->is_optimizing()) {
+#if !defined(TARGET_ARCH_DBC)
+    // TODO(vegorov) re-enable edge counters on DBC if we consider them
+    // beneficial for the quality of the optimized bytecode.
     if (compiler->NeedsEdgeCounter(this)) {
       compiler->EmitEdgeCounter(preorder_number());
     }
+#endif
+
     // The deoptimization descriptor points after the edge counter code for
     // uniformity with ARM and MIPS, where we can reuse pattern matching
     // code that matches backwards from the end of the pattern.
     compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
                                    GetDeoptId(),
                                    TokenPosition::kNoSource);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
@@ skipping 179 matching lines @@
                               Location::SameAsFirstInput(),
                               LocationSummary::kNoCall)
       : LocationSummary::Make(zone,
                               0,
                               Location::NoLocation(),
                               LocationSummary::kNoCall);
 }
 
 
 void DropTempsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+#if defined(TARGET_ARCH_DBC)
+  // On DBC the action of poping the TOS value and then pushing it
+  // after all intermediates are poped is folded into a special
+  // bytecode (DropR). On other architectures this is handled by
+  // instruction prologue/epilogues.
+  ASSERT(!compiler->is_optimizing());
+  if (InputCount() != 0 && HasTemp()) {

[zra, 2016/04/14 18:27:48]

(InputCount() != 0)

[Vyacheslav Egorov (Google), 2016/04/18 15:56:41]

Done.

+    __ DropR(num_temps());
+  } else {
+    __ Drop(num_temps() + ((InputCount() != 0) ? 1 : 0));
+  }
+#else
   ASSERT(!compiler->is_optimizing());
   // Assert that register assignment is correct.
   ASSERT((InputCount() == 0) || (locs()->out(0).reg() == locs()->in(0).reg()));
   __ Drop(num_temps());
+#endif  // defined(TARGET_ARCH_DBC)
 }
 
 
 StrictCompareInstr::StrictCompareInstr(TokenPosition token_pos,
                                        Token::Kind kind,
                                        Value* left,
                                        Value* right,
                                        bool needs_number_check)
     : ComparisonInstr(token_pos,
                       kind,
                       left,
                       right,
                       Thread::Current()->GetNextDeoptId()),
       needs_number_check_(needs_number_check) {
   ASSERT((kind == Token::kEQ_STRICT) || (kind == Token::kNE_STRICT));
 }
 
 
 LocationSummary* InstanceCallInstr::MakeLocationSummary(Zone* zone,
                                                         bool optimizing) const {
   return MakeCallSummary(zone);
 }
 
 
+// DBC does not use specialized inline cache stubs for smi operations.
+#if !defined(TARGET_ARCH_DBC)
 static const StubEntry* TwoArgsSmiOpInlineCacheEntry(Token::Kind kind) {
   if (!FLAG_two_args_smi_icd) {
     return 0;
   }
   switch (kind) {
     case Token::kADD: return StubCode::SmiAddInlineCache_entry();
     case Token::kSUB: return StubCode::SmiSubInlineCache_entry();
     case Token::kEQ:  return StubCode::SmiEqualInlineCache_entry();
     default:          return NULL;
   }
 }
+#endif
 
 
 void InstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Zone* zone = compiler->zone();
   const ICData* call_ic_data = NULL;
   if (!FLAG_propagate_ic_data || !compiler->is_optimizing() ||
       (ic_data() == NULL)) {
     const Array& arguments_descriptor =
         Array::Handle(zone, ArgumentsDescriptor::New(ArgumentCount(),
                                                      argument_names()));
     call_ic_data = compiler->GetOrAddInstanceCallICData(
         deopt_id(), function_name(), arguments_descriptor,
         checked_argument_count());
   } else {
     call_ic_data = &ICData::ZoneHandle(zone, ic_data()->raw());
   }
+
+#if !defined(TARGET_ARCH_DBC)
   if (compiler->is_optimizing() && HasICData()) {
     ASSERT(HasICData());
     if (ic_data()->NumberOfUsedChecks() > 0) {
       const ICData& unary_ic_data =
           ICData::ZoneHandle(zone, ic_data()->AsUnaryClassChecks());
       compiler->GenerateInstanceCall(deopt_id(),
                                      token_pos(),
                                      ArgumentCount(),
                                      locs(),
                                      unary_ic_data);
@@ skipping 53 matching lines @@
       compiler->EmitInstanceCall(*stub_entry, *call_ic_data, ArgumentCount(),
                                  deopt_id(), token_pos(), locs());
     } else {
       compiler->GenerateInstanceCall(deopt_id(),
                                      token_pos(),
                                      ArgumentCount(),
                                      locs(),
                                      *call_ic_data);
     }
   }
+#else
+  // Emit smi fast path instruction. If fast-path succeeds it skips the next
+  // instruction otherwise it fall through.

[zra, 2016/04/14 18:27:48]

falls

[Vyacheslav Egorov (Google), 2016/04/18 15:56:41]

Done.

+  if (function_name().raw() == Symbols::Plus().raw()) {
+    __ AddTOS();
+  } else if (function_name().raw() == Symbols::EqualOperator().raw()) {
+    __ EqualTOS();
+  } else if (function_name().raw() == Symbols::LAngleBracket().raw()) {
+    __ LessThanTOS();
+  } else if (function_name().raw() == Symbols::RAngleBracket().raw()) {
+    __ GreaterThanTOS();
+  } else if (function_name().raw() == Symbols::BitAnd().raw()) {
+    __ BitAndTOS();
+  } else if (function_name().raw() == Symbols::BitOr().raw()) {
+    __ BitOrTOS();
+  } else if (function_name().raw() == Symbols::Star().raw()) {
+    __ MulTOS();
+  }
+
+  const intptr_t call_ic_data_kidx = __ AddConstant(*call_ic_data);
+  switch (call_ic_data->NumArgsTested()) {
+    case 1:
+      __ InstanceCall(ArgumentCount(), call_ic_data_kidx);
+      break;
+    case 2:
+      __ InstanceCall2(ArgumentCount(), call_ic_data_kidx);
+      break;
+    case 3:
+      __ InstanceCall3(ArgumentCount(), call_ic_data_kidx);
+      break;
+    default:
+      UNIMPLEMENTED();
+      break;
+  }
+  compiler->AddCurrentDescriptor(RawPcDescriptors::kIcCall,
+                                 deopt_id(),
+                                 token_pos());
+#endif  // !defined(TARGET_ARCH_DBC)
 }
 
 
 bool PolymorphicInstanceCallInstr::HasSingleRecognizedTarget() const {
   return ic_data().HasOneTarget() &&
       (MethodRecognizer::RecognizeKind(
           Function::Handle(ic_data().GetTargetAt(0))) !=
        MethodRecognizer::kUnknown);
 }
 
 
 bool PolymorphicInstanceCallInstr::HasOnlyDispatcherTargets() const {
   for (intptr_t i = 0; i < ic_data().NumberOfChecks(); ++i) {
     const Function& target = Function::Handle(ic_data().GetTargetAt(i));
     if (!target.IsNoSuchMethodDispatcher() &&
         !target.IsInvokeFieldDispatcher()) {
       return false;
     }
   }
   return true;
 }
 
+
+// DBC does not support optimizing compiler and thus doesn't emit
+// PolymorphicInstanceCallInstr.
+#if !defined(TARGET_ARCH_DBC)
 void PolymorphicInstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(ic_data().NumArgsTested() == 1);
   if (!with_checks()) {
     ASSERT(ic_data().HasOneTarget());
     const Function& target = Function::ZoneHandle(ic_data().GetTargetAt(0));
     compiler->GenerateStaticCall(deopt_id(),
                                  instance_call()->token_pos(),
                                  target,
                                  instance_call()->ArgumentCount(),
                                  instance_call()->argument_names(),
                                  locs(),
                                  ICData::Handle());
     return;
   }
 
   compiler->EmitPolymorphicInstanceCall(ic_data(),
                                         instance_call()->ArgumentCount(),
                                         instance_call()->argument_names(),
                                         deopt_id(),
                                         instance_call()->token_pos(),
                                         locs());
 }
+#endif
 
 
 LocationSummary* StaticCallInstr::MakeLocationSummary(Zone* zone,
                                                       bool optimizing) const {
   return MakeCallSummary(zone);
 }
 
 
 void StaticCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+#if !defined(TARGET_ARCH_DBC)
   const ICData* call_ic_data = NULL;
   if (!FLAG_propagate_ic_data || !compiler->is_optimizing() ||
       (ic_data() == NULL)) {
     const Array& arguments_descriptor =
         Array::Handle(ArgumentsDescriptor::New(ArgumentCount(),
                                                argument_names()));
     MethodRecognizer::Kind recognized_kind =
         MethodRecognizer::RecognizeKind(function());
     int num_args_checked = 0;
     switch (recognized_kind) {
@@ skipping 12 matching lines @@
   } else {
     call_ic_data = &ICData::ZoneHandle(ic_data()->raw());
   }
   compiler->GenerateStaticCall(deopt_id(),
                                token_pos(),
                                function(),
                                ArgumentCount(),
                                argument_names(),
                                locs(),
                                *call_ic_data);
+#else
+  const Array& arguments_descriptor =
+      (ic_data() == NULL) ?
+        Array::Handle(ArgumentsDescriptor::New(ArgumentCount(),
+                                               argument_names())) :
+        Array::Handle(ic_data()->arguments_descriptor());
+  const intptr_t argdesc_kidx = __ AddConstant(arguments_descriptor);
+
+  __ PushConstant(function());
+  __ StaticCall(ArgumentCount(), argdesc_kidx);
+  compiler->AddCurrentDescriptor(RawPcDescriptors::kUnoptStaticCall,
+                                 deopt_id(),
+                                 token_pos());
+#endif  // !defined(TARGET_ARCH_DBC)
 }
 
 
 void AssertAssignableInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   compiler->GenerateAssertAssignable(token_pos(),
                                      deopt_id(),
                                      dst_type(),
                                      dst_name(),
                                      locs());
+
+  // DBC does not use LocationSummaries in the same way as other architectures.
+#if !defined(TARGET_ARCH_DBC)
   ASSERT(locs()->in(0).reg() == locs()->out(0).reg());
+#endif
 }
 
 
 LocationSummary* DeoptimizeInstr::MakeLocationSummary(Zone* zone,
                                                       bool opt) const {
   return new(zone) LocationSummary(zone, 0, 0, LocationSummary::kNoCall);
 }
 
 
 void DeoptimizeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 90 matching lines @@
   intptr_t use_index = instr->env()->Length();  // Start index after inner.
   for (Environment::DeepIterator it(copy); !it.Done(); it.Advance()) {
     Value* value = it.CurrentValue();
     value->set_instruction(instr);
     value->set_use_index(use_index++);
     value->definition()->AddEnvUse(value);
   }
 }
 
 
-static bool BindsToSmiConstant(Value* value) {
-  return value->BindsToConstant() && value->BoundConstant().IsSmi();
-}
-
-
 ComparisonInstr* EqualityCompareInstr::CopyWithNewOperands(Value* new_left,
                                                            Value* new_right) {
   return new EqualityCompareInstr(token_pos(),
                                   kind(),
                                   new_left,
                                   new_right,
                                   operation_cid(),
                                   deopt_id());
 }
 
@@ skipping 47 matching lines @@
   }
   for (intptr_t i = 0; i < cid_results().length(); i++) {
     if (cid_results()[i] != other_instr->cid_results()[i]) {
       return false;
     }
   }
   return true;
 }
 
 
+#if !defined(TARGET_ARCH_DBC)
+static bool BindsToSmiConstant(Value* value) {
+  return value->BindsToConstant() && value->BoundConstant().IsSmi();
+}
+#endif
+
+
 bool IfThenElseInstr::Supports(ComparisonInstr* comparison,
                                Value* v1,
                                Value* v2) {
+#if !defined(TARGET_ARCH_DBC)
   bool is_smi_result = BindsToSmiConstant(v1) && BindsToSmiConstant(v2);
   if (comparison->IsStrictCompare()) {
     // Strict comparison with number checks calls a stub and is not supported
     // by if-conversion.
     return is_smi_result
         && !comparison->AsStrictCompare()->needs_number_check();
   }
   if (comparison->operation_cid() != kSmiCid) {
     // Non-smi comparisons are not supported by if-conversion.
     return false;
   }
   return is_smi_result;
+#else
+  return false;
+#endif  // !defined(TARGET_ARCH_DBC)
 }
 
 
 bool PhiInstr::IsRedundant() const {
   ASSERT(InputCount() > 1);
   Definition* first = InputAt(0)->definition();
   for (intptr_t i = 1; i < InputCount(); ++i) {
     Definition* def = InputAt(i)->definition();
     if (def != first) return false;
   }
@@ skipping 344 matching lines @@
   set_native_c_function(native_function);
   function().SetIsNativeAutoSetupScope(auto_setup_scope);
   Dart_NativeEntryResolver resolver = library.native_entry_resolver();
   bool is_bootstrap_native = Bootstrap::IsBootstapResolver(resolver);
   set_is_bootstrap_native(is_bootstrap_native);
 }
 
 #undef __
 
 }  // namespace dart