summaryrefslogtreecommitdiff
path: root/ICSharpCode.Decompiler/Disassembler/ReflectionDisassembler.cs
diff options
context:
space:
mode:
Diffstat (limited to 'ICSharpCode.Decompiler/Disassembler/ReflectionDisassembler.cs')
-rw-r--r--ICSharpCode.Decompiler/Disassembler/ReflectionDisassembler.cs1168
1 files changed, 1168 insertions, 0 deletions
diff --git a/ICSharpCode.Decompiler/Disassembler/ReflectionDisassembler.cs b/ICSharpCode.Decompiler/Disassembler/ReflectionDisassembler.cs
new file mode 100644
index 00000000..2a374c3a
--- /dev/null
+++ b/ICSharpCode.Decompiler/Disassembler/ReflectionDisassembler.cs
@@ -0,0 +1,1168 @@
+// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using ICSharpCode.NRefactory;
+using Mono.Cecil;
+using Mono.Collections.Generic;
+
+namespace ICSharpCode.Decompiler.Disassembler
+{
+ /// <summary>
+ /// Disassembles type and member definitions.
+ /// </summary>
+ public sealed class ReflectionDisassembler
+ {
+ ITextOutput output;
+ CancellationToken cancellationToken;
+ bool isInType; // whether we are currently disassembling a whole type (-> defaultCollapsed for foldings)
+ MethodBodyDisassembler methodBodyDisassembler;
+ MemberReference currentMember;
+
+ public ReflectionDisassembler(ITextOutput output, bool detectControlStructure, CancellationToken cancellationToken)
+ {
+ if (output == null)
+ throw new ArgumentNullException("output");
+ this.output = output;
+ this.cancellationToken = cancellationToken;
+ methodBodyDisassembler = new MethodBodyDisassembler(output, detectControlStructure, cancellationToken);
+ }
+
+ #region Disassemble Method
+ EnumNameCollection<MethodAttributes> methodAttributeFlags = new EnumNameCollection<MethodAttributes>() {
+ { MethodAttributes.Final, "final" },
+ { MethodAttributes.HideBySig, "hidebysig" },
+ { MethodAttributes.SpecialName, "specialname" },
+ { MethodAttributes.PInvokeImpl, null }, // handled separately
+ { MethodAttributes.UnmanagedExport, "export" },
+ { MethodAttributes.RTSpecialName, "rtspecialname" },
+ { MethodAttributes.RequireSecObject, "reqsecobj" },
+ { MethodAttributes.NewSlot, "newslot" },
+ { MethodAttributes.CheckAccessOnOverride, "strict" },
+ { MethodAttributes.Abstract, "abstract" },
+ { MethodAttributes.Virtual, "virtual" },
+ { MethodAttributes.Static, "static" },
+ { MethodAttributes.HasSecurity, null }, // ?? also invisible in ILDasm
+ };
+
+ EnumNameCollection<MethodAttributes> methodVisibility = new EnumNameCollection<MethodAttributes>() {
+ { MethodAttributes.Private, "private" },
+ { MethodAttributes.FamANDAssem, "famandassem" },
+ { MethodAttributes.Assembly, "assembly" },
+ { MethodAttributes.Family, "family" },
+ { MethodAttributes.FamORAssem, "famorassem" },
+ { MethodAttributes.Public, "public" },
+ };
+
+ EnumNameCollection<MethodCallingConvention> callingConvention = new EnumNameCollection<MethodCallingConvention>() {
+ { MethodCallingConvention.C, "unmanaged cdecl" },
+ { MethodCallingConvention.StdCall, "unmanaged stdcall" },
+ { MethodCallingConvention.ThisCall, "unmanaged thiscall" },
+ { MethodCallingConvention.FastCall, "unmanaged fastcall" },
+ { MethodCallingConvention.VarArg, "vararg" },
+ { MethodCallingConvention.Generic, null },
+ };
+
+ EnumNameCollection<MethodImplAttributes> methodCodeType = new EnumNameCollection<MethodImplAttributes>() {
+ { MethodImplAttributes.IL, "cil" },
+ { MethodImplAttributes.Native, "native" },
+ { MethodImplAttributes.OPTIL, "optil" },
+ { MethodImplAttributes.Runtime, "runtime" },
+ };
+
+ EnumNameCollection<MethodImplAttributes> methodImpl = new EnumNameCollection<MethodImplAttributes>() {
+ { MethodImplAttributes.Synchronized, "synchronized" },
+ { MethodImplAttributes.NoInlining, "noinlining" },
+ { MethodImplAttributes.NoOptimization, "nooptimization" },
+ { MethodImplAttributes.PreserveSig, "preservesig" },
+ { MethodImplAttributes.InternalCall, "internalcall" },
+ { MethodImplAttributes.ForwardRef, "forwardref" },
+ };
+
+ public void DisassembleMethod(MethodDefinition method)
+ {
+ // set current member
+ currentMember = method;
+
+ // write method header
+ output.WriteDefinition(".method ", method);
+ DisassembleMethodInternal(method);
+ }
+
+ void DisassembleMethodInternal(MethodDefinition method)
+ {
+ // .method public hidebysig specialname
+ // instance default class [mscorlib]System.IO.TextWriter get_BaseWriter () cil managed
+ //
+
+ TextLocation startLocation = output.Location;
+
+ //emit flags
+ WriteEnum(method.Attributes & MethodAttributes.MemberAccessMask, methodVisibility);
+ WriteFlags(method.Attributes & ~MethodAttributes.MemberAccessMask, methodAttributeFlags);
+ if(method.IsCompilerControlled) output.Write("privatescope ");
+
+ if ((method.Attributes & MethodAttributes.PInvokeImpl) == MethodAttributes.PInvokeImpl) {
+ output.Write("pinvokeimpl");
+ if (method.HasPInvokeInfo && method.PInvokeInfo != null) {
+ PInvokeInfo info = method.PInvokeInfo;
+ output.Write("(\"" + NRefactory.CSharp.TextWriterTokenWriter.ConvertString(info.Module.Name) + "\"");
+
+ if (!string.IsNullOrEmpty(info.EntryPoint) && info.EntryPoint != method.Name)
+ output.Write(" as \"" + NRefactory.CSharp.TextWriterTokenWriter.ConvertString(info.EntryPoint) + "\"");
+
+ if (info.IsNoMangle)
+ output.Write(" nomangle");
+
+ if (info.IsCharSetAnsi)
+ output.Write(" ansi");
+ else if (info.IsCharSetAuto)
+ output.Write(" autochar");
+ else if (info.IsCharSetUnicode)
+ output.Write(" unicode");
+
+ if (info.SupportsLastError)
+ output.Write(" lasterr");
+
+ if (info.IsCallConvCdecl)
+ output.Write(" cdecl");
+ else if (info.IsCallConvFastcall)
+ output.Write(" fastcall");
+ else if (info.IsCallConvStdCall)
+ output.Write(" stdcall");
+ else if (info.IsCallConvThiscall)
+ output.Write(" thiscall");
+ else if (info.IsCallConvWinapi)
+ output.Write(" winapi");
+
+ output.Write(')');
+ }
+ output.Write(' ');
+ }
+
+ output.WriteLine();
+ output.Indent();
+ if (method.ExplicitThis) {
+ output.Write("instance explicit ");
+ } else if (method.HasThis) {
+ output.Write("instance ");
+ }
+
+ //call convention
+ WriteEnum(method.CallingConvention & (MethodCallingConvention)0x1f, callingConvention);
+
+ //return type
+ method.ReturnType.WriteTo(output);
+ output.Write(' ');
+ if (method.MethodReturnType.HasMarshalInfo) {
+ WriteMarshalInfo(method.MethodReturnType.MarshalInfo);
+ }
+
+ if (method.IsCompilerControlled) {
+ output.Write(DisassemblerHelpers.Escape(method.Name + "$PST" + method.MetadataToken.ToInt32().ToString("X8")));
+ } else {
+ output.Write(DisassemblerHelpers.Escape(method.Name));
+ }
+
+ WriteTypeParameters(output, method);
+
+ //( params )
+ output.Write(" (");
+ if (method.HasParameters) {
+ output.WriteLine();
+ output.Indent();
+ WriteParameters(method.Parameters);
+ output.Unindent();
+ }
+ output.Write(") ");
+ //cil managed
+ WriteEnum(method.ImplAttributes & MethodImplAttributes.CodeTypeMask, methodCodeType);
+ if ((method.ImplAttributes & MethodImplAttributes.ManagedMask) == MethodImplAttributes.Managed)
+ output.Write("managed ");
+ else
+ output.Write("unmanaged ");
+ WriteFlags(method.ImplAttributes & ~(MethodImplAttributes.CodeTypeMask | MethodImplAttributes.ManagedMask), methodImpl);
+
+ output.Unindent();
+ OpenBlock(defaultCollapsed: isInType);
+ WriteAttributes(method.CustomAttributes);
+ if (method.HasOverrides) {
+ foreach (var methodOverride in method.Overrides) {
+ output.Write(".override method ");
+ methodOverride.WriteTo(output);
+ output.WriteLine();
+ }
+ }
+ foreach (var p in method.Parameters) {
+ WriteParameterAttributes(p);
+ }
+ WriteSecurityDeclarations(method);
+
+ if (method.HasBody) {
+ // create IL code mappings - used in debugger
+ MethodDebugSymbols debugSymbols = new MethodDebugSymbols(method);
+ debugSymbols.StartLocation = startLocation;
+ methodBodyDisassembler.Disassemble(method.Body, debugSymbols);
+ debugSymbols.EndLocation = output.Location;
+ output.AddDebugSymbols(debugSymbols);
+ }
+
+ CloseBlock("end of method " + DisassemblerHelpers.Escape(method.DeclaringType.Name) + "::" + DisassemblerHelpers.Escape(method.Name));
+ }
+
+ #region Write Security Declarations
+ void WriteSecurityDeclarations(ISecurityDeclarationProvider secDeclProvider)
+ {
+ if (!secDeclProvider.HasSecurityDeclarations)
+ return;
+ foreach (var secdecl in secDeclProvider.SecurityDeclarations) {
+ output.Write(".permissionset ");
+ switch (secdecl.Action) {
+ case SecurityAction.Request:
+ output.Write("request");
+ break;
+ case SecurityAction.Demand:
+ output.Write("demand");
+ break;
+ case SecurityAction.Assert:
+ output.Write("assert");
+ break;
+ case SecurityAction.Deny:
+ output.Write("deny");
+ break;
+ case SecurityAction.PermitOnly:
+ output.Write("permitonly");
+ break;
+ case SecurityAction.LinkDemand:
+ output.Write("linkcheck");
+ break;
+ case SecurityAction.InheritDemand:
+ output.Write("inheritcheck");
+ break;
+ case SecurityAction.RequestMinimum:
+ output.Write("reqmin");
+ break;
+ case SecurityAction.RequestOptional:
+ output.Write("reqopt");
+ break;
+ case SecurityAction.RequestRefuse:
+ output.Write("reqrefuse");
+ break;
+ case SecurityAction.PreJitGrant:
+ output.Write("prejitgrant");
+ break;
+ case SecurityAction.PreJitDeny:
+ output.Write("prejitdeny");
+ break;
+ case SecurityAction.NonCasDemand:
+ output.Write("noncasdemand");
+ break;
+ case SecurityAction.NonCasLinkDemand:
+ output.Write("noncaslinkdemand");
+ break;
+ case SecurityAction.NonCasInheritance:
+ output.Write("noncasinheritance");
+ break;
+ default:
+ output.Write(secdecl.Action.ToString());
+ break;
+ }
+ output.WriteLine(" = {");
+ output.Indent();
+ for (int i = 0; i < secdecl.SecurityAttributes.Count; i++) {
+ SecurityAttribute sa = secdecl.SecurityAttributes[i];
+ if (sa.AttributeType.Scope == sa.AttributeType.Module) {
+ output.Write("class ");
+ output.Write(DisassemblerHelpers.Escape(GetAssemblyQualifiedName(sa.AttributeType)));
+ } else {
+ sa.AttributeType.WriteTo(output, ILNameSyntax.TypeName);
+ }
+ output.Write(" = {");
+ if (sa.HasFields || sa.HasProperties) {
+ output.WriteLine();
+ output.Indent();
+
+ foreach (CustomAttributeNamedArgument na in sa.Fields) {
+ output.Write("field ");
+ WriteSecurityDeclarationArgument(na);
+ output.WriteLine();
+ }
+
+ foreach (CustomAttributeNamedArgument na in sa.Properties) {
+ output.Write("property ");
+ WriteSecurityDeclarationArgument(na);
+ output.WriteLine();
+ }
+
+ output.Unindent();
+ }
+ output.Write('}');
+
+ if (i + 1< secdecl.SecurityAttributes.Count)
+ output.Write(',');
+ output.WriteLine();
+ }
+ output.Unindent();
+ output.WriteLine("}");
+ }
+ }
+
+ void WriteSecurityDeclarationArgument(CustomAttributeNamedArgument na)
+ {
+ TypeReference type = na.Argument.Type;
+ if (type.MetadataType == MetadataType.Class || type.MetadataType == MetadataType.ValueType) {
+ output.Write("enum ");
+ if (type.Scope != type.Module) {
+ output.Write("class ");
+ output.Write(DisassemblerHelpers.Escape(GetAssemblyQualifiedName(type)));
+ } else {
+ type.WriteTo(output, ILNameSyntax.TypeName);
+ }
+ } else {
+ type.WriteTo(output);
+ }
+ output.Write(' ');
+ output.Write(DisassemblerHelpers.Escape(na.Name));
+ output.Write(" = ");
+ if (na.Argument.Value is string) {
+ // secdecls use special syntax for strings
+ output.Write("string('{0}')", NRefactory.CSharp.TextWriterTokenWriter.ConvertString((string)na.Argument.Value).Replace("'", "\'"));
+ } else {
+ WriteConstant(na.Argument.Value);
+ }
+ }
+
+ string GetAssemblyQualifiedName(TypeReference type)
+ {
+ AssemblyNameReference anr = type.Scope as AssemblyNameReference;
+ if (anr == null) {
+ ModuleDefinition md = type.Scope as ModuleDefinition;
+ if (md != null) {
+ anr = md.Assembly.Name;
+ }
+ }
+ if (anr != null) {
+ return type.FullName + ", " + anr.FullName;
+ } else {
+ return type.FullName;
+ }
+ }
+ #endregion
+
+ #region WriteMarshalInfo
+ void WriteMarshalInfo(MarshalInfo marshalInfo)
+ {
+ output.Write("marshal(");
+ WriteNativeType(marshalInfo.NativeType, marshalInfo);
+ output.Write(") ");
+ }
+
+ void WriteNativeType(NativeType nativeType, MarshalInfo marshalInfo = null)
+ {
+ switch (nativeType) {
+ case NativeType.None:
+ break;
+ case NativeType.Boolean:
+ output.Write("bool");
+ break;
+ case NativeType.I1:
+ output.Write("int8");
+ break;
+ case NativeType.U1:
+ output.Write("unsigned int8");
+ break;
+ case NativeType.I2:
+ output.Write("int16");
+ break;
+ case NativeType.U2:
+ output.Write("unsigned int16");
+ break;
+ case NativeType.I4:
+ output.Write("int32");
+ break;
+ case NativeType.U4:
+ output.Write("unsigned int32");
+ break;
+ case NativeType.I8:
+ output.Write("int64");
+ break;
+ case NativeType.U8:
+ output.Write("unsigned int64");
+ break;
+ case NativeType.R4:
+ output.Write("float32");
+ break;
+ case NativeType.R8:
+ output.Write("float64");
+ break;
+ case NativeType.LPStr:
+ output.Write("lpstr");
+ break;
+ case NativeType.Int:
+ output.Write("int");
+ break;
+ case NativeType.UInt:
+ output.Write("unsigned int");
+ break;
+ case NativeType.Func:
+ goto default; // ??
+ case NativeType.Array:
+ ArrayMarshalInfo ami = (ArrayMarshalInfo)marshalInfo;
+ if (ami == null)
+ goto default;
+ if (ami.ElementType != NativeType.Max)
+ WriteNativeType(ami.ElementType);
+ output.Write('[');
+ if (ami.SizeParameterMultiplier == 0) {
+ output.Write(ami.Size.ToString());
+ } else {
+ if (ami.Size >= 0)
+ output.Write(ami.Size.ToString());
+ output.Write(" + ");
+ output.Write(ami.SizeParameterIndex.ToString());
+ }
+ output.Write(']');
+ break;
+ case NativeType.Currency:
+ output.Write("currency");
+ break;
+ case NativeType.BStr:
+ output.Write("bstr");
+ break;
+ case NativeType.LPWStr:
+ output.Write("lpwstr");
+ break;
+ case NativeType.LPTStr:
+ output.Write("lptstr");
+ break;
+ case NativeType.FixedSysString:
+ output.Write("fixed sysstring[{0}]", ((FixedSysStringMarshalInfo)marshalInfo).Size);
+ break;
+ case NativeType.IUnknown:
+ output.Write("iunknown");
+ break;
+ case NativeType.IDispatch:
+ output.Write("idispatch");
+ break;
+ case NativeType.Struct:
+ output.Write("struct");
+ break;
+ case NativeType.IntF:
+ output.Write("interface");
+ break;
+ case NativeType.SafeArray:
+ output.Write("safearray ");
+ SafeArrayMarshalInfo sami = marshalInfo as SafeArrayMarshalInfo;
+ if (sami != null) {
+ switch (sami.ElementType) {
+ case VariantType.None:
+ break;
+ case VariantType.I2:
+ output.Write("int16");
+ break;
+ case VariantType.I4:
+ output.Write("int32");
+ break;
+ case VariantType.R4:
+ output.Write("float32");
+ break;
+ case VariantType.R8:
+ output.Write("float64");
+ break;
+ case VariantType.CY:
+ output.Write("currency");
+ break;
+ case VariantType.Date:
+ output.Write("date");
+ break;
+ case VariantType.BStr:
+ output.Write("bstr");
+ break;
+ case VariantType.Dispatch:
+ output.Write("idispatch");
+ break;
+ case VariantType.Error:
+ output.Write("error");
+ break;
+ case VariantType.Bool:
+ output.Write("bool");
+ break;
+ case VariantType.Variant:
+ output.Write("variant");
+ break;
+ case VariantType.Unknown:
+ output.Write("iunknown");
+ break;
+ case VariantType.Decimal:
+ output.Write("decimal");
+ break;
+ case VariantType.I1:
+ output.Write("int8");
+ break;
+ case VariantType.UI1:
+ output.Write("unsigned int8");
+ break;
+ case VariantType.UI2:
+ output.Write("unsigned int16");
+ break;
+ case VariantType.UI4:
+ output.Write("unsigned int32");
+ break;
+ case VariantType.Int:
+ output.Write("int");
+ break;
+ case VariantType.UInt:
+ output.Write("unsigned int");
+ break;
+ default:
+ output.Write(sami.ElementType.ToString());
+ break;
+ }
+ }
+ break;
+ case NativeType.FixedArray:
+ output.Write("fixed array");
+ FixedArrayMarshalInfo fami = marshalInfo as FixedArrayMarshalInfo;
+ if (fami != null) {
+ output.Write("[{0}]", fami.Size);
+ if (fami.ElementType != NativeType.None) {
+ output.Write(' ');
+ WriteNativeType(fami.ElementType);
+ }
+ }
+ break;
+ case NativeType.ByValStr:
+ output.Write("byvalstr");
+ break;
+ case NativeType.ANSIBStr:
+ output.Write("ansi bstr");
+ break;
+ case NativeType.TBStr:
+ output.Write("tbstr");
+ break;
+ case NativeType.VariantBool:
+ output.Write("variant bool");
+ break;
+ case NativeType.ASAny:
+ output.Write("as any");
+ break;
+ case NativeType.LPStruct:
+ output.Write("lpstruct");
+ break;
+ case NativeType.CustomMarshaler:
+ CustomMarshalInfo cmi = marshalInfo as CustomMarshalInfo;
+ if (cmi == null)
+ goto default;
+ output.Write("custom(\"{0}\", \"{1}\"",
+ NRefactory.CSharp.TextWriterTokenWriter.ConvertString(cmi.ManagedType.FullName),
+ NRefactory.CSharp.TextWriterTokenWriter.ConvertString(cmi.Cookie));
+ if (cmi.Guid != Guid.Empty || !string.IsNullOrEmpty(cmi.UnmanagedType)) {
+ output.Write(", \"{0}\", \"{1}\"", cmi.Guid.ToString(), NRefactory.CSharp.TextWriterTokenWriter.ConvertString(cmi.UnmanagedType));
+ }
+ output.Write(')');
+ break;
+ case NativeType.Error:
+ output.Write("error");
+ break;
+ default:
+ output.Write(nativeType.ToString());
+ break;
+ }
+ }
+ #endregion
+
+ void WriteParameters(Collection<ParameterDefinition> parameters)
+ {
+ for (int i = 0; i < parameters.Count; i++) {
+ var p = parameters[i];
+ if (p.IsIn)
+ output.Write("[in] ");
+ if (p.IsOut)
+ output.Write("[out] ");
+ if (p.IsOptional)
+ output.Write("[opt] ");
+ p.ParameterType.WriteTo(output);
+ output.Write(' ');
+ if (p.HasMarshalInfo) {
+ WriteMarshalInfo(p.MarshalInfo);
+ }
+ output.WriteDefinition(DisassemblerHelpers.Escape(p.Name), p);
+ if (i < parameters.Count - 1)
+ output.Write(',');
+ output.WriteLine();
+ }
+ }
+
+ bool HasParameterAttributes(ParameterDefinition p)
+ {
+ return p.HasConstant || p.HasCustomAttributes;
+ }
+
+ void WriteParameterAttributes(ParameterDefinition p)
+ {
+ if (!HasParameterAttributes(p))
+ return;
+ output.Write(".param [{0}]", p.Index + 1);
+ if (p.HasConstant) {
+ output.Write(" = ");
+ WriteConstant(p.Constant);
+ }
+ output.WriteLine();
+ WriteAttributes(p.CustomAttributes);
+ }
+
+ void WriteConstant(object constant)
+ {
+ if (constant == null) {
+ output.Write("nullref");
+ } else {
+ string typeName = DisassemblerHelpers.PrimitiveTypeName(constant.GetType().FullName);
+ if (typeName != null && typeName != "string") {
+ output.Write(typeName);
+ output.Write('(');
+ float? cf = constant as float?;
+ double? cd = constant as double?;
+ if (cf.HasValue && (float.IsNaN(cf.Value) || float.IsInfinity(cf.Value))) {
+ output.Write("0x{0:x8}", BitConverter.ToInt32(BitConverter.GetBytes(cf.Value), 0));
+ } else if (cd.HasValue && (double.IsNaN(cd.Value) || double.IsInfinity(cd.Value))) {
+ output.Write("0x{0:x16}", BitConverter.DoubleToInt64Bits(cd.Value));
+ } else {
+ DisassemblerHelpers.WriteOperand(output, constant);
+ }
+ output.Write(')');
+ } else {
+ DisassemblerHelpers.WriteOperand(output, constant);
+ }
+ }
+ }
+ #endregion
+
+ #region Disassemble Field
+ EnumNameCollection<FieldAttributes> fieldVisibility = new EnumNameCollection<FieldAttributes>() {
+ { FieldAttributes.Private, "private" },
+ { FieldAttributes.FamANDAssem, "famandassem" },
+ { FieldAttributes.Assembly, "assembly" },
+ { FieldAttributes.Family, "family" },
+ { FieldAttributes.FamORAssem, "famorassem" },
+ { FieldAttributes.Public, "public" },
+ };
+
+ EnumNameCollection<FieldAttributes> fieldAttributes = new EnumNameCollection<FieldAttributes>() {
+ { FieldAttributes.Static, "static" },
+ { FieldAttributes.Literal, "literal" },
+ { FieldAttributes.InitOnly, "initonly" },
+ { FieldAttributes.SpecialName, "specialname" },
+ { FieldAttributes.RTSpecialName, "rtspecialname" },
+ { FieldAttributes.NotSerialized, "notserialized" },
+ };
+
+ public void DisassembleField(FieldDefinition field)
+ {
+ output.WriteDefinition(".field ", field);
+ if (field.HasLayoutInfo) {
+ output.Write("[" + field.Offset + "] ");
+ }
+ WriteEnum(field.Attributes & FieldAttributes.FieldAccessMask, fieldVisibility);
+ const FieldAttributes hasXAttributes = FieldAttributes.HasDefault | FieldAttributes.HasFieldMarshal | FieldAttributes.HasFieldRVA;
+ WriteFlags(field.Attributes & ~(FieldAttributes.FieldAccessMask | hasXAttributes), fieldAttributes);
+ if (field.HasMarshalInfo) {
+ WriteMarshalInfo(field.MarshalInfo);
+ }
+ field.FieldType.WriteTo(output);
+ output.Write(' ');
+ output.Write(DisassemblerHelpers.Escape(field.Name));
+ if ((field.Attributes & FieldAttributes.HasFieldRVA) == FieldAttributes.HasFieldRVA) {
+ output.Write(" at I_{0:x8}", field.RVA);
+ }
+ if (field.HasConstant) {
+ output.Write(" = ");
+ WriteConstant(field.Constant);
+ }
+ output.WriteLine();
+ if (field.HasCustomAttributes) {
+ output.MarkFoldStart();
+ WriteAttributes(field.CustomAttributes);
+ output.MarkFoldEnd();
+ }
+ }
+ #endregion
+
+ #region Disassemble Property
+ EnumNameCollection<PropertyAttributes> propertyAttributes = new EnumNameCollection<PropertyAttributes>() {
+ { PropertyAttributes.SpecialName, "specialname" },
+ { PropertyAttributes.RTSpecialName, "rtspecialname" },
+ { PropertyAttributes.HasDefault, "hasdefault" },
+ };
+
+ public void DisassembleProperty(PropertyDefinition property)
+ {
+ // set current member
+ currentMember = property;
+
+ output.WriteDefinition(".property ", property);
+ WriteFlags(property.Attributes, propertyAttributes);
+ if (property.HasThis)
+ output.Write("instance ");
+ property.PropertyType.WriteTo(output);
+ output.Write(' ');
+ output.Write(DisassemblerHelpers.Escape(property.Name));
+
+ output.Write("(");
+ if (property.HasParameters) {
+ output.WriteLine();
+ output.Indent();
+ WriteParameters(property.Parameters);
+ output.Unindent();
+ }
+ output.Write(")");
+
+ OpenBlock(false);
+ WriteAttributes(property.CustomAttributes);
+ WriteNestedMethod(".get", property.GetMethod);
+ WriteNestedMethod(".set", property.SetMethod);
+
+ foreach (var method in property.OtherMethods) {
+ WriteNestedMethod(".other", method);
+ }
+ CloseBlock();
+ }
+
+ void WriteNestedMethod(string keyword, MethodDefinition method)
+ {
+ if (method == null)
+ return;
+
+ output.Write(keyword);
+ output.Write(' ');
+ method.WriteTo(output);
+ output.WriteLine();
+ }
+ #endregion
+
+ #region Disassemble Event
+ EnumNameCollection<EventAttributes> eventAttributes = new EnumNameCollection<EventAttributes>() {
+ { EventAttributes.SpecialName, "specialname" },
+ { EventAttributes.RTSpecialName, "rtspecialname" },
+ };
+
+ public void DisassembleEvent(EventDefinition ev)
+ {
+ // set current member
+ currentMember = ev;
+
+ output.WriteDefinition(".event ", ev);
+ WriteFlags(ev.Attributes, eventAttributes);
+ ev.EventType.WriteTo(output, ILNameSyntax.TypeName);
+ output.Write(' ');
+ output.Write(DisassemblerHelpers.Escape(ev.Name));
+ OpenBlock(false);
+ WriteAttributes(ev.CustomAttributes);
+ WriteNestedMethod(".addon", ev.AddMethod);
+ WriteNestedMethod(".removeon", ev.RemoveMethod);
+ WriteNestedMethod(".fire", ev.InvokeMethod);
+ foreach (var method in ev.OtherMethods) {
+ WriteNestedMethod(".other", method);
+ }
+ CloseBlock();
+ }
+ #endregion
+
+ #region Disassemble Type
+ EnumNameCollection<TypeAttributes> typeVisibility = new EnumNameCollection<TypeAttributes>() {
+ { TypeAttributes.Public, "public" },
+ { TypeAttributes.NotPublic, "private" },
+ { TypeAttributes.NestedPublic, "nested public" },
+ { TypeAttributes.NestedPrivate, "nested private" },
+ { TypeAttributes.NestedAssembly, "nested assembly" },
+ { TypeAttributes.NestedFamily, "nested family" },
+ { TypeAttributes.NestedFamANDAssem, "nested famandassem" },
+ { TypeAttributes.NestedFamORAssem, "nested famorassem" },
+ };
+
+ EnumNameCollection<TypeAttributes> typeLayout = new EnumNameCollection<TypeAttributes>() {
+ { TypeAttributes.AutoLayout, "auto" },
+ { TypeAttributes.SequentialLayout, "sequential" },
+ { TypeAttributes.ExplicitLayout, "explicit" },
+ };
+
+ EnumNameCollection<TypeAttributes> typeStringFormat = new EnumNameCollection<TypeAttributes>() {
+ { TypeAttributes.AutoClass, "auto" },
+ { TypeAttributes.AnsiClass, "ansi" },
+ { TypeAttributes.UnicodeClass, "unicode" },
+ };
+
+ EnumNameCollection<TypeAttributes> typeAttributes = new EnumNameCollection<TypeAttributes>() {
+ { TypeAttributes.Abstract, "abstract" },
+ { TypeAttributes.Sealed, "sealed" },
+ { TypeAttributes.SpecialName, "specialname" },
+ { TypeAttributes.Import, "import" },
+ { TypeAttributes.Serializable, "serializable" },
+ { TypeAttributes.WindowsRuntime, "windowsruntime" },
+ { TypeAttributes.BeforeFieldInit, "beforefieldinit" },
+ { TypeAttributes.HasSecurity, null },
+ };
+
+ public void DisassembleType(TypeDefinition type)
+ {
+ // start writing IL
+ output.WriteDefinition(".class ", type);
+
+ if ((type.Attributes & TypeAttributes.ClassSemanticMask) == TypeAttributes.Interface)
+ output.Write("interface ");
+ WriteEnum(type.Attributes & TypeAttributes.VisibilityMask, typeVisibility);
+ WriteEnum(type.Attributes & TypeAttributes.LayoutMask, typeLayout);
+ WriteEnum(type.Attributes & TypeAttributes.StringFormatMask, typeStringFormat);
+ const TypeAttributes masks = TypeAttributes.ClassSemanticMask | TypeAttributes.VisibilityMask | TypeAttributes.LayoutMask | TypeAttributes.StringFormatMask;
+ WriteFlags(type.Attributes & ~masks, typeAttributes);
+
+ output.Write(DisassemblerHelpers.Escape(type.DeclaringType != null ? type.Name : type.FullName));
+ WriteTypeParameters(output, type);
+ output.MarkFoldStart(defaultCollapsed: isInType);
+ output.WriteLine();
+
+ if (type.BaseType != null) {
+ output.Indent();
+ output.Write("extends ");
+ type.BaseType.WriteTo(output, ILNameSyntax.TypeName);
+ output.WriteLine();
+ output.Unindent();
+ }
+ if (type.HasInterfaces) {
+ output.Indent();
+ for (int index = 0; index < type.Interfaces.Count; index++) {
+ if (index > 0)
+ output.WriteLine(",");
+ if (index == 0)
+ output.Write("implements ");
+ else
+ output.Write(" ");
+ type.Interfaces[index].WriteTo(output, ILNameSyntax.TypeName);
+ }
+ output.WriteLine();
+ output.Unindent();
+ }
+
+ output.WriteLine("{");
+ output.Indent();
+ bool oldIsInType = isInType;
+ isInType = true;
+ WriteAttributes(type.CustomAttributes);
+ WriteSecurityDeclarations(type);
+ if (type.HasLayoutInfo) {
+ output.WriteLine(".pack {0}", type.PackingSize);
+ output.WriteLine(".size {0}", type.ClassSize);
+ output.WriteLine();
+ }
+ if (type.HasNestedTypes) {
+ output.WriteLine("// Nested Types");
+ foreach (var nestedType in type.NestedTypes) {
+ cancellationToken.ThrowIfCancellationRequested();
+ DisassembleType(nestedType);
+ output.WriteLine();
+ }
+ output.WriteLine();
+ }
+ if (type.HasFields) {
+ output.WriteLine("// Fields");
+ foreach (var field in type.Fields) {
+ cancellationToken.ThrowIfCancellationRequested();
+ DisassembleField(field);
+ }
+ output.WriteLine();
+ }
+ if (type.HasMethods) {
+ output.WriteLine("// Methods");
+ foreach (var m in type.Methods) {
+ cancellationToken.ThrowIfCancellationRequested();
+ DisassembleMethod(m);
+ output.WriteLine();
+ }
+ }
+ if (type.HasEvents) {
+ output.WriteLine("// Events");
+ foreach (var ev in type.Events) {
+ cancellationToken.ThrowIfCancellationRequested();
+ DisassembleEvent(ev);
+ output.WriteLine();
+ }
+ output.WriteLine();
+ }
+ if (type.HasProperties) {
+ output.WriteLine("// Properties");
+ foreach (var prop in type.Properties) {
+ cancellationToken.ThrowIfCancellationRequested();
+ DisassembleProperty(prop);
+ }
+ output.WriteLine();
+ }
+ CloseBlock("end of class " + (type.DeclaringType != null ? type.Name : type.FullName));
+ isInType = oldIsInType;
+ }
+
+ void WriteTypeParameters(ITextOutput output, IGenericParameterProvider p)
+ {
+ if (p.HasGenericParameters) {
+ output.Write('<');
+ for (int i = 0; i < p.GenericParameters.Count; i++) {
+ if (i > 0)
+ output.Write(", ");
+ GenericParameter gp = p.GenericParameters[i];
+ if (gp.HasReferenceTypeConstraint) {
+ output.Write("class ");
+ } else if (gp.HasNotNullableValueTypeConstraint) {
+ output.Write("valuetype ");
+ }
+ if (gp.HasDefaultConstructorConstraint) {
+ output.Write(".ctor ");
+ }
+ if (gp.HasConstraints) {
+ output.Write('(');
+ for (int j = 0; j < gp.Constraints.Count; j++) {
+ if (j > 0)
+ output.Write(", ");
+ gp.Constraints[j].WriteTo(output, ILNameSyntax.TypeName);
+ }
+ output.Write(") ");
+ }
+ if (gp.IsContravariant) {
+ output.Write('-');
+ } else if (gp.IsCovariant) {
+ output.Write('+');
+ }
+ output.Write(DisassemblerHelpers.Escape(gp.Name));
+ }
+ output.Write('>');
+ }
+ }
+ #endregion
+
+ #region Helper methods
+ void WriteAttributes(Collection<CustomAttribute> attributes)
+ {
+ foreach (CustomAttribute a in attributes) {
+ output.Write(".custom ");
+ a.Constructor.WriteTo(output);
+ byte[] blob = a.GetBlob();
+ if (blob != null) {
+ output.Write(" = ");
+ WriteBlob(blob);
+ }
+ output.WriteLine();
+ }
+ }
+
+ void WriteBlob(byte[] blob)
+ {
+ output.Write("(");
+ output.Indent();
+
+ for (int i = 0; i < blob.Length; i++) {
+ if (i % 16 == 0 && i < blob.Length - 1) {
+ output.WriteLine();
+ } else {
+ output.Write(' ');
+ }
+ output.Write(blob[i].ToString("x2"));
+ }
+
+ output.WriteLine();
+ output.Unindent();
+ output.Write(")");
+ }
+
+ void OpenBlock(bool defaultCollapsed)
+ {
+ output.MarkFoldStart(defaultCollapsed: defaultCollapsed);
+ output.WriteLine();
+ output.WriteLine("{");
+ output.Indent();
+ }
+
+ void CloseBlock(string comment = null)
+ {
+ output.Unindent();
+ output.Write("}");
+ if (comment != null)
+ output.Write(" // " + comment);
+ output.MarkFoldEnd();
+ output.WriteLine();
+ }
+
+ void WriteFlags<T>(T flags, EnumNameCollection<T> flagNames) where T : struct
+ {
+ long val = Convert.ToInt64(flags);
+ long tested = 0;
+ foreach (var pair in flagNames) {
+ tested |= pair.Key;
+ if ((val & pair.Key) != 0 && pair.Value != null) {
+ output.Write(pair.Value);
+ output.Write(' ');
+ }
+ }
+ if ((val & ~tested) != 0)
+ output.Write("flag({0:x4}) ", val & ~tested);
+ }
+
+ void WriteEnum<T>(T enumValue, EnumNameCollection<T> enumNames) where T : struct
+ {
+ long val = Convert.ToInt64(enumValue);
+ foreach (var pair in enumNames) {
+ if (pair.Key == val) {
+ if (pair.Value != null) {
+ output.Write(pair.Value);
+ output.Write(' ');
+ }
+ return;
+ }
+ }
+ if (val != 0) {
+ output.Write("flag({0:x4})", val);
+ output.Write(' ');
+ }
+
+ }
+
+ sealed class EnumNameCollection<T> : IEnumerable<KeyValuePair<long, string>> where T : struct
+ {
+ List<KeyValuePair<long, string>> names = new List<KeyValuePair<long, string>>();
+
+ public void Add(T flag, string name)
+ {
+ names.Add(new KeyValuePair<long, string>(Convert.ToInt64(flag), name));
+ }
+
+ public IEnumerator<KeyValuePair<long, string>> GetEnumerator()
+ {
+ return names.GetEnumerator();
+ }
+
+ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+ {
+ return names.GetEnumerator();
+ }
+ }
+ #endregion
+
+ public void DisassembleNamespace(string nameSpace, IEnumerable<TypeDefinition> types)
+ {
+ if (!string.IsNullOrEmpty(nameSpace)) {
+ output.Write(".namespace " + DisassemblerHelpers.Escape(nameSpace));
+ OpenBlock(false);
+ }
+ bool oldIsInType = isInType;
+ isInType = true;
+ foreach (TypeDefinition td in types) {
+ cancellationToken.ThrowIfCancellationRequested();
+ DisassembleType(td);
+ output.WriteLine();
+ }
+ if (!string.IsNullOrEmpty(nameSpace)) {
+ CloseBlock();
+ isInType = oldIsInType;
+ }
+ }
+
+ public void WriteAssemblyHeader(AssemblyDefinition asm)
+ {
+ output.Write(".assembly ");
+ if (asm.Name.IsWindowsRuntime)
+ output.Write("windowsruntime ");
+ output.Write(DisassemblerHelpers.Escape(asm.Name.Name));
+ OpenBlock(false);
+ WriteAttributes(asm.CustomAttributes);
+ WriteSecurityDeclarations(asm);
+ if (asm.Name.PublicKey != null && asm.Name.PublicKey.Length > 0) {
+ output.Write(".publickey = ");
+ WriteBlob(asm.Name.PublicKey);
+ output.WriteLine();
+ }
+ if (asm.Name.HashAlgorithm != AssemblyHashAlgorithm.None) {
+ output.Write(".hash algorithm 0x{0:x8}", (int)asm.Name.HashAlgorithm);
+ if (asm.Name.HashAlgorithm == AssemblyHashAlgorithm.SHA1)
+ output.Write(" // SHA1");
+ output.WriteLine();
+ }
+ Version v = asm.Name.Version;
+ if (v != null) {
+ output.WriteLine(".ver {0}:{1}:{2}:{3}", v.Major, v.Minor, v.Build, v.Revision);
+ }
+ CloseBlock();
+ }
+
+ public void WriteAssemblyReferences(ModuleDefinition module)
+ {
+ foreach (var mref in module.ModuleReferences) {
+ output.WriteLine(".module extern {0}", DisassemblerHelpers.Escape(mref.Name));
+ }
+ foreach (var aref in module.AssemblyReferences) {
+ output.Write(".assembly extern ");
+ if (aref.IsWindowsRuntime)
+ output.Write("windowsruntime ");
+ output.Write(DisassemblerHelpers.Escape(aref.Name));
+ OpenBlock(false);
+ if (aref.PublicKeyToken != null) {
+ output.Write(".publickeytoken = ");
+ WriteBlob(aref.PublicKeyToken);
+ output.WriteLine();
+ }
+ if (aref.Version != null) {
+ output.WriteLine(".ver {0}:{1}:{2}:{3}", aref.Version.Major, aref.Version.Minor, aref.Version.Build, aref.Version.Revision);
+ }
+ CloseBlock();
+ }
+ }
+
+ public void WriteModuleHeader(ModuleDefinition module)
+ {
+ if (module.HasExportedTypes) {
+ foreach (ExportedType exportedType in module.ExportedTypes) {
+ output.Write(".class extern ");
+ if (exportedType.IsForwarder)
+ output.Write("forwarder ");
+ output.Write(exportedType.DeclaringType != null ? exportedType.Name : exportedType.FullName);
+ OpenBlock(false);
+ if (exportedType.DeclaringType != null)
+ output.WriteLine(".class extern {0}", DisassemblerHelpers.Escape(exportedType.DeclaringType.FullName));
+ else
+ output.WriteLine(".assembly extern {0}", DisassemblerHelpers.Escape(exportedType.Scope.Name));
+ CloseBlock();
+ }
+ }
+
+ output.WriteLine(".module {0}", module.Name);
+ output.WriteLine("// MVID: {0}", module.Mvid.ToString("B").ToUpperInvariant());
+ // TODO: imagebase, file alignment, stackreserve, subsystem
+ output.WriteLine(".corflags 0x{0:x} // {1}", module.Attributes, module.Attributes.ToString());
+
+ WriteAttributes(module.CustomAttributes);
+ }
+
+ public void WriteModuleContents(ModuleDefinition module)
+ {
+ foreach (TypeDefinition td in module.Types) {
+ DisassembleType(td);
+ output.WriteLine();
+ }
+ }
+ }
+}