SamboyCoding / Cpp2IL / 30857607998

        if (method.AppContext.Binary.PointerSizeBytes != 8)

            return;

        var cfg = method.ControlFlowGraph!;

        var definitions = new Dictionary<LocalVariable, Instruction>();

        var homeBlock = new Dictionary<Instruction, Block>();

        foreach (var block in cfg.Blocks)

            foreach (var instruction in block.Instructions)

                homeBlock[instruction] = block;

                if (instruction.Destination is LocalVariable destination)

                    definitions[destination] = instruction;

        var changed = false;

        foreach (var block in cfg.Blocks.ToList())

            foreach (var instruction in block.Instructions.ToList())

                if (instruction.OpCode is not (OpCode.IndirectCall or OpCode.IndirectJump))

                if (MatchDispatch(method, instruction, definitions, homeBlock) is not { } match)

                RewriteDispatch(method, instruction, block, match, definitions);

                TryExciseLookup(cfg, match, definitions, homeBlock);

                changed = true;

        if (changed)

            DeadCodeEliminator.Run(method);

    }

        MethodAnalysisContext Resolved,

        Instruction InvokeDataPhi,

        Block Merge,

        Instruction SlowCall,

        LocalVariable KlassLocal);

        var targetLoad = dispatch.Operands[0] switch

        {

            MemoryOperand folded => folded,

            LocalVariable target when Definition(definitions, target) is { OpCode: OpCode.Move, Operands: [_, MemoryOperand loaded] } => loaded,

            _ => default(MemoryOperand?)

        };

        if (targetLoad is not { Index: null, Scale: 0, Addend: 0, Base: LocalVariable invokeData })

            return null;

        if (Definition(definitions, invokeData) is not { OpCode: OpCode.Phi, Operands: [_, LocalVariable first, LocalVariable second] } phi)

            return null;

        var firstDefinition = Definition(definitions, first);

        var secondDefinition = Definition(definitions, second);

        var slowCall = firstDefinition is { OpCode: OpCode.Call } 

            ? firstDefinition

            : secondDefinition is { OpCode: OpCode.Call } ? secondDefinition : null;

        var vtableEntry = ReferenceEquals(slowCall, firstDefinition) ? secondDefinition : firstDefinition;

        if (slowCall is not { Operands: [Immediate, _, _, LocalVariable interfaceArg, LocalVariable slotArg, ..] })

            return null;

        if (ChaseCopies(definitions, interfaceArg) is not { OpCode: OpCode.Move, Operands: [_, TypeAnalysisContext declaringInterface] })

            return null;

        if (declaringInterface is RuntimeMethodInfoAnalysisContext

            || !(declaringInterface is GenericInstanceTypeAnalysisContext { GenericType.IsInterface: true } || declaringInterface.IsInterface))

            return null;

        if (ChaseCopies(definitions, slotArg) is not { OpCode: OpCode.Move, Operands: [_, Immediate slotImmediate] }

            || slotImmediate.Value is < 0 or > ushort.MaxValue)

            return null;

        var slot = (int)slotImmediate.Value;

        if (MatchVTableEntryChain(definitions, vtableEntry, slot) is not { } klassLocal)

            return null;

        if (ResolveInterfaceSlot(declaringInterface, slot) is not { } resolved)

            return null;

        if (!homeBlock.TryGetValue(phi, out var merge))

            return null;

        return new Match(resolved, phi, merge, slowCall, klassLocal);

        if (vtableEntry is not { OpCode: OpCode.Add, Operands: [_, LocalVariable addLeft, LocalVariable addRight] })

            return null;

        var (klassCandidate, sum) = Definition(definitions, addRight) is { OpCode: OpCode.Move, Operands: [_, MemoryOperand { Index: null, Scale: 0, Addend: 0 }] }

            ? (addRight, addLeft)

            : (addLeft, addRight);

        if (Definition(definitions, klassCandidate) is not { OpCode: OpCode.Move, Operands: [_, MemoryOperand { Index: null, Scale: 0, Addend: 0, Base: LocalVariable }] })

            return null;

        if (ChaseCopies(definitions, sum) is not { OpCode: OpCode.Add, Operands: [_, LocalVariable shifted, Immediate { Value: VTableOffset }] })

            return null;

        if (ChaseCopies(definitions, shifted) is not { OpCode: OpCode.ShiftLeft, Operands: [_, LocalVariable index, Immediate { Value: InvokeDataShift }] })

            return null;

        var entryOffset = ChaseCopies(definitions, index);

        if (entryOffset is { OpCode: OpCode.Add, Operands: [_, LocalVariable beforeSlot, Immediate slotAddend] })

            if (slotAddend.Value != slot)

                return null;

            entryOffset = ChaseCopies(definitions, beforeSlot);

        else if (slot != 0)

            return null;

        if (entryOffset is not { OpCode: OpCode.Move, Operands: [_, MemoryOperand { Base: not null }] })

            return null;

        return klassCandidate;

        => definitions.TryGetValue(local, out var definition) ? definition : null;

        var visited = new HashSet<LocalVariable>();

        while (visited.Add(local))

            if (Definition(definitions, local) is not { } definition)

                return null;

            if (definition is { OpCode: OpCode.Move, Operands: [_, LocalVariable source] })

                local = source;

                continue;

            return definition;

        return null;

        if (declaringInterface is GenericInstanceTypeAnalysisContext genericInstance)

            var baseMethod = genericInstance.GenericType.Methods.FirstOrDefault(m => m.Definition?.slot == slot);

            return baseMethod == null ? null : new ConcreteGenericMethodAnalysisContext(baseMethod, genericInstance.GenericArguments, []);

        return declaringInterface.Methods.FirstOrDefault(m => m.Definition?.slot == slot);

        var resolved = match.Resolved;

        var isTailCall = dispatch.OpCode == OpCode.IndirectJump;

        if (isTailCall)

            var operands = new List<IOperand> { resolved };

            if (!resolved.IsVoid)

                operands.Add(new LocalVariable("interfaceTailCallResult", new Register(null, "rax")));

            operands.AddRange(dispatch.Operands.Skip(2));

            dispatch.SetOperands(operands);

            if (resolved.IsVoid)

                dispatch.RemoveOperandAt(1);

            dispatch.SetOperand(0, resolved);

        dispatch.OpCode = resolved.IsVoid ? OpCode.CallVoid : OpCode.Call;

        X64CallingConventionResolver.RemapRawArguments(dispatch, resolved);

        var assembly = resolved.DeclaringType?.DeclaringAssembly ?? method.DeclaringType?.DeclaringAssembly;

        for (var i = 1; i < dispatch.Operands.Count; i++)

            if (dispatch.Operands[i] is not LocalVariable argument

                || Definition(definitions, argument) is not { OpCode: OpCode.Move, Operands: [_, MemoryOperand { Index: null, Scale: 0, Base: LocalVariable loadBase } load] }

                || !ReferenceEquals(Definition(definitions, loadBase), match.InvokeDataPhi))

            if (load.Addend == 8 && assembly != null)

                dispatch.SetOperand(i, new RuntimeMethodInfoAnalysisContext(resolved, assembly));

            else if (load.Addend == 0)

                dispatch.SetOperand(i, new Immediate(0));

        if (isTailCall)

            var returnOperands = !method.IsVoid && !resolved.IsVoid

                ? new List<IOperand> { dispatch.Operands[1] }

                : [];

            block.AddInstruction(new Instruction(-1, OpCode.Return, returnOperands));

            block.CalculateBlockType();

    }

        var merge = match.Merge;

        if (!homeBlock.TryGetValue(match.SlowCall, out var slowBlock))

            return;

        if (Definition(definitions, match.KlassLocal) is not { } klassDefinition

            || !homeBlock.TryGetValue(klassDefinition, out var head) || head == merge)

            return;

        if (!TryCollectRegion(cfg, head, merge, out var region) || !region.Contains(slowBlock))

            return;

        if (!RegionIsSideEffectFree(region, match.SlowCall) || AnyValueEscapes(cfg, region, merge))

            return;

        if (!MergePhisAreDead(cfg, merge, out var removable))

            return;

        foreach (var instruction in removable)

            instruction.OpCode = OpCode.Nop;

            instruction.SetOperands();

        foreach (var successor in head.Successors)

            successor.Predecessors.Remove(head);

        head.Successors.Clear();

        head.Successors.Add(merge);

        var terminator = head.Instructions[^1];

        if (terminator.OpCode is OpCode.Jump or OpCode.ConditionalJump)

            terminator.OpCode = OpCode.Jump;

            terminator.SetOperands(merge);

            head.AddInstruction(new Instruction(-1, OpCode.Jump, merge));

        head.CalculateBlockType();

        merge.Predecessors.RemoveAll(region.Contains);

        merge.Predecessors.Add(head);

        foreach (var block in region)

            foreach (var successor in block.Successors)

                successor.Predecessors.Remove(block);

            foreach (var predecessor in block.Predecessors)

                predecessor.Successors.Remove(block);

            block.Successors.Clear();

            block.Predecessors.Clear();

            cfg.Blocks.Remove(block);

    }

        region = [];

        var queue = new Queue<Block>(merge.Predecessors);

        while (queue.Count > 0)

            var block = queue.Dequeue();

            if (block == head)

            if (block == merge || block == cfg.EntryBlock || block == cfg.ExitBlock || region.Count > 64)

                return false;

            if (!region.Add(block))

            foreach (var predecessor in block.Predecessors)

                queue.Enqueue(predecessor);

        if (region.Count == 0)

            return false;

        var collected = region;

        foreach (var block in collected)

            if (block.Predecessors.Any(p => p != head && !collected.Contains(p)))

                return false;

            if (block.Successors.Any(s => s != merge && !collected.Contains(s)))

                return false;

        return head.Successors.All(s => s == merge || collected.Contains(s));

    }

        foreach (var block in region)

            foreach (var instruction in block.Instructions)

                if (ReferenceEquals(instruction, slowCall))

                var harmless = instruction.OpCode switch

                {

                    OpCode.Nop or OpCode.Jump or OpCode.ConditionalJump or OpCode.Phi => true,

                    OpCode.Move or OpCode.Add or OpCode.Subtract or OpCode.Multiply or OpCode.Divide

                        or OpCode.ShiftLeft or OpCode.ShiftRight or OpCode.And or OpCode.Or or OpCode.Xor

                        or OpCode.Not or OpCode.Negate

                        or (>= OpCode.CheckEqual and <= OpCode.CheckLessOrEqual)

                        => instruction.Destination is LocalVariable,

                    _ => false,

                };

                if (!harmless)

                    return false;

        return true;

    }

        var regionDefs = new HashSet<LocalVariable>();

        foreach (var block in region)

            foreach (var instruction in block.Instructions)

                if (instruction.Destination is LocalVariable destination)

                    regionDefs.Add(destination);

        foreach (var block in cfg.Blocks)

            if (region.Contains(block))

            foreach (var instruction in block.Instructions)

                if (instruction.OpCode == OpCode.Phi && block == merge)

                if (Uses(instruction, regionDefs))

                    return true;

        return false;

    }

        removable = [];

        var useSites = new Dictionary<LocalVariable, List<Instruction>>();

        foreach (var block in cfg.Blocks)

            foreach (var instruction in block.Instructions)

                foreach (var used in UsedLocals(instruction))

                    if (!useSites.TryGetValue(used, out var sites))

                        useSites[used] = sites = [];

                    sites.Add(instruction);

        foreach (var phi in merge.Instructions)

            if (phi.OpCode != OpCode.Phi)

            if (phi.Operands[0] is not LocalVariable phiDest)

                return false;

            foreach (var use in useSites.TryGetValue(phiDest, out var phiUses) ? phiUses : [])

                if (use is not { OpCode: OpCode.Move, Operands: [LocalVariable loaded, MemoryOperand] }

                    || (useSites.TryGetValue(loaded, out var loadUses) && loadUses.Count > 0))

                    return false;

                removable.Add(use);

            removable.Add(phi);

        return true;

    }

        => UsedLocals(instruction).Any(candidates.Contains);

        for (var i = 0; i < instruction.Operands.Count; i++)

            if (ReferenceEquals(instruction.Operands[i], instruction.Destination))

            switch (instruction.Operands[i])

                    yield return local;

                    break;

                    yield return addressed;

                    break;

                    if (memory.Base is LocalVariable baseLocal)

                        yield return baseLocal;

                    if (memory.Index is LocalVariable indexLocal)

                        yield return indexLocal;

    }