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"
422 Register code, Register scratch) {
423 // Verify that the code kind is baseline code via the CodeKind.
424 __ Ldr(scratch, FieldMemOperand(code, CodeT::kFlagsOffset));
430 static void AssertCodeTIsBaseline(MacroAssembler* masm, Register code,
432 DCHECK(!AreAliased(code, scratch));
433 return AssertCodeTIsBaselineAllowClobber(masm, code, scratch);
785 // returns control to the code after the B(&invoke) above, which
1001 // Store code entry in the closure.
1073 // If the optimized code is cleared, go to runtime to update the optimization
1078 // Check if the optimized code is marked for deopt. If it is, call the
1099 // Optimized code is good, get it into the closure and link the closure into
1100 // the optimized functions list, then tail call the optimized code.
1106 // Optimized code slot contains deoptimized code or code is cleared and
1107 // optimized code marker isn't updated. Evict the code, update the marker
1108 // and re-enter the closure's code.
1150 // will restore the original bytecode. In order to simplify the code, we have
1169 // The code to load the next bytecode is common to both wide and extra wide.
1213 // is optimized code or a tiering state that needs to be processed.
1233 // Check if optimized code is available
1323 // We'll use the bytecode for both code age/OSR resetting, and pushing onto
1330 // Baseline code frames store the feedback vector where interpreter would
1399 // Generate code for entering a JS function with the interpreter.
1444 // Check if feedback vector is valid. If valid, check for optimized code
1469 // MANUAL indicates that the scope shouldn't actually generate code to set up
1631 // Load the baseline code into the closure.
1831 // Set up LR to point to code below, so we return there after we're done
1925 // If the code deoptimizes during the implicit function entry stack interrupt
1985 int code = config->GetAllocatableGeneralCode(0);
1986 __ Ldr(Register::from_code(code), MemOperand(fp, offset));
2046 DCHECK_EQ(kInterpreterAccumulatorRegister.code(), x0.code());
2080 // If the code object is null, just return to the caller.
2097 // Load deoptimization data from the code object.
2098 // <deopt_data> = <code>[#deoptimization_data_offset]
2429 Handle<CodeT> code) {
2495 __ Jump(code, RelocInfo::CODE_TARGET);
2504 Handle<CodeT> code) {
2566 __ Jump(code, RelocInfo::CODE_TARGET);
3260 // x0 result0 The return code from the call.
3484 // by allocating it in callee-save registers they will be preserved by C code.
3782 __ Peek<TurboAssembler::kAuthLR>(lr, 0); // Return to calling code.
3814 int offset0 = reg0.code() * reg_size;
3815 int offset1 = reg1.code() * reg_size;
3849 int offset0 = reg0.code() * reg_size;
3856 int offset1 = reg1.code() * reg_size;
3872 // TODO(all): This code needs to be revisited. We probably only need to save
3908 // Get the address of the location in the code object. This is the return
3928 // - x2: code object address
4039 // ARM code.
4081 // bytecode. If there is baseline code on the shared function info, converts an
4083 // code. Otherwise execution continues with bytecode.
4103 // Check if we have baseline code. For OSR entry it is safe to assume we
4104 // always have baseline code.
4110 // Start with bytecode as there is no baseline code.
4117 // Start with baseline code.
4165 // If the code deoptimizes during the implicit function entry stack interrupt
4231 // Retry from the start after installing baseline code.