public SourceFileEntry(MonoSymbolFile file, string file_name) { this.file = file; this.file_name = file_name; this.Index = file.AddSource(this); this.creating = true; }
protected LineNumberTable(MonoSymbolFile file) { this.LineBase = file.OffsetTable.LineNumberTable_LineBase; this.LineRange = file.OffsetTable.LineNumberTable_LineRange; this.OpcodeBase = (byte)file.OffsetTable.LineNumberTable_OpcodeBase; this.MaxAddressIncrement = (int)(255 - this.OpcodeBase) / this.LineRange; }
public MonoSymbolWriter (Stream stream) { this.stream = stream; this.methods = new List<SourceMethodBuilder> (); this.sources = new List<SourceFileEntry> (); this.comp_units = new List<CompileUnitEntry> (); this.file = new MonoSymbolFile (); }
public CompileUnitEntry(MonoSymbolFile file, SourceFileEntry source) { this.file = file; this.source = source; this.Index = file.AddCompileUnit(this); this.creating = true; this.namespaces = new List<NamespaceEntry>(); }
public MonoSymbolWriter (string filename) { this.methods = new List<SourceMethodBuilder> (); this.sources = new List<SourceFileEntry> (); this.comp_units = new List<CompileUnitEntry> (); this.file = new MonoSymbolFile (); this.filename = filename + ".mdb"; }
public MonoSymbolWriter (string filename) { this.methods = new ArrayList (); this.sources = new ArrayList (); this.comp_units = new ArrayList (); this.current_method_stack = new Stack (); this.file = new MonoSymbolFile (); this.filename = filename + ".mdb"; }
internal NamespaceEntry(MonoSymbolFile file, MyBinaryReader reader) { this.Name = reader.ReadString(); this.Index = reader.ReadLeb128(); this.Parent = reader.ReadLeb128(); int count = reader.ReadLeb128(); this.UsingClauses = new string[count]; for (int i = 0; i < count; i++) { this.UsingClauses[i] = reader.ReadString(); } }
//internal void WriteData(MyBinaryWriter bw) //{ // this.DataOffset = (int)bw.BaseStream.Position; // bw.Write(this.file_name); // if (this.guid == null) // { // this.guid = Guid.NewGuid().ToByteArray(); // try // { // using (FileStream fs = new FileStream(this.file_name, FileMode.Open, FileAccess.Read)) // { // MD5 md5 = MD5.Create(); // this.hash = md5.ComputeHash(fs); // } // } // catch // { // this.hash = new byte[16]; // } // } // bw.Write(this.guid); // bw.Write(this.hash); // bw.Write(this.auto_generated ? 1 : 0); //} //internal void Write(BinaryWriter bw) //{ // bw.Write(this.Index); // bw.Write(this.DataOffset); //} internal SourceFileEntry(MonoSymbolFile file, MyBinaryReader reader) { this.file = file; this.Index = reader.ReadInt32(); this.DataOffset = reader.ReadInt32(); int old_pos = (int)reader.BaseStream.Position; reader.BaseStream.Position = (long)this.DataOffset; this.file_name = reader.ReadString(); //??this.guid = reader.ReadBytes(16); this.hash = reader.ReadBytes(16); this.auto_generated = (reader.ReadByte() == 1); reader.BaseStream.Position = (long)old_pos; }
internal MethodEntry(MonoSymbolFile file, CompileUnitEntry comp_unit, int token, ScopeVariable[] scope_vars, LocalVariableEntry[] locals, LineNumberEntry[] lines, CodeBlockEntry[] code_blocks, string real_name, MethodEntry.Flags flags, int namespace_id) { this.SymbolFile = file; this.real_name = real_name; this.locals = locals; this.code_blocks = code_blocks; this.scope_vars = scope_vars; this.flags = flags; this.index = -1; this.Token = token; this.CompileUnitIndex = comp_unit.Index; this.CompileUnit = comp_unit; this.NamespaceID = namespace_id; this.CheckLineNumberTable(lines); this.lnt = new LineNumberTable(file, lines); file.NumLineNumbers += lines.Length; int num_locals = (locals != null) ? locals.Length : 0; if (num_locals <= 32) { for (int i = 0; i < num_locals; i++) { string nm = locals[i].Name; for (int j = i + 1; j < num_locals; j++) { if (locals[j].Name == nm) { flags |= MethodEntry.Flags.LocalNamesAmbiguous; goto IL_108; } } } IL_108:; } else { Dictionary<string, LocalVariableEntry> local_names = new Dictionary<string, LocalVariableEntry>(); for (int k = 0; k < locals.Length; k++) { LocalVariableEntry local = locals[k]; if (local_names.ContainsKey(local.Name)) { flags |= MethodEntry.Flags.LocalNamesAmbiguous; break; } local_names.Add(local.Name, local); } } }
public void RewriteMdbFile (string inputFile) { if (!settings.Quiet) Console.WriteLine ("Processing {0}", inputFile); var input = MonoSymbolFile.ReadSymbolFile (inputFile); var output = new MonoSymbolFile (); foreach (var s in input.Sources) { var newFileName = settings.FileNamesOnly ? Path.Combine (Path.GetDirectoryName (s.FileName), settings.Replace (Path.GetFileName (s.FileName))) : settings.Replace (s.FileName); if (settings.Verbose) Console.WriteLine ("{0} -> {1}", s.FileName, newFileName); s.FileName = newFileName; output.AddSource (s); } foreach (var cu in input.CompileUnits) { cu.ReadAll (); output.AddCompileUnit (cu); } foreach (var m in input.Methods) { m.ReadAll (); output.AddMethod (m); } var mdbName = new FileInfo (inputFile).Name; var tmpMdb = Path.GetTempFileName (); var finalMdb = inputFile; if (settings.OutputDirectory != null) finalMdb = Path.Combine (settings.OutputDirectory, mdbName); using (var stream = new FileStream (tmpMdb, FileMode.Create)) { output.CreateSymbolFile (input.Guid, stream); } input.Dispose (); File.Delete (finalMdb); File.Move (tmpMdb, finalMdb); }
internal MethodEntry(MonoSymbolFile file, MyBinaryReader reader, int index) { this.SymbolFile = file; this.index = index; this.Token = reader.ReadInt32(); this.DataOffset = reader.ReadInt32(); this.LineNumberTableOffset = reader.ReadInt32(); long old_pos = reader.BaseStream.Position; reader.BaseStream.Position = (long)this.DataOffset; this.CompileUnitIndex = reader.ReadLeb128(); this.LocalVariableTableOffset = reader.ReadLeb128(); this.NamespaceID = reader.ReadLeb128(); this.CodeBlockTableOffset = reader.ReadLeb128(); this.ScopeVariableTableOffset = reader.ReadLeb128(); this.RealNameOffset = reader.ReadLeb128(); this.flags = (MethodEntry.Flags)reader.ReadLeb128(); reader.BaseStream.Position = old_pos; this.CompileUnit = file.GetCompileUnit(this.CompileUnitIndex); }
static void MdbRebase(string mdbFile, string toRemove) { #if WINDOWS_BUILD Console.Error.WriteLine ("Warning: skipping MDB rebasing of {0} (not supported on Windows)", mdbFile); #else using (var input = MonoSymbolFile.ReadSymbolFile (mdbFile)) { var output = new MonoSymbolFile (); foreach (var source in input.Sources) { source.FileName = Path.Combine ( Path.GetDirectoryName (source.FileName), Path.GetFileName (source.FileName).Replace (toRemove, String.Empty) ); output.AddSource (source); } foreach (var compileUnit in input.CompileUnits) { compileUnit.ReadAll (); output.AddCompileUnit (compileUnit); } foreach (var method in input.Methods) { method.ReadAll (); output.AddMethod (method); } var tmpMdb = Path.GetTempFileName (); using (var stream = new FileStream (tmpMdb, FileMode.Create)) output.CreateSymbolFile (input.Guid, stream); File.Delete (mdbFile); File.Move (tmpMdb, mdbFile); } #endif }
public void WriteDebugSymbol (MonoSymbolFile file) { if (debug_builder == null) return; var token = builder.GetToken (); int t = token.Token; #if STATIC if (ModuleBuilder.IsPseudoToken (t)) t = member.Module.Builder.ResolvePseudoToken (t); #endif debug_builder.DefineMethod (file, t); }
public override void WriteDebugSymbol (MonoSymbolFile file) { if (get != null) get.WriteDebugSymbol (file); if (set != null) set.WriteDebugSymbol (file); }
static void ConvertSymbolFileToXml (MonoSymbolFile symbolFile, string xmlFile) { using (XmlTextWriter writer = new XmlTextWriter (xmlFile, Encoding.UTF8)) { writer.Formatting = Formatting.Indented; writer.WriteStartDocument (); writer.WriteStartElement ("symbols"); writer.WriteStartElement ("files"); foreach (var file in symbolFile.Sources) { writer.WriteStartElement ("file"); writer.WriteAttributeString ("id", file.Index.ToString ()); writer.WriteAttributeString ("name", Path.GetFileName (file.FileName)); var checksum = file.Checksum; if (checksum != null) writer.WriteAttributeString ("checksum", ChecksumToString (checksum)); writer.WriteEndElement (); } writer.WriteEndElement (); writer.WriteStartElement ("methods"); foreach (var method in symbolFile.Methods) { writer.WriteStartElement ("method"); writer.WriteAttributeString ("token", IntToHex (method.Token)); var il_entries = method.GetLineNumberTable (); writer.WriteStartElement ("sequencepoints"); foreach (var entry in il_entries.LineNumbers) { writer.WriteStartElement ("entry"); writer.WriteAttributeString ("il", IntToHex (entry.Offset)); writer.WriteAttributeString ("row", entry.Row.ToString ()); writer.WriteAttributeString ("col", entry.Column.ToString ()); writer.WriteAttributeString ("file_ref", entry.File.ToString ()); writer.WriteAttributeString ("hidden", BoolToString (entry.IsHidden)); writer.WriteEndElement (); } writer.WriteEndElement (); writer.WriteStartElement ("locals"); foreach (var local in method.GetLocals ()) { writer.WriteStartElement ("entry"); writer.WriteAttributeString ("name", local.Name); writer.WriteAttributeString ("il_index", local.Index.ToString ()); writer.WriteAttributeString ("scope_ref", local.BlockIndex.ToString ()); writer.WriteEndElement (); } writer.WriteEndElement (); writer.WriteStartElement ("scopes"); foreach (var scope in method.GetCodeBlocks ()) { writer.WriteStartElement ("entry"); writer.WriteAttributeString ("index", scope.Index.ToString ()); writer.WriteAttributeString ("start", IntToHex (scope.StartOffset)); writer.WriteAttributeString ("end", IntToHex (scope.EndOffset)); writer.WriteEndElement (); } writer.WriteEndElement (); writer.WriteEndElement (); } writer.WriteEndElement (); writer.WriteEndElement (); writer.WriteEndDocument (); } }
public MdbReader (MonoSymbolFile symFile) { symbol_file = symFile; documents = new Dictionary<string, Document> (); }
public override void WriteDebugSymbol (MonoSymbolFile file) { if (debug_builder == null) return; var token = ConstructorBuilder.GetToken (); int t = token.Token; #if STATIC if (token.IsPseudoToken) t = Module.Builder.ResolvePseudoToken (t); #endif debug_builder.DefineMethod (file, t); }
public void DefineMethod (MonoSymbolFile file) { DefineMethod (file, method.Token); }
void DoRead (MonoSymbolFile file, MyBinaryReader br) { ArrayList lines = new ArrayList (); bool is_hidden = false, modified = false; int stm_line = 1, stm_offset = 0, stm_file = 1; while (true) { byte opcode = br.ReadByte (); if (opcode == 0) { byte size = br.ReadByte (); long end_pos = br.BaseStream.Position + size; opcode = br.ReadByte (); if (opcode == DW_LNE_end_sequence) { if (modified) lines.Add (new LineNumberEntry ( stm_file, stm_line, stm_offset, is_hidden)); break; } else if (opcode == DW_LNE_MONO_negate_is_hidden) { is_hidden = !is_hidden; modified = true; } else throw new MonoSymbolFileException ( "Unknown extended opcode {0:x} in LNT ({1})", opcode, file.FileName); br.BaseStream.Position = end_pos; continue; } else if (opcode < OpcodeBase) { switch (opcode) { case DW_LNS_copy: lines.Add (new LineNumberEntry ( stm_file, stm_line, stm_offset, is_hidden)); modified = false; break; case DW_LNS_advance_pc: stm_offset += br.ReadLeb128 (); modified = true; break; case DW_LNS_advance_line: stm_line += br.ReadLeb128 (); modified = true; break; case DW_LNS_set_file: stm_file = br.ReadLeb128 (); modified = true; break; case DW_LNS_const_add_pc: stm_offset += MaxAddressIncrement; modified = true; break; default: throw new MonoSymbolFileException ( "Unknown standard opcode {0:x} in LNT", opcode); } } else { opcode -= OpcodeBase; stm_offset += opcode / LineRange; stm_line += LineBase + (opcode % LineRange); lines.Add (new LineNumberEntry ( stm_file, stm_line, stm_offset, is_hidden)); modified = false; } } _line_numbers = new LineNumberEntry [lines.Count]; lines.CopyTo (_line_numbers, 0); }
public SourceFileEntry(MonoSymbolFile file, string sourceFile, byte [] guid, byte [] checksum) : this(file, sourceFile, sourceFile, guid, checksum) { }
internal void Write(MonoSymbolFile file, MyBinaryWriter bw) { bw.WriteLeb128(Index); bw.Write(Name); bw.WriteLeb128(BlockIndex); }
internal LocalVariableEntry(MonoSymbolFile file, MyBinaryReader reader) { Index = reader.ReadLeb128(); Name = reader.ReadString(); BlockIndex = reader.ReadLeb128(); }
internal void WriteData(MonoSymbolFile file, MyBinaryWriter bw) { if (index <= 0) { throw new InvalidOperationException(); } LocalVariableTableOffset = (int)bw.BaseStream.Position; int num_locals = locals != null ? locals.Length : 0; bw.WriteLeb128(num_locals); for (int i = 0; i < num_locals; i++) { locals [i].Write(file, bw); } file.LocalCount += num_locals; CodeBlockTableOffset = (int)bw.BaseStream.Position; int num_code_blocks = code_blocks != null ? code_blocks.Length : 0; bw.WriteLeb128(num_code_blocks); for (int i = 0; i < num_code_blocks; i++) { code_blocks [i].Write(bw); } ScopeVariableTableOffset = (int)bw.BaseStream.Position; int num_scope_vars = scope_vars != null ? scope_vars.Length : 0; bw.WriteLeb128(num_scope_vars); for (int i = 0; i < num_scope_vars; i++) { scope_vars [i].Write(bw); } if (real_name != null) { RealNameOffset = (int)bw.BaseStream.Position; bw.Write(real_name); } foreach (var lne in lnt.LineNumbers) { if (lne.EndRow != -1 || lne.EndColumn != -1) { flags |= Flags.EndInfoIncluded; } } LineNumberTableOffset = (int)bw.BaseStream.Position; lnt.Write(file, bw, (flags & Flags.ColumnsInfoIncluded) != 0, (flags & Flags.EndInfoIncluded) != 0); DataOffset = (int)bw.BaseStream.Position; bw.WriteLeb128(CompileUnitIndex); bw.WriteLeb128(LocalVariableTableOffset); bw.WriteLeb128(NamespaceID); bw.WriteLeb128(CodeBlockTableOffset); bw.WriteLeb128(ScopeVariableTableOffset); bw.WriteLeb128(RealNameOffset); bw.WriteLeb128((int)flags); }
internal MethodEntry(MonoSymbolFile file, CompileUnitEntry comp_unit, int token, ScopeVariable[] scope_vars, LocalVariableEntry[] locals, LineNumberEntry[] lines, CodeBlockEntry[] code_blocks, string real_name, Flags flags, int namespace_id) { this.SymbolFile = file; this.real_name = real_name; this.locals = locals; this.code_blocks = code_blocks; this.scope_vars = scope_vars; this.flags = flags; index = -1; Token = token; CompileUnitIndex = comp_unit.Index; CompileUnit = comp_unit; NamespaceID = namespace_id; CheckLineNumberTable(lines); lnt = new LineNumberTable(file, lines); file.NumLineNumbers += lines.Length; int num_locals = locals != null ? locals.Length : 0; if (num_locals <= 32) { // Most of the time, the O(n^2) factor is actually // less than the cost of allocating the hash table, // 32 is a rough number obtained through some testing. for (int i = 0; i < num_locals; i++) { string nm = locals [i].Name; for (int j = i + 1; j < num_locals; j++) { if (locals [j].Name == nm) { flags |= Flags.LocalNamesAmbiguous; goto locals_check_done; } } } locals_check_done: ; } else { var local_names = new Dictionary <string, LocalVariableEntry> (); foreach (LocalVariableEntry local in locals) { if (local_names.ContainsKey(local.Name)) { flags |= Flags.LocalNamesAmbiguous; break; } local_names.Add(local.Name, local); } } }
void DoRead(MonoSymbolFile file, MyBinaryReader br, bool includesColumns, bool includesEnds) { var lines = new List <LineNumberEntry> (); bool is_hidden = false, modified = false; int stm_line = 1, stm_offset = 0, stm_file = 1; while (true) { byte opcode = br.ReadByte(); if (opcode == 0) { byte size = br.ReadByte(); long end_pos = br.BaseStream.Position + size; opcode = br.ReadByte(); if (opcode == DW_LNE_end_sequence) { if (modified) { lines.Add(new LineNumberEntry( stm_file, stm_line, -1, stm_offset, is_hidden)); } break; } else if (opcode == DW_LNE_MONO_negate_is_hidden) { is_hidden = !is_hidden; modified = true; } else if ((opcode >= DW_LNE_MONO__extensions_start) && (opcode <= DW_LNE_MONO__extensions_end)) { ; // reserved for future extensions } else { throw new MonoSymbolFileException("Unknown extended opcode {0:x}", opcode); } br.BaseStream.Position = end_pos; continue; } else if (opcode < OpcodeBase) { switch (opcode) { case DW_LNS_copy: lines.Add(new LineNumberEntry( stm_file, stm_line, -1, stm_offset, is_hidden)); modified = false; break; case DW_LNS_advance_pc: stm_offset += br.ReadLeb128(); modified = true; break; case DW_LNS_advance_line: stm_line += br.ReadLeb128(); modified = true; break; case DW_LNS_set_file: stm_file = br.ReadLeb128(); modified = true; break; case DW_LNS_const_add_pc: stm_offset += MaxAddressIncrement; modified = true; break; default: throw new MonoSymbolFileException( "Unknown standard opcode {0:x} in LNT", opcode); } } else { opcode -= OpcodeBase; stm_offset += opcode / LineRange; stm_line += LineBase + (opcode % LineRange); lines.Add(new LineNumberEntry( stm_file, stm_line, -1, stm_offset, is_hidden)); modified = false; } } _line_numbers = lines.ToArray(); if (includesColumns) { for (int i = 0; i < _line_numbers.Length; ++i) { var ln = _line_numbers[i]; if (ln.Row >= 0) { ln.Column = br.ReadLeb128(); } } } if (includesEnds) { for (int i = 0; i < _line_numbers.Length; ++i) { var ln = _line_numbers[i]; int row = br.ReadLeb128(); if (row == 0xffffff) { ln.EndRow = -1; ln.EndColumn = -1; } else { ln.EndRow = ln.Row + row; ln.EndColumn = br.ReadLeb128(); } } } }
public override void WriteDebugSymbol (MonoSymbolFile file) { if (IsPartialPart) return; foreach (var m in members) { m.WriteDebugSymbol (file); } }
public void DefineMethod(MonoSymbolFile file) { DefineMethod(file, method.Token); }
internal LineNumberTable(MonoSymbolFile file, LineNumberEntry[] lines) : this(file) { this._line_numbers = lines; }
public MdbReader (ModuleDefinition module, MonoSymbolFile symFile) { this.module = module; this.symbol_file = symFile; this.documents = new Dictionary<string, Document> (); }
internal void Write(MonoSymbolFile file, MyBinaryWriter bw, bool hasColumnsInfo, bool hasEndInfo) { int start = (int)bw.BaseStream.Position; bool last_is_hidden = false; int last_line = 1, last_offset = 0, last_file = 1; for (int i = 0; i < LineNumbers.Length; i++) { int line_inc = LineNumbers [i].Row - last_line; int offset_inc = LineNumbers [i].Offset - last_offset; if (LineNumbers [i].File != last_file) { bw.Write(DW_LNS_set_file); bw.WriteLeb128(LineNumbers [i].File); last_file = LineNumbers [i].File; } if (LineNumbers [i].IsHidden != last_is_hidden) { bw.Write((byte)0); bw.Write((byte)1); bw.Write(DW_LNE_MONO_negate_is_hidden); last_is_hidden = LineNumbers [i].IsHidden; } if (offset_inc >= MaxAddressIncrement) { if (offset_inc < 2 * MaxAddressIncrement) { bw.Write(DW_LNS_const_add_pc); offset_inc -= MaxAddressIncrement; } else { bw.Write(DW_LNS_advance_pc); bw.WriteLeb128(offset_inc); offset_inc = 0; } } if ((line_inc < LineBase) || (line_inc >= LineBase + LineRange)) { bw.Write(DW_LNS_advance_line); bw.WriteLeb128(line_inc); if (offset_inc != 0) { bw.Write(DW_LNS_advance_pc); bw.WriteLeb128(offset_inc); } bw.Write(DW_LNS_copy); } else { byte opcode; opcode = (byte)(line_inc - LineBase + (LineRange * offset_inc) + OpcodeBase); bw.Write(opcode); } last_line = LineNumbers [i].Row; last_offset = LineNumbers [i].Offset; } bw.Write((byte)0); bw.Write((byte)1); bw.Write(DW_LNE_end_sequence); if (hasColumnsInfo) { for (int i = 0; i < LineNumbers.Length; i++) { var ln = LineNumbers [i]; if (ln.Row >= 0) { bw.WriteLeb128(ln.Column); } } } if (hasEndInfo) { for (int i = 0; i < LineNumbers.Length; i++) { var ln = LineNumbers [i]; if (ln.EndRow == -1 || ln.EndColumn == -1 || ln.Row > ln.EndRow) { bw.WriteLeb128(0xffffff); } else { bw.WriteLeb128(ln.EndRow - ln.Row); bw.WriteLeb128(ln.EndColumn); } } } file.ExtendedLineNumberSize += (int)bw.BaseStream.Position - start; }
public void DefineMethod (MonoSymbolFile file, int token) { MethodEntry entry = new MethodEntry ( file, _comp_unit.Entry, token, ScopeVariables, Locals, method_lines.ToArray (), Blocks, null, MethodEntry.Flags.ColumnsInfoIncluded, ns_id); file.AddMethod (entry); }
public SourceFileEntry(MonoSymbolFile file, string file_name, byte[] guid, byte[] checksum) : this(file, file_name) { this.guid = guid; this.hash = checksum; }
public virtual void WriteDebugSymbol (MonoSymbolFile file) { }
public static MonoSymbolFile ReadSymbolFile(ModuleDefinition module) { return(MonoSymbolFile.ReadSymbolFile(module, module.FullyQualifiedName)); }
// // Creates symbol file index in debug symbol file // void CreateUnitSymbolInfo(MonoSymbolFile symwriter) { var si = file.CreateSymbolInfo (symwriter); comp_unit = new CompileUnitEntry (symwriter, si); if (include_files != null) { foreach (SourceFile include in include_files.Values) { si = include.CreateSymbolInfo (symwriter); comp_unit.AddFile (si); } } }
public void DefineMethod(MonoSymbolFile file, int token) { var blocks = Blocks; if (blocks.Length > 0) { // // When index is provided by user it can be inserted in // any order but mdb format does not store its value. It // uses stored order as the index instead. // var sorted = new List <CodeBlockEntry> (blocks.Length); int max_index = 0; for (int i = 0; i < blocks.Length; ++i) { max_index = System.Math.Max(max_index, blocks [i].Index); } for (int i = 0; i < max_index; ++i) { var scope_index = i + 1; // // Common fast path // if (i < blocks.Length && blocks [i].Index == scope_index) { sorted.Add(blocks [i]); continue; } bool found = false; for (int ii = 0; ii < blocks.Length; ++ii) { if (blocks [ii].Index == scope_index) { sorted.Add(blocks [ii]); found = true; break; } } if (found) { continue; } // // Ideally this should never happen but with current design we can // generate scope index for unreachable code before reachable code // sorted.Add(new CodeBlockEntry(scope_index, -1, CodeBlockEntry.Type.CompilerGenerated, 0)); } blocks = sorted.ToArray(); //for (int i = 0; i < blocks.Length; ++i) { // if (blocks [i].Index - 1 != i) // throw new ArgumentException ("CodeBlocks cannot be converted to mdb format"); //} } var entry = new MethodEntry( file, _comp_unit.Entry, token, ScopeVariables, Locals, method_lines.ToArray(), blocks, null, MethodEntry.Flags.ColumnsInfoIncluded, ns_id); file.AddMethod(entry); }
public override void WriteDebugSymbol (MonoSymbolFile file) { add.WriteDebugSymbol (file); remove.WriteDebugSymbol (file); }
void DoRead(MonoSymbolFile file, MyBinaryReader br) { ArrayList lines = new ArrayList(); bool is_hidden = false, modified = false; int stm_line = 1, stm_offset = 0, stm_file = 1; while (true) { byte opcode = br.ReadByte(); if (opcode == 0) { byte size = br.ReadByte(); long end_pos = br.BaseStream.Position + size; opcode = br.ReadByte(); if (opcode == DW_LNE_end_sequence) { if (modified) { lines.Add(new LineNumberEntry( stm_file, stm_line, stm_offset, is_hidden)); } break; } else if (opcode == DW_LNE_MONO_negate_is_hidden) { is_hidden = !is_hidden; modified = true; } else if ((opcode >= DW_LNE_MONO__extensions_start) && (opcode <= DW_LNE_MONO__extensions_end)) { ; // reserved for future extensions } else { throw new MonoSymbolFileException( "Unknown extended opcode {0:x} in LNT ({1})", opcode, file.FileName); } br.BaseStream.Position = end_pos; continue; } else if (opcode < OpcodeBase) { switch (opcode) { case DW_LNS_copy: lines.Add(new LineNumberEntry( stm_file, stm_line, stm_offset, is_hidden)); modified = false; break; case DW_LNS_advance_pc: stm_offset += br.ReadLeb128(); modified = true; break; case DW_LNS_advance_line: stm_line += br.ReadLeb128(); modified = true; break; case DW_LNS_set_file: stm_file = br.ReadLeb128(); modified = true; break; case DW_LNS_const_add_pc: stm_offset += MaxAddressIncrement; modified = true; break; default: throw new MonoSymbolFileException( "Unknown standard opcode {0:x} in LNT", opcode); } } else { opcode -= OpcodeBase; stm_offset += opcode / LineRange; stm_line += LineBase + (opcode % LineRange); lines.Add(new LineNumberEntry( stm_file, stm_line, stm_offset, is_hidden)); modified = false; } } _line_numbers = new LineNumberEntry [lines.Count]; lines.CopyTo(_line_numbers, 0); }
public override void WriteDebugSymbol (MonoSymbolFile file) { if (MethodData != null && !IsPartialDefinition) MethodData.WriteDebugSymbol (file); }
internal void Write(MonoSymbolFile file, MyBinaryWriter bw) { int start = (int)bw.BaseStream.Position; bool last_is_hidden = false; int last_line = 1, last_offset = 0, last_file = 1; for (int i = 0; i < LineNumbers.Length; i++) { int line_inc = LineNumbers [i].Row - last_line; int offset_inc = LineNumbers [i].Offset - last_offset; if (SuppressDuplicates && (i + 1 < LineNumbers.Length)) { if (LineNumbers [i + 1].Equals(LineNumbers [i])) { continue; } } if (LineNumbers [i].File != last_file) { bw.Write(DW_LNS_set_file); bw.WriteLeb128(LineNumbers [i].File); last_file = LineNumbers [i].File; } if (LineNumbers [i].IsHidden != last_is_hidden) { bw.Write((byte)0); bw.Write((byte)1); bw.Write(DW_LNE_MONO_negate_is_hidden); last_is_hidden = LineNumbers [i].IsHidden; } if (offset_inc >= MaxAddressIncrement) { if (offset_inc < 2 * MaxAddressIncrement) { bw.Write(DW_LNS_const_add_pc); offset_inc -= MaxAddressIncrement; } else { bw.Write(DW_LNS_advance_pc); bw.WriteLeb128(offset_inc); offset_inc = 0; } } if ((line_inc < LineBase) || (line_inc >= LineBase + LineRange)) { bw.Write(DW_LNS_advance_line); bw.WriteLeb128(line_inc); if (offset_inc != 0) { bw.Write(DW_LNS_advance_pc); bw.WriteLeb128(offset_inc); } bw.Write(DW_LNS_copy); } else { byte opcode; opcode = (byte)(line_inc - LineBase + (LineRange * offset_inc) + OpcodeBase); bw.Write(opcode); } last_line = LineNumbers [i].Row; last_offset = LineNumbers [i].Offset; } bw.Write((byte)0); bw.Write((byte)1); bw.Write(DW_LNE_end_sequence); file.ExtendedLineNumberSize += (int)bw.BaseStream.Position - start; }
public override void WriteDebugSymbol (MonoSymbolFile file) { if (MethodData != null) MethodData.WriteDebugSymbol (file); }
internal void Write (MonoSymbolFile file, MyBinaryWriter bw) { int start = (int) bw.BaseStream.Position; bool last_is_hidden = false; int last_line = 1, last_offset = 0, last_file = 1; for (int i = 0; i < LineNumbers.Length; i++) { int line_inc = LineNumbers [i].Row - last_line; int offset_inc = LineNumbers [i].Offset - last_offset; if (SuppressDuplicates && (i+1 < LineNumbers.Length)) { if (LineNumbers [i+1].Equals (LineNumbers [i])) continue; } if (LineNumbers [i].File != last_file) { bw.Write (DW_LNS_set_file); bw.WriteLeb128 (LineNumbers [i].File); last_file = LineNumbers [i].File; } if (LineNumbers [i].IsHidden != last_is_hidden) { bw.Write ((byte) 0); bw.Write ((byte) 1); bw.Write (DW_LNE_MONO_negate_is_hidden); last_is_hidden = LineNumbers [i].IsHidden; } if (offset_inc >= MaxAddressIncrement) { if (offset_inc < 2 * MaxAddressIncrement) { bw.Write (DW_LNS_const_add_pc); offset_inc -= MaxAddressIncrement; } else { bw.Write (DW_LNS_advance_pc); bw.WriteLeb128 (offset_inc); offset_inc = 0; } } if ((line_inc < LineBase) || (line_inc >= LineBase + LineRange)) { bw.Write (DW_LNS_advance_line); bw.WriteLeb128 (line_inc); if (offset_inc != 0) { bw.Write (DW_LNS_advance_pc); bw.WriteLeb128 (offset_inc); } bw.Write (DW_LNS_copy); } else { byte opcode; opcode = (byte) (line_inc - LineBase + (LineRange * offset_inc) + OpcodeBase); bw.Write (opcode); } last_line = LineNumbers [i].Row; last_offset = LineNumbers [i].Offset; } bw.Write ((byte) 0); bw.Write ((byte) 1); bw.Write (DW_LNE_end_sequence); file.ExtendedLineNumberSize += (int) bw.BaseStream.Position - start; }
public override void WriteDebugSymbol (MonoSymbolFile file) { if (containers != null) { foreach (TypeContainer tc in containers) { tc.WriteDebugSymbol (file); } } }
internal static LineNumberTable Read (MonoSymbolFile file, MyBinaryReader br) { LineNumberTable lnt = new LineNumberTable (file); lnt.DoRead (file, br); return lnt; }