IKVM.Runtime.InstructionState Struct Reference

Classes
struct	LocalStoreSites

Public Types
enum	ShareFlags : byte { None = 0 , Stack = 1 , Locals = 2 , All = Stack | Locals }

Public Member Functions
	InstructionState (RuntimeContext context, RuntimeJavaType[] stack, int stackLen, int stackEnd, RuntimeJavaType[] locals, bool uninitializedThis)
	Initializes a new instance.
void	SetLocal1 (int index, RuntimeJavaType type)
void	SetLocal2 (int index, RuntimeJavaType type)
void	PushHelper (RuntimeJavaType type)
void	StackCopyOnWrite ()
	Copies the stack for future modification.
void	LocalsCopyOnWrite ()
	Copies the locals for future modification.

Static Public Member Functions
static InstructionState	operator+ (InstructionState s1, InstructionState s2)
	Creates a new state which is the merged combination of the two specified states.
static RuntimeJavaType	FindCommonBaseTypeHelper (RuntimeContext context, RuntimeJavaType type1, RuntimeJavaType type2)
static bool	HasMissingBaseType (RuntimeJavaType tw)

Public Attributes
readonly RuntimeContext	_context
RuntimeJavaType[]	_stack
int	_stackLen
int	_stackEnd
RuntimeJavaType[]	_locals
bool	_uninitializedThis
ShareFlags	_flags

Detailed Description

Definition at line 31 of file InstructionState.cs.

Member Enumeration Documentation

ShareFlags

enum IKVM.Runtime.InstructionState.ShareFlags : byte

Enumerator
None
Stack
Locals
All

Definition at line 92 of file InstructionState.cs.

        {
            None = 0,
            Stack = 1,
            Locals = 2,
            All = Stack | Locals
        }

Constructor & Destructor Documentation

InstructionState()

IKVM.Runtime.InstructionState.InstructionState	(	RuntimeContext	context,
		RuntimeJavaType[]	stack,
		int	stackLen,
		int	stackEnd,
		RuntimeJavaType[]	locals,
		bool	uninitializedThis )

Initializes a new instance.

Parameters

context
stack
stackLen
stackEnd
locals
uninitializedThis

Exceptions

ArgumentNullException

Definition at line 120 of file InstructionState.cs.

        {
            _context = context ?? throw new ArgumentNullException(nameof(context));
            _flags = ShareFlags.All;
            _stack = stack;
            _stackLen = stackLen;
            _stackEnd = stackEnd;
            _locals = locals;
            _uninitializedThis = uninitializedThis;
            _initialized = true;
        }

Member Function Documentation

FindCommonBaseTypeHelper()

static RuntimeJavaType IKVM.Runtime.InstructionState.FindCommonBaseTypeHelper ( RuntimeContext context, RuntimeJavaType type1, RuntimeJavaType type2 )

static

Definition at line 383 of file InstructionState.cs.

        {
            if (type1 == type2)
                return type1;
 
            // NOTE according to a paper by Alessandro Coglio & Allen Goldberg titled
            // "Type Safety in the JVM: Some Problems in Java 2 SDK 1.2 and Proposed Solutions"
            // the common base of two interfaces is java.lang.Object, and there is special
            // treatment for java.lang.Object types that allow it to be assigned to any interface
            // type, the JVM's typesafety then depends on the invokeinterface instruction to make
            // sure that the reference actually implements the interface.
            // NOTE the ECMA CLI spec also specifies this interface merging algorithm, so we can't
            // really do anything more clever than this.
            if (type1.IsInterface && type2.IsInterface)
                return context.JavaBase.TypeOfJavaLangObject;
 
            // t1 is an interface and is implemented by t2, common base type is t1
            if (type1.IsInterface)
                return type2.ImplementsInterface(type1) ? type1 : context.JavaBase.TypeOfJavaLangObject;
 
            // t2 is an interface and is implemented by t1, common base type is t2
            if (type2.IsInterface)
                return type1.ImplementsInterface(type2) ? type2 : context.JavaBase.TypeOfJavaLangObject;
 
            var st1 = new Stack<RuntimeJavaType>();
            while (type1 != null)
            {
                st1.Push(type1);
                type1 = type1.BaseTypeWrapper;
            }
 
            var st2 = new Stack<RuntimeJavaType>();
            while (type2 != null)
            {
                st2.Push(type2);
                type2 = type2.BaseTypeWrapper;
            }
 
            // pop each item off of the stacks until they do not match
            var type = context.JavaBase.TypeOfJavaLangObject;
            for (; ; )
            {
                type1 = st1.Count > 0 ? st1.Pop() : null;
                type2 = st2.Count > 0 ? st2.Pop() : null;
                if (type1 != type2)
                    return type;
 
                type = type1;
            }
        }

HasMissingBaseType()

static bool IKVM.Runtime.InstructionState.HasMissingBaseType ( RuntimeJavaType tw )

static

Definition at line 772 of file InstructionState.cs.

        {
#if IMPORTER
            for (RuntimeJavaType baseTypeWrapper; (baseTypeWrapper = tw.BaseTypeWrapper) != null; tw = baseTypeWrapper)
            {
                if (baseTypeWrapper.IsUnloadable)
                {
                    tw.Context.StaticCompiler.IssueMissingTypeMessage(tw.TypeAsBaseType.BaseType);
                    return true;
                }
            }
#endif
            return false;
        }

LocalsCopyOnWrite()

void IKVM.Runtime.InstructionState.LocalsCopyOnWrite

(

)

Copies the locals for future modification.

Definition at line 863 of file InstructionState.cs.

        {
            if ((_flags & ShareFlags.Locals) != 0)
            {
                _flags &= ~ShareFlags.Locals;
                _locals = (RuntimeJavaType[])_locals.Clone();
            }
        }

operator+()

static InstructionState IKVM.Runtime.InstructionState.operator+ ( InstructionState s1, InstructionState s2 )

static

Creates a new state which is the merged combination of the two specified states.

Parameters

s1
s2

Returns

Exceptions

VerifyError

Definition at line 195 of file InstructionState.cs.

        {
            if (s1._initialized == false)
                return s2.Copy();
 
            if (s1._stackLen != s2._stackLen || s1._stackEnd != s2._stackEnd)
                throw new VerifyError($"Inconsistent stack height: {s1._stackLen + s1._stack.Length - s1._stackEnd} != {s2._stackLen + s2._stack.Length - s2._stackEnd}");
 
            var s = s1.Copy();
            s._changed = s1._changed;
 
            for (int i = 0; i < s._stackLen; i++)
            {
                var type1 = s._stack[i];
                var type2 = s2._stack[i];
                if (type1 == type2)
                {
                    // perfect match, nothing to do
                }
                else if ((type1 == s1._context.VerifierJavaTypeFactory.ExtendedDouble && type2 == s1._context.PrimitiveJavaTypeFactory.DOUBLE) || (type2 == s1._context.VerifierJavaTypeFactory.ExtendedDouble && type1 == s1._context.PrimitiveJavaTypeFactory.DOUBLE))
                {
                    if (type1 != s1._context.VerifierJavaTypeFactory.ExtendedDouble)
                    {
                        s.StackCopyOnWrite();
                        s._stack[i] = s1._context.VerifierJavaTypeFactory.ExtendedDouble;
                        s._changed = true;
                    }
                }
                else if ((type1 == s1._context.VerifierJavaTypeFactory.ExtendedFloat && type2 == s1._context.PrimitiveJavaTypeFactory.FLOAT) || (type2 == s1._context.VerifierJavaTypeFactory.ExtendedFloat && type1 == s1._context.PrimitiveJavaTypeFactory.FLOAT))
                {
                    if (type1 != s1._context.VerifierJavaTypeFactory.ExtendedFloat)
                    {
                        s.StackCopyOnWrite();
                        s._stack[i] = s1._context.VerifierJavaTypeFactory.ExtendedFloat;
                        s._changed = true;
                    }
                }
                else if (!type1.IsPrimitive)
                {
                    var baseType = FindCommonBaseType(s1._context, type1, type2);
                    if (baseType == s1._context.VerifierJavaTypeFactory.Invalid)
                        throw new VerifyError(string.Format("cannot merge {0} and {1}", type1.Name, type2.Name));
 
                    if (type1 != baseType)
                    {
                        s.StackCopyOnWrite();
                        s._stack[i] = baseType;
                        s._changed = true;
                    }
                }
                else
                {
                    throw new VerifyError(string.Format("cannot merge {0} and {1}", type1.Name, type2.Name));
                }
            }
 
            for (int i = 0; i < s._locals.Length; i++)
            {
                var type = s._locals[i];
                var type2 = s2._locals[i];
                var baseType = FindCommonBaseType(s1._context, type, type2);
                if (type != baseType)
                {
                    s.LocalsCopyOnWrite();
                    s._locals[i] = baseType;
                    s._changed = true;
                }
            }
 
            if (!s._uninitializedThis && s2._uninitializedThis)
            {
                s._uninitializedThis = true;
                s._changed = true;
            }
 
            return s;
        }

PushHelper()

void IKVM.Runtime.InstructionState.PushHelper

(

RuntimeJavaType

type

)

Definition at line 813 of file InstructionState.cs.

        {
            if (type.IsWidePrimitive || type == _context.VerifierJavaTypeFactory.ExtendedDouble)
                _stackEnd--;
 
            if (_stackLen >= _stackEnd)
                throw new VerifyError("Stack overflow");
 
            StackCopyOnWrite();
            _stack[_stackLen++] = type;
        }

SetLocal1()

void IKVM.Runtime.InstructionState.SetLocal1	(	int	index,
		RuntimeJavaType	type )

Definition at line 434 of file InstructionState.cs.

        {
            try
            {
                LocalsCopyOnWrite();
                if (index > 0 && _locals[index - 1] != _context.VerifierJavaTypeFactory.Invalid && _locals[index - 1].IsWidePrimitive)
                    _locals[index - 1] = _context.VerifierJavaTypeFactory.Invalid;
 
                _locals[index] = type;
            }
            catch (IndexOutOfRangeException)
            {
                throw new VerifyError("Illegal local variable number");
            }
        }

SetLocal2()

void IKVM.Runtime.InstructionState.SetLocal2	(	int	index,
		RuntimeJavaType	type )

Definition at line 450 of file InstructionState.cs.

        {
            try
            {
                LocalsCopyOnWrite();
                if (index > 0 && _locals[index - 1] != _context.VerifierJavaTypeFactory.Invalid && _locals[index - 1].IsWidePrimitive)
                    _locals[index - 1] = _context.VerifierJavaTypeFactory.Invalid;
 
                _locals[index] = type;
                _locals[index + 1] = _context.VerifierJavaTypeFactory.Invalid;
            }
            catch (IndexOutOfRangeException)
            {
                throw new VerifyError("Illegal local variable number");
            }
        }

StackCopyOnWrite()

void IKVM.Runtime.InstructionState.StackCopyOnWrite

(

)

Copies the stack for future modification.

Definition at line 851 of file InstructionState.cs.

        {
            if ((_flags & ShareFlags.Stack) != 0)
            {
                _flags &= ~ShareFlags.Stack;
                _stack = (RuntimeJavaType[])_stack.Clone();
            }
        }

Member Data Documentation

_context

readonly RuntimeContext IKVM.Runtime.InstructionState._context

Definition at line 100 of file InstructionState.cs.

_flags

ShareFlags IKVM.Runtime.InstructionState._flags

Definition at line 107 of file InstructionState.cs.

_locals

RuntimeJavaType [] IKVM.Runtime.InstructionState._locals

Definition at line 104 of file InstructionState.cs.

_stack

RuntimeJavaType [] IKVM.Runtime.InstructionState._stack

Definition at line 101 of file InstructionState.cs.

_stackEnd

int IKVM.Runtime.InstructionState._stackEnd

Definition at line 103 of file InstructionState.cs.

_stackLen

int IKVM.Runtime.InstructionState._stackLen

Definition at line 102 of file InstructionState.cs.

_uninitializedThis

bool IKVM.Runtime.InstructionState._uninitializedThis

Definition at line 105 of file InstructionState.cs.

---

The documentation for this struct was generated from the following file:

• src/IKVM.Runtime/InstructionState.cs