OLD | NEW |
---|---|
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 188 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
199 // A return value of true indicates the compilation pipeline is still | 199 // A return value of true indicates the compilation pipeline is still |
200 // going, not necessarily that we optimized the code. | 200 // going, not necessarily that we optimized the code. |
201 static bool MakeCrankshaftCode(CompilationInfo* info) { | 201 static bool MakeCrankshaftCode(CompilationInfo* info) { |
202 OptimizingCompiler compiler(info); | 202 OptimizingCompiler compiler(info); |
203 OptimizingCompiler::Status status = compiler.CreateGraph(); | 203 OptimizingCompiler::Status status = compiler.CreateGraph(); |
204 | 204 |
205 if (status != OptimizingCompiler::SUCCEEDED) { | 205 if (status != OptimizingCompiler::SUCCEEDED) { |
206 return status != OptimizingCompiler::FAILED; | 206 return status != OptimizingCompiler::FAILED; |
207 } | 207 } |
208 status = compiler.OptimizeGraph(); | 208 status = compiler.OptimizeGraph(); |
209 compiler.DoPendingAbort(); | |
209 if (status != OptimizingCompiler::SUCCEEDED) { | 210 if (status != OptimizingCompiler::SUCCEEDED) { |
210 return status != OptimizingCompiler::FAILED; | 211 return status != OptimizingCompiler::FAILED; |
211 } | 212 } |
212 status = compiler.GenerateAndInstallCode(); | 213 status = compiler.GenerateAndInstallCode(); |
213 return status != OptimizingCompiler::FAILED; | 214 return status != OptimizingCompiler::FAILED; |
214 } | 215 } |
215 | 216 |
216 | 217 |
217 OptimizingCompiler::Status OptimizingCompiler::CreateGraph() { | 218 OptimizingCompiler::Status OptimizingCompiler::CreateGraph() { |
218 ASSERT(V8::UseCrankshaft()); | 219 ASSERT(V8::UseCrankshaft()); |
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
333 return SetLastStatus(BAILED_OUT); | 334 return SetLastStatus(BAILED_OUT); |
334 } else { | 335 } else { |
335 return AbortOptimization(); | 336 return AbortOptimization(); |
336 } | 337 } |
337 } | 338 } |
338 | 339 |
339 return SetLastStatus(SUCCEEDED); | 340 return SetLastStatus(SUCCEEDED); |
340 } | 341 } |
341 | 342 |
342 OptimizingCompiler::Status OptimizingCompiler::OptimizeGraph() { | 343 OptimizingCompiler::Status OptimizingCompiler::OptimizeGraph() { |
344 AssertNoAllocation no_gc; | |
345 NoHandleAllocation no_handles; | |
346 | |
343 ASSERT(last_status() == SUCCEEDED); | 347 ASSERT(last_status() == SUCCEEDED); |
344 Timer t(this, &time_taken_to_optimize_); | 348 Timer t(this, &time_taken_to_optimize_); |
345 ASSERT(graph_ != NULL); | 349 ASSERT(graph_ != NULL); |
346 SmartArrayPointer<char> bailout_reason; | 350 SmartArrayPointer<char> bailout_reason; |
347 if (!graph_->Optimize(&bailout_reason)) { | 351 if (!graph_->Optimize(&bailout_reason)) { |
348 if (!bailout_reason.is_empty()) graph_builder_->Bailout(*bailout_reason); | 352 if (!bailout_reason.is_empty()) graph_builder_->Bailout(*bailout_reason); |
349 return AbortOptimization(); | 353 return DeferAbortOptimization(); |
350 } else { | 354 } else { |
351 chunk_ = LChunk::NewChunk(graph_); | 355 chunk_ = LChunk::NewChunk(graph_); |
352 if (chunk_ == NULL) { | 356 if (chunk_ == NULL) { |
353 return AbortOptimization(); | 357 return DeferAbortOptimization(); |
354 } | 358 } |
355 } | 359 } |
356 return SetLastStatus(SUCCEEDED); | 360 return SetLastStatus(SUCCEEDED); |
357 } | 361 } |
358 | 362 |
359 | 363 |
360 OptimizingCompiler::Status OptimizingCompiler::GenerateAndInstallCode() { | 364 OptimizingCompiler::Status OptimizingCompiler::GenerateAndInstallCode() { |
361 ASSERT(last_status() == SUCCEEDED); | 365 ASSERT(last_status() == SUCCEEDED); |
366 ASSERT(!abort_optimization_); | |
362 Timer timer(this, &time_taken_to_codegen_); | 367 Timer timer(this, &time_taken_to_codegen_); |
363 ASSERT(chunk_ != NULL); | 368 ASSERT(chunk_ != NULL); |
364 ASSERT(graph_ != NULL); | 369 ASSERT(graph_ != NULL); |
365 Handle<Code> optimized_code = chunk_->Codegen(); | 370 Handle<Code> optimized_code = chunk_->Codegen(); |
366 if (optimized_code.is_null()) return AbortOptimization(); | 371 if (optimized_code.is_null()) return AbortOptimization(); |
367 info()->SetCode(optimized_code); | 372 info()->SetCode(optimized_code); |
368 RecordOptimizationStats(); | 373 RecordOptimizationStats(); |
369 return SetLastStatus(SUCCEEDED); | 374 return SetLastStatus(SUCCEEDED); |
370 } | 375 } |
371 | 376 |
(...skipping 279 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
651 } else { | 656 } else { |
652 if (result->ic_age() != HEAP->global_ic_age()) { | 657 if (result->ic_age() != HEAP->global_ic_age()) { |
653 result->ResetForNewContext(HEAP->global_ic_age()); | 658 result->ResetForNewContext(HEAP->global_ic_age()); |
654 } | 659 } |
655 } | 660 } |
656 | 661 |
657 return result; | 662 return result; |
658 } | 663 } |
659 | 664 |
660 | 665 |
661 bool Compiler::CompileLazy(CompilationInfo* info) { | 666 static bool InstallFullCode(CompilationInfo* info) { |
662 Isolate* isolate = info->isolate(); | 667 // Update the shared function info with the compiled code and the |
668 // scope info. Please note, that the order of the shared function | |
669 // info initialization is important since set_scope_info might | |
670 // trigger a GC, causing the ASSERT below to be invalid if the code | |
671 // was flushed. By setting the code object last we avoid this. | |
672 Handle<SharedFunctionInfo> shared = info->shared_info(); | |
673 Handle<Code> code = info->code(); | |
674 Handle<JSFunction> function = info->closure(); | |
675 Handle<ScopeInfo> scope_info = | |
676 ScopeInfo::Create(info->scope(), info->zone()); | |
677 shared->set_scope_info(*scope_info); | |
678 shared->set_code(*code); | |
679 if (!function.is_null()) { | |
680 function->ReplaceCode(*code); | |
681 ASSERT(!function->IsOptimized()); | |
682 } | |
663 | 683 |
664 ZoneScope zone_scope(info->zone(), DELETE_ON_EXIT); | 684 // Set the expected number of properties for instances. |
685 FunctionLiteral* lit = info->function(); | |
686 int expected = lit->expected_property_count(); | |
687 SetExpectedNofPropertiesFromEstimate(shared, expected); | |
665 | 688 |
666 // The VM is in the COMPILER state until exiting this function. | 689 // Set the optimization hints after performing lazy compilation, as |
667 VMState state(isolate, COMPILER); | 690 // these are not set when the function is set up as a lazily |
691 // compiled function. | |
692 shared->SetThisPropertyAssignmentsInfo( | |
693 lit->has_only_simple_this_property_assignments(), | |
694 *lit->this_property_assignments()); | |
668 | 695 |
669 PostponeInterruptsScope postpone(isolate); | 696 // Check the function has compiled code. |
697 ASSERT(shared->is_compiled()); | |
698 shared->set_code_age(0); | |
699 shared->set_dont_optimize(lit->flags()->Contains(kDontOptimize)); | |
700 shared->set_dont_inline(lit->flags()->Contains(kDontInline)); | |
701 shared->set_ast_node_count(lit->ast_node_count()); | |
670 | 702 |
703 if (V8::UseCrankshaft()&& | |
704 !function.is_null() && | |
705 !shared->optimization_disabled()) { | |
706 // If we're asked to always optimize, we compile the optimized | |
707 // version of the function right away - unless the debugger is | |
708 // active as it makes no sense to compile optimized code then. | |
709 if (FLAG_always_opt && | |
710 !Isolate::Current()->DebuggerHasBreakPoints()) { | |
711 CompilationInfoWithZone optimized(function); | |
712 optimized.SetOptimizing(AstNode::kNoNumber); | |
713 return Compiler::CompileLazy(&optimized); | |
714 } | |
715 } | |
716 return true; | |
717 } | |
718 | |
719 | |
720 static void InstallCodeCommon(CompilationInfo* info) { | |
671 Handle<SharedFunctionInfo> shared = info->shared_info(); | 721 Handle<SharedFunctionInfo> shared = info->shared_info(); |
672 int compiled_size = shared->end_position() - shared->start_position(); | 722 Handle<Code> code = info->code(); |
673 isolate->counters()->total_compile_size()->Increment(compiled_size); | 723 ASSERT(!code.is_null()); |
674 | 724 |
725 // Set optimizable to false if this is disallowed by the shared | |
726 // function info, e.g., we might have flushed the code and must | |
727 // reset this bit when lazy compiling the code again. | |
728 if (shared->optimization_disabled()) code->set_optimizable(false); | |
729 | |
730 Handle<JSFunction> function = info->closure(); | |
731 Compiler::RecordFunctionCompilation(Logger::LAZY_COMPILE_TAG, info, shared); | |
732 } | |
733 | |
734 | |
735 static void InsertCodeIntoOptimizedCodeMap(CompilationInfo* info) { | |
736 Handle<Code> code = info->code(); | |
737 Handle<JSFunction> function = info->closure(); | |
738 if (FLAG_cache_optimized_code && code->kind() == Code::OPTIMIZED_FUNCTION) { | |
739 Handle<SharedFunctionInfo> shared(function->shared()); | |
740 Handle<FixedArray> literals(function->literals()); | |
741 Handle<Context> global_context(function->context()->global_context()); | |
742 SharedFunctionInfo::AddToOptimizedCodeMap( | |
743 shared, global_context, code, literals); | |
744 } | |
745 } | |
746 | |
747 | |
748 static bool InstallCodeFromOptimizedCodeMap(CompilationInfo* info) { | |
675 if (FLAG_cache_optimized_code && info->IsOptimizing()) { | 749 if (FLAG_cache_optimized_code && info->IsOptimizing()) { |
750 Handle<SharedFunctionInfo> shared = info->shared_info(); | |
676 Handle<JSFunction> function = info->closure(); | 751 Handle<JSFunction> function = info->closure(); |
677 ASSERT(!function.is_null()); | 752 ASSERT(!function.is_null()); |
678 Handle<Context> global_context(function->context()->global_context()); | 753 Handle<Context> global_context(function->context()->global_context()); |
679 int index = shared->SearchOptimizedCodeMap(*global_context); | 754 int index = shared->SearchOptimizedCodeMap(*global_context); |
680 if (index > 0) { | 755 if (index > 0) { |
681 if (FLAG_trace_opt) { | 756 if (FLAG_trace_opt) { |
682 PrintF("[found optimized code for: "); | 757 PrintF("[found optimized code for: "); |
683 function->PrintName(); | 758 function->PrintName(); |
684 PrintF(" / %" V8PRIxPTR "]\n", reinterpret_cast<intptr_t>(*function)); | 759 PrintF(" / %" V8PRIxPTR "]\n", reinterpret_cast<intptr_t>(*function)); |
685 } | 760 } |
686 // Caching of optimized code enabled and optimized code found. | 761 // Caching of optimized code enabled and optimized code found. |
687 shared->InstallFromOptimizedCodeMap(*function, index); | 762 shared->InstallFromOptimizedCodeMap(*function, index); |
688 return true; | 763 return true; |
689 } | 764 } |
690 } | 765 } |
766 return false; | |
767 } | |
768 | |
769 | |
770 bool Compiler::CompileLazy(CompilationInfo* info) { | |
771 Isolate* isolate = info->isolate(); | |
772 | |
773 ZoneScope zone_scope(info->zone(), DELETE_ON_EXIT); | |
774 | |
775 // The VM is in the COMPILER state until exiting this function. | |
776 VMState state(isolate, COMPILER); | |
777 | |
778 PostponeInterruptsScope postpone(isolate); | |
779 | |
780 Handle<SharedFunctionInfo> shared = info->shared_info(); | |
781 int compiled_size = shared->end_position() - shared->start_position(); | |
782 isolate->counters()->total_compile_size()->Increment(compiled_size); | |
783 | |
784 if (InstallCodeFromOptimizedCodeMap(info)) return true; | |
691 | 785 |
692 // Generate the AST for the lazily compiled function. | 786 // Generate the AST for the lazily compiled function. |
693 if (ParserApi::Parse(info, kNoParsingFlags)) { | 787 if (ParserApi::Parse(info, kNoParsingFlags)) { |
694 // Measure how long it takes to do the lazy compilation; only take the | 788 // Measure how long it takes to do the lazy compilation; only take the |
695 // rest of the function into account to avoid overlap with the lazy | 789 // rest of the function into account to avoid overlap with the lazy |
696 // parsing statistics. | 790 // parsing statistics. |
697 HistogramTimerScope timer(isolate->counters()->compile_lazy()); | 791 HistogramTimerScope timer(isolate->counters()->compile_lazy()); |
698 | 792 |
699 // After parsing we know the function's language mode. Remember it. | 793 // After parsing we know the function's language mode. Remember it. |
700 LanguageMode language_mode = info->function()->language_mode(); | 794 LanguageMode language_mode = info->function()->language_mode(); |
701 info->SetLanguageMode(language_mode); | 795 info->SetLanguageMode(language_mode); |
702 shared->set_language_mode(language_mode); | 796 shared->set_language_mode(language_mode); |
703 | 797 |
704 // Compile the code. | 798 // Compile the code. |
705 if (!MakeCode(info)) { | 799 if (!MakeCode(info)) { |
706 if (!isolate->has_pending_exception()) { | 800 if (!isolate->has_pending_exception()) { |
707 isolate->StackOverflow(); | 801 isolate->StackOverflow(); |
708 } | 802 } |
709 } else { | 803 } else { |
710 ASSERT(!info->code().is_null()); | 804 InstallCodeCommon(info); |
711 Handle<Code> code = info->code(); | |
712 // Set optimizable to false if this is disallowed by the shared | |
713 // function info, e.g., we might have flushed the code and must | |
714 // reset this bit when lazy compiling the code again. | |
715 if (shared->optimization_disabled()) code->set_optimizable(false); | |
716 | |
717 Handle<JSFunction> function = info->closure(); | |
718 RecordFunctionCompilation(Logger::LAZY_COMPILE_TAG, info, shared); | |
719 | 805 |
720 if (info->IsOptimizing()) { | 806 if (info->IsOptimizing()) { |
807 Handle<Code> code = info->code(); | |
721 ASSERT(shared->scope_info() != ScopeInfo::Empty()); | 808 ASSERT(shared->scope_info() != ScopeInfo::Empty()); |
722 function->ReplaceCode(*code); | 809 info->closure()->ReplaceCode(*code); |
723 if (FLAG_cache_optimized_code && | 810 InsertCodeIntoOptimizedCodeMap(info); |
724 code->kind() == Code::OPTIMIZED_FUNCTION) { | 811 return true; |
725 Handle<SharedFunctionInfo> shared(function->shared()); | |
726 Handle<FixedArray> literals(function->literals()); | |
727 Handle<Context> global_context(function->context()->global_context()); | |
728 SharedFunctionInfo::AddToOptimizedCodeMap( | |
729 shared, global_context, code, literals); | |
730 } | |
731 } else { | 812 } else { |
732 // Update the shared function info with the compiled code and the | 813 return InstallFullCode(info); |
733 // scope info. Please note, that the order of the shared function | |
734 // info initialization is important since set_scope_info might | |
735 // trigger a GC, causing the ASSERT below to be invalid if the code | |
736 // was flushed. By setting the code object last we avoid this. | |
737 Handle<ScopeInfo> scope_info = | |
738 ScopeInfo::Create(info->scope(), info->zone()); | |
739 shared->set_scope_info(*scope_info); | |
740 shared->set_code(*code); | |
741 if (!function.is_null()) { | |
742 function->ReplaceCode(*code); | |
743 ASSERT(!function->IsOptimized()); | |
744 } | |
745 | |
746 // Set the expected number of properties for instances. | |
747 FunctionLiteral* lit = info->function(); | |
748 int expected = lit->expected_property_count(); | |
749 SetExpectedNofPropertiesFromEstimate(shared, expected); | |
750 | |
751 // Set the optimization hints after performing lazy compilation, as | |
752 // these are not set when the function is set up as a lazily | |
753 // compiled function. | |
754 shared->SetThisPropertyAssignmentsInfo( | |
755 lit->has_only_simple_this_property_assignments(), | |
756 *lit->this_property_assignments()); | |
757 | |
758 // Check the function has compiled code. | |
759 ASSERT(shared->is_compiled()); | |
760 shared->set_code_age(0); | |
761 shared->set_dont_optimize(lit->flags()->Contains(kDontOptimize)); | |
762 shared->set_dont_inline(lit->flags()->Contains(kDontInline)); | |
763 shared->set_dont_cache(lit->flags()->Contains(kDontCache)); | |
764 shared->set_ast_node_count(lit->ast_node_count()); | |
765 | |
766 if (V8::UseCrankshaft()&& | |
767 !function.is_null() && | |
768 !shared->optimization_disabled()) { | |
769 // If we're asked to always optimize, we compile the optimized | |
770 // version of the function right away - unless the debugger is | |
771 // active as it makes no sense to compile optimized code then. | |
772 if (FLAG_always_opt && | |
773 !Isolate::Current()->DebuggerHasBreakPoints()) { | |
774 CompilationInfoWithZone optimized(function); | |
775 optimized.SetOptimizing(AstNode::kNoNumber); | |
776 return CompileLazy(&optimized); | |
777 } | |
778 } | |
779 } | 814 } |
780 | |
781 return true; | |
782 } | 815 } |
783 } | 816 } |
784 | 817 |
785 ASSERT(info->code().is_null()); | 818 ASSERT(info->code().is_null()); |
786 return false; | 819 return false; |
787 } | 820 } |
788 | 821 |
789 | 822 |
823 void Compiler::RecompileParallel(Handle<JSFunction> closure) { | |
824 ASSERT(!closure->IsInRecompileQueue()); | |
Yang
2012/07/19 16:11:56
As discussed, this should probably be a real check
sanjoy
2012/07/19 16:25:36
Done.
| |
825 | |
826 Isolate* isolate = closure->GetIsolate(); | |
827 if (!isolate->optimizing_compiler_thread()->IsQueueAvailable()) { | |
828 if (FLAG_trace_parallel_recompilation) { | |
829 PrintF(" ** Compilation queue, will retry opting on next run.\n"); | |
830 } | |
831 return; | |
832 } | |
833 | |
834 SmartPointer<CompilationInfo> info(new CompilationInfoWithZone(closure)); | |
835 VMState state(isolate, PARALLEL_COMPILER_PROLOGUE); | |
836 PostponeInterruptsScope postpone(isolate); | |
837 | |
838 Handle<SharedFunctionInfo> shared = info->shared_info(); | |
839 int compiled_size = shared->end_position() - shared->start_position(); | |
840 isolate->counters()->total_compile_size()->Increment(compiled_size); | |
841 info->SetOptimizing(AstNode::kNoNumber); | |
842 | |
843 { | |
844 CompilationHandleScope handle_scope(*info); | |
845 | |
846 if (InstallCodeFromOptimizedCodeMap(*info)) return; | |
847 | |
848 if (ParserApi::Parse(*info, kNoParsingFlags)) { | |
849 LanguageMode language_mode = info->function()->language_mode(); | |
850 info->SetLanguageMode(language_mode); | |
851 shared->set_language_mode(language_mode); | |
852 info->SaveHandles(); | |
853 | |
854 if (Rewriter::Rewrite(*info) && Scope::Analyze(*info)) { | |
855 OptimizingCompiler* compiler = | |
856 new(info->zone()) OptimizingCompiler(*info); | |
857 OptimizingCompiler::Status status = compiler->CreateGraph(); | |
858 if (status == OptimizingCompiler::SUCCEEDED) { | |
859 isolate->optimizing_compiler_thread()->QueueForOptimization(compiler); | |
860 shared->code()->set_profiler_ticks(0); | |
861 closure->ReplaceCode(isolate->builtins()->builtin( | |
862 Builtins::kInRecompileQueue)); | |
863 info.Detach(); | |
864 } else if (status == OptimizingCompiler::BAILED_OUT) { | |
865 isolate->clear_pending_exception(); | |
866 InstallFullCode(*info); | |
867 } | |
868 } | |
869 } | |
870 } | |
871 | |
872 if (isolate->has_pending_exception()) { | |
873 isolate->clear_pending_exception(); | |
874 } | |
875 } | |
876 | |
877 | |
878 void Compiler::InstallOptimizedCode(OptimizingCompiler* optimizing_compiler) { | |
879 optimizing_compiler->DoPendingAbort(); | |
880 SmartPointer<CompilationInfo> info(optimizing_compiler->info()); | |
881 // If crankshaft succeeded, install the optimized code else install | |
882 // the unoptimized code. | |
883 OptimizingCompiler::Status status = optimizing_compiler->last_status(); | |
884 if (status == OptimizingCompiler::SUCCEEDED) { | |
885 status = optimizing_compiler->GenerateAndInstallCode(); | |
886 ASSERT(status == OptimizingCompiler::SUCCEEDED || | |
887 status == OptimizingCompiler::BAILED_OUT); | |
888 } | |
889 | |
890 InstallCodeCommon(*info); | |
891 if (status == OptimizingCompiler::SUCCEEDED) { | |
892 Handle<Code> code = info->code(); | |
893 ASSERT(info->shared_info()->scope_info() != ScopeInfo::Empty()); | |
894 info->closure()->ReplaceCode(*code); | |
895 if (info->shared_info()->SearchOptimizedCodeMap( | |
896 info->closure()->context()->global_context()) == -1) { | |
897 InsertCodeIntoOptimizedCodeMap(*info); | |
898 } | |
899 } else { | |
900 info->SetCode(Handle<Code>(info->shared_info()->code())); | |
901 InstallFullCode(*info); | |
902 } | |
903 } | |
904 | |
905 | |
790 Handle<SharedFunctionInfo> Compiler::BuildFunctionInfo(FunctionLiteral* literal, | 906 Handle<SharedFunctionInfo> Compiler::BuildFunctionInfo(FunctionLiteral* literal, |
791 Handle<Script> script) { | 907 Handle<Script> script) { |
792 // Precondition: code has been parsed and scopes have been analyzed. | 908 // Precondition: code has been parsed and scopes have been analyzed. |
793 CompilationInfoWithZone info(script); | 909 CompilationInfoWithZone info(script); |
794 info.SetFunction(literal); | 910 info.SetFunction(literal); |
795 info.SetScope(literal->scope()); | 911 info.SetScope(literal->scope()); |
796 info.SetLanguageMode(literal->scope()->language_mode()); | 912 info.SetLanguageMode(literal->scope()->language_mode()); |
797 | 913 |
798 LiveEditFunctionTracker live_edit_tracker(info.isolate(), literal); | 914 LiveEditFunctionTracker live_edit_tracker(info.isolate(), literal); |
799 // Determine if the function can be lazily compiled. This is necessary to | 915 // Determine if the function can be lazily compiled. This is necessary to |
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
911 } | 1027 } |
912 } | 1028 } |
913 | 1029 |
914 GDBJIT(AddCode(Handle<String>(shared->DebugName()), | 1030 GDBJIT(AddCode(Handle<String>(shared->DebugName()), |
915 Handle<Script>(info->script()), | 1031 Handle<Script>(info->script()), |
916 Handle<Code>(info->code()), | 1032 Handle<Code>(info->code()), |
917 info)); | 1033 info)); |
918 } | 1034 } |
919 | 1035 |
920 } } // namespace v8::internal | 1036 } } // namespace v8::internal |
OLD | NEW |