OLD | NEW |
---|---|
1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 #if !defined(DART_PRECOMPILED_RUNTIME) | 4 #if !defined(DART_PRECOMPILED_RUNTIME) |
5 #include "vm/flow_graph_inliner.h" | 5 #include "vm/flow_graph_inliner.h" |
6 | 6 |
7 #include "vm/aot_optimizer.h" | 7 #include "vm/aot_optimizer.h" |
8 #include "vm/precompiler.h" | |
8 #include "vm/block_scheduler.h" | 9 #include "vm/block_scheduler.h" |
9 #include "vm/branch_optimizer.h" | 10 #include "vm/branch_optimizer.h" |
10 #include "vm/compiler.h" | 11 #include "vm/compiler.h" |
11 #include "vm/kernel.h" | 12 #include "vm/kernel.h" |
12 #include "vm/kernel_to_il.h" | 13 #include "vm/kernel_to_il.h" |
13 #include "vm/flags.h" | 14 #include "vm/flags.h" |
14 #include "vm/flow_graph.h" | 15 #include "vm/flow_graph.h" |
15 #include "vm/flow_graph_builder.h" | 16 #include "vm/flow_graph_builder.h" |
16 #include "vm/flow_graph_compiler.h" | 17 #include "vm/flow_graph_compiler.h" |
17 #include "vm/flow_graph_type_propagator.h" | 18 #include "vm/flow_graph_type_propagator.h" |
(...skipping 188 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
206 inlined(inlined_function), | 207 inlined(inlined_function), |
207 inlined_depth(depth), | 208 inlined_depth(depth), |
208 call_instr(call), | 209 call_instr(call), |
209 bailout_reason(reason) {} | 210 bailout_reason(reason) {} |
210 }; | 211 }; |
211 | 212 |
212 | 213 |
213 // A collection of call sites to consider for inlining. | 214 // A collection of call sites to consider for inlining. |
214 class CallSites : public ValueObject { | 215 class CallSites : public ValueObject { |
215 public: | 216 public: |
216 explicit CallSites(FlowGraph* flow_graph) | 217 explicit CallSites(FlowGraph* flow_graph, intptr_t threshold) |
217 : static_calls_(), closure_calls_(), instance_calls_() {} | 218 : inlining_depth_threshold_(threshold), |
219 static_calls_(), | |
220 closure_calls_(), | |
221 instance_calls_() {} | |
218 | 222 |
219 struct InstanceCallInfo { | 223 struct InstanceCallInfo { |
220 PolymorphicInstanceCallInstr* call; | 224 PolymorphicInstanceCallInstr* call; |
221 double ratio; | 225 double ratio; |
222 const FlowGraph* caller_graph; | 226 const FlowGraph* caller_graph; |
223 InstanceCallInfo(PolymorphicInstanceCallInstr* call_arg, | 227 InstanceCallInfo(PolymorphicInstanceCallInstr* call_arg, |
224 FlowGraph* flow_graph) | 228 FlowGraph* flow_graph) |
225 : call(call_arg), ratio(0.0), caller_graph(flow_graph) {} | 229 : call(call_arg), ratio(0.0), caller_graph(flow_graph) {} |
226 const Function& caller() const { return caller_graph->function(); } | 230 const Function& caller() const { return caller_graph->function(); } |
227 }; | 231 }; |
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
350 } | 354 } |
351 } | 355 } |
352 } | 356 } |
353 } | 357 } |
354 | 358 |
355 | 359 |
356 void FindCallSites(FlowGraph* graph, | 360 void FindCallSites(FlowGraph* graph, |
357 intptr_t depth, | 361 intptr_t depth, |
358 GrowableArray<InlinedInfo>* inlined_info) { | 362 GrowableArray<InlinedInfo>* inlined_info) { |
359 ASSERT(graph != NULL); | 363 ASSERT(graph != NULL); |
360 if (depth > FLAG_inlining_depth_threshold) { | 364 if (depth > inlining_depth_threshold_) { |
361 if (FLAG_print_inlining_tree) { | 365 if (FLAG_print_inlining_tree) { |
362 RecordAllNotInlinedFunction(graph, depth, inlined_info); | 366 RecordAllNotInlinedFunction(graph, depth, inlined_info); |
363 } | 367 } |
364 return; | 368 return; |
365 } | 369 } |
366 | 370 |
367 // Recognized methods are not treated as normal calls. They don't have | 371 // Recognized methods are not treated as normal calls. They don't have |
368 // calls in themselves, so we keep adding those even when at the threshold. | 372 // calls in themselves, so we keep adding those even when at the threshold. |
369 const bool inline_only_recognized_methods = | 373 const bool inline_only_recognized_methods = |
370 (depth == FLAG_inlining_depth_threshold); | 374 (depth == inlining_depth_threshold_); |
371 | 375 |
372 const intptr_t instance_call_start_ix = instance_calls_.length(); | 376 const intptr_t instance_call_start_ix = instance_calls_.length(); |
373 const intptr_t static_call_start_ix = static_calls_.length(); | 377 const intptr_t static_call_start_ix = static_calls_.length(); |
374 for (BlockIterator block_it = graph->postorder_iterator(); !block_it.Done(); | 378 for (BlockIterator block_it = graph->postorder_iterator(); !block_it.Done(); |
375 block_it.Advance()) { | 379 block_it.Advance()) { |
376 for (ForwardInstructionIterator it(block_it.Current()); !it.Done(); | 380 for (ForwardInstructionIterator it(block_it.Current()); !it.Done(); |
377 it.Advance()) { | 381 it.Advance()) { |
378 Instruction* current = it.Current(); | 382 Instruction* current = it.Current(); |
379 if (current->IsPolymorphicInstanceCall()) { | 383 if (current->IsPolymorphicInstanceCall()) { |
380 PolymorphicInstanceCallInstr* instance_call = | 384 PolymorphicInstanceCallInstr* instance_call = |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
416 ClosureCallInstr* closure_call = current->AsClosureCall(); | 420 ClosureCallInstr* closure_call = current->AsClosureCall(); |
417 closure_calls_.Add(ClosureCallInfo(closure_call, graph)); | 421 closure_calls_.Add(ClosureCallInfo(closure_call, graph)); |
418 } | 422 } |
419 } | 423 } |
420 } | 424 } |
421 } | 425 } |
422 ComputeCallSiteRatio(static_call_start_ix, instance_call_start_ix); | 426 ComputeCallSiteRatio(static_call_start_ix, instance_call_start_ix); |
423 } | 427 } |
424 | 428 |
425 private: | 429 private: |
430 intptr_t inlining_depth_threshold_; | |
426 GrowableArray<StaticCallInfo> static_calls_; | 431 GrowableArray<StaticCallInfo> static_calls_; |
427 GrowableArray<ClosureCallInfo> closure_calls_; | 432 GrowableArray<ClosureCallInfo> closure_calls_; |
428 GrowableArray<InstanceCallInfo> instance_calls_; | 433 GrowableArray<InstanceCallInfo> instance_calls_; |
429 | 434 |
430 DISALLOW_COPY_AND_ASSIGN(CallSites); | 435 DISALLOW_COPY_AND_ASSIGN(CallSites); |
431 }; | 436 }; |
432 | 437 |
433 | 438 |
434 struct InlinedCallData { | 439 struct InlinedCallData { |
435 InlinedCallData(Definition* call, | 440 InlinedCallData(Definition* call, |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
506 return true; | 511 return true; |
507 } | 512 } |
508 } | 513 } |
509 } | 514 } |
510 return false; | 515 return false; |
511 } | 516 } |
512 | 517 |
513 | 518 |
514 class CallSiteInliner : public ValueObject { | 519 class CallSiteInliner : public ValueObject { |
515 public: | 520 public: |
516 explicit CallSiteInliner(FlowGraphInliner* inliner) | 521 explicit CallSiteInliner(FlowGraphInliner* inliner, intptr_t threshold) |
517 : inliner_(inliner), | 522 : inliner_(inliner), |
518 caller_graph_(inliner->flow_graph()), | 523 caller_graph_(inliner->flow_graph()), |
519 inlined_(false), | 524 inlined_(false), |
520 initial_size_(inliner->flow_graph()->InstructionCount()), | 525 initial_size_(inliner->flow_graph()->InstructionCount()), |
521 inlined_size_(0), | 526 inlined_size_(0), |
522 inlined_recursive_call_(false), | 527 inlined_recursive_call_(false), |
523 inlining_depth_(1), | 528 inlining_depth_(1), |
524 inlining_recursion_depth_(0), | 529 inlining_recursion_depth_(0), |
530 inlining_depth_threshold_(threshold), | |
525 collected_call_sites_(NULL), | 531 collected_call_sites_(NULL), |
526 inlining_call_sites_(NULL), | 532 inlining_call_sites_(NULL), |
527 function_cache_(), | 533 function_cache_(), |
528 inlined_info_() {} | 534 inlined_info_() {} |
529 | 535 |
530 FlowGraph* caller_graph() const { return caller_graph_; } | 536 FlowGraph* caller_graph() const { return caller_graph_; } |
531 | 537 |
532 Thread* thread() const { return caller_graph_->thread(); } | 538 Thread* thread() const { return caller_graph_->thread(); } |
533 Isolate* isolate() const { return caller_graph_->isolate(); } | 539 Isolate* isolate() const { return caller_graph_->isolate(); } |
534 Zone* zone() const { return caller_graph_->zone(); } | 540 Zone* zone() const { return caller_graph_->zone(); } |
(...skipping 28 matching lines...) Expand all Loading... | |
563 } | 569 } |
564 if ((const_arg_count >= FLAG_inlining_constant_arguments_count) && | 570 if ((const_arg_count >= FLAG_inlining_constant_arguments_count) && |
565 (instr_count <= FLAG_inlining_constant_arguments_min_size_threshold)) { | 571 (instr_count <= FLAG_inlining_constant_arguments_min_size_threshold)) { |
566 return true; | 572 return true; |
567 } | 573 } |
568 return false; | 574 return false; |
569 } | 575 } |
570 | 576 |
571 void InlineCalls() { | 577 void InlineCalls() { |
572 // If inlining depth is less then one abort. | 578 // If inlining depth is less then one abort. |
573 if (FLAG_inlining_depth_threshold < 1) return; | 579 if (inlining_depth_threshold_ < 1) return; |
574 if (caller_graph_->function().deoptimization_counter() >= | 580 if (caller_graph_->function().deoptimization_counter() >= |
575 FLAG_deoptimization_counter_inlining_threshold) { | 581 FLAG_deoptimization_counter_inlining_threshold) { |
576 return; | 582 return; |
577 } | 583 } |
578 // Create two call site collections to swap between. | 584 // Create two call site collections to swap between. |
579 CallSites sites1(caller_graph_); | 585 CallSites sites1(caller_graph_, inlining_depth_threshold_); |
580 CallSites sites2(caller_graph_); | 586 CallSites sites2(caller_graph_, inlining_depth_threshold_); |
581 CallSites* call_sites_temp = NULL; | 587 CallSites* call_sites_temp = NULL; |
582 collected_call_sites_ = &sites1; | 588 collected_call_sites_ = &sites1; |
583 inlining_call_sites_ = &sites2; | 589 inlining_call_sites_ = &sites2; |
584 // Collect initial call sites. | 590 // Collect initial call sites. |
585 collected_call_sites_->FindCallSites(caller_graph_, inlining_depth_, | 591 collected_call_sites_->FindCallSites(caller_graph_, inlining_depth_, |
586 &inlined_info_); | 592 &inlined_info_); |
587 while (collected_call_sites_->HasCalls()) { | 593 while (collected_call_sites_->HasCalls()) { |
588 TRACE_INLINING( | 594 TRACE_INLINING( |
589 THR_Print(" Depth %" Pd " ----------\n", inlining_depth_)); | 595 THR_Print(" Depth %" Pd " ----------\n", inlining_depth_)); |
590 if (collected_call_sites_->NumCalls() > FLAG_max_inlined_per_depth) { | 596 if (collected_call_sites_->NumCalls() > FLAG_max_inlined_per_depth) { |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
662 | 668 |
663 // Do not rely on function type feedback or presence of code to determine | 669 // Do not rely on function type feedback or presence of code to determine |
664 // if a function was compiled. | 670 // if a function was compiled. |
665 if (!FLAG_precompiled_mode && !function.was_compiled()) { | 671 if (!FLAG_precompiled_mode && !function.was_compiled()) { |
666 TRACE_INLINING(THR_Print(" Bailout: not compiled yet\n")); | 672 TRACE_INLINING(THR_Print(" Bailout: not compiled yet\n")); |
667 PRINT_INLINING_TREE("Not compiled", &call_data->caller, &function, | 673 PRINT_INLINING_TREE("Not compiled", &call_data->caller, &function, |
668 call_data->call); | 674 call_data->call); |
669 return false; | 675 return false; |
670 } | 676 } |
671 | 677 |
678 if ((inliner_->precompiler_ != NULL) && | |
679 inliner_->precompiler_->HasFeedback() && | |
680 (function.usage_counter() <= 0) && !inliner_->AlwaysInline(function)) { | |
681 TRACE_INLINING(THR_Print(" Bailout: not compiled yet\n")); | |
682 PRINT_INLINING_TREE("Not compiled", &call_data->caller, &function, | |
683 call_data->call); | |
684 return false; | |
685 } | |
686 | |
672 // Type feedback may have been cleared for this function (ClearICDataArray), | 687 // Type feedback may have been cleared for this function (ClearICDataArray), |
673 // but we need it for inlining. | 688 // but we need it for inlining. |
674 if (!FLAG_precompiled_mode && (function.ic_data_array() == Array::null())) { | 689 if (!FLAG_precompiled_mode && (function.ic_data_array() == Array::null())) { |
675 TRACE_INLINING(THR_Print(" Bailout: type feedback cleared\n")); | 690 TRACE_INLINING(THR_Print(" Bailout: type feedback cleared\n")); |
676 PRINT_INLINING_TREE("Not compiled", &call_data->caller, &function, | 691 PRINT_INLINING_TREE("Not compiled", &call_data->caller, &function, |
677 call_data->call); | 692 call_data->call); |
678 return false; | 693 return false; |
679 } | 694 } |
680 | 695 |
681 // Abort if this function has deoptimized too much. | 696 // Abort if this function has deoptimized too much. |
(...skipping 102 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
784 } | 799 } |
785 } else { | 800 } else { |
786 FlowGraphBuilder builder(*parsed_function, *ic_data_array, | 801 FlowGraphBuilder builder(*parsed_function, *ic_data_array, |
787 exit_collector, Compiler::kNoOSRDeoptId); | 802 exit_collector, Compiler::kNoOSRDeoptId); |
788 builder.SetInitialBlockId(caller_graph_->max_block_id()); | 803 builder.SetInitialBlockId(caller_graph_->max_block_id()); |
789 { | 804 { |
790 CSTAT_TIMER_SCOPE(thread(), graphinliner_build_timer); | 805 CSTAT_TIMER_SCOPE(thread(), graphinliner_build_timer); |
791 callee_graph = builder.BuildGraph(); | 806 callee_graph = builder.BuildGraph(); |
792 } | 807 } |
793 } | 808 } |
809 #ifdef DART_PRECOMPILER | |
810 if (FLAG_precompiled_mode) { | |
rmacnak
2016/12/16 22:22:05
The change was to move this out of the "else build
| |
811 Precompiler::PopulateWithICData(parsed_function->function(), | |
812 callee_graph); | |
813 if (inliner_->precompiler_ != NULL) { | |
814 inliner_->precompiler_->TryApplyFeedback( | |
815 parsed_function->function(), callee_graph); | |
816 } | |
817 } | |
818 #endif | |
794 | 819 |
795 // The parameter stubs are a copy of the actual arguments providing | 820 // The parameter stubs are a copy of the actual arguments providing |
796 // concrete information about the values, for example constant values, | 821 // concrete information about the values, for example constant values, |
797 // without linking between the caller and callee graphs. | 822 // without linking between the caller and callee graphs. |
798 // TODO(zerny): Put more information in the stubs, eg, type information. | 823 // TODO(zerny): Put more information in the stubs, eg, type information. |
799 ZoneGrowableArray<Definition*>* param_stubs = | 824 ZoneGrowableArray<Definition*>* param_stubs = |
800 new (Z) ZoneGrowableArray<Definition*>(function.NumParameters()); | 825 new (Z) ZoneGrowableArray<Definition*>(function.NumParameters()); |
801 | 826 |
802 // Create a parameter stub for each fixed positional parameter. | 827 // Create a parameter stub for each fixed positional parameter. |
803 for (intptr_t i = 0; i < function.num_fixed_parameters(); ++i) { | 828 for (intptr_t i = 0; i < function.num_fixed_parameters(); ++i) { |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
850 | 875 |
851 { | 876 { |
852 CSTAT_TIMER_SCOPE(thread(), graphinliner_opt_timer); | 877 CSTAT_TIMER_SCOPE(thread(), graphinliner_opt_timer); |
853 // TODO(fschneider): Improve suppression of speculative inlining. | 878 // TODO(fschneider): Improve suppression of speculative inlining. |
854 // Deopt-ids overlap between caller and callee. | 879 // Deopt-ids overlap between caller and callee. |
855 if (FLAG_precompiled_mode) { | 880 if (FLAG_precompiled_mode) { |
856 #ifdef DART_PRECOMPILER | 881 #ifdef DART_PRECOMPILER |
857 AotOptimizer optimizer(inliner_->precompiler_, callee_graph, | 882 AotOptimizer optimizer(inliner_->precompiler_, callee_graph, |
858 inliner_->use_speculative_inlining_, | 883 inliner_->use_speculative_inlining_, |
859 inliner_->inlining_black_list_); | 884 inliner_->inlining_black_list_); |
860 optimizer.PopulateWithICData(); | |
861 | 885 |
862 optimizer.ApplyClassIds(); | 886 optimizer.ApplyClassIds(); |
863 DEBUG_ASSERT(callee_graph->VerifyUseLists()); | 887 DEBUG_ASSERT(callee_graph->VerifyUseLists()); |
864 | 888 |
865 FlowGraphTypePropagator::Propagate(callee_graph); | 889 FlowGraphTypePropagator::Propagate(callee_graph); |
866 DEBUG_ASSERT(callee_graph->VerifyUseLists()); | 890 DEBUG_ASSERT(callee_graph->VerifyUseLists()); |
867 | 891 |
868 optimizer.ApplyICData(); | 892 optimizer.ApplyICData(); |
869 DEBUG_ASSERT(callee_graph->VerifyUseLists()); | 893 DEBUG_ASSERT(callee_graph->VerifyUseLists()); |
870 | 894 |
(...skipping 497 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1368 } | 1392 } |
1369 | 1393 |
1370 FlowGraphInliner* inliner_; | 1394 FlowGraphInliner* inliner_; |
1371 FlowGraph* caller_graph_; | 1395 FlowGraph* caller_graph_; |
1372 bool inlined_; | 1396 bool inlined_; |
1373 const intptr_t initial_size_; | 1397 const intptr_t initial_size_; |
1374 intptr_t inlined_size_; | 1398 intptr_t inlined_size_; |
1375 bool inlined_recursive_call_; | 1399 bool inlined_recursive_call_; |
1376 intptr_t inlining_depth_; | 1400 intptr_t inlining_depth_; |
1377 intptr_t inlining_recursion_depth_; | 1401 intptr_t inlining_recursion_depth_; |
1402 intptr_t inlining_depth_threshold_; | |
1378 CallSites* collected_call_sites_; | 1403 CallSites* collected_call_sites_; |
1379 CallSites* inlining_call_sites_; | 1404 CallSites* inlining_call_sites_; |
1380 GrowableArray<ParsedFunction*> function_cache_; | 1405 GrowableArray<ParsedFunction*> function_cache_; |
1381 GrowableArray<InlinedInfo> inlined_info_; | 1406 GrowableArray<InlinedInfo> inlined_info_; |
1382 | 1407 |
1383 DISALLOW_COPY_AND_ASSIGN(CallSiteInliner); | 1408 DISALLOW_COPY_AND_ASSIGN(CallSiteInliner); |
1384 }; | 1409 }; |
1385 | 1410 |
1386 | 1411 |
1387 PolymorphicInliner::PolymorphicInliner(CallSiteInliner* owner, | 1412 PolymorphicInliner::PolymorphicInliner(CallSiteInliner* owner, |
(...skipping 534 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1922 TRACE_INLINING( | 1947 TRACE_INLINING( |
1923 THR_Print("AlwaysInline annotation for %s\n", function.ToCString())); | 1948 THR_Print("AlwaysInline annotation for %s\n", function.ToCString())); |
1924 return true; | 1949 return true; |
1925 } | 1950 } |
1926 | 1951 |
1927 if (function.IsDispatcherOrImplicitAccessor()) { | 1952 if (function.IsDispatcherOrImplicitAccessor()) { |
1928 // Smaller or same size as the call. | 1953 // Smaller or same size as the call. |
1929 return true; | 1954 return true; |
1930 } | 1955 } |
1931 | 1956 |
1957 if (function.is_const()) { | |
1958 // Inlined const fields are smaller than a call. | |
1959 return true; | |
1960 } | |
1961 | |
1932 if (function.IsGetterFunction() || function.IsSetterFunction() || | 1962 if (function.IsGetterFunction() || function.IsSetterFunction() || |
1933 IsInlineableOperator(function) || | 1963 IsInlineableOperator(function) || |
1934 (function.kind() == RawFunction::kConstructor)) { | 1964 (function.kind() == RawFunction::kConstructor)) { |
1935 const intptr_t count = function.optimized_instruction_count(); | 1965 const intptr_t count = function.optimized_instruction_count(); |
1936 if ((count != 0) && (count < FLAG_inline_getters_setters_smaller_than)) { | 1966 if ((count != 0) && (count < FLAG_inline_getters_setters_smaller_than)) { |
1937 return true; | 1967 return true; |
1938 } | 1968 } |
1939 } | 1969 } |
1940 return MethodRecognizer::AlwaysInline(function); | 1970 return MethodRecognizer::AlwaysInline(function); |
1941 } | 1971 } |
(...skipping 13 matching lines...) Expand all Loading... | |
1955 TRACE_INLINING(THR_Print("Inlining calls in %s\n", top.ToCString())); | 1985 TRACE_INLINING(THR_Print("Inlining calls in %s\n", top.ToCString())); |
1956 | 1986 |
1957 if (FLAG_support_il_printer && trace_inlining() && | 1987 if (FLAG_support_il_printer && trace_inlining() && |
1958 (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized)) { | 1988 (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized)) { |
1959 THR_Print("Before Inlining of %s\n", | 1989 THR_Print("Before Inlining of %s\n", |
1960 flow_graph_->function().ToFullyQualifiedCString()); | 1990 flow_graph_->function().ToFullyQualifiedCString()); |
1961 FlowGraphPrinter printer(*flow_graph_); | 1991 FlowGraphPrinter printer(*flow_graph_); |
1962 printer.PrintBlocks(); | 1992 printer.PrintBlocks(); |
1963 } | 1993 } |
1964 | 1994 |
1965 CallSiteInliner inliner(this); | 1995 intptr_t inlining_depth_threshold = FLAG_inlining_depth_threshold; |
1996 if ((precompiler_ != NULL) && precompiler_->HasFeedback() && | |
1997 (top.usage_counter() <= 0)) { | |
1998 inlining_depth_threshold = 1; | |
1999 } | |
2000 | |
2001 CallSiteInliner inliner(this, inlining_depth_threshold); | |
1966 inliner.InlineCalls(); | 2002 inliner.InlineCalls(); |
1967 if (FLAG_print_inlining_tree) { | 2003 if (FLAG_print_inlining_tree) { |
1968 inliner.PrintInlinedInfo(top); | 2004 inliner.PrintInlinedInfo(top); |
1969 } | 2005 } |
1970 | 2006 |
1971 if (inliner.inlined()) { | 2007 if (inliner.inlined()) { |
1972 flow_graph_->DiscoverBlocks(); | 2008 flow_graph_->DiscoverBlocks(); |
1973 if (trace_inlining()) { | 2009 if (trace_inlining()) { |
1974 THR_Print("Inlining growth factor: %f\n", inliner.GrowthFactor()); | 2010 THR_Print("Inlining growth factor: %f\n", inliner.GrowthFactor()); |
1975 if (FLAG_support_il_printer && | 2011 if (FLAG_support_il_printer && |
(...skipping 1621 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3597 } | 3633 } |
3598 | 3634 |
3599 default: | 3635 default: |
3600 return false; | 3636 return false; |
3601 } | 3637 } |
3602 } | 3638 } |
3603 | 3639 |
3604 | 3640 |
3605 } // namespace dart | 3641 } // namespace dart |
3606 #endif // !defined(DART_PRECOMPILED_RUNTIME) | 3642 #endif // !defined(DART_PRECOMPILED_RUNTIME) |
OLD | NEW |