Line data Source code
1 : // Copyright 2011 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 : #include "src/disassembler.h"
6 :
7 : #include <memory>
8 :
9 : #include "src/assembler-inl.h"
10 : #include "src/code-stubs.h"
11 : #include "src/codegen.h"
12 : #include "src/debug/debug.h"
13 : #include "src/deoptimizer.h"
14 : #include "src/disasm.h"
15 : #include "src/ic/ic.h"
16 : #include "src/macro-assembler.h"
17 : #include "src/objects-inl.h"
18 : #include "src/snapshot/serializer-common.h"
19 : #include "src/string-stream.h"
20 :
21 : namespace v8 {
22 : namespace internal {
23 :
24 : #ifdef ENABLE_DISASSEMBLER
25 :
26 : class V8NameConverter: public disasm::NameConverter {
27 : public:
28 : explicit V8NameConverter(Code* code) : code_(code) {}
29 : virtual const char* NameOfAddress(byte* pc) const;
30 : virtual const char* NameInCode(byte* addr) const;
31 : Code* code() const { return code_; }
32 : private:
33 : Code* code_;
34 :
35 : EmbeddedVector<char, 128> v8_buffer_;
36 : };
37 :
38 :
39 : const char* V8NameConverter::NameOfAddress(byte* pc) const {
40 : const char* name =
41 : code_ == NULL ? NULL : code_->GetIsolate()->builtins()->Lookup(pc);
42 :
43 : if (name != NULL) {
44 : SNPrintF(v8_buffer_, "%p (%s)", static_cast<void*>(pc), name);
45 : return v8_buffer_.start();
46 : }
47 :
48 : if (code_ != NULL) {
49 : int offs = static_cast<int>(pc - code_->instruction_start());
50 : // print as code offset, if it seems reasonable
51 : if (0 <= offs && offs < code_->instruction_size()) {
52 : SNPrintF(v8_buffer_, "%p <+0x%x>", static_cast<void*>(pc), offs);
53 : return v8_buffer_.start();
54 : }
55 : }
56 :
57 : return disasm::NameConverter::NameOfAddress(pc);
58 : }
59 :
60 :
61 : const char* V8NameConverter::NameInCode(byte* addr) const {
62 : // The V8NameConverter is used for well known code, so we can "safely"
63 : // dereference pointers in generated code.
64 : return (code_ != NULL) ? reinterpret_cast<const char*>(addr) : "";
65 : }
66 :
67 :
68 : static void DumpBuffer(std::ostream* os, StringBuilder* out) {
69 : (*os) << out->Finalize() << std::endl;
70 : out->Reset();
71 : }
72 :
73 :
74 : static const int kOutBufferSize = 2048 + String::kMaxShortPrintLength;
75 : static const int kRelocInfoPosition = 57;
76 :
77 : static int DecodeIt(Isolate* isolate, std::ostream* os,
78 : const V8NameConverter& converter, byte* begin, byte* end) {
79 : SealHandleScope shs(isolate);
80 : DisallowHeapAllocation no_alloc;
81 : ExternalReferenceEncoder ref_encoder(isolate);
82 :
83 : v8::internal::EmbeddedVector<char, 128> decode_buffer;
84 : v8::internal::EmbeddedVector<char, kOutBufferSize> out_buffer;
85 : StringBuilder out(out_buffer.start(), out_buffer.length());
86 : byte* pc = begin;
87 : disasm::Disassembler d(converter);
88 : RelocIterator* it = NULL;
89 : if (converter.code() != NULL) {
90 : it = new RelocIterator(converter.code());
91 : } else {
92 : // No relocation information when printing code stubs.
93 : }
94 : int constants = -1; // no constants being decoded at the start
95 :
96 : while (pc < end) {
97 : // First decode instruction so that we know its length.
98 : byte* prev_pc = pc;
99 : if (constants > 0) {
100 : SNPrintF(decode_buffer,
101 : "%08x constant",
102 : *reinterpret_cast<int32_t*>(pc));
103 : constants--;
104 : pc += 4;
105 : } else {
106 : int num_const = d.ConstantPoolSizeAt(pc);
107 : if (num_const >= 0) {
108 : SNPrintF(decode_buffer,
109 : "%08x constant pool begin (num_const = %d)",
110 : *reinterpret_cast<int32_t*>(pc), num_const);
111 : constants = num_const;
112 : pc += 4;
113 : } else if (it != NULL && !it->done() && it->rinfo()->pc() == pc &&
114 : it->rinfo()->rmode() == RelocInfo::INTERNAL_REFERENCE) {
115 : // raw pointer embedded in code stream, e.g., jump table
116 : byte* ptr = *reinterpret_cast<byte**>(pc);
117 : SNPrintF(
118 : decode_buffer, "%08" V8PRIxPTR " jump table entry %4" PRIuS,
119 : reinterpret_cast<intptr_t>(ptr), static_cast<size_t>(ptr - begin));
120 : pc += sizeof(ptr);
121 : } else {
122 : decode_buffer[0] = '\0';
123 : pc += d.InstructionDecode(decode_buffer, pc);
124 : }
125 : }
126 :
127 : // Collect RelocInfo for this instruction (prev_pc .. pc-1)
128 : List<const char*> comments(4);
129 : List<byte*> pcs(1);
130 : List<RelocInfo::Mode> rmodes(1);
131 : List<intptr_t> datas(1);
132 : if (it != NULL) {
133 : while (!it->done() && it->rinfo()->pc() < pc) {
134 : if (RelocInfo::IsComment(it->rinfo()->rmode())) {
135 : // For comments just collect the text.
136 : comments.Add(reinterpret_cast<const char*>(it->rinfo()->data()));
137 : } else {
138 : // For other reloc info collect all data.
139 : pcs.Add(it->rinfo()->pc());
140 : rmodes.Add(it->rinfo()->rmode());
141 : datas.Add(it->rinfo()->data());
142 : }
143 : it->next();
144 : }
145 : }
146 :
147 : // Comments.
148 : for (int i = 0; i < comments.length(); i++) {
149 : out.AddFormatted(" %s", comments[i]);
150 : DumpBuffer(os, &out);
151 : }
152 :
153 : // Instruction address and instruction offset.
154 : out.AddFormatted("%p %4" V8PRIxPTRDIFF " ", static_cast<void*>(prev_pc),
155 : prev_pc - begin);
156 :
157 : // Instruction.
158 : out.AddFormatted("%s", decode_buffer.start());
159 :
160 : // Print all the reloc info for this instruction which are not comments.
161 : for (int i = 0; i < pcs.length(); i++) {
162 : // Put together the reloc info
163 : RelocInfo relocinfo(pcs[i], rmodes[i], datas[i], converter.code());
164 :
165 : // Indent the printing of the reloc info.
166 : if (i == 0) {
167 : // The first reloc info is printed after the disassembled instruction.
168 : out.AddPadding(' ', kRelocInfoPosition - out.position());
169 : } else {
170 : // Additional reloc infos are printed on separate lines.
171 : DumpBuffer(os, &out);
172 : out.AddPadding(' ', kRelocInfoPosition);
173 : }
174 :
175 : RelocInfo::Mode rmode = relocinfo.rmode();
176 : if (rmode == RelocInfo::DEOPT_SCRIPT_OFFSET) {
177 : out.AddFormatted(" ;; debug: deopt position, script offset '%d'",
178 : static_cast<int>(relocinfo.data()));
179 : } else if (rmode == RelocInfo::DEOPT_INLINING_ID) {
180 : out.AddFormatted(" ;; debug: deopt position, inlining id '%d'",
181 : static_cast<int>(relocinfo.data()));
182 : } else if (rmode == RelocInfo::DEOPT_REASON) {
183 : DeoptimizeReason reason =
184 : static_cast<DeoptimizeReason>(relocinfo.data());
185 : out.AddFormatted(" ;; debug: deopt reason '%s'",
186 : DeoptimizeReasonToString(reason));
187 : } else if (rmode == RelocInfo::DEOPT_ID) {
188 : out.AddFormatted(" ;; debug: deopt index %d",
189 : static_cast<int>(relocinfo.data()));
190 : } else if (rmode == RelocInfo::EMBEDDED_OBJECT) {
191 : HeapStringAllocator allocator;
192 : StringStream accumulator(&allocator);
193 : relocinfo.target_object()->ShortPrint(&accumulator);
194 : std::unique_ptr<char[]> obj_name = accumulator.ToCString();
195 : out.AddFormatted(" ;; object: %s", obj_name.get());
196 : } else if (rmode == RelocInfo::EXTERNAL_REFERENCE) {
197 : const char* reference_name = ref_encoder.NameOfAddress(
198 : isolate, relocinfo.target_external_reference());
199 : out.AddFormatted(" ;; external reference (%s)", reference_name);
200 : } else if (RelocInfo::IsCodeTarget(rmode)) {
201 : out.AddFormatted(" ;; code:");
202 : Code* code = Code::GetCodeFromTargetAddress(relocinfo.target_address());
203 : Code::Kind kind = code->kind();
204 : if (code->is_inline_cache_stub()) {
205 : out.AddFormatted(" %s", Code::Kind2String(kind));
206 : if (kind == Code::BINARY_OP_IC || kind == Code::TO_BOOLEAN_IC ||
207 : kind == Code::COMPARE_IC) {
208 : InlineCacheState ic_state = IC::StateFromCode(code);
209 : out.AddFormatted(" %s", Code::ICState2String(ic_state));
210 : }
211 : } else if (kind == Code::STUB || kind == Code::HANDLER) {
212 : // Get the STUB key and extract major and minor key.
213 : uint32_t key = code->stub_key();
214 : uint32_t minor_key = CodeStub::MinorKeyFromKey(key);
215 : CodeStub::Major major_key = CodeStub::GetMajorKey(code);
216 : DCHECK(major_key == CodeStub::MajorKeyFromKey(key));
217 : out.AddFormatted(" %s, %s, ", Code::Kind2String(kind),
218 : CodeStub::MajorName(major_key));
219 : out.AddFormatted("minor: %d", minor_key);
220 : } else {
221 : out.AddFormatted(" %s", Code::Kind2String(kind));
222 : }
223 : if (rmode == RelocInfo::CODE_TARGET_WITH_ID) {
224 : out.AddFormatted(" (id = %d)", static_cast<int>(relocinfo.data()));
225 : }
226 : } else if (RelocInfo::IsRuntimeEntry(rmode) &&
227 : isolate->deoptimizer_data() != NULL) {
228 : // A runtime entry reloinfo might be a deoptimization bailout.
229 : Address addr = relocinfo.target_address();
230 : int id = Deoptimizer::GetDeoptimizationId(isolate,
231 : addr,
232 : Deoptimizer::EAGER);
233 : if (id == Deoptimizer::kNotDeoptimizationEntry) {
234 : id = Deoptimizer::GetDeoptimizationId(isolate,
235 : addr,
236 : Deoptimizer::LAZY);
237 : if (id == Deoptimizer::kNotDeoptimizationEntry) {
238 : id = Deoptimizer::GetDeoptimizationId(isolate,
239 : addr,
240 : Deoptimizer::SOFT);
241 : if (id == Deoptimizer::kNotDeoptimizationEntry) {
242 : out.AddFormatted(" ;; %s", RelocInfo::RelocModeName(rmode));
243 : } else {
244 : out.AddFormatted(" ;; soft deoptimization bailout %d", id);
245 : }
246 : } else {
247 : out.AddFormatted(" ;; lazy deoptimization bailout %d", id);
248 : }
249 : } else {
250 : out.AddFormatted(" ;; deoptimization bailout %d", id);
251 : }
252 : } else {
253 : out.AddFormatted(" ;; %s", RelocInfo::RelocModeName(rmode));
254 : }
255 : }
256 : DumpBuffer(os, &out);
257 : }
258 :
259 : // Emit comments following the last instruction (if any).
260 : if (it != NULL) {
261 : for ( ; !it->done(); it->next()) {
262 : if (RelocInfo::IsComment(it->rinfo()->rmode())) {
263 : out.AddFormatted(" %s",
264 : reinterpret_cast<const char*>(it->rinfo()->data()));
265 : DumpBuffer(os, &out);
266 : }
267 : }
268 : }
269 :
270 : delete it;
271 : return static_cast<int>(pc - begin);
272 : }
273 :
274 :
275 : int Disassembler::Decode(Isolate* isolate, std::ostream* os, byte* begin,
276 : byte* end, Code* code) {
277 : V8NameConverter v8NameConverter(code);
278 : return DecodeIt(isolate, os, v8NameConverter, begin, end);
279 : }
280 :
281 : #else // ENABLE_DISASSEMBLER
282 :
283 0 : int Disassembler::Decode(Isolate* isolate, std::ostream* os, byte* begin,
284 : byte* end, Code* code) {
285 0 : return 0;
286 : }
287 :
288 : #endif // ENABLE_DISASSEMBLER
289 :
290 : } // namespace internal
291 : } // namespace v8
|
