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();
}