Remove unused/not working function tracing flag and functionality.

runtime/vm/flow_graph_compiler.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
 #include "vm/locations.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_scopes, false, "Print scopes of local variables.");
-DEFINE_FLAG(bool, trace_functions, false, "Trace entry of each function.");
 DECLARE_FLAG(bool, code_comments);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, intrinsify);
 DECLARE_FLAG(bool, propagate_ic_data);
 DECLARE_FLAG(bool, report_usage_count);
-DECLARE_FLAG(bool, trace_functions);
 DECLARE_FLAG(int, optimization_counter_threshold);
 
 void CompilerDeoptInfo::BuildReturnAddress(DeoptInfoBuilder* builder,
                                            const Function& function,
                                            intptr_t slot_ix) {
   builder->AddReturnAddressAfter(function, deopt_id(), slot_ix);
 }
 
 
 void CompilerDeoptInfoWithStub::BuildReturnAddress(DeoptInfoBuilder* builder,
@@ skipping 384 matching lines @@
   code.set_comments(assembler()->GetCodeComments());
 }
 
 
 // Returns 'true' if code generation for this function is complete, i.e.,
 // no fall-through to regular code is needed.
 bool FlowGraphCompiler::TryIntrinsify() {
   if (!CanOptimize()) return false;
   // Intrinsification skips arguments checks, therefore disable if in checked
   // mode.
-  if (FLAG_intrinsify && !FLAG_trace_functions && !FLAG_enable_type_checks) {
+  if (FLAG_intrinsify && !FLAG_enable_type_checks) {
     if ((parsed_function().function().kind() == RawFunction::kImplicitGetter)) {
       // An implicit getter must have a specific AST structure.
       const SequenceNode& sequence_node = *parsed_function().node_sequence();
       ASSERT(sequence_node.length() == 1);
       ASSERT(sequence_node.NodeAt(0)->IsReturnNode());
       const ReturnNode& return_node = *sequence_node.NodeAt(0)->AsReturnNode();
       ASSERT(return_node.value()->IsLoadInstanceFieldNode());
       const LoadInstanceFieldNode& load_node =
           *return_node.value()->AsLoadInstanceFieldNode();
       GenerateInlinedGetter(load_node.field().Offset());
       return true;
     }
     if ((parsed_function().function().kind() == RawFunction::kImplicitSetter)) {
       // An implicit setter must have a specific AST structure.
       // Sequence node has one store node and one return NULL node.
       const SequenceNode& sequence_node = *parsed_function().node_sequence();
       ASSERT(sequence_node.length() == 2);
       ASSERT(sequence_node.NodeAt(0)->IsStoreInstanceFieldNode());
       ASSERT(sequence_node.NodeAt(1)->IsReturnNode());
       const StoreInstanceFieldNode& store_node =
           *sequence_node.NodeAt(0)->AsStoreInstanceFieldNode();
       GenerateInlinedSetter(store_node.field().Offset());
       return true;
     }
   }
   // Even if an intrinsified version of the function was successfully
   // generated, it may fall through to the non-intrinsified method body.
-  if (!FLAG_trace_functions) {
-    return Intrinsifier::Intrinsify(parsed_function().function(), assembler());
-  }
-  return false;
+  return Intrinsifier::Intrinsify(parsed_function().function(), assembler());
 }
 
 
 void FlowGraphCompiler::GenerateInstanceCall(
     intptr_t deopt_id,
     intptr_t token_pos,
     intptr_t argument_count,
     const Array& argument_names,
     LocationSummary* locs,
     const ICData& ic_data) {
@@ skipping 444 matching lines @@
       ASSERT(Utils::IsInt(31, disp));
       return FieldAddress(array, disp);
     }
     default:
       UNIMPLEMENTED();
       return FieldAddress(SPREG, 0);
   }
 }
 
 }  // namespace dart