Lines Matching defs:bytecode

455   // Underlying function needs to have bytecode available.
949 // Advance the current bytecode offset. This simulates what all bytecode
951 // label if the bytecode (without prefix) is a return bytecode. Will not advance
952 // the bytecode offset if the current bytecode is a JumpLoop, instead just
953 // re-executing the JumpLoop to jump to the correct bytecode.
957                                           Register bytecode, Register scratch1,
962   // The bytecode offset value will be increased by one in wide and extra wide
963   // cases. In the case of having a wide or extra wide JumpLoop bytecode, we
964   // will restore the original bytecode. In order to simplify the code, we have
968                      bytecode, original_bytecode_offset));
974   // Check if the bytecode is a Wide or ExtraWide prefix bytecode.
981   __ cmp(bytecode, Operand(0x3));
983   __ tst(bytecode, Operand(0x1));
984   // Load the next bytecode.
986   __ ldrb(bytecode, MemOperand(bytecode_array, bytecode_offset));
999   // Bailout to the return label if this is a return bytecode.
1001   // Create cmp, cmpne, ..., cmpne to check for a return bytecode.
1004   __ cmp(bytecode, Operand(static_cast<int>(interpreter::Bytecode::k##NAME)), \
1015   __ cmp(bytecode, Operand(static_cast<int>(interpreter::Bytecode::kJumpLoop)));
1018   // increased it to skip the wide / extra-wide prefix bytecode.
1023   // Otherwise, load the size of the current bytecode and advance the offset.
1024   __ ldrb(scratch1, MemOperand(bytecode_size_table, bytecode));
1072   // Reset the bytecode age and OSR state (optimized to a single write).
1149     // We'll use the bytecode for both code age/OSR resetting, and pushing onto
1160     // store the bytecode offset.
1244   // Get the bytecode array from the function object and load it into
1254   // The bytecode array could have been flushed from the shared function info,
1298   // Load the initial bytecode offset.
1302   // Push bytecode array and Smi tagged bytecode array offset.
1333   // If the bytecode array has a valid incoming new target or generator object
1351   // Load the dispatch table into a register and dispatch to the bytecode
1352   // handler at the current bytecode offset.
1366   // Any returns to the entry trampoline are either due to the return bytecode
1369   // Get bytecode array and bytecode offset from the stack frame.
1376   // Either return, or advance to the next bytecode and dispatch.
1391   // Modify the bytecode offset in the stack to be kFunctionEntryBytecodeOffset
1400   // After the call, restore the bytecode array, bytecode offset and accumulator
1401   // registers again. Also, restore the bytecode offset in the stack to its
1632   // Get the bytecode array pointer from the frame.
1647   // Get the target bytecode offset from the frame.
1661   // Dispatch to the target bytecode.
1673   // Get bytecode array and bytecode offset from the stack frame.
1686   // Load the current bytecode.
1690   // Advance to the next bytecode.
1697   // Convert new bytecode offset to a Smi and save in the stackframe.
1706   // not a valid bytecode offset. Detect this case and advance to the first
1707   // actual bytecode.
1836     // JavaScript frame. This is the case then OSR is triggered from bytecode.
3558 // bytecode. If there is baseline code on the shared function info, converts an
3560 // code. Otherwise execution continues with bytecode.
3585     // Start with bytecode as there is no baseline code.
3624   // Compute baseline pc for bytecode offset.
3638   // not a valid bytecode offset.
3653   // Get bytecode array from the stack frame.
3688     // If the bytecode offset is kFunctionEntryOffset, get the start address of
3689     // the first bytecode.