Enable optimizer pipeline for DBC.

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 101 matching lines @@
 //    Note: return instruction knows how many arguments to remove from the
 //    stack because it can look at the call instruction at caller's PC and
 //    take argument count from it.
 //
 //  - Move rA, rX
 //
 //    FP[rA] <- FP[rX]
 //    Note: rX is signed so it can be used to address parameters which are
 //    at negative indices with respect to FP.
 //
+//  - Swap rA, rX
+//
+//    FP[rA], FP[rX] <- FP[rX], FP[rA]
+//    Note: rX is signed so it can be used to address parameters which are
+//    at negative indices with respect to FP.
+//
 //  - Push rX
 //
 //    Push FP[rX] to the stack.
 //
 //  - LoadConstant rA, D; PushConstant D
 //
 //    Load value at index D from constant pool into FP[rA] or push it onto the
 //    stack.
 //
 //  - StoreLocal rX; PopLocal rX
 //
 //    Store top of the stack into FP[rX] and pop it if needed.
 //
 //  - StaticCall ArgC, D
 //
 //    Invoke function in SP[0] with arguments SP[-(1+ArgC)], ..., SP[-1] and
 //    argument descriptor PP[D].
 //
-//  - InstanceCall ArgC, D; InstanceCall2 ArgC, D; InstanceCall3 ArgC, D
+//  - InstanceCall<N> ArgC, D; InstanceCall<N>Opt ArgC, D
 //
-//    Lookup and invoke method using ICData in PP[D] with arguments
-//    SP[-(1+ArgC)], ..., SP[-1].
+//    Lookup and invoke method with N checked arguments using ICData in PP[D]
+//    with arguments SP[-(1+ArgC)], ..., SP[-1].
 //
 //  - NativeCall, NativeBootstrapCall
 //
 //    Invoke native function SP[-1] with argc_tag SP[0].
 //
 //  - AddTOS; SubTOS; MulTOS; BitOrTOS; BitAndTOS; EqualTOS; LessThanTOS;
 //    GreaterThanTOS;
 //
 //    Smi fast-path for a corresponding method. Checks if SP[0] and SP[-1] are
 //    both smis and result of SP[0] <op> SP[-1] is a smi - if this is true
 //    then pops operands and pushes result on the stack and skips the next
 //    instruction (which implements a slow path fallback).
 //
 //  - StoreStaticTOS D
 //
 //    Stores TOS into the static field PP[D].
 //
 //  - PushStatic
 //
 //    Pushes value of the static field PP[D] on to the stack.
 //
 //  - InitStaticTOS
 //
 //    Takes static field from TOS and ensures that it is initialized.
 //
-//  - IfNeStrictTOS; IfEqStrictTOS; IfNeStrictNumTOS; IfEqStrictNumTOS
+//  - If<Cond>(Num)TOS
+//    If<Cond>(Num) rA, rD
+//
+//    Cond is either NeStrict or EqStrict
 //
 //    Skips the next instruction unless the given condition holds. 'Num'
 //    variants perform number check while non-Num variants just compare
 //    RawObject pointers.
 //
 //    Used to implement conditional jump:
 //
 //        IfNeStrictTOS
 //        Jump T         ;; jump if not equal
 //
 //  - 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
 //
 //    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
+//
+//    Store rC into array rA at index rB. No typechecking is done.
+//    rA is assumed to be a RawArray, rB to be a smi.
+//
 //  - StoreField rA, B, rC
 //
 //    Store value FP[rC] into object FP[rA] at offset (in words) B.
 //
 //  - StoreFieldTOS D
 //
 //    Store value SP[0] into object SP[-1] at offset (in words) D.
 //
 //  - LoadField rA, rB, C
 //
 //    Load value at offset (in words) C from object FP[rB] into FP[rA].
 //
 //  - LoadFieldTOS D
 //
 //    Push value at offset (in words) D from object SP[0].
 //
 //  - BooleanNegateTOS
 //
 //    SP[0] = !SP[0]
 //
+//  - BooleanNegate rA, rD
+//
+//    FP[rA] = !FP[rD]
+//
 //  - Throw A
 //
 //    Throw (Rethrow if A != 0) exception. Exception object and stack object
 //    are taken from TOS.
 //
 //  - Entry A, B, rC
 //
 //    Function prologue for the function with no optional or named arguments:
 //        A - expected number of positional arguments;
 //        B - number of local slots to reserve;
 //        rC - specifies context register to initialize with empty context.
 //
-//  - EntryOpt A, B, C
+//  - EntryOptional A, B, C
 //
 //    Function prologue for the function with optional or named arguments:
 //        A - expected number of positional arguments;
 //        B - number of optional arguments;
 //        C - number of named arguments;
 //
 //    Only one of B and C can be not 0.
 //
-//    If B is not 0 then EntryOpt bytecode is followed by B LoadConstant
+//    If B is not 0 then EntryOptional bytecode is followed by B LoadConstant
 //    bytecodes specifying default values for optional arguments.
 //
-//    If C is not 0 then EntryOpt is followed by 2 * B LoadConstant bytecodes.
+//    If C is not 0 then EntryOptional is followed by 2 * B LoadConstant
+//    bytecodes.
 //    Bytecode at 2 * i specifies name of the i-th named argument and at
 //    2 * i + 1 default value. rA part of the LoadConstant bytecode specifies
 //    the location of the parameter on the stack. Here named arguments are
 //    sorted alphabetically to enable linear matching similar to how function
 //    prologues are implemented on other architectures.
 //
-//    Note: Unlike Entry bytecode EntryOpt does not setup the frame for
+//    Note: Unlike Entry bytecode EntryOptional does not setup the frame for
 //    local variables this is done by a separate bytecode Frame.
 //
+//  - EntryOptimized A, D
+//
+//    Function prologue for optimized functions with no optional or named
+//    arguments.
+//        A - expected number of positional arguments;
+//        B - number of local slots to reserve for registers;
+//
+//    Note: reserved slots are not initialized because optimized code
+//    has stack maps attached to call sites.
+//
+//  - HotCheck A, D
+//
+//    Increment current function's usage counter by A and check if it
+//    exceeds D. If it does trigger (re)optimization of the current
+//    function.
+//
 //  - Frame D
 //
 //    Reserve and initialize with null space for D local variables.
 //
 //  - SetFrame A
 //
 //    Reinitialize SP assuming that current frame has size A.
 //    Used to drop temporaries from the stack in the exception handler.
 //
 //  - AllocateContext D
@@ skipping 34 matching lines @@
 //
 //  - DebugStep, DebugBreak A
 //
 //    Debugger support. DebugBreak is bytecode that can be patched into the
 //    instruction stream to trigger in place breakpoint.
 //
 //    When patching instance or static call with DebugBreak we set A to
 //    match patched call's argument count so that Return instructions continue
 //    to work.
 //
+// TODO(vegorov) the way we replace calls with DebugBreak does not work
+//               with our smi fast paths because DebugBreak is simply skipped.
+//
 //  - LoadClassIdTOS, LoadClassId rA, D
 //
 //    LoadClassIdTOS loads the class id from the object at SP[0] and stores it
 //    to SP[0]. LoadClassId loads the class id from FP[rA] and stores it to
 //    FP[D].
 //
-// TODO(vegorov) the way we replace calls with DebugBreak does not work
-//               with our smi fast paths because DebugBreak is simply skipped.
+//  - Deopt ArgC, D
+//
+//    If D != 0 then trigger eager deoptimization with deopt id (D - 1).
+//    If D == 0 then trigger lazy deoptimization.
+//
+//    The meaning of operand ArgC (encoded as A operand) matches that of an
+//    ArgC operand in call instructions. This is needed because we could
+//    potentially patch calls instructions with a lazy deopt and we need to
+//    ensure that any Return/ReturnTOS instructions
+//    returning from the patched calls will continue to function,
+//    e.g. in bytecode sequences like
+//
+//    InstanceCall ... <- lazy deopt inside first call
+//    InstanceCall ... <- patches seconds call with Deopt
 //
 // BYTECODE LIST FORMAT
 //
 // Bytecode list below is specified using the following format:
 //
 //     V(BytecodeName, OperandForm, Op1, Op2, Op3)
 //
 // - OperandForm specifies operand encoding and should be one of 0, A, T, A_D,
 //   A_X, X, D (see ENCODING section above).
 //
 // - Op1, Op2, Op2 specify operand meaning. Possible values:
 //
 //     ___ ignored / non-existent operand
 //     num immediate operand
 //     lit constant literal from object pool
 //     reg register (unsigned FP relative local)
 //     xeg x-register (signed FP relative local)
 //     tgt jump target relative to the PC of the current instruction
 //
 // TODO(vegorov) jump targets should be encoded relative to PC of the next
 //               instruction because PC is incremeted immediately after fetch
 //               and before decoding.
 //
 #define BYTECODES_LIST(V)                              \
   V(Trap,                            0, ___, ___, ___) \
   V(Compile,                         0, ___, ___, ___) \
+  V(HotCheck,                      A_D, num, num, ___) \
   V(Intrinsic,                       A, num, ___, ___) \
   V(Drop1,                           0, ___, ___, ___) \
   V(DropR,                           A, num, ___, ___) \
   V(Drop,                            A, num, ___, ___) \
   V(Jump,                            T, tgt, ___, ___) \
-  V(Return,                          A, num, ___, ___) \
+  V(Return,                          A, reg, ___, ___) \
   V(ReturnTOS,                       0, ___, ___, ___) \
   V(Move,                          A_X, reg, xeg, ___) \
+  V(Swap,                          A_X, reg, xeg, ___) \
   V(Push,                            X, xeg, ___, ___) \
   V(LoadConstant,                  A_D, reg, lit, ___) \
   V(LoadClassId,                   A_D, reg, reg, ___) \
   V(LoadClassIdTOS,                  0, ___, ___, ___) \
   V(PushConstant,                    D, lit, ___, ___) \
   V(StoreLocal,                      X, xeg, ___, ___) \
   V(PopLocal,                        X, xeg, ___, ___) \
   V(StaticCall,                    A_D, num, num, ___) \
-  V(InstanceCall,                  A_D, num, num, ___) \
+  V(InstanceCall1,                  A_D, num, num, ___) \
   V(InstanceCall2,                 A_D, num, num, ___) \
-  V(InstanceCall3,                 A_D, num, num, ___) \
+  V(InstanceCall1Opt,              A_D, num, num, ___) \
+  V(InstanceCall2Opt,              A_D, num, num, ___) \
   V(NativeCall,                      0, ___, ___, ___) \
   V(NativeBootstrapCall,             0, ___, ___, ___) \
   V(AddTOS,                          0, ___, ___, ___) \
   V(SubTOS,                          0, ___, ___, ___) \
   V(MulTOS,                          0, ___, ___, ___) \
   V(BitOrTOS,                        0, ___, ___, ___) \
   V(BitAndTOS,                       0, ___, ___, ___) \
   V(EqualTOS,                        0, ___, ___, ___) \
   V(LessThanTOS,                     0, ___, ___, ___) \
   V(GreaterThanTOS,                  0, ___, ___, ___) \
   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(IfNeStrictNum,                 A_D, reg, reg, ___) \
+  V(IfEqStrictNum,                 A_D, reg, reg, ___) \
   V(CreateArrayTOS,                  0, ___, ___, ___) \
   V(Allocate,                        D, lit, ___, ___) \
   V(AllocateT,                       0, ___, ___, ___) \
   V(StoreIndexedTOS,                 0, ___, ___, ___) \
-  V(StoreField,                  A_B_C, reg, reg, reg) \
+  V(StoreIndexed,                A_B_C, reg, reg, reg) \
+  V(StoreField,                  A_B_C, reg, num, reg) \
   V(StoreFieldTOS,                   D, num, ___, ___) \
-  V(LoadField,                   A_B_C, reg, reg, reg) \
+  V(LoadField,                   A_B_C, reg, reg, num) \
   V(LoadFieldTOS,                    D, num, ___, ___) \
   V(BooleanNegateTOS,                0, ___, ___, ___) \
+  V(BooleanNegate,                 A_D, reg, reg, ___) \
   V(Throw,                           A, num, ___, ___) \
   V(Entry,                       A_B_C, num, num, num) \
-  V(EntryOpt,                    A_B_C, num, num, num) \
+  V(EntryOptional,               A_B_C, num, num, num) \
+  V(EntryOptimized,                A_D, num, num, ___) \
   V(Frame,                           D, num, ___, ___) \
   V(SetFrame,                        A, num, ___, num) \
   V(AllocateContext,                 D, num, ___, ___) \
   V(CloneContext,                    0, ___, ___, ___) \
   V(MoveSpecial,                   A_D, reg, num, ___) \
   V(InstantiateType,                 D, lit, ___, ___) \
   V(InstantiateTypeArgumentsTOS,   A_D, num, lit, ___) \
   V(AssertAssignable,                D, num, lit, ___) \
   V(AssertBoolean,                   A, num, ___, ___) \
   V(CheckStack,                      0, ___, ___, ___) \
   V(DebugStep,                       0, ___, ___, ___) \
   V(DebugBreak,                      A, num, ___, ___) \
+  V(Deopt,                         A_D, num, num, ___) \
 
 typedef uint32_t Instr;
 
 class Bytecode {
  public:
   enum Opcode {
 #define DECLARE_BYTECODE(name, encoding, op1, op2, op3) k##name,
 BYTECODES_LIST(DECLARE_BYTECODE)
 #undef DECLARE_BYTECODE
   };
@@ skipping 41 matching lines @@
   }
 
   DART_FORCE_INLINE static uint16_t DecodeD(Instr bc) {
     return (bc >> kDShift) & kDMask;
   }
 
   DART_FORCE_INLINE static Opcode DecodeOpcode(Instr bc) {
     return static_cast<Opcode>(bc & 0xFF);
   }
 
+  DART_FORCE_INLINE static bool IsCallOpcode(Instr instr) {
+    switch (DecodeOpcode(instr)) {
+      case Bytecode::kStaticCall:
+      case Bytecode::kInstanceCall1:
+      case Bytecode::kInstanceCall2:
+      case Bytecode::kInstanceCall1Opt:
+      case Bytecode::kInstanceCall2Opt:
+      case Bytecode::kDebugBreak:
+        return true;
+
+      default:
+        return false;
+    }
+  }
+
   DART_FORCE_INLINE static uint8_t DecodeArgc(Instr call) {
-#if defined(DEBUG)
-    const Opcode op = DecodeOpcode(call);
-    ASSERT((op == Bytecode::kStaticCall) ||
-           (op == Bytecode::kInstanceCall) ||
-           (op == Bytecode::kInstanceCall2) ||
-           (op == Bytecode::kInstanceCall3) ||
-           (op == Bytecode::kDebugBreak));
-#endif
+    ASSERT(IsCallOpcode(call));
     return (call >> 8) & 0xFF;
   }
 
   static Instr At(uword pc) { return *reinterpret_cast<Instr*>(pc); }
 
  private:
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(Bytecode);
 };
 
 // Various dummy declarations to make shared code compile.
 // TODO(vegorov) we need to prune away as much dead code as possible instead
 // of just making it compile.
 typedef int16_t Register;
 
 const int16_t FPREG = 0;
 const int16_t SPREG = 1;
 const intptr_t kNumberOfCpuRegisters = 20;
-const intptr_t kDartAvailableCpuRegs = 0;
+const intptr_t kDartAvailableCpuRegs = -1;
 const intptr_t kNoRegister = -1;
 const intptr_t kReservedCpuRegisters = 0;
 const intptr_t ARGS_DESC_REG = 0;
 const intptr_t CODE_REG = 0;
 const intptr_t kExceptionObjectReg = 0;
 const intptr_t kStackTraceObjectReg = 0;
 const intptr_t CTX = 0;
 
 enum FpuRegister {
   kNoFpuRegister = -1,
   kFakeFpuRegister,
   kNumberOfDummyFpuRegisters,
 };
 const FpuRegister FpuTMP = kFakeFpuRegister;
 const intptr_t kNumberOfFpuRegisters = 1;
 
 enum Condition { EQ, NE };
 
 }  // namespace dart
 
 #endif  // VM_CONSTANTS_DBC_H_