DBC: A couple allocation fastpaths.

runtime/vm/simulator_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 <setjmp.h>  // NOLINT
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_DBC)
 
@@ skipping 238 matching lines @@
     ASSERT(GetClassId(code) == kCodeCid);
     FP[kPcMarkerSlotFromFp] = code;
   }
 
   DART_FORCE_INLINE static uint8_t* GetTypedData(
       RawObject* obj, RawObject* index, intptr_t scale) {
     ASSERT(RawObject::IsTypedDataClassId(obj->GetClassId()));
     RawTypedData* array = reinterpret_cast<RawTypedData*>(obj);
     const intptr_t byte_offset = Smi::Value(RAW_CAST(Smi, index));
     ASSERT(byte_offset >= 0);
-    ASSERT(((byte_offset + (1 << scale)) >> scale) <=
-               Smi::Value(array->ptr()->length_));
     return array->ptr()->data() + byte_offset;
   }
 };
 
 
 DART_FORCE_INLINE static uint32_t* SavedCallerPC(RawObject** FP) {
   return reinterpret_cast<uint32_t*>(FP[kSavedCallerPcSlotFromFp]);
 }
 
 
@@ skipping 1548 matching lines @@
         pc++;
       }
     }
     DISPATCH();
   }
 
 #if defined(ARCH_IS_64_BIT)
   {
     BYTECODE(WriteIntoDouble, A_D);
     const double value = bit_cast<double, RawObject*>(FP[rD]);
-    RawDouble* box = RAW_CAST(Double, *SP--);
+    RawDouble* box = RAW_CAST(Double, FP[rA]);
     box->ptr()->value_ = value;
-    FP[rA] = box;
     DISPATCH();
   }
 
   {
     BYTECODE(UnboxDouble, A_D);
     const RawDouble* box = RAW_CAST(Double, FP[rD]);
     FP[rA] = bit_cast<RawObject*, double>(box->ptr()->value_);
     DISPATCH();
   }
 
@@ skipping 475 matching lines @@
     {
       SP[1] = SP[0];  // Context to clone.
       Exit(thread, FP, SP + 2, pc);
       NativeArguments args(thread, 1, SP + 1, SP);
       INVOKE_RUNTIME(DRT_CloneContext, args);
     }
     DISPATCH();
   }
 
   {
+    BYTECODE(AllocateOpt, A_D);
+    const uword tags =
+        static_cast<uword>(Smi::Value(RAW_CAST(Smi, LOAD_CONSTANT(rD))));
+    const intptr_t instance_size = RawObject::SizeTag::decode(tags);
+    const uword start = thread->heap()->new_space()->TryAllocate(instance_size);
+    if (LIKELY(start != 0)) {
+      *reinterpret_cast<uword*>(start + Instance::tags_offset()) = tags;
+      for (intptr_t current_offset = sizeof(RawInstance);
+           current_offset < instance_size;
+           current_offset += kWordSize) {
+        *reinterpret_cast<RawObject**>(start + current_offset) = null_value;
+      }
+      FP[rA] = reinterpret_cast<RawObject*>(start + kHeapObjectTag);
+      pc += 2;
+    }
+    DISPATCH();
+  }
+
+  {
     BYTECODE(Allocate, A_D);
     SP[1] = 0;  // Space for the result.
     SP[2] = LOAD_CONSTANT(rD);  // Class object.
     SP[3] = null_value;  // Type arguments.
     Exit(thread, FP, SP + 4, pc);
     NativeArguments args(thread, 2, SP + 2, SP + 1);
     INVOKE_RUNTIME(DRT_AllocateObject, args);
     SP++;  // Result is in SP[1].
     DISPATCH();
   }
 
   {
     BYTECODE(AllocateT, 0);
     SP[1] = SP[-0];  // Class object.
     SP[2] = SP[-1];  // Type arguments
     Exit(thread, FP, SP + 3, pc);
     NativeArguments args(thread, 2, SP + 1, SP - 1);
     INVOKE_RUNTIME(DRT_AllocateObject, args);
     SP -= 1;  // Result is in SP - 1.
     DISPATCH();
   }
 
   {
+    BYTECODE(CreateArrayOpt, A_B_C);
+    const intptr_t length = Smi::Value(RAW_CAST(Smi, FP[rB]));
+    if (LIKELY(length <= Array::kMaxElements)) {
+      const intptr_t fixed_size = sizeof(RawArray) + kObjectAlignment - 1;
+      const intptr_t instance_size =
+          (fixed_size + length*kWordSize) & ~(kObjectAlignment - 1);
+      const uword start =
+          thread->heap()->new_space()->TryAllocate(instance_size);
+      if (LIKELY(start != 0)) {
+        const intptr_t cid = kArrayCid;
+        uword tags = 0;
+        if (LIKELY(instance_size < RawObject::SizeTag::kMaxSizeTag)) {
+          tags = RawObject::SizeTag::update(instance_size, tags);
+        }
+        tags = RawObject::ClassIdTag::update(cid, tags);
+        *reinterpret_cast<uword*>(start + Instance::tags_offset()) = tags;
+        *reinterpret_cast<RawObject**>(start + Array::length_offset()) = FP[rB];
+        *reinterpret_cast<RawObject**>(start + Array::type_arguments_offset()) =
+            FP[rC];
+        RawObject** data =
+            reinterpret_cast<RawObject**>(start + Array::data_offset());
+        for (intptr_t i = 0; i < length; i++) {
+          data[i] = null_value;
+        }
+        FP[rA] = reinterpret_cast<RawObject*>(start + kHeapObjectTag);
+        pc += 4;
+      }
+    }
+    DISPATCH();
+  }
+
+  {
     BYTECODE(CreateArrayTOS, 0);
     SP[1] = SP[-0];  // Length.
     SP[2] = SP[-1];  // Type.
     Exit(thread, FP, SP + 3, pc);
     NativeArguments args(thread, 2, SP + 1, SP - 1);
     INVOKE_RUNTIME(DRT_AllocateArray, args);
     SP -= 1;
     DISPATCH();
   }
 
@@ skipping 878 matching lines @@
   pc_ = pc;
   special_[kExceptionSpecialIndex] = raw_exception;
   special_[kStacktraceSpecialIndex] = raw_stacktrace;
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC