Lines Matching refs:Code
6 // * Redistributions of source code must retain the above copyright
33 #include "code-stubs.h"
289 // Update the static counter each time a new code stub is generated.
347 // Initialize the code pointer in the function to be the one
362 __ add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag));
373 // (native context, optimized code, literals).
374 // The optimized code map must never be empty, so check the first elements.
376 // Speculatively move code object into r4.
395 // Hit: fetch the optimized code.
405 // TODO(fschneider): Idea: store proper code pointers in the map and either
408 __ add(r4, r4, Operand(Code::kHeaderSize - kHeapObjectTag));
573 return result1_.code() +
574 (result2_.code() << 4) +
575 (source_.code() << 8) +
576 (zeros_.code() << 12);
764 // x < x is false regardless. For the others here is some code to check
933 // Both are heap numbers. Load them up then jump to the code we have
1078 // Generate code to lookup number in the number string cache.
1131 // NOTICE! This code is only reached after a smi-fast-case check, so
1144 // One operand is a smi. EmitSmiNonsmiComparison generates code that can:
1193 // or load both doubles into r0, r1, r2, r3 and jump to the code that handles
1296 // Generates code to call a C function to do a double operation.
1297 // This code never falls through, but returns with a heap number containing
1676 __ stop("Unreachable code.");
1721 // The code below for writing into heap numbers isn't capable of
1777 // Generate the smi code. If the operation on smis are successful this return is
1779 // requested the code falls through. If number allocation is requested but a
1780 // heap number cannot be allocated the code jumps to the label gc_required.
1835 // Code falls through if the result is not returned as either a smi or heap
2020 __ stop("Unreachable code.");
2120 // type transition code for DIV operations expecting an integer result: the
2121 // code will fall through to this type transition.
2258 // Code below will scratch result if allocation fails. To keep both arguments
2538 // This can only happen if the stub is called from non-optimized code.
2689 // The stub is called from non-optimized code, which expects the result
2746 // regenerate, which would lead to code stub initialization state being messed
2748 Code* save_doubles_code;
2752 Code* store_buffer_overflow_code;
2764 Handle<Code> code = stub.GetCode(isolate);
2765 code->set_is_pregenerated(true);
2899 // by javascript code.
3002 // r0: code entry
3024 // r0: code entry
3035 // r0: code entry
3092 // handler block in this code object, so its index is 0.
3097 // returns control to the code after the bl(&invoke) above, which
3108 // Notice that we cannot store a reference to the trampoline code directly in
3112 // r0: code entry
3134 masm->add(pc, ip, Operand(Code::kHeaderSize - kHeapObjectTag));
3355 if (kind() == Code::KEYED_LOAD_IC) {
3365 ASSERT(kind() == Code::LOAD_IC);
3385 if (kind() == Code::KEYED_LOAD_IC) {
3395 ASSERT(kind() == Code::LOAD_IC);
3423 if (kind() == Code::KEYED_STORE_IC) {
3435 ASSERT(kind() == Code::STORE_IC);
3860 // time or if regexp entry in generated code is turned off runtime switch or
3879 // registers and will be preserved by the call to the native RegExp code, as
3880 // this code is called using the normal C calling convention. When calling
3881 // directly from generated code the native RegExp code will not do a GC and
3949 // (5) Sequential string. Load regexp code according to encoding.
3953 // Deferred code at the end of the stub:
4000 // (5) Sequential string. Load regexp code according to encoding.
4022 // r7: irregexp code
4023 // Check that the irregexp code has been generated for the actual string
4024 // encoding. If it has, the field contains a code object otherwise it contains
4025 // a smi (code flushing support).
4030 // r7: code
4033 // All checks done. Now push arguments for native regexp code.
4096 // Locate the code entry and call it.
4097 __ add(r7, r7, Operand(Code::kHeaderSize - kHeapObjectTag));
4120 // stack overflow (on the backtrack stack) was detected in RegExp code but
4149 // Process the result from the native regexp code.
4205 // Get the static offsets vector filled by the native regexp code.
4238 // Deferred code for string handling.
4532 Handle<Code> adaptor =
4571 __ add(pc, jmp_reg, Operand(Code::kHeaderSize - kHeapObjectTag));
4670 // index is a number, but the code of getting the actual character
4699 // At this point code register contains smi tagged ASCII char code.
4926 // This is required by the contract of the method: code at the
6161 __ add(r2, r0, Operand(Code::kHeaderSize - kHeapObjectTag));
6179 intptr_t code =
6181 __ mov(lr, Operand(code, RelocInfo::CODE_TARGET));
6514 // Hydrogen code stubs need stub2 at snapshot time.
6554 // is assumed by the patching code.
7016 // The array construct code is only set for the global and natives
7130 // The array construct code is only set for the global and natives
