Lines Matching refs:Code
6 // * Redistributions of source code must retain the above copyright
44 Code::Flags flags,
57 // Multiply by 3 because there are 3 fields per entry (name, code, map).
61 // Get the code entry from the cache.
74 __ mov(offset, FieldOperand(extra, Code::kFlagsOffset));
75 __ and_(offset, ~Code::kFlagsNotUsedInLookup);
87 // Jump to the first instruction in the code stub.
88 __ add(extra, Immediate(Code::kHeaderSize - kHeapObjectTag));
108 // Get the code entry from the cache.
112 __ mov(offset, FieldOperand(offset, Code::kFlagsOffset));
113 __ and_(offset, ~Code::kFlagsNotUsedInLookup);
125 // Restore offset and re-load code entry from cache.
129 // Jump to the first instruction in the code stub.
130 __ add(offset, Immediate(Code::kHeaderSize - kHeapObjectTag));
192 Code::Flags flags,
201 // Assert that code is valid. The multiplying code relies on the entry size
206 ASSERT(Code::ExtractTypeFromFlags(flags) == 0);
309 // Generate code to check if an object is a string. If the object is
531 Code::ExtraICState extra_state)
645 // Deferred code for fast API call case---clean preallocated space.
718 Code::ExtraICState extra_state_;
722 void StubCompiler::GenerateLoadMiss(MacroAssembler* masm, Code::Kind kind) {
723 ASSERT(kind == Code::LOAD_IC || kind == Code::KEYED_LOAD_IC);
724 Handle<Code> code = (kind == Code::LOAD_IC)
727 __ jmp(code, RelocInfo::CODE_TARGET);
732 Handle<Code> code =
734 __ jmp(code, RelocInfo::CODE_TARGET);
827 // Generate code to check that a global property cell is empty. Create
943 // in the code. Load it from the map.
1057 // Emitting a stub call may try to allocate (if the code is not
1119 // Compile the interceptor call, followed by inline code to load the
1129 // result. The CALLBACKS case needs the receiver to be passed into C++ code,
1163 // Clobber registers when generating debug-code to provoke errors.
1209 // Important invariant in CALLBACKS case: the code above must be
1245 if (kind_ == Code::KEYED_CALL_IC) {
1305 Handle<Code> code =
1309 __ jmp(code, RelocInfo::CODE_TARGET);
1313 Handle<Code> CallStubCompiler::CompileCallField(Handle<JSObject> object,
1364 // Return the generated code.
1369 Handle<Code> CallStubCompiler::CompileArrayPushCall(
1385 return Handle<Code>::null();
1571 // Return the generated code.
1576 Handle<Code> CallStubCompiler::CompileArrayPopCall(
1592 return Handle<Code>::null();
1653 // Return the generated code.
1658 Handle<Code> CallStubCompiler::CompileStringCharCodeAtCall(
1674 return Handle<Code>::null();
1684 if (kind_ == Code::CALL_IC &&
1736 // Return the generated code.
1741 Handle<Code> CallStubCompiler::CompileStringCharAtCall(
1757 return Handle<Code>::null();
1767 if (kind_ == Code::CALL_IC &&
1821 // Return the generated code.
1826 Handle<Code> CallStubCompiler::CompileStringFromCharCodeCall(
1845 return Handle<Code>::null();
1864 // Load the char code argument.
1865 Register code = ebx;
1866 __ mov(code, Operand(esp, 1 * kPointerSize));
1868 // Check the code is a smi.
1871 __ JumpIfNotSmi(code, &slow);
1873 // Convert the smi code to uint16.
1874 __ and_(code, Immediate(Smi::FromInt(0xffff)));
1876 StringCharFromCodeGenerator generator(code, eax);
1896 // Return the generated code.
1901 Handle<Code> CallStubCompiler::CompileMathFloorCall(
1916 return Handle<Code>::null();
1926 return Handle<Code>::null();
2026 // Return the generated code.
2031 Handle<Code> CallStubCompiler::CompileMathAbsCall(
2050 return Handle<Code>::null();
2131 // Return the generated code.
2136 Handle<Code> CallStubCompiler::CompileFastApiCall(
2146 if (object->IsGlobalObject()) return Handle<Code>::null();
2147 if (!cell.is_null()) return Handle<Code>::null();
2148 if (!object->IsJSObject()) return Handle<Code>::null();
2151 if (depth == kInvalidProtoDepth) return Handle<Code>::null();
2190 // Return the generated code.
2195 Handle<Code> CallStubCompiler::CompileCallConstant(Handle<Object> object,
2209 Handle<Code> code = CompileCustomCall(object, holder,
2212 // A null handle means bail out to the regular compiler code below.
2213 if (!code.is_null()) return code;
2319 // Return the generated code.
2324 Handle<Code> CallStubCompiler::CompileCallInterceptor(Handle<JSObject> object,
2378 // Return the generated code.
2383 Handle<Code> CallStubCompiler::CompileCallGlobal(
2398 Handle<Code> code = CompileCustomCall(object, holder, cell, function, name);
2399 // A null handle means bail out to the regular compiler code below.
2400 if (!code.is_null()) return code;
2420 // Jump to the cached code (tail call).
2427 // We call indirectly through the code field in the function to
2439 // Return the generated code.
2444 Handle<Code> StoreStubCompiler::CompileStoreField(Handle<JSObject> object,
2456 // Generate store field code. Trashes the name register.
2462 Handle<Code> ic = isolate()->builtins()->StoreIC_Miss();
2465 // Return the generated code.
2470 Handle<Code> StoreStubCompiler::CompileStoreCallback(
2509 Handle<Code> ic = isolate()->builtins()->StoreIC_Miss();
2512 // Return the generated code.
2517 Handle<Code> StoreStubCompiler::CompileStoreInterceptor(
2555 Handle<Code> ic = isolate()->builtins()->StoreIC_Miss();
2558 // Return the generated code.
2563 Handle<Code> StoreStubCompiler::CompileStoreGlobal(
2603 Handle<Code> ic = isolate()->builtins()->StoreIC_Miss();
2606 // Return the generated code.
2611 Handle<Code> KeyedStoreStubCompiler::CompileStoreField(Handle<JSObject> object,
2630 // Generate store field code. Trashes the name register.
2636 Handle<Code> ic = isolate()->builtins()->KeyedStoreIC_Miss();
2639 // Return the generated code.
2644 Handle<Code> KeyedStoreStubCompiler::CompileStoreElement(
2654 Handle<Code> stub =
2659 Handle<Code> ic = isolate()->builtins()->KeyedStoreIC_Miss();
2662 // Return the generated code.
2667 Handle<Code> KeyedStoreStubCompiler::CompileStorePolymorphic(
2694 Handle<Code> miss_ic = isolate()->builtins()->KeyedStoreIC_Miss();
2697 // Return the generated code.
2702 Handle<Code> LoadStubCompiler::CompileLoadNonexistent(Handle<String> name,
2735 Code::LOAD_IC);
2737 // Return the generated code.
2742 Handle<Code> LoadStubCompiler::CompileLoadField(Handle<JSObject> object,
2755 GenerateLoadMiss(masm(), Code::LOAD_IC);
2757 // Return the generated code.
2762 Handle<Code> LoadStubCompiler::CompileLoadCallback(
2777 GenerateLoadMiss(masm(), Code::LOAD_IC);
2779 // Return the generated code.
2784 Handle<Code> LoadStubCompiler::CompileLoadConstant(Handle<JSObject> object,
2797 GenerateLoadMiss(masm(), Code::LOAD_IC);
2799 // Return the generated code.
2804 Handle<Code> LoadStubCompiler::CompileLoadInterceptor(Handle<JSObject> receiver,
2823 GenerateLoadMiss(masm(), Code::LOAD_IC);
2825 // Return the generated code.
2830 Handle<Code> LoadStubCompiler::CompileLoadGlobal(
2871 GenerateLoadMiss(masm(), Code::LOAD_IC);
2873 // Return the generated code.
2878 Handle<Code> KeyedLoadStubCompiler::CompileLoadField(Handle<String> name,
2900 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
2902 // Return the generated code.
2907 Handle<Code> KeyedLoadStubCompiler::CompileLoadCallback(
2931 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
2933 // Return the generated code.
2938 Handle<Code> KeyedLoadStubCompiler::CompileLoadConstant(
2961 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
2963 // Return the generated code.
2968 Handle<Code> KeyedLoadStubCompiler::CompileLoadInterceptor(
2992 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
2994 // Return the generated code.
2999 Handle<Code> KeyedLoadStubCompiler::CompileLoadArrayLength(
3018 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
3020 // Return the generated code.
3025 Handle<Code> KeyedLoadStubCompiler::CompileLoadStringLength(
3044 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
3046 // Return the generated code.
3051 Handle<Code> KeyedLoadStubCompiler::CompileLoadFunctionPrototype(
3070 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
3072 // Return the generated code.
3077 Handle<Code> KeyedLoadStubCompiler::CompileLoadElement(
3086 Handle<Code> stub = KeyedLoadElementStub(elements_kind).GetCode();
3090 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
3092 // Return the generated code.
3097 Handle<Code> KeyedLoadStubCompiler::CompileLoadPolymorphic(
3117 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
3119 // Return the generated code.
3126 Handle<Code> ConstructStubCompiler::CompileConstructStub(
3136 // Check to see whether there are any break points in the function code. If
3138 // code for the function thereby hitting the break points.
3247 // Jump to the generic stub in case the specialized code cannot handle the
3250 Handle<Code> code = isolate()->builtins()->JSConstructStubGeneric();
3251 __ jmp(code, RelocInfo::CODE_TARGET);
3253 // Return the generated code.
3302 Handle<Code> slow_ic =
3314 Handle<Code> miss_force_generic_ic =
3457 Handle<Code> ic = masm->isolate()->builtins()->KeyedLoadIC_Slow();
3468 Handle<Code> miss_ic =
3579 // processors that don't support SSE2. The code in IntegerConvert
3580 // (code-stubs-ia32.cc) is roughly what is needed here though the
3623 // range [0, 2^31-1]. For the time being, to keep this code simple,
3655 Handle<Code> ic = masm->isolate()->builtins()->KeyedStoreIC_Slow();
3666 Handle<Code> miss_ic =
3703 Handle<Code> miss_ic =
3762 Handle<Code> slow_ic =
3767 Handle<Code> miss_ic =
3845 Handle<Code> ic_force_generic =
3851 Handle<Code> ic_miss = masm->isolate()->builtins()->KeyedStoreIC_Miss();
3923 Handle<Code> ic_slow = masm->isolate()->builtins()->KeyedStoreIC_Slow();
3973 Handle<Code> ic_force_generic =
3979 Handle<Code> ic_miss = masm->isolate()->builtins()->KeyedStoreIC_Miss();
4051 Handle<Code> ic_slow = masm->isolate()->builtins()->KeyedStoreIC_Slow();
