| // Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| #ifndef RUNTIME_VM_DWARF_H_ |
| #define RUNTIME_VM_DWARF_H_ |
| |
| #include "vm/allocation.h" |
| #include "vm/hash_map.h" |
| #include "vm/object.h" |
| #include "vm/zone.h" |
| |
| namespace dart { |
| |
| #ifdef DART_PRECOMPILER |
| |
| class Elf; |
| class InliningNode; |
| |
| struct ScriptIndexPair { |
| // Typedefs needed for the DirectChainedHashMap template. |
| typedef const Script* Key; |
| typedef intptr_t Value; |
| typedef ScriptIndexPair Pair; |
| |
| static Key KeyOf(Pair kv) { return kv.script_; } |
| |
| static Value ValueOf(Pair kv) { return kv.index_; } |
| |
| static inline intptr_t Hashcode(Key key) { |
| return String::Handle(key->url()).Hash(); |
| } |
| |
| static inline bool IsKeyEqual(Pair pair, Key key) { |
| return pair.script_->raw() == key->raw(); |
| } |
| |
| ScriptIndexPair(const Script* s, intptr_t index) : script_(s), index_(index) { |
| ASSERT(!s->IsNull()); |
| ASSERT(s->IsNotTemporaryScopedHandle()); |
| } |
| |
| ScriptIndexPair() : script_(NULL), index_(-1) {} |
| |
| void Print() const; |
| |
| const Script* script_; |
| intptr_t index_; |
| }; |
| |
| typedef DirectChainedHashMap<ScriptIndexPair> ScriptIndexMap; |
| |
| struct FunctionIndexPair { |
| // Typedefs needed for the DirectChainedHashMap template. |
| typedef const Function* Key; |
| typedef intptr_t Value; |
| typedef FunctionIndexPair Pair; |
| |
| static Key KeyOf(Pair kv) { return kv.function_; } |
| |
| static Value ValueOf(Pair kv) { return kv.index_; } |
| |
| static inline intptr_t Hashcode(Key key) { return key->token_pos().value(); } |
| |
| static inline bool IsKeyEqual(Pair pair, Key key) { |
| return pair.function_->raw() == key->raw(); |
| } |
| |
| FunctionIndexPair(const Function* f, intptr_t index) |
| : function_(f), index_(index) { |
| ASSERT(!f->IsNull()); |
| ASSERT(f->IsNotTemporaryScopedHandle()); |
| } |
| |
| FunctionIndexPair() : function_(NULL), index_(-1) {} |
| |
| void Print() const; |
| |
| const Function* function_; |
| intptr_t index_; |
| }; |
| |
| typedef DirectChainedHashMap<FunctionIndexPair> FunctionIndexMap; |
| |
| struct CodeIndexPair { |
| // Typedefs needed for the DirectChainedHashMap template. |
| typedef const Code* Key; |
| typedef intptr_t Value; |
| typedef CodeIndexPair Pair; |
| |
| static Key KeyOf(Pair kv) { return kv.code_; } |
| |
| static Value ValueOf(Pair kv) { return kv.index_; } |
| |
| static inline intptr_t Hashcode(Key key) { |
| // Code objects are always allocated in old space, so they don't move. |
| return key->PayloadStart(); |
| } |
| |
| static inline bool IsKeyEqual(Pair pair, Key key) { |
| return pair.code_->raw() == key->raw(); |
| } |
| |
| CodeIndexPair(const Code* c, intptr_t index) : code_(c), index_(index) { |
| ASSERT(!c->IsNull()); |
| ASSERT(c->IsNotTemporaryScopedHandle()); |
| } |
| |
| CodeIndexPair() : code_(NULL), index_(-1) {} |
| |
| void Print() const; |
| |
| const Code* code_; |
| intptr_t index_; |
| }; |
| |
| typedef DirectChainedHashMap<CodeIndexPair> CodeIndexMap; |
| |
| class Dwarf : public ZoneAllocated { |
| public: |
| Dwarf(Zone* zone, StreamingWriteStream* stream, Elf* elf); |
| |
| void AddCode(const Code& code, intptr_t offset); |
| intptr_t AddCode(const Code& code); |
| intptr_t AddFunction(const Function& function); |
| intptr_t AddScript(const Script& script); |
| intptr_t LookupFunction(const Function& function); |
| intptr_t LookupScript(const Script& script); |
| |
| void Write() { |
| WriteAbbreviations(); |
| WriteCompilationUnit(); |
| WriteLines(); |
| } |
| |
| private: |
| static const intptr_t DW_TAG_compile_unit = 0x11; |
| static const intptr_t DW_TAG_inlined_subroutine = 0x1d; |
| static const intptr_t DW_TAG_subprogram = 0x2e; |
| |
| static const intptr_t DW_CHILDREN_no = 0x0; |
| static const intptr_t DW_CHILDREN_yes = 0x1; |
| |
| static const intptr_t DW_AT_sibling = 0x1; |
| static const intptr_t DW_AT_name = 0x3; |
| static const intptr_t DW_AT_stmt_list = 0x10; |
| static const intptr_t DW_AT_low_pc = 0x11; |
| static const intptr_t DW_AT_high_pc = 0x12; |
| static const intptr_t DW_AT_comp_dir = 0x1b; |
| static const intptr_t DW_AT_inline = 0x20; |
| static const intptr_t DW_AT_producer = 0x25; |
| static const intptr_t DW_AT_abstract_origin = 0x31; |
| static const intptr_t DW_AT_decl_column = 0x39; |
| static const intptr_t DW_AT_decl_file = 0x3a; |
| static const intptr_t DW_AT_decl_line = 0x3b; |
| static const intptr_t DW_AT_call_column = 0x57; |
| static const intptr_t DW_AT_call_file = 0x58; |
| static const intptr_t DW_AT_call_line = 0x59; |
| |
| static const intptr_t DW_FORM_addr = 0x01; |
| static const intptr_t DW_FORM_string = 0x08; |
| static const intptr_t DW_FORM_udata = 0x0f; |
| static const intptr_t DW_FORM_ref4 = 0x13; |
| static const intptr_t DW_FORM_ref_udata = 0x15; |
| static const intptr_t DW_FORM_sec_offset = 0x17; |
| |
| static const intptr_t DW_INL_not_inlined = 0x0; |
| static const intptr_t DW_INL_inlined = 0x1; |
| |
| static const intptr_t DW_LNS_copy = 0x1; |
| static const intptr_t DW_LNS_advance_pc = 0x2; |
| static const intptr_t DW_LNS_advance_line = 0x3; |
| static const intptr_t DW_LNS_set_file = 0x4; |
| |
| static const intptr_t DW_LNE_end_sequence = 0x01; |
| static const intptr_t DW_LNE_set_address = 0x02; |
| |
| enum { |
| kCompilationUnit = 1, |
| kAbstractFunction, |
| kConcreteFunction, |
| kInlinedFunction, |
| }; |
| |
| void Print(const char* format, ...) PRINTF_ATTRIBUTE(2, 3); |
| void sleb128(intptr_t value) { |
| if (asm_stream_) { |
| Print(".sleb128 %" Pd "\n", value); |
| } else { |
| bool is_last_part = false; |
| while (!is_last_part) { |
| uint8_t part = value & 0x7F; |
| value >>= 7; |
| if ((value == 0 && (part & 0x40) == 0) || |
| (value == static_cast<intptr_t>(-1) && (part & 0x40) != 0)) { |
| is_last_part = true; |
| } else { |
| part |= 0x80; |
| } |
| bin_stream_->WriteBytes(reinterpret_cast<const uint8_t*>(&part), |
| sizeof(part)); |
| } |
| } |
| } |
| void uleb128(uintptr_t value) { |
| if (asm_stream_) { |
| Print(".uleb128 %" Pd "\n", value); |
| } else { |
| bool is_last_part = false; |
| while (!is_last_part) { |
| uint8_t part = value & 0x7F; |
| value >>= 7; |
| if (value == 0) { |
| is_last_part = true; |
| } else { |
| part |= 0x80; |
| } |
| bin_stream_->WriteBytes(reinterpret_cast<const uint8_t*>(&part), |
| sizeof(part)); |
| } |
| } |
| } |
| void u1(uint8_t value) { |
| if (asm_stream_) { |
| Print(".byte %d\n", value); |
| } else { |
| bin_stream_->WriteBytes(reinterpret_cast<const uint8_t*>(&value), |
| sizeof(value)); |
| } |
| } |
| void u2(uint16_t value) { |
| if (asm_stream_) { |
| Print(".2byte %d\n", value); |
| } else { |
| bin_stream_->WriteBytes(reinterpret_cast<const uint8_t*>(&value), |
| sizeof(value)); |
| } |
| } |
| intptr_t u4(uint32_t value) { |
| if (asm_stream_) { |
| Print(".4byte %d\n", value); |
| return -1; |
| } else { |
| intptr_t fixup = position(); |
| bin_stream_->WriteBytes(reinterpret_cast<const uint8_t*>(&value), |
| sizeof(value)); |
| return fixup; |
| } |
| } |
| void fixup_u4(intptr_t position, uint32_t value) { |
| if (asm_stream_) { |
| UNREACHABLE(); |
| } else { |
| memmove(bin_stream_->buffer() + position, &value, sizeof(value)); |
| } |
| } |
| void addr(uword value) { |
| if (asm_stream_) { |
| UNREACHABLE(); |
| } else { |
| bin_stream_->WriteBytes(reinterpret_cast<const uint8_t*>(&value), |
| sizeof(value)); |
| } |
| } |
| void string(const char* cstr) { // NOLINT |
| if (asm_stream_) { |
| Print(".string \"%s\"\n", cstr); // NOLINT |
| } else { |
| bin_stream_->WriteBytes(reinterpret_cast<const uint8_t*>(cstr), |
| strlen(cstr) + 1); |
| } |
| } |
| intptr_t position() { |
| if (asm_stream_) { |
| UNREACHABLE(); |
| } else { |
| return bin_stream_->Position(); |
| } |
| } |
| |
| void WriteAbbreviations(); |
| void WriteCompilationUnit(); |
| void WriteAbstractFunctions(); |
| void WriteConcreteFunctions(); |
| InliningNode* ExpandInliningTree(const Code& code); |
| void WriteInliningNode(InliningNode* node, |
| intptr_t root_code_index, |
| const Script& parent_script); |
| void WriteLines(); |
| |
| Zone* const zone_; |
| Elf* const elf_; |
| StreamingWriteStream* asm_stream_; |
| WriteStream* bin_stream_; |
| ZoneGrowableArray<const Code*> codes_; |
| CodeIndexMap code_to_index_; |
| ZoneGrowableArray<const Function*> functions_; |
| FunctionIndexMap function_to_index_; |
| ZoneGrowableArray<const Script*> scripts_; |
| ScriptIndexMap script_to_index_; |
| uint32_t* abstract_origins_; |
| intptr_t temp_; |
| }; |
| |
| #endif // DART_PRECOMPILER |
| |
| } // namespace dart |
| |
| #endif // RUNTIME_VM_DWARF_H_ |