Lines Matching defs:bytecode

557   // Underlying function needs to have bytecode available.
1135 // Advance the current bytecode offset. This simulates what all bytecode
1137 // label if the bytecode (without prefix) is a return bytecode. Will not advance
1138 // the bytecode offset if the current bytecode is a JumpLoop, instead just
1139 // re-executing the JumpLoop to jump to the correct bytecode.
1143                                           Register bytecode, Register scratch1,
1148   // The bytecode offset value will be increased by one in wide and extra wide
1149   // cases. In the case of having a wide or extra wide JumpLoop bytecode, we
1150   // will restore the original bytecode. In order to simplify the code, we have
1154                      bytecode, original_bytecode_offset));
1159   // Check if the bytecode is a Wide or ExtraWide prefix bytecode.
1166   __ Cmp(bytecode, Operand(0x3));
1168   __ Tst(bytecode, Operand(0x1));
1169   // The code to load the next bytecode is common to both wide and extra wide.
1172   __ Ldrb(bytecode, MemOperand(bytecode_array, bytecode_offset));
1187 // Bailout to the return label if this is a return bytecode.
1197   __ Cmp(bytecode, Operand(static_cast<int>(interpreter::Bytecode::kJumpLoop)));
1200   // increased it to skip the wide / extra-wide prefix bytecode.
1205   // Otherwise, load the size of the current bytecode and advance the offset.
1206   __ Ldrb(scratch1.W(), MemOperand(bytecode_size_table, bytecode));
1255   // Reset the bytecode age and OSR state (optimized to a single write).
1323     // We'll use the bytecode for both code age/OSR resetting, and pushing onto
1331     // store the bytecode offset.
1417   // Get the bytecode array from the function object and load it into
1429   // The bytecode array could have been flushed from the shared function info,
1479   // Load the initial bytecode offset.
1483   // Push actual argument count, bytecode array, Smi tagged bytecode array
1520   // If the bytecode array has a valid incoming new target or generator object
1541   // Load the dispatch table into a register and dispatch to the bytecode
1542   // handler at the current bytecode offset.
1555   // Any returns to the entry trampoline are either due to the return bytecode
1560   // Get bytecode array and bytecode offset from the stack frame.
1566   // Either return, or advance to the next bytecode and dispatch.
1581   // Modify the bytecode offset in the stack to be kFunctionEntryBytecodeOffset
1590   // After the call, restore the bytecode array, bytecode offset and accumulator
1591   // registers again. Also, restore the bytecode offset in the stack to its
1803   // Get the bytecode array pointer from the frame.
1818   // Get the target bytecode offset from the frame.
1836   // Dispatch to the target bytecode.
1895   // Get bytecode array and bytecode offset from the stack frame.
1907   // Load the current bytecode.
1911   // Advance to the next bytecode.
1918   // Convert new bytecode offset to a Smi and save in the stackframe.
1927   // not a valid bytecode offset. Detect this case and advance to the first
1928   // actual bytecode.
2089     // JavaScript frame. This is the case then OSR is triggered from bytecode.
4081 // bytecode. If there is baseline code on the shared function info, converts an
4083 // code. Otherwise execution continues with bytecode.
4110     // Start with bytecode as there is no baseline code.
4153   // Compute baseline pc for bytecode offset.
4167   // not a valid bytecode offset.
4182   // Get bytecode array from the stack frame.
4213     // If the bytecode offset is kFunctionEntryOffset, get the start address of
4214     // the first bytecode.