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"
168 __ bkpt(0); // Unreachable code.
335 // Unreachable code.
343 static void AssertCodeIsBaseline(MacroAssembler* masm, Register code,
345 DCHECK(!AreAliased(code, scratch));
346 // Verify that the code kind is baseline code via the CodeKind.
347 __ ldr(scratch, FieldMemOperand(code, Code::kFlagsOffset));
548 // r1: code entry
656 // returns control to the code after the bl(&invoke) above, which
765 // Unreachable code.
799 // Invoke the code.
837 // Store code entry in the closure.
899 // If the optimized code is cleared, go to runtime to update the optimization
904 // Check if the optimized code is marked for deopt. If it is, call the
913 // Optimized code is good, get it into the closure and link the closure
914 // into the optimized functions list, then tail call the optimized code.
920 // Optimized code slot contains deoptimized code or code is cleared and
921 // optimized code marker isn't updated. Evict the code, update the marker
922 // and re-enter the closure's code.
964 // will restore the original bytecode. In order to simplify the code, we have
1031 // is optimized code or a tiering state that needs to be processed.
1051 // Check if optimized code is available
1149 // We'll use the bytecode for both code age/OSR resetting, and pushing onto
1159 // Baseline code frames store the feedback vector where interpreter would
1225 // Generate code for entering a JS function with the interpreter.
1267 // Check if feedback vector is valid. If valid, check for optimized code
1290 // MANUAL indicates that the scope shouldn't actually generate code to set up
1439 // Load the baseline code into the closure.
1525 // Unreachable code.
1573 Handle<Code> code = BUILTIN_CODE(masm->isolate(), ArrayConstructorImpl);
1574 __ Jump(code, RelocInfo::CODE_TARGET);
1588 // Unreachable code.
1704 // If the code deoptimizes during the implicit function entry stack interrupt
1743 int code = config->GetAllocatableGeneralCode(i);
1744 __ Pop(Register::from_code(code));
1745 if (java_script_builtin && code == kJavaScriptCallArgCountRegister.code()) {
1746 __ SmiUntag(Register::from_code(code));
1799 DCHECK_EQ(kInterpreterAccumulatorRegister.code(), r0.code());
1826 // If the code object is null, just return to the caller.
1840 // Load deoptimization data from the code object.
1841 // <deopt_data> = <code>[#deoptimization_data_offset]
2074 Handle<Code> code) {
2133 __ Jump(code, RelocInfo::CODE_TARGET);
2142 Handle<Code> code) {
2222 // Tail-call to the {code} handler.
2223 __ Jump(code, RelocInfo::CODE_TARGET);
2627 CHECK(fp_param_reg.code() >= lowest_fp_reg.code() &&
2628 fp_param_reg.code() <= highest_fp_reg.code());
2632 CHECK_EQ(highest_fp_reg.code() - lowest_fp_reg.code() + 1,
2636 CHECK_EQ(highest_fp_reg.code() - lowest_fp_reg.code() + 1,
2685 last.code() - first.code() + 1,
2926 // If we reach this code, 30 <= exponent <= 83.
3280 __ ldr(pc, MemOperand(sp, 0)); // Return to calling code.
3318 // This code tries to be close to ia32 code so that any changes can be
3361 // Get the address of the location in the code object (r3) (return
3378 // r2: code address or 0 already loaded.
3558 // bytecode. If there is baseline code on the shared function info, converts an
3560 // code. Otherwise execution continues with bytecode.
3578 // Check if we have baseline code. For OSR entry it is safe to assume we
3579 // always have baseline code.
3585 // Start with bytecode as there is no baseline code.
3592 // Start with baseline code.
3636 // If the code deoptimizes during the implicit function entry stack interrupt
3706 // Retry from the start after installing baseline code.