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"
38 static void AssertCodeIsBaseline(MacroAssembler* masm, Register code,
40 DCHECK(!AreAliased(code, scratch));
41 // Verify that the code kind is baseline code via the CodeKind.
42 __ LoadU32(scratch, FieldMemOperand(code, Code::kFlagsOffset));
99 // bytecode. If there is baseline code on the shared function info, converts an
101 // code. Otherwise execution continues with bytecode.
121 // Check if we have baseline code. For OSR entry it is safe to assume we
122 // always have baseline code.
128 // Start with bytecode as there is no baseline code.
135 // Start with baseline code.
181 // If the code deoptimizes during the implicit function entry stack interrupt
249 // Retry from the start after installing baseline code.
265 // If the code object is null, just return to the caller.
279 // Load deoptimization data from the code object.
280 // <deopt_data> = <code>[#deoptimization_data_offset]
424 __ bkpt(0); // Unreachable code.
599 // Unreachable code.
783 // r3: code entry
815 // r3: code entry
920 // returns control to the code after the b(&invoke) above, which
925 // Notice that we cannot store a reference to the trampoline code directly in
1044 // Unreachable code.
1079 // Invoke the code.
1119 // Store code entry in the closure.
1187 // If the optimized code is cleared, go to runtime to update the optimization
1192 // Check if the optimized code is marked for deopt. If it is, call the
1202 // Optimized code is good, get it into the closure and link the closure
1203 // into the optimized functions list, then tail call the optimized code.
1210 // Optimized code slot contains deoptimized code or code is cleared and
1211 // optimized code marker isn't updated. Evict the code, update the marker
1212 // and re-enter the closure's code.
1254 // will restore the original bytecode. In order to simplify the code, we have
1324 // Check if optimized code is available
1343 // is optimized code or a tiering state that needs to be processed.
1424 // We'll use the bytecode for both code age/OSR resetting, and pushing onto
1432 // Baseline code frames store the feedback vector where interpreter would
1494 // Generate code for entering a JS function with the interpreter.
1542 // Check if feedback vector is valid. If valid, check for optimized code
1556 // Check if the optimized code slot is not empty or has a tiering state.
1574 // MANUAL indicates that the scope shouldn't actually generate code to set up
1733 // Load the baseline code into the closure.
1862 Handle<Code> code = BUILTIN_CODE(masm->isolate(), ArrayConstructorImpl);
1863 __ Jump(code, RelocInfo::CODE_TARGET);
1996 // If the code deoptimizes during the implicit function entry stack interrupt
2034 int code = config->GetAllocatableGeneralCode(i);
2035 __ Pop(Register::from_code(code));
2036 if (java_script_builtin && code == kJavaScriptCallArgCountRegister.code()) {
2037 __ SmiUntag(Register::from_code(code));
2094 DCHECK_EQ(kInterpreterAccumulatorRegister.code(), r2.code());
2327 Handle<Code> code) {
2392 __ Jump(code, RelocInfo::CODE_TARGET);
2401 Handle<Code> code) {
2486 // Tail-call to the {code} handler.
2487 __ Jump(code, RelocInfo::CODE_TARGET);
3208 // If we reach this code, 31 <= exponent <= 83.
3626 // This code tries to be close to ia32 code so that any changes can be
3643 int code = config->GetAllocatableDoubleCode(i);
3644 const DoubleRegister dreg = DoubleRegister::from_code(code);
3645 int offset = code * kDoubleSize;
3662 // Get the address of the location in the code object (r5)(return
3680 // r4: code address or 0 already loaded.
3702 // TODO(john.yan): optimize the following code by using mvc instruction
3715 int code = config->GetAllocatableDoubleCode(i);
3716 int dst_offset = code * kDoubleSize + double_regs_offset;
3718 code * kDoubleSize + kNumberOfRegisters * kSystemPointerSize;
3805 int code = config->GetAllocatableDoubleCode(i);
3806 const DoubleRegister dreg = DoubleRegister::from_code(code);
3807 int src_offset = code * kDoubleSize + double_regs_offset;