emitter.vb

大名鼎鼎的mono是.NET平台的跨平台（支持linux

    Shared Sub EmitMultOrMultOvf(ByVal Info As EmitInfo, ByVal OperandType As Type)
        If Info.IntegerOverflowChecks Then
            EmitMultOvf(Info, OperandType)
        Else
            EmitMult(Info, OperandType)
        End If
    End Sub

    Shared Sub EmitIs(ByVal Info As EmitInfo)
        Info.Stack.Pop(Info.Stack.Peek)
        Info.Stack.Pop(Info.Stack.Peek)
        Info.ILGen.Emit(OpCodes.Ceq)
        Info.Stack.Push(Info.Compiler.TypeCache.System_Boolean)
    End Sub

    Shared Sub EmitRShift(ByVal Info As EmitInfo, ByVal OpType As Type)
        OpType = Helper.GetTypeOrTypeBuilder(OpType)
        Info.Stack.Pop(Info.Compiler.TypeCache.System_Int32)
        Info.Stack.Pop(OpType)
        Info.ILGen.Emit(OpCodes.Shr)
        Info.Stack.Push(OpType)
    End Sub

    Shared Sub EmitLShift(ByVal Info As EmitInfo, ByVal OpType As Type)
        OpType = Helper.GetTypeOrTypeBuilder(OpType)
        Info.Stack.Pop(Info.Compiler.TypeCache.System_Int32)
        Info.Stack.Pop(OpType)
        Info.ILGen.Emit(OpCodes.Shl)
        Info.Stack.Push(OpType)
    End Sub

    Shared Sub EmitIntDiv(ByVal Info As EmitInfo, ByVal OpType As Type)
        OpType = Helper.GetTypeOrTypeBuilder(OpType)
        Info.Stack.Pop(OpType)
        Info.Stack.Pop(OpType)
        Info.ILGen.Emit(OpCodes.Div)
        Info.Stack.Push(OpType)
    End Sub

    Shared Sub EmitRealDiv(ByVal Info As EmitInfo, ByVal OpType As Type)
        OpType = Helper.GetTypeOrTypeBuilder(OpType)
        Info.Stack.Pop(OpType)
        Info.Stack.Pop(OpType)
        Info.ILGen.Emit(OpCodes.Div)
        Info.Stack.Push(OpType)
    End Sub

    Shared Sub EmitIsNot(ByVal Info As EmitInfo)
        Info.Stack.Pop(Info.Stack.Peek)
        Info.Stack.Pop(Info.Stack.Peek)
        Info.ILGen.Emit(OpCodes.Ceq)
        Info.ILGen.Emit(OpCodes.Ldc_I4_0)
        Info.ILGen.Emit(OpCodes.Ceq)
        Info.Stack.Push(Info.Compiler.TypeCache.System_Boolean)
    End Sub
    ''' <summary>
    ''' Create a local parameter. 
    ''' In the future might return an already created parameter that is no longer beeing used.
    ''' </summary>
    ''' <param name="Info"></param>
    ''' <param name="Type"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Shared Function CreateLocal(ByVal Info As EmitInfo, ByVal Type As Type) As LocalBuilder
        Type = Helper.GetTypeOrTypeBuilder(Type)
        Return Info.ILGen.DeclareLocal(Type)
    End Function


    <Diagnostics.Conditional("DEBUG")> _
    Private Shared Sub PopParameters(ByVal Info As EmitInfo, ByVal Params As ParameterInfo())
        For i As Integer = Params.GetUpperBound(0) To 0 Step -1
            Info.Stack.Pop(Params(i).ParameterType)
        Next
    End Sub

    <Diagnostics.Conditional("DEBUG")> _
    Private Shared Sub PopParameters(ByVal Info As EmitInfo, ByVal Params As Type())
        For i As Integer = Params.GetUpperBound(0) To 0 Step -1
            Info.Stack.Pop(Params(i))
        Next
    End Sub

    Shared Sub EmitDup(ByVal Info As EmitInfo)
        Info.ILGen.Emit(OpCodes.Dup)
        Info.Stack.Push(Info.Stack.Peek)
    End Sub

    ''' <summary>
    ''' Loads a pointer to the specified method onto the stack.
    ''' Loads either a Lftfn or Ldvirtftn, according to the static 
    ''' state of the method.
    ''' </summary>
    ''' <param name="Info"></param>
    ''' <param name="Method"></param>
    ''' <remarks></remarks>
    Shared Sub EmitLoadVftn(ByVal Info As EmitInfo, ByVal Method As MethodBase)
        Dim methodinf As MethodInfo = TryCast(Method, MethodInfo)
        If methodinf IsNot Nothing Then
            methodinf = Helper.GetMethodOrMethodBuilder(methodinf)
            If methodinf.IsStatic Then
                Info.ILGen.Emit(OpCodes.Ldftn, methodinf)
            Else
                Info.Stack.Pop(methodinf.DeclaringType)
                Info.ILGen.Emit(OpCodes.Ldvirtftn, methodinf)
            End If
        Else
            Helper.Stop()
        End If
        Info.Stack.Push(Info.Compiler.TypeCache.System_IntPtr)
    End Sub

    Shared Sub EmitInitObj(ByVal Info As EmitInfo, ByVal Type As Type)
        Type = Helper.GetTypeOrTypeBuilder(Type)
        Info.ILGen.Emit(OpCodes.Initobj, Type)
        Info.Stack.Pop(Info.Compiler.TypeManager.MakeByRefType(CType(Info.Method, ParsedObject), Type))
    End Sub

    Shared Sub EmitNeg(ByVal Info As EmitInfo)
        Info.ILGen.Emit(OpCodes.Neg)
    End Sub

    ''' <summary>
    ''' Emit a newobj.
    ''' </summary>
    ''' <param name="Info"></param>
    ''' <param name="Constructor"></param>
    ''' <remarks></remarks>
    Shared Sub EmitNew(ByVal Info As EmitInfo, ByVal Constructor As ConstructorInfo)
        Dim OriginalConstructor As ConstructorInfo = Constructor
        Helper.Assert(Constructor IsNot Nothing)
        PopParameters(Info, Constructor.GetParameters)
        Constructor = Helper.GetCtorOrCtorBuilder(Constructor)
        Info.ILGen.Emit(OpCodes.Newobj, Constructor)
        Info.Stack.Push(Constructor.DeclaringType)
    End Sub

    ''' <summary>
    ''' Emit a newobj.
    ''' </summary>
    ''' <param name="Info"></param>
    ''' <param name="Constructor"></param>
    ''' <remarks></remarks>
    Shared Sub EmitNew(ByVal Info As EmitInfo, ByVal Constructor As MethodInfo, ByVal ParameterTypes() As Type)
        Dim OriginalConstructor As MethodInfo = Constructor
        Helper.Assert(Constructor IsNot Nothing)
        PopParameters(Info, ParameterTypes)
        Constructor = Helper.GetMethodOrMethodBuilder(Constructor)
        Info.ILGen.Emit(OpCodes.Newobj, Constructor)
        Info.Stack.Push(Constructor.DeclaringType)
    End Sub

    Shared Sub EmitCastClass(ByVal Info As EmitInfo, ByVal FromType As Type, ByVal ToType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        ToType = Helper.GetTypeOrTypeBuilder(ToType)
        Helper.Assert(ToType.IsByRef = False)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Castclass, ToType)
        Info.Stack.Push(ToType)
    End Sub

    Shared Sub EmitIsInst(ByVal Info As EmitInfo, ByVal FromType As Type, ByVal ToType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        ToType = Helper.GetTypeOrTypeBuilder(ToType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Isinst, ToType)
        Info.Stack.Push(ToType)
    End Sub

    Shared Sub EmitValueTypeToObjectConversion(ByVal Info As EmitInfo, ByVal FromType As Type, ByVal ToType As Type)
        ToType = Helper.GetTypeOrTypeBuilder(ToType)
        'Dim FromType As Type = Info.Stack.Peek
        Dim FromTP, ToTP As TypeCode

        FromTP = Helper.GetTypeCode(Info.Compiler, FromType)
        ToTP = Helper.GetTypeCode(info.Compiler, ToType)

        Helper.Assert(ToTP = TypeCode.Object)

        If ToType.IsByRef AndAlso Helper.CompareType(ToType.GetElementType, FromType) Then
            Dim localvar As LocalBuilder = Info.ILGen.DeclareLocal(FromType)
            Emitter.EmitStoreVariable(Info, localvar)
            Emitter.EmitLoadVariableLocation(Info, localvar)
        ElseIf FromType.BaseType.IsEnum AndAlso Helper.CompareType(ToType, Info.Compiler.TypeCache.System_Enum) Then

        Else
            Helper.NotImplemented()
        End If
    End Sub

    Shared Sub EmitConv_U1(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_U1)
        Info.Stack.Push(Info.Compiler.TypeCache.System_Byte)
    End Sub

    Shared Sub EmitConv_U1_Overflow(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_Ovf_U1)
        Info.Stack.Push(Info.Compiler.TypeCache.System_Byte)
    End Sub

    Shared Sub EmitConv_U1_Overflow_Underflow(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_Ovf_U1_Un)
        Info.Stack.Push(Info.Compiler.TypeCache.System_Byte)
    End Sub

    Shared Sub EmitConv_I1(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_I1)
        Info.Stack.Push(Info.Compiler.TypeCache.System_SByte)
    End Sub

    Shared Sub EmitConv_I1_Overflow(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_Ovf_I1)
        Info.Stack.Push(Info.Compiler.TypeCache.System_SByte)
    End Sub

    Shared Sub EmitConv_I1_Overflow_Underflow(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_Ovf_I1_Un)
        Info.Stack.Push(Info.Compiler.TypeCache.System_SByte)
    End Sub

    Shared Sub EmitConv_U2(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_U2)
        Info.Stack.Push(Info.Compiler.TypeCache.System_UInt16)
    End Sub

    Shared Sub EmitConv_U2_Overflow(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_Ovf_U2)
        Info.Stack.Push(Info.Compiler.TypeCache.System_UInt16)
    End Sub

    Shared Sub EmitConv_U2_Overflow_Underflow(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_Ovf_U2_Un)
        Info.Stack.Push(Info.Compiler.TypeCache.System_UInt16)
    End Sub

    Shared Sub EmitConv_I2(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_I2)
        Info.Stack.Push(Info.Compiler.TypeCache.System_Int16)
    End Sub

    Shared Sub EmitConv_I2_Overflow(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_Ovf_I2)
        Info.Stack.Push(Info.Compiler.TypeCache.System_Int16)
    End Sub

    Shared Sub EmitConv_I2_Overflow_Underflow(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_Ovf_I2_Un)
        Info.Stack.Push(Info.Compiler.TypeCache.System_Int16)
    End Sub

    Shared Sub EmitConv_U4(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_U4)
        Info.Stack.Push(Info.Compiler.TypeCache.System_UInt32)
    End Sub

    Shared Sub EmitConv_U4_Overflow(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_Ovf_U4)
        Info.Stack.Push(Info.Compiler.TypeCache.System_UInt32)
    End Sub

    Shared Sub EmitConv_U4_Overflow_Underflow(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_Ovf_U4_Un)
        Info.Stack.Push(Info.Compiler.TypeCache.System_UInt32)
    End Sub

    Shared Sub EmitConv_I4(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_I4)
        Info.Stack.Push(Info.Compiler.TypeCache.System_Int32)
    End Sub

    Shared Sub EmitConv_I4_Overflow(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_Ovf_I4)
        Info.Stack.Push(Info.Compiler.TypeCache.System_Int32)
    End Sub

    Shared Sub EmitConv_I4_Overflow_Underflow(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_Ovf_I4_Un)
        Info.Stack.Push(Info.Compiler.TypeCache.System_Int32)
    End Sub

    Shared Sub EmitConv_U8(ByVal Info As EmitInfo, ByVal FromType As Type)
        FromType = Helper.GetTypeOrTypeBuilder(FromType)
        Info.Stack.Pop(FromType)
        Info.ILGen.Emit(OpCodes.Conv_U8)
        Info.Stack.Push(Info.Compiler.TypeCache.System_UInt64)