LCOV - code coverage report
Current view: top level - src - disassembler.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 0 2 0.0 %
Date: 2017-04-26 Functions: 0 1 0.0 %

          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

Generated by: LCOV version 1.10