Lines Matching refs:Code
6 // * Redistributions of source code must retain the above copyright
33 #include "code-stubs.h"
127 // Initialize the code pointer in the function to be the one
130 __ Addu(a3, a3, Operand(Code::kHeaderSize - kHeapObjectTag));
341 // Fall through to generate the code to handle double elements.
448 return result1_.code() +
449 (result2_.code() << 4) +
450 (source_.code() << 8) +
451 (zeros_.code() << 12);
1173 // x < x is false regardless. For the others here is some code to check
1506 // Both are heap numbers. Load them up then jump to the code we have
1673 // Generate code to lookup number in the number string cache.
1708 // NOTICE! This code is only reached after a smi-fast-case check, so
1721 // One operand is a smi. EmitSmiNonsmiComparison generates code that can:
1794 // or load both doubles and jump to the code that handles
1965 __ li(a2, Operand(Smi::FromInt(tos_.code())));
2327 // generation code does not use any raw pointers.
2617 __ stop("Unreachable code.");
2673 // The code below for writing into heap numbers isn't capable of
2743 // Generate the smi code. If the operation on smis are successful this return is
2745 // requested the code falls through. If number allocation is requested but a
2746 // heap number cannot be allocated the code jumps to the lable gc_required.
2791 // Code falls through if the result is not returned as either a smi or heap
3006 __ stop("Unreachable code.");
3070 // The non FPU code does not support this special case, so jump to
3146 // type transition code for DIV operations expecting an integer result: the
3147 // code will fall through to this type transition.
3299 // Code below will scratch result if allocation fails. To keep both arguments
3602 // This can only happen if the stub is called from non-optimized code.
3770 // The stub is called from non-optimized code, which expects the result
3821 Handle<Code> code = save_doubles.GetCode();
3822 code->set_is_pregenerated(true);
3825 code->GetIsolate()->set_fp_stubs_generated(true);
3831 Handle<Code> code = stub.GetCode();
3832 code->set_is_pregenerated(true);
3870 // We are calling compiled C/C++ code. a0 and a1 hold our two arguments. We
3885 // coverage code can interfere with the proper calculation of ra.
3892 // instruction past the real call into C code (the jalr(t9)), and push it.
3959 // by javascript code.
4152 // handler block in this code object, so its index is 0.
4156 // returns control to the code after the bal(&invoke) above, which
4167 // Notice that we cannot store a reference to the trampoline code directly in
4195 __ addiu(t9, t9, Code::kHeaderSize - kHeapObjectTag);
4822 // time or if regexp entry in generated code is turned off runtime switch or
4844 // registers and will be preserved by the call to the native RegExp code, as
4845 // this code is called using the normal C calling convention. When calling
4846 // directly from generated code the native RegExp code will not do a GC and
5015 // Find the code object based on the assumptions above.
5022 // Check that the irregexp code has been generated for the actual string
5023 // encoding. If it has, the field contains a code object otherwise it contains
5024 // a smi (code flushing support).
5028 // t9: code
5032 // RegExp code to avoid handling changing stack height.
5038 // t9: code
5041 // All checks done. Now push arguments for native regexp code.
5113 // Locate the code entry and call it.
5114 __ Addu(t9, t9, Operand(Code::kHeaderSize - kHeapObjectTag));
5134 // stack overflow (on the backtrack stack) was detected in RegExp code but
5160 // Process the result from the native regexp code.
5196 // Get the static offsets vector filled by the native regexp code.
5447 Handle<Code> adaptor =
5484 __ Addu(at, a2, Operand(Code::kHeaderSize - kHeapObjectTag));
5628 // index is a number, but the code of getting the actual character
5664 // At this point code register contains smi tagged ASCII char code.
5878 // This is required by the contract of the method: code at the
7028 __ Addu(a2, v0, Operand(Code::kHeaderSize - kHeapObjectTag));
