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 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
783 callee_graph = builder.BuildGraph(); | 798 callee_graph = builder.BuildGraph(); |
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 } |
| 808 #ifdef DART_PRECOMPILER |
| 809 Precompiler::PopulateWithICData(parsed_function->function(), |
| 810 callee_graph); |
| 811 if (inliner_->precompiler_ != NULL) { |
| 812 inliner_->precompiler_->TryApplyFeedback( |
| 813 parsed_function->function(), callee_graph); |
| 814 } |
| 815 #endif |
793 } | 816 } |
794 | 817 |
795 // The parameter stubs are a copy of the actual arguments providing | 818 // The parameter stubs are a copy of the actual arguments providing |
796 // concrete information about the values, for example constant values, | 819 // concrete information about the values, for example constant values, |
797 // without linking between the caller and callee graphs. | 820 // without linking between the caller and callee graphs. |
798 // TODO(zerny): Put more information in the stubs, eg, type information. | 821 // TODO(zerny): Put more information in the stubs, eg, type information. |
799 ZoneGrowableArray<Definition*>* param_stubs = | 822 ZoneGrowableArray<Definition*>* param_stubs = |
800 new (Z) ZoneGrowableArray<Definition*>(function.NumParameters()); | 823 new (Z) ZoneGrowableArray<Definition*>(function.NumParameters()); |
801 | 824 |
802 // Create a parameter stub for each fixed positional parameter. | 825 // Create a parameter stub for each fixed positional parameter. |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
850 | 873 |
851 { | 874 { |
852 CSTAT_TIMER_SCOPE(thread(), graphinliner_opt_timer); | 875 CSTAT_TIMER_SCOPE(thread(), graphinliner_opt_timer); |
853 // TODO(fschneider): Improve suppression of speculative inlining. | 876 // TODO(fschneider): Improve suppression of speculative inlining. |
854 // Deopt-ids overlap between caller and callee. | 877 // Deopt-ids overlap between caller and callee. |
855 if (FLAG_precompiled_mode) { | 878 if (FLAG_precompiled_mode) { |
856 #ifdef DART_PRECOMPILER | 879 #ifdef DART_PRECOMPILER |
857 AotOptimizer optimizer(inliner_->precompiler_, callee_graph, | 880 AotOptimizer optimizer(inliner_->precompiler_, callee_graph, |
858 inliner_->use_speculative_inlining_, | 881 inliner_->use_speculative_inlining_, |
859 inliner_->inlining_black_list_); | 882 inliner_->inlining_black_list_); |
860 optimizer.PopulateWithICData(); | |
861 | 883 |
862 optimizer.ApplyClassIds(); | 884 optimizer.ApplyClassIds(); |
863 DEBUG_ASSERT(callee_graph->VerifyUseLists()); | 885 DEBUG_ASSERT(callee_graph->VerifyUseLists()); |
864 | 886 |
865 FlowGraphTypePropagator::Propagate(callee_graph); | 887 FlowGraphTypePropagator::Propagate(callee_graph); |
866 DEBUG_ASSERT(callee_graph->VerifyUseLists()); | 888 DEBUG_ASSERT(callee_graph->VerifyUseLists()); |
867 | 889 |
868 optimizer.ApplyICData(); | 890 optimizer.ApplyICData(); |
869 DEBUG_ASSERT(callee_graph->VerifyUseLists()); | 891 DEBUG_ASSERT(callee_graph->VerifyUseLists()); |
870 | 892 |
(...skipping 497 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1368 } | 1390 } |
1369 | 1391 |
1370 FlowGraphInliner* inliner_; | 1392 FlowGraphInliner* inliner_; |
1371 FlowGraph* caller_graph_; | 1393 FlowGraph* caller_graph_; |
1372 bool inlined_; | 1394 bool inlined_; |
1373 const intptr_t initial_size_; | 1395 const intptr_t initial_size_; |
1374 intptr_t inlined_size_; | 1396 intptr_t inlined_size_; |
1375 bool inlined_recursive_call_; | 1397 bool inlined_recursive_call_; |
1376 intptr_t inlining_depth_; | 1398 intptr_t inlining_depth_; |
1377 intptr_t inlining_recursion_depth_; | 1399 intptr_t inlining_recursion_depth_; |
| 1400 intptr_t inlining_depth_threshold_; |
1378 CallSites* collected_call_sites_; | 1401 CallSites* collected_call_sites_; |
1379 CallSites* inlining_call_sites_; | 1402 CallSites* inlining_call_sites_; |
1380 GrowableArray<ParsedFunction*> function_cache_; | 1403 GrowableArray<ParsedFunction*> function_cache_; |
1381 GrowableArray<InlinedInfo> inlined_info_; | 1404 GrowableArray<InlinedInfo> inlined_info_; |
1382 | 1405 |
1383 DISALLOW_COPY_AND_ASSIGN(CallSiteInliner); | 1406 DISALLOW_COPY_AND_ASSIGN(CallSiteInliner); |
1384 }; | 1407 }; |
1385 | 1408 |
1386 | 1409 |
1387 PolymorphicInliner::PolymorphicInliner(CallSiteInliner* owner, | 1410 PolymorphicInliner::PolymorphicInliner(CallSiteInliner* owner, |
(...skipping 534 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1922 TRACE_INLINING( | 1945 TRACE_INLINING( |
1923 THR_Print("AlwaysInline annotation for %s\n", function.ToCString())); | 1946 THR_Print("AlwaysInline annotation for %s\n", function.ToCString())); |
1924 return true; | 1947 return true; |
1925 } | 1948 } |
1926 | 1949 |
1927 if (function.IsDispatcherOrImplicitAccessor()) { | 1950 if (function.IsDispatcherOrImplicitAccessor()) { |
1928 // Smaller or same size as the call. | 1951 // Smaller or same size as the call. |
1929 return true; | 1952 return true; |
1930 } | 1953 } |
1931 | 1954 |
| 1955 if (function.is_const()) { |
| 1956 // Inlined const fields are smaller than a call. |
| 1957 return true; |
| 1958 } |
| 1959 |
1932 if (function.IsGetterFunction() || function.IsSetterFunction() || | 1960 if (function.IsGetterFunction() || function.IsSetterFunction() || |
1933 IsInlineableOperator(function) || | 1961 IsInlineableOperator(function) || |
1934 (function.kind() == RawFunction::kConstructor)) { | 1962 (function.kind() == RawFunction::kConstructor)) { |
1935 const intptr_t count = function.optimized_instruction_count(); | 1963 const intptr_t count = function.optimized_instruction_count(); |
1936 if ((count != 0) && (count < FLAG_inline_getters_setters_smaller_than)) { | 1964 if ((count != 0) && (count < FLAG_inline_getters_setters_smaller_than)) { |
1937 return true; | 1965 return true; |
1938 } | 1966 } |
1939 } | 1967 } |
1940 return MethodRecognizer::AlwaysInline(function); | 1968 return MethodRecognizer::AlwaysInline(function); |
1941 } | 1969 } |
(...skipping 13 matching lines...) Expand all Loading... |
1955 TRACE_INLINING(THR_Print("Inlining calls in %s\n", top.ToCString())); | 1983 TRACE_INLINING(THR_Print("Inlining calls in %s\n", top.ToCString())); |
1956 | 1984 |
1957 if (FLAG_support_il_printer && trace_inlining() && | 1985 if (FLAG_support_il_printer && trace_inlining() && |
1958 (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized)) { | 1986 (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized)) { |
1959 THR_Print("Before Inlining of %s\n", | 1987 THR_Print("Before Inlining of %s\n", |
1960 flow_graph_->function().ToFullyQualifiedCString()); | 1988 flow_graph_->function().ToFullyQualifiedCString()); |
1961 FlowGraphPrinter printer(*flow_graph_); | 1989 FlowGraphPrinter printer(*flow_graph_); |
1962 printer.PrintBlocks(); | 1990 printer.PrintBlocks(); |
1963 } | 1991 } |
1964 | 1992 |
1965 CallSiteInliner inliner(this); | 1993 intptr_t inlining_depth_threshold = FLAG_inlining_depth_threshold; |
| 1994 if ((precompiler_ != NULL) && precompiler_->HasFeedback() && |
| 1995 (top.usage_counter() <= 0)) { |
| 1996 inlining_depth_threshold = 1; |
| 1997 } |
| 1998 |
| 1999 CallSiteInliner inliner(this, inlining_depth_threshold); |
1966 inliner.InlineCalls(); | 2000 inliner.InlineCalls(); |
1967 if (FLAG_print_inlining_tree) { | 2001 if (FLAG_print_inlining_tree) { |
1968 inliner.PrintInlinedInfo(top); | 2002 inliner.PrintInlinedInfo(top); |
1969 } | 2003 } |
1970 | 2004 |
1971 if (inliner.inlined()) { | 2005 if (inliner.inlined()) { |
1972 flow_graph_->DiscoverBlocks(); | 2006 flow_graph_->DiscoverBlocks(); |
1973 if (trace_inlining()) { | 2007 if (trace_inlining()) { |
1974 THR_Print("Inlining growth factor: %f\n", inliner.GrowthFactor()); | 2008 THR_Print("Inlining growth factor: %f\n", inliner.GrowthFactor()); |
1975 if (FLAG_support_il_printer && | 2009 if (FLAG_support_il_printer && |
(...skipping 1621 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3597 } | 3631 } |
3598 | 3632 |
3599 default: | 3633 default: |
3600 return false; | 3634 return false; |
3601 } | 3635 } |
3602 } | 3636 } |
3603 | 3637 |
3604 | 3638 |
3605 } // namespace dart | 3639 } // namespace dart |
3606 #endif // !defined(DART_PRECOMPILED_RUNTIME) | 3640 #endif // !defined(DART_PRECOMPILED_RUNTIME) |
OLD | NEW |