Move TraceInlinedFunction from Hydrogen graph builder to CompilationInfo.

src/compilation-info.h

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COMPILATION_INFO_H_
 #define V8_COMPILATION_INFO_H_
 
 #include <memory>
 
 #include "src/compilation-dependencies.h"
@@ skipping 265 matching lines @@
   struct InlinedFunctionHolder {
     Handle<SharedFunctionInfo> shared_info;
 
     // Root that holds the unoptimized code of the inlined function alive
     // (and out of reach of code flushing) until we finish compilation.
     // Do not remove.
     Handle<Code> inlined_code_object_root;
 
     InliningPosition position;
 
+    static const int kSourceNotDumped = -1;
+    int source_id;

[Tobias Tebbi, 2016/12/15 16:22:01]

These are too many ids. Now we have inlining_id, inlined_function_id and
source_id, all related to a single inlined function. Instead of adding state to
the compilation process, why not dump the inlined functions after the
compilation is complete, in internal::CodeGenerator. Also, CompilationInfo is
supposed to be a pure data container without logic.

+
     InlinedFunctionHolder(Handle<SharedFunctionInfo> inlined_shared_info,
                           Handle<Code> inlined_code_object_root,
                           SourcePosition pos)
         : shared_info(inlined_shared_info),
-          inlined_code_object_root(inlined_code_object_root) {
+          inlined_code_object_root(inlined_code_object_root),
+          source_id(kSourceNotDumped) {
       position.position = pos;
       // initialized when generating the deoptimization literals
       position.inlined_function_id = DeoptimizationInputData::kNotInlinedIndex;
     }
 
     void RegisterInlinedFunctionId(size_t inlined_function_id) {
       position.inlined_function_id = static_cast<int>(inlined_function_id);
     }
   };
 
@@ skipping 32 matching lines @@
   void SetFlag(Flag flag) { flags_ |= flag; }
 
   void SetFlag(Flag flag, bool value) {
     flags_ = value ? flags_ | flag : flags_ & ~flag;
   }
 
   bool GetFlag(Flag flag) const { return (flags_ & flag) != 0; }
 
   void set_is_debug();
 
+  // If we are tracking source positions then this function prints a unique

[Tobias Tebbi, 2016/12/15 16:22:01]

"tracking source positions" is not an accurate description anymore. We track
source positions in many more circumstances than the --hydrogen-track-positions
flag. Perhaps we should introduce a new flag for IRHydra.

+  // identifier assigned to each inlining and dumps function source if it
+  // was inlined for the first time during the current optimization.
+  void TraceInlinedFunction(Handle<SharedFunctionInfo> shared,
+                            SourcePosition position, int inlining_id);
+
+  // Assign source id to the given inlining: source ids are used to
+  // avoid dumping the same function multiple times to minimize trace
+  // size.
+  bool AssignSourceIdToInlining(int inlining_id, int* source_id);
+
   unsigned flags_;
 
   Code::Flags code_flags_;
 
   Handle<JSFunction> closure_;
 
   // The compiled code.
   Handle<Code> code_;
 
   // Compilation mode flag and whether deoptimization is allowed.
@@ skipping 32 matching lines @@
 
   Vector<const char> debug_name_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationInfo);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILATION_INFO_H_