IKVM.Runtime.LocalVarInfo Struct Reference

Classes
struct	FindLocalVarState
struct	FindLocalVarStoreSite

Static Public Member Functions
static void	FindLvtEntry (LocalVar lv, ClassFile.Method method, int instructionIndex)
static bool	IsLoadLocal (NormalizedByteCode bc)
static bool	IsStoreLocal (NormalizedByteCode bc)
static Dictionary< int, string >[]	FindLocalVariables (CodeInfo codeInfo, RuntimeJavaMethod mw, ClassFile classFile, ClassFile.Method method)
static Dictionary< int, string >[]	FindLocalVariablesImpl (RuntimeContext context, CodeInfo codeInfo, ClassFile classFile, ClassFile.Method method, FindLocalVarState[] state)
static void	VisitLocalLoads (RuntimeContext context, CodeInfo codeInfo, ClassFile.Method method, List< LocalVar > locals, Dictionary< long, LocalVar > localByStoreSite, Dictionary< int, string > storeSites, int instructionIndex, bool debug)
static long	MakeKey (int i, int j)
static LocalVar	MergeLocals (RuntimeContext context, List< LocalVar > locals, Dictionary< long, LocalVar > localByStoreSite, LocalVar l1, LocalVar l2)

Public Attributes
readonly LocalVar[]	localVars
readonly LocalVar[][]	invokespecialLocalVars
readonly LocalVar[]	allLocalVars

Detailed Description

Definition at line 34 of file LocalVarInfo.cs.

Member Function Documentation

FindLocalVariables()

static Dictionary< int, string >[] IKVM.Runtime.LocalVarInfo.FindLocalVariables ( CodeInfo codeInfo, RuntimeJavaMethod mw, ClassFile classFile, ClassFile.Method method )

static

Definition at line 342 of file LocalVarInfo.cs.

        {
            var state = new FindLocalVarState[method.Instructions.Length];
            state[0].changed = true;
            state[0].sites = new FindLocalVarStoreSite[method.MaxLocals];
 
            var parameters = mw.GetParameters();
            int argpos = 0;
            if (!mw.IsStatic)
                state[0].sites[argpos++].Add(-1);
 
            for (int i = 0; i < parameters.Length; i++)
            {
                state[0].sites[argpos++].Add(-1);
                if (parameters[i].IsWidePrimitive)
                    argpos++;
            }
 
            return FindLocalVariablesImpl(mw.DeclaringType.Context, codeInfo, classFile, method, state);
        }

FindLocalVariablesImpl()

static Dictionary< int, string >[] IKVM.Runtime.LocalVarInfo.FindLocalVariablesImpl ( RuntimeContext context, CodeInfo codeInfo, ClassFile classFile, ClassFile.Method method, FindLocalVarState[] state )

static

Definition at line 363 of file LocalVarInfo.cs.

        {
            var instructions = method.Instructions;
            var exceptions = method.ExceptionTable;
            var maxLocals = method.MaxLocals;
            var localStoreReaders = new Dictionary<int, string>[instructions.Length];
 
            var done = false;
            while (!done)
            {
                done = true;
                for (int i = 0; i < instructions.Length; i++)
                {
                    if (state[i].changed)
                    {
                        done = false;
                        state[i].changed = false;
 
                        var curr = state[i].Copy();
 
                        for (int j = 0; j < exceptions.Length; j++)
                            if (exceptions[j].startIndex <= i && i < exceptions[j].endIndex)
                                state[exceptions[j].handlerIndex].Merge(curr);
 
                        if (IsLoadLocal(instructions[i].NormalizedOpCode) && (instructions[i].NormalizedOpCode != NormalizedByteCode.__aload || !RuntimeVerifierJavaType.IsFaultBlockException(codeInfo.GetRawStackTypeWrapper(i + 1, 0))))
                        {
                            localStoreReaders[i] ??= new Dictionary<int, string>();
 
                            for (int j = 0; j < curr.sites[instructions[i].NormalizedArg1].Count; j++)
                                localStoreReaders[i][curr.sites[instructions[i].NormalizedArg1][j]] = "";
                        }
 
                        if (IsStoreLocal(instructions[i].NormalizedOpCode) && (instructions[i].NormalizedOpCode != NormalizedByteCode.__astore || !RuntimeVerifierJavaType.IsFaultBlockException(codeInfo.GetRawStackTypeWrapper(i, 0))))
                        {
                            curr.Store(i, instructions[i].NormalizedArg1);
 
                            // if this is a store at the end of an exception block,
                            // we need to propagate the new state to the exception handler
                            for (int j = 0; j < exceptions.Length; j++)
                                if (exceptions[j].endIndex == i + 1)
                                    state[exceptions[j].handlerIndex].Merge(curr);
                        }
 
                        if (instructions[i].NormalizedOpCode == NormalizedByteCode.__invokespecial)
                        {
                            var cpi = classFile.GetMethodref(instructions[i].Arg1);
                            if (ReferenceEquals(cpi.Name, StringConstants.INIT))
                            {
                                var type = codeInfo.GetRawStackTypeWrapper(i, cpi.GetArgTypes().Length);
                                // after we've invoked the constructor, the uninitialized references are now initialized
                                if (type == context.VerifierJavaTypeFactory.UninitializedThis || RuntimeVerifierJavaType.IsNew(type))
                                    for (int j = 0; j < maxLocals; j++)
                                        if (codeInfo.GetLocalTypeWrapper(i, j) == type)
                                            curr.Store(i, j);
                            }
                        }
                        else if (instructions[i].NormalizedOpCode == NormalizedByteCode.__goto_finally)
                        {
                            int handler = instructions[i].HandlerIndex;
 
                            // Normally a store at the end of a try block doesn't affect the handler block,
                            // but in the case of a finally handler it does, so we need to make sure that
                            // we merge here in case the try block ended with a store.
                            state[handler].Merge(curr);
 
                            // Now we recursively analyse the handler and afterwards merge the endfault locations back to us
                            FindLocalVarState[] handlerState = new FindLocalVarState[instructions.Length];
                            handlerState[handler].Merge(curr);
                            curr = new FindLocalVarState();
                            FindLocalVariablesImpl(context, codeInfo, classFile, method, handlerState);
 
                            // Merge back to the target of our __goto_finally
                            for (int j = 0; j < handlerState.Length; j++)
                            {
                                if (instructions[j].NormalizedOpCode == NormalizedByteCode.__athrow
                                    && codeInfo.HasState(j)
                                    && RuntimeVerifierJavaType.IsFaultBlockException(codeInfo.GetRawStackTypeWrapper(j, 0))
                                    && ((RuntimeVerifierJavaType)codeInfo.GetRawStackTypeWrapper(j, 0)).Index == handler)
                                {
                                    curr.Merge(handlerState[j]);
                                }
                            }
                        }
 
                        switch (ByteCodeMetaData.GetFlowControl(instructions[i].NormalizedOpCode))
                        {
                            case ByteCodeFlowControl.Switch:
                                {
                                    for (int j = 0; j < instructions[i].SwitchEntryCount; j++)
                                        state[instructions[i].GetSwitchTargetIndex(j)].Merge(curr);
 
                                    state[instructions[i].DefaultTarget].Merge(curr);
                                    break;
                                }
                            case ByteCodeFlowControl.Branch:
                                state[instructions[i].TargetIndex].Merge(curr);
                                break;
                            case ByteCodeFlowControl.CondBranch:
                                state[instructions[i].TargetIndex].Merge(curr);
                                state[i + 1].Merge(curr);
                                break;
                            case ByteCodeFlowControl.Return:
                            case ByteCodeFlowControl.Throw:
                                break;
                            case ByteCodeFlowControl.Next:
                                state[i + 1].Merge(curr);
                                break;
                            default:
                                throw new InvalidOperationException();
                        }
                    }
                }
            }
 
            return localStoreReaders;
        }

FindLvtEntry()

static void IKVM.Runtime.LocalVarInfo.FindLvtEntry ( LocalVar lv, ClassFile.Method method, int instructionIndex )

static

Definition at line 178 of file LocalVarInfo.cs.

        {
            var lvt = method.LocalVariableTableAttribute;
            if (lvt != null)
            {
                var pc = method.Instructions[instructionIndex].PC;
                var nextPC = method.Instructions[instructionIndex + 1].PC;
                var isStore = IsStoreLocal(method.Instructions[instructionIndex].NormalizedOpCode);
 
                foreach (var e in lvt)
                {
                    // TODO validate the contents of the LVT entry
                    if (e.index == lv.local && (e.start_pc <= pc || (e.start_pc == nextPC && isStore)) && e.start_pc + e.length > pc)
                    {
                        lv.name = e.name;
                        lv.start_pc = e.start_pc;
                        lv.end_pc = e.start_pc + e.length;
                        break;
                    }
                }
            }
        }

IsLoadLocal()

static bool IKVM.Runtime.LocalVarInfo.IsLoadLocal ( NormalizedByteCode bc )

static

Definition at line 217 of file LocalVarInfo.cs.

        {
            return bc is
                NormalizedByteCode.__aload or
                NormalizedByteCode.__iload or
                NormalizedByteCode.__lload or
                NormalizedByteCode.__fload or
                NormalizedByteCode.__dload or
                NormalizedByteCode.__iinc or
                NormalizedByteCode.__ret;
        }

IsStoreLocal()

static bool IKVM.Runtime.LocalVarInfo.IsStoreLocal ( NormalizedByteCode bc )

static

Definition at line 229 of file LocalVarInfo.cs.

        {
            return bc is
                NormalizedByteCode.__astore or
                NormalizedByteCode.__istore or
                NormalizedByteCode.__lstore or
                NormalizedByteCode.__fstore or
                NormalizedByteCode.__dstore;
        }

MakeKey()

static long IKVM.Runtime.LocalVarInfo.MakeKey ( int i, int j )

static

Definition at line 570 of file LocalVarInfo.cs.

        {
            return (((long)(uint)i) << 32) + (uint)j;
        }

MergeLocals()

static LocalVar IKVM.Runtime.LocalVarInfo.MergeLocals ( RuntimeContext context, List< LocalVar > locals, Dictionary< long, LocalVar > localByStoreSite, LocalVar l1, LocalVar l2 )

static

Definition at line 575 of file LocalVarInfo.cs.

        {
            Debug.Assert(l1 != l2);
            Debug.Assert(l1.local == l2.local);
 
            for (int i = 0; i < locals.Count; i++)
            {
                if (locals[i] == l2)
                {
                    locals.RemoveAt(i);
                    i--;
                }
            }
 
            var temp = new Dictionary<long, LocalVar>(localByStoreSite);
            localByStoreSite.Clear();
            foreach (var kv in temp)
                localByStoreSite[kv.Key] = kv.Value == l2 ? l1 : kv.Value;
 
            l1.isArg |= l2.isArg;
            l1.type = InstructionState.FindCommonBaseType(context, l1.type, l2.type);
            Debug.Assert(l1.type != context.VerifierJavaTypeFactory.Invalid);
 
            return l1;
        }

VisitLocalLoads()

static void IKVM.Runtime.LocalVarInfo.VisitLocalLoads ( RuntimeContext context, CodeInfo codeInfo, ClassFile.Method method, List< LocalVar > locals, Dictionary< long, LocalVar > localByStoreSite, Dictionary< int, string > storeSites, int instructionIndex, bool debug )

static

Definition at line 480 of file LocalVarInfo.cs.

        {
            Debug.Assert(IsLoadLocal(method.Instructions[instructionIndex].NormalizedOpCode));
 
            LocalVar local = null;
            var type = context.VerifierJavaTypeFactory.Null;
            var localIndex = method.Instructions[instructionIndex].NormalizedArg1;
            var isArg = false;
            foreach (int store in storeSites.Keys)
            {
                if (store == -1)
                {
                    // it's a method argument, it has no initial store, but the type is simply the parameter type
                    type = InstructionState.FindCommonBaseType(context, type, codeInfo.GetLocalTypeWrapper(0, localIndex));
                    isArg = true;
                }
                else
                {
                    if (method.Instructions[store].NormalizedOpCode == NormalizedByteCode.__invokespecial)
                    {
                        type = InstructionState.FindCommonBaseType(context, type, codeInfo.GetLocalTypeWrapper(store + 1, localIndex));
                    }
                    else if (method.Instructions[store].NormalizedOpCode == NormalizedByteCode.__static_error)
                    {
                        // it's an __invokespecial that turned into a __static_error
                        // (since a __static_error doesn't continue, we don't need to set type)
                    }
                    else
                    {
                        Debug.Assert(IsStoreLocal(method.Instructions[store].NormalizedOpCode));
                        type = InstructionState.FindCommonBaseType(context, type, codeInfo.GetStackTypeWrapper(store, 0));
                    }
                }
                // we can't have an invalid type, because that would have failed verification earlier
                Debug.Assert(type != context.VerifierJavaTypeFactory.Invalid);
 
                if (localByStoreSite.TryGetValue(MakeKey(store, localIndex), out var l))
                {
                    if (local == null)
                    {
                        local = l;
                    }
                    else if (local != l)
                    {
                        // If we've already defined a LocalVar and we find another one, then we merge them
                        // together.
                        // This happens for the following code fragment:
                        //
                        // int i = -1;
                        // try { i = 0; for(; ; ) System.out.println(i); } catch(Exception x) {}
                        // try { i = 0; for(; ; ) System.out.println(i); } catch(Exception x) {}
                        // System.out.println(i);
                        //
                        local = MergeLocals(context, locals, localByStoreSite, local, l);
                    }
                }
            }
 
            if (local == null)
            {
                local = new LocalVar();
                local.local = localIndex;
                local.type = RuntimeVerifierJavaType.IsThis(type) ? ((RuntimeVerifierJavaType)type).UnderlyingType : type;
                local.isArg = isArg;
 
                if (debug)
                    FindLvtEntry(local, method, instructionIndex);
 
                locals.Add(local);
            }
            else
            {
                local.isArg |= isArg;
                local.type = InstructionState.FindCommonBaseType(context, local.type, type);
                Debug.Assert(local.type != context.VerifierJavaTypeFactory.Invalid);
            }
 
            foreach (int store in storeSites.Keys)
            {
                if (!localByStoreSite.TryGetValue(MakeKey(store, localIndex), out var v))
                {
                    localByStoreSite[MakeKey(store, localIndex)] = local;
                }
                else if (v != local)
                {
                    local = MergeLocals(context, locals, localByStoreSite, local, v);
                }
            }
        }

Member Data Documentation

allLocalVars

readonly LocalVar [] IKVM.Runtime.LocalVarInfo.allLocalVars

Definition at line 39 of file LocalVarInfo.cs.

invokespecialLocalVars

readonly LocalVar [][] IKVM.Runtime.LocalVarInfo.invokespecialLocalVars

Definition at line 38 of file LocalVarInfo.cs.

localVars

readonly LocalVar [] IKVM.Runtime.LocalVarInfo.localVars

Definition at line 37 of file LocalVarInfo.cs.

---

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

• src/IKVM.Runtime/LocalVarInfo.cs