Cross Reference: /external/chromium_org/v8/src/ic/ic-compiler.cc

Lines Matching refs:Code
16 Handle<Code> PropertyICCompiler::Find(Handle<Name> name,
17                                       Handle<Map> stub_holder, Code::Kind kind,
20   Code::Flags flags =
21       Code::ComputeMonomorphicFlags(kind, extra_state, cache_holder);
23   if (probe->IsCode()) return handle(Code::cast(probe));
24   return Handle<Code>::null();
36 Handle<Code> PropertyICCompiler::CompileMonomorphic(Handle<HeapType> type,
37                                                     Handle<Code> handler,
44   Code::StubType stub_type = handler->type();
49 Handle<Code> PropertyICCompiler::ComputeMonomorphic(
50     Code::Kind kind, Handle<Name> name, Handle<HeapType> type,
51     Handle<Code> handler, ExtraICState extra_ic_state) {
61   Handle<Code> ic;
72   if (kind == Code::KEYED_STORE_IC) {
86 Handle<Code> PropertyICCompiler::ComputeKeyedLoadMonomorphic(
89   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC);
93   if (probe->IsCode()) return Handle<Code>::cast(probe);
96   Handle<Code> stub;
110   PropertyICCompiler compiler(isolate, Code::KEYED_LOAD_IC);
111   Handle<Code> code =
120 Handle<Code> PropertyICCompiler::ComputeKeyedStoreMonomorphic(
126   Code::Flags flags =
127       Code::ComputeMonomorphicFlags(Code::KEYED_STORE_IC, extra_state);
136   if (probe->IsCode()) return Handle<Code>::cast(probe);
138   PropertyICCompiler compiler(isolate, Code::KEYED_STORE_IC, extra_state);
139   Handle<Code> code =
149 Code* PropertyICCompiler::FindPreMonomorphic(Isolate* isolate, Code::Kind kind,
151   Code::Flags flags = Code::ComputeFlags(kind, PREMONOMORPHIC, state);
159   return reinterpret_cast<Code*>(code);
163 static void FillCache(Isolate* isolate, Handle<Code> code) {
170 Handle<Code> PropertyICCompiler::ComputeLoad(Isolate* isolate,
173   Code::Flags flags = Code::ComputeFlags(Code::LOAD_IC, ic_state, extra_state);
177   if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
179   PropertyICCompiler compiler(isolate, Code::LOAD_IC);
180   Handle<Code> code;
193 Handle<Code> PropertyICCompiler::ComputeStore(Isolate* isolate,
196   Code::Flags flags = Code::ComputeFlags(Code::STORE_IC, ic_state, extra_state);
200   if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
202   PropertyICCompiler compiler(isolate, Code::STORE_IC);
203   Handle<Code> code;
221 Handle<Code> PropertyICCompiler::ComputeCompareNil(Handle<Map> receiver_map,
226     Handle<Code> cached_ic =
227         Find(name, receiver_map, Code::COMPARE_NIL_IC, stub->GetExtraICState());
231   Code::FindAndReplacePattern pattern;
233   Handle<Code> ic = stub->GetCodeCopy(pattern);
244 Handle<Code> PropertyICCompiler::ComputeKeyedLoadPolymorphic(
247   Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, POLYMORPHIC);
251   if (probe->IsCode()) return Handle<Code>::cast(probe);
260   PropertyICCompiler ic_compiler(isolate, Code::KEYED_LOAD_IC);
261   Handle<Code> code = ic_compiler.CompilePolymorphic(
262       &types, &handlers, isolate->factory()->empty_string(), Code::NORMAL,
272 Handle<Code> PropertyICCompiler::ComputePolymorphic(
273     Code::Kind kind, TypeHandleList* types, CodeHandleList* handlers,
275   Handle<Code> handler = handlers->at(0);
276   Code::StubType type = valid_types == 1 ? handler->type() : Code::NORMAL;
277   DCHECK(kind == Code::LOAD_IC || kind == Code::STORE_IC);
283 Handle<Code> PropertyICCompiler::ComputeKeyedStorePolymorphic(
295   Code::Flags flags =
296       Code::ComputeFlags(Code::KEYED_STORE_IC, POLYMORPHIC, extra_state);
298   if (probe->IsCode()) return Handle<Code>::cast(probe);
300   PropertyICCompiler compiler(isolate, Code::KEYED_STORE_IC, extra_state);
301   Handle<Code> code =
308 Handle<Code> PropertyICCompiler::CompileLoadInitialize(Code::Flags flags) {
310   Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadInitialize");
316 Handle<Code> PropertyICCompiler::CompileLoadPreMonomorphic(Code::Flags flags) {
318   Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadPreMonomorphic");
325 Handle<Code> PropertyICCompiler::CompileStoreInitialize(Code::Flags flags) {
327   Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreInitialize");
333 Handle<Code> PropertyICCompiler::CompileStorePreMonomorphic(Code::Flags flags) {
335   Handle<Code> code = GetCodeWithFlags(flags, "CompileStorePreMonomorphic");
342 Handle<Code> PropertyICCompiler::CompileStoreGeneric(Code::Flags flags) {
343   ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
346   Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreGeneric");
352 Handle<Code> PropertyICCompiler::CompileStoreMegamorphic(Code::Flags flags) {
354   Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreMegamorphic");
360 Handle<Code> PropertyICCompiler::GetCode(Code::Kind kind, Code::StubType type,
363   Code::Flags flags =
364       Code::ComputeFlags(kind, state, extra_ic_state_, type, cache_holder());
365   Handle<Code> code = GetCodeWithFlags(flags, name);
372 Handle<Code> PropertyICCompiler::CompileKeyedStorePolymorphic(
379     Handle<Code> cached_stub;
412   Handle<Code> code = CompileKeyedStorePolymorphic(receiver_maps, &handlers,
423 Handle<Code> PropertyICCompiler::CompileKeyedStoreMonomorphic(
427   Handle<Code> stub;
441   return GetCode(kind(), Code::NORMAL, factory()->empty_string());