2014-04-24 11:44:22 +00:00
|
|
|
// Copyright 2011 the V8 project authors. All rights reserved.
|
2014-04-29 06:42:26 +00:00
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file.
|
2014-04-24 11:44:22 +00:00
|
|
|
|
2015-08-14 09:41:32 +00:00
|
|
|
#include "src/disassembler.h"
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2016-07-25 10:24:45 +00:00
|
|
|
#include <memory>
|
|
|
|
|
2017-02-23 11:46:29 +00:00
|
|
|
#include "src/assembler-inl.h"
|
2014-06-03 08:12:43 +00:00
|
|
|
#include "src/code-stubs.h"
|
|
|
|
#include "src/codegen.h"
|
2015-07-31 11:07:50 +00:00
|
|
|
#include "src/debug/debug.h"
|
2014-06-03 08:12:43 +00:00
|
|
|
#include "src/deoptimizer.h"
|
|
|
|
#include "src/disasm.h"
|
2016-06-09 16:46:12 +00:00
|
|
|
#include "src/ic/ic.h"
|
2014-06-03 08:12:43 +00:00
|
|
|
#include "src/macro-assembler.h"
|
2017-02-23 11:46:29 +00:00
|
|
|
#include "src/objects-inl.h"
|
2016-03-01 14:42:57 +00:00
|
|
|
#include "src/snapshot/serializer-common.h"
|
2014-06-03 08:12:43 +00:00
|
|
|
#include "src/string-stream.h"
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2009-05-25 10:05:56 +00:00
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
#ifdef ENABLE_DISASSEMBLER
|
|
|
|
|
|
|
|
class V8NameConverter: public disasm::NameConverter {
|
|
|
|
public:
|
|
|
|
explicit V8NameConverter(Code* code) : code_(code) {}
|
|
|
|
virtual const char* NameOfAddress(byte* pc) const;
|
2008-07-30 08:49:36 +00:00
|
|
|
virtual const char* NameInCode(byte* addr) const;
|
2008-07-03 15:10:15 +00:00
|
|
|
Code* code() const { return code_; }
|
|
|
|
private:
|
|
|
|
Code* code_;
|
2011-03-18 20:35:07 +00:00
|
|
|
|
|
|
|
EmbeddedVector<char, 128> v8_buffer_;
|
2008-07-03 15:10:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
const char* V8NameConverter::NameOfAddress(byte* pc) const {
|
[assembler] Introduce proper AssemblerBase::Print() for improved debuggability.
While working on frame elision, I wanted to disassemble codegen in the
debugger, as the code generation is progressing. I discovered we had a
"Print" member on the x64 assembler, without any implementation. I
pulled it up to AssemblerBase and gave it an implementation that
should work for the other architectures.
Also checked that ia32, x87, arm and arm64 assemblers didn't have
such an implementation - free Print.
Arm64 has a naming conflict with the v8::internal::Disassembler. I
renamed the arm64 type with a more specific name.
Opportunistically fixed a bug in the name converter. This debug-time
printer doesn't provide a Code object, which should be OK with the
name converters, by the looks of other APIs there. All this means is that
when using the Print() API, we just get addresses dumped without any
context (like what this address may be - a stub maybe, etc). This seems
fine for the scenario.
There may be other places that assume a Code object. Since this is
a diagnostics-only scenario, for codegen developers, I feel it is
reasonable to fix such other places as we find them.
Review URL: https://codereview.chromium.org/1431933003
Cr-Commit-Position: refs/heads/master@{#31869}
2015-11-09 05:39:20 +00:00
|
|
|
const char* name =
|
|
|
|
code_ == NULL ? NULL : code_->GetIsolate()->builtins()->Lookup(pc);
|
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
if (name != NULL) {
|
2016-05-24 10:45:23 +00:00
|
|
|
SNPrintF(v8_buffer_, "%s (%p)", name, static_cast<void*>(pc));
|
2011-03-18 20:35:07 +00:00
|
|
|
return v8_buffer_.start();
|
2008-07-03 15:10:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (code_ != NULL) {
|
2009-11-11 09:50:06 +00:00
|
|
|
int offs = static_cast<int>(pc - code_->instruction_start());
|
2008-07-03 15:10:15 +00:00
|
|
|
// print as code offset, if it seems reasonable
|
|
|
|
if (0 <= offs && offs < code_->instruction_size()) {
|
2016-05-24 10:45:23 +00:00
|
|
|
SNPrintF(v8_buffer_, "%d (%p)", offs, static_cast<void*>(pc));
|
2011-03-18 20:35:07 +00:00
|
|
|
return v8_buffer_.start();
|
2008-07-03 15:10:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return disasm::NameConverter::NameOfAddress(pc);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-30 08:49:36 +00:00
|
|
|
const char* V8NameConverter::NameInCode(byte* addr) const {
|
|
|
|
// The V8NameConverter is used for well known code, so we can "safely"
|
|
|
|
// dereference pointers in generated code.
|
|
|
|
return (code_ != NULL) ? reinterpret_cast<const char*>(addr) : "";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-09-30 10:29:32 +00:00
|
|
|
static void DumpBuffer(std::ostream* os, StringBuilder* out) {
|
|
|
|
(*os) << out->Finalize() << std::endl;
|
2011-08-11 12:52:37 +00:00
|
|
|
out->Reset();
|
2008-07-03 15:10:15 +00:00
|
|
|
}
|
|
|
|
|
2011-08-11 12:52:37 +00:00
|
|
|
|
2009-03-19 11:57:18 +00:00
|
|
|
static const int kOutBufferSize = 2048 + String::kMaxShortPrintLength;
|
2008-07-03 15:10:15 +00:00
|
|
|
static const int kRelocInfoPosition = 57;
|
|
|
|
|
2014-09-30 10:29:32 +00:00
|
|
|
static int DecodeIt(Isolate* isolate, std::ostream* os,
|
2014-09-25 08:33:24 +00:00
|
|
|
const V8NameConverter& converter, byte* begin, byte* end) {
|
2013-06-03 15:32:22 +00:00
|
|
|
SealHandleScope shs(isolate);
|
|
|
|
DisallowHeapAllocation no_alloc;
|
2013-09-03 11:54:08 +00:00
|
|
|
ExternalReferenceEncoder ref_encoder(isolate);
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2008-09-11 14:34:48 +00:00
|
|
|
v8::internal::EmbeddedVector<char, 128> decode_buffer;
|
|
|
|
v8::internal::EmbeddedVector<char, kOutBufferSize> out_buffer;
|
2011-08-11 13:59:29 +00:00
|
|
|
StringBuilder out(out_buffer.start(), out_buffer.length());
|
2008-07-03 15:10:15 +00:00
|
|
|
byte* pc = begin;
|
|
|
|
disasm::Disassembler d(converter);
|
|
|
|
RelocIterator* it = NULL;
|
|
|
|
if (converter.code() != NULL) {
|
|
|
|
it = new RelocIterator(converter.code());
|
|
|
|
} else {
|
|
|
|
// No relocation information when printing code stubs.
|
|
|
|
}
|
2008-07-30 08:49:36 +00:00
|
|
|
int constants = -1; // no constants being decoded at the start
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
while (pc < end) {
|
|
|
|
// First decode instruction so that we know its length.
|
|
|
|
byte* prev_pc = pc;
|
2008-07-30 08:49:36 +00:00
|
|
|
if (constants > 0) {
|
2014-06-13 16:43:27 +00:00
|
|
|
SNPrintF(decode_buffer,
|
|
|
|
"%08x constant",
|
|
|
|
*reinterpret_cast<int32_t*>(pc));
|
2008-07-30 08:49:36 +00:00
|
|
|
constants--;
|
|
|
|
pc += 4;
|
|
|
|
} else {
|
|
|
|
int num_const = d.ConstantPoolSizeAt(pc);
|
|
|
|
if (num_const >= 0) {
|
2014-06-13 16:43:27 +00:00
|
|
|
SNPrintF(decode_buffer,
|
2015-07-03 10:32:27 +00:00
|
|
|
"%08x constant pool begin (num_const = %d)",
|
|
|
|
*reinterpret_cast<int32_t*>(pc), num_const);
|
2008-07-30 08:49:36 +00:00
|
|
|
constants = num_const;
|
|
|
|
pc += 4;
|
2008-09-18 11:59:55 +00:00
|
|
|
} else if (it != NULL && !it->done() && it->rinfo()->pc() == pc &&
|
2008-09-22 13:57:03 +00:00
|
|
|
it->rinfo()->rmode() == RelocInfo::INTERNAL_REFERENCE) {
|
2008-09-18 11:59:55 +00:00
|
|
|
// raw pointer embedded in code stream, e.g., jump table
|
|
|
|
byte* ptr = *reinterpret_cast<byte**>(pc);
|
2016-04-12 16:13:08 +00:00
|
|
|
SNPrintF(
|
|
|
|
decode_buffer, "%08" V8PRIxPTR " jump table entry %4" PRIuS,
|
|
|
|
reinterpret_cast<intptr_t>(ptr), static_cast<size_t>(ptr - begin));
|
2015-02-09 08:56:01 +00:00
|
|
|
pc += sizeof(ptr);
|
2008-07-30 08:49:36 +00:00
|
|
|
} else {
|
|
|
|
decode_buffer[0] = '\0';
|
2008-09-11 14:34:48 +00:00
|
|
|
pc += d.InstructionDecode(decode_buffer, pc);
|
2008-07-30 08:49:36 +00:00
|
|
|
}
|
|
|
|
}
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
// Collect RelocInfo for this instruction (prev_pc .. pc-1)
|
|
|
|
List<const char*> comments(4);
|
|
|
|
List<byte*> pcs(1);
|
2008-09-22 13:57:03 +00:00
|
|
|
List<RelocInfo::Mode> rmodes(1);
|
2008-07-03 15:10:15 +00:00
|
|
|
List<intptr_t> datas(1);
|
|
|
|
if (it != NULL) {
|
|
|
|
while (!it->done() && it->rinfo()->pc() < pc) {
|
2008-09-22 13:57:03 +00:00
|
|
|
if (RelocInfo::IsComment(it->rinfo()->rmode())) {
|
2008-07-03 15:10:15 +00:00
|
|
|
// For comments just collect the text.
|
|
|
|
comments.Add(reinterpret_cast<const char*>(it->rinfo()->data()));
|
|
|
|
} else {
|
|
|
|
// For other reloc info collect all data.
|
|
|
|
pcs.Add(it->rinfo()->pc());
|
|
|
|
rmodes.Add(it->rinfo()->rmode());
|
|
|
|
datas.Add(it->rinfo()->data());
|
|
|
|
}
|
|
|
|
it->next();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Comments.
|
|
|
|
for (int i = 0; i < comments.length(); i++) {
|
2011-08-11 12:52:37 +00:00
|
|
|
out.AddFormatted(" %s", comments[i]);
|
2014-09-25 08:33:24 +00:00
|
|
|
DumpBuffer(os, &out);
|
2008-07-03 15:10:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Instruction address and instruction offset.
|
2016-05-24 10:45:23 +00:00
|
|
|
out.AddFormatted("%p %4" V8PRIdPTRDIFF " ", static_cast<void*>(prev_pc),
|
|
|
|
prev_pc - begin);
|
2008-07-03 15:10:15 +00:00
|
|
|
|
2008-07-30 08:49:36 +00:00
|
|
|
// Instruction.
|
2008-09-11 14:34:48 +00:00
|
|
|
out.AddFormatted("%s", decode_buffer.start());
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
// Print all the reloc info for this instruction which are not comments.
|
|
|
|
for (int i = 0; i < pcs.length(); i++) {
|
|
|
|
// Put together the reloc info
|
2015-11-27 12:18:38 +00:00
|
|
|
RelocInfo relocinfo(isolate, pcs[i], rmodes[i], datas[i],
|
|
|
|
converter.code());
|
2008-07-03 15:10:15 +00:00
|
|
|
|
|
|
|
// Indent the printing of the reloc info.
|
|
|
|
if (i == 0) {
|
|
|
|
// The first reloc info is printed after the disassembled instruction.
|
2008-07-30 08:49:36 +00:00
|
|
|
out.AddPadding(' ', kRelocInfoPosition - out.position());
|
2008-07-03 15:10:15 +00:00
|
|
|
} else {
|
|
|
|
// Additional reloc infos are printed on separate lines.
|
2014-09-25 08:33:24 +00:00
|
|
|
DumpBuffer(os, &out);
|
2008-07-30 08:49:36 +00:00
|
|
|
out.AddPadding(' ', kRelocInfoPosition);
|
2008-07-03 15:10:15 +00:00
|
|
|
}
|
|
|
|
|
2008-09-22 13:57:03 +00:00
|
|
|
RelocInfo::Mode rmode = relocinfo.rmode();
|
This CL enables precise source positions for all V8 compilers. It merges compiler::SourcePosition and internal::SourcePosition to a single class used throughout the codebase. The new internal::SourcePosition instances store an id identifying an inlined function in addition to a script offset.
SourcePosition::InliningId() refers to a the new table DeoptimizationInputData::InliningPositions(), which provides the following data for every inlining id:
- The inlined SharedFunctionInfo as an offset into DeoptimizationInfo::LiteralArray
- The SourcePosition of the inlining. Recursively, this yields the full inlining stack.
Before the Code object is created, the same information can be found in CompilationInfo::inlined_functions().
If SourcePosition::InliningId() is SourcePosition::kNotInlined, it refers to the outer (non-inlined) function.
So every SourcePosition has full information about its inlining stack, as long as the corresponding Code object is known. The internal represenation of a source position is a positive 64bit integer.
All compilers create now appropriate source positions for inlined functions. In the case of Turbofan, this required using AstGraphBuilderWithPositions for inlined functions too. So this class is now moved to a header file.
At the moment, the additional information in source positions is only used in --trace-deopt and --code-comments. The profiler needs to be updated, at the moment it gets the correct script offsets from the deopt info, but the wrong script id from the reconstructed deopt stack, which can lead to wrong outputs. This should be resolved by making the profiler use the new inlining information for deopts.
I activated the inlined deoptimization tests in test-cpu-profiler.cc for Turbofan, changing them to a case where the deopt stack and the inlining position agree. It is currently still broken for other cases.
The following additional changes were necessary:
- The source position table (internal::SourcePositionTableBuilder etc.) supports now 64bit source positions. Encoding source positions in a single 64bit int together with the difference encoding in the source position table results in very little overhead for the inlining id, since only 12% of the source positions in Octane have a changed inlining id.
- The class HPositionInfo was effectively dead code and is now removed.
- SourcePosition has new printing and information facilities, including computing a full inlining stack.
- I had to rename compiler/source-position.{h,cc} to compiler/compiler-source-position-table.{h,cc} to avoid clashes with the new src/source-position.cc file.
- I wrote the new wrapper PodArray for ByteArray. It is a template working with any POD-type. This is used in DeoptimizationInputData::InliningPositions().
- I removed HInlinedFunctionInfo and HGraph::inlined_function_infos, because they were only used for the now obsolete Crankshaft inlining ids.
- Crankshaft managed a list of inlined functions in Lithium: LChunk::inlined_functions. This is an analog structure to CompilationInfo::inlined_functions. So I removed LChunk::inlined_functions and made Crankshaft use CompilationInfo::inlined_functions instead, because this was necessary to register the offsets into the literal array in a uniform way. This is a safe change because LChunk::inlined_functions has no other uses and the functions in CompilationInfo::inlined_functions have a strictly longer lifespan, being created earlier (in Hydrogen already).
BUG=v8:5432
Review-Url: https://codereview.chromium.org/2451853002
Cr-Commit-Position: refs/heads/master@{#40975}
2016-11-14 17:21:37 +00:00
|
|
|
if (rmode == RelocInfo::DEOPT_SCRIPT_OFFSET) {
|
|
|
|
out.AddFormatted(" ;; debug: deopt position, script offset '%d'",
|
|
|
|
static_cast<int>(relocinfo.data()));
|
|
|
|
} else if (rmode == RelocInfo::DEOPT_INLINING_ID) {
|
|
|
|
out.AddFormatted(" ;; debug: deopt position, inlining id '%d'",
|
2016-06-29 13:49:19 +00:00
|
|
|
static_cast<int>(relocinfo.data()));
|
2015-02-05 14:51:45 +00:00
|
|
|
} else if (rmode == RelocInfo::DEOPT_REASON) {
|
2016-07-18 09:23:28 +00:00
|
|
|
DeoptimizeReason reason =
|
|
|
|
static_cast<DeoptimizeReason>(relocinfo.data());
|
2015-02-05 14:51:45 +00:00
|
|
|
out.AddFormatted(" ;; debug: deopt reason '%s'",
|
2016-07-18 09:23:28 +00:00
|
|
|
DeoptimizeReasonToString(reason));
|
2016-05-11 14:05:41 +00:00
|
|
|
} else if (rmode == RelocInfo::DEOPT_ID) {
|
2016-05-13 08:49:49 +00:00
|
|
|
out.AddFormatted(" ;; debug: deopt index %d",
|
2016-05-11 14:05:41 +00:00
|
|
|
static_cast<int>(relocinfo.data()));
|
2008-09-22 13:57:03 +00:00
|
|
|
} else if (rmode == RelocInfo::EMBEDDED_OBJECT) {
|
2008-07-03 15:10:15 +00:00
|
|
|
HeapStringAllocator allocator;
|
|
|
|
StringStream accumulator(&allocator);
|
|
|
|
relocinfo.target_object()->ShortPrint(&accumulator);
|
2016-07-25 10:24:45 +00:00
|
|
|
std::unique_ptr<char[]> obj_name = accumulator.ToCString();
|
2013-12-09 07:41:20 +00:00
|
|
|
out.AddFormatted(" ;; object: %s", obj_name.get());
|
2008-09-22 13:57:03 +00:00
|
|
|
} else if (rmode == RelocInfo::EXTERNAL_REFERENCE) {
|
2015-03-06 08:15:03 +00:00
|
|
|
const char* reference_name = ref_encoder.NameOfAddress(
|
|
|
|
isolate, relocinfo.target_external_reference());
|
2008-07-30 08:49:36 +00:00
|
|
|
out.AddFormatted(" ;; external reference (%s)", reference_name);
|
2008-09-22 13:57:03 +00:00
|
|
|
} else if (RelocInfo::IsCodeTarget(rmode)) {
|
2008-09-17 12:38:50 +00:00
|
|
|
out.AddFormatted(" ;; code:");
|
2008-12-09 12:53:59 +00:00
|
|
|
Code* code = Code::GetCodeFromTargetAddress(relocinfo.target_address());
|
2008-09-17 12:38:50 +00:00
|
|
|
Code::Kind kind = code->kind();
|
|
|
|
if (code->is_inline_cache_stub()) {
|
2016-06-09 16:46:12 +00:00
|
|
|
out.AddFormatted(" %s", Code::Kind2String(kind));
|
|
|
|
if (!IC::ICUseVector(kind)) {
|
|
|
|
InlineCacheState ic_state = IC::StateFromCode(code);
|
|
|
|
out.AddFormatted(" %s", Code::ICState2String(ic_state));
|
|
|
|
}
|
2013-09-30 13:53:21 +00:00
|
|
|
} else if (kind == Code::STUB || kind == Code::HANDLER) {
|
2014-07-23 09:49:00 +00:00
|
|
|
// Get the STUB key and extract major and minor key.
|
|
|
|
uint32_t key = code->stub_key();
|
|
|
|
uint32_t minor_key = CodeStub::MinorKeyFromKey(key);
|
|
|
|
CodeStub::Major major_key = CodeStub::GetMajorKey(code);
|
2014-08-04 11:34:54 +00:00
|
|
|
DCHECK(major_key == CodeStub::MajorKeyFromKey(key));
|
2014-07-23 09:49:00 +00:00
|
|
|
out.AddFormatted(" %s, %s, ", Code::Kind2String(kind),
|
2015-08-24 10:23:39 +00:00
|
|
|
CodeStub::MajorName(major_key));
|
2015-07-10 08:49:14 +00:00
|
|
|
out.AddFormatted("minor: %d", minor_key);
|
2008-09-17 12:38:50 +00:00
|
|
|
} else {
|
|
|
|
out.AddFormatted(" %s", Code::Kind2String(kind));
|
2008-07-03 15:10:15 +00:00
|
|
|
}
|
2011-04-27 15:02:59 +00:00
|
|
|
if (rmode == RelocInfo::CODE_TARGET_WITH_ID) {
|
|
|
|
out.AddFormatted(" (id = %d)", static_cast<int>(relocinfo.data()));
|
|
|
|
}
|
2013-03-13 11:40:26 +00:00
|
|
|
} else if (RelocInfo::IsRuntimeEntry(rmode) &&
|
2013-02-25 14:46:09 +00:00
|
|
|
isolate->deoptimizer_data() != NULL) {
|
2010-12-07 11:31:57 +00:00
|
|
|
// A runtime entry reloinfo might be a deoptimization bailout.
|
|
|
|
Address addr = relocinfo.target_address();
|
2013-03-18 13:57:49 +00:00
|
|
|
int id = Deoptimizer::GetDeoptimizationId(isolate,
|
|
|
|
addr,
|
|
|
|
Deoptimizer::EAGER);
|
2010-12-07 11:31:57 +00:00
|
|
|
if (id == Deoptimizer::kNotDeoptimizationEntry) {
|
2013-03-18 13:57:49 +00:00
|
|
|
id = Deoptimizer::GetDeoptimizationId(isolate,
|
|
|
|
addr,
|
|
|
|
Deoptimizer::LAZY);
|
2012-12-18 16:25:45 +00:00
|
|
|
if (id == Deoptimizer::kNotDeoptimizationEntry) {
|
2013-05-14 11:45:33 +00:00
|
|
|
id = Deoptimizer::GetDeoptimizationId(isolate,
|
|
|
|
addr,
|
|
|
|
Deoptimizer::SOFT);
|
|
|
|
if (id == Deoptimizer::kNotDeoptimizationEntry) {
|
|
|
|
out.AddFormatted(" ;; %s", RelocInfo::RelocModeName(rmode));
|
|
|
|
} else {
|
|
|
|
out.AddFormatted(" ;; soft deoptimization bailout %d", id);
|
|
|
|
}
|
2012-12-18 16:25:45 +00:00
|
|
|
} else {
|
|
|
|
out.AddFormatted(" ;; lazy deoptimization bailout %d", id);
|
|
|
|
}
|
2010-12-07 11:31:57 +00:00
|
|
|
} else {
|
|
|
|
out.AddFormatted(" ;; deoptimization bailout %d", id);
|
|
|
|
}
|
2008-09-17 12:38:50 +00:00
|
|
|
} else {
|
|
|
|
out.AddFormatted(" ;; %s", RelocInfo::RelocModeName(rmode));
|
2008-07-03 15:10:15 +00:00
|
|
|
}
|
|
|
|
}
|
2014-09-25 08:33:24 +00:00
|
|
|
DumpBuffer(os, &out);
|
2008-07-03 15:10:15 +00:00
|
|
|
}
|
|
|
|
|
2011-08-11 13:59:29 +00:00
|
|
|
// Emit comments following the last instruction (if any).
|
|
|
|
if (it != NULL) {
|
|
|
|
for ( ; !it->done(); it->next()) {
|
|
|
|
if (RelocInfo::IsComment(it->rinfo()->rmode())) {
|
|
|
|
out.AddFormatted(" %s",
|
|
|
|
reinterpret_cast<const char*>(it->rinfo()->data()));
|
2014-09-25 08:33:24 +00:00
|
|
|
DumpBuffer(os, &out);
|
2011-08-11 13:59:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
delete it;
|
2009-11-11 09:50:06 +00:00
|
|
|
return static_cast<int>(pc - begin);
|
2008-07-03 15:10:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-09-30 10:29:32 +00:00
|
|
|
int Disassembler::Decode(Isolate* isolate, std::ostream* os, byte* begin,
|
|
|
|
byte* end, Code* code) {
|
2008-07-03 15:10:15 +00:00
|
|
|
V8NameConverter v8NameConverter(code);
|
2014-09-25 08:33:24 +00:00
|
|
|
return DecodeIt(isolate, os, v8NameConverter, begin, end);
|
2008-07-03 15:10:15 +00:00
|
|
|
}
|
2008-07-30 08:49:36 +00:00
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
#else // ENABLE_DISASSEMBLER
|
|
|
|
|
2014-09-30 10:29:32 +00:00
|
|
|
int Disassembler::Decode(Isolate* isolate, std::ostream* os, byte* begin,
|
|
|
|
byte* end, Code* code) {
|
2013-02-25 14:46:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2013-07-05 09:52:11 +00:00
|
|
|
|
2008-07-03 15:10:15 +00:00
|
|
|
#endif // ENABLE_DISASSEMBLER
|
|
|
|
|
2015-06-01 22:46:54 +00:00
|
|
|
} // namespace internal
|
|
|
|
} // namespace v8
|