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
21namespace v8 {
22namespace internal {
23
24#ifdef ENABLE_DISASSEMBLER
25
26class 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
39const 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_, "%s  (%p)", name, static_cast<void*>(pc));
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_, "%d  (%p)", offs, static_cast<void*>(pc));
53      return v8_buffer_.start();
54    }
55  }
56
57  return disasm::NameConverter::NameOfAddress(pc);
58}
59
60
61const 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
68static void DumpBuffer(std::ostream* os, StringBuilder* out) {
69  (*os) << out->Finalize() << std::endl;
70  out->Reset();
71}
72
73
74static const int kOutBufferSize = 2048 + String::kMaxShortPrintLength;
75static const int kRelocInfoPosition = 57;
76
77static 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" V8PRIdPTRDIFF "  ", 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(isolate, pcs[i], rmodes[i], datas[i],
164                          converter.code());
165
166      // Indent the printing of the reloc info.
167      if (i == 0) {
168        // The first reloc info is printed after the disassembled instruction.
169        out.AddPadding(' ', kRelocInfoPosition - out.position());
170      } else {
171        // Additional reloc infos are printed on separate lines.
172        DumpBuffer(os, &out);
173        out.AddPadding(' ', kRelocInfoPosition);
174      }
175
176      RelocInfo::Mode rmode = relocinfo.rmode();
177      if (rmode == RelocInfo::DEOPT_SCRIPT_OFFSET) {
178        out.AddFormatted("    ;; debug: deopt position, script offset '%d'",
179                         static_cast<int>(relocinfo.data()));
180      } else if (rmode == RelocInfo::DEOPT_INLINING_ID) {
181        out.AddFormatted("    ;; debug: deopt position, inlining id '%d'",
182                         static_cast<int>(relocinfo.data()));
183      } else if (rmode == RelocInfo::DEOPT_REASON) {
184        DeoptimizeReason reason =
185            static_cast<DeoptimizeReason>(relocinfo.data());
186        out.AddFormatted("    ;; debug: deopt reason '%s'",
187                         DeoptimizeReasonToString(reason));
188      } else if (rmode == RelocInfo::DEOPT_ID) {
189        out.AddFormatted("    ;; debug: deopt index %d",
190                         static_cast<int>(relocinfo.data()));
191      } else if (rmode == RelocInfo::EMBEDDED_OBJECT) {
192        HeapStringAllocator allocator;
193        StringStream accumulator(&allocator);
194        relocinfo.target_object()->ShortPrint(&accumulator);
195        std::unique_ptr<char[]> obj_name = accumulator.ToCString();
196        out.AddFormatted("    ;; object: %s", obj_name.get());
197      } else if (rmode == RelocInfo::EXTERNAL_REFERENCE) {
198        const char* reference_name = ref_encoder.NameOfAddress(
199            isolate, relocinfo.target_external_reference());
200        out.AddFormatted("    ;; external reference (%s)", reference_name);
201      } else if (RelocInfo::IsCodeTarget(rmode)) {
202        out.AddFormatted("    ;; code:");
203        Code* code = Code::GetCodeFromTargetAddress(relocinfo.target_address());
204        Code::Kind kind = code->kind();
205        if (code->is_inline_cache_stub()) {
206          out.AddFormatted(" %s", Code::Kind2String(kind));
207          if (!IC::ICUseVector(kind)) {
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
275int 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
283int Disassembler::Decode(Isolate* isolate, std::ostream* os, byte* begin,
284                         byte* end, Code* code) {
285  return 0;
286}
287
288#endif  // ENABLE_DISASSEMBLER
289
290}  // namespace internal
291}  // namespace v8
292