protected MonoFundamentalType(MonoSymbolFile file, Cecil.TypeDefinition typedef, string name, FundamentalKind kind, int size) : base(file.Language, name, kind, size) { this.file = file; this.typedef = typedef; }
public static int InjectHooks(Dictionary <string, List <AttributeData> > attributes, AssemblyDefinition assemblyDefinition) { if (!attributes.ContainsKey(nameof(AddMethodAttribute))) { return(0); } var injectedCorrectly = 0; ConsoleHelper.WriteNewline(); foreach (var hook in attributes[nameof(AddMethodAttribute)]) { // Improve: Add check for multiple args here var typeDefinition = Cecil.ConvertStringToClass(hook.Attribute.ConstructorArguments[0].Value.ToString(), assemblyDefinition); if (typeDefinition == null) { continue; } var methodName = hook.Attribute.ConstructorArguments[1].Value.ToString(); if (Cecil.MethodExists(typeDefinition, methodName)) { ConsoleHelper.WriteError($"Method \"{methodName}\" Already exists in type {typeDefinition.Name}."); continue; } if (Cecil.InjectNewMethod(typeDefinition, assemblyDefinition, methodName, hook)) { ++injectedCorrectly; } } return(injectedCorrectly); }
public static int InjectHooks(Dictionary <string, List <HookData> > attributes, AssemblyDefinition assembly, Dictionary <string, TypeDefinition> typeDefinitions) { if (!attributes.ContainsKey(nameof(AddMethodHook))) { return(0); } int injectedCorrectly = 0; foreach (HookData hook in attributes[nameof(AddMethodHook)]) { TypeDefinition typeDef = Cecil.ConvertStringToClass(hook.Attribute.ConstructorArguments[0].Value.ToString(), assembly, typeDefinitions); if (typeDef == null) { continue; } string methodName = hook.Attribute.ConstructorArguments[1].Value.ToString(); if (Cecil.MethodExists(typeDef, methodName)) { string desc = string.Format("Method {0} already exists in type {1}", methodName, typeDef.FullName); Externs.MessageBox("Method already exists!", desc); } else if (Cecil.InjectNewMethod(typeDef, assembly, typeDefinitions, methodName, hook)) { ++injectedCorrectly; } } return(injectedCorrectly); }
/// <summary> /// Writes the specified statement. /// </summary> /// <param name="statement">The statement.</param> void ILanguageWriter.Write(Cecil.Decompiler.Ast.Statement statement) { LanguageWriter.Write(statement); if (_formatter != null) { _formatter.CompleteDecompile(statement, this); } }
/// <summary> /// Writes the specified expression. /// </summary> /// <param name="expression">The expression.</param> void ILanguageWriter.Write(Cecil.Decompiler.Ast.Expression expression) { LanguageWriter.Write(expression); if (_formatter != null) { _formatter.CompleteDecompile(expression, this); } }
public static void DumpLineNumberTable(TextWriter writer, MonoSymbolFile file, Cecil.MethodDefinition mdef, C.MethodEntry entry) { try { DumpLineNumberTable_internal (writer, file, mdef, entry); } catch (Exception ex) { writer.WriteLine ("DUMP LNT EX: {0}", ex); } }
protected MonoClassInfo(MonoSymbolFile file, Cecil.TypeDefinition typedef, TargetMemoryAccess target, TargetAddress klass) { this.SymbolFile = file; this.KlassAddress = klass; this.CecilType = typedef; parent_klass = MetadataHelper.MonoClassGetParent (target, klass); GenericClass = MetadataHelper.MonoClassGetGenericClass (target, klass); GenericContainer = MetadataHelper.MonoClassGetGenericContainer (target, klass); }
/// <summary> /// Assigns the generic blueprint and the type arguments to the generic instance type. /// </summary> /// <param name="conversion"></param> /// <param name="converted"></param> /// <param name="convertedDeclaringType"></param> /// <returns></returns> public void Build(ILConversion conversion, ConvertedTypeDefinition_I converted, ConvertedTypeDefinition_I convertedDeclaringType) { //Done on purpose to find errors var typeDefinition = (TypeDefinition)converted.SourceTypeReference; System.Reflection.TypeAttributes attributes = Cecil.Metadata.Members.Types.GetTypeAttributes(typeDefinition); if (converted is ConvertedTypeDefinitionWithDeclaringType_I withDeclaringType) { var packingSize = Cecil.GetPackingSize(typeDefinition); if (convertedDeclaringType == null) // Can occur if passing in a single nested type or if a nested class gets processed before its parents gets // processed. { if (!(converted.SourceTypeReference is TypeDefinition)) { throw new Exception("Expected a type definition"); } var semanticDeclaringType = Execution.Types.Ensuring.Ensure(conversion, converted.SourceTypeReference.DeclaringType, null, null); if (!(semanticDeclaringType is ConvertedTypeDefinition_I producedDeclaringType)) { throw new Exception($"Expected the declaring type of a nested class to be castable to {typeof(ConvertedTypeDefinition_I)}"); } convertedDeclaringType = producedDeclaringType; } withDeclaringType.DeclaringType = convertedDeclaringType; // The plus sign and the parent class name before it needs to be dropped from the full name prior to calling define nested class // as the type builder will automatically add them back on based upon the name of the declaring type. var fullName = Types.Naming.GetTypeBuilderNestedClassFullName(converted.FullName); converted.TypeBuilder = convertedDeclaringType.TypeBuilder.DefineNestedType(fullName, attributes, null, packingSize); } else { if (converted.FullName == "<Module>") { var x = converted.Module.ModuleBuilder.GetType("<Module>", true); } converted.TypeBuilder = converted.Module.ModuleBuilder.DefineType(converted.FullName, attributes); } converted.UnderlyingType = converted.TypeBuilder; this.Unified.Types.ExtendWithCrossReference(conversion.RuntimicSystem, converted, converted.UnderlyingType.AssemblyQualifiedName); Types.Building.UpdateBuildPhase(converted, BuildPhaseKind.TypeDefined); }
private void EnsureVariableTypes(ILConversion conversion, MethodDefinition method, TypeReference genericArgumentSource) { if (method.Body.HasVariables) { foreach (var variable in method.Body.Variables) { var resolvedVariableTypeReference = Cecil.ResolveAnyTypeArguments(genericArgumentSource, variable.VariableType); Types.Scanning.EnsureType(conversion, resolvedVariableTypeReference); } } }
private void EnsureReturnType(ILConversion conversion, MethodDefinition method, TypeReference genericArgumentSource) { var returnType = method.ReturnType; // If generic, go ahead and skip. It will get resolved. if (returnType.IsGenericParameter) { return; } var resolvedReturnTypeReference = Cecil.ResolveAnyTypeArguments(genericArgumentSource, returnType); Types.Scanning.EnsureType(conversion, resolvedReturnTypeReference); }
private void EnsureTypes(ILConversion conversion, EventDefinition propertyDefinition, TypeReference genericArgumentSource) { var eventTypeReference = propertyDefinition.EventType; // If generic, go ahead and skip. It will get resolved. if (eventTypeReference.IsGenericParameter) { return; } var resolvedEventTypeReference = Cecil.ResolveAnyTypeArguments(genericArgumentSource, propertyDefinition.EventType); var eventTypeDefinition = Models.Types.ResolveToTypeDefinition(conversion.RuntimicSystem, resolvedEventTypeReference); Execution.Types.Ensuring.Ensure(conversion, eventTypeDefinition, null, null); }
public void EnsureTypes(ILConversion conversion, FieldDefinition field, TypeReference genericArgumentSource) { var fieldTypeReference = field.FieldType; // If generic, go ahead and skip. It will get resolved. if (fieldTypeReference.IsGenericParameter) { return; } var resolvedReturnTypeReference = Cecil.ResolveForTypeScan(genericArgumentSource, fieldTypeReference); var returnTypeDefinition = Models.Types.ResolveToTypeDefinition(conversion.RuntimicSystem, resolvedReturnTypeReference); Execution.Types.Ensuring.Ensure(conversion, returnTypeDefinition, null, null); }
private void EnsureTypes(ILConversion conversion, PropertyDefinition propertyDefinition, TypeReference genericArgumentSource) { var propertyTypeReference = propertyDefinition.PropertyType; // If generic, go ahead and skip. It will get resolved. if (propertyTypeReference.IsGenericParameter) { return; } var resolvedPropertyTypeReference = Cecil.ResolveAnyTypeArguments(genericArgumentSource, propertyTypeReference); var propertyTypeDefinition = Models.Types.ResolveToTypeDefinition(conversion.RuntimicSystem, resolvedPropertyTypeReference); //Execution.Types.Ensuring.Ensure(conversion.Model, propertyTypeDefinition, null, null); throw new System.Exception("Fix"); }
private void EnsureGenericParameters(ILConversion conversion, MethodDefinition method, TypeReference genericArgumentSource) { var genericParameters = method.GenericParameters; for (int i = 0; i < genericParameters.Count; i++) { var genericParameter = genericParameters[i]; var genericParameterConstraints = genericParameter.Constraints; for (int j = 0; j < genericParameterConstraints.Count; j++) { var resolvedConstraintTypeReference = Cecil.ResolveAnyTypeArguments(genericArgumentSource, genericParameterConstraints[j]); Types.Scanning.EnsureType(conversion, resolvedConstraintTypeReference); } } }
private void EnsureParameterTypes(ILConversion conversion, MethodDefinition method, TypeReference genericArgumentSource) { var parameters = method.Parameters; for (int i = 0; i < parameters.Count; i++) { var parameter = parameters[i]; var parameterType = parameter.ParameterType; if (parameterType.IsGenericParameter) { continue; } var resolvedParameterTypeReference = Cecil.ResolveAnyTypeArguments(genericArgumentSource, parameterType); Types.Scanning.EnsureType(conversion, resolvedParameterTypeReference); } }
public void EnsureTypes(ILConversion conversion, SemanticTypeMask_I boundTypeMask) { if (!boundTypeMask.IsDefinition()) { return; } var typeDefinitionMask = (SemanticTypeDefinitionMask_I)boundTypeMask; var typeReference = typeDefinitionMask.SourceTypeReference; var typeDefinition = Cecil.GetFundamentalTypeDefinition(typeReference); var fields = typeDefinition.Fields; for (int i = 0; i < fields.Count; i++) { var field = fields[i]; EnsureTypes(conversion, field, typeReference); } }
public static int InjectHooks(Dictionary <string, List <AttributeData> > attributes, AssemblyDefinition assemblyDefinition) { if (!attributes.ContainsKey(nameof(HookAttributes))) { return(0); } var injectedCorrectly = 0; foreach (var hook in attributes[nameof(HookAttributes)]) { hook.TargetData = Cecil.ConvertStringToClassAndMethod(hook.Attribute.ConstructorArguments[0].Value.ToString(), assemblyDefinition); if (hook.TargetData == null) { continue; } if (Cecil.Inject(hook.TargetData, hook)) { ++injectedCorrectly; } } return(injectedCorrectly); }
/// <summary> /// Ensures that all of the types that the method uses have been created so that when the methods is actually converted, /// no types have to be created. /// </summary> /// <param name="conversion"></param> /// <param name="boundTypeMask"></param> public void EnsureTypes(ILConversion conversion, SemanticTypeMask_I boundTypeMask) { if (!boundTypeMask.IsDefinition()) { return; } var typeDefinitionMask = (BoundTypeDefinitionMask_I)boundTypeMask; var typeReference = typeDefinitionMask.SourceTypeReference; // Done on purpose to find errors var typeDefinition = Cecil.GetFundamentalTypeDefinition(typeReference); var methods = typeDefinition.Methods; for (int i = 0; i < methods.Count; i++) { var method = methods[i]; EnsureTypes(conversion, method, typeReference); } }
public static int InjectHooks(Dictionary <string, List <HookData> > attributes, AssemblyDefinition assembly, Dictionary <string, TypeDefinition> typeDefinitions) { if (!attributes.ContainsKey(nameof(AddCallHook))) { return(0); } int injectedCorrectly = 0; foreach (HookData hook in attributes[nameof(AddCallHook)]) { if (hook.Attribute.ConstructorArguments.Count > 0) { hook.TargetData = Cecil.ConvertStringToClassAndMethod(hook.Attribute.ConstructorArguments[0].Value.ToString(), assembly, typeDefinitions, hook); if (hook.TargetData != null && Cecil.Inject(hook.TargetData, hook)) { ++injectedCorrectly; } } } return(injectedCorrectly); }
public System.Type GetUnderlyingType(RuntimicSystemModel model, TypeReference typeReference) { if (typeReference.IsGenericParameter) { var bound = ResolveToBound_GenericParameter(model, (GenericParameter)typeReference); return(bound.UnderlyingType); } if (typeReference.IsGenericInstance) { throw new Exception("Should never happen."); //var genericInstance = (GenericInstanceType)typeReference; //var genericTypeDefinitionType = GetUnderlyingType(model, genericInstance.ElementType); //System.Type[] genericArguments = new System.Type[genericInstance.GenericArguments.Count]; //for (int i = 0; i < genericInstance.GenericArguments.Count; i++) //{ // genericArguments[i] = GetUnderlyingType(model, genericInstance.GenericArguments[i]); // if (genericArguments[i] == null) // { // throw new Exception("The underlying type was null."); // } //} //var result = XCommonAppPal.Api.Runtimic.Execution.Metadata.Assemblies.MakeGenericType(genericTypeDefinitionType, genericArguments); //return result; } return(Cecil.GetUnderlyingType(typeReference)); }
public ExecutionTypeNode_I Ensure(ExecutionEnsureContext context) { if (!context.IsConverted.HasValue) { throw new Exception("Expected conversion to be figured out."); } if (context.StructuralInputTypeNode.CecilTypeReference.IsNested && context.DeclaringType == null) { context.DeclaringType = Execution.Types.Ensuring.EnsureBound(context, context.StructuralInputTypeNode.CecilTypeReference.DeclaringType, cloneContext: true); } if (context.IsConverted.Value) { var conversion = context.Conversion; var structuralInputTypeNode = context.StructuralInputTypeNode; var metadataToken = structuralInputTypeNode.MetadataToken; var structuralAssembly = Conversion.Metadata.Assemblies.EnsureNode(context.Conversion, structuralInputTypeNode.Module.Assembly); var convertedModuleNode = Conversion.Metadata.Modules.Ensure(context.Conversion, structuralAssembly, structuralInputTypeNode.Module); var tableId = (int)(metadataToken & 0xFF000000); if (!convertedModuleNode.Tables.TryGetValue(tableId, out ConvertedTypeTable table)) { table = new ConvertedTypeTable(); convertedModuleNode.Tables.Add(tableId, table); } if (table.ByRow.TryGetValue((uint)context.RowId, out ConversionTypeNode conversionTypeNode)) { return(conversionTypeNode); } var converted = Conversion.Metadata.Members.Types.Creation.Create(conversion.RuntimicSystem, structuralInputTypeNode.CecilTypeReference); converted.Module = convertedModuleNode.ConvertedModule; conversionTypeNode = new ConversionTypeNode() { Assembly = structuralAssembly, ByReferenceType = null, Id = 0, InputStructuralNode = structuralInputTypeNode, IsByReferenceType = false, IsDerived = false, IsPointerType = false, MetadataToken = metadataToken, Module = convertedModuleNode, PointerType = null, Type = converted }; table.ByRow.Add((uint)context.RowId, conversionTypeNode); var convertedDeclaringType = context.ConvertedDeclaringType; Converted_BuildPhase1(conversion, structuralInputTypeNode, converted, convertedDeclaringType); Conversion.Metadata.Members.Types.Building.IfPossibleBuildPhase2(conversion, converted); return(conversionTypeNode); } else { var structuralInputTypeNode = context.StructuralInputTypeNode; if (structuralInputTypeNode.FullName == "Root.Code.Containers.E01D.Sorting.SortingContainer_I`1") { } var metadataToken = structuralInputTypeNode.MetadataToken; var boundAssembly = Bound.Metadata.Assemblies.EnsureNode(context.RuntimicSystem, structuralInputTypeNode.Module.Assembly); var boundModuleNode = Bound.Metadata.Modules.Ensuring.EnsureNode(context.RuntimicSystem, boundAssembly, structuralInputTypeNode.Module); var tableId = (int)(metadataToken & 0xFF000000); if (!boundModuleNode.Tables.TryGetValue(tableId, out BoundTypeTable table)) { table = new BoundTypeTable(); boundModuleNode.Tables.Add(tableId, table); } if (table.ByRow.TryGetValue((uint)context.RowId, out BoundTypeNode boundTypeNode)) { return(boundTypeNode); } //--------------------------------- // Conversion is going to occur. //--------------------------------- if (context.UnderlyingType == null) { context.UnderlyingType = Cecil.GetUnderlyingType(structuralInputTypeNode.CecilTypeReference); if (context.UnderlyingType == null) { throw new Exception("Null type"); } } var bound = Bound.Metadata.Members.Types.Creation.Create(context.RuntimicSystem, context.StructuralInputTypeNode.CecilTypeReference, context.UnderlyingType); boundTypeNode = new BoundTypeNode() { Assembly = boundAssembly, ByReferenceType = null, Id = 0, InputStructuralNode = structuralInputTypeNode, IsByReferenceType = false, IsDerived = false, IsPointerType = false, MetadataToken = metadataToken, Module = boundModuleNode, PointerType = null, Type = bound }; bound.Module = boundModuleNode.BoundModule; //// Add the type instance to the model. Do not do any recursive calls till this methods is called. table.ByRow.Add((uint)context.RowId, boundTypeNode); //Types.Addition.Add(semanticModel, boundModule, bound); Bound.Metadata.Members.Types.Building.NonGenericInstances.Phase1Initial.Build(context.RuntimicSystem, bound, context.UnderlyingType, context.DeclaringType); return(boundTypeNode); } }
public TargetType LookupMonoType(Cecil.TypeReference type) { TargetType result = (TargetType) type_hash [type]; if (result != null) return result; if (type is Cecil.ArrayType) { Cecil.ArrayType atype = (Cecil.ArrayType) type; TargetType element_type = LookupMonoType (atype.ElementType); result = new MonoArrayType (element_type, atype.Rank); } else if (type is Cecil.TypeDefinition) { Cecil.TypeDefinition tdef = (Cecil.TypeDefinition) type; if (tdef.IsEnum) result = new MonoEnumType (this, tdef); else result = new MonoClassType (this, tdef); } else { Console.WriteLine ("UNKNOWN TYPE: {0} {1}", type, type.GetType ()); return null; } if (!type_hash.Contains (type)) type_hash.Add (type, result); return result; }
internal void AddCoreType(Cecil.TypeDefinition typedef, TargetType type, TargetClassType klass, TargetAddress klass_address) { corlib.AddType (typedef, type); if (!class_hash.Contains (klass_address)) class_hash.Add (klass_address, type); }
Cecil.TypeDefinition resolve_cecil_type_ref(Cecil.TypeReference type) { type = type.GetElementType (); if (type is Cecil.TypeDefinition) return (Cecil.TypeDefinition) type; Cecil.AssemblyNameReference reference = type.Scope as Cecil.AssemblyNameReference; if (reference != null) { Cecil.AssemblyDefinition assembly = resolve_cecil_asm_name (reference); if (assembly == null) return null; return assembly.MainModule.GetType (type.FullName); } Cecil.ModuleDefinition module = type.Scope as Cecil.ModuleDefinition; if (module != null) return module.GetType (type.FullName); throw new NotImplementedException (); }
Ast.Expression Convert(Ast.Expression expr, Cecil.TypeReference actualType, Cecil.TypeReference reqType) { if (reqType == null || actualType == reqType) { return expr; } else { bool actualIsIntegerOrEnum = TypeAnalysis.IsIntegerOrEnum(actualType); bool requiredIsIntegerOrEnum = TypeAnalysis.IsIntegerOrEnum(reqType); if (TypeAnalysis.IsBoolean(reqType)) { if (TypeAnalysis.IsBoolean(actualType)) return expr; if (actualIsIntegerOrEnum) { return new BinaryOperatorExpression(expr, BinaryOperatorType.InEquality, AstBuilder.MakePrimitive(0, actualType)); } else { return new BinaryOperatorExpression(expr, BinaryOperatorType.InEquality, new NullReferenceExpression()); } } if (TypeAnalysis.IsBoolean(actualType) && requiredIsIntegerOrEnum) { return new ConditionalExpression { Condition = expr, TrueExpression = AstBuilder.MakePrimitive(1, reqType), FalseExpression = AstBuilder.MakePrimitive(0, reqType) }; } if (expr is PrimitiveExpression && !requiredIsIntegerOrEnum && TypeAnalysis.IsEnum(actualType)) { return expr.CastTo(AstBuilder.ConvertType(actualType)); } if (actualIsIntegerOrEnum && requiredIsIntegerOrEnum) { return expr.CastTo(AstBuilder.ConvertType(reqType)); } return expr; } }
public MonoMethod(MonoSymbolFile file, MethodSource source, int domain, C.MethodEntry method, Cecil.MethodDefinition mdef) : base(source.Name, file.ImageFile, file.Module) { this.file = file; this.source = source; this.domain = domain; this.method = method; this.mdef = mdef; foreach (Cecil.CustomAttribute cattr in mdef.CustomAttributes) { string cname = cattr.Constructor.DeclaringType.FullName; if ((cname == "System.Diagnostics.DebuggerHiddenAttribute") || (cname == "System.Runtime.CompilerServices.CompilerGeneratedAttribute")) is_compiler_generated = true; } }
public MonoMethodSource(MonoSymbolFile file, SourceFile source_file, C.MethodEntry method, Cecil.MethodDefinition mdef, MonoClassType klass, MonoFunctionType function) { this.file = file; this.source_file = source_file; this.method = method; this.mdef = mdef; this.function = function; this.klass = klass; full_name = method.GetRealName (); if (full_name == null) full_name = MonoSymbolFile.GetMethodName (mdef); C.LineNumberEntry start, end; C.LineNumberTable lnt = method.GetLineNumberTable (); if (lnt.GetMethodBounds (out start, out end)) start_row = start.Row; end_row = end.Row; }
internal static string GetMethodSignature(Cecil.MethodDefinition mdef) { StringBuilder sb = new StringBuilder ("("); bool first = true; foreach (Cecil.ParameterDefinition p in mdef.Parameters) { if (first) first = false; else sb.Append (", "); sb.Append (GetTypeSignature (p.ParameterType).Replace ('+','/')); } sb.Append (")"); return sb.ToString (); }
internal static string GetMethodName(Cecil.MethodDefinition mdef) { StringBuilder sb = new StringBuilder (GetTypeSignature (mdef.DeclaringType)); if (mdef.DeclaringType.GenericParameters.Count > 0) { sb.Append ('<'); bool first = true; foreach (Cecil.GenericParameter p in mdef.DeclaringType.GenericParameters) { if (first) first = false; else sb.Append (','); sb.Append (p.Name); } sb.Append ('>'); } sb.Append ('.'); sb.Append (mdef.Name); if (mdef.GenericParameters.Count > 0) { sb.Append ('<'); bool first = true; foreach (Cecil.GenericParameter p in mdef.GenericParameters) { if (first) first = false; else sb.Append (','); sb.Append (p.Name); } sb.Append ('>'); } sb.Append (GetMethodSignature (mdef)); return sb.ToString (); }
internal static void CheckCustomAttributes(Cecil.ICustomAttributeProvider type, out DebuggerBrowsableState? browsable_state, out DebuggerDisplayAttribute debugger_display, out DebuggerTypeProxyAttribute type_proxy, out bool is_compiler_generated) { browsable_state = null; debugger_display = null; type_proxy = null; is_compiler_generated = false; foreach (Cecil.CustomAttribute cattr in type.CustomAttributes) { string cname = cattr.Constructor.DeclaringType.FullName; if (cname == cgen_attr) { is_compiler_generated = true; } else if (cname == debugger_display_attr) { string text = (string) cattr.ConstructorArguments [0].Value; debugger_display = new DebuggerDisplayAttribute (text); foreach (var named_arg in cattr.Properties) { string key = named_arg.Name; if (key == "Name") debugger_display.Name = (string) named_arg.Argument.Value; else if (key == "Type") debugger_display.Type = (string) named_arg.Argument.Value; else { debugger_display = null; break; } } } else if (cname == browsable_attr) { browsable_state = (DebuggerBrowsableState) cattr.GetBlob () [2]; } else if (cname == type_proxy_attr) { string text = (string) cattr.ConstructorArguments [0].Value; type_proxy = new DebuggerTypeProxyAttribute (text); } } }
private void Converted_BuildPhase1(ILConversion conversion, StructuralTypeNode structuralInputTypeNode, ConvertedTypeDefinition converted, ConvertedTypeDefinition_I convertedDeclaringType) { var typeDefinition = (TypeDefinition)structuralInputTypeNode.CecilTypeReference; System.Reflection.TypeAttributes attributes = Cecil.Metadata.Members.Types.GetTypeAttributes(typeDefinition); var packingSize = Cecil.GetPackingSize(typeDefinition); if (converted is ConvertedTypeDefinitionWithDeclaringType_I withDeclaringType) { if (convertedDeclaringType == null ) // Can occur if passing in a single nested type or if a nested class gets processed before its parents gets // processed. { if (!(converted.SourceTypeReference is TypeDefinition)) { throw new Exception("Expected a type definition"); } var semanticDeclaringType = Execution.Types.Ensuring.Ensure(conversion, converted.SourceTypeReference.DeclaringType, null, null); if (!(semanticDeclaringType is ConvertedTypeDefinition_I producedDeclaringType)) { throw new Exception( $"Expected the declaring type of a nested class to be castable to {typeof(ConvertedTypeDefinition_I)}"); } convertedDeclaringType = producedDeclaringType; } withDeclaringType.DeclaringType = convertedDeclaringType; // The plus sign and the parent class name before it needs to be dropped from the full name prior to calling define nested class // as the type builder will automatically add them back on based upon the name of the declaring type. var fullName = Conversion.Metadata.Members.Types.Naming.GetTypeBuilderNestedClassFullName(converted.FullName); // The !IsEnum check prevents: [MD]: Error: ClassLayout has parent TypeDef token=0x02000036 marked AutoLayout. [token:0x00000001] // The Class or ValueType indexed by Parent shall be SequentialLayout or ExplicitLayout (§II.23.1.15). // That is, AutoLayout types shall not own any rows in the ClassLayout table. [ERROR] if (typeDefinition.IsValueType && !typeDefinition.IsEnum) { converted.TypeBuilder = convertedDeclaringType.TypeBuilder.DefineNestedType(converted.FullName, attributes, null, (PackingSize)typeDefinition.PackingSize, typeDefinition.ClassSize); } else { converted.TypeBuilder = convertedDeclaringType.TypeBuilder.DefineNestedType(fullName, attributes, null, packingSize); } } else { if (converted.FullName == "Root.Testing.Resources.Models.E01D.Runtimic.Execution.Emitting.Conversion.Inputs.Types.SimpleValueType") { } if (converted.FullName == "<Module>") { var x = converted.Module.ModuleBuilder.GetType("<Module>", true); } // The !IsEnum check prevents: [MD]: Error: ClassLayout has parent TypeDef token=0x02000036 marked AutoLayout. [token:0x00000001] // The Class or ValueType indexed by Parent shall be SequentialLayout or ExplicitLayout (§II.23.1.15). // That is, AutoLayout types shall not own any rows in the ClassLayout table. [ERROR] if (typeDefinition.IsValueType && !typeDefinition.IsEnum) { converted.TypeBuilder = converted.Module.ModuleBuilder.DefineType(converted.FullName, attributes, null, (PackingSize)typeDefinition.PackingSize, typeDefinition.ClassSize); } else { converted.TypeBuilder = converted.Module.ModuleBuilder.DefineType(converted.FullName, attributes, null, packingSize); } } converted.UnderlyingType = converted.TypeBuilder; //this.Unified.Types.ExtendWithCrossReference(conversion.Model, converted, // converted.UnderlyingType.AssemblyQualifiedName); Conversion.Metadata.Members.Types.Building.UpdateBuildPhase(converted, BuildPhaseKind.TypeDefined); }
Cecil.AssemblyDefinition resolve_cecil_asm_name(Cecil.AssemblyNameReference name) { foreach (MonoSymbolFile symfile in symfile_hash.Values) { if (name.FullName == symfile.Assembly.Name.FullName) return symfile.Assembly; } return null; }
public static MonoClassInfo ReadCoreType(MonoSymbolFile file, Cecil.TypeDefinition typedef, TargetMemoryAccess target, TargetAddress klass, out MonoClassType type) { MonoClassInfo info = new MonoClassInfo (file, typedef, target, klass); type = new MonoClassType (file, typedef, info); ((IMonoStructType) type).ClassInfo = info; info.struct_type = type; info.type = type; return info; }
public TargetType LookupMonoType(Cecil.TypeReference type) { MonoSymbolFile file; Cecil.TypeDefinition typedef = type as Cecil.TypeDefinition; if (typedef != null) { file = (MonoSymbolFile) assembly_hash [type.Module.Assembly]; if (file == null) { Console.WriteLine ("Type `{0}' from unknown assembly `{1}'", type, type.Module.Assembly); return null; } return file.LookupMonoType (typedef); } Cecil.ArrayType array = type as Cecil.ArrayType; if (array != null) { TargetType element_type = LookupMonoType (array.ElementType); if (element_type == null) return null; return new MonoArrayType (element_type, array.Rank); } Cecil.ByReferenceType reftype = type as Cecil.ByReferenceType; if (reftype != null) { TargetType element_type = LookupMonoType (reftype.ElementType); if (element_type == null) return null; return new MonoPointerType (element_type); } Cecil.GenericParameter gen_param = type as Cecil.GenericParameter; if (gen_param != null) return new MonoGenericParameterType (this, gen_param.Name); Cecil.GenericInstanceType gen_inst = type as Cecil.GenericInstanceType; if (gen_inst != null) { TargetType[] args = new TargetType [gen_inst.GenericArguments.Count]; for (int i = 0; i < args.Length; i++) { args [i] = LookupMonoType (gen_inst.GenericArguments [i]); if (args [i] == null) return null; } MonoClassType container = LookupMonoType (gen_inst.ElementType) as MonoClassType; if (container == null) return null; return new MonoGenericInstanceType (container, args, TargetAddress.Null); } int rank = 0; string full_name = type.FullName; int pos = full_name.IndexOf ('['); if (pos > 0) { string dim = full_name.Substring (pos); full_name = full_name.Substring (0, pos); if ((dim.Length < 2) || (dim [dim.Length - 1] != ']')) throw new ArgumentException (); for (int i = 1; i < dim.Length - 1; i++) if (dim [i] != ',') throw new ArgumentException (); rank = dim.Length - 1; } TargetType mono_type = LookupType (full_name); if (mono_type == null) return null; if (rank > 0) return new MonoArrayType (mono_type, rank); else return mono_type; }
public static int GetMethodToken(Cecil.MethodDefinition method) { return (int) (method.MetadataToken.TokenType + method.MetadataToken.RID); }
internal MonoClassType CreateCoreType(MonoSymbolFile file, Cecil.TypeDefinition typedef, TargetMemoryAccess memory, TargetAddress klass) { MonoClassType type; MonoClassInfo info = MonoClassInfo.ReadCoreType ( file, typedef, memory, klass, out type); class_info_by_addr.Add (klass, info); return type; }
public static Cecil.MethodDefinition GetMethod(Cecil.ModuleDefinition module, int token) { return (Cecil.MethodDefinition) module.LookupByToken ( Cecil.Metadata.TokenType.Method, token & 0xffffff); }
static void DumpLineNumberTable_internal(TextWriter writer, MonoSymbolFile file, Cecil.MethodDefinition mdef, C.MethodEntry entry) { string full_name = MonoSymbolFile.GetMethodName (mdef); if (mdef.MetadataToken.TokenType != Cecil.Metadata.TokenType.Method) { writer.WriteLine ("UNKNOWN METHOD: {0}", full_name); return; } writer.WriteLine (); writer.WriteLine ("Symfile Line Numbers (file / row / offset):"); writer.WriteLine ("-------------------------------------------"); C.LineNumberEntry[] lnt; lnt = entry.GetLineNumberTable ().LineNumbers; for (int i = 0; i < lnt.Length; i++) { C.LineNumberEntry lne = lnt [i]; writer.WriteLine ("{0,4} {1,4} {2,4} {3,4:x}{4}", i, lne.File, lne.Row, lne.Offset, lne.IsHidden ? " (hidden)" : ""); } writer.WriteLine ("-------------------------------------------"); writer.WriteLine (); List<string> lines; Dictionary<int,int> offsets; if (!DisassembleMethod_internal (file.ImageFile, (int) mdef.MetadataToken.RID, out lines, out offsets)) { writer.WriteLine ("Cannot disassemble method: {0}", full_name); return; } writer.WriteLine ("Disassembling {0}:\n\n{1}\n", full_name, String.Join ("\n", lines.ToArray ())); }
public static int GetMethodToken(Cecil.MethodDefinition method) { return method.MetadataToken.ToInt32 (); }
// This must match mono_type_get_desc() in mono/metadata/debug-helpers.c. protected static string GetTypeSignature(Cecil.TypeReference t) { Cecil.ByReferenceType rtype = t as Cecil.ByReferenceType; if (rtype != null) return GetTypeSignature (rtype.ElementType) + "&"; Cecil.ArrayType atype = t as Cecil.ArrayType; if (atype != null) { string etype = GetTypeSignature (atype.ElementType); if (atype.Rank > 1) return String.Format ("{0}[{1}]", etype, atype.Rank); else return etype + "[]"; } switch (t.FullName) { case "System.Char": return "char"; case "System.Boolean": return "bool"; case "System.Byte": return "byte"; case "System.SByte": return "sbyte"; case "System.Int16": return "int16"; case "System.UInt16": return "uint16"; case "System.Int32": return "int"; case "System.UInt32": return "uint"; case "System.Int64": return "long"; case "System.UInt64": return "ulong"; case "System.Single": return "single"; case "System.Double": return "double"; case "System.String": return "string"; case "System.Object": return "object"; case "System.Decimal": return "decimal"; default: return RemoveGenericArity (t.FullName); } }
public void AddType(Cecil.TypeDefinition typedef, TargetType type) { if (!type_hash.Contains (typedef)) type_hash.Add (typedef, type); }
protected MonoClassType LookupMonoClass(Cecil.TypeReference typeref) { TargetType type = LookupMonoType (typeref); if (type == null) return null; MonoClassType class_type = type as MonoClassType; if (class_type != null) return class_type; if (type.HasClassType) return (MonoClassType) type.ClassType; throw new InternalError ("UNKNOWN TYPE: {0}", type); }
public TypeHashEntry(Cecil.TypeDefinition type) { Token = (int) (type.MetadataToken.TokenType + type.MetadataToken.RID); }
Ast.Expression Convert(Ast.Expression expr, Cecil.TypeReference actualType, Cecil.TypeReference reqType) { if (actualType == null || reqType == null || TypeAnalysis.IsSameType(actualType, reqType)) { return expr; } else if (actualType is ByReferenceType && reqType is PointerType && expr is DirectionExpression) { return Convert( new UnaryOperatorExpression(UnaryOperatorType.AddressOf, ((DirectionExpression)expr).Expression.Detach()), new PointerType(((ByReferenceType)actualType).ElementType), reqType); } else if (actualType is PointerType && reqType is ByReferenceType) { expr = Convert(expr, actualType, new PointerType(((ByReferenceType)reqType).ElementType)); return new DirectionExpression { FieldDirection = FieldDirection.Ref, Expression = new UnaryOperatorExpression(UnaryOperatorType.Dereference, expr) }; } else if (actualType is PointerType && reqType is PointerType) { if (actualType.FullName != reqType.FullName) return expr.CastTo(AstBuilder.ConvertType(reqType)); else return expr; } else { bool actualIsIntegerOrEnum = TypeAnalysis.IsIntegerOrEnum(actualType); bool requiredIsIntegerOrEnum = TypeAnalysis.IsIntegerOrEnum(reqType); if (TypeAnalysis.IsBoolean(reqType)) { if (TypeAnalysis.IsBoolean(actualType)) return expr; if (actualIsIntegerOrEnum) { return new BinaryOperatorExpression(expr, BinaryOperatorType.InEquality, AstBuilder.MakePrimitive(0, actualType)); } else { return new BinaryOperatorExpression(expr, BinaryOperatorType.InEquality, new NullReferenceExpression()); } } if (TypeAnalysis.IsBoolean(actualType) && requiredIsIntegerOrEnum) { return new ConditionalExpression { Condition = expr, TrueExpression = AstBuilder.MakePrimitive(1, reqType), FalseExpression = AstBuilder.MakePrimitive(0, reqType) }; } if (expr is PrimitiveExpression && !requiredIsIntegerOrEnum && TypeAnalysis.IsEnum(actualType)) { return expr.CastTo(AstBuilder.ConvertType(actualType)); } bool actualIsPrimitiveType = actualIsIntegerOrEnum || actualType.MetadataType == MetadataType.Single || actualType.MetadataType == MetadataType.Double; bool requiredIsPrimitiveType = requiredIsIntegerOrEnum || reqType.MetadataType == MetadataType.Single || reqType.MetadataType == MetadataType.Double; if (actualIsPrimitiveType && requiredIsPrimitiveType) { return expr.CastTo(AstBuilder.ConvertType(reqType)); } return expr; } }
public MdbSymbolReader(Cecil.AssemblyDefinition asm, MonoSymbolFile file) { this.Assembly = asm; this.File = file; }