LCOV - code coverage report
Current view: top level - src/compiler - graph-visualizer.h (source / functions) Hit Total Coverage
Test: app.info Lines: 17 18 94.4 %
Date: 2019-02-19 Functions: 5 5 100.0 %

          Line data    Source code
       1             : // Copyright 2013 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_COMPILER_GRAPH_VISUALIZER_H_
       6             : #define V8_COMPILER_GRAPH_VISUALIZER_H_
       7             : 
       8             : #include <stdio.h>
       9             : #include <fstream>  // NOLINT(readability/streams)
      10             : #include <iosfwd>
      11             : #include <memory>
      12             : 
      13             : #include "src/globals.h"
      14             : #include "src/handles.h"
      15             : 
      16             : namespace v8 {
      17             : namespace internal {
      18             : 
      19             : class OptimizedCompilationInfo;
      20             : class SharedFunctionInfo;
      21             : class SourcePosition;
      22             : namespace compiler {
      23             : 
      24             : class Graph;
      25             : class Instruction;
      26             : class InstructionBlock;
      27             : class InstructionOperand;
      28             : class InstructionSequence;
      29             : class NodeOrigin;
      30             : class NodeOriginTable;
      31             : class RegisterAllocationData;
      32             : class Schedule;
      33             : class SourcePositionTable;
      34             : 
      35             : struct TurboJsonFile : public std::ofstream {
      36             :   TurboJsonFile(OptimizedCompilationInfo* info, std::ios_base::openmode mode);
      37             :   ~TurboJsonFile() override;
      38             : };
      39             : 
      40             : struct TurboCfgFile : public std::ofstream {
      41             :   explicit TurboCfgFile(Isolate* isolate = nullptr);
      42             :   ~TurboCfgFile() override;
      43             : };
      44             : 
      45             : struct SourcePositionAsJSON {
      46         501 :   explicit SourcePositionAsJSON(const SourcePosition& sp) : sp(sp) {}
      47             :   const SourcePosition& sp;
      48             : };
      49             : 
      50             : V8_INLINE V8_EXPORT_PRIVATE SourcePositionAsJSON
      51             : AsJSON(const SourcePosition& sp) {
      52         501 :   return SourcePositionAsJSON(sp);
      53             : }
      54             : 
      55             : struct NodeOriginAsJSON {
      56         250 :   explicit NodeOriginAsJSON(const NodeOrigin& no) : no(no) {}
      57             :   const NodeOrigin& no;
      58             : };
      59             : 
      60             : V8_INLINE V8_EXPORT_PRIVATE NodeOriginAsJSON AsJSON(const NodeOrigin& no) {
      61         250 :   return NodeOriginAsJSON(no);
      62             : }
      63             : 
      64             : std::ostream& operator<<(std::ostream& out, const SourcePositionAsJSON& pos);
      65             : 
      66             : // Small helper that deduplicates SharedFunctionInfos.
      67          14 : class SourceIdAssigner {
      68             :  public:
      69           7 :   explicit SourceIdAssigner(size_t size) {
      70           7 :     printed_.reserve(size);
      71           7 :     source_ids_.reserve(size);
      72           7 :   }
      73             :   int GetIdFor(Handle<SharedFunctionInfo> shared);
      74          10 :   int GetIdAt(size_t pos) const { return source_ids_[pos]; }
      75             : 
      76             :  private:
      77             :   std::vector<Handle<SharedFunctionInfo>> printed_;
      78             :   std::vector<int> source_ids_;
      79             : };
      80             : 
      81             : void JsonPrintAllSourceWithPositions(std::ostream& os,
      82             :                                      OptimizedCompilationInfo* info,
      83             :                                      Isolate* isolate);
      84             : 
      85             : void JsonPrintFunctionSource(std::ostream& os, int source_id,
      86             :                              std::unique_ptr<char[]> function_name,
      87             :                              Handle<Script> script, Isolate* isolate,
      88             :                              Handle<SharedFunctionInfo> shared,
      89             :                              bool with_key = false);
      90             : std::unique_ptr<char[]> GetVisualizerLogFileName(OptimizedCompilationInfo* info,
      91             :                                                  const char* optional_base_dir,
      92             :                                                  const char* phase,
      93             :                                                  const char* suffix);
      94             : 
      95             : struct GraphAsJSON {
      96          44 :   GraphAsJSON(const Graph& g, SourcePositionTable* p, NodeOriginTable* o)
      97          44 :       : graph(g), positions(p), origins(o) {}
      98             :   const Graph& graph;
      99             :   const SourcePositionTable* positions;
     100             :   const NodeOriginTable* origins;
     101             : };
     102             : 
     103             : V8_INLINE V8_EXPORT_PRIVATE GraphAsJSON AsJSON(const Graph& g,
     104             :                                                SourcePositionTable* p,
     105             :                                                NodeOriginTable* o) {
     106          44 :   return GraphAsJSON(g, p, o);
     107             : }
     108             : 
     109             : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
     110             :                                            const GraphAsJSON& ad);
     111             : 
     112             : struct AsRPO {
     113          20 :   explicit AsRPO(const Graph& g) : graph(g) {}
     114             :   const Graph& graph;
     115             : };
     116             : 
     117             : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os, const AsRPO& ad);
     118             : 
     119             : struct AsC1VCompilation {
     120             :   explicit AsC1VCompilation(const OptimizedCompilationInfo* info)
     121           1 :       : info_(info) {}
     122             :   const OptimizedCompilationInfo* info_;
     123             : };
     124             : 
     125             : struct AsScheduledGraph {
     126           0 :   explicit AsScheduledGraph(const Schedule* schedule) : schedule(schedule) {}
     127             :   const Schedule* schedule;
     128             : };
     129             : 
     130             : std::ostream& operator<<(std::ostream& os, const AsScheduledGraph& scheduled);
     131             : struct AsC1V {
     132             :   AsC1V(const char* phase, const Schedule* schedule,
     133             :         const SourcePositionTable* positions = nullptr,
     134             :         const InstructionSequence* instructions = nullptr)
     135             :       : schedule_(schedule),
     136             :         instructions_(instructions),
     137             :         positions_(positions),
     138           1 :         phase_(phase) {}
     139             :   const Schedule* schedule_;
     140             :   const InstructionSequence* instructions_;
     141             :   const SourcePositionTable* positions_;
     142             :   const char* phase_;
     143             : };
     144             : 
     145             : struct AsC1VRegisterAllocationData {
     146             :   explicit AsC1VRegisterAllocationData(
     147             :       const char* phase, const RegisterAllocationData* data = nullptr)
     148           3 :       : phase_(phase), data_(data) {}
     149             :   const char* phase_;
     150             :   const RegisterAllocationData* data_;
     151             : };
     152             : 
     153             : std::ostream& operator<<(std::ostream& os, const AsC1VCompilation& ac);
     154             : std::ostream& operator<<(std::ostream& os, const AsC1V& ac);
     155             : std::ostream& operator<<(std::ostream& os,
     156             :                          const AsC1VRegisterAllocationData& ac);
     157             : 
     158             : struct InstructionOperandAsJSON {
     159             :   const InstructionOperand* op_;
     160             :   const InstructionSequence* code_;
     161             : };
     162             : 
     163             : std::ostream& operator<<(std::ostream& os, const InstructionOperandAsJSON& o);
     164             : 
     165             : struct InstructionAsJSON {
     166             :   int index_;
     167             :   const Instruction* instr_;
     168             :   const InstructionSequence* code_;
     169             : };
     170             : std::ostream& operator<<(std::ostream& os, const InstructionAsJSON& i);
     171             : 
     172             : struct InstructionBlockAsJSON {
     173             :   const InstructionBlock* block_;
     174             :   const InstructionSequence* code_;
     175             : };
     176             : 
     177             : std::ostream& operator<<(std::ostream& os, const InstructionBlockAsJSON& b);
     178             : 
     179             : struct InstructionSequenceAsJSON {
     180             :   const InstructionSequence* sequence_;
     181             : };
     182             : std::ostream& operator<<(std::ostream& os, const InstructionSequenceAsJSON& s);
     183             : 
     184             : }  // namespace compiler
     185             : }  // namespace internal
     186             : }  // namespace v8
     187             : 
     188             : #endif  // V8_COMPILER_GRAPH_VISUALIZER_H_

Generated by: LCOV version 1.10