Lines Matching refs:Code
6 // * Redistributions of source code must retain the above copyright
33 #include "code-stubs.h"
125 // Initialize the code pointer in the function to be the one
128 __ add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag));
343 // Fall through to generate the code to handle double elements.
451 return result1_.code() +
452 (result2_.code() << 4) +
453 (source_.code() << 8) +
454 (zeros_.code() << 12);
1138 // x < x is false regardless. For the others here is some code to check
1438 // Both are heap numbers. Load them up then jump to the code we have
1599 // Generate code to lookup number in the number string cache.
1634 // NOTICE! This code is only reached after a smi-fast-case check, so
1647 // One operand is a smi. EmitSmiNonsmiComparison generates code that can:
1706 // or load both doubles into r0, r1, r2, r3 and jump to the code that handles
1877 __ mov(r2, Operand(Smi::FromInt(tos_.code())));
2242 // generation code does not use any raw pointers.
2501 __ stop("Unreachable code.");
2558 // The code below for writing into heap numbers isn't capable of
2627 // Generate the smi code. If the operation on smis are successful this return is
2629 // requested the code falls through. If number allocation is requested but a
2630 // heap number cannot be allocated the code jumps to the lable gc_required.
2675 // Code falls through if the result is not returned as either a smi or heap
2893 __ stop("Unreachable code.");
2957 // The non vfp3 code does not support this special case, so jump to
3027 // type transition code for DIV operations expecting an integer result: the
3028 // code will fall through to this type transition.
3178 // Code below will scratch result if allocation fails. To keep both arguments
3465 // This can only happen if the stub is called from non-optimized code.
3616 // The stub is called from non-optimized code, which expects the result
3667 Handle<Code> code = save_doubles.GetCode();
3668 code->set_is_pregenerated(true);
3671 code->GetIsolate()->set_fp_stubs_generated(true);
3677 Handle<Code> code = stub.GetCode();
3678 code->set_is_pregenerated(true);
3789 // by javascript code.
3887 // r0: code entry
3909 // r0: code entry
3922 // r0: code entry
3972 // handler block in this code object, so its index is 0.
3977 // returns control to the code after the bl(&invoke) above, which
3988 // Notice that we cannot store a reference to the trampoline code directly in
3992 // r0: code entry
4011 masm->add(pc, ip, Operand(Code::kHeaderSize - kHeapObjectTag));
4613 // time or if regexp entry in generated code is turned off runtime switch or
4633 // registers and will be preserved by the call to the native RegExp code, as
4634 // this code is called using the normal C calling convention. When calling
4635 // directly from generated code the native RegExp code will not do a GC and
4798 // Find the code object based on the assumptions above.
4804 // Check that the irregexp code has been generated for the actual string
4805 // encoding. If it has, the field contains a code object otherwise it contains
4806 // a smi (code flushing support).
4810 // r7: code
4814 // RegExp code to avoid handling changing stack height.
4820 // r7: code
4823 // All checks done. Now push arguments for native regexp code.
4881 // Locate the code entry and call it.
4882 __ add(r7, r7, Operand(Code::kHeaderSize - kHeapObjectTag));
4905 // stack overflow (on the backtrack stack) was detected in RegExp code but
4934 // Process the result from the native regexp code.
4970 // Get the static offsets vector filled by the native regexp code.
5217 Handle<Code> adaptor =
5254 __ add(pc, r2, Operand(Code::kHeaderSize - kHeapObjectTag));
5395 // index is a number, but the code of getting the actual character
5424 // At this point code register contains smi tagged ASCII char code.
5669 // This is required by the contract of the method: code at the
6792 __ add(r2, r0, Operand(Code::kHeaderSize - kHeapObjectTag));
