Lines Matching refs:Code
6 // * Redistributions of source code must retain the above copyright
33 #include "code-stubs.h"
119 // Initialize the code pointer in the function to be the one
122 __ add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag));
294 return result1_.code() +
295 (result2_.code() << 4) +
296 (source_.code() << 8) +
297 (zeros_.code() << 12);
446 // Generate non VFP3 code to check if a double can be exactly represented by a
467 // Generates code to call a C function to do a double operation using core
469 // This code never falls through, but returns with a heap number containing
1069 // x < x is false regardless. For the others here is some code to check
1362 // Both are heap numbers. Load them up then jump to the code we have
1523 // Generate code to lookup number in the number string cache.
1559 // NOTICE! This code is only reached after a smi-fast-case check, so
1573 // One operand is a smi. EmitSmiNonsmiComparison generates code that can:
1632 // or load both doubles into r0, r1, r2, r3 and jump to the code that handles
1771 Handle<Code> GetTypeRecordingBinaryOpStub(int key,
2066 __ stop("Unreachable code.");
2123 // The code below for writing into heap numbers isn't capable of
2192 // Generate the smi code. If the operation on smis are successful this return is
2194 // requested the code falls through. If number allocation is requested but a
2195 // heap number cannot be allocated the code jumps to the lable gc_required.
2241 // Code falls through if the result is not returned as either a smi or heap
2428 __ stop("Unreachable code.");
2492 // The non vfp3 code does not support this special case, so jump to
2710 // Code below will scratch result if allocation fails. To keep both arguments
3263 // support moving the C entry code stub. This should be fixed, but currently
3320 // by javascript code.
3403 // r0: code entry
3423 // r0: code entry
3436 // r0: code entry
3490 // returns control to the code after the bl(&invoke) above, which
3502 // Notice that we cannot store a reference to the trampoline code directly in
3506 // r0: code entry
3525 masm->add(pc, ip, Operand(Code::kHeaderSize - kHeapObjectTag));
3916 // time or if regexp entry in generated code is turned off runtime switch or
3940 // registers and will be preserved by the call to the native RegExp code, as
3941 // this code is called using the normal C calling convention. When calling
3942 // directly from generated code the native RegExp code will not do a GC and
4082 // Find the code object based on the assumptions above.
4088 // Check that the irregexp code has been generated for the actual string
4089 // encoding. If it has, the field contains a code object otherwise it contains
4095 // r7: code
4099 // RegExp code to avoid handling changing stack height.
4105 // r7: code
4108 // All checks done. Now push arguments for native regexp code.
4158 // Locate the code entry and call it.
4159 __ add(r7, r7, Operand(Code::kHeaderSize - kHeapObjectTag));
4182 // stack overflow (on the backtrack stack) was detected in RegExp code but
4212 // Process the result from the native regexp code.
4239 // Get the static offsets vector filled by the native regexp code.
4559 // Load the 2-byte character code into the result register. We can
4616 // index is a number, but the code of getting the actual character
4644 // At this point code register contains smi tagged ASCII char code.
4689 // Generate code for copying characters using a simple loop. This should only
4701 // Generate code for copying a large number of characters. This function
4720 // string is found the code falls through with the string in register r0.
4952 // This is required by the contract of the method: code at the
5848 __ add(r2, r0, Operand(Code::kHeaderSize - kHeapObjectTag));
