DBC: A couple allocation fastpaths.

runtime/vm/constants_dbc.h

 // 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.
 
 #ifndef VM_CONSTANTS_DBC_H_
 #define VM_CONSTANTS_DBC_H_
 
 #include "platform/globals.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 213 matching lines @@
 //
 //    FP[rA] <- FP[rB] op FP[rC]. These instructions expect their operands to be
 //    Smis, but don't check that they are.
 //
 //  - BitNot rA, rD
 //
 //    FP[rA] <- ~FP[rD]. As above, assumes FP[rD] is a Smi.
 //
 //  - WriteIntoDouble rA, rD
 //
-//    Box the double in FP[rD] with the result in FP[rA].
+//    Box the double in FP[rD] using the box in FP[rA].
 //
 //  - UnboxDouble rA, rD
 //
 //    Unbox the double in FP[rD] into FP[rA]. Assumes FP[rD] is a double.
 //
 //  - CheckedUnboxDouble rA, rD
 //
 //    Unboxes FP[rD] into FP[rA] and skips the following instruction unless
 //    FP[rD] is not a double or a Smi. When FP[rD] is a Smi, converts it to a
 //    double.
@@ skipping 57 matching lines @@
 //
 //    Cond is Le, Lt, Ge, Gt, unsigned variants ULe, ULt, UGe, UGt, and
 //    unboxed double variants DEq, DNe, DLe, DLt, DGe, DGt.
 //    Skips the next instruction unless FP[rA] <Cond> FP[rD]. Assumes that
 //    FP[rA] and FP[rD] are Smis or unboxed doubles as inidcated by <Cond>.
 //
 //  - CreateArrayTOS
 //
 //    Allocate array of length SP[0] with type arguments SP[-1].
 //
+//  - CreateArrayOpt rA, rB, rC
+//
+//    Try to allocate a new array where FP[rB] is the length, and FP[rC] is the
+//    type. If allocation is successful, the result is stored in FP[rA], and
+//    the next four instructions, which should be the
+//    (Push type; Push length; AllocateTOS; PopLocal) slow path are skipped.
+//
 //  - Allocate D
 //
 //    Allocate object of class PP[D] with no type arguments.
 //
+//  - AllocateOpt rA, D
+//
+//    Try allocating an object with tags in PP[D] with no type arguments.
+//    If allocation is successful, the result is stored in FP[rA], and
+//    the next two instructions, which should be the (Allocate class; PopLocal)
+//    slow path are skipped
+//
 //  - AllocateT
 //
 //    Allocate object of class SP[0] with type arguments SP[-1].
 //
 //  - StoreIndexedTOS
 //
 //    Store SP[0] into array SP[-2] at index SP[-1]. No typechecking is done.
 //    SP[-2] is assumed to be a RawArray, SP[-1] to be a smi.
 //
 //  - StoreIndexed rA, rB, rC
@@ skipping 351 matching lines @@
   V(IfDEq,                         A_D, reg, reg, ___) \
   V(IfDLe,                         A_D, reg, reg, ___) \
   V(IfDLt,                         A_D, reg, reg, ___) \
   V(IfDGe,                         A_D, reg, reg, ___) \
   V(IfDGt,                         A_D, reg, reg, ___) \
   V(IfNeStrictNum,                 A_D, reg, reg, ___) \
   V(IfEqStrictNum,                 A_D, reg, reg, ___) \
   V(IfEqNull,                        A, reg, ___, ___) \
   V(IfNeNull,                        A, reg, ___, ___) \
   V(CreateArrayTOS,                  0, ___, ___, ___) \
+  V(CreateArrayOpt,              A_B_C, reg, reg, ___) \
   V(Allocate,                        D, lit, ___, ___) \
   V(AllocateT,                       0, ___, ___, ___) \
+  V(AllocateOpt,                   A_D, reg, lit, ___) \
   V(StoreIndexedTOS,                 0, ___, ___, ___) \
   V(StoreIndexed,                A_B_C, reg, reg, reg) \
   V(StoreIndexedUint8,           A_B_C, reg, reg, reg) \
   V(StoreIndexedExternalUint8,   A_B_C, reg, reg, reg) \
   V(StoreIndexedOneByteString,   A_B_C, reg, reg, reg) \
   V(StoreIndexedUint32,          A_B_C, reg, reg, reg) \
   V(StoreIndexedFloat64,         A_B_C, reg, reg, reg) \
   V(StoreIndexed8Float64,        A_B_C, reg, reg, reg) \
   V(LoadIndexed,                 A_B_C, reg, reg, reg) \
   V(LoadIndexedUint8,            A_B_C, reg, reg, reg) \
@@ skipping 175 matching lines @@
 
 // After a comparison, the condition NEXT_IS_TRUE means the following
 // instruction is executed if the comparision is true and skipped over overwise.
 // Conidition NEXT_IS_FALSE means the following instruction is executed if the
 // comparison is false and skipped over otherwise.
 enum Condition { NEXT_IS_TRUE, NEXT_IS_FALSE };
 
 }  // namespace dart
 
 #endif  // VM_CONSTANTS_DBC_H_