Lines Matching refs:Code
6 // * Redistributions of source code must retain the above copyright
54 // We always generate arm code, never thumb code, even if V8 is compiled to
69 // Using bx does not yield better code, so use it only when required
102 void MacroAssembler::Jump(Handle<Code> code, RelocInfo::Mode rmode,
105 // 'code' is always generated ARM code, never THUMB code
106 Jump(reinterpret_cast<intptr_t>(code.location()), rmode, cond);
180 int MacroAssembler::CallSize(Handle<Code> code,
184 return CallSize(reinterpret_cast<Address>(code.location()), rmode, cond);
188 void MacroAssembler::Call(Handle<Code> code,
199 // 'code' is always generated ARM code, never THUMB code
200 Call(reinterpret_cast<Address>(code.location()), rmode, cond);
201 ASSERT_EQ(CallSize(code, rmode, ast_id, cond),
475 // Clobber clobbered input registers when running with the debug-code flag
494 // The compiled code assumes that record write doesn't change the
536 // Clobber clobbered registers when running with the debug-code flag
651 return MemOperand(sp, SafepointRegisterStackIndex(reg.code()) * kPointerSize);
658 int register_offset = SafepointRegisterStackIndex(reg.code()) * kPointerSize;
667 ASSERT_EQ(0, dst1.code() % 2);
668 ASSERT_EQ(dst1.code() + 1, dst2.code());
670 // V8 does not use this addressing mode, so the fallback code
709 ASSERT_EQ(0, src1.code() % 2);
710 ASSERT_EQ(src1.code() + 1, src2.code());
712 // V8 does not use this addressing mode, so the fallback code
826 // Reserve room for saved entry sp and code object.
849 // since the sp slot and code slot were pushed after the fp.
942 // This macro takes the dst register to make the code more readable
957 Handle<Code> code_constant,
973 // r3: callee code entry
975 // The code below is made a lot easier because the calling code already sets
991 // don't want that done. Skip adaption code by making it look
1014 add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag));
1017 Handle<Code> adaptor =
1036 void MacroAssembler::InvokeCode(Register code,
1047 InvokePrologue(expected, actual, Handle<Code>::null(), code,
1052 call_wrapper.BeforeCall(CallSize(code));
1054 Call(code);
1059 Jump(code);
1069 void MacroAssembler::InvokeCode(Handle<Code> code,
1080 InvokePrologue(expected, actual, code, no_reg,
1086 Call(code, rmode);
1089 Jump(code, rmode);
1140 // We call indirectly through the code field in the function to
1193 // Adjust this code if not the case.
1203 // Set up the code object (r5) and the state (r6) for pushing.
1210 // Push the frame pointer, context, state, and code object.
1239 // a fixed array of (smi-tagged) code offsets.
1240 // r0 = exception, r1 = code object, r2 = state.
1241 ldr(r3, FieldMemOperand(r1, Code::kHandlerTableOffset)); // Handler table.
1245 add(r1, r1, Operand(Code::kHeaderSize - kHeapObjectTag)); // Code start.
1251 // Adjust this code if not the case.
1270 // Get the code object (r1) and state (r2). Restore the context and frame
1285 // Adjust this code if not the case.
1316 // Get the code object (r1) and state (r2). Clear the context and frame
1349 // Cannot use ip as a temporary in this verification code. Due to the fact
1368 // Cannot use ip as a temporary in this verification code. Due to the fact
1409 // Compute the hash code from the untagged key. This must be kept in sync
1550 ASSERT(result.code() < ip.code());
1558 // This code stores a temporary value in ip. This is OK, as the code below
1609 // them are ip. ip is used explicitly in the code generated below.
1631 ASSERT(result.code() < ip.code());
1637 // This code stores a temporary value in ip. This is OK, as the code below
1944 // it's an Infinity, and the non-NaN code path applies.
2056 Handle<Code> success,
2341 // This code is faster for doubles that are in the ranges -0x7fffffff to
2610 // should remove this need and make the runtime routine entry code
2648 // should remove this need and make the runtime routine entry code
2709 // Load the code entry point from the builtins object.
2819 // We don't actually want to generate a pile of code for this, so just
2828 // If the calling code cares about the exact number of
3492 // marked black immediately so this code is not hit).
3729 // Create a new macro assembler pointing to the address of the code to patch.
3737 // Indicate that code has changed.
3740 // Check that the code was patched as expected.