mirror of
https://github.com/Smaug123/WoofWare.PawPrint
synced 2025-10-05 06:08:39 +00:00
774 lines
40 KiB
Forth
774 lines
40 KiB
Forth
namespace WoofWare.PawPrint
|
|
|
|
#nowarn "9"
|
|
|
|
open System
|
|
open System.Collections.Generic
|
|
open System.Collections.Immutable
|
|
open System.Reflection
|
|
open System.Reflection.Metadata
|
|
open System.Reflection.PortableExecutable
|
|
open Microsoft.Extensions.Logging
|
|
|
|
/// <summary>
|
|
/// Represents information about a method parameter.
|
|
/// Corresponds to Parameter in System.Reflection.Metadata.
|
|
/// </summary>
|
|
type Parameter =
|
|
{
|
|
/// <summary>The name of the parameter.</summary>
|
|
Name : string
|
|
|
|
/// <summary>
|
|
/// The default value of the parameter, if one is specified.
|
|
/// This is used for optional parameters.
|
|
/// </summary>
|
|
DefaultValue : Constant
|
|
|
|
/// <summary>
|
|
/// The position of the parameter in the parameter list.
|
|
/// For instance methods, index 0 is the 'this' parameter.
|
|
/// </summary>
|
|
SequenceNumber : int
|
|
}
|
|
|
|
[<RequireQualifiedAccess>]
|
|
module Parameter =
|
|
let readAll (metadata : MetadataReader) (param : ParameterHandleCollection) : Parameter ImmutableArray =
|
|
let result = ImmutableArray.CreateBuilder ()
|
|
|
|
for param in param do
|
|
let param = metadata.GetParameter param
|
|
|
|
// The spec doesn't seem to mention this behaviour, but a sequence number of 0 (and an unnamed parameter)
|
|
// seems to correspond with a ref return.
|
|
if param.SequenceNumber <> 0 then
|
|
{
|
|
Name = metadata.GetString param.Name
|
|
DefaultValue = metadata.GetConstant (param.GetDefaultValue ())
|
|
SequenceNumber = param.SequenceNumber
|
|
}
|
|
|> result.Add
|
|
|
|
result.ToImmutable ()
|
|
|
|
type ExceptionOffset =
|
|
{
|
|
TryLength : int
|
|
TryOffset : int
|
|
HandlerLength : int
|
|
HandlerOffset : int
|
|
}
|
|
|
|
type ExceptionRegion =
|
|
| Filter of filterOffset : int * ExceptionOffset
|
|
/// Token is a TypeRef, TypeDef, or TypeSpec
|
|
| Catch of MetadataToken * ExceptionOffset
|
|
| Finally of ExceptionOffset
|
|
| Fault of ExceptionOffset
|
|
|
|
static member OfExceptionRegion (r : System.Reflection.Metadata.ExceptionRegion) : ExceptionRegion =
|
|
let offset =
|
|
{
|
|
HandlerLength = r.HandlerLength
|
|
HandlerOffset = r.HandlerOffset
|
|
TryLength = r.TryLength
|
|
TryOffset = r.TryOffset
|
|
}
|
|
|
|
match r.Kind with
|
|
| ExceptionRegionKind.Catch -> ExceptionRegion.Catch (MetadataToken.ofEntityHandle r.CatchType, offset)
|
|
| ExceptionRegionKind.Filter -> ExceptionRegion.Filter (r.FilterOffset, offset)
|
|
| ExceptionRegionKind.Finally -> ExceptionRegion.Finally offset
|
|
| ExceptionRegionKind.Fault -> ExceptionRegion.Fault offset
|
|
| _ -> raise (ArgumentOutOfRangeException ())
|
|
|
|
type MethodInstructions<'methodVars> =
|
|
{
|
|
/// <summary>
|
|
/// The IL instructions that compose the method body, along with their offset positions.
|
|
/// Each tuple contains the instruction and its offset in the method body.
|
|
/// </summary>
|
|
Instructions : (IlOp * int) list
|
|
|
|
/// <summary>
|
|
/// A map from instruction offset (program counter) to the corresponding IL operation.
|
|
/// This is the inverse of Instructions for efficient lookup.
|
|
/// </summary>
|
|
Locations : Map<int, IlOp>
|
|
|
|
/// <summary>
|
|
/// Whether local variables in this method should be initialized to their default values.
|
|
/// This corresponds to the localsinit flag in the method header.
|
|
/// </summary>
|
|
LocalsInit : bool
|
|
|
|
LocalVars : ImmutableArray<'methodVars> option
|
|
|
|
ExceptionRegions : ImmutableArray<ExceptionRegion>
|
|
}
|
|
|
|
[<RequireQualifiedAccess>]
|
|
module MethodInstructions =
|
|
let onlyRet () : MethodInstructions<'methodVars> =
|
|
let op = IlOp.Nullary NullaryIlOp.Ret
|
|
|
|
{
|
|
Instructions = [ op, 0 ]
|
|
Locations = Map.empty |> Map.add 0 op
|
|
LocalsInit = false
|
|
LocalVars = None
|
|
ExceptionRegions = ImmutableArray.Empty
|
|
}
|
|
|
|
let setLocalVars<'a, 'b> (v : ImmutableArray<'b> option) (s : MethodInstructions<'a>) : MethodInstructions<'b> =
|
|
{
|
|
Instructions = s.Instructions
|
|
Locations = s.Locations
|
|
LocalsInit = s.LocalsInit
|
|
LocalVars = v
|
|
ExceptionRegions = s.ExceptionRegions
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents detailed information about a method in a .NET assembly.
|
|
/// This is a strongly-typed representation of MethodDefinition from System.Reflection.Metadata.
|
|
/// </summary>
|
|
type MethodInfo<'typeGenerics, 'methodGenerics, 'methodVars> =
|
|
{
|
|
/// <summary>
|
|
/// The type that declares this method, along with its assembly information.
|
|
/// </summary>
|
|
DeclaringType : ConcreteType<'typeGenerics>
|
|
|
|
/// <summary>
|
|
/// The metadata token handle that uniquely identifies this method in the assembly.
|
|
/// </summary>
|
|
Handle : MethodDefinitionHandle
|
|
|
|
/// <summary>The name of the method.</summary>
|
|
Name : string
|
|
|
|
/// <summary>
|
|
/// The IL instructions that compose the method body, along with their offset positions.
|
|
///
|
|
/// There may be no instructions for this method, e.g. if it's an `InternalCall`.
|
|
/// </summary>
|
|
Instructions : MethodInstructions<'methodVars> option
|
|
|
|
/// <summary>
|
|
/// The parameters of this method.
|
|
/// </summary>
|
|
Parameters : Parameter ImmutableArray
|
|
|
|
/// <summary>
|
|
/// The generic type parameters defined by this method, if any.
|
|
/// </summary>
|
|
Generics : 'methodGenerics ImmutableArray
|
|
|
|
/// <summary>
|
|
/// The signature of the method, including return type and parameter types.
|
|
/// </summary>
|
|
Signature : TypeMethodSignature<'methodVars>
|
|
|
|
/// <summary>
|
|
/// The signature as it was read from assembly metadata.
|
|
/// </summary>
|
|
RawSignature : TypeMethodSignature<TypeDefn>
|
|
|
|
/// <summary>
|
|
/// Custom attributes defined on the method. I've never yet seen one of these in practice.
|
|
/// </summary>
|
|
CustomAttributes : WoofWare.PawPrint.CustomAttribute ImmutableArray
|
|
|
|
MethodAttributes : MethodAttributes
|
|
|
|
ImplAttributes : MethodImplAttributes
|
|
|
|
/// <summary>
|
|
/// Whether this method is static (true) or an instance method (false).
|
|
/// </summary>
|
|
IsStatic : bool
|
|
}
|
|
|
|
override this.ToString () =
|
|
$"{this.DeclaringType.Assembly.Name}.{this.DeclaringType.Name}.{this.Name}"
|
|
|
|
/// <summary>
|
|
/// Whether this method's implementation is directly supplied by the CLI, rather than being loaded
|
|
/// from an assembly as IL.
|
|
/// </summary>
|
|
member this.IsCliInternal : bool =
|
|
this.ImplAttributes.HasFlag MethodImplAttributes.InternalCall
|
|
|
|
/// <summary>
|
|
/// Whether this method is implemented as a platform invoke (P/Invoke) to unmanaged code.
|
|
/// </summary>
|
|
member this.IsPinvokeImpl : bool =
|
|
this.MethodAttributes.HasFlag MethodAttributes.PinvokeImpl
|
|
|
|
[<RequireQualifiedAccess>]
|
|
module MethodInfo =
|
|
let isJITIntrinsic
|
|
(getMemberRefParentType : MemberReferenceHandle -> TypeRef)
|
|
(methodDefs : IReadOnlyDictionary<MethodDefinitionHandle, MethodInfo<'a, 'b, 'c>>)
|
|
(this : MethodInfo<'d, 'e, 'f>)
|
|
: bool
|
|
=
|
|
this.CustomAttributes
|
|
|> Seq.exists (fun attr ->
|
|
match attr.Constructor with
|
|
| MetadataToken.MethodDef handle ->
|
|
let constructor = methodDefs.[handle]
|
|
|
|
constructor.DeclaringType.Name = "IntrinsicAttribute"
|
|
&& constructor.DeclaringType.Assembly.FullName.StartsWith (
|
|
"System.Private.CoreLib, ",
|
|
StringComparison.Ordinal
|
|
)
|
|
| MetadataToken.MemberReference handle ->
|
|
let ty = getMemberRefParentType handle
|
|
ty.Namespace = "System" && ty.Name = "IntrinsicAttribute"
|
|
| con -> failwith $"TODO: {con}"
|
|
)
|
|
|
|
let mapTypeGenerics<'a, 'b, 'methodGen, 'vars>
|
|
(f : 'a -> 'b)
|
|
(m : MethodInfo<'a, 'methodGen, 'vars>)
|
|
: MethodInfo<'b, 'methodGen, 'vars>
|
|
=
|
|
{
|
|
DeclaringType = m.DeclaringType |> ConcreteType.mapGeneric (fun _ -> f)
|
|
Handle = m.Handle
|
|
Name = m.Name
|
|
Instructions = m.Instructions
|
|
Parameters = m.Parameters
|
|
Generics = m.Generics
|
|
Signature = m.Signature
|
|
RawSignature = m.RawSignature
|
|
CustomAttributes = m.CustomAttributes
|
|
MethodAttributes = m.MethodAttributes
|
|
ImplAttributes = m.ImplAttributes
|
|
IsStatic = m.IsStatic
|
|
}
|
|
|
|
let mapMethodGenerics<'a, 'b, 'vars, 'typeGen>
|
|
(f : int -> 'a -> 'b)
|
|
(m : MethodInfo<'typeGen, 'a, 'vars>)
|
|
: MethodInfo<'typeGen, 'b, 'vars>
|
|
=
|
|
let generics = m.Generics |> Seq.mapi f |> ImmutableArray.CreateRange
|
|
|
|
{
|
|
DeclaringType = m.DeclaringType
|
|
Handle = m.Handle
|
|
Name = m.Name
|
|
Instructions = m.Instructions
|
|
Parameters = m.Parameters
|
|
Generics = generics
|
|
Signature = m.Signature
|
|
RawSignature = m.RawSignature
|
|
CustomAttributes = m.CustomAttributes
|
|
MethodAttributes = m.MethodAttributes
|
|
ImplAttributes = m.ImplAttributes
|
|
IsStatic = m.IsStatic
|
|
}
|
|
|
|
let setMethodVars
|
|
(vars2 : MethodInstructions<'vars2> option)
|
|
(signature : TypeMethodSignature<'vars2>)
|
|
(m : MethodInfo<'typeGen, 'methodGen, 'vars1>)
|
|
: MethodInfo<'typeGen, 'methodGen, 'vars2>
|
|
=
|
|
{
|
|
DeclaringType = m.DeclaringType
|
|
Handle = m.Handle
|
|
Name = m.Name
|
|
Instructions = vars2
|
|
Parameters = m.Parameters
|
|
Generics = m.Generics
|
|
Signature = signature
|
|
RawSignature = m.RawSignature
|
|
CustomAttributes = m.CustomAttributes
|
|
MethodAttributes = m.MethodAttributes
|
|
ImplAttributes = m.ImplAttributes
|
|
IsStatic = m.IsStatic
|
|
}
|
|
|
|
type private Dummy = class end
|
|
|
|
type private MethodBody =
|
|
{
|
|
Instructions : (IlOp * int) list
|
|
LocalInit : bool
|
|
LocalSig : ImmutableArray<TypeDefn> option
|
|
MaxStackSize : int
|
|
ExceptionRegions : ImmutableArray<ExceptionRegion>
|
|
}
|
|
|
|
let private readMetadataToken (reader : byref<BlobReader>) : MetadataToken =
|
|
reader.ReadUInt32 () |> int |> MetadataToken.ofInt
|
|
|
|
let private readStringToken (reader : byref<BlobReader>) : StringToken =
|
|
let value = reader.ReadUInt32 () |> int
|
|
StringToken.ofInt value
|
|
|
|
// TODO: each opcode probably ought to store how many bytes it takes, so we can advance the program counter?
|
|
let private readOpCode (reader : byref<BlobReader>) : ILOpCode =
|
|
let op = reader.ReadByte ()
|
|
|
|
if op = 0xFEuy then
|
|
let op2 = reader.ReadByte ()
|
|
LanguagePrimitives.EnumOfValue (0xFE00us ||| (uint16 op2))
|
|
else
|
|
LanguagePrimitives.EnumOfValue (uint16 op)
|
|
|
|
let private readMethodBody
|
|
(peReader : PEReader)
|
|
(metadataReader : MetadataReader)
|
|
(assembly : AssemblyName)
|
|
(methodDef : MethodDefinition)
|
|
: MethodBody option
|
|
=
|
|
if methodDef.RelativeVirtualAddress = 0 then
|
|
None
|
|
else
|
|
let methodBody = peReader.GetMethodBody methodDef.RelativeVirtualAddress
|
|
|
|
let localSig =
|
|
if methodBody.LocalSignature.IsNil then
|
|
None
|
|
else
|
|
|
|
let s = methodBody.LocalSignature |> metadataReader.GetStandaloneSignature
|
|
s.DecodeLocalSignature (TypeDefn.typeProvider assembly, ()) |> Some
|
|
|
|
let ilBytes = methodBody.GetILBytes ()
|
|
use bytes = fixed ilBytes
|
|
let mutable reader : BlobReader = BlobReader (bytes, ilBytes.Length)
|
|
|
|
let rec readInstructions acc =
|
|
if reader.Offset >= ilBytes.Length then
|
|
List.rev acc
|
|
else
|
|
let offset = reader.Offset
|
|
let opCode = readOpCode (&reader)
|
|
|
|
let opCode =
|
|
match opCode with
|
|
| ILOpCode.Nop -> IlOp.Nullary NullaryIlOp.Nop
|
|
| ILOpCode.Break -> IlOp.Nullary NullaryIlOp.Break
|
|
| ILOpCode.Ldarg_0 -> IlOp.Nullary NullaryIlOp.LdArg0
|
|
| ILOpCode.Ldarg_1 -> IlOp.Nullary NullaryIlOp.LdArg1
|
|
| ILOpCode.Ldarg_2 -> IlOp.Nullary NullaryIlOp.LdArg2
|
|
| ILOpCode.Ldarg_3 -> IlOp.Nullary NullaryIlOp.LdArg3
|
|
| ILOpCode.Ldloc_0 -> IlOp.Nullary NullaryIlOp.Ldloc_0
|
|
| ILOpCode.Ldloc_1 -> IlOp.Nullary NullaryIlOp.Ldloc_1
|
|
| ILOpCode.Ldloc_2 -> IlOp.Nullary NullaryIlOp.Ldloc_2
|
|
| ILOpCode.Ldloc_3 -> IlOp.Nullary NullaryIlOp.Ldloc_3
|
|
| ILOpCode.Stloc_0 -> IlOp.Nullary NullaryIlOp.Stloc_0
|
|
| ILOpCode.Stloc_1 -> IlOp.Nullary NullaryIlOp.Stloc_1
|
|
| ILOpCode.Stloc_2 -> IlOp.Nullary NullaryIlOp.Stloc_2
|
|
| ILOpCode.Stloc_3 -> IlOp.Nullary NullaryIlOp.Stloc_3
|
|
| ILOpCode.Ldarg_s -> IlOp.UnaryConst (UnaryConstIlOp.Ldarg_s (reader.ReadByte ()))
|
|
| ILOpCode.Ldarga_s -> IlOp.UnaryConst (UnaryConstIlOp.Ldarga_s (reader.ReadByte ()))
|
|
| ILOpCode.Starg_s -> IlOp.UnaryConst (UnaryConstIlOp.Starg_s (reader.ReadByte ()))
|
|
| ILOpCode.Ldloc_s -> IlOp.UnaryConst (UnaryConstIlOp.Ldloc_s (reader.ReadByte ()))
|
|
| ILOpCode.Ldloca_s -> IlOp.UnaryConst (UnaryConstIlOp.Ldloca_s (reader.ReadByte ()))
|
|
| ILOpCode.Stloc_s -> IlOp.UnaryConst (UnaryConstIlOp.Stloc_s (reader.ReadSByte ()))
|
|
| ILOpCode.Ldnull -> IlOp.Nullary NullaryIlOp.LdNull
|
|
| ILOpCode.Ldc_i4_m1 -> IlOp.Nullary NullaryIlOp.LdcI4_m1
|
|
| ILOpCode.Ldc_i4_0 -> IlOp.Nullary NullaryIlOp.LdcI4_0
|
|
| ILOpCode.Ldc_i4_1 -> IlOp.Nullary NullaryIlOp.LdcI4_1
|
|
| ILOpCode.Ldc_i4_2 -> IlOp.Nullary NullaryIlOp.LdcI4_2
|
|
| ILOpCode.Ldc_i4_3 -> IlOp.Nullary NullaryIlOp.LdcI4_3
|
|
| ILOpCode.Ldc_i4_4 -> IlOp.Nullary NullaryIlOp.LdcI4_4
|
|
| ILOpCode.Ldc_i4_5 -> IlOp.Nullary NullaryIlOp.LdcI4_5
|
|
| ILOpCode.Ldc_i4_6 -> IlOp.Nullary NullaryIlOp.LdcI4_6
|
|
| ILOpCode.Ldc_i4_7 -> IlOp.Nullary NullaryIlOp.LdcI4_7
|
|
| ILOpCode.Ldc_i4_8 -> IlOp.Nullary NullaryIlOp.LdcI4_8
|
|
| ILOpCode.Ldc_i4_s -> IlOp.UnaryConst (UnaryConstIlOp.Ldc_I4_s (reader.ReadSByte ()))
|
|
| ILOpCode.Ldc_i4 -> IlOp.UnaryConst (UnaryConstIlOp.Ldc_I4 (reader.ReadInt32 ()))
|
|
| ILOpCode.Ldc_i8 -> IlOp.UnaryConst (UnaryConstIlOp.Ldc_I8 (reader.ReadInt64 ()))
|
|
| ILOpCode.Ldc_r4 -> IlOp.UnaryConst (UnaryConstIlOp.Ldc_R4 (reader.ReadSingle ()))
|
|
| ILOpCode.Ldc_r8 -> IlOp.UnaryConst (UnaryConstIlOp.Ldc_R8 (reader.ReadDouble ()))
|
|
| ILOpCode.Dup -> IlOp.Nullary NullaryIlOp.Dup
|
|
| ILOpCode.Pop -> IlOp.Nullary NullaryIlOp.Pop
|
|
| ILOpCode.Jmp ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Jmp, readMetadataToken &reader)
|
|
| ILOpCode.Call ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Call, readMetadataToken &reader)
|
|
| ILOpCode.Calli ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Calli, readMetadataToken &reader)
|
|
| ILOpCode.Ret -> IlOp.Nullary NullaryIlOp.Ret
|
|
| ILOpCode.Br_s -> IlOp.UnaryConst (UnaryConstIlOp.Br_s (reader.ReadSByte ()))
|
|
| ILOpCode.Brfalse_s -> IlOp.UnaryConst (UnaryConstIlOp.Brfalse_s (reader.ReadSByte ()))
|
|
| ILOpCode.Brtrue_s -> IlOp.UnaryConst (UnaryConstIlOp.Brtrue_s (reader.ReadSByte ()))
|
|
| ILOpCode.Beq_s -> IlOp.UnaryConst (UnaryConstIlOp.Beq_s (reader.ReadSByte ()))
|
|
| ILOpCode.Bge_s -> IlOp.UnaryConst (UnaryConstIlOp.Bge_s (reader.ReadSByte ()))
|
|
| ILOpCode.Bgt_s -> IlOp.UnaryConst (UnaryConstIlOp.Bgt_s (reader.ReadSByte ()))
|
|
| ILOpCode.Ble_s -> IlOp.UnaryConst (UnaryConstIlOp.Ble_s (reader.ReadSByte ()))
|
|
| ILOpCode.Blt_s -> IlOp.UnaryConst (UnaryConstIlOp.Blt_s (reader.ReadSByte ()))
|
|
| ILOpCode.Bne_un_s -> IlOp.UnaryConst (UnaryConstIlOp.Bne_un_s (reader.ReadSByte ()))
|
|
| ILOpCode.Bge_un_s -> IlOp.UnaryConst (UnaryConstIlOp.Bge_un_s (reader.ReadSByte ()))
|
|
| ILOpCode.Bgt_un_s -> IlOp.UnaryConst (UnaryConstIlOp.Bgt_un_s (reader.ReadSByte ()))
|
|
| ILOpCode.Ble_un_s -> IlOp.UnaryConst (UnaryConstIlOp.Ble_un_s (reader.ReadSByte ()))
|
|
| ILOpCode.Blt_un_s -> IlOp.UnaryConst (UnaryConstIlOp.Blt_un_s (reader.ReadSByte ()))
|
|
| ILOpCode.Br -> IlOp.UnaryConst (UnaryConstIlOp.Br (reader.ReadInt32 ()))
|
|
| ILOpCode.Brfalse -> IlOp.UnaryConst (UnaryConstIlOp.Brfalse (reader.ReadInt32 ()))
|
|
| ILOpCode.Brtrue -> IlOp.UnaryConst (UnaryConstIlOp.Brtrue (reader.ReadInt32 ()))
|
|
| ILOpCode.Beq -> IlOp.UnaryConst (UnaryConstIlOp.Beq (reader.ReadInt32 ()))
|
|
| ILOpCode.Bge -> IlOp.UnaryConst (UnaryConstIlOp.Bge (reader.ReadInt32 ()))
|
|
| ILOpCode.Bgt -> IlOp.UnaryConst (UnaryConstIlOp.Bgt (reader.ReadInt32 ()))
|
|
| ILOpCode.Ble -> IlOp.UnaryConst (UnaryConstIlOp.Ble (reader.ReadInt32 ()))
|
|
| ILOpCode.Blt -> IlOp.UnaryConst (UnaryConstIlOp.Blt (reader.ReadInt32 ()))
|
|
| ILOpCode.Bne_un -> IlOp.UnaryConst (UnaryConstIlOp.Bne_un (reader.ReadInt32 ()))
|
|
| ILOpCode.Bge_un -> IlOp.UnaryConst (UnaryConstIlOp.Bge_un (reader.ReadInt32 ()))
|
|
| ILOpCode.Bgt_un -> IlOp.UnaryConst (UnaryConstIlOp.Bgt_un (reader.ReadInt32 ()))
|
|
| ILOpCode.Ble_un -> IlOp.UnaryConst (UnaryConstIlOp.Ble_un (reader.ReadInt32 ()))
|
|
| ILOpCode.Blt_un -> IlOp.UnaryConst (UnaryConstIlOp.Blt_un (reader.ReadInt32 ()))
|
|
| ILOpCode.Switch ->
|
|
let count = reader.ReadUInt32 ()
|
|
|
|
if count > uint32 System.Int32.MaxValue then
|
|
failwith "Debugger error: can't create a jump table with more than int32.Max entries"
|
|
|
|
let count = int count
|
|
let result = ImmutableArray.CreateBuilder count
|
|
|
|
for i = 0 to count - 1 do
|
|
result.Add (reader.ReadInt32 ())
|
|
|
|
IlOp.Switch (result.ToImmutable ())
|
|
| ILOpCode.Ldind_i -> IlOp.Nullary NullaryIlOp.Ldind_i
|
|
| ILOpCode.Ldind_i1 -> IlOp.Nullary NullaryIlOp.Ldind_i1
|
|
| ILOpCode.Ldind_u1 -> IlOp.Nullary NullaryIlOp.Ldind_u1
|
|
| ILOpCode.Ldind_i2 -> IlOp.Nullary NullaryIlOp.Ldind_i2
|
|
| ILOpCode.Ldind_u2 -> IlOp.Nullary NullaryIlOp.Ldind_u2
|
|
| ILOpCode.Ldind_i4 -> IlOp.Nullary NullaryIlOp.Ldind_i4
|
|
| ILOpCode.Ldind_u4 -> IlOp.Nullary NullaryIlOp.Ldind_u4
|
|
| ILOpCode.Ldind_i8 -> IlOp.Nullary NullaryIlOp.Ldind_i8
|
|
| ILOpCode.Ldind_r4 -> IlOp.Nullary NullaryIlOp.Ldind_r4
|
|
| ILOpCode.Ldind_r8 -> IlOp.Nullary NullaryIlOp.Ldind_r8
|
|
| ILOpCode.Ldind_ref -> IlOp.Nullary NullaryIlOp.Ldind_ref
|
|
| ILOpCode.Stind_ref -> IlOp.Nullary NullaryIlOp.Stind_ref
|
|
| ILOpCode.Stind_i1 -> IlOp.Nullary NullaryIlOp.Stind_I1
|
|
| ILOpCode.Stind_i2 -> IlOp.Nullary NullaryIlOp.Stind_I2
|
|
| ILOpCode.Stind_i4 -> IlOp.Nullary NullaryIlOp.Stind_I4
|
|
| ILOpCode.Stind_i8 -> IlOp.Nullary NullaryIlOp.Stind_I8
|
|
| ILOpCode.Stind_r4 -> IlOp.Nullary NullaryIlOp.Stind_R4
|
|
| ILOpCode.Stind_r8 -> IlOp.Nullary NullaryIlOp.Stind_R8
|
|
| ILOpCode.Add -> IlOp.Nullary NullaryIlOp.Add
|
|
| ILOpCode.Sub -> IlOp.Nullary NullaryIlOp.Sub
|
|
| ILOpCode.Mul -> IlOp.Nullary NullaryIlOp.Mul
|
|
| ILOpCode.Div -> IlOp.Nullary NullaryIlOp.Div
|
|
| ILOpCode.Div_un -> IlOp.Nullary NullaryIlOp.Div_un
|
|
| ILOpCode.Rem -> IlOp.Nullary NullaryIlOp.Rem
|
|
| ILOpCode.Rem_un -> IlOp.Nullary NullaryIlOp.Rem_un
|
|
| ILOpCode.And -> IlOp.Nullary NullaryIlOp.And
|
|
| ILOpCode.Or -> IlOp.Nullary NullaryIlOp.Or
|
|
| ILOpCode.Xor -> IlOp.Nullary NullaryIlOp.Xor
|
|
| ILOpCode.Shl -> IlOp.Nullary NullaryIlOp.Shl
|
|
| ILOpCode.Shr -> IlOp.Nullary NullaryIlOp.Shr
|
|
| ILOpCode.Shr_un -> IlOp.Nullary NullaryIlOp.Shr_un
|
|
| ILOpCode.Neg -> IlOp.Nullary NullaryIlOp.Neg
|
|
| ILOpCode.Not -> IlOp.Nullary NullaryIlOp.Not
|
|
| ILOpCode.Conv_i1 -> IlOp.Nullary NullaryIlOp.Conv_I1
|
|
| ILOpCode.Conv_i2 -> IlOp.Nullary NullaryIlOp.Conv_I2
|
|
| ILOpCode.Conv_i4 -> IlOp.Nullary NullaryIlOp.Conv_I4
|
|
| ILOpCode.Conv_i8 -> IlOp.Nullary NullaryIlOp.Conv_I8
|
|
| ILOpCode.Conv_r4 -> IlOp.Nullary NullaryIlOp.Conv_R4
|
|
| ILOpCode.Conv_r8 -> IlOp.Nullary NullaryIlOp.Conv_R8
|
|
| ILOpCode.Conv_u4 -> IlOp.Nullary NullaryIlOp.Conv_U4
|
|
| ILOpCode.Conv_u8 -> IlOp.Nullary NullaryIlOp.Conv_U8
|
|
| ILOpCode.Callvirt ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Callvirt, readMetadataToken &reader)
|
|
| ILOpCode.Cpobj ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Cpobj, readMetadataToken &reader)
|
|
| ILOpCode.Ldobj ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Ldobj, readMetadataToken &reader)
|
|
| ILOpCode.Ldstr -> IlOp.UnaryStringToken (UnaryStringTokenIlOp.Ldstr, readStringToken &reader)
|
|
| ILOpCode.Newobj ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Newobj, readMetadataToken &reader)
|
|
| ILOpCode.Castclass ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Castclass, readMetadataToken &reader)
|
|
| ILOpCode.Isinst ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Isinst, readMetadataToken &reader)
|
|
| ILOpCode.Conv_r_un -> IlOp.Nullary NullaryIlOp.Conv_r_un
|
|
| ILOpCode.Unbox ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Unbox, readMetadataToken &reader)
|
|
| ILOpCode.Throw -> IlOp.Nullary NullaryIlOp.Throw
|
|
| ILOpCode.Ldfld ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Ldfld, readMetadataToken &reader)
|
|
| ILOpCode.Ldflda ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Ldflda, readMetadataToken &reader)
|
|
| ILOpCode.Stfld ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Stfld, readMetadataToken &reader)
|
|
| ILOpCode.Ldsfld ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Ldsfld, readMetadataToken &reader)
|
|
| ILOpCode.Ldsflda ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Ldsflda, readMetadataToken &reader)
|
|
| ILOpCode.Stsfld ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Stsfld, readMetadataToken &reader)
|
|
| ILOpCode.Stobj ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Stobj, readMetadataToken &reader)
|
|
| ILOpCode.Conv_ovf_i_un -> IlOp.Nullary NullaryIlOp.Conv_ovf_i_un
|
|
| ILOpCode.Conv_ovf_i1_un -> IlOp.Nullary NullaryIlOp.Conv_ovf_i1_un
|
|
| ILOpCode.Conv_ovf_i2_un -> IlOp.Nullary NullaryIlOp.Conv_ovf_i2_un
|
|
| ILOpCode.Conv_ovf_i4_un -> IlOp.Nullary NullaryIlOp.Conv_ovf_i4_un
|
|
| ILOpCode.Conv_ovf_i8_un -> IlOp.Nullary NullaryIlOp.Conv_ovf_i8_un
|
|
| ILOpCode.Conv_ovf_u_un -> IlOp.Nullary NullaryIlOp.Conv_ovf_u_un
|
|
| ILOpCode.Conv_ovf_u1_un -> IlOp.Nullary NullaryIlOp.Conv_ovf_u1_un
|
|
| ILOpCode.Conv_ovf_u2_un -> IlOp.Nullary NullaryIlOp.Conv_ovf_u2_un
|
|
| ILOpCode.Conv_ovf_u4_un -> IlOp.Nullary NullaryIlOp.Conv_ovf_u4_un
|
|
| ILOpCode.Conv_ovf_u8_un -> IlOp.Nullary NullaryIlOp.Conv_ovf_u8_un
|
|
| ILOpCode.Box ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Box, readMetadataToken &reader)
|
|
| ILOpCode.Newarr ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Newarr, readMetadataToken &reader)
|
|
| ILOpCode.Ldlen -> IlOp.Nullary NullaryIlOp.LdLen
|
|
| ILOpCode.Ldelema ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Ldelema, readMetadataToken &reader)
|
|
| ILOpCode.Ldelem_i1 -> IlOp.Nullary NullaryIlOp.Ldelem_i1
|
|
| ILOpCode.Ldelem_u1 -> IlOp.Nullary NullaryIlOp.Ldelem_u1
|
|
| ILOpCode.Ldelem_i2 -> IlOp.Nullary NullaryIlOp.Ldelem_i2
|
|
| ILOpCode.Ldelem_u2 -> IlOp.Nullary NullaryIlOp.Ldelem_u2
|
|
| ILOpCode.Ldelem_i4 -> IlOp.Nullary NullaryIlOp.Ldelem_i4
|
|
| ILOpCode.Ldelem_u4 -> IlOp.Nullary NullaryIlOp.Ldelem_u4
|
|
| ILOpCode.Ldelem_i8 -> IlOp.Nullary NullaryIlOp.Ldelem_i8
|
|
| ILOpCode.Ldelem_i -> IlOp.Nullary NullaryIlOp.Ldelem_i
|
|
| ILOpCode.Ldelem_r4 -> IlOp.Nullary NullaryIlOp.Ldelem_r4
|
|
| ILOpCode.Ldelem_r8 -> IlOp.Nullary NullaryIlOp.Ldelem_r8
|
|
| ILOpCode.Ldelem_ref -> IlOp.Nullary NullaryIlOp.Ldelem_ref
|
|
| ILOpCode.Stelem_i -> IlOp.Nullary NullaryIlOp.Stelem_i
|
|
| ILOpCode.Stelem_i1 -> IlOp.Nullary NullaryIlOp.Stelem_i1
|
|
| ILOpCode.Stelem_i2 -> IlOp.Nullary NullaryIlOp.Stelem_i2
|
|
| ILOpCode.Stelem_i4 -> IlOp.Nullary NullaryIlOp.Stelem_i4
|
|
| ILOpCode.Stelem_i8 -> IlOp.Nullary NullaryIlOp.Stelem_i8
|
|
| ILOpCode.Stelem_r4 -> IlOp.Nullary NullaryIlOp.Stelem_r4
|
|
| ILOpCode.Stelem_r8 -> IlOp.Nullary NullaryIlOp.Stelem_r8
|
|
| ILOpCode.Stelem_ref -> IlOp.Nullary NullaryIlOp.Stelem_ref
|
|
| ILOpCode.Ldelem ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Ldelem, readMetadataToken &reader)
|
|
| ILOpCode.Stelem ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Stelem, readMetadataToken &reader)
|
|
| ILOpCode.Unbox_any ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Unbox_Any, readMetadataToken &reader)
|
|
| ILOpCode.Conv_ovf_i1 -> IlOp.Nullary NullaryIlOp.Conv_ovf_i1
|
|
| ILOpCode.Conv_ovf_u1 -> IlOp.Nullary NullaryIlOp.Conv_ovf_u1
|
|
| ILOpCode.Conv_ovf_i2 -> IlOp.Nullary NullaryIlOp.Conv_ovf_i2
|
|
| ILOpCode.Conv_ovf_u2 -> IlOp.Nullary NullaryIlOp.Conv_ovf_u2
|
|
| ILOpCode.Conv_ovf_i4 -> IlOp.Nullary NullaryIlOp.Conv_ovf_i4
|
|
| ILOpCode.Conv_ovf_u4 -> IlOp.Nullary NullaryIlOp.Conv_ovf_u4
|
|
| ILOpCode.Conv_ovf_i8 -> IlOp.Nullary NullaryIlOp.Conv_ovf_i8
|
|
| ILOpCode.Conv_ovf_u8 -> IlOp.Nullary NullaryIlOp.Conv_ovf_u8
|
|
| ILOpCode.Refanyval ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Refanyval, readMetadataToken &reader)
|
|
| ILOpCode.Ckfinite -> IlOp.Nullary NullaryIlOp.Ckfinite
|
|
| ILOpCode.Mkrefany ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Mkrefany, readMetadataToken &reader)
|
|
| ILOpCode.Ldtoken ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Ldtoken, readMetadataToken &reader)
|
|
| ILOpCode.Conv_u2 -> IlOp.Nullary NullaryIlOp.Conv_U2
|
|
| ILOpCode.Conv_u1 -> IlOp.Nullary NullaryIlOp.Conv_U1
|
|
| ILOpCode.Conv_i -> IlOp.Nullary NullaryIlOp.Conv_I
|
|
| ILOpCode.Conv_ovf_i -> IlOp.Nullary NullaryIlOp.Conv_ovf_i
|
|
| ILOpCode.Conv_ovf_u -> IlOp.Nullary NullaryIlOp.Conv_ovf_u
|
|
| ILOpCode.Add_ovf -> IlOp.Nullary NullaryIlOp.Add_ovf
|
|
| ILOpCode.Add_ovf_un -> IlOp.Nullary NullaryIlOp.Add_ovf_un
|
|
| ILOpCode.Mul_ovf -> IlOp.Nullary NullaryIlOp.Mul_ovf
|
|
| ILOpCode.Mul_ovf_un -> IlOp.Nullary NullaryIlOp.Mul_ovf_un
|
|
| ILOpCode.Sub_ovf -> IlOp.Nullary NullaryIlOp.Sub_ovf
|
|
| ILOpCode.Sub_ovf_un -> IlOp.Nullary NullaryIlOp.Sub_ovf_un
|
|
| ILOpCode.Endfinally -> IlOp.Nullary NullaryIlOp.Endfinally
|
|
| ILOpCode.Leave -> IlOp.UnaryConst (UnaryConstIlOp.Leave (reader.ReadInt32 ()))
|
|
| ILOpCode.Leave_s -> IlOp.UnaryConst (UnaryConstIlOp.Leave_s (reader.ReadSByte ()))
|
|
| ILOpCode.Stind_i -> IlOp.Nullary NullaryIlOp.Stind_I
|
|
| ILOpCode.Conv_u -> IlOp.Nullary NullaryIlOp.Conv_U
|
|
| ILOpCode.Arglist -> IlOp.Nullary NullaryIlOp.Arglist
|
|
| ILOpCode.Ceq -> IlOp.Nullary NullaryIlOp.Ceq
|
|
| ILOpCode.Cgt -> IlOp.Nullary NullaryIlOp.Cgt
|
|
| ILOpCode.Cgt_un -> IlOp.Nullary NullaryIlOp.Cgt_un
|
|
| ILOpCode.Clt -> IlOp.Nullary NullaryIlOp.Clt
|
|
| ILOpCode.Clt_un -> IlOp.Nullary NullaryIlOp.Clt_un
|
|
| ILOpCode.Ldftn ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Ldftn, readMetadataToken &reader)
|
|
| ILOpCode.Ldvirtftn ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Ldvirtftn, readMetadataToken &reader)
|
|
| ILOpCode.Ldarg -> IlOp.UnaryConst (UnaryConstIlOp.Ldarg (reader.ReadUInt16 ()))
|
|
| ILOpCode.Ldarga -> IlOp.UnaryConst (UnaryConstIlOp.Ldarga (reader.ReadUInt16 ()))
|
|
| ILOpCode.Starg -> IlOp.UnaryConst (UnaryConstIlOp.Starg (reader.ReadUInt16 ()))
|
|
| ILOpCode.Ldloc -> IlOp.UnaryConst (UnaryConstIlOp.Ldloc (reader.ReadUInt16 ()))
|
|
| ILOpCode.Ldloca -> IlOp.UnaryConst (UnaryConstIlOp.Ldloca (reader.ReadUInt16 ()))
|
|
| ILOpCode.Stloc -> IlOp.UnaryConst (UnaryConstIlOp.Stloc (reader.ReadUInt16 ()))
|
|
| ILOpCode.Localloc -> IlOp.Nullary NullaryIlOp.Localloc
|
|
| ILOpCode.Endfilter -> IlOp.Nullary NullaryIlOp.Endfilter
|
|
| ILOpCode.Unaligned -> IlOp.UnaryConst (UnaryConstIlOp.Unaligned (reader.ReadByte ()))
|
|
| ILOpCode.Volatile -> IlOp.Nullary NullaryIlOp.Volatile
|
|
| ILOpCode.Tail -> IlOp.Nullary NullaryIlOp.Tail
|
|
| ILOpCode.Initobj ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Initobj, readMetadataToken &reader)
|
|
| ILOpCode.Constrained ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Constrained, readMetadataToken &reader)
|
|
| ILOpCode.Cpblk -> IlOp.Nullary NullaryIlOp.Cpblk
|
|
| ILOpCode.Initblk -> IlOp.Nullary NullaryIlOp.Initblk
|
|
| ILOpCode.Rethrow -> IlOp.Nullary NullaryIlOp.Rethrow
|
|
| ILOpCode.Sizeof ->
|
|
IlOp.UnaryMetadataToken (UnaryMetadataTokenIlOp.Sizeof, readMetadataToken &reader)
|
|
| ILOpCode.Refanytype -> IlOp.Nullary NullaryIlOp.Refanytype
|
|
| ILOpCode.Readonly -> IlOp.Nullary NullaryIlOp.Readonly
|
|
| i -> failwithf "Unknown opcode: %A" i
|
|
|
|
readInstructions ((opCode, offset) :: acc)
|
|
|
|
let instructions = readInstructions []
|
|
|
|
let er =
|
|
methodBody.ExceptionRegions
|
|
|> Seq.map ExceptionRegion.OfExceptionRegion
|
|
|> ImmutableArray.CreateRange
|
|
|
|
{
|
|
Instructions = instructions
|
|
LocalInit = methodBody.LocalVariablesInitialized
|
|
LocalSig = localSig
|
|
MaxStackSize = methodBody.MaxStack
|
|
ExceptionRegions = er
|
|
}
|
|
|> Some
|
|
|
|
let read
|
|
(loggerFactory : ILoggerFactory)
|
|
(peReader : PEReader)
|
|
(metadataReader : MetadataReader)
|
|
(methodHandle : MethodDefinitionHandle)
|
|
: MethodInfo<GenericParamFromMetadata, GenericParamFromMetadata, TypeDefn> option
|
|
=
|
|
let logger = loggerFactory.CreateLogger "MethodInfo"
|
|
let assemblyName = metadataReader.GetAssemblyDefinition().GetAssemblyName ()
|
|
let methodDef = metadataReader.GetMethodDefinition methodHandle
|
|
let methodName = metadataReader.GetString methodDef.Name
|
|
let methodSig = methodDef.DecodeSignature (TypeDefn.typeProvider assemblyName, ())
|
|
let implAttrs = methodDef.ImplAttributes
|
|
|
|
let methodBody =
|
|
if
|
|
implAttrs.HasFlag MethodImplAttributes.InternalCall
|
|
|| implAttrs.HasFlag MethodImplAttributes.Runtime
|
|
then
|
|
None
|
|
elif methodDef.Attributes.HasFlag MethodAttributes.PinvokeImpl then
|
|
None
|
|
else
|
|
match readMethodBody peReader metadataReader assemblyName methodDef with
|
|
| None ->
|
|
logger.LogTrace $"no method body in {assemblyName.Name} {methodName}"
|
|
None
|
|
| Some body ->
|
|
{
|
|
MethodInstructions.Instructions = body.Instructions
|
|
Locations = body.Instructions |> List.map (fun (a, b) -> b, a) |> Map.ofList
|
|
LocalsInit = body.LocalInit
|
|
LocalVars = body.LocalSig
|
|
ExceptionRegions = body.ExceptionRegions
|
|
}
|
|
|> Some
|
|
|
|
let declaringType = methodDef.GetDeclaringType ()
|
|
|
|
let declaringDefn = metadataReader.GetTypeDefinition (declaringType)
|
|
|
|
let declaringTypeNamespace = metadataReader.GetString declaringDefn.Namespace
|
|
|
|
let declaringTypeName = metadataReader.GetString declaringDefn.Name
|
|
|
|
let declaringTypeGenericParams =
|
|
metadataReader.GetTypeDefinition(declaringType).GetGenericParameters ()
|
|
|> GenericParameter.readAll metadataReader
|
|
|
|
let attrs =
|
|
let result = ImmutableArray.CreateBuilder ()
|
|
let attrs = methodDef.GetCustomAttributes ()
|
|
|
|
for attr in attrs do
|
|
metadataReader.GetCustomAttribute attr
|
|
|> CustomAttribute.make attr
|
|
|> result.Add
|
|
|
|
result.ToImmutable ()
|
|
|
|
let typeSig = TypeMethodSignature.make methodSig
|
|
|
|
let methodParams = Parameter.readAll metadataReader (methodDef.GetParameters ())
|
|
|
|
let methodGenericParams =
|
|
GenericParameter.readAll metadataReader (methodDef.GetGenericParameters ())
|
|
|
|
let declaringType =
|
|
ConcreteType.make
|
|
assemblyName
|
|
declaringType
|
|
declaringTypeNamespace
|
|
declaringTypeName
|
|
declaringTypeGenericParams
|
|
|
|
{
|
|
DeclaringType = declaringType
|
|
Handle = methodHandle
|
|
Name = methodName
|
|
Instructions = methodBody
|
|
Parameters = methodParams
|
|
Generics = methodGenericParams
|
|
Signature = typeSig
|
|
RawSignature = typeSig
|
|
MethodAttributes = methodDef.Attributes
|
|
CustomAttributes = attrs
|
|
IsStatic = not methodSig.Header.IsInstance
|
|
ImplAttributes = implAttrs
|
|
}
|
|
|> Some
|
|
|
|
let rec resolveBaseType
|
|
(methodGenerics : TypeDefn ImmutableArray option)
|
|
(executingMethod : MethodInfo<TypeDefn, 'methodGen, 'vars>)
|
|
(td : TypeDefn)
|
|
: ResolvedBaseType
|
|
=
|
|
match td with
|
|
| TypeDefn.Void -> failwith "Void isn't a type that appears at runtime and has no base type"
|
|
| TypeDefn.PrimitiveType ty ->
|
|
match ty with
|
|
| PrimitiveType.SByte
|
|
| PrimitiveType.Byte
|
|
| PrimitiveType.Int16
|
|
| PrimitiveType.UInt16
|
|
| PrimitiveType.Int32
|
|
| PrimitiveType.UInt32
|
|
| PrimitiveType.Int64
|
|
| PrimitiveType.UInt64
|
|
| PrimitiveType.Single
|
|
| PrimitiveType.Double
|
|
| PrimitiveType.Char
|
|
| PrimitiveType.Boolean -> ResolvedBaseType.ValueType
|
|
| PrimitiveType.String -> ResolvedBaseType.Object
|
|
| PrimitiveType.TypedReference -> failwith "todo"
|
|
| PrimitiveType.IntPtr -> failwith "todo"
|
|
| PrimitiveType.UIntPtr -> failwith "todo"
|
|
| PrimitiveType.Object -> failwith "todo"
|
|
| TypeDefn.Array (elt, shape) -> failwith "todo"
|
|
| TypeDefn.Pinned typeDefn -> failwith "todo"
|
|
| TypeDefn.Pointer typeDefn -> failwith "todo"
|
|
| TypeDefn.Byref typeDefn -> failwith "todo"
|
|
| TypeDefn.OneDimensionalArrayLowerBoundZero elements -> failwith "todo"
|
|
| TypeDefn.Modified (original, afterMod, modificationRequired) -> failwith "todo"
|
|
| TypeDefn.FromReference (typeRef, signatureTypeKind) -> failwith "todo"
|
|
| TypeDefn.FromDefinition (comparableTypeDefinitionHandle, _, signatureTypeKind) -> failwith "todo"
|
|
| TypeDefn.GenericInstantiation (generic, args) -> failwith "todo"
|
|
| TypeDefn.FunctionPointer typeMethodSignature -> failwith "todo"
|
|
| TypeDefn.GenericTypeParameter index ->
|
|
resolveBaseType methodGenerics executingMethod executingMethod.DeclaringType.Generics.[index]
|
|
| TypeDefn.GenericMethodParameter index ->
|
|
match methodGenerics with
|
|
| None -> failwith "unexpectedly asked for a generic method parameter when we had none"
|
|
| Some generics -> resolveBaseType methodGenerics executingMethod generics.[index]
|