DBC: A couple allocation fastpaths.

runtime/vm/intermediate_language_dbc.cc

 // Copyright (c) 2016, 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_DBC.
 #if defined(TARGET_ARCH_DBC)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/cpu.h"
@@ skipping 665 matching lines @@
   __ Bind(&is_true);
   __ LoadConstant(result_reg, Bool::True());
   __ Bind(&done);
 }
 
 
 EMIT_NATIVE_CODE(CreateArray,
                  2, Location::RequiresRegister(),
                  LocationSummary::kCall) {
   if (compiler->is_optimizing()) {
-    __ Push(locs()->in(0).reg());
-    __ Push(locs()->in(1).reg());
-  }
-  __ CreateArrayTOS();
-  compiler->RecordSafepoint(locs());
-  if (compiler->is_optimizing()) {
-    __ PopLocal(locs()->out(0).reg());
+    const Register length = locs()->in(kLengthPos).reg();
+    const Register type_arguments = locs()->in(kElementTypePos).reg();
+    const Register out = locs()->out(0).reg();
+    __ CreateArrayOpt(out, length, type_arguments);
+    __ Push(type_arguments);
+    __ Push(length);
+    __ CreateArrayTOS();
+    compiler->RecordSafepoint(locs());
+    __ PopLocal(out);
+  } else {
+    __ CreateArrayTOS();
+    compiler->RecordSafepoint(locs());
   }
 }
 
 
 EMIT_NATIVE_CODE(StoreIndexed, 3, Location::NoLocation(),
                  LocationSummary::kNoCall, 1) {
   if (!compiler->is_optimizing()) {
     ASSERT(class_id() == kArrayCid);
     __ StoreIndexedTOS();
     return;
@@ skipping 200 matching lines @@
   const Register str = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();  // Result char code is a smi.
   __ StringToCharCode(result, str);
 }
 
 
 EMIT_NATIVE_CODE(AllocateObject,
                  0, Location::RequiresRegister(),
                  LocationSummary::kCall) {
   if (ArgumentCount() == 1) {
+    // Allocate with type arguments.
     __ PushConstant(cls());
     __ AllocateT();
     compiler->AddCurrentDescriptor(RawPcDescriptors::kOther,
                                    Thread::kNoDeoptId,
                                    token_pos());
+    compiler->RecordSafepoint(locs());
+    if (compiler->is_optimizing()) {
+      __ PopLocal(locs()->out(0).reg());
+    }
+  } else if (compiler->is_optimizing()) {
+    // If we're optimizing, try a streamlined fastpath.
+    const intptr_t instance_size = cls().instance_size();
+    Isolate* isolate = Isolate::Current();
+    if (Heap::IsAllocatableInNewSpace(instance_size) &&
+        !cls().TraceAllocation(isolate)) {
+      uword tags = 0;
+      tags = RawObject::SizeTag::update(instance_size, tags);
+      ASSERT(cls().id() != kIllegalCid);
+      tags = RawObject::ClassIdTag::update(cls().id(), tags);
+      if (Smi::IsValid(tags)) {
+        const intptr_t tags_kidx = __ AddConstant(Smi::Handle(Smi::New(tags)));
+        __ AllocateOpt(locs()->out(0).reg(), tags_kidx);
+      }
+    }
+    const intptr_t kidx = __ AddConstant(cls());
+    __ Allocate(kidx);
+    compiler->AddCurrentDescriptor(RawPcDescriptors::kOther,
+                                   Thread::kNoDeoptId,
+                                   token_pos());
+    compiler->RecordSafepoint(locs());
+    __ PopLocal(locs()->out(0).reg());
   } else {
     const intptr_t kidx = __ AddConstant(cls());
     __ Allocate(kidx);
     compiler->AddCurrentDescriptor(RawPcDescriptors::kOther,
                                    Thread::kNoDeoptId,
                                    token_pos());
-  }
-  compiler->RecordSafepoint(locs());
-  if (compiler->is_optimizing()) {
-    __ PopLocal(locs()->out(0).reg());
+    compiler->RecordSafepoint(locs());
   }
 }
 
 
 EMIT_NATIVE_CODE(StoreInstanceField, 2) {
   ASSERT(!HasTemp());
   ASSERT(offset_in_bytes() % kWordSize == 0);
   if (compiler->is_optimizing()) {
     const Register value = locs()->in(1).reg();
     const Register instance = locs()->in(0).reg();
@@ skipping 468 matching lines @@
       UNREACHABLE();
       break;
   }
 }
 
 
 EMIT_NATIVE_CODE(Box, 1, Location::RequiresRegister(), LocationSummary::kCall) {
   ASSERT(from_representation() == kUnboxedDouble);
   const Register value = locs()->in(0).reg();
   const Register out = locs()->out(0).reg();
+  const intptr_t instance_size = compiler->double_class().instance_size();
+  Isolate* isolate = Isolate::Current();
+  ASSERT(Heap::IsAllocatableInNewSpace(instance_size));
+  if (!compiler->double_class().TraceAllocation(isolate)) {
+    uword tags = 0;
+    tags = RawObject::SizeTag::update(instance_size, tags);
+    tags = RawObject::ClassIdTag::update(compiler->double_class().id(), tags);
+    if (Smi::IsValid(tags)) {
+      const intptr_t tags_kidx = __ AddConstant(Smi::Handle(Smi::New(tags)));
+      __ AllocateOpt(out, tags_kidx);
+    }
+  }
   const intptr_t kidx = __ AddConstant(compiler->double_class());
   __ Allocate(kidx);
   compiler->AddCurrentDescriptor(RawPcDescriptors::kOther,
                                  Thread::kNoDeoptId,
                                  token_pos());
   compiler->RecordSafepoint(locs());
-  // __ Allocate puts the box at the top of the stack.
+  __ PopLocal(out);
   __ WriteIntoDouble(out, value);
 }
 
 
 EMIT_NATIVE_CODE(Unbox, 1, Location::RequiresRegister()) {
   ASSERT(representation() == kUnboxedDouble);
   const intptr_t value_cid = value()->Type()->ToCid();
   const intptr_t box_cid = BoxCid();
   const Register box = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
@@ skipping 310 matching lines @@
   __ IfULe(length, index);
   compiler->EmitDeopt(deopt_id(),
                       ICData::kDeoptCheckArrayBound,
                       (generalized_ ? ICData::kGeneralized : 0) |
                       (licm_hoisted_ ? ICData::kHoisted : 0));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC