1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// Copyright 2013 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_COMPILER_GRAPH_VISUALIZER_H_
#define V8_COMPILER_GRAPH_VISUALIZER_H_
#include <stdio.h>
#include <fstream> // NOLINT(readability/streams)
#include <iosfwd>
#include <memory>
#include "src/globals.h"
#include "src/handles.h"
namespace v8 {
namespace internal {
class OptimizedCompilationInfo;
class SharedFunctionInfo;
class SourcePosition;
namespace compiler {
class Graph;
class InstructionSequence;
class NodeOrigin;
class NodeOriginTable;
class RegisterAllocationData;
class Schedule;
class SourcePositionTable;
struct TurboJsonFile : public std::ofstream {
TurboJsonFile(OptimizedCompilationInfo* info, std::ios_base::openmode mode);
~TurboJsonFile();
};
struct SourcePositionAsJSON {
explicit SourcePositionAsJSON(const SourcePosition& sp) : sp(sp) {}
const SourcePosition& sp;
};
V8_INLINE V8_EXPORT_PRIVATE SourcePositionAsJSON
AsJSON(const SourcePosition& sp) {
return SourcePositionAsJSON(sp);
}
struct NodeOriginAsJSON {
explicit NodeOriginAsJSON(const NodeOrigin& no) : no(no) {}
const NodeOrigin& no;
};
V8_INLINE V8_EXPORT_PRIVATE NodeOriginAsJSON AsJSON(const NodeOrigin& no) {
return NodeOriginAsJSON(no);
}
std::ostream& operator<<(std::ostream& out, const SourcePositionAsJSON& pos);
// Small helper that deduplicates SharedFunctionInfos.
class SourceIdAssigner {
public:
explicit SourceIdAssigner(size_t size) {
printed_.reserve(size);
source_ids_.reserve(size);
}
int GetIdFor(Handle<SharedFunctionInfo> shared);
int GetIdAt(size_t pos) const { return source_ids_[pos]; }
private:
std::vector<Handle<SharedFunctionInfo>> printed_;
std::vector<int> source_ids_;
};
void JsonPrintAllSourceWithPositions(std::ostream& os,
OptimizedCompilationInfo* info,
Isolate* isolate);
void JsonPrintFunctionSource(std::ostream& os, int source_id,
std::unique_ptr<char[]> function_name,
Handle<Script> script, Isolate* isolate,
Handle<SharedFunctionInfo> shared,
bool with_key = false);
std::unique_ptr<char[]> GetVisualizerLogFileName(OptimizedCompilationInfo* info,
const char* optional_base_dir,
const char* phase,
const char* suffix);
struct GraphAsJSON {
GraphAsJSON(const Graph& g, SourcePositionTable* p, NodeOriginTable* o)
: graph(g), positions(p), origins(o) {}
const Graph& graph;
const SourcePositionTable* positions;
const NodeOriginTable* origins;
};
V8_INLINE V8_EXPORT_PRIVATE GraphAsJSON AsJSON(const Graph& g,
SourcePositionTable* p,
NodeOriginTable* o) {
return GraphAsJSON(g, p, o);
}
V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
const GraphAsJSON& ad);
struct AsRPO {
explicit AsRPO(const Graph& g) : graph(g) {}
const Graph& graph;
};
V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os, const AsRPO& ad);
struct AsC1VCompilation {
explicit AsC1VCompilation(const OptimizedCompilationInfo* info)
: info_(info) {}
const OptimizedCompilationInfo* info_;
};
struct AsScheduledGraph {
explicit AsScheduledGraph(const Schedule* schedule) : schedule(schedule) {}
const Schedule* schedule;
};
std::ostream& operator<<(std::ostream& os, const AsScheduledGraph& scheduled);
struct AsC1V {
AsC1V(const char* phase, const Schedule* schedule,
const SourcePositionTable* positions = nullptr,
const InstructionSequence* instructions = nullptr)
: schedule_(schedule),
instructions_(instructions),
positions_(positions),
phase_(phase) {}
const Schedule* schedule_;
const InstructionSequence* instructions_;
const SourcePositionTable* positions_;
const char* phase_;
};
struct AsC1VRegisterAllocationData {
explicit AsC1VRegisterAllocationData(
const char* phase, const RegisterAllocationData* data = nullptr)
: phase_(phase), data_(data) {}
const char* phase_;
const RegisterAllocationData* data_;
};
std::ostream& operator<<(std::ostream& os, const AsC1VCompilation& ac);
std::ostream& operator<<(std::ostream& os, const AsC1V& ac);
std::ostream& operator<<(std::ostream& os,
const AsC1VRegisterAllocationData& ac);
} // namespace compiler
} // namespace internal
} // namespace v8
#endif // V8_COMPILER_GRAPH_VISUALIZER_H_
|
