Lines Matching defs:code
2 // Use of this source code is governed by a BSD-style license that can be
8 #include "src/codegen/code-factory.h"
325 // Unreachable code.
481 // returns control to the code after the bal(&invoke) above, which
609 // Invoke the code.
635 static void AssertCodeIsBaseline(MacroAssembler* masm, Register code,
637 DCHECK(!AreAliased(code, scratch));
638 // Verify that the code kind is baseline code via the CodeKind.
639 __ lw(scratch, FieldMemOperand(code, Code::kFlagsOffset));
807 // Store code entry in the closure.
871 // If the optimized code is cleared, go to runtime to update the optimization
876 // Check if the optimized code is marked for deopt. If it is, call the
885 // Optimized code is good, get it into the closure and link the closure into
886 // the optimized functions list, then tail call the optimized code.
895 // Optimized code slot contains deoptimized code or code is cleared and
896 // optimized code marker isn't updated. Evict the code, update the marker
897 // and re-enter the closure's code.
941 // will restore the original bytecode. In order to simplify the code, we have
1005 // is optimized code or a tiering state that needs to be processed.
1024 // Check if optimized code marker is available
1049 // Reset code age and the OSR state (optimized to a single write).
1120 // We'll use the bytecode for both code age/OSR resetting, and pushing onto
1127 // Baseline code frames store the feedback vector where interpreter would
1141 // code.
1197 // Generate code for entering a JS function with the interpreter.
1238 // Check if feedback vector is valid. If valid, check for optimized code
1245 // is optimized code or an tiering state, call that instead.
1250 // Check if the optimized code slot is not empty or has a tiering state.
1268 // MANUAL indicates that the scope shouldn't actually generate code to set up
1416 // Load the baseline code into the closure.
1428 // Unreachable code.
1433 // Unreachable code.
1503 // Unreachable code.
1564 // Unreachable code.
1631 // Unreachable code.
1679 // If the code deoptimizes during the implicit function entry stack interrupt
1718 int code = config->GetAllocatableGeneralCode(i);
1719 __ Pop(Register::from_code(code));
1720 if (java_script_builtin && code == kJavaScriptCallArgCountRegister.code()) {
1721 __ SmiUntag(Register::from_code(code));
1776 DCHECK_EQ(kInterpreterAccumulatorRegister.code(), v0.code());
1798 // If the code object is null, just return to the caller.
1806 // Load deoptimization data from the code object.
1807 // <deopt_data> = <code>[#deoptimization_data_offset]
2046 Handle<Code> code) {
2100 __ Jump(code, RelocInfo::CODE_TARGET);
2109 Handle<Code> code) {
2180 // Tail-call to the {code} handler.
2181 __ Jump(code, RelocInfo::CODE_TARGET);
2749 // We are calling compiled C/C++ code. a0 and a1 hold our two arguments. We
3303 __ lw(t9, MemOperand(sp, kCArgsSlotsSize)); // Return to calling code.
3318 // This code assumes that cache lines are 32 bytes and if the cache line is
3329 // the kPrefHintPrepareForStore hint is used, the code will not work
3830 // This code tries to be close to ia32 code so that any changes can be
3850 int code = config->GetAllocatableDoubleCode(i);
3851 const DoubleRegister fpu_reg = DoubleRegister::from_code(code);
3852 int offset = code * kDoubleSize;
3872 // Get the address of the location in the code object (a2) (return
3889 // a2: code address or 0 already loaded.
3922 int code = config->GetAllocatableDoubleCode(i);
3923 int dst_offset = code * kDoubleSize + double_regs_offset;
3924 int src_offset = code * kDoubleSize + kNumberOfRegisters * kPointerSize;
3991 int code = config->GetAllocatableDoubleCode(i);
3992 const DoubleRegister fpu_reg = DoubleRegister::from_code(code);
3993 int src_offset = code * kDoubleSize + double_regs_offset;
4038 // bytecode. If there is baseline code on the shared function info, converts an
4040 // code. Otherwise execution continues with bytecode.
4058 // Check if we have baseline code. For OSR entry it is safe to assume we
4059 // always have baseline code.
4065 // Start with bytecode as there is no baseline code.
4072 // Start with baseline code.
4117 // If the code deoptimizes during the implicit function entry stack interrupt
4188 // Retry from the start after installing baseline code.