Lines Matching refs:code
6 // * Redistributions of source code must retain the above copyright
179 // tos: code slot
210 // TODO(1241774): Improve this code:
213 // 3) don't copy parameter operand code from SlotOperand!
293 // Generate code to 'execute' declarations and initialize functions
313 // bother compiling all the code if the scope has an illegal
350 // Add a label for checking the size of the code used for returning.
368 // Here we use masm_-> instead of the __ macro to avoid the code coverage
369 // tool from instrumenting as we rely on the code size here.
373 // Check that the size of the code used for returning matches what is
383 // Code generation state must be reset.
390 // Process any deferred code using the register allocator.
482 // code register. If force_cc is set, the value is forced to set the
483 // condition code register and no value is pushed. If the condition code
499 // code as we unwind the C++ stack.
513 // Convert the TOS value to a boolean in the condition code register.
560 // If both "true" and "false" need to be loaded jump across the code for
687 // register to a boolean in the condition code register. The code
692 // Note: The generated code snippet does not change stack variables.
693 // Only the condition code should be set.
722 // Convert the result (r0) to a condition code.
886 // NOTE: This is an attempt to inline (a bit) more of the code for
890 // code size is increased by ~1% (measured on a combination of
1009 deferred->Branch(ne); // Go to deferred code on non-Smis and negative.
1032 // numbers, unfortunately, but since this code is inline we prefer
1125 // Use the shared code stub to call the function.
1307 // Generate different code depending on which parts of the if statement
1737 // Record source position of the statement as this code which is
1738 // after the code for the body actually belongs to the loop
1803 // Check cache validity in generated code. This is a fast case for
2046 // Generate code for the statements in the try block.
2077 // Generate unlink code for the (formerly) shadowing labels that have been
2083 // Because we can be jumping here (to spilled code) from unspilled
2084 // code, we need to reestablish a spilled frame at this block.
2160 // Generate code for the statements in the try block.
2196 // Generate code to unlink and set the state for the (formerly)
2204 // Because we can be jumping here (to spilled code) from
2205 // unspilled code, we need to reestablish a spilled frame at
2250 // Generate code for the statements in the finally block.
2259 // Generate code to jump to the right destination for all used
2314 // Use the fast case closure allocation code that allocates in new
2398 // Generate fast-case code for variables that might be shadowed by
2488 // the eval code (sigh...) and the const variable may have been
2510 // executed, the code is identical to a normal store (see below).
2525 // calling this code. r2 may be loaded with context; used below in
2601 Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
2741 Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
2810 // Generate code to set the elements in the array that are not
2822 // The property must be set by generated code.
2972 // must be resolved after the arguments have been evaluated. The IC code
3043 // Setup the name register and call the IC initialization code.
3046 Handle<Code> stub = ComputeCallInitialize(arg_count, in_loop);
3090 // Set the name register and call the IC initialization code.
3093 Handle<Code> stub = ComputeCallInitialize(arg_count, in_loop);
3178 Handle<Code> ic(Builtins::builtin(Builtins::JSConstructCall));
3327 // This should generate code that performs a charCodeAt() call or returns
3696 Handle<Code> stub = ComputeCallInitialize(arg_count, in_loop);
4058 // NOTE: The code below assumes that the slow cases (calls to runtime)
4124 // literal 'null'. If so, we optimize the code by inlining a null check
4165 // efficient, we generate special code for expressions of the form:
4324 Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
4382 Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
4436 // Call the appropriate IC code.
4437 Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
4455 // Call IC code.
4456 Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
4695 return result1_.code() +
4696 (result2_.code() << 4) +
4697 (source_.code() << 8) +
4698 (zeros_.code() << 12);
4790 return the_int_.code() +
4791 (the_heap_number_.code() << 4) +
4792 (scratch_.code() << 8);
4917 // x < x is false regardless. For the others here is some code to check
5188 // Both are heap numbers. Load them up then jump to the code we have
5233 // NOTICE! This code is only reached after a smi-fast-case check, so
5247 // One operand is a smi. EmitSmiNonsmiComparison generates code that can:
5306 // or load both doubles into r0, r1, r2, r3 and jump to the code that handles
5389 // We fall into this code if the operands were Smis, but the result was
5390 // not (eg. overflow). We branch into this code (to the not_smi label) if
5768 // The code below for writing into heap numbers isn't capable of writing
5972 ASSERT(kSmiTag == 0); // Adjust code below.
5991 ASSERT(kSmiTag == 0); // Adjust code below.
6009 ASSERT(kSmiTag == 0); // adjust code below
6142 ASSERT(kSmiTag == 0); // adjust code below
6189 // This code should be unreachable.
6302 // Adjust this code if not the case.
6336 // Adjust this code if not the case.
6437 // support moving the C entry code stub. This should be fixed, but currently
6487 // by javascript code.
6562 // r0: code entry
6576 // r0: code entry
6583 // r0: code entry
6616 // returns control to the code after the bl(&invoke) above, which
6627 // Notice that we cannot store a reference to the trampoline code directly in
6631 // r0: code entry
6649 masm->add(pc, ip, Operand(Code::kHeaderSize - kHeapObjectTag));
6968 __ Jump(Handle<Code>(Builtins::builtin(Builtins::ArgumentsAdaptorTrampoline)),
