Lines Matching defs:code
6 // * Redistributions of source code must retain the above copyright
117 // Determine whether to use the full compiler for all code. If the flag
120 // the code from the full compiler supports mode precise break points. For the
121 // crankshaft adaptive compiler debugging the optimized code is not possible at
167 // code as non-optimizable. The marker on the shared function info
168 // is there because we flush non-optimized code thereby loosing the
169 // non-optimizable information for the code. When the code is
175 Handle<Code> code = Handle<Code>(shared->code());
176 ASSERT(code->kind() == Code::FUNCTION);
177 code->set_optimizable(false);
178 info->SetCode(code);
179 Isolate* isolate = code->GetIsolate();
195 // In case we are not optimizing simply return the code from
196 // the full code generator.
201 // We should never arrive here if there is not code object on the
203 Handle<Code> code(info->shared_info()->code());
204 ASSERT(code->kind() == Code::FUNCTION);
210 // Fall back to using the full code generator if it's not possible
212 // generated code for this from the shared function object.
214 info->SetCode(code);
225 // necessarily that we optimized the code.
244 // necessarily that we optimized the code.
253 info->SetCode(code);
257 // Recompile the unoptimized version of the code if the current version
259 // run the full code generator to get a baseline for the compile-time
267 // optimized code.
275 shared->EnableDeoptimizationSupport(*unoptimized.code());
276 // The existing unoptimized code was replaced with the new one.
282 // Check that the unoptimized, shared code is ready for
284 // optimizable marker in the code object and optimize anyway. This
285 // is safe as long as the unoptimized code has deoptimization
287 ASSERT(FLAG_always_opt || code->optimizable());
297 TypeFeedbackOracle oracle(code, global_context);
302 info->SetCode(Handle<Code>::null());
307 Handle<Code> optimized_code = graph->Compile(info);
316 // shared code but mark it as unoptimizable.
319 // that we optimized the code.
325 // Precondition: code has been parsed. Postcondition: the code field in
331 // If crankshaft is not supported fall back to full code generator
342 // Precondition: code has been parsed. Postcondition: the code field in
376 Code* code = it.frame()->LookupCode();
378 it.frame()->pc() - code->instruction_start());
401 // Compile the code.
410 ASSERT(!info->code().is_null());
415 info->code(),
426 *info->code(),
431 info->code()));
437 *info->code(),
440 GDBJIT(AddCode(Handle<String>(), script, info->code()));
614 // Compile the code.
620 ASSERT(!info->code().is_null());
621 Handle<Code> code = info->code();
623 // function info, e.g., we might have flushed the code and must
624 // reset this bit when lazy compiling the code again.
625 if (shared->optimization_disabled()) code->set_optimizable(false);
631 function->ReplaceCode(*code);
633 // Update the shared function info with the compiled code and the
636 // trigger a GC, causing the ASSERT below to be invalid if the code
637 // was flushed. By settting the code object last we avoid this.
641 shared->set_code(*code);
643 function->ReplaceCode(*code);
659 // Check the function has compiled code.
666 // active as it makes no sense to compile optimized code then.
683 ASSERT(info->code().is_null());
690 // Precondition: code has been parsed and scopes have been analyzed.
706 // Generate code
708 Handle<Code> code = info.isolate()->builtins()->LazyCompile();
709 info.SetCode(code);
712 ASSERT(!info.code().is_null());
722 info.code(),
768 // Log the code generation. If source information is available include
773 Handle<Code> code = info->code();
774 if (*code == info->isolate()->builtins()->builtin(Builtins::kLazyCompile))
781 *code,
788 *code,
796 Handle<Code>(info->code())));
