public void Read(DwarfBinaryReader reader, long end_pos)
{
while (reader.Position < end_pos) {
byte first = reader.ReadByte ();
int opcode = first >> 6;
int low = first & 0x3f;
if (opcode == (int) DW_CFA.offset) {
int offset = reader.ReadLeb128 ();
offset *= cie.DataAlignment;
columns [low + 1].State = State.Offset;
columns [low + 1].Register = 0;
columns [low + 1].Offset = offset;
continue;
} else if (opcode == (int) DW_CFA.advance_loc) {
current_address += low;
if (current_address > address)
return;
continue;
} else if (opcode != 0) {
continue;
}
switch ((DW_CFA) low) {
case DW_CFA.nop:
break;
case DW_CFA.def_cfa:
columns [0].State = State.Register;
columns [0].Register = reader.ReadLeb128 ();
columns [0].Offset = reader.ReadLeb128 ();
break;
case DW_CFA.def_cfa_register:
columns [0].State = State.Register;
columns [0].Register = reader.ReadLeb128 ();
break;
case DW_CFA.def_cfa_offset:
columns [0].Offset = reader.ReadLeb128 ();
break;
case DW_CFA.gnu_args_size:
// Ignored.
reader.ReadLeb128 ();
break;
default:
break;
}
}
}
void read_cie(DwarfBinaryReader reader)
{
long length = reader.ReadInitialLength ();
long end_pos = reader.Position + length;
int id = reader.ReadInt32 ();
bool is_cie;
if (frame.is_ehframe)
is_cie = id == 0;
else
is_cie = id == -1;
if (!is_cie)
throw new InvalidOperationException ();
int version = reader.ReadByte ();
if (version != 1)
throw new DwarfException (
reader.Bfd, "Unknown version {0} in CIE",
version);
string augmentation = reader.ReadString ();
if (augmentation.StartsWith ("eh")) {
reader.ReadAddress ();
augmentation = augmentation.Substring (2);
}
code_alignment = reader.ReadLeb128 ();
data_alignment = reader.ReadSLeb128 ();
return_register = reader.ReadByte ();
for (int pos = 0; pos < augmentation.Length; pos++) {
if (augmentation [pos] == 'z') {
reader.ReadLeb128 ();
// has_z_augmentation = true;
continue;
}
if (augmentation [pos] == 'L')
continue;
else if (augmentation [pos] == 'R') {
encoding = reader.ReadByte ();
continue;
}
else if (augmentation [pos] == 'P') {
continue;
}
throw new DwarfException (
reader.Bfd, "Unknown augmentation `{0}' in CIE",
augmentation[pos]);
}
columns = new Column [return_register + 2];
for (int i = 0; i < columns.Length; i++)
columns [i] = new Column (State.Undefined);
Entry entry = new Entry (this);
entry.Read (reader, end_pos);
reader.Position = end_pos;
}
public AbbrevEntry(DwarfReader dwarf, DwarfBinaryReader reader)
{
abbrev_id = reader.ReadLeb128 ();
tag = (DwarfTag) reader.ReadLeb128 ();
has_children = reader.ReadByte () != 0;
Attributes = new ArrayList ();
do {
int attr = reader.ReadLeb128 ();
int form = reader.ReadLeb128 ();
if ((attr == 0) && (form == 0))
break;
Attributes.Add (new AttributeEntry (
dwarf, (DwarfAttribute) attr, (DwarfForm) form));
} while (true);
}
ArrayList read_aranges()
{
ArrayList ranges = new ArrayList ();
if (debug_aranges_reader == null)
return ranges;
DwarfBinaryReader reader = new DwarfBinaryReader (
bfd, (TargetBlob) debug_aranges_reader.Data, Is64Bit);
while (!reader.IsEof) {
long length = reader.ReadInitialLength ();
long stop = reader.Position + length;
int version = reader.ReadInt16 ();
long offset = reader.ReadOffset ();
int address_size = reader.ReadByte ();
int segment_size = reader.ReadByte ();
if ((address_size != 4) && (address_size != 8))
throw new DwarfException (
bfd, "Unknown address size: {0}", address_size);
if (segment_size != 0)
throw new DwarfException (
bfd, "Segmented address mode not supported");
if (version != 2)
throw new DwarfException (
bfd, "Wrong version in .debug_aranges: {0}",
version);
if (AddressSize == 8)
reader.Position = ((reader.Position+15) >> 4) * 16;
else
reader.Position = ((reader.Position+7) >> 3) * 8;
while (reader.Position < stop) {
long address = reader.ReadAddress ();
long size = reader.ReadAddress ();
if ((address == 0) && (size == 0))
break;
TargetAddress taddress = GetAddress (address);
ranges.Add (new RangeEntry (this, offset, taddress, size));
}
}
return ranges;
}
public LineNumberEngine(DieCompileUnit comp_unit, long offset,
string compilation_dir)
{
this.comp_unit = comp_unit;
this.offset = offset;
this.reader = comp_unit.dwarf.DebugLineReader;
this.compilation_dir = compilation_dir;
debug ("NEW LNE: {0}", offset);
reader.Position = offset;
length = reader.ReadInitialLength ();
end_offset = reader.Position + length;
version = reader.ReadInt16 ();
header_length = reader.ReadOffset ();
data_offset = reader.Position + header_length;
minimum_insn_length = reader.ReadByte ();
default_is_stmt = reader.ReadByte () != 0;
line_base = (sbyte) reader.ReadByte ();
line_range = reader.ReadByte ();
opcode_base = reader.ReadByte ();
standard_opcode_lengths = new int [opcode_base - 1];
for (int i = 0; i < opcode_base - 1; i++)
standard_opcode_lengths [i] = reader.ReadByte ();
include_dirs = new ArrayList ();
while (reader.PeekByte () != 0)
include_dirs.Add (reader.ReadString ());
reader.Position++;
source_files = new ArrayList ();
while (reader.PeekByte () != 0)
source_files.Add (new FileEntry (this, reader));
reader.Position++;
const_add_pc_range = ((0xff - opcode_base) / line_range) *
minimum_insn_length;
debug ("NEW LNE #1: {0} {1} - {2} {3} {4}",
reader.Position, offset, length,
data_offset, end_offset);
lines = new ArrayList ();
stm = new StatementMachine (this, data_offset, end_offset);
Read ();
lines.Sort ();
addresses = new LineNumber [lines.Count];
lines.CopyTo (addresses, 0);
}
public CompilationUnit(DwarfReader dwarf, DwarfBinaryReader reader)
{
this.dwarf = dwarf;
real_start_offset = reader.Position;
unit_length = reader.ReadInitialLength ();
start_offset = reader.Position;
version = reader.ReadInt16 ();
abbrev_offset = reader.ReadOffset ();
address_size = reader.ReadByte ();
if (version < 2)
throw new DwarfException (
dwarf.bfd, "Wrong DWARF version: {0}",
version);
abbrevs = new Hashtable ();
types = new Hashtable ();
subprogs = new Hashtable ();
namespaces = new Dictionary<long,DieNamespace> ();
DwarfBinaryReader abbrev_reader = dwarf.DebugAbbrevReader;
abbrev_reader.Position = abbrev_offset;
while (abbrev_reader.PeekByte () != 0) {
AbbrevEntry entry = new AbbrevEntry (dwarf, abbrev_reader);
abbrevs.Add (entry.ID, entry);
}
comp_unit_die = Die.CreateDieCompileUnit (reader, this);
reader.Position = start_offset + unit_length;
}
