bool ELFHeader::Parse(lldb_private::DataExtractor &data, lldb::offset_t *offset) { // Read e_ident. This provides byte order and address size info. if (data.GetU8(offset, &e_ident, EI_NIDENT) == NULL) return false; const unsigned byte_size = Is32Bit() ? 4 : 8; data.SetByteOrder(GetByteOrder()); data.SetAddressByteSize(byte_size); // Read e_type and e_machine. if (data.GetU16(offset, &e_type, 2) == NULL) return false; // Read e_version. if (data.GetU32(offset, &e_version, 1) == NULL) return false; // Read e_entry, e_phoff and e_shoff. if (GetMaxU64(data, offset, &e_entry, byte_size, 3) == false) return false; // Read e_flags. if (data.GetU32(offset, &e_flags, 1) == NULL) return false; // Read e_ehsize, e_phentsize, e_phnum, e_shentsize, e_shnum and // e_shstrndx. if (data.GetU16(offset, &e_ehsize, 6) == NULL) return false; return true; }
lldb::offset_t DWARFMappedHash::Prologue::Read (const lldb_private::DataExtractor &data, lldb::offset_t offset) { ClearAtoms (); die_base_offset = data.GetU32 (&offset); const uint32_t atom_count = data.GetU32 (&offset); if (atom_count == 0x00060003u) { // Old format, deal with contents of old pre-release format while (data.GetU32(&offset)) /* do nothing */; // Hardcode to the only known value for now. AppendAtom (eAtomTypeDIEOffset, DW_FORM_data4); } else { for (uint32_t i=0; i<atom_count; ++i) { AtomType type = (AtomType)data.GetU16 (&offset); dw_form_t form = (dw_form_t)data.GetU16 (&offset); AppendAtom (type, form); } } return offset; }
bool ELFSymbol::Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset) { const unsigned byte_size = data.GetAddressByteSize(); const bool parsing_32 = byte_size == 4; // Read st_name. if (data.GetU32(offset, &st_name, 1) == NULL) return false; if (parsing_32) { // Read st_value and st_size. if (GetMaxU64(data, offset, &st_value, byte_size, 2) == false) return false; // Read st_info and st_other. if (data.GetU8(offset, &st_info, 2) == NULL) return false; // Read st_shndx. if (data.GetU16(offset, &st_shndx, 1) == NULL) return false; } else { // Read st_info and st_other. if (data.GetU8(offset, &st_info, 2) == NULL) return false; // Read st_shndx. if (data.GetU16(offset, &st_shndx, 1) == NULL) return false; // Read st_value and st_size. if (data.GetU64(offset, &st_value, 2) == NULL) return false; } return true; }
virtual size_t Decode (const lldb_private::Disassembler &disassembler, const lldb_private::DataExtractor &data, lldb::offset_t data_offset) { // All we have to do is read the opcode which can be easy for some // architectures bool got_op = false; DisassemblerLLVMC &llvm_disasm = GetDisassemblerLLVMC(); const ArchSpec &arch = llvm_disasm.GetArchitecture(); const lldb::ByteOrder byte_order = data.GetByteOrder(); const uint32_t min_op_byte_size = arch.GetMinimumOpcodeByteSize(); const uint32_t max_op_byte_size = arch.GetMaximumOpcodeByteSize(); if (min_op_byte_size == max_op_byte_size) { // Fixed size instructions, just read that amount of data. if (!data.ValidOffsetForDataOfSize(data_offset, min_op_byte_size)) return false; switch (min_op_byte_size) { case 1: m_opcode.SetOpcode8 (data.GetU8 (&data_offset), byte_order); got_op = true; break; case 2: m_opcode.SetOpcode16 (data.GetU16 (&data_offset), byte_order); got_op = true; break; case 4: m_opcode.SetOpcode32 (data.GetU32 (&data_offset), byte_order); got_op = true; break; case 8: m_opcode.SetOpcode64 (data.GetU64 (&data_offset), byte_order); got_op = true; break; default: m_opcode.SetOpcodeBytes(data.PeekData(data_offset, min_op_byte_size), min_op_byte_size); got_op = true; break; } } if (!got_op) { bool is_alternate_isa = false; DisassemblerLLVMC::LLVMCDisassembler *mc_disasm_ptr = GetDisasmToUse (is_alternate_isa); const llvm::Triple::ArchType machine = arch.GetMachine(); if (machine == llvm::Triple::arm || machine == llvm::Triple::thumb) { if (machine == llvm::Triple::thumb || is_alternate_isa) { uint32_t thumb_opcode = data.GetU16(&data_offset); if ((thumb_opcode & 0xe000) != 0xe000 || ((thumb_opcode & 0x1800u) == 0)) { m_opcode.SetOpcode16 (thumb_opcode, byte_order); m_is_valid = true; } else { thumb_opcode <<= 16; thumb_opcode |= data.GetU16(&data_offset); m_opcode.SetOpcode16_2 (thumb_opcode, byte_order); m_is_valid = true; } } else { m_opcode.SetOpcode32 (data.GetU32(&data_offset), byte_order); m_is_valid = true; } } else { // The opcode isn't evenly sized, so we need to actually use the llvm // disassembler to parse it and get the size. uint8_t *opcode_data = const_cast<uint8_t *>(data.PeekData (data_offset, 1)); const size_t opcode_data_len = data.BytesLeft(data_offset); const addr_t pc = m_address.GetFileAddress(); llvm::MCInst inst; llvm_disasm.Lock(this, NULL); const size_t inst_size = mc_disasm_ptr->GetMCInst(opcode_data, opcode_data_len, pc, inst); llvm_disasm.Unlock(); if (inst_size == 0) m_opcode.Clear(); else { m_opcode.SetOpcodeBytes(opcode_data, inst_size); m_is_valid = true; } } } return m_opcode.GetByteSize(); }
virtual size_t Decode (const lldb_private::Disassembler &disassembler, const lldb_private::DataExtractor &data, uint32_t data_offset) { // All we have to do is read the opcode which can be easy for some // architetures bool got_op = false; const ArchSpec &arch = m_disasm.GetArchitecture(); const uint32_t min_op_byte_size = arch.GetMinimumOpcodeByteSize(); const uint32_t max_op_byte_size = arch.GetMaximumOpcodeByteSize(); if (min_op_byte_size == max_op_byte_size) { // Fixed size instructions, just read that amount of data. if (!data.ValidOffsetForDataOfSize(data_offset, min_op_byte_size)) return false; switch (min_op_byte_size) { case 1: m_opcode.SetOpcode8 (data.GetU8 (&data_offset)); got_op = true; break; case 2: m_opcode.SetOpcode16 (data.GetU16 (&data_offset)); got_op = true; break; case 4: m_opcode.SetOpcode32 (data.GetU32 (&data_offset)); got_op = true; break; case 8: m_opcode.SetOpcode64 (data.GetU64 (&data_offset)); got_op = true; break; default: m_opcode.SetOpcodeBytes(data.PeekData(data_offset, min_op_byte_size), min_op_byte_size); got_op = true; break; } } if (!got_op) { ::LLVMDisasmContextRef disasm_context = m_disasm.m_disasm_context; bool is_altnernate_isa = false; if (m_disasm.m_alternate_disasm_context) { const AddressClass address_class = GetAddressClass (); if (address_class == eAddressClassCodeAlternateISA) { disasm_context = m_disasm.m_alternate_disasm_context; is_altnernate_isa = true; } } const llvm::Triple::ArchType machine = arch.GetMachine(); if (machine == llvm::Triple::arm || machine == llvm::Triple::thumb) { if (machine == llvm::Triple::thumb || is_altnernate_isa) { uint32_t thumb_opcode = data.GetU16(&data_offset); if ((thumb_opcode & 0xe000) != 0xe000 || ((thumb_opcode & 0x1800u) == 0)) { m_opcode.SetOpcode16 (thumb_opcode); } else { thumb_opcode <<= 16; thumb_opcode |= data.GetU16(&data_offset); m_opcode.SetOpcode32 (thumb_opcode); m_is_valid = true; } } else { m_opcode.SetOpcode32 (data.GetU32(&data_offset)); } } else { // The opcode isn't evenly sized, so we need to actually use the llvm // disassembler to parse it and get the size. char out_string[512]; m_disasm.Lock(this, NULL); uint8_t *opcode_data = const_cast<uint8_t *>(data.PeekData (data_offset, 1)); const size_t opcode_data_len = data.GetByteSize() - data_offset; const addr_t pc = m_address.GetFileAddress(); const size_t inst_size = ::LLVMDisasmInstruction (disasm_context, opcode_data, opcode_data_len, pc, // PC value out_string, sizeof(out_string)); // The address lookup function could have caused us to fill in our comment m_comment.clear(); m_disasm.Unlock(); if (inst_size == 0) m_opcode.Clear(); else { m_opcode.SetOpcodeBytes(opcode_data, inst_size); m_is_valid = true; } } } return m_opcode.GetByteSize(); }