Home | History | Annotate | Download | only in arm

Lines Matching refs:Code

6 //     * Redistributions of source code must retain the above copyright
32 #include "code-stubs.h"
70 // NONE indicates that the scope shouldn't actually generate code to set up
82 void LCodeGen::FinishCode(Handle<Code> code) {
84 code->set_stack_slots(GetStackSlotCount());
85 code->set_safepoint_table_offset(safepoints_.GetCodeOffset());
87 RegisterDependentCodeForEmbeddedMaps(code);
89 PopulateDeoptimizationData(code);
90 info()->CommitDependencies(code);
162 // for code aging to work properly.
164 __ nop(ip.code());
172 // Reserve space for the stack slots needed by the code.
264 // Don't emit code for basic blocks with a replacement.
291 LDeferredCode* code = deferred_[i];
293 int pos = instructions_->at(code->instruction_index())->position();
298 code->instruction_index(),
299 code->instr()->hydrogen_value()->id(),
300 code->instr()->Mnemonic());
301 __ bind(code->entry());
311 Comment(";;; Deferred code");
313 code->Generate();
321 __ jmp(code->exit());
325 // Force constant pool emission at the end of the deferred code to make
335 // code, i.e. that offsets to the table can be encoded in the 24bit signed
337 // To simplify we consider the code size from the first instruction to the
391 // sequence. Mark the generated code as done unless we bailed out.
701 void LCodeGen::CallCode(Handle<Code> code,
705 CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT, storage_mode);
709 void LCodeGen::CallCodeGeneric(Handle<Code> code,
716 // Block literal pool emission to ensure nop indicating no inlined smi code
721 __ Call(code, mode, TypeFeedbackId::None(), al, storage_mode);
724 // Signal that we don't inline smi code before these stubs in the
725 // optimizing code generator.
726 if (code->kind() == Code::BINARY_OP_IC ||
727 code->kind() == Code::COMPARE_IC) {
847 void LCodeGen::RegisterDependentCodeForEmbeddedMaps(Handle<Code> code) {
850 for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
863 // this code is not yet in the depended code lists of the embedded maps.
867 maps.at(i)->AddDependentCode(DependentCode::kWeaklyEmbeddedGroup, code);
872 void LCodeGen::PopulateDeoptimizationData(Handle<Code> code) {
904 code->set_deoptimization_data(*data);
1116 // Note: The code below even works when right contains kMinInt.
1197 // For 'r3 = r1 % r2' we can have the following ARM code:
1308 // Branch and condition free code for integer division by a power
1343 // Branch and condition free code for integer division by a power
1553 // "right" can't be null because the code would have already been
1587 // Use optimized code for specific constants.
1618 // For other constants we emit standard code.
1640 // Generate standard code.
2001 __ stop("Unreachable code.");
2140 // Block literal pool emission to ensure nop indicating no inlined smi code
2144 __ nop(); // Signals no inlined code.
2567 Handle<Code> ic = CompareIC::GetUninitialized(isolate(), op);
2569 // This instruction also signals no smi code inlined.
2663 // Faster code path to avoid two compares: subtract lower bound from the
2777 __ bind(deferred->map_check()); // Label for calculating code patching.
2795 // calling the deferred code.
2806 // Go to the deferred code.
2812 // Here result has either true or false. Deferred code also produces true or
2842 // Make sure that code size is predicable, since we use specific constants
2843 // offsets in the code to find embedded values..
2880 Handle<Code> ic = CompareIC::GetUninitialized(isolate(), op);
2882 // This instruction also signals no smi code inlined.
2960 Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();
2995 Handle<Code> ic = (instr->strict_mode_flag() == kStrictMode)
3089 Handle<Code> ic = isolate()->builtins()->LoadIC_Initialize();
3374 Handle<Code> ic = isolate()->builtins()->KeyedLoadIC_Initialize();
4031 Handle<Code> ic =
4043 Handle<Code> ic =
4068 Handle<Code> ic =
4092 // No cell in r2 for construct type feedback in optimized code
4248 Handle<Code> ic = (instr->strict_mode_flag() == kStrictMode)
4464 Handle<Code> ic = (instr->strict_mode_flag() == kStrictMode)
4923 // The carry flag is set when we reach this deferred code as we just executed
5000 // Branch to deferred code if the input was tagged.
5001 // The deferred code will take care of restoring the tag.
5429 // Use the fast case closure allocation code that allocates in new
5576 // instruction for patching the code here.
5677 // the deferred code.
5694 // code, but if there were none, record the entrypoint here.