DBC: Enables unboxed doubles

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 165 matching lines @@
 //    instruction (which implements a slow path fallback).
 //
 //  - Add, Sub, Mul, Div, Mod, Shl, Shr rA, rB, rC
 //
 //    Arithmetic operations on Smis. FP[rA] <- FP[rB] op FP[rC].
 //    If these instructions can trigger a deoptimization, the following
 //    instruction should be Deopt. If no deoptimization should be triggered,
 //    the immediately following instruction is skipped. These instructions
 //    expect their operands to be Smis, but don't check that they are.
 //
+//  - DAdd, DSub, DMul, DDiv rA, rB, rC
+//
+//    Arithmetic operaions on unboxed doubles. FP[rA] <- FP[rB] op FP[rC].
+//
 //  - Neg rA , rD
 //
 //    FP[rA] <- -FP[rD]. Assumes FP[rD] is a Smi. If there is no overflow the
 //    immediately following instruction is skipped.
 //
+//  - DNeg rA, rD
+//
+//    FP[rA] <- -FP[rD]. Assumes FP[rD] is an unboxed double.
+//
 //  - BitOr, BitAnd, BitXor rA, rB, rC
 //
 //    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.
 //
+//  - BoxDouble rA, rD
+//
+//    Box the double in FP[rD] with the result 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

[Vyacheslav Egorov (Google), 2016/07/14 16:26:24]

I guess the next instruction is always a deoptimization which means instead of
actually embedding deoptimization into the bytecode we could make
CheckUnboxDouble instruction itself deoptimize.

[zra, 2016/07/14 21:12:10]

For now I'd prefer to follow the pattern we have going with the other places we
can deopt.

+//    FP[rD] is not a double or a Smi. When FP[rD] is a Smi, converts it to a
+//    double.
+//
+//  - SmiToDouble rA, rD
+//
+//    Convert the Smi in FP[rD] to an unboxed double in FP[rA].
+//
 //  - StoreStaticT`OS D
 //
 //    Stores TOS into the static field PP[D].
 //
 //  - PushStatic
 //
 //    Pushes value of the static field PP[D] on to the stack.
 //
 //  - InitStaticTOS
 //
@@ skipping 13 matching lines @@
 //        IfNeStrictTOS
 //        Jump T         ;; jump if not equal
 //
 //  - If<Cond>Null rA
 //
 //    Cond is Eq or Ne. Skips the next instruction unless the given condition
 //    holds.
 //
 //  - If<Cond> rA, rD
 //
-//    Cond is Le, Lt, Ge, Gt, or unsigned variants ULe, ULt, UGe, UGt.
+//    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.
+//    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].
 //
 //  - Allocate D
 //
 //    Allocate object of class PP[D] with no type arguments.
 //
 //  - AllocateT
@@ skipping 147 matching lines @@
 //    the class id of FP[rA] matches, jump to PC + N + 1 if the matching Nop's
 //    A != 0 or PC + N + 2 if the matching Nop's A = 0. If no match is found,
 //    jump to PC + N.
 //
 //  - CheckSmi rA
 //
 //    If FP[rA] is a Smi, then skip the next instruction.
 //
 //  - CheckClassId rA, D
 //
-//    If the object at FP[rA]'s class id matches the class id D, then skip the
+//    If the class id in FP[rA] matches the class id D, then skip the
 //    following instruction.
 //
 //  - CheckDenseSwitch rA, D
 //
 //    Skips the next 3 instructions if the object at FP[rA] is a valid class for
 //    a dense switch with low cid encoded in the following Nop instruction, and
 //    the cid mask encoded in the Nop instruction after that, or if D == 1 and
 //    FP[rA] is a Smi. Skips 2 instructions otherwise.
 //
 //  - CheckCids rA, rB, rC
@@ skipping 105 matching lines @@
   V(Mul,                         A_B_C, reg, reg, reg) \
   V(Div,                         A_B_C, reg, reg, reg) \
   V(Mod,                         A_B_C, reg, reg, reg) \
   V(Shl,                         A_B_C, reg, reg, reg) \
   V(Shr,                         A_B_C, reg, reg, reg) \
   V(Neg,                           A_D, reg, reg, ___) \
   V(BitOr,                       A_B_C, reg, reg, reg) \
   V(BitAnd,                      A_B_C, reg, reg, reg) \
   V(BitXor,                      A_B_C, reg, reg, reg) \
   V(BitNot,                        A_D, reg, reg, ___) \
+  V(BoxDouble,                     A_D, reg, reg, ___) \
+  V(UnboxDouble,                   A_D, reg, reg, ___) \
+  V(CheckedUnboxDouble,            A_D, reg, reg, ___) \
+  V(SmiToDouble,                   A_D, reg, reg, ___) \
+  V(DAdd,                        A_B_C, reg, reg, reg) \
+  V(DSub,                        A_B_C, reg, reg, reg) \
+  V(DMul,                        A_B_C, reg, reg, reg) \
+  V(DDiv,                        A_B_C, reg, reg, reg) \
+  V(DNeg,                          A_D, reg, reg, ___) \
   V(StoreStaticTOS,                  D, lit, ___, ___) \
   V(PushStatic,                      D, lit, ___, ___) \
   V(InitStaticTOS,                   0, ___, ___, ___) \
   V(IfNeStrictTOS,                   0, ___, ___, ___) \
   V(IfEqStrictTOS,                   0, ___, ___, ___) \
   V(IfNeStrictNumTOS,                0, ___, ___, ___) \
   V(IfEqStrictNumTOS,                0, ___, ___, ___) \
   V(IfNeStrict,                    A_D, reg, reg, ___) \
   V(IfEqStrict,                    A_D, reg, reg, ___) \
   V(IfLe,                          A_D, reg, reg, ___) \
   V(IfLt,                          A_D, reg, reg, ___) \
   V(IfGe,                          A_D, reg, reg, ___) \
   V(IfGt,                          A_D, reg, reg, ___) \
   V(IfULe,                         A_D, reg, reg, ___) \
   V(IfULt,                         A_D, reg, reg, ___) \
   V(IfUGe,                         A_D, reg, reg, ___) \
   V(IfUGt,                         A_D, reg, reg, ___) \
+  V(IfDNe,                         A_D, reg, reg, ___) \
+  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(Allocate,                        D, lit, ___, ___) \
   V(AllocateT,                       0, ___, ___, ___) \
   V(StoreIndexedTOS,                 0, ___, ___, ___) \
   V(StoreIndexed,                A_B_C, reg, reg, reg) \
   V(LoadIndexed,                 A_B_C, reg, reg, reg) \
@@ skipping 142 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_