| // Copyright (c) 2018, 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 RUNTIME_VM_CONSTANTS_KBC_H_ |
| #define RUNTIME_VM_CONSTANTS_KBC_H_ |
| |
| #include "platform/assert.h" |
| #include "platform/globals.h" |
| #include "platform/utils.h" |
| |
| namespace dart { |
| |
| // clang-format off |
| // List of KernelBytecode instructions. |
| // |
| // INTERPRETER STATE |
| // |
| // current frame info (see stack_frame_kbc.h for layout) |
| // v-----^-----v |
| // ~----+----~ ~----+-------+-------+-~ ~-+-------+-------+-~ |
| // ~ | ~ ~ | FP[0] | FP[1] | ~ ~ | SP[-1]| SP[0] | |
| // ~----+----~ ~----+-------+-------+-~ ~-+-------+-------+-~ |
| // ^ ^ |
| // FP SP |
| // |
| // |
| // The state of execution is captured in few interpreter registers: |
| // |
| // FP - base of the current frame |
| // SP - top of the stack (TOS) for the current frame |
| // PP - object pool for the currently execution function |
| // |
| // Frame info stored below FP additionally contains pointers to the currently |
| // executing function and code (see stack_frame_dbc.h for more information). |
| // |
| // In the unoptimized code most of bytecodes take operands implicitly from |
| // stack and store results again on the stack. Constant operands are usually |
| // taken from the object pool by index. |
| // |
| // ENCODING |
| // |
| // Each instruction starts with opcode byte. Certain instructions have |
| // wide encoding variant. In such case, the least significant bit of opcode is |
| // not set for compact variant and set for wide variant. |
| // |
| // The following operand encodings are used: |
| // |
| // 0........8.......16.......24.......32.......40.......48 |
| // +--------+ |
| // | opcode | 0: no operands |
| // +--------+ |
| // |
| // +--------+--------+ |
| // | opcode | A | A: unsigned 8-bit operand |
| // +--------+--------+ |
| // |
| // +--------+--------+ |
| // | opcode | D | D: unsigned 8/32-bit operand |
| // +--------+--------+ |
| // |
| // +--------+----------------------------------+ |
| // | opcode | D | D (wide) |
| // +--------+----------------------------------+ |
| // |
| // +--------+--------+ |
| // | opcode | X | X: signed 8/32-bit operand |
| // +--------+--------+ |
| // |
| // +--------+----------------------------------+ |
| // | opcode | X | X (wide) |
| // +--------+----------------------------------+ |
| // |
| // +--------+--------+ |
| // | opcode | T | T: signed 8/24-bit operand |
| // +--------+--------+ |
| // |
| // +--------+--------------------------+ |
| // | opcode | T | T (wide) |
| // +--------+--------------------------+ |
| // |
| // +--------+--------+--------+ |
| // | opcode | A | E | A_E: unsigned 8-bit operand and |
| // +--------+--------+--------+ unsigned 8/32-bit operand |
| // |
| // +--------+--------+----------------------------------+ |
| // | opcode | A | E | A_E (wide) |
| // +--------+--------+----------------------------------+ |
| // |
| // +--------+--------+--------+ |
| // | opcode | A | Y | A_Y: unsigned 8-bit operand and |
| // +--------+--------+--------+ signed 8/32-bit operand |
| // |
| // +--------+--------+----------------------------------+ |
| // | opcode | A | Y | A_Y (wide) |
| // +--------+--------+----------------------------------+ |
| // |
| // +--------+--------+--------+ |
| // | opcode | D | F | D_F: unsigned 8/32-bit operand and |
| // +--------+--------+--------+ unsigned 8-bit operand |
| // |
| // +--------+----------------------------------+--------+ |
| // | opcode | D | F | D_F (wide) |
| // +--------+----------------------------------+--------+ |
| // |
| // +--------+--------+--------+--------+ |
| // | opcode | A | B | C | A_B_C: 3 unsigned 8-bit operands |
| // +--------+--------+--------+--------+ |
| // |
| // |
| // INSTRUCTIONS |
| // |
| // - Trap |
| // |
| // Unreachable instruction. |
| // |
| // - Entry rD |
| // |
| // Function prologue for the function |
| // rD - number of local slots to reserve; |
| // |
| // - EntryFixed A, D |
| // |
| // Function prologue for functions without optional arguments. |
| // Checks number of arguments. |
| // A - expected number of positional arguments; |
| // D - number of local slots to reserve; |
| // |
| // - 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 EntryOptional bytecode is followed by B LoadConstant |
| // bytecodes specifying default values for optional arguments. |
| // |
| // If C is not 0 then EntryOptional is followed by 2 * C 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 EntryOptional does not setup the frame for |
| // local variables this is done by a separate bytecode Frame, which should |
| // follow EntryOptional and its LoadConstant instructions. |
| // |
| // - LoadConstant rA, D |
| // |
| // Used in conjunction with EntryOptional instruction to describe names and |
| // default values of optional parameters. |
| // |
| // - Frame D |
| // |
| // Reserve and initialize with null space for D local variables. |
| // |
| // - CheckFunctionTypeArgs A, D |
| // |
| // Check for a passed-in type argument vector of length A and |
| // store it at FP[D]. |
| // |
| // - CheckStack A |
| // |
| // Compare SP against isolate stack limit and call StackOverflow handler if |
| // necessary. Should be used in prologue (A = 0), or at the beginning of |
| // a loop with depth A. |
| // |
| // - Allocate D |
| // |
| // Allocate object of class PP[D] with no type arguments. |
| // |
| // - AllocateT |
| // |
| // Allocate object of class SP[0] with type arguments SP[-1]. |
| // |
| // - CreateArrayTOS |
| // |
| // Allocate array of length SP[0] with type arguments SP[-1]. |
| // |
| // - AllocateContext A, D |
| // |
| // Allocate Context object holding D context variables. |
| // A is a static ID of the context. Static ID of a context may be used to |
| // disambiguate accesses to different context objects. |
| // Context objects with the same ID should have the same number of |
| // context variables. |
| // |
| // - CloneContext A, D |
| // |
| // Clone Context object SP[0] holding D context variables. |
| // A is a static ID of the context. Cloned context has the same ID. |
| // |
| // - LoadContextParent |
| // |
| // Load parent from context SP[0]. |
| // |
| // - StoreContextParent |
| // |
| // Store context SP[0] into `parent` field of context SP[-1]. |
| // |
| // - LoadContextVar A, D |
| // |
| // Load value from context SP[0] at index D. |
| // A is a static ID of the context. |
| // |
| // - StoreContextVar A, D |
| // |
| // Store value SP[0] into context SP[-1] at index D. |
| // A is a static ID of the context. |
| // |
| // - PushConstant D |
| // |
| // Push value at index D from constant pool onto the stack. |
| // |
| // - PushNull |
| // |
| // Push `null` onto the stack. |
| // |
| // - PushTrue |
| // |
| // Push `true` onto the stack. |
| // |
| // - PushFalse |
| // |
| // Push `false` onto the stack. |
| // |
| // - PushInt rX |
| // |
| // Push int rX onto the stack. |
| // |
| // - Drop1 |
| // |
| // Drop 1 value from the stack |
| // |
| // - Push rX |
| // |
| // Push FP[rX] to the stack. |
| // |
| // - StoreLocal rX; PopLocal rX |
| // |
| // Store top of the stack into FP[rX] and pop it if needed. |
| // |
| // - LoadFieldTOS D |
| // |
| // Push value at offset (in words) PP[D] from object SP[0]. |
| // |
| // - StoreFieldTOS D |
| // |
| // Store value SP[0] into object SP[-1] at offset (in words) PP[D]. |
| // |
| // - 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. |
| // |
| // - PushStatic D |
| // |
| // Pushes value of the static field PP[D] on to the stack. |
| // |
| // - StoreStaticTOS D |
| // |
| // Stores TOS into the static field PP[D]. |
| // |
| // - Jump target |
| // |
| // Jump to the given target. Target is specified as offset from the PC of the |
| // jump instruction. |
| // |
| // - JumpIfNoAsserts target |
| // |
| // Jump to the given target if assertions are not enabled. |
| // Target is specified as offset from the PC of the jump instruction. |
| // |
| // - JumpIfNotZeroTypeArgs target |
| // |
| // Jump to the given target if number of passed function type |
| // arguments is not zero. |
| // Target is specified as offset from the PC of the jump instruction. |
| // |
| // - JumpIfEqStrict target; JumpIfNeStrict target |
| // |
| // Jump to the given target if SP[-1] is the same (JumpIfEqStrict) / |
| // not the same (JumpIfNeStrict) object as SP[0]. |
| // |
| // - JumpIfTrue target; JumpIfFalse target |
| // - JumpIfNull target; JumpIfNotNull target |
| // |
| // Jump to the given target if SP[0] is true/false/null/not null. |
| // |
| // - IndirectStaticCall ArgC, D |
| // |
| // Invoke the function given by the ICData in SP[0] with arguments |
| // SP[-(1+ArgC)], ..., SP[-1] and argument descriptor PP[D], which |
| // indicates whether the first argument is a type argument vector. |
| // |
| // - DirectCall ArgC, D |
| // |
| // Invoke the function PP[D] with arguments |
| // SP[-(ArgC-1)], ..., SP[0] and argument descriptor PP[D+1]. |
| // |
| // - InterfaceCall ArgC, D |
| // |
| // Lookup and invoke method using ICData in PP[D] |
| // with arguments SP[-(1+ArgC)], ..., SP[-1]. |
| // Method has to be declared (explicitly or implicitly) in an interface |
| // implemented by a receiver, and passed arguments are valid for the |
| // interface method declaration. |
| // The ICData indicates whether the first argument is a type argument vector. |
| // |
| // - UncheckedInterfaceCall ArgC, D |
| // |
| // Same as InterfaceCall, but can omit type checks of generic-covariant |
| // parameters. |
| // |
| // - DynamicCall ArgC, D |
| // |
| // Lookup and invoke method using ICData in PP[D] |
| // with arguments SP[-(1+ArgC)], ..., SP[-1]. |
| // The ICData indicates whether the first argument is a type argument vector. |
| // |
| // - NativeCall D |
| // |
| // Invoke native function described by array at pool[D]. |
| // array[0] is wrapper, array[1] is function, array[2] is argc_tag. |
| // |
| // - ReturnTOS |
| // |
| // Return to the caller using a value from the top-of-stack as a result. |
| // |
| // 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. |
| // |
| // - AssertAssignable A, D |
| // |
| // Assert that instance SP[-4] is assignable to variable named SP[0] of |
| // type SP[-1] with instantiator type arguments SP[-3] and function type |
| // arguments SP[-2] using SubtypeTestCache PP[D]. |
| // If A is 1, then the instance may be a Smi. |
| // |
| // Instance remains on stack. Other arguments are consumed. |
| // |
| // - AssertBoolean A |
| // |
| // Assert that TOS is a boolean (A = 1) or that TOS is not null (A = 0). |
| // |
| // - AssertSubtype |
| // |
| // Assert that one type is a subtype of another. Throws a TypeError |
| // otherwise. The stack has the following arguments on it: |
| // |
| // SP[-4] instantiator type args |
| // SP[-3] function type args |
| // SP[-2] sub_type |
| // SP[-1] super_type |
| // SP[-0] dst_name |
| // |
| // All 5 arguments are consumed from the stack and no results is pushed. |
| // |
| // - LoadTypeArgumentsField D |
| // |
| // Load instantiator type arguments from an instance SP[0]. |
| // PP[D] = offset (in words) of type arguments field corresponding |
| // to an instance's class. |
| // |
| // - InstantiateType D |
| // |
| // Instantiate type PP[D] with instantiator type arguments SP[-1] and |
| // function type arguments SP[0]. |
| // |
| // - InstantiateTypeArgumentsTOS A, D |
| // |
| // Instantiate type arguments PP[D] with instantiator type arguments SP[-1] |
| // and function type arguments SP[0]. A != 0 indicates that resulting type |
| // arguments are all dynamic if both instantiator and function type |
| // arguments are all dynamic. |
| // |
| // - Throw A |
| // |
| // Throw (Rethrow if A != 0) exception. Exception object and stack object |
| // are taken from TOS. |
| // |
| // - MoveSpecial A, rX |
| // |
| // Copy value from special variable to FP[rX]. Currently only |
| // used to pass exception object (A = 0) and stack trace object (A = 1) to |
| // catch handler. |
| // |
| // - SetFrame A |
| // |
| // Reinitialize SP assuming that current frame has size A. |
| // Used to drop temporaries from the stack in the exception handler. |
| // |
| // - BooleanNegateTOS |
| // |
| // SP[0] = !SP[0] |
| // |
| // - EqualsNull |
| // |
| // SP[0] = (SP[0] == null) ? true : false |
| // |
| // - NegateInt |
| // |
| // Equivalent to invocation of unary int operator-. |
| // Receiver should have static type int. |
| // Check SP[0] for null; SP[0] = -SP[0]. |
| // |
| // - AddInt; SubInt; MulInt; TruncDivInt; ModInt; BitAndInt; BitOrInt; |
| // BitXorInt; ShlInt; ShrInt |
| // |
| // Equivalent to invocation of binary int operator +, -, *, ~/, %, &, |, |
| // ^, << or >>. Receiver and argument should have static type int. |
| // Check SP[-1] and SP[0] for null; push SP[-1] <op> SP[0]. |
| // |
| // - CompareIntEq; CompareIntGt; CompareIntLt; CompareIntGe; CompareIntLe |
| // |
| // Equivalent to invocation of binary int operator ==, >, <, >= or <=. |
| // Receiver and argument should have static type int. |
| // Check SP[-1] and SP[0] for null; push SP[-1] <op> SP[0] ? true : false. |
| // |
| // - NegateDouble |
| // |
| // Equivalent to invocation of unary double operator-. |
| // Receiver should have static type double. |
| // Check SP[0] for null; SP[0] = -SP[0]. |
| // |
| // - AddDouble; SubDouble; MulDouble; DivDouble |
| // |
| // Equivalent to invocation of binary int operator +, -, *, /. |
| // Receiver and argument should have static type double. |
| // Check SP[-1] and SP[0] for null; push SP[-1] <op> SP[0]. |
| // |
| // - CompareDoubleEq; CompareDoubleGt; CompareDoubleLt; CompareDoubleGe; |
| // CompareDoubleLe |
| // |
| // Equivalent to invocation of binary double operator ==, >, <, >= or <=. |
| // Receiver and argument should have static type double. |
| // Check SP[-1] and SP[0] for null; push SP[-1] <op> SP[0] ? true : false. |
| // |
| // - AllocateClosure D |
| // |
| // Allocate closure object for closure function ConstantPool[D]. |
| // |
| // BYTECODE LIST FORMAT |
| // |
| // KernelBytecode list below is specified using the following format: |
| // |
| // V(BytecodeName, OperandForm, BytecodeKind, Op1, Op2, Op3) |
| // |
| // - OperandForm specifies operand encoding and should be one of 0, A, D, X, T, |
| // A_D (old), A_X (old), A_E, A_Y, D_F or A_B_C (see ENCODING section above). |
| // |
| // - BytecodeKind is one of OLD, WIDE, RESV (reserved), ORDN (ordinary) |
| // |
| // - Op1, Op2, Op3 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 incremented immediately after fetch |
| // and before decoding. |
| // |
| #define PUBLIC_KERNEL_BYTECODES_LIST(V) \ |
| V(Trap_Old, 0, OLD, ___, ___, ___) \ |
| V(Entry_Old, D, OLD, num, ___, ___) \ |
| V(EntryFixed_Old, A_D, OLD, num, num, ___) \ |
| V(EntryOptional_Old, A_B_C, OLD, num, num, num) \ |
| V(LoadConstant_Old, A_D, OLD, reg, lit, ___) \ |
| V(Frame_Old, D, OLD, num, ___, ___) \ |
| V(CheckFunctionTypeArgs_Old, A_D, OLD, num, reg, ___) \ |
| V(CheckStack_Old, A, OLD, num, ___, ___) \ |
| V(Allocate_Old, D, OLD, lit, ___, ___) \ |
| V(AllocateT_Old, 0, OLD, ___, ___, ___) \ |
| V(CreateArrayTOS_Old, 0, OLD, ___, ___, ___) \ |
| V(AllocateContext_Old, D, OLD, num, ___, ___) \ |
| V(CloneContext_Old, D, OLD, num, ___, ___) \ |
| V(LoadContextParent_Old, 0, OLD, ___, ___, ___) \ |
| V(StoreContextParent_Old, 0, OLD, ___, ___, ___) \ |
| V(LoadContextVar_Old, D, OLD, num, ___, ___) \ |
| V(StoreContextVar_Old, D, OLD, num, ___, ___) \ |
| V(PushConstant_Old, D, OLD, lit, ___, ___) \ |
| V(PushNull_Old, 0, OLD, ___, ___, ___) \ |
| V(PushTrue_Old, 0, OLD, ___, ___, ___) \ |
| V(PushFalse_Old, 0, OLD, ___, ___, ___) \ |
| V(PushInt_Old, X, OLD, num, ___, ___) \ |
| V(Drop1_Old, 0, OLD, ___, ___, ___) \ |
| V(Push_Old, X, OLD, xeg, ___, ___) \ |
| V(PopLocal_Old, X, OLD, xeg, ___, ___) \ |
| V(StoreLocal_Old, X, OLD, xeg, ___, ___) \ |
| V(LoadFieldTOS_Old, D, OLD, lit, ___, ___) \ |
| V(StoreFieldTOS_Old, D, OLD, lit, ___, ___) \ |
| V(StoreIndexedTOS_Old, 0, OLD, ___, ___, ___) \ |
| V(PushStatic_Old, D, OLD, lit, ___, ___) \ |
| V(StoreStaticTOS_Old, D, OLD, lit, ___, ___) \ |
| V(Jump_Old, T, OLD, tgt, ___, ___) \ |
| V(JumpIfNoAsserts_Old, T, OLD, tgt, ___, ___) \ |
| V(JumpIfNotZeroTypeArgs_Old, T, OLD, tgt, ___, ___) \ |
| V(JumpIfEqStrict_Old, T, OLD, tgt, ___, ___) \ |
| V(JumpIfNeStrict_Old, T, OLD, tgt, ___, ___) \ |
| V(JumpIfTrue_Old, T, OLD, tgt, ___, ___) \ |
| V(JumpIfFalse_Old, T, OLD, tgt, ___, ___) \ |
| V(JumpIfNull_Old, T, OLD, tgt, ___, ___) \ |
| V(JumpIfNotNull_Old, T, OLD, tgt, ___, ___) \ |
| V(Unused00_Old, 0, RESV, num, num, ___) \ |
| V(InterfaceCall_Old, A_D, OLD, num, num, ___) \ |
| V(DynamicCall_Old, A_D, OLD, num, num, ___) \ |
| V(NativeCall_Old, D, OLD, lit, ___, ___) \ |
| V(ReturnTOS_Old, 0, OLD, ___, ___, ___) \ |
| V(AssertAssignable_Old, A_D, OLD, num, lit, ___) \ |
| V(AssertBoolean_Old, A, OLD, num, ___, ___) \ |
| V(AssertSubtype_Old, 0, OLD, ___, ___, ___) \ |
| V(LoadTypeArgumentsField_Old, D, OLD, lit, ___, ___) \ |
| V(InstantiateType_Old, D, OLD, lit, ___, ___) \ |
| V(InstantiateTypeArgumentsTOS_Old, A_D, OLD, num, lit, ___) \ |
| V(Throw_Old, A, OLD, num, ___, ___) \ |
| V(MoveSpecial_Old, A_X, OLD, num, xeg, ___) \ |
| V(SetFrame_Old, A, OLD, num, ___, num) \ |
| V(BooleanNegateTOS_Old, 0, OLD, ___, ___, ___) \ |
| V(EqualsNull_Old, 0, OLD, ___, ___, ___) \ |
| V(NegateInt_Old, 0, OLD, ___, ___, ___) \ |
| V(AddInt_Old, 0, OLD, ___, ___, ___) \ |
| V(SubInt_Old, 0, OLD, ___, ___, ___) \ |
| V(MulInt_Old, 0, OLD, ___, ___, ___) \ |
| V(TruncDivInt_Old, 0, OLD, ___, ___, ___) \ |
| V(ModInt_Old, 0, OLD, ___, ___, ___) \ |
| V(BitAndInt_Old, 0, OLD, ___, ___, ___) \ |
| V(BitOrInt_Old, 0, OLD, ___, ___, ___) \ |
| V(BitXorInt_Old, 0, OLD, ___, ___, ___) \ |
| V(ShlInt_Old, 0, OLD, ___, ___, ___) \ |
| V(ShrInt_Old, 0, OLD, ___, ___, ___) \ |
| V(CompareIntEq_Old, 0, OLD, ___, ___, ___) \ |
| V(CompareIntGt_Old, 0, OLD, ___, ___, ___) \ |
| V(CompareIntLt_Old, 0, OLD, ___, ___, ___) \ |
| V(CompareIntGe_Old, 0, OLD, ___, ___, ___) \ |
| V(CompareIntLe_Old, 0, OLD, ___, ___, ___) \ |
| V(DirectCall_Old, A_D, OLD, num, num, ___) \ |
| V(AllocateClosure_Old, D, OLD, lit, ___, ___) \ |
| V(UncheckedInterfaceCall_Old, A_D, OLD, num, num, ___) \ |
| V(NegateDouble_Old, 0, OLD, ___, ___, ___) \ |
| V(AddDouble_Old, 0, OLD, ___, ___, ___) \ |
| V(SubDouble_Old, 0, OLD, ___, ___, ___) \ |
| V(MulDouble_Old, 0, OLD, ___, ___, ___) \ |
| V(DivDouble_Old, 0, OLD, ___, ___, ___) \ |
| V(CompareDoubleEq_Old, 0, OLD, ___, ___, ___) \ |
| V(CompareDoubleGt_Old, 0, OLD, ___, ___, ___) \ |
| V(CompareDoubleLt_Old, 0, OLD, ___, ___, ___) \ |
| V(CompareDoubleGe_Old, 0, OLD, ___, ___, ___) \ |
| V(CompareDoubleLe_Old, 0, OLD, ___, ___, ___) \ |
| V(Trap, 0, ORDN, ___, ___, ___) \ |
| V(Entry, D, ORDN, num, ___, ___) \ |
| V(Entry_Wide, D, WIDE, num, ___, ___) \ |
| V(EntryFixed, A_E, ORDN, num, num, ___) \ |
| V(EntryFixed_Wide, A_E, WIDE, num, num, ___) \ |
| V(EntryOptional, A_B_C, ORDN, num, num, num) \ |
| V(Unused00, 0, RESV, ___, ___, ___) \ |
| V(LoadConstant, A_E, ORDN, reg, lit, ___) \ |
| V(LoadConstant_Wide, A_E, WIDE, reg, lit, ___) \ |
| V(Frame, D, ORDN, num, ___, ___) \ |
| V(Frame_Wide, D, WIDE, num, ___, ___) \ |
| V(CheckFunctionTypeArgs, A_E, ORDN, num, reg, ___) \ |
| V(CheckFunctionTypeArgs_Wide, A_E, WIDE, num, reg, ___) \ |
| V(CheckStack, A, ORDN, num, ___, ___) \ |
| V(Unused01, 0, RESV, ___, ___, ___) \ |
| V(Unused02, 0, RESV, ___, ___, ___) \ |
| V(Unused03, 0, RESV, ___, ___, ___) \ |
| V(Allocate, D, ORDN, lit, ___, ___) \ |
| V(Allocate_Wide, D, WIDE, lit, ___, ___) \ |
| V(AllocateT, 0, ORDN, ___, ___, ___) \ |
| V(CreateArrayTOS, 0, ORDN, ___, ___, ___) \ |
| V(AllocateClosure, D, ORDN, lit, ___, ___) \ |
| V(AllocateClosure_Wide, D, WIDE, lit, ___, ___) \ |
| V(AllocateContext, A_E, ORDN, num, ___, ___) \ |
| V(AllocateContext_Wide, A_E, WIDE, num, ___, ___) \ |
| V(CloneContext, A_E, ORDN, num, ___, ___) \ |
| V(CloneContext_Wide, A_E, WIDE, num, ___, ___) \ |
| V(LoadContextParent, 0, ORDN, ___, ___, ___) \ |
| V(StoreContextParent, 0, ORDN, ___, ___, ___) \ |
| V(LoadContextVar, A_E, ORDN, num, ___, ___) \ |
| V(LoadContextVar_Wide, A_E, WIDE, num, ___, ___) \ |
| V(Unused04, 0, RESV, ___, ___, ___) \ |
| V(Unused05, 0, RESV, ___, ___, ___) \ |
| V(StoreContextVar, A_E, ORDN, num, ___, ___) \ |
| V(StoreContextVar_Wide, A_E, WIDE, num, ___, ___) \ |
| V(PushConstant, D, ORDN, lit, ___, ___) \ |
| V(PushConstant_Wide, D, WIDE, lit, ___, ___) \ |
| V(Unused06, 0, RESV, ___, ___, ___) \ |
| V(Unused07, 0, RESV, ___, ___, ___) \ |
| V(PushTrue, 0, ORDN, ___, ___, ___) \ |
| V(PushFalse, 0, ORDN, ___, ___, ___) \ |
| V(PushInt, X, ORDN, num, ___, ___) \ |
| V(PushInt_Wide, X, WIDE, num, ___, ___) \ |
| V(Unused08, 0, RESV, ___, ___, ___) \ |
| V(Unused09, 0, RESV, ___, ___, ___) \ |
| V(Unused10, 0, RESV, ___, ___, ___) \ |
| V(Unused11, 0, RESV, ___, ___, ___) \ |
| V(PushNull, 0, ORDN, ___, ___, ___) \ |
| V(Drop1, 0, ORDN, ___, ___, ___) \ |
| V(Push, X, ORDN, xeg, ___, ___) \ |
| V(Push_Wide, X, WIDE, xeg, ___, ___) \ |
| V(Unused12, 0, RESV, ___, ___, ___) \ |
| V(Unused13, 0, RESV, ___, ___, ___) \ |
| V(Unused14, 0, RESV, ___, ___, ___) \ |
| V(Unused15, 0, RESV, ___, ___, ___) \ |
| V(Unused16, 0, RESV, ___, ___, ___) \ |
| V(Unused17, 0, RESV, ___, ___, ___) \ |
| V(PopLocal, X, ORDN, xeg, ___, ___) \ |
| V(PopLocal_Wide, X, WIDE, xeg, ___, ___) \ |
| V(Unused18, 0, RESV, ___, ___, ___) \ |
| V(Unused19, 0, RESV, ___, ___, ___) \ |
| V(StoreLocal, X, ORDN, xeg, ___, ___) \ |
| V(StoreLocal_Wide, X, WIDE, xeg, ___, ___) \ |
| V(LoadFieldTOS, D, ORDN, lit, ___, ___) \ |
| V(LoadFieldTOS_Wide, D, WIDE, lit, ___, ___) \ |
| V(StoreFieldTOS, D, ORDN, lit, ___, ___) \ |
| V(StoreFieldTOS_Wide, D, WIDE, lit, ___, ___) \ |
| V(StoreIndexedTOS, 0, ORDN, ___, ___, ___) \ |
| V(Unused20, 0, RESV, ___, ___, ___) \ |
| V(PushStatic, D, ORDN, lit, ___, ___) \ |
| V(PushStatic_Wide, D, WIDE, lit, ___, ___) \ |
| V(StoreStaticTOS, D, ORDN, lit, ___, ___) \ |
| V(StoreStaticTOS_Wide, D, WIDE, lit, ___, ___) \ |
| V(Jump, T, ORDN, tgt, ___, ___) \ |
| V(Jump_Wide, T, WIDE, tgt, ___, ___) \ |
| V(JumpIfNoAsserts, T, ORDN, tgt, ___, ___) \ |
| V(JumpIfNoAsserts_Wide, T, WIDE, tgt, ___, ___) \ |
| V(JumpIfNotZeroTypeArgs, T, ORDN, tgt, ___, ___) \ |
| V(JumpIfNotZeroTypeArgs_Wide, T, WIDE, tgt, ___, ___) \ |
| V(JumpIfEqStrict, T, ORDN, tgt, ___, ___) \ |
| V(JumpIfEqStrict_Wide, T, WIDE, tgt, ___, ___) \ |
| V(JumpIfNeStrict, T, ORDN, tgt, ___, ___) \ |
| V(JumpIfNeStrict_Wide, T, WIDE, tgt, ___, ___) \ |
| V(JumpIfTrue, T, ORDN, tgt, ___, ___) \ |
| V(JumpIfTrue_Wide, T, WIDE, tgt, ___, ___) \ |
| V(JumpIfFalse, T, ORDN, tgt, ___, ___) \ |
| V(JumpIfFalse_Wide, T, WIDE, tgt, ___, ___) \ |
| V(JumpIfNull, T, ORDN, tgt, ___, ___) \ |
| V(JumpIfNull_Wide, T, WIDE, tgt, ___, ___) \ |
| V(JumpIfNotNull, T, ORDN, tgt, ___, ___) \ |
| V(JumpIfNotNull_Wide, T, WIDE, tgt, ___, ___) \ |
| V(DirectCall, D_F, ORDN, num, num, ___) \ |
| V(DirectCall_Wide, D_F, WIDE, num, num, ___) \ |
| V(Unused21, 0, RESV, ___, ___, ___) \ |
| V(Unused22, 0, RESV, ___, ___, ___) \ |
| V(InterfaceCall, D_F, ORDN, num, num, ___) \ |
| V(InterfaceCall_Wide, D_F, WIDE, num, num, ___) \ |
| V(Unused23, 0, RESV, ___, ___, ___) \ |
| V(Unused24, 0, RESV, ___, ___, ___) \ |
| V(Unused25, 0, RESV, ___, ___, ___) \ |
| V(Unused26, 0, RESV, ___, ___, ___) \ |
| V(Unused27, 0, RESV, ___, ___, ___) \ |
| V(Unused28, 0, RESV, ___, ___, ___) \ |
| V(UncheckedInterfaceCall, D_F, ORDN, num, num, ___) \ |
| V(UncheckedInterfaceCall_Wide, D_F, WIDE, num, num, ___) \ |
| V(DynamicCall, D_F, ORDN, num, num, ___) \ |
| V(DynamicCall_Wide, D_F, WIDE, num, num, ___) \ |
| V(NativeCall, D, ORDN, lit, ___, ___) \ |
| V(NativeCall_Wide, D, WIDE, lit, ___, ___) \ |
| V(ReturnTOS, 0, ORDN, ___, ___, ___) \ |
| V(Unused29, 0, RESV, ___, ___, ___) \ |
| V(AssertAssignable, A_E, ORDN, num, lit, ___) \ |
| V(AssertAssignable_Wide, A_E, WIDE, num, lit, ___) \ |
| V(Unused30, 0, RESV, ___, ___, ___) \ |
| V(Unused31, 0, RESV, ___, ___, ___) \ |
| V(AssertBoolean, A, ORDN, num, ___, ___) \ |
| V(AssertSubtype, 0, ORDN, ___, ___, ___) \ |
| V(LoadTypeArgumentsField, D, ORDN, lit, ___, ___) \ |
| V(LoadTypeArgumentsField_Wide, D, WIDE, lit, ___, ___) \ |
| V(InstantiateType, D, ORDN, lit, ___, ___) \ |
| V(InstantiateType_Wide, D, WIDE, lit, ___, ___) \ |
| V(InstantiateTypeArgumentsTOS, A_E, ORDN, num, lit, ___) \ |
| V(InstantiateTypeArgumentsTOS_Wide, A_E, WIDE, num, lit, ___) \ |
| V(Unused32, 0, RESV, ___, ___, ___) \ |
| V(Unused33, 0, RESV, ___, ___, ___) \ |
| V(Unused34, 0, RESV, ___, ___, ___) \ |
| V(Unused35, 0, RESV, ___, ___, ___) \ |
| V(Throw, A, ORDN, num, ___, ___) \ |
| V(SetFrame, A, ORDN, num, ___, num) \ |
| V(MoveSpecial, A_Y, ORDN, num, xeg, ___) \ |
| V(MoveSpecial_Wide, A_Y, WIDE, num, xeg, ___) \ |
| V(BooleanNegateTOS, 0, ORDN, ___, ___, ___) \ |
| V(EqualsNull, 0, ORDN, ___, ___, ___) \ |
| V(Unused36, 0, RESV, ___, ___, ___) \ |
| V(Unused37, 0, RESV, ___, ___, ___) \ |
| V(NegateInt, 0, ORDN, ___, ___, ___) \ |
| V(AddInt, 0, ORDN, ___, ___, ___) \ |
| V(SubInt, 0, ORDN, ___, ___, ___) \ |
| V(MulInt, 0, ORDN, ___, ___, ___) \ |
| V(TruncDivInt, 0, ORDN, ___, ___, ___) \ |
| V(ModInt, 0, ORDN, ___, ___, ___) \ |
| V(BitAndInt, 0, ORDN, ___, ___, ___) \ |
| V(BitOrInt, 0, ORDN, ___, ___, ___) \ |
| V(BitXorInt, 0, ORDN, ___, ___, ___) \ |
| V(ShlInt, 0, ORDN, ___, ___, ___) \ |
| V(ShrInt, 0, ORDN, ___, ___, ___) \ |
| V(CompareIntEq, 0, ORDN, ___, ___, ___) \ |
| V(CompareIntGt, 0, ORDN, ___, ___, ___) \ |
| V(CompareIntLt, 0, ORDN, ___, ___, ___) \ |
| V(CompareIntGe, 0, ORDN, ___, ___, ___) \ |
| V(CompareIntLe, 0, ORDN, ___, ___, ___) \ |
| V(NegateDouble, 0, ORDN, ___, ___, ___) \ |
| V(AddDouble, 0, ORDN, ___, ___, ___) \ |
| V(SubDouble, 0, ORDN, ___, ___, ___) \ |
| V(MulDouble, 0, ORDN, ___, ___, ___) \ |
| V(DivDouble, 0, ORDN, ___, ___, ___) \ |
| V(CompareDoubleEq, 0, ORDN, ___, ___, ___) \ |
| V(CompareDoubleGt, 0, ORDN, ___, ___, ___) \ |
| V(CompareDoubleLt, 0, ORDN, ___, ___, ___) \ |
| V(CompareDoubleGe, 0, ORDN, ___, ___, ___) \ |
| V(CompareDoubleLe, 0, ORDN, ___, ___, ___) \ |
| |
| // These bytecodes are only generated within the VM. Reassigning their |
| // opcodes is not a breaking change. |
| #define INTERNAL_KERNEL_BYTECODES_LIST(V) \ |
| V(VMInternal_ImplicitGetter, 0, ORDN, ___, ___, ___) \ |
| V(VMInternal_ImplicitSetter, 0, ORDN, ___, ___, ___) \ |
| V(VMInternal_ImplicitStaticGetter, 0, ORDN, ___, ___, ___) \ |
| V(VMInternal_MethodExtractor, 0, ORDN, ___, ___, ___) \ |
| V(VMInternal_InvokeClosure, 0, ORDN, ___, ___, ___) \ |
| V(VMInternal_InvokeField, 0, ORDN, ___, ___, ___) \ |
| V(VMInternal_ForwardDynamicInvocation, 0, ORDN, ___, ___, ___) \ |
| V(VMInternal_NoSuchMethodDispatcher, 0, ORDN, ___, ___, ___) \ |
| V(VMInternal_ImplicitStaticClosure, 0, ORDN, ___, ___, ___) \ |
| V(VMInternal_ImplicitInstanceClosure, 0, ORDN, ___, ___, ___) \ |
| |
| #define KERNEL_BYTECODES_LIST(V) \ |
| PUBLIC_KERNEL_BYTECODES_LIST(V) \ |
| INTERNAL_KERNEL_BYTECODES_LIST(V) |
| |
| // clang-format on |
| |
| typedef uint8_t KBCInstr; |
| |
| class KernelBytecode { |
| public: |
| // Magic value of bytecode files. |
| static const intptr_t kMagicValue = 0x44424332; // 'DBC2' |
| // Minimum bytecode format version supported by VM. |
| static const intptr_t kMinSupportedBytecodeFormatVersion = 3; |
| // Maximum bytecode format version supported by VM. |
| // The range of supported versions should include version produced by bytecode |
| // generator (currentBytecodeFormatVersion in pkg/vm/lib/bytecode/dbc.dart). |
| static const intptr_t kMaxSupportedBytecodeFormatVersion = 9; |
| |
| enum Opcode { |
| #define DECLARE_BYTECODE(name, encoding, kind, op1, op2, op3) k##name, |
| KERNEL_BYTECODES_LIST(DECLARE_BYTECODE) |
| #undef DECLARE_BYTECODE |
| }; |
| |
| static const char* NameOf(Opcode op) { |
| const char* names[] = { |
| #define NAME(name, encoding, kind, op1, op2, op3) #name, |
| KERNEL_BYTECODES_LIST(NAME) |
| #undef NAME |
| }; |
| return names[op]; |
| } |
| |
| static const intptr_t kInstructionSize[]; |
| |
| enum SpecialIndex { |
| kExceptionSpecialIndex, |
| kStackTraceSpecialIndex, |
| kSpecialIndexCount |
| }; |
| |
| private: |
| static const intptr_t kWideModifier = 1; |
| |
| static_assert(kMinSupportedBytecodeFormatVersion < 7, |
| "Cleanup support for old bytecode format versions"); |
| DART_FORCE_INLINE static bool IsOld(const KBCInstr* instr) { |
| return DecodeOpcode(instr) < kTrap; |
| } |
| |
| // Should be used only on instructions with wide variants. |
| DART_FORCE_INLINE static bool IsWide(const KBCInstr* instr) { |
| return ((DecodeOpcode(instr) & kWideModifier) != 0); |
| } |
| |
| public: |
| DART_FORCE_INLINE static uint8_t DecodeA(const KBCInstr* bc) { return bc[1]; } |
| |
| DART_FORCE_INLINE static uint8_t DecodeB(const KBCInstr* bc) { return bc[2]; } |
| |
| DART_FORCE_INLINE static uint8_t DecodeC(const KBCInstr* bc) { return bc[3]; } |
| |
| DART_FORCE_INLINE static uint32_t DecodeD(const KBCInstr* bc) { |
| if (IsOld(bc)) { |
| return static_cast<uint16_t>(bc[2]) | (static_cast<uint16_t>(bc[3]) << 8); |
| } else if (IsWide(bc)) { |
| return static_cast<uint32_t>(bc[1]) | |
| (static_cast<uint32_t>(bc[2]) << 8) | |
| (static_cast<uint32_t>(bc[3]) << 16) | |
| (static_cast<uint32_t>(bc[4]) << 24); |
| } else { |
| return bc[1]; |
| } |
| } |
| |
| DART_FORCE_INLINE static int32_t DecodeX(const KBCInstr* bc) { |
| if (IsOld(bc)) { |
| return static_cast<int16_t>(static_cast<uint16_t>(bc[2]) | |
| (static_cast<uint16_t>(bc[3]) << 8)); |
| } else if (IsWide(bc)) { |
| return static_cast<int32_t>(static_cast<uint32_t>(bc[1]) | |
| (static_cast<uint32_t>(bc[2]) << 8) | |
| (static_cast<uint32_t>(bc[3]) << 16) | |
| (static_cast<uint32_t>(bc[4]) << 24)); |
| } else { |
| return static_cast<int8_t>(bc[1]); |
| } |
| } |
| |
| DART_FORCE_INLINE static int32_t DecodeT(const KBCInstr* bc) { |
| if (IsOld(bc)) { |
| return static_cast<int32_t>((static_cast<uint32_t>(bc[1]) << 8) | |
| (static_cast<uint32_t>(bc[2]) << 16) | |
| (static_cast<uint32_t>(bc[3]) << 24)) >> |
| (8 - 2); |
| } else if (IsWide(bc)) { |
| return static_cast<int32_t>((static_cast<uint32_t>(bc[1]) << 8) | |
| (static_cast<uint32_t>(bc[2]) << 16) | |
| (static_cast<uint32_t>(bc[3]) << 24)) >> |
| 8; |
| } else { |
| return static_cast<int8_t>(bc[1]); |
| } |
| } |
| |
| DART_FORCE_INLINE static uint32_t DecodeE(const KBCInstr* bc) { |
| if (IsOld(bc)) { |
| return static_cast<uint16_t>(bc[2]) | (static_cast<uint16_t>(bc[3]) << 8); |
| } else if (IsWide(bc)) { |
| return static_cast<uint32_t>(bc[2]) | |
| (static_cast<uint32_t>(bc[3]) << 8) | |
| (static_cast<uint32_t>(bc[4]) << 16) | |
| (static_cast<uint32_t>(bc[5]) << 24); |
| } else { |
| return bc[2]; |
| } |
| } |
| |
| DART_FORCE_INLINE static int32_t DecodeY(const KBCInstr* bc) { |
| if (IsOld(bc)) { |
| return static_cast<int16_t>(static_cast<uint16_t>(bc[2]) | |
| (static_cast<uint16_t>(bc[3]) << 8)); |
| } else if (IsWide(bc)) { |
| return static_cast<int32_t>(static_cast<uint32_t>(bc[2]) | |
| (static_cast<uint32_t>(bc[3]) << 8) | |
| (static_cast<uint32_t>(bc[4]) << 16) | |
| (static_cast<uint32_t>(bc[5]) << 24)); |
| } else { |
| return static_cast<int8_t>(bc[2]); |
| } |
| } |
| |
| DART_FORCE_INLINE static uint8_t DecodeF(const KBCInstr* bc) { |
| if (IsOld(bc)) { |
| return bc[1]; |
| } else if (IsWide(bc)) { |
| return bc[5]; |
| } else { |
| return bc[2]; |
| } |
| } |
| |
| DART_FORCE_INLINE static Opcode DecodeOpcode(const KBCInstr* bc) { |
| return static_cast<Opcode>(bc[0]); |
| } |
| |
| DART_FORCE_INLINE static const KBCInstr* Next(const KBCInstr* bc) { |
| return bc + kInstructionSize[DecodeOpcode(bc)]; |
| } |
| |
| DART_FORCE_INLINE static bool IsJumpOpcode(const KBCInstr* instr) { |
| switch (DecodeOpcode(instr)) { |
| case KernelBytecode::kJump_Old: |
| case KernelBytecode::kJumpIfNoAsserts_Old: |
| case KernelBytecode::kJumpIfNotZeroTypeArgs_Old: |
| case KernelBytecode::kJumpIfEqStrict_Old: |
| case KernelBytecode::kJumpIfNeStrict_Old: |
| case KernelBytecode::kJumpIfTrue_Old: |
| case KernelBytecode::kJumpIfFalse_Old: |
| case KernelBytecode::kJumpIfNull_Old: |
| case KernelBytecode::kJumpIfNotNull_Old: |
| case KernelBytecode::kJump: |
| case KernelBytecode::kJump_Wide: |
| case KernelBytecode::kJumpIfNoAsserts: |
| case KernelBytecode::kJumpIfNoAsserts_Wide: |
| case KernelBytecode::kJumpIfNotZeroTypeArgs: |
| case KernelBytecode::kJumpIfNotZeroTypeArgs_Wide: |
| case KernelBytecode::kJumpIfEqStrict: |
| case KernelBytecode::kJumpIfEqStrict_Wide: |
| case KernelBytecode::kJumpIfNeStrict: |
| case KernelBytecode::kJumpIfNeStrict_Wide: |
| case KernelBytecode::kJumpIfTrue: |
| case KernelBytecode::kJumpIfTrue_Wide: |
| case KernelBytecode::kJumpIfFalse: |
| case KernelBytecode::kJumpIfFalse_Wide: |
| case KernelBytecode::kJumpIfNull: |
| case KernelBytecode::kJumpIfNull_Wide: |
| case KernelBytecode::kJumpIfNotNull: |
| case KernelBytecode::kJumpIfNotNull_Wide: |
| return true; |
| |
| default: |
| return false; |
| } |
| } |
| |
| DART_FORCE_INLINE static bool IsLoadConstantOpcode(const KBCInstr* instr) { |
| switch (DecodeOpcode(instr)) { |
| case KernelBytecode::kLoadConstant: |
| case KernelBytecode::kLoadConstant_Wide: |
| case KernelBytecode::kLoadConstant_Old: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| DART_FORCE_INLINE static bool IsCheckStackOpcode(const KBCInstr* instr) { |
| switch (DecodeOpcode(instr)) { |
| case KernelBytecode::kCheckStack: |
| case KernelBytecode::kCheckStack_Old: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| DART_FORCE_INLINE static bool IsEntryOptionalOpcode(const KBCInstr* instr) { |
| switch (DecodeOpcode(instr)) { |
| case KernelBytecode::kEntryOptional: |
| case KernelBytecode::kEntryOptional_Old: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| DART_FORCE_INLINE static bool IsFrameOpcode(const KBCInstr* instr) { |
| switch (DecodeOpcode(instr)) { |
| case KernelBytecode::kFrame: |
| case KernelBytecode::kFrame_Wide: |
| case KernelBytecode::kFrame_Old: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| DART_FORCE_INLINE static bool IsSetFrameOpcode(const KBCInstr* instr) { |
| switch (DecodeOpcode(instr)) { |
| case KernelBytecode::kSetFrame: |
| case KernelBytecode::kSetFrame_Old: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| DART_FORCE_INLINE static bool IsCallOpcode_Old(const KBCInstr* instr) { |
| switch (DecodeOpcode(instr)) { |
| case KernelBytecode::kDirectCall_Old: |
| case KernelBytecode::kInterfaceCall_Old: |
| case KernelBytecode::kUncheckedInterfaceCall_Old: |
| case KernelBytecode::kDynamicCall_Old: |
| return true; |
| |
| default: |
| return false; |
| } |
| } |
| |
| DART_FORCE_INLINE static bool IsNativeCallOpcode(const KBCInstr* instr) { |
| switch (DecodeOpcode(instr)) { |
| case KernelBytecode::kNativeCall: |
| case KernelBytecode::kNativeCall_Wide: |
| case KernelBytecode::kNativeCall_Old: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| // The interpreter and this function must agree on the opcodes. |
| DART_FORCE_INLINE static bool IsDebugBreakCheckedOpcode( |
| const KBCInstr* instr) { |
| switch (DecodeOpcode(instr)) { |
| case KernelBytecode::kPopLocal: |
| case KernelBytecode::kPopLocal_Wide: |
| case KernelBytecode::kStoreLocal: |
| case KernelBytecode::kStoreLocal_Wide: |
| case KernelBytecode::kStoreStaticTOS: |
| case KernelBytecode::kStoreStaticTOS_Wide: |
| case KernelBytecode::kCheckStack: |
| case KernelBytecode::kDirectCall: |
| case KernelBytecode::kDirectCall_Wide: |
| case KernelBytecode::kInterfaceCall: |
| case KernelBytecode::kInterfaceCall_Wide: |
| case KernelBytecode::kUncheckedInterfaceCall: |
| case KernelBytecode::kUncheckedInterfaceCall_Wide: |
| case KernelBytecode::kDynamicCall: |
| case KernelBytecode::kDynamicCall_Wide: |
| case KernelBytecode::kReturnTOS: |
| case KernelBytecode::kThrow: |
| case KernelBytecode::kJump: |
| case KernelBytecode::kJump_Wide: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| static const uint8_t kNativeCallToGrowableListArgc = 2; |
| |
| DART_FORCE_INLINE static uint8_t DecodeArgc_Old(const KBCInstr* ret_addr) { |
| const intptr_t kOldInstructionSize = 4; |
| const KBCInstr* call = ret_addr - kOldInstructionSize; |
| ASSERT(IsOld(call)); |
| if (DecodeOpcode(call) == KernelBytecode::kNativeCall_Old) { |
| // The only NativeCall redirecting to a bytecode function is the call |
| // to new _GrowableList<E>(0). |
| return kNativeCallToGrowableListArgc; |
| } |
| ASSERT(IsCallOpcode_Old(call)); |
| return DecodeA(call); |
| } |
| |
| // Returns a fake return address which points after the 2-argument |
| // bytecode call, followed by ReturnTOS instructions. |
| static const KBCInstr* GetNativeCallToGrowableListReturnTrampoline(); |
| |
| DART_FORCE_INLINE static uint8_t DecodeArgc(const KBCInstr* ret_addr) { |
| // All call instructions have DF encoding, with argc being the last byte |
| // regardless of whether the wide variant is used or not. |
| return ret_addr[-1]; |
| } |
| |
| // Converts bytecode PC into an offset. |
| // For return addresses used in PcDescriptors, PC is also augmented by 1. |
| // TODO(regis): Eliminate this correction. |
| static intptr_t BytecodePcToOffset(uint32_t pc, bool is_return_address) { |
| return pc + (is_return_address ? 1 : 0); |
| } |
| |
| static uint32_t OffsetToBytecodePc(intptr_t offset, bool is_return_address) { |
| return offset - (is_return_address ? 1 : 0); |
| } |
| |
| static void GetVMInternalBytecodeInstructions(Opcode opcode, |
| const KBCInstr** instructions, |
| intptr_t* instructions_size); |
| |
| private: |
| DISALLOW_ALLOCATION(); |
| DISALLOW_IMPLICIT_CONSTRUCTORS(KernelBytecode); |
| }; |
| |
| } // namespace dart |
| |
| #endif // RUNTIME_VM_CONSTANTS_KBC_H_ |
