Examples of com.strobel.assembler.ir.Instruction

com.strobel.assembler.ir.Instruction
User: Mike Strobel Date: 1/6/13 Time: 1:31 AM

    private void populateExceptionHandlerInfo(final InstructionCollection body, final List<ExceptionTableEntry> exceptionTable) {
        if (body.isEmpty()) {
            return;
        }


        final Instruction bodyEndInstruction = body.get(body.size() - 1);


        final List<HandlerWithRange> entries = new ArrayList<>(exceptionTable.size());


        for (final ExceptionTableEntry entry : exceptionTable) {
            entries.add(
                new HandlerWithRange(
                    entry,
                    new Range(entry.getHandlerOffset(), Integer.MAX_VALUE)
                )
            );
        }


//        Collections.sort(entries);


        final ControlFlowGraph cfg = ControlFlowGraphBuilder.build(body, Collections.<ExceptionHandler>emptyList());


        cfg.computeDominance();
        cfg.computeDominanceFrontier();


        final List<ControlFlowNode> nodes = cfg.getNodes();
        final Map<Instruction, ControlFlowNode> nodeLookup = new IdentityHashMap<>();


        for (int j = 0; j < nodes.size(); j++) {
            final ControlFlowNode node = nodes.get(j);


            if (node.getNodeType() != ControlFlowNodeType.Normal) {
                continue;
            }


            for (Instruction i = node.getStart();
                 i != null && i.getOffset() < node.getEnd().getEndOffset();
                 i = i.getNext()) {


                nodeLookup.put(i, node);
            }
        }


        for (int i = 0; i < entries.size(); i++) {
            int minOffset = Integer.MAX_VALUE;


            final HandlerWithRange entry = entries.get(i);


            ControlFlowNode tryEnd = null;


            for (int j = 0; j < nodes.size(); j++) {
                final ControlFlowNode node = nodes.get(j);
                final Instruction end = node.getEnd();


                if (end != null && end.getOffset() == entry.entry.getEndOffset()) {
                    final Instruction previousInstruction = node.getStart().getPrevious();
                    final HandlerWithRange nearestHandler = findNearestHandler(entries, entry);
                    final Instruction firstHandlerInstruction = body.atOffset(nearestHandler.range.getStart());


                    if (end.getOpCode() == OpCode.GOTO && end.getNext() == firstHandlerInstruction) {
                        tryEnd = nodeLookup.get(end);
                    }
                    else if (previousInstruction != null) {
                        tryEnd = nodeLookup.get(previousInstruction);
                    }


                    break;
                }
            }


            for (int j = 0; j < nodes.size(); j++) {
                final ControlFlowNode node = nodes.get(j);


                if (node.getNodeType() != ControlFlowNodeType.Normal) {
                    continue;
                }


                if (node.getStart().getOffset() == entry.range.getStart()) {
                    final ControlFlowNode end = findHandlerEnd(node, tryEnd, new LinkedHashSet<ControlFlowNode>(), cfg.getRegularExit());


                    if (end != null && end.getNodeType() == ControlFlowNodeType.Normal) {
                        minOffset = end.getEnd().getEndOffset();
                    }
                    else {
                        minOffset = node.getEnd().getEndOffset();
                    }


                    for (int k = 0; k < entries.size(); k++) {
                        final HandlerWithRange other = entries.get(k);


                        if (k != i &&
                            entry.entry.getStartOffset() >= other.entry.getStartOffset() &&
                            entry.entry.getHandlerOffset() < other.entry.getHandlerOffset() &&
                            entry.entry.getEndOffset() <= other.entry.getEndOffset() &&
                            other.range.getStart() < minOffset) {


                            minOffset = other.range.getStart();
                        }
                    }


                    break;
                }
            }


            if (minOffset != Integer.MAX_VALUE) {
                entry.range.setEnd(minOffset);
            }
        }


//        Collections.sort(entries);


        final List<ExceptionHandler> exceptionHandlers = _methodBody.getExceptionHandlers();


        for (final HandlerWithRange entry : entries) {
            final int startOffset = entry.entry.getStartOffset();
            final int endOffset = entry.entry.getEndOffset();
            final int handlerStart = entry.range.getStart();
            final int handlerEnd = entry.range.getEnd();
            final TypeReference catchType = entry.entry.getCatchType();


            final Instruction firstInstruction = body.tryGetAtOffset(startOffset);
            final Instruction lastInstruction;
            final Instruction handlerFirstInstruction = body.tryGetAtOffset(handlerStart);
            final Instruction handlerLastInstruction;


            if (endOffset <= bodyEndInstruction.getOffset()) {
                lastInstruction = body.tryGetAtOffset(endOffset).getPrevious();
            }
            else if (endOffset == bodyEndInstruction.getEndOffset()) {
                lastInstruction = bodyEndInstruction;
            }
            else {
                lastInstruction = new Instruction(endOffset, OpCode.NOP);
            }


            if (handlerEnd <= bodyEndInstruction.getOffset()) {
                handlerLastInstruction = body.tryGetAtOffset(handlerEnd).getPrevious();
            }
            else if (handlerEnd == bodyEndInstruction.getEndOffset()) {
                handlerLastInstruction = bodyEndInstruction;
            }
            else {
                handlerLastInstruction = new Instruction(handlerEnd, OpCode.NOP);
            }


            final ExceptionHandler handler;


            if (catchType == null) {

View Full Code Here

        cfg.computeDominanceFrontier();


        final List<ExceptionHandler> handlers = new ArrayList<>();


        for (final ExceptionTableEntry entry : tableEntries) {
            final Instruction handlerStart = instructions.atOffset(entry.getHandlerOffset());


            final ControlFlowNode handlerStartNode = firstOrDefault(
                cfg.getNodes(),
                new Predicate<ControlFlowNode>() {
                    @Override
                    public boolean test(final ControlFlowNode node) {
                        return node.getStart() == handlerStart;
                    }
                }
            );


            if (handlerStartNode == null) {
                throw new IllegalStateException(
                    format(
                        "Could not find entry node for handler at offset %d.",
                        handlerStart.getOffset()
                    )
                );
            }


            final Set<ControlFlowNode> dominationSet = new HashSet<>();

View Full Code Here

        //


        final InstructionCollection instructions = _instructions;


        for (int i = 0, n = instructions.size(); i < n; i++) {
            final Instruction blockStart = instructions.get(i);
            final ExceptionTableEntry blockStartExceptionHandler = findInnermostExceptionHandler(blockStart.getOffset());


            //
            // See how big we can make that block...
            //
            for (; i + 1 < n; i++) {
                final Instruction instruction = instructions.get(i);
                final OpCode opCode = instruction.getOpCode();


                if (opCode.isUnconditionalBranch() /*|| opCode.canThrow()*/ || _hasIncomingJumps[i + 1]) {
                    break;
                }


                final Instruction next = instruction.getNext();


                if (next != null) {
                    //
                    // Ensure that blocks never contain instructions from different try blocks.
                    //
                    final ExceptionTableEntry innermostExceptionHandler = findInnermostExceptionHandler(next.getOffset());


                    if (innermostExceptionHandler != blockStartExceptionHandler) {
                        break;
                    }
                }

View Full Code Here

        final InstructionCollection instructions = _instructions;


        createEdge(_entryPoint, instructions.get(0), JumpType.Normal);


        for (final ControlFlowNode node : _nodes) {
            final Instruction end = node.getEnd();


            if (end == null || end.getOffset() >= _instructions.get(_instructions.size() - 1).getEndOffset()) {
                continue;
            }


            final OpCode endOpCode = end.getOpCode();


            //
            // Create normal edges from one instruction to the next.
            //
            if (!endOpCode.isUnconditionalBranch()) {
                final Instruction next = end.getNext();


                if (next != null) {
                    createEdge(node, next, JumpType.Normal);
                }
            }

View Full Code Here

        //
        // Step 4: Create edges for the exceptional control flow.
        //


        for (final ControlFlowNode node : _nodes) {
            final Instruction end = node.getEnd();


            if (end != null &&
                end.getOffset() < _instructions.get(_instructions.size() - 1).getEndOffset()) {


                final ControlFlowNode innermostHandler = findInnermostExceptionHandlerNode(node.getEnd().getOffset());


                if (innermostHandler == null) {
                    continue;

View Full Code Here


        if (entry == null) {
            return null;
        }


        final Instruction nodeStart = _instructions.atOffset(entry.getHandlerOffset());


        for (final ControlFlowNode node : _nodes) {
            if (node.getStart() == nodeStart) {
                return node;
            }

View Full Code Here

            if (code == OpCode.WIDE) {
                code = code << 8 | b.readUnsignedByte();
            }


            final OpCode op = OpCode.get(code);
            final Instruction instruction;


            switch (op.getOperandType()) {
                case None: {
                    if (op.isLoad() || op.isStore()) {
                        variables.ensure(OpCodeHelpers.getLoadStoreMacroArgumentIndex(op), op, offset);
                    }
                    instruction = Instruction.create(op);
                    break;
                }


                case PrimitiveTypeCode: {
                    instruction = Instruction.create(op, BuiltinTypes.fromPrimitiveTypeCode(b.readUnsignedByte()));
                    break;
                }


                case TypeReference: {
                    final int typeToken = b.readUnsignedShort();
                    instruction = Instruction.create(op, _scope.lookupType(typeToken));
                    break;
                }


                case TypeReferenceU1: {
                    instruction = Instruction.create(op, _scope.lookupType(b.readUnsignedShort()), b.readUnsignedByte());
                    break;
                }


                case DynamicCallSite: {
                    instruction = Instruction.create(op, _scope.lookupDynamicCallSite(b.readUnsignedShort()));
                    b.readUnsignedByte();
                    b.readUnsignedByte();
                    break;
                }


                case MethodReference: {
                    instruction = Instruction.create(op, _scope.lookupMethod(b.readUnsignedShort()));


                    if (op == OpCode.INVOKEINTERFACE) {
                        b.readUnsignedByte();
                        b.readUnsignedByte();
                    }


                    break;
                }


                case FieldReference: {
                    instruction = Instruction.create(op, _scope.lookupField(b.readUnsignedShort()));
                    break;
                }


                case BranchTarget: {
                    final int targetOffset;


                    instruction = new Instruction(op);


                    if (op.isWide()) {
                        targetOffset = offset + _scope.<Integer>lookupConstant(b.readUnsignedShort());
                    }
                    else {
                        targetOffset = offset + (int) b.readShort();
                    }


                    if (targetOffset < offset) {
                        final Instruction target = body.atOffset(targetOffset);


                        if (!target.hasLabel()) {
                            target.setLabel(new Label(targetOffset));
                        }


                        instruction.setOperand(target);
                    }
                    else if (targetOffset == offset) {
                        instruction.setOperand(instruction);
                        instruction.setLabel(new Label(offset));
                    }
                    else if (targetOffset > b.size()) {
                        //
                        // Target is a label after the last instruction.  Insert a dummy NOP.
                        //
                        instruction.setOperand(new Instruction(targetOffset, OpCode.NOP));
                    }
                    else {
                        final Fixup oldFixup = fixups[targetOffset];
                        final Fixup newFixup = new Fixup() {
                            @Override
                            public void fix(final Instruction target) {
                                instruction.setOperand(target);
                            }
                        };


                        fixups[targetOffset] = oldFixup != null ? Fixup.combine(oldFixup, newFixup)
                                                                : newFixup;
                    }


                    break;
                }


                case I1: {
                    instruction = Instruction.create(op, b.readByte());
                    break;
                }


                case I2: {
                    instruction = Instruction.create(op, b.readShort());
                    break;
                }


                case I8: {
                    instruction = Instruction.create(op, b.readLong());
                    break;
                }


                case Constant: {
                    instruction = new Instruction(op, _scope.lookupConstant(b.readUnsignedByte()));
                    break;
                }


                case WideConstant: {
                    final int constantToken = b.readUnsignedShort();
                    instruction = new Instruction(op, _scope.lookupConstant(constantToken));
                    break;
                }


                case Switch: {
                    while (b.position() % 4 != 0) {
                        b.readByte();
                    }


                    final SwitchInfo switchInfo = new SwitchInfo();
                    final int defaultOffset = offset + b.readInt();


                    instruction = Instruction.create(op, switchInfo);


                    if (defaultOffset < offset) {
                        switchInfo.setDefaultTarget(body.atOffset(defaultOffset));
                    }
                    else if (defaultOffset == offset) {
                        switchInfo.setDefaultTarget(instruction);
                    }
                    else {
                        switchInfo.setDefaultTarget(new Instruction(defaultOffset, OpCode.NOP));


                        final Fixup oldFixup = fixups[defaultOffset];
                        final Fixup newFixup = new Fixup() {
                            @Override
                            public void fix(final Instruction target) {
                                switchInfo.setDefaultTarget(target);
                            }
                        };


                        fixups[defaultOffset] = oldFixup != null ? Fixup.combine(oldFixup, newFixup)
                                                                 : newFixup;
                    }


                    if (op == OpCode.TABLESWITCH) {
                        final int low = b.readInt();
                        final int high = b.readInt();
                        final Instruction[] targets = new Instruction[high - low + 1];


                        switchInfo.setLowValue(low);
                        switchInfo.setHighValue(high);


                        for (int i = 0; i < targets.length; i++) {
                            final int targetIndex = i;
                            final int targetOffset = offset + b.readInt();


                            if (targetOffset < offset) {
                                targets[targetIndex] = body.atOffset(targetOffset);
                            }
                            else if (targetOffset == offset) {
                                targets[targetIndex] = instruction;
                            }
                            else {
                                targets[targetIndex] = new Instruction(targetOffset, OpCode.NOP);


                                final Fixup oldFixup = fixups[targetOffset];
                                final Fixup newFixup = new Fixup() {
                                    @Override
                                    public void fix(final Instruction target) {
                                        targets[targetIndex] = target;
                                    }
                                };


                                fixups[targetOffset] = oldFixup != null ? Fixup.combine(oldFixup, newFixup)
                                                                        : newFixup;
                            }
                        }


                        switchInfo.setTargets(targets);
                    }
                    else {
                        final int pairCount = b.readInt();
                        final int[] keys = new int[pairCount];
                        final Instruction[] targets = new Instruction[pairCount];


                        for (int i = 0; i < pairCount; i++) {
                            final int targetIndex = i;


                            keys[targetIndex] = b.readInt();


                            final int targetOffset = offset + b.readInt();


                            if (targetOffset < offset) {
                                targets[targetIndex] = body.atOffset(targetOffset);
                            }
                            else if (targetOffset == offset) {
                                targets[targetIndex] = instruction;
                            }
                            else {
                                targets[targetIndex] = new Instruction(targetOffset, OpCode.NOP);


                                final Fixup oldFixup = fixups[targetOffset];
                                final Fixup newFixup = new Fixup() {
                                    @Override
                                    public void fix(final Instruction target) {
                                        targets[targetIndex] = target;
                                    }
                                };


                                fixups[targetOffset] = oldFixup != null ? Fixup.combine(oldFixup, newFixup)
                                                                        : newFixup;
                            }
                        }


                        switchInfo.setKeys(keys);
                        switchInfo.setTargets(targets);
                    }


                    break;
                }


                case Local: {
                    final int variableSlot;


                    if (op.isWide()) {
                        variableSlot = b.readUnsignedShort();
                    }
                    else {
                        variableSlot = b.readUnsignedByte();
                    }


                    final VariableDefinition variable = variables.ensure(variableSlot, op, offset);


                    if (variableSlot < 0) {
                        instruction = new Instruction(op, new ErrorOperand("!!! BAD LOCAL: " + variableSlot + " !!!"));
                    }
                    else {
                        instruction = Instruction.create(op, variable);
                    }


                    break;
                }


                case LocalI1: {
                    final int variableSlot;
                    final int operand;


                    if (op.isWide()) {
                        variableSlot = b.readUnsignedShort();
                    }
                    else {
                        variableSlot = b.readUnsignedByte();
                    }


                    final VariableDefinition variable = variables.ensure(variableSlot, op, offset);


                    operand = b.readByte();


                    if (variableSlot < 0) {
                        instruction = new Instruction(
                            op,
                            new ErrorOperand("!!! BAD LOCAL: " + variableSlot + " !!!"),
                            operand
                        );
                    }
                    else {
                        instruction = Instruction.create(op, variable, operand);
                    }


                    break;
                }


                case LocalI2: {
                    final int variableSlot;
                    final int operand;


                    if (op.isWide()) {
                        variableSlot = b.readUnsignedShort();
                    }
                    else {
                        variableSlot = b.readUnsignedByte();
                    }


                    final VariableDefinition variable = variables.ensure(variableSlot, op, offset);


                    operand = b.readShort();


                    if (variableSlot < 0) {
                        instruction = new Instruction(
                            op,
                            new ErrorOperand("!!! BAD LOCAL: " + variableSlot + " !!!"),
                            operand
                        );
                    }
                    else {
                        instruction = Instruction.create(op, variable, operand);
                    }


                    break;
                }


                default: {
                    throw new IllegalStateException("Unrecognized opcode: " + code);
                }
            }


            instruction.setOffset(offset);
            body.add(instruction);


            final Fixup fixup = fixups[offset];


            if (fixup != null) {
                if (!instruction.hasLabel()) {
                    instruction.setLabel(new Label(offset));
                }
                fixup.fix(instruction);
            }
        }


        variables.updateScopes(_code.getCodeSize());
        variables.mergeVariables();
        variables.updateScopes(_code.getCodeSize());


        int labelCount = 0;


        for (int i = 0; i < body.size(); i++) {
            final Instruction instruction = body.get(i);
            final OpCode code = instruction.getOpCode();
            final Object operand = instruction.hasOperand() ? instruction.getOperand(0) : null;


            if (operand instanceof VariableDefinition) {
                final VariableDefinition currentVariable = (VariableDefinition) operand;
                final int effectiveOffset;


                if (code.isStore()) {
                    effectiveOffset = instruction.getOffset() + code.getSize() + code.getOperandType().getBaseSize();
                }
                else {
                    effectiveOffset = instruction.getOffset();
                }


                VariableDefinition actualVariable = variables.tryFind(currentVariable.getSlot(), effectiveOffset);


                if (actualVariable == null && code.isStore()) {
                    actualVariable = variables.find(
                        currentVariable.getSlot(),
                        effectiveOffset + code.getSize() + code.getOperandType().getBaseSize()
                    );
                }


                if (actualVariable != currentVariable) {
                    if (instruction.getOperandCount() > 1) {
                        final Object[] operands = new Object[instruction.getOperandCount()];


                        operands[0] = actualVariable;


                        for (int j = 1; j < operands.length; j++) {
                            operands[j] = instruction.getOperand(j);
                        }


                        instruction.setOperand(operands);
                    }
                    else {
                        instruction.setOperand(actualVariable);
                    }
                }
            }


            if (instruction.hasLabel()) {
                instruction.getLabel().setIndex(labelCount++);
            }
        }


        final List<ExceptionTableEntry> exceptionTable = _code.getExceptionTableEntries();

View Full Code Here

        //


        final List<Instruction> instructions = _instructions;


        for (int i = 0, n = instructions.size(); i < n; i++) {
            final Instruction blockStart = instructions.get(i);
            final ExceptionHandler blockStartExceptionHandler = findInnermostExceptionHandler(blockStart.getOffset());


            //
            // See how big we can make that block...
            //
            for (; i + 1 < n; i++) {
                final Instruction instruction = instructions.get(i);
                final OpCode opCode = instruction.getOpCode();


                if (opCode.isUnconditionalBranch() /*|| opCode.canThrow()*/ || _hasIncomingJumps[i + 1]) {
                    break;
                }


                final Instruction next = instruction.getNext();


                if (next != null) {
                    //
                    // Ensure that blocks never contain instructions from different try blocks.
                    //
                    final ExceptionHandler innermostExceptionHandler = findInnermostExceptionHandler(next.getOffset());


                    if (innermostExceptionHandler != blockStartExceptionHandler) {
                        break;
                    }
                }

View Full Code Here

        final List<Instruction> instructions = _instructions;


        createEdge(_entryPoint, instructions.get(0), JumpType.Normal);


        for (final ControlFlowNode node : _nodes) {
            final Instruction end = node.getEnd();


            if (end == null || end.getOffset() >= _instructions.get(_instructions.size() - 1).getEndOffset()) {
                continue;
            }


            final OpCode endOpCode = end.getOpCode();


            //
            // Create normal edges from one instruction to the next.
            //
            if (!endOpCode.isUnconditionalBranch()) {
                final Instruction next = end.getNext();


                if (next != null) {
                    createEdge(node, next, JumpType.Normal);
                }
            }

View Full Code Here

        //
        // Step 4: Create edges for the exceptional control flow.
        //


        for (final ControlFlowNode node : _nodes) {
            final Instruction end = node.getEnd();


            if (end != null &&
                end.getOffset() < _instructions.get(_instructions.size() - 1).getEndOffset()) {


                final ControlFlowNode innermostHandler = findInnermostExceptionHandlerNode(node.getEnd().getOffset());


                if (innermostHandler == _exceptionalExit) {
                    if (any(node.getInstructions(), CAN_THROW)) {

View Full Code Here

0 1 2 3

TOP

Related Classes of com.strobel.assembler.ir.Instruction

com.strobel.assembler.flowanalysis.ControlFlowGraphBuilder

com.strobel.assembler.flowanalysis.ControlFlowNode$InstructionIterator

com.strobel.assembler.metadata.ExceptionHandlerMapper

com.strobel.assembler.metadata.Label

com.strobel.assembler.metadata.MethodReader

com.strobel.decompiler.ast.LoopsAndConditions

com.strobel.decompiler.DecompilerHelpers

com.strobel.decompiler.InstructionHelper

com.strobel.decompiler.languages.BytecodeLanguage$InstructionPrinter

com.strobel.decompiler.PlainTextOutput

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.