private RVA WriteUnresolvedMethodBody(MethodDefinition method)
{
var code_reader = metadata.module.reader.code;
var raw_body = code_reader.PatchRawMethodBody(method, this, out int code_size, out MetadataToken local_var_token);
bool fat_header = (raw_body.buffer[0] & 0x3) == 0x3;
if (fat_header)
{
Align(4);
}
uint rva = BeginMethod();
if (fat_header || !GetOrMapTinyMethodBody(raw_body, ref rva))
{
WriteBytes(raw_body);
}
if (method.debug_info == null)
{
return(rva);
}
ISymbolWriter symbol_writer = metadata.symbol_writer;
if (symbol_writer != null)
{
method.debug_info.code_size = code_size;
method.debug_info.local_var_token = local_var_token;
symbol_writer.Write(method.debug_info);
}
return(rva);
}
internal PdbWriter(ISymbolWriter writer, ModuleDefinition module, string pdb)
{
m_writer = writer;
m_module = module;
m_documents = new Hashtable ();
m_pdb = pdb;
}
internal PdbWriter(ISymbolWriter writer, ModuleDefinition module, string pdb)
{
m_writer = writer;
m_module = module;
m_documents = new Hashtable();
m_pdb = pdb;
}
private uint WriteUnresolvedMethodBody(MethodDefinition method)
{
int code_size;
MetadataToken local_var_token;
ByteBuffer byteBuffer = metadata.module.reader.code.PatchRawMethodBody(method, this, out code_size, out local_var_token);
bool num = (byteBuffer.buffer[0] & 3) == 3;
if (num)
{
Align(4);
}
uint result = BeginMethod();
if (num || !GetOrMapTinyMethodBody(byteBuffer, ref result))
{
base.WriteBytes(byteBuffer);
}
if (method.debug_info == null)
{
return(result);
}
ISymbolWriter symbol_writer = metadata.symbol_writer;
if (symbol_writer != null)
{
method.debug_info.code_size = code_size;
method.debug_info.local_var_token = local_var_token;
symbol_writer.Write(method.debug_info);
}
return(result);
}
internal ModuleBuilder(AssemblyBuilder assb, string name, string fullyqname, bool emitSymbolInfo, bool transient)
{
this.name = this.scopename = name;
this.fqname = fullyqname;
this.assembly = this.assemblyb = assb;
this.transient = transient;
// to keep mcs fast we do not want CryptoConfig wo be involved to create the RNG
guid = Guid.FastNewGuidArray();
// guid = Guid.NewGuid().ToByteArray ();
table_idx = get_next_table_index(this, 0x00, true);
name_cache = new Hashtable();
basic_init(this);
CreateGlobalType();
if (emitSymbolInfo)
{
Assembly asm = Assembly.LoadWithPartialName("Mono.CompilerServices.SymbolWriter");
Type t = asm.GetType("Mono.CompilerServices.SymbolWriter.SymbolWriterImpl");
if (t != null)
{
symbolWriter = (ISymbolWriter)Activator.CreateInstance(t, new object[] { this });
string fileName = fqname;
if (assemblyb.AssemblyDir != null)
{
fileName = Path.Combine(assemblyb.AssemblyDir, fileName);
}
symbolWriter.Initialize(IntPtr.Zero, fileName, true);
}
}
}
internal void EmitLineNumberInfo(ISymbolWriter symWriter)
{
for (int i = 0; i < this.m_DocumentCount; i++)
{
this.m_Documents[i].EmitLineNumberInfo(symWriter);
}
}
internal void GenerateDebugInfo(ISymbolWriter symbolWriter)
{
if (sequencePointLists != null)
{
SequencePointList first = (SequencePointList)sequencePointLists [0];
SequencePointList last = (SequencePointList)sequencePointLists [sequencePointLists.Count - 1];
symbolWriter.SetMethodSourceRange(first.Document, first.StartLine, first.StartColumn, last.Document, last.EndLine, last.EndColumn);
foreach (SequencePointList list in sequencePointLists)
{
symbolWriter.DefineSequencePoints(list.Document, list.GetOffsets(), list.GetLines(), list.GetColumns(), list.GetEndLines(), list.GetEndColumns());
}
if (locals != null)
{
foreach (LocalBuilder local in locals)
{
if (local.Name != null && local.Name.Length > 0)
{
SignatureHelper sighelper = SignatureHelper.GetLocalVarSigHelper(module as ModuleBuilder);
sighelper.AddArgument(local.LocalType);
byte[] signature = sighelper.GetSignature();
symbolWriter.DefineLocalVariable(local.Name, FieldAttributes.Public, signature, SymAddressKind.ILOffset, local.position, 0, 0, local.StartOffset, local.EndOffset);
}
}
}
sequencePointLists = null;
}
}
// Token: 0x060049E1 RID: 18913 RVA: 0x0010B160 File Offset: 0x00109360
internal void EmitLineNumberInfo(ISymbolWriter symWriter)
{
for (int i = 0; i < this.m_DocumentCount; i++)
{
this.m_Documents[i].EmitLineNumberInfo(symWriter);
}
}
private ModuleBuilder DefineDynamicModuleInternalNoLock(
String name,
bool emitSymbolInfo, // specify if emit symbol info or not
ref StackCrawlMark stackMark)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (name.Length == 0)
{
throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
}
if (name[0] == '\0')
{
throw new ArgumentException(SR.Argument_InvalidName, nameof(name));
}
BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilder.DefineDynamicModule( " + name + " )");
Debug.Assert(m_assemblyData != null, "m_assemblyData is null in DefineDynamicModuleInternal");
ModuleBuilder dynModule;
ISymbolWriter writer = null;
IntPtr pInternalSymWriter = new IntPtr();
// create the dynamic module- only one ModuleBuilder per AssemblyBuilder can be created
if (m_fManifestModuleUsedAsDefinedModule == true)
{
throw new InvalidOperationException(SR.InvalidOperation_NoMultiModuleAssembly);
}
// Init(...) has already been called on m_manifestModuleBuilder in InitManifestModule()
dynModule = m_manifestModuleBuilder;
// Create the symbol writer
if (emitSymbolInfo)
{
writer = SymWrapperCore.SymWriter.CreateSymWriter();
String fileName = "Unused"; // this symfile is never written to disk so filename does not matter.
// Pass the "real" module to the VM
pInternalSymWriter = ModuleBuilder.nCreateISymWriterForDynamicModule(dynModule.InternalModule, fileName);
// In Telesto, we took the SetUnderlyingWriter method private as it's a very rickety method.
// This might someday be a good move for the desktop CLR too.
((SymWrapperCore.SymWriter)writer).InternalSetUnderlyingWriter(pInternalSymWriter);
} // Creating the symbol writer
dynModule.SetSymWriter(writer);
m_assemblyData.AddModule(dynModule);
if (dynModule == m_manifestModuleBuilder)
{ // We are reusing manifest module as user-defined dynamic module
m_fManifestModuleUsedAsDefinedModule = true;
}
return(dynModule);
} // DefineDynamicModuleInternalNoLock
internal void EmitLineNumberInfo(ISymbolWriter symWriter)
{
for (int index = 0; index < this.m_DocumentCount; ++index)
{
this.m_Documents[index].EmitLineNumberInfo(symWriter);
}
}
/// <summary>
/// </summary>
/// <param name="filename">
/// </param>
public static void Convert(string filename, ISymbolWriter symbolWriter)
{
using (var stream = File.OpenRead(filename))
{
var funcs = PdbFile.LoadFunctions(stream, true);
Convert(funcs, symbolWriter);
}
}
/// <summary>
/// </summary>
/// <param name="filename">
/// </param>
public static void Convert(string filename, ISymbolWriter symbolWriter)
{
using (var stream = File.OpenRead(filename))
{
var funcs = PdbFile.LoadFunctions(stream, true);
Convert(funcs, symbolWriter);
}
}
private void GetDebugHeader()
{
ISymbolWriter writer = this.metadata.symbol_writer;
if ((writer != null) && !writer.GetDebugHeader(out this.debug_directory, out this.debug_data))
{
this.debug_data = Empty <byte> .Array;
}
}
/// <summary>
/// </summary>
/// <param name="assembly">
/// </param>
/// <param name="functions">
/// </param>
/// <param name="symbolWriter">
/// </param>
internal static void Convert(IEnumerable <PdbFunction> functions, ISymbolWriter symbolWriter)
{
var converter = new Converter(symbolWriter);
foreach (var function in functions)
{
converter.ConvertFunction(function);
}
}
internal ModuleBuilder DefineDynamicModuleInternal(
String name,
bool emitSymbolInfo, // specify if emit symbol info or not
ref StackCrawlMark stackMark)
{
BCLDebug.Log("DYNIL", "## DYNIL LOGGING: AssemblyBuilder.DefineDynamicModule( " + name + " )");
BCLDebug.Assert(m_assemblyData != null, "m_assemblyData is null in DefineDynamicModuleInternal");
if (name == null)
{
throw new ArgumentNullException("name");
}
if (name.Length == 0)
{
throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
}
if (name[0] == '\0')
{
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidName"), "name");
}
m_assemblyData.CheckNameConflict(name);
// create the dynamic module
ModuleBuilder dynModule = nDefineDynamicModule(this, emitSymbolInfo, name, ref stackMark);
ISymbolWriter writer = null;
if (emitSymbolInfo)
{
// create the default SymWriter
Assembly assem = LoadISymWrapper();
Type symWriter = assem.GetType("System.Diagnostics.SymbolStore.SymWriter", true, false);
if (symWriter != null && !symWriter.IsVisible)
{
symWriter = null;
}
if (symWriter == null)
{
// cannot find SymWriter
throw new ExecutionEngineException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString(ResId.MissingType), "SymWriter"));
}
try {
(new PermissionSet(PermissionState.Unrestricted)).Assert();
writer = (ISymbolWriter)Activator.CreateInstance(symWriter);
}
finally {
CodeAccessPermission.RevertAssert();
}
}
dynModule.Init(name, null, writer);
m_assemblyData.AddModule(dynModule);
return(dynModule);
}
public static void WriteModuleTo(ModuleDefinition module, Stream stream, WriterParameters parameters)
{
AssemblyNameDefinition name;
if ((int)(module.Attributes & ModuleAttributes.ILOnly) == 0)
{
throw new NotSupportedException("Writing mixed-mode assemblies is not supported");
}
if (module.HasImage && module.ReadingMode == ReadingMode.Deferred)
{
ImmediateModuleReader.ReadModule(module);
}
module.MetadataSystem.Clear();
if (module.assembly != null)
{
name = module.assembly.Name;
}
else
{
name = null;
}
AssemblyNameDefinition publicKey = name;
string fullyQualifiedName = stream.GetFullyQualifiedName();
ISymbolWriterProvider symbolWriterProvider = parameters.SymbolWriterProvider;
if (symbolWriterProvider == null && parameters.WriteSymbols)
{
symbolWriterProvider = SymbolProvider.GetPlatformWriterProvider();
}
ISymbolWriter symbolWriter = ModuleWriter.GetSymbolWriter(module, fullyQualifiedName, symbolWriterProvider);
if (parameters.StrongNameKeyPair != null && publicKey != null)
{
publicKey.PublicKey = parameters.StrongNameKeyPair.PublicKey;
ModuleDefinition attributes = module;
attributes.Attributes = attributes.Attributes | ModuleAttributes.StrongNameSigned;
}
MetadataBuilder metadataBuilder = new MetadataBuilder(module, fullyQualifiedName, symbolWriterProvider, symbolWriter);
ModuleWriter.BuildMetadata(module, metadataBuilder);
if (module.symbol_reader != null)
{
module.symbol_reader.Dispose();
}
ImageWriter imageWriter = ImageWriter.CreateWriter(module, metadataBuilder, stream);
imageWriter.WriteImage();
if (parameters.StrongNameKeyPair != null)
{
CryptoService.StrongName(stream, imageWriter, parameters.StrongNameKeyPair);
}
if (symbolWriter != null)
{
symbolWriter.Dispose();
}
}
/// <summary>
/// </summary>
/// <param name="filename">
/// </param>
/// <param name="symbolWriter">
/// </param>
internal Converter(string filename, ISymbolWriter symbolWriter)
{
this.symbolWriter = symbolWriter;
using (var stream = File.OpenRead(filename))
{
foreach (var pdbFunc in PdbFile.LoadFunctions(stream, true))
{
funcs[pdbFunc.token] = pdbFunc;
}
}
}
internal void GenerateDebugInfo(ISymbolWriter symbolWriter)
{
if (this.ilgen != null && this.ilgen.HasDebugInfo)
{
SymbolToken symbolToken = new SymbolToken(this.GetToken().Token);
symbolWriter.OpenMethod(symbolToken);
symbolWriter.SetSymAttribute(symbolToken, "__name", Encoding.UTF8.GetBytes(this.Name));
this.ilgen.GenerateDebugInfo(symbolWriter);
symbolWriter.CloseMethod();
}
}
internal void GenerateDebugInfo(ISymbolWriter symbolWriter)
{
if (ilgen != null && ilgen.HasDebugInfo)
{
SymbolToken token = new SymbolToken(GetToken().Token);
symbolWriter.OpenMethod(token);
symbolWriter.SetSymAttribute(token, "__name", System.Text.Encoding.UTF8.GetBytes(Name));
ilgen.GenerateDebugInfo(symbolWriter);
symbolWriter.CloseMethod();
}
}
/// <summary>
/// </summary>
/// <param name="filename">
/// </param>
/// <param name="symbolWriter">
/// </param>
internal Converter(string filename, ISymbolWriter symbolWriter)
{
this.symbolWriter = symbolWriter;
using (var stream = File.OpenRead(filename))
{
foreach (var pdbFunc in PdbFile.LoadFunctions(stream, true))
{
funcs[pdbFunc.token] = pdbFunc;
}
}
}
private void BuildTypeParameterDisplayFromSymbol(ISymbol symbol, ISymbolWriter writer, INode enclosingDeclaraiton, TypeFormatFlags flags = TypeFormatFlags.None, Stack <ISymbol> symbolStack = null)
{
var targetSymbol = m_checker.GetTargetSymbol(symbol);
if ((targetSymbol.Flags & SymbolFlags.Class) != SymbolFlags.None ||
(targetSymbol.Flags & SymbolFlags.Interface) != SymbolFlags.None ||
(targetSymbol.Flags & SymbolFlags.TypeAlias) != SymbolFlags.None)
{
BuildDisplayForTypeParametersAndDelimiters(m_checker.GetLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), writer, enclosingDeclaraiton, flags, symbolStack);
}
}
// Token: 0x06004A52 RID: 19026 RVA: 0x0010CC38 File Offset: 0x0010AE38
internal virtual void EmitLocalSymInfo(ISymbolWriter symWriter)
{
for (int i = 0; i < this.m_iLocalSymCount; i++)
{
symWriter.DefineLocalVariable(this.m_strName[i], FieldAttributes.PrivateScope, this.m_ubSignature[i], SymAddressKind.ILOffset, this.m_iLocalSlot[i], 0, 0, this.m_iStartOffset[i], this.m_iEndOffset[i]);
}
for (int i = 0; i < this.m_iNameSpaceCount; i++)
{
symWriter.UsingNamespace(this.m_namespace[i]);
}
}
private ModuleBuilder DefineDynamicModuleInternalNoLock(
string name,
bool emitSymbolInfo, // specify if emit symbol info or not
ref StackCrawlMark stackMark)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (name.Length == 0)
{
throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
}
if (name[0] == '\0')
{
throw new ArgumentException(SR.Argument_InvalidName, nameof(name));
}
// Create the dynamic module- only one ModuleBuilder per AssemblyBuilder can be created.
if (_isManifestModuleUsedAsDefinedModule)
{
throw new InvalidOperationException(SR.InvalidOperation_NoMultiModuleAssembly);
}
Debug.Assert(_assemblyData != null, "_assemblyData is null in DefineDynamicModuleInternal");
// Init(...) has already been called on _manifestModuleBuilder in InitManifestModule()
ModuleBuilder dynModule = _manifestModuleBuilder;
// Create the symbol writer
ISymbolWriter writer = null;
if (emitSymbolInfo)
{
writer = SymWrapperCore.SymWriter.CreateSymWriter();
// Pass the "real" module to the VM.
// This symfile is never written to disk so filename does not matter.
IntPtr pInternalSymWriter = ModuleBuilder.nCreateISymWriterForDynamicModule(dynModule.InternalModule, "Unused");
((SymWrapperCore.SymWriter)writer).InternalSetUnderlyingWriter(pInternalSymWriter);
}
dynModule.SetSymWriter(writer);
_assemblyData._moduleBuilderList.Add(dynModule);
if (dynModule == _manifestModuleBuilder)
{
// We are reusing manifest module as user-defined dynamic module
_isManifestModuleUsedAsDefinedModule = true;
}
return(dynModule);
}
internal virtual void EmitLocalSymInfo(ISymbolWriter symWriter)
{
int num;
for (num = 0; num < this.m_iLocalSymCount; num++)
{
symWriter.DefineLocalVariable(this.m_strName[num], FieldAttributes.PrivateScope, this.m_ubSignature[num], SymAddressKind.ILOffset, this.m_iLocalSlot[num], 0, 0, this.m_iStartOffset[num], this.m_iEndOffset[num]);
}
for (num = 0; num < this.m_iNameSpaceCount; num++)
{
symWriter.UsingNamespace(this.m_namespace[num]);
}
}
private void BuildTypeParameterDisplay(ITypeParameter tp, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags, Stack <ISymbol> symbolStack)
{
AppendSymbolNameOnly(tp.Symbol, writer);
var varraint = m_checker.GetConstraintOfTypeParameter(tp);
if (varraint != null)
{
WriteSpace(writer);
WriteKeyword(writer, SyntaxKind.ExtendsKeyword);
WriteSpace(writer);
BuildTypeDisplay(varraint, writer, enclosingDeclaration, flags, symbolStack);
}
}
private void GetDebugHeader()
{
ISymbolWriter symbol_writer = metadata.symbol_writer;
if (symbol_writer != null)
{
debug_header = symbol_writer.GetDebugHeader();
}
if (module.HasDebugHeader && module.GetDebugHeader().GetDeterministicEntry() != null)
{
debug_header = debug_header.AddDeterministicEntry();
}
}
private void GetDebugHeader()
{
ISymbolWriter symbolWriter = this.metadata.symbol_writer;
if (symbolWriter == null)
{
return;
}
if (!symbolWriter.GetDebugHeader(out this.debug_directory, out this.debug_data))
{
this.debug_data = Empty <byte> .Array;
}
}
internal ModuleBuilder(AssemblyBuilder assb, string name, string fullyqname, bool emitSymbolInfo, bool transient)
{
this.name = this.scopename = name;
this.fqname = fullyqname;
this.assembly = this.assemblyb = assb;
this.transient = transient;
// to keep mcs fast we do not want CryptoConfig wo be involved to create the RNG
guid = Guid.FastNewGuidArray();
// guid = Guid.NewGuid().ToByteArray ();
table_idx = get_next_table_index(this, 0x00, true);
name_cache = new Hashtable();
us_string_cache = new Dictionary <string, int> (512);
basic_init(this);
CreateGlobalType();
if (assb.IsRun)
{
TypeBuilder tb = new TypeBuilder(this, TypeAttributes.Abstract, 0xFFFFFF); /*last valid token*/
Type type = tb.CreateType();
set_wrappers_type(this, type);
}
if (emitSymbolInfo)
{
#if MOONLIGHT
symbolWriter = new Mono.CompilerServices.SymbolWriter.SymbolWriterImpl(this);
#else
Assembly asm = Assembly.LoadWithPartialName("Mono.CompilerServices.SymbolWriter");
if (asm == null)
{
throw new ExecutionEngineException("The assembly for default symbol writer cannot be loaded");
}
Type t = asm.GetType("Mono.CompilerServices.SymbolWriter.SymbolWriterImpl");
if (t == null)
{
throw new ExecutionEngineException("The type that implements the default symbol writer interface cannot be found");
}
symbolWriter = (ISymbolWriter)Activator.CreateInstance(t, new object[] { this });
#endif
string fileName = fqname;
if (assemblyb.AssemblyDir != null)
{
fileName = Path.Combine(assemblyb.AssemblyDir, fileName);
}
symbolWriter.Initialize(IntPtr.Zero, fileName, true);
}
}
public ConnectionSynchronizer(
IAccountReader accountReader,
IAccountWriter accountWriter,
ISymbolReader symbolReader,
ISymbolWriter symbolWriter,
ICurrencyReader currencyReader,
ITokenizer tokenizer)
{
AccountReader = accountReader;
AccountWriter = accountWriter;
SymbolReader = symbolReader;
SymbolWriter = symbolWriter;
CurrencyReader = currencyReader;
Tokenizer = tokenizer;
}
private RVA WriteResolvedMethodBody(MethodDefinition method)
{
RVA rva;
body = method.Body;
ComputeHeader();
if (RequiresFatHeader())
{
Align(4);
rva = BeginMethod();
WriteFatHeader();
WriteInstructions();
if (body.HasExceptionHandlers)
{
WriteExceptionHandlers();
}
}
else
{
rva = BeginMethod();
WriteByte((byte)(0x2 | (body.CodeSize << 2))); // tiny
WriteInstructions();
int start_position = (int)(rva - code_base);
int body_size = position - start_position;
byte[] body_bytes = new byte[body_size];
Array.Copy(buffer, start_position, body_bytes, 0, body_size);
if (GetOrMapTinyMethodBody(new ByteBuffer(body_bytes), ref rva))
{
position = start_position;
}
}
ISymbolWriter symbol_writer = metadata.symbol_writer;
if (symbol_writer != null && method.debug_info != null)
{
method.debug_info.code_size = body.CodeSize;
method.debug_info.local_var_token = body.local_var_token;
symbol_writer.Write(method.debug_info);
}
return(rva);
}
private static void BuildTypePredicateDisplay(ISymbolWriter writer, ITypePredicate predicate)
{
var identifierTypePredicate = IsIdentifierTypePredicate(predicate);
if (identifierTypePredicate != null)
{
writer.WriteParameter(identifierTypePredicate.ParameterName);
}
else
{
WriteKeyword(writer, SyntaxKind.ThisKeyword);
}
WriteSpace(writer);
WriteKeyword(writer, SyntaxKind.IsKeyword);
WriteSpace(writer);
}
private void WriteUnresolvedMethodBody(MethodDefinition method)
{
MethodSymbols symbols;
ByteBuffer buffer = this.metadata.module.Read <MethodDefinition, CodeReader>(method, (_, reader) => reader.code).PatchRawMethodBody(method, this, out symbols);
base.WriteBytes(buffer);
if (!symbols.instructions.IsNullOrEmpty <InstructionSymbol>())
{
symbols.method_token = method.token;
symbols.local_var_token = GetLocalVarToken(buffer, symbols);
ISymbolWriter writer = this.metadata.symbol_writer;
if (writer != null)
{
writer.Write(symbols);
}
}
}
internal void EmitLineNumberInfo(ISymbolWriter symWriter)
{
if (this.m_iLineNumberCount != 0)
{
int[] destinationArray = new int[this.m_iLineNumberCount];
Array.Copy(this.m_iOffsets, destinationArray, this.m_iLineNumberCount);
int[] numArray2 = new int[this.m_iLineNumberCount];
Array.Copy(this.m_iLines, numArray2, this.m_iLineNumberCount);
int[] numArray3 = new int[this.m_iLineNumberCount];
Array.Copy(this.m_iColumns, numArray3, this.m_iLineNumberCount);
int[] numArray4 = new int[this.m_iLineNumberCount];
Array.Copy(this.m_iEndLines, numArray4, this.m_iLineNumberCount);
int[] numArray5 = new int[this.m_iLineNumberCount];
Array.Copy(this.m_iEndColumns, numArray5, this.m_iLineNumberCount);
symWriter.DefineSequencePoints(this.m_document, destinationArray, numArray2, numArray3, numArray4, numArray5);
}
}
internal void EmitLineNumberInfo(ISymbolWriter symWriter)
{
if (this.m_iLineNumberCount != 0)
{
int[] destinationArray = new int[this.m_iLineNumberCount];
Array.Copy(this.m_iOffsets, destinationArray, this.m_iLineNumberCount);
int[] numArray2 = new int[this.m_iLineNumberCount];
Array.Copy(this.m_iLines, numArray2, this.m_iLineNumberCount);
int[] numArray3 = new int[this.m_iLineNumberCount];
Array.Copy(this.m_iColumns, numArray3, this.m_iLineNumberCount);
int[] numArray4 = new int[this.m_iLineNumberCount];
Array.Copy(this.m_iEndLines, numArray4, this.m_iLineNumberCount);
int[] numArray5 = new int[this.m_iLineNumberCount];
Array.Copy(this.m_iEndColumns, numArray5, this.m_iLineNumberCount);
symWriter.DefineSequencePoints(this.m_document, destinationArray, numArray2, numArray3, numArray4, numArray5);
}
}
public static void WriteModuleTo(ModuleDefinition module, Stream stream, WriterParameters parameters)
{
if ((module.Attributes & ModuleAttributes.ILOnly) == 0)
{
throw new NotSupportedException("Writing mixed-mode assemblies is not supported");
}
if (module.HasImage && (module.ReadingMode == ReadingMode.Deferred))
{
ImmediateModuleReader.ReadModule(module);
}
module.MetadataSystem.Clear();
AssemblyNameDefinition name = module.assembly?.Name;
string fullyQualifiedName = stream.GetFullyQualifiedName();
ISymbolWriterProvider symbolWriterProvider = parameters.SymbolWriterProvider;
if ((symbolWriterProvider == null) && parameters.WriteSymbols)
{
symbolWriterProvider = SymbolProvider.GetPlatformWriterProvider();
}
ISymbolWriter writer = GetSymbolWriter(module, fullyQualifiedName, symbolWriterProvider);
if ((parameters.StrongNameKeyPair != null) && (name != null))
{
name.PublicKey = parameters.StrongNameKeyPair.PublicKey;
module.Attributes |= ModuleAttributes.StrongNameSigned;
}
MetadataBuilder metadata = new MetadataBuilder(module, fullyQualifiedName, symbolWriterProvider, writer);
BuildMetadata(module, metadata);
if (module.symbol_reader != null)
{
module.symbol_reader.Dispose();
}
ImageWriter writer2 = ImageWriter.CreateWriter(module, metadata, stream);
writer2.WriteImage();
if (parameters.StrongNameKeyPair != null)
{
CryptoService.StrongName(stream, writer2, parameters.StrongNameKeyPair);
}
if (writer != null)
{
writer.Dispose();
}
}
internal void EmitLineNumberInfo(ISymbolWriter symWriter)
{
if (this.m_iLineNumberCount == 0)
{
return;
}
int[] offsets = new int[this.m_iLineNumberCount];
Array.Copy((Array)this.m_iOffsets, (Array)offsets, this.m_iLineNumberCount);
int[] lines = new int[this.m_iLineNumberCount];
Array.Copy((Array)this.m_iLines, (Array)lines, this.m_iLineNumberCount);
int[] columns = new int[this.m_iLineNumberCount];
Array.Copy((Array)this.m_iColumns, (Array)columns, this.m_iLineNumberCount);
int[] endLines = new int[this.m_iLineNumberCount];
Array.Copy((Array)this.m_iEndLines, (Array)endLines, this.m_iLineNumberCount);
int[] endColumns = new int[this.m_iLineNumberCount];
Array.Copy((Array)this.m_iEndColumns, (Array)endColumns, this.m_iLineNumberCount);
symWriter.DefineSequencePoints(this.m_document, offsets, lines, columns, endLines, endColumns);
}
internal void EmitScopeTree(ISymbolWriter symWriter)
{
for (int i = 0; i < this.m_iCount; i++)
{
if (this.m_ScopeActions[i] == ScopeAction.Open)
{
symWriter.OpenScope(this.m_iOffsets[i]);
}
else
{
symWriter.CloseScope(this.m_iOffsets[i]);
}
if (this.m_localSymInfos[i] != null)
{
this.m_localSymInfos[i].EmitLocalSymInfo(symWriter);
}
}
}
public void SaveSymbols(ISymbolWriter writer)
{
SaveSymbols ();
m_controller.Writer.SymbolWriter = writer;
}
internal void CreateSymWriter()
{
_symbolWriter = _myModule.GetSymWriter();
}
internal void GenerateDebugInfo (ISymbolWriter symbolWriter)
{
if (ilgen != null && ilgen.HasDebugInfo) {
SymbolToken token = new SymbolToken (GetToken().Token);
symbolWriter.OpenMethod (token);
symbolWriter.SetSymAttribute (token, "__name", System.Text.Encoding.UTF8.GetBytes (Name));
ilgen.GenerateDebugInfo (symbolWriter);
symbolWriter.CloseMethod ();
}
}
internal void GenerateDebugInfo (ISymbolWriter symbolWriter)
{
symbolWriter.OpenNamespace (this.Namespace);
if (methods != null) {
for (int i = 0; i < num_methods; ++i) {
MethodBuilder metb = (MethodBuilder) methods[i];
metb.GenerateDebugInfo (symbolWriter);
}
}
if (ctors != null) {
foreach (ConstructorBuilder ctor in ctors)
ctor.GenerateDebugInfo (symbolWriter);
}
symbolWriter.CloseNamespace ();
if (subtypes != null) {
for (int i = 0; i < subtypes.Length; ++i)
subtypes [i].GenerateDebugInfo (symbolWriter);
}
}
internal void SetSymWriter(ISymbolWriter writer)
{
m_iSymWriter = writer;
}
internal ModuleBuilder (AssemblyBuilder assb, string name, string fullyqname, bool emitSymbolInfo, bool transient) {
this.name = this.scopename = name;
this.fqname = fullyqname;
this.assembly = this.assemblyb = assb;
this.transient = transient;
// to keep mcs fast we do not want CryptoConfig wo be involved to create the RNG
guid = Guid.FastNewGuidArray ();
// guid = Guid.NewGuid().ToByteArray ();
table_idx = get_next_table_index (this, 0x00, true);
name_cache = new Hashtable ();
us_string_cache = new Dictionary<string, int> (512);
basic_init (this);
CreateGlobalType ();
if (assb.IsRun) {
TypeBuilder tb = new TypeBuilder (this, TypeAttributes.Abstract, 0xFFFFFF); /*last valid token*/
Type type = tb.CreateType ();
set_wrappers_type (this, type);
}
if (emitSymbolInfo) {
#if MOONLIGHT
symbolWriter = new Mono.CompilerServices.SymbolWriter.SymbolWriterImpl (this);
#else
Assembly asm = Assembly.LoadWithPartialName ("Mono.CompilerServices.SymbolWriter");
if (asm == null)
throw new TypeLoadException ("The assembly for default symbol writer cannot be loaded");
Type t = asm.GetType ("Mono.CompilerServices.SymbolWriter.SymbolWriterImpl", true);
symbolWriter = (ISymbolWriter) Activator.CreateInstance (t, new object[] { this });
#endif
string fileName = fqname;
if (assemblyb.AssemblyDir != null)
fileName = Path.Combine (assemblyb.AssemblyDir, fileName);
symbolWriter.Initialize (IntPtr.Zero, fileName, true);
}
}
internal virtual void EmitLocalSymInfo(ISymbolWriter symWriter)
{
int i;
for (i = 0; i < m_iLocalSymCount; i ++)
{
symWriter.DefineLocalVariable(
m_strName[i],
FieldAttributes.PrivateScope,
m_ubSignature[i],
SymAddressKind.ILOffset,
m_iLocalSlot[i],
0, // addr2 is not used yet
0, // addr3 is not used
m_iStartOffset[i],
m_iEndOffset[i]);
}
for (i = 0; i < m_iNameSpaceCount; i ++)
{
symWriter.UsingNamespace(m_namespace[i]);
}
}
/// <summary>
/// </summary>
/// <param name="assembly">
/// </param>
/// <param name="functions">
/// </param>
/// <param name="symbolWriter">
/// </param>
internal static void Convert(IEnumerable<PdbFunction> functions, ISymbolWriter symbolWriter)
{
var converter = new Converter(symbolWriter);
foreach (var function in functions)
{
converter.ConvertFunction(function);
}
}
public void WriteSymbols(ModuleDefinition module)
{
if (!m_saveSymbols)
return;
if (m_asmOutput == null)
m_asmOutput = module.Assembly.Name.Name + "." + (module.Assembly.Kind == AssemblyKind.Dll ? "dll" : "exe");
if (m_symbolWriter == null)
m_symbolWriter = SymbolStoreHelper.GetWriter (module, m_asmOutput);
foreach (TypeDefinition type in module.Types) {
foreach (MethodDefinition method in type.Methods)
WriteSymbols (method);
foreach (MethodDefinition ctor in type.Constructors)
WriteSymbols (ctor);
}
m_symbolWriter.Dispose ();
}
public static IConverter GetConverter(string filename, ISymbolWriter symbolWriter)
{
return new Converter(filename, symbolWriter);
}
/// <summary>
/// </summary>
/// <param name="symbolWriter">
/// </param>
/// <param name="function">
/// </param>
/// <returns>
/// </returns>
private SourceFile GetSourceFile(ISymbolWriter symbolWriter, PdbFunction function)
{
var name = (from l in function.lines where l.file != null select l.file.name).First();
SourceFile file;
if (this.files.TryGetValue(name, out file))
{
return file;
}
var entry = symbolWriter.DefineDocument(name);
var unit = symbolWriter.DefineCompilationUnit(entry);
file = new SourceFile(unit, entry);
this.files.Add(name, file);
return file;
}
public PerformRewrite (ISymbolWriter sym, RewriterOptions options)
{
this.sym = sym;
this.options = options;
}
internal void GenerateDebugInfo (ISymbolWriter symbolWriter)
{
if (sequencePointLists != null) {
SequencePointList first = (SequencePointList) sequencePointLists [0];
SequencePointList last = (SequencePointList) sequencePointLists [sequencePointLists.Count - 1];
symbolWriter.SetMethodSourceRange (first.Document, first.StartLine, first.StartColumn, last.Document, last.EndLine, last.EndColumn);
foreach (SequencePointList list in sequencePointLists)
symbolWriter.DefineSequencePoints (list.Document, list.GetOffsets(), list.GetLines(), list.GetColumns(), list.GetEndLines(), list.GetEndColumns());
if (locals != null) {
foreach (LocalBuilder local in locals) {
if (local.Name != null && local.Name.Length > 0) {
SignatureHelper sighelper = SignatureHelper.GetLocalVarSigHelper (module as ModuleBuilder);
sighelper.AddArgument (local.LocalType);
byte[] signature = sighelper.GetSignature ();
symbolWriter.DefineLocalVariable (local.Name, FieldAttributes.Public, signature, SymAddressKind.ILOffset, local.position, 0, 0, local.StartOffset, local.EndOffset);
}
}
}
sequencePointLists = null;
}
}
/// <summary>
/// </summary>
/// <param name="symbolWriter">
/// </param>
internal Converter(ISymbolWriter symbolWriter)
{
this.symbolWriter = symbolWriter;
}
internal void Init(
String strModuleName,
String strFileName,
ISymbolWriter writer)
{
m_moduleData = new ModuleBuilderData(this, strModuleName, strFileName);
m_TypeBuilderList = new ArrayList();
m_iSymWriter = writer;
if (writer != null)
{
// Set the underlying writer for the managed writer
// that we're using. Note that this function requires
// unmanaged code access.
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert();
writer.SetUnderlyingWriter(m_pInternalSymWriter);
}
}
[System.Security.SecurityCritical] // auto-generated
#endif
internal void EmitLineNumberInfo(ISymbolWriter symWriter)
{
int[] iOffsetsTemp;
int[] iLinesTemp;
int[] iColumnsTemp;
int[] iEndLinesTemp;
int[] iEndColumnsTemp;
if (m_iLineNumberCount == 0)
return;
// reduce the array size to be exact
iOffsetsTemp = new int [m_iLineNumberCount];
Array.Copy(m_iOffsets, iOffsetsTemp, m_iLineNumberCount);
iLinesTemp = new int [m_iLineNumberCount];
Array.Copy(m_iLines, iLinesTemp, m_iLineNumberCount);
iColumnsTemp = new int [m_iLineNumberCount];
Array.Copy(m_iColumns, iColumnsTemp, m_iLineNumberCount);
iEndLinesTemp = new int [m_iLineNumberCount];
Array.Copy(m_iEndLines, iEndLinesTemp, m_iLineNumberCount);
iEndColumnsTemp = new int [m_iLineNumberCount];
Array.Copy(m_iEndColumns, iEndColumnsTemp, m_iLineNumberCount);
symWriter.DefineSequencePoints(m_document, iOffsetsTemp, iLinesTemp, iColumnsTemp, iEndLinesTemp, iEndColumnsTemp);
}
public void SaveSymbols(string outputDirectory, ISymbolWriter writer)
{
SaveSymbols (outputDirectory);
m_controller.Writer.SymbolWriter = writer;
}