public DieFormalParameter(DieSubprogram parent, DwarfBinaryReader reader, CompilationUnit comp_unit, AbbrevEntry abbrev) : base(parent, reader, comp_unit, abbrev, null, false) { }
private long ReadEncodedValue(DwarfBinaryReader reader, int encoding) { long base_addr; switch (encoding & 0x70) { case 0: base_addr = 0; break; case (byte) DW_EH_PE.pcrel: base_addr = vma + reader.Position; break; default: throw new DwarfException ( reader.Bfd, "Unknown encoding `{0:x}' in CIE", encoding); } long value; switch (encoding & 0x0f) { case (byte) DW_EH_PE.udata4: value = reader.ReadUInt32 (); break; case (byte) DW_EH_PE.sdata4: value = reader.ReadInt32 (); break; default: throw new DwarfException ( reader.Bfd, "Unknown encoding `{0:x}' in CIE", encoding); } return base_addr + value; }
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; }
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 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); }
public DieVariable(DieSubprogram parent, DwarfBinaryReader reader, CompilationUnit comp_unit, AbbrevEntry abbrev, DieLexicalBlock lexical) : base(parent, reader, comp_unit, abbrev, lexical, true) { }
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 DieNamespace(DwarfBinaryReader reader, CompilationUnit comp_unit, long offset, AbbrevEntry abbrev) : base(reader, comp_unit, abbrev) { this.offset = offset; comp_unit.AddNamespace (offset, this); if (extension != null) { if (extension.name != null) { if (name != null) name = extension.name + "::" + name; else name = extension.name; } } }
protected override ArrayList ReadChildren(DwarfBinaryReader reader) { string old_ns = comp_unit.CurrentNamespace; if (name == null) comp_unit.CurrentNamespace = null; else if (comp_unit.CurrentNamespace != null) comp_unit.CurrentNamespace = comp_unit.CurrentNamespace + "::" + name; else comp_unit.CurrentNamespace = name; try { debug ("NS CHILDREN: {0} -> {1}", name, comp_unit.CurrentNamespace); return base.ReadChildren (reader); debug ("NS CHILDREN DONE: {0}", name); } finally { comp_unit.CurrentNamespace = old_ns; } }
public DieMember(DwarfBinaryReader reader, CompilationUnit comp_unit, AbbrevEntry abbrev) : base(reader, comp_unit, abbrev) { this.target_info = reader.TargetMemoryInfo; }
public DieMethodVariable(DieSubprogram subprog, DwarfBinaryReader reader, CompilationUnit comp_unit, AbbrevEntry abbrev, DieLexicalBlock lexical_block, bool is_local) : base(reader, comp_unit, abbrev) { this.subprog = subprog; this.lexical_block = lexical_block; if (subprog != null) { if (is_local) subprog.AddLocal (this); else subprog.AddParameter (this); } }
protected override Die CreateDie(DwarfBinaryReader reader, CompilationUnit comp_unit, long offset, AbbrevEntry abbrev) { switch (abbrev.Tag) { case DwarfTag.formal_parameter: return new DieFormalParameter (subprog, reader, comp_unit, abbrev); case DwarfTag.variable: return new DieVariable (subprog, reader, comp_unit, abbrev, this); case DwarfTag.lexical_block: return new DieLexicalBlock (subprog, reader, comp_unit, abbrev); default: debug ("LEXICAL BLOCK ({0}): unknown die: {1}", Offset, abbrev.Tag); return base.CreateDie (reader, comp_unit, offset, abbrev); } }
public DieLexicalBlock(DieSubprogram subprog, DwarfBinaryReader reader, CompilationUnit comp_unit, AbbrevEntry abbrev) : base(reader, comp_unit, abbrev) { this.subprog = subprog; }
public DieInheritance(DwarfBinaryReader reader, CompilationUnit comp_unit, AbbrevEntry abbrev) : base(reader, comp_unit, abbrev) { }
public DieTypedef(DwarfBinaryReader reader, CompilationUnit comp_unit, long offset, AbbrevEntry abbrev) : base(reader, comp_unit, offset, abbrev) { }
public DieStructureType(DwarfBinaryReader reader, CompilationUnit comp_unit, long offset, AbbrevEntry abbrev, bool is_union) : base(reader, comp_unit, offset, abbrev) { this.IsUnion = is_union; }
public DieVariable(DieSubprogram parent, DwarfBinaryReader reader, CompilationUnit comp_unit, AbbrevEntry abbrev) : base(parent, reader, comp_unit, abbrev, null, true) { }
protected override Die CreateDie(DwarfBinaryReader reader, CompilationUnit comp_unit, long offset, AbbrevEntry abbrev) { switch (abbrev.Tag) { case DwarfTag.inheritance: return new DieInheritance (reader, comp_unit, abbrev); default: return base.CreateDie (reader, comp_unit, offset, abbrev); } }
public DieVariableBase(DwarfBinaryReader reader, CompilationUnit comp_unit, AbbrevEntry abbrev) : base(reader, comp_unit, abbrev) { }
public DieSubprogram(DwarfBinaryReader reader, CompilationUnit comp_unit, long offset, AbbrevEntry abbrev) : base(reader, comp_unit, abbrev) { this.real_offset = offset; if ((start_pc != 0) && (end_pc != 0)) is_continuous = true; comp_unit.AddSubprogram (offset, this); }
public FileEntry(LineNumberEngine engine, DwarfBinaryReader reader) { FileName = reader.ReadString (); Directory = reader.ReadLeb128 (); LastModificationTime = reader.ReadLeb128 (); Length = reader.ReadLeb128 (); string dir_name; if (Directory > 0) dir_name = (string) engine.include_dirs [Directory - 1]; else dir_name = engine.compilation_dir; string full_name; if (dir_name != null) full_name = Path.Combine (dir_name, FileName); else full_name = FileName; File = engine.comp_unit.dwarf.GetSourceFile (full_name); }
protected override Die CreateDie(DwarfBinaryReader reader, CompilationUnit comp_unit, long offset, AbbrevEntry abbrev) { switch (abbrev.Tag) { case DwarfTag.formal_parameter: return new DieFormalParameter (this, reader, comp_unit, abbrev); case DwarfTag.variable: return new DieVariable (this, reader, comp_unit, abbrev); case DwarfTag.lexical_block: return new DieLexicalBlock (this, reader, comp_unit, abbrev); default: return base.CreateDie (reader, comp_unit, offset, abbrev); } }
Hashtable read_pubtypes() { if (debug_pubtypes_reader == null) return null; DwarfBinaryReader reader = new DwarfBinaryReader ( bfd, (TargetBlob) debug_pubtypes_reader.Data, Is64Bit); Hashtable names = Hashtable.Synchronized (new Hashtable ()); while (!reader.IsEof) { long length = reader.ReadInitialLength (); long stop = reader.Position + length; int version = reader.ReadInt16 (); long debug_offset = reader.ReadOffset (); reader.ReadOffset (); if (version != 2) throw new DwarfException ( bfd, "Wrong version in .debug_pubtypes: {0}", version); while (reader.Position < stop) { long offset = reader.ReadInt32 (); if (offset == 0) break; string name = reader.ReadString (); if (!names.Contains (name)) names.Add (name, new NameEntry (debug_offset, offset)); } } return names; }
public DieSubrangeType(DwarfBinaryReader reader, CompilationUnit comp_unit, AbbrevEntry abbrev) : base(reader, comp_unit, abbrev) { }
public StackFrame UnwindStack(StackFrame frame, TargetMemoryAccess target, Architecture arch) { if (frame.TargetAddress.IsNull) return null; TargetAddress address = frame.TargetAddress; DwarfBinaryReader reader = new DwarfBinaryReader (bfd, blob, false); while (reader.Position < reader.Size) { long length = reader.ReadInitialLength (); if (length == 0) break; long end_pos = reader.Position + length; long cie_pointer = reader.ReadOffset (); bool is_cie; if (is_ehframe) is_cie = cie_pointer == 0; else is_cie = cie_pointer == -1; if (is_cie) { reader.Position = end_pos; continue; } if (is_ehframe) cie_pointer = reader.Position - cie_pointer - target.TargetMemoryInfo.TargetAddressSize; CIE cie = find_cie (cie_pointer); long initial, range; if (is_ehframe) { initial = ReadEncodedValue (reader, cie.Encoding); range = ReadEncodedValue (reader, cie.Encoding & 0x0f); } else { initial = reader.ReadAddress (); range = reader.ReadAddress (); } TargetAddress start = new TargetAddress (target.AddressDomain, initial); if ((address < start) || (address > start + range)) { reader.Position = end_pos; continue; } Entry fde = new Entry (cie, start, address); fde.Read (reader, end_pos); return fde.Unwind (frame, target, arch); } return null; }
protected override Die CreateDie(DwarfBinaryReader reader, CompilationUnit comp_unit, long offset, AbbrevEntry abbrev) { switch (abbrev.Tag) { case DwarfTag.formal_parameter: return new DieFormalParameter (null, reader, comp_unit, abbrev); default: return base.CreateDie (reader, comp_unit, offset, abbrev); } }
public CIE(DwarfFrameReader frame, long offset, CIE next) { this.frame = frame; this.offset = offset; this.next = next; DwarfBinaryReader reader = new DwarfBinaryReader ( frame.bfd, frame.blob, false); read_cie (reader); }
public DieType(DwarfBinaryReader reader, CompilationUnit comp_unit, long offset, AbbrevEntry abbrev) : base(reader, comp_unit, abbrev) { this.offset = offset; this.language = reader.Bfd.NativeLanguage; comp_unit.AddType (offset, this); if (specification != null) { if ((name == null) && (specification.name != null)) name = specification.Name; } if (name != null) { if (comp_unit.CurrentNamespace != null) name = comp_unit.CurrentNamespace + "::" + name; comp_unit.DwarfReader.AddType (this); } }
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; } } }
public DieEnumerator(DwarfBinaryReader reader, CompilationUnit comp_unit, AbbrevEntry abbrev) : base(reader, comp_unit, abbrev) { }