Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.strobel.decompiler.ast.AstBuilder Maven / Gradle / Ivy
/*
* AstBuilder.java
*
* Copyright (c) 2013 Mike Strobel
*
* This source code is based on Mono.Cecil from Jb Evain, Copyright (c) Jb Evain;
* and ILSpy/ICSharpCode from SharpDevelop, Copyright (c) AlphaSierraPapa.
*
* This source code is subject to terms and conditions of the Apache License, Version 2.0.
* A copy of the license can be found in the License.html file at the root of this distribution.
* By using this source code in any fashion, you are agreeing to be bound by the terms of the
* Apache License, Version 2.0.
*
* You must not remove this notice, or any other, from this software.
*/
package com.strobel.decompiler.ast;
import com.strobel.annotations.NotNull;
import com.strobel.assembler.flowanalysis.ControlFlowEdge;
import com.strobel.assembler.flowanalysis.ControlFlowGraph;
import com.strobel.assembler.flowanalysis.ControlFlowGraphBuilder;
import com.strobel.assembler.flowanalysis.ControlFlowNode;
import com.strobel.assembler.flowanalysis.ControlFlowNodeType;
import com.strobel.assembler.flowanalysis.JumpType;
import com.strobel.assembler.ir.*;
import com.strobel.assembler.metadata.*;
import com.strobel.core.*;
import com.strobel.decompiler.DecompilerContext;
import com.strobel.decompiler.ITextOutput;
import com.strobel.decompiler.InstructionHelper;
import com.strobel.decompiler.PlainTextOutput;
import com.strobel.functions.Function;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import static com.strobel.core.CollectionUtilities.*;
import static com.strobel.decompiler.ast.PatternMatching.match;
import static java.lang.String.format;
public final class AstBuilder {
private final static Logger LOG = Logger.getLogger(AstBuilder.class.getSimpleName());
private final static AstCode[] CODES = AstCode.values();
private final static StackSlot[] EMPTY_STACK = new StackSlot[0];
private final static ByteCode[] EMPTY_DEFINITIONS = new ByteCode[0];
private final Map _loadExceptions = new LinkedHashMap<>();
private final Set _removed = new LinkedHashSet<>();
private Map _originalInstructionMap;
private ControlFlowGraph _cfg;
private InstructionCollection _instructions;
private List _exceptionHandlers;
private MethodBody _body;
private boolean _optimize;
private DecompilerContext _context;
private CoreMetadataFactory _factory;
public static List build(final MethodBody body, final boolean optimize, final DecompilerContext context) {
final AstBuilder builder = new AstBuilder();
builder._body = VerifyArgument.notNull(body, "body");
builder._optimize = optimize;
builder._context = VerifyArgument.notNull(context, "context");
if (LOG.isLoggable(Level.FINE)) {
LOG.fine(
format(
"Beginning bytecode AST construction for %s:%s...",
body.getMethod().getFullName(),
body.getMethod().getSignature()
)
);
}
if (body.getInstructions().isEmpty()) {
return Collections.emptyList();
}
builder._instructions = copyInstructions(body.getInstructions());
final InstructionCollection oldInstructions = body.getInstructions();
final InstructionCollection newInstructions = builder._instructions;
builder._originalInstructionMap = new IdentityHashMap<>();
for (int i = 0; i < newInstructions.size(); i++) {
builder._originalInstructionMap.put(newInstructions.get(i), oldInstructions.get(i));
}
builder._exceptionHandlers = remapHandlers(body.getExceptionHandlers(), builder._instructions);
Collections.sort(builder._exceptionHandlers);
builder.removeGetClassCallsForInvokeDynamic();
builder.pruneExceptionHandlers();
FinallyInlining.run(builder._body, builder._instructions, builder._exceptionHandlers, builder._removed);
builder.inlineSubroutines();
builder._cfg = ControlFlowGraphBuilder.build(builder._instructions, builder._exceptionHandlers);
builder._cfg.computeDominance();
builder._cfg.computeDominanceFrontier();
LOG.fine("Performing stack analysis...");
final List byteCode = builder.performStackAnalysis();
LOG.fine("Creating bytecode AST...");
@SuppressWarnings("UnnecessaryLocalVariable")
final List ast = builder.convertToAst(
byteCode,
new LinkedHashSet<>(builder._exceptionHandlers),
0,
new MutableInteger(byteCode.size())
);
if (LOG.isLoggable(Level.FINE)) {
LOG.fine(
format(
"Finished bytecode AST construction for %s:%s.",
body.getMethod().getFullName(),
body.getMethod().getSignature()
)
);
}
return ast;
}
private static boolean isGetClassInvocation(final Instruction p) {
return p != null &&
p.getOpCode() == OpCode.INVOKEVIRTUAL &&
p.getOperand(0).getParameters().isEmpty() &&
StringUtilities.equals(p.getOperand(0).getName(), "getClass");
}
private void removeGetClassCallsForInvokeDynamic() {
for (final Instruction i : _instructions) {
if (i.getOpCode() != OpCode.INVOKEDYNAMIC) {
continue;
}
final Instruction p1 = i.getPrevious();
if (p1 == null || p1.getOpCode() != OpCode.POP) {
continue;
}
final Instruction p2 = p1.getPrevious();
if (p2 == null || !isGetClassInvocation(p2)) {
continue;
}
final Instruction p3 = p2.getPrevious();
if (p3 == null || p3.getOpCode() != OpCode.DUP) {
continue;
}
p1.setOpCode(OpCode.NOP);
p1.setOperand(null);
p2.setOpCode(OpCode.NOP);
p2.setOperand(null);
p3.setOpCode(OpCode.NOP);
p3.setOperand(null);
}
}
@SuppressWarnings("ConstantConditions")
private void inlineSubroutines() {
LOG.fine("Inlining subroutines...");
final List subroutines = findSubroutines();
if (subroutines.isEmpty()) {
return;
}
final List handlers = _exceptionHandlers;
final Set originalHandlers = new HashSet<>(handlers);
final List inlinedSubroutines = new ArrayList<>();
final Set instructionsToKeep = new HashSet<>();
for (final SubroutineInfo subroutine : subroutines) {
if (callsOtherSubroutine(subroutine, subroutines)) {
continue;
}
boolean fullyInlined = true;
for (final Instruction reference : subroutine.liveReferences) {
fullyInlined &= inlineSubroutine(subroutine, reference);
}
for (final Instruction p : subroutine.deadReferences) {
p.setOpCode(OpCode.NOP);
p.setOperand(null);
_removed.add(p);
}
if (fullyInlined) {
inlinedSubroutines.add(subroutine);
}
else {
for (final ControlFlowNode node : subroutine.contents) {
for (Instruction p = node.getStart();
p != null && p.getOffset() < node.getStart().getEndOffset();
p = p.getNext()) {
instructionsToKeep.add(p);
}
}
}
}
//
// NOP-out the original subroutine instructions only after all subroutines have been processed.
// Note that there might be overlapping subroutines, and it's possible that some ranges may still
// be live code if not all subroutines were successfully inlined at all jump sites.
//
for (final SubroutineInfo subroutine : inlinedSubroutines) {
for (Instruction p = subroutine.start;
p != null && p.getOffset() < subroutine.end.getEndOffset();
p = p.getNext()) {
if (instructionsToKeep.contains(p)) {
continue;
}
p.setOpCode(OpCode.NOP);
p.setOperand(null);
_removed.add(p);
}
for (final ExceptionHandler handler : subroutine.containedHandlers) {
if (originalHandlers.contains(handler)) {
handlers.remove(handler);
}
}
}
}
private boolean inlineSubroutine(final SubroutineInfo subroutine, final Instruction reference) {
if (!subroutine.start.getOpCode().isStore()) {
return false;
}
final InstructionCollection instructions = _instructions;
final Map originalInstructionMap = _originalInstructionMap;
final boolean nonEmpty = subroutine.start != subroutine.end && subroutine.start.getNext() != subroutine.end;
if (nonEmpty) {
final int jumpIndex = instructions.indexOf(reference);
final List originalContents = new ArrayList<>();
for (final ControlFlowNode node : subroutine.contents) {
for (Instruction p = node.getStart();
p != null && p.getOffset() < node.getEnd().getEndOffset();
p = p.getNext()) {
originalContents.add(p);
}
}
final Map remappedJumps = new IdentityHashMap<>();
final List contents = copyInstructions(originalContents);
for (int i = 0, n = originalContents.size(); i < n; i++) {
remappedJumps.put(originalContents.get(i), contents.get(i));
originalInstructionMap.put(contents.get(i), mappedInstruction(originalInstructionMap, originalContents.get(i)));
}
final Instruction newStart = mappedInstruction(remappedJumps, subroutine.start);
final Instruction newEnd = reference.getNext() != null ? reference.getNext()
: mappedInstruction(remappedJumps, subroutine.end).getPrevious();
for (final ControlFlowNode exitNode : subroutine.exitNodes) {
final Instruction newExit = mappedInstruction(remappedJumps, exitNode.getEnd());
if (newExit != null) {
newExit.setOpCode(OpCode.GOTO);
newExit.setOperand(newEnd);
remappedJumps.put(newExit, newEnd);
}
}
newStart.setOpCode(OpCode.NOP);
newStart.setOperand(null);
instructions.addAll(jumpIndex, toList(contents));
if (newStart != first(contents)) {
instructions.add(jumpIndex, new Instruction(OpCode.GOTO, newStart));
}
instructions.remove(reference);
instructions.recomputeOffsets();
remappedJumps.put(reference, first(contents));
remappedJumps.put(subroutine.end, newEnd);
remappedJumps.put(subroutine.start, newStart);
remapJumps(Collections.singletonMap(reference, newStart));
remapHandlersForInlinedSubroutine(reference, first(contents), last(contents));
duplicateHandlersForInlinedSubroutine(subroutine, remappedJumps);
}
else {
reference.setOpCode(OpCode.NOP);
reference.setOperand(OpCode.NOP);
}
return true;
}
@SuppressWarnings("ConstantConditions")
private void remapHandlersForInlinedSubroutine(
final Instruction jump,
final Instruction start,
final Instruction end) {
final List handlers = _exceptionHandlers;
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
final InstructionBlock oldTry = handler.getTryBlock();
final InstructionBlock oldHandler = handler.getHandlerBlock();
final InstructionBlock newTryBlock;
final InstructionBlock newHandlerBlock;
if (oldTry.getFirstInstruction() == jump || oldTry.getLastInstruction() == jump) {
newTryBlock = new InstructionBlock(
oldTry.getFirstInstruction() == jump ? start : oldTry.getFirstInstruction(),
oldTry.getLastInstruction() == jump ? end : oldTry.getLastInstruction()
);
}
else {
newTryBlock = oldTry;
}
if (oldHandler.getFirstInstruction() == jump || oldHandler.getLastInstruction() == jump) {
newHandlerBlock = new InstructionBlock(
oldHandler.getFirstInstruction() == jump ? start : oldHandler.getFirstInstruction(),
oldHandler.getLastInstruction() == jump ? end : oldHandler.getLastInstruction()
);
}
else {
newHandlerBlock = oldHandler;
}
if (newTryBlock != oldTry || newHandlerBlock != oldHandler) {
if (handler.isCatch()) {
handlers.set(
i,
ExceptionHandler.createCatch(newTryBlock, newHandlerBlock, handler.getCatchType())
);
}
else {
handlers.set(
i,
ExceptionHandler.createFinally(newTryBlock, newHandlerBlock)
);
}
}
}
}
@SuppressWarnings("ConstantConditions")
private void duplicateHandlersForInlinedSubroutine(final SubroutineInfo subroutine, final Map oldToNew) {
final List handlers = _exceptionHandlers;
for (final ExceptionHandler handler : subroutine.containedHandlers) {
final InstructionBlock oldTry = handler.getTryBlock();
final InstructionBlock oldHandler = handler.getHandlerBlock();
final InstructionBlock newTryBlock;
final InstructionBlock newHandlerBlock;
final Instruction newTryStart = mappedInstruction(oldToNew, oldTry.getFirstInstruction());
final Instruction newTryEnd = mappedInstruction(oldToNew, oldTry.getLastInstruction());
final Instruction newHandlerStart = mappedInstruction(oldToNew, oldHandler.getFirstInstruction());
final Instruction newHandlerEnd = mappedInstruction(oldToNew, oldHandler.getLastInstruction());
if (newTryStart != null || newTryEnd != null) {
newTryBlock = new InstructionBlock(
newTryStart != null ? newTryStart : oldTry.getFirstInstruction(),
newTryEnd != null ? newTryEnd : oldTry.getLastInstruction()
);
}
else {
newTryBlock = oldTry;
}
if (newHandlerStart != null || newHandlerEnd != null) {
newHandlerBlock = new InstructionBlock(
newHandlerStart != null ? newHandlerStart : oldHandler.getFirstInstruction(),
newHandlerEnd != null ? newHandlerEnd : oldHandler.getLastInstruction()
);
}
else {
newHandlerBlock = oldHandler;
}
if (newTryBlock != oldTry || newHandlerBlock != oldHandler) {
handlers.add(
handler.isCatch() ? ExceptionHandler.createCatch(newTryBlock, newHandlerBlock, handler.getCatchType())
: ExceptionHandler.createFinally(newTryBlock, newHandlerBlock)
);
}
}
}
@SuppressWarnings("ConstantConditions")
private void remapJumps(final Map remappedJumps) {
for (final Instruction instruction : _instructions) {
if (instruction.hasLabel()) {
instruction.getLabel().setIndex(instruction.getOffset());
}
if (instruction.getOperandCount() == 0) {
continue;
}
final Object operand = instruction.getOperand(0);
if (operand instanceof Instruction) {
final Instruction oldTarget = (Instruction) operand;
final Instruction newTarget = mappedInstruction(remappedJumps, oldTarget);
if (newTarget != null) {
if (newTarget == instruction) {
instruction.setOpCode(OpCode.NOP);
instruction.setOperand(null);
}
else {
instruction.setOperand(newTarget);
if (!newTarget.hasLabel()) {
newTarget.setLabel(new com.strobel.assembler.metadata.Label(newTarget.getOffset()));
}
}
}
}
else if (operand instanceof SwitchInfo) {
final SwitchInfo oldOperand = (SwitchInfo) operand;
final Instruction oldDefault = oldOperand.getDefaultTarget();
final Instruction newDefault = mappedInstruction(remappedJumps, oldDefault);
if (newDefault != null && !newDefault.hasLabel()) {
newDefault.setLabel(new com.strobel.assembler.metadata.Label(newDefault.getOffset()));
}
final Instruction[] oldTargets = oldOperand.getTargets();
Instruction[] newTargets = null;
for (int i = 0; i < oldTargets.length; i++) {
final Instruction newTarget = mappedInstruction(remappedJumps, oldTargets[i]);
if (newTarget != null) {
if (newTargets == null) {
newTargets = Arrays.copyOf(oldTargets, oldTargets.length);
}
newTargets[i] = newTarget;
if (!newTarget.hasLabel()) {
newTarget.setLabel(new com.strobel.assembler.metadata.Label(newTarget.getOffset()));
}
}
}
if (newDefault != null || newTargets != null) {
final SwitchInfo newOperand = new SwitchInfo(
oldOperand.getKeys(),
newDefault != null ? newDefault : oldDefault,
newTargets != null ? newTargets : oldTargets
);
instruction.setOperand(newOperand);
}
}
}
}
private boolean callsOtherSubroutine(final SubroutineInfo subroutine, final List subroutines) {
return any(
subroutines,
new Predicate() {
@Override
public boolean test(final SubroutineInfo info) {
return info != subroutine &&
any(
info.liveReferences,
new Predicate() {
@Override
public boolean test(final Instruction p) {
return p.getOffset() >= subroutine.start.getOffset() &&
p.getOffset() < subroutine.end.getEndOffset();
}
}
) &&
!subroutine.contents.containsAll(info.contents);
}
}
);
}
private List findSubroutines() {
final InstructionCollection instructions = _instructions;
if (instructions.isEmpty()) {
return Collections.emptyList();
}
Map, Set>> handlerContents = null;
Map subroutineMap = null;
ControlFlowGraph cfg = null;
for (Instruction p = first(instructions);
p != null;
p = p.getNext()) {
if (!p.getOpCode().isJumpToSubroutine()) {
continue;
}
final boolean isLive = !_removed.contains(p);
if (cfg == null) {
cfg = ControlFlowGraphBuilder.build(instructions, _exceptionHandlers);
cfg.computeDominance();
cfg.computeDominanceFrontier();
subroutineMap = new IdentityHashMap<>();
handlerContents = new IdentityHashMap<>();
for (final ExceptionHandler handler : _exceptionHandlers) {
final InstructionBlock tryBlock = handler.getTryBlock();
final InstructionBlock handlerBlock = handler.getHandlerBlock();
final Set tryNodes = findDominatedNodes(
cfg,
findNode(cfg, tryBlock.getFirstInstruction()),
true,
Collections.emptySet()
);
final Set handlerNodes = findDominatedNodes(
cfg,
findNode(cfg, handlerBlock.getFirstInstruction()),
true,
Collections.emptySet()
);
handlerContents.put(handler, Pair.create(tryNodes, handlerNodes));
}
}
final Instruction target = p.getOperand(0);
if (_removed.contains(target)) {
continue;
}
SubroutineInfo info = subroutineMap.get(target);
if (info == null) {
final ControlFlowNode start = findNode(cfg, target);
final List contents = toList(
findDominatedNodes(
cfg,
start,
true,
Collections.emptySet()
)
);
Collections.sort(contents);
subroutineMap.put(target, info = new SubroutineInfo(start, contents, cfg));
for (final ExceptionHandler handler : _exceptionHandlers) {
final Pair, Set> pair = handlerContents.get(handler);
if (contents.containsAll(pair.getFirst()) && contents.containsAll(pair.getSecond())) {
info.containedHandlers.add(handler);
}
}
}
if (isLive) {
info.liveReferences.add(p);
}
else {
info.deadReferences.add(p);
}
}
if (subroutineMap == null) {
return Collections.emptyList();
}
final List subroutines = toList(subroutineMap.values());
Collections.sort(
subroutines,
new Comparator() {
@Override
public int compare(@NotNull final SubroutineInfo o1, @NotNull final SubroutineInfo o2) {
if (o1.contents.containsAll(o2.contents)) {
return 1;
}
if (o2.contents.containsAll(o1.contents)) {
return -1;
}
return Integer.compare(o2.start.getOffset(), o1.start.getOffset());
}
}
);
return subroutines;
}
private final static class SubroutineInfo {
final Instruction start;
final Instruction end;
final List liveReferences = new ArrayList<>();
final List deadReferences = new ArrayList<>();
final List contents;
final ControlFlowNode entryNode;
final List exitNodes = new ArrayList<>();
final List containedHandlers = new ArrayList<>();
final ControlFlowGraph cfg;
public SubroutineInfo(final ControlFlowNode entryNode, final List contents, final ControlFlowGraph cfg) {
this.start = entryNode.getStart();
this.end = last(contents).getEnd();
this.entryNode = entryNode;
this.contents = contents;
this.cfg = cfg;
for (final ControlFlowNode node : contents) {
if (node.getNodeType() == ControlFlowNodeType.Normal &&
node.getEnd().getOpCode().isReturnFromSubroutine()) {
this.exitNodes.add(node);
}
}
}
}
private final static class HandlerInfo {
final ExceptionHandler handler;
final ControlFlowNode handlerNode;
final ControlFlowNode head;
final ControlFlowNode tail;
final List tryNodes;
final List handlerNodes;
HandlerInfo(
final ExceptionHandler handler,
final ControlFlowNode handlerNode,
final ControlFlowNode head,
final ControlFlowNode tail,
final List tryNodes,
final List handlerNodes) {
this.handler = handler;
this.handlerNode = handlerNode;
this.head = head;
this.tail = tail;
this.tryNodes = tryNodes;
this.handlerNodes = handlerNodes;
}
}
private static ControlFlowNode findNode(final ControlFlowGraph cfg, final Instruction instruction) {
final int offset = instruction.getOffset();
for (final ControlFlowNode node : cfg.getNodes()) {
if (node.getNodeType() != ControlFlowNodeType.Normal) {
continue;
}
if (offset >= node.getStart().getOffset() &&
offset < node.getEnd().getEndOffset()) {
return node;
}
}
return null;
}
private static Set findDominatedNodes(
final ControlFlowGraph cfg,
final ControlFlowNode head,
final boolean diveIntoHandlers,
final Set terminals) {
final Set visited = new LinkedHashSet<>();
final ArrayDeque agenda = new ArrayDeque<>();
final Set result = new LinkedHashSet<>();
agenda.add(head);
visited.add(head);
while (!agenda.isEmpty()) {
ControlFlowNode addNode = agenda.removeFirst();
if (terminals.contains(addNode)) {
continue;
}
if (diveIntoHandlers && addNode.getExceptionHandler() != null) {
addNode = findNode(cfg, addNode.getExceptionHandler().getHandlerBlock().getFirstInstruction());
}
else if (diveIntoHandlers && addNode.getNodeType() == ControlFlowNodeType.EndFinally) {
agenda.addAll(addNode.getDominatorTreeChildren());
continue;
}
if (addNode == null || addNode.getNodeType() != ControlFlowNodeType.Normal) {
continue;
}
if (!head.dominates(addNode) &&
!shouldIncludeExceptionalExit(cfg, head, addNode)) {
continue;
}
if (!result.add(addNode)) {
continue;
}
for (final ControlFlowNode successor : addNode.getSuccessors()) {
if (visited.add(successor)) {
agenda.add(successor);
}
}
}
return result;
}
private static boolean shouldIncludeExceptionalExit(
final ControlFlowGraph cfg,
final ControlFlowNode head,
final ControlFlowNode node) {
if (node.getNodeType() != ControlFlowNodeType.Normal) {
return false;
}
if (!node.getDominanceFrontier().contains(cfg.getExceptionalExit()) &&
!node.dominates(cfg.getExceptionalExit())) {
final ControlFlowNode innermostHandlerNode = findInnermostExceptionHandlerNode(cfg, node.getEnd().getOffset(), false);
if (innermostHandlerNode == null || !node.getDominanceFrontier().contains(innermostHandlerNode)) {
return false;
}
}
return head.getNodeType() == ControlFlowNodeType.Normal &&
node.getNodeType() == ControlFlowNodeType.Normal &&
node.getStart().getNext() == node.getEnd() &&
head.getStart().getOpCode().isStore() &&
node.getStart().getOpCode().isLoad() &&
node.getEnd().getOpCode() == OpCode.ATHROW &&
InstructionHelper.getLoadOrStoreSlot(head.getStart()) == InstructionHelper.getLoadOrStoreSlot(node.getStart());
}
private static ControlFlowNode findInnermostExceptionHandlerNode(
final ControlFlowGraph cfg,
final int offsetInTryBlock,
final boolean finallyOnly) {
ExceptionHandler result = null;
ControlFlowNode resultNode = null;
final List nodes = cfg.getNodes();
for (int i = nodes.size() - 1; i >= 0; i--) {
final ControlFlowNode node = nodes.get(i);
final ExceptionHandler handler = node.getExceptionHandler();
if (handler == null) {
break;
}
if (finallyOnly && handler.isCatch()) {
continue;
}
final InstructionBlock tryBlock = handler.getTryBlock();
if (tryBlock.getFirstInstruction().getOffset() <= offsetInTryBlock &&
offsetInTryBlock < tryBlock.getLastInstruction().getEndOffset() &&
(result == null ||
tryBlock.getFirstInstruction().getOffset() > result.getTryBlock().getFirstInstruction().getOffset())) {
result = handler;
resultNode = node;
}
}
return resultNode != null ? resultNode
: cfg.getExceptionalExit();
}
private static boolean opCodesMatch(
final Instruction tail1,
final Instruction tail2,
final int count,
final Function previous) {
int i = 0;
if (tail1 == null || tail2 == null) {
return false;
}
for (Instruction p1 = tail1, p2 = tail2;
p1 != null && p2 != null && i < count;
p1 = previous.apply(p1), p2 = previous.apply(p2), i++) {
final OpCode c1 = p1.getOpCode();
final OpCode c2 = p2.getOpCode();
if (c1.isLoad()) {
if (!c2.isLoad() || c2.getStackBehaviorPush() != c1.getStackBehaviorPush()) {
return false;
}
}
else if (c1.isStore()) {
if (!c2.isStore() || c2.getStackBehaviorPop() != c1.getStackBehaviorPop()) {
return false;
}
}
else if (c1 != p2.getOpCode()) {
return false;
}
switch (c1.getOperandType()) {
case TypeReferenceU1:
if (!Objects.equals(p1.getOperand(1), p2.getOperand(1))) {
return false;
}
// fall through
case PrimitiveTypeCode:
case TypeReference: {
if (!Objects.equals(p1.getOperand(0), p2.getOperand(0))) {
return false;
}
break;
}
case MethodReference:
case FieldReference: {
final MemberReference m1 = p1.getOperand(0);
final MemberReference m2 = p2.getOperand(0);
if (!StringUtilities.equals(m1.getFullName(), m2.getFullName()) ||
!StringUtilities.equals(m1.getErasedSignature(), m2.getErasedSignature())) {
return false;
}
break;
}
case I1:
case I2:
case I8:
case Constant:
case WideConstant: {
if (!Objects.equals(p1.getOperand(0), p2.getOperand(0))) {
return false;
}
break;
}
case LocalI1:
case LocalI2: {
if (!Objects.equals(p1.getOperand(1), p2.getOperand(1))) {
return false;
}
break;
}
}
}
return i == count;
}
private static Map createNodeMap(final ControlFlowGraph cfg) {
final Map nodeMap = new IdentityHashMap<>();
for (final ControlFlowNode node : cfg.getNodes()) {
if (node.getNodeType() != ControlFlowNodeType.Normal) {
continue;
}
for (Instruction p = node.getStart();
p != null && p.getOffset() < node.getEnd().getEndOffset();
p = p.getNext()) {
nodeMap.put(p, node);
}
}
return nodeMap;
}
private static List remapHandlers(final List handlers, final InstructionCollection instructions) {
final List newHandlers = new ArrayList<>();
for (final ExceptionHandler handler : handlers) {
final InstructionBlock oldTry = handler.getTryBlock();
final InstructionBlock oldHandler = handler.getHandlerBlock();
final InstructionBlock newTry = new InstructionBlock(
instructions.atOffset(oldTry.getFirstInstruction().getOffset()),
instructions.atOffset(oldTry.getLastInstruction().getOffset())
);
final InstructionBlock newHandler = new InstructionBlock(
instructions.atOffset(oldHandler.getFirstInstruction().getOffset()),
instructions.atOffset(oldHandler.getLastInstruction().getOffset())
);
if (handler.isCatch()) {
newHandlers.add(
ExceptionHandler.createCatch(
newTry,
newHandler,
handler.getCatchType()
)
);
}
else {
newHandlers.add(
ExceptionHandler.createFinally(
newTry,
newHandler
)
);
}
}
return newHandlers;
}
private static InstructionCollection copyInstructions(final List instructions) {
final InstructionCollection instructionsCopy = new InstructionCollection();
final Map oldToNew = new IdentityHashMap<>();
for (final Instruction instruction : instructions) {
final Instruction copy = new Instruction(instruction.getOffset(), instruction.getOpCode());
if (instruction.getOperandCount() > 1) {
final Object[] operands = new Object[instruction.getOperandCount()];
for (int i = 0; i < operands.length; i++) {
operands[i] = instruction.getOperand(i);
}
copy.setOperand(operands);
}
else {
copy.setOperand(instruction.getOperand(0));
}
copy.setLabel(instruction.getLabel());
instructionsCopy.add(copy);
oldToNew.put(instruction, copy);
}
for (final Instruction instruction : instructionsCopy) {
if (!instruction.hasOperand()) {
continue;
}
final Object operand = instruction.getOperand(0);
if (operand instanceof Instruction) {
instruction.setOperand(mappedInstruction(oldToNew, (Instruction) operand));
}
else if (operand instanceof SwitchInfo) {
final SwitchInfo oldOperand = (SwitchInfo) operand;
final Instruction oldDefault = oldOperand.getDefaultTarget();
final Instruction newDefault = mappedInstruction(oldToNew, oldDefault);
final Instruction[] oldTargets = oldOperand.getTargets();
final Instruction[] newTargets = new Instruction[oldTargets.length];
for (int i = 0; i < newTargets.length; i++) {
newTargets[i] = mappedInstruction(oldToNew, oldTargets[i]);
}
final SwitchInfo newOperand = new SwitchInfo(oldOperand.getKeys(), newDefault, newTargets);
newOperand.setLowValue(oldOperand.getLowValue());
newOperand.setHighValue(oldOperand.getHighValue());
instruction.setOperand(newOperand);
}
}
instructionsCopy.recomputeOffsets();
return instructionsCopy;
}
@SuppressWarnings("ConstantConditions")
private void pruneExceptionHandlers() {
LOG.fine("Pruning exception handlers...");
final List handlers = _exceptionHandlers;
if (handlers.isEmpty()) {
return;
}
removeSelfHandlingFinallyHandlers();
removeEmptyCatchBlockBodies();
trimAggressiveFinallyBlocks();
trimAggressiveCatchBlocks();
closeTryHandlerGaps();
// extendHandlers();
mergeSharedHandlers();
alignFinallyBlocksWithSiblingCatchBlocks();
ensureDesiredProtectedRanges();
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
if (!handler.isFinally()) {
continue;
}
final InstructionBlock tryBlock = handler.getTryBlock();
final List siblings = findHandlers(tryBlock, handlers);
for (int j = 0; j < siblings.size(); j++) {
final ExceptionHandler sibling = siblings.get(j);
if (sibling.isCatch() && j < siblings.size() - 1) {
final ExceptionHandler nextSibling = siblings.get(j + 1);
if (sibling.getHandlerBlock().getLastInstruction() !=
nextSibling.getHandlerBlock().getFirstInstruction().getPrevious()) {
final int index = handlers.indexOf(sibling);
handlers.set(
index,
ExceptionHandler.createCatch(
sibling.getTryBlock(),
new InstructionBlock(
sibling.getHandlerBlock().getFirstInstruction(),
nextSibling.getHandlerBlock().getFirstInstruction().getPrevious()
),
sibling.getCatchType()
)
);
siblings.set(j, handlers.get(j));
}
}
}
}
outer:
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
if (!handler.isFinally()) {
continue;
}
final InstructionBlock tryBlock = handler.getTryBlock();
final List siblings = findHandlers(tryBlock, handlers);
for (final ExceptionHandler sibling : siblings) {
if (sibling == handler || sibling.isFinally()) {
continue;
}
for (int j = 0; j < handlers.size(); j++) {
final ExceptionHandler e = handlers.get(j);
if (e == handler || e == sibling || !e.isFinally()) {
continue;
}
if (e.getTryBlock().getFirstInstruction() == sibling.getHandlerBlock().getFirstInstruction() &&
e.getHandlerBlock().equals(handler.getHandlerBlock())) {
handlers.remove(j);
final int removeIndex = j--;
if (removeIndex < i) {
--i;
continue outer;
}
}
}
}
}
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
if (!handler.isFinally()) {
continue;
}
final InstructionBlock tryBlock = handler.getTryBlock();
final InstructionBlock handlerBlock = handler.getHandlerBlock();
for (int j = 0; j < handlers.size(); j++) {
final ExceptionHandler other = handlers.get(j);
if (other != handler &&
other.isFinally() &&
other.getHandlerBlock().equals(handlerBlock) &&
tryBlock.contains(other.getTryBlock()) &&
tryBlock.getLastInstruction() == other.getTryBlock().getLastInstruction()) {
handlers.remove(j);
if (j < i) {
--i;
break;
}
--j;
}
}
}
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
final InstructionBlock tryBlock = handler.getTryBlock();
final ExceptionHandler firstHandler = findFirstHandler(tryBlock, handlers);
final InstructionBlock firstHandlerBlock = firstHandler.getHandlerBlock();
final Instruction firstAfterTry = tryBlock.getLastInstruction().getNext();
final Instruction firstInHandler = firstHandlerBlock.getFirstInstruction();
final Instruction lastBeforeHandler = firstInHandler.getPrevious();
if (firstAfterTry != firstInHandler &&
firstAfterTry != null &&
lastBeforeHandler != null) {
InstructionBlock newTryBlock = null;
final FlowControl flowControl = lastBeforeHandler.getOpCode().getFlowControl();
if (flowControl == FlowControl.Branch ||
flowControl == FlowControl.Return && lastBeforeHandler.getOpCode() == OpCode.RETURN) {
if (lastBeforeHandler == firstAfterTry) {
newTryBlock = new InstructionBlock(tryBlock.getFirstInstruction(), lastBeforeHandler);
}
}
else if (flowControl == FlowControl.Throw ||
flowControl == FlowControl.Return && lastBeforeHandler.getOpCode() != OpCode.RETURN) {
if (lastBeforeHandler.getPrevious() == firstAfterTry) {
newTryBlock = new InstructionBlock(tryBlock.getFirstInstruction(), lastBeforeHandler);
}
}
if (newTryBlock != null) {
final List siblings = findHandlers(tryBlock, handlers);
for (int j = 0; j < siblings.size(); j++) {
final ExceptionHandler sibling = siblings.get(j);
final int index = handlers.indexOf(sibling);
if (sibling.isCatch()) {
handlers.set(
index,
ExceptionHandler.createCatch(
newTryBlock,
sibling.getHandlerBlock(),
sibling.getCatchType()
)
);
}
else {
handlers.set(
index,
ExceptionHandler.createFinally(
newTryBlock,
sibling.getHandlerBlock()
)
);
}
}
}
}
}
//
// Look for finally blocks which duplicate an outer catch.
//
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
final InstructionBlock tryBlock = handler.getTryBlock();
final InstructionBlock handlerBlock = handler.getHandlerBlock();
if (!handler.isFinally()) {
continue;
}
final ExceptionHandler innermostHandler = findInnermostExceptionHandler(
tryBlock.getFirstInstruction().getOffset(),
handler
);
if (innermostHandler == null ||
innermostHandler == handler ||
innermostHandler.isFinally()) {
continue;
}
for (int j = 0; j < handlers.size(); j++) {
final ExceptionHandler sibling = handlers.get(j);
if (sibling != handler &&
sibling != innermostHandler &&
sibling.getTryBlock().equals(handlerBlock) &&
sibling.getHandlerBlock().equals(innermostHandler.getHandlerBlock())) {
handlers.remove(j);
if (j < i) {
--i;
break;
}
--j;
}
}
}
}
private void removeEmptyCatchBlockBodies() {
final List handlers = _exceptionHandlers;
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
if (!handler.isCatch()) {
continue;
}
final InstructionBlock catchBlock = handler.getHandlerBlock();
final Instruction start = catchBlock.getFirstInstruction();
final Instruction end = catchBlock.getLastInstruction();
if (start != end || !start.getOpCode().isStore()) {
continue;
}
// final InstructionBlock tryBlock = handler.getTryBlock();
//
// for (int j = 0; j < handlers.size(); j++) {
// if (i == j) {
// continue;
// }
//
// final ExceptionHandler other = handlers.get(j);
// final InstructionBlock finallyBlock = other.getHandlerBlock();
//
// if (other.isFinally() &&
// finallyBlock.contains(tryBlock) &&
// finallyBlock.contains(catchBlock)) {
//
// final Instruction endFinally = finallyBlock.getLastInstruction();
//
// if (endFinally != null &&
// endFinally.getOpCode().isThrow() &&
// endFinally.getPrevious() != null &&
// endFinally.getPrevious().getOpCode().isLoad() &&
// endFinally.getPrevious().getPrevious() == end &&
// (InstructionHelper.getLoadOrStoreSlot(endFinally.getPrevious()) !=
// InstructionHelper.getLoadOrStoreSlot(end))) {
//
// end.setOpCode(OpCode.POP);
// end.setOperand(null);
// _removed.add(end);
// break;
// }
// }
// }
end.setOpCode(OpCode.POP);
end.setOperand(null);
_removed.add(end);
}
}
private void ensureDesiredProtectedRanges() {
final List handlers = _exceptionHandlers;
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
final InstructionBlock tryBlock = handler.getTryBlock();
final List siblings = findHandlers(tryBlock, handlers);
final ExceptionHandler firstSibling = first(siblings);
final InstructionBlock firstHandler = firstSibling.getHandlerBlock();
final Instruction desiredEndTry = firstHandler.getFirstInstruction().getPrevious();
for (int j = 0; j < siblings.size(); j++) {
ExceptionHandler sibling = siblings.get(j);
if (handler.getTryBlock().getLastInstruction() != desiredEndTry) {
final int index = handlers.indexOf(sibling);
if (sibling.isCatch()) {
handlers.set(
index,
ExceptionHandler.createCatch(
new InstructionBlock(
tryBlock.getFirstInstruction(),
desiredEndTry
),
sibling.getHandlerBlock(),
sibling.getCatchType()
)
);
}
else {
handlers.set(
index,
ExceptionHandler.createFinally(
new InstructionBlock(
tryBlock.getFirstInstruction(),
desiredEndTry
),
sibling.getHandlerBlock()
)
);
}
sibling = handlers.get(index);
siblings.set(j, sibling);
}
}
}
}
private void alignFinallyBlocksWithSiblingCatchBlocks() {
final List handlers = _exceptionHandlers;
outer:
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
if (handler.isCatch()) {
continue;
}
final InstructionBlock tryBlock = handler.getTryBlock();
final InstructionBlock handlerBlock = handler.getHandlerBlock();
for (int j = 0; j < handlers.size(); j++) {
if (i == j) {
continue;
}
final ExceptionHandler other = handlers.get(j);
final InstructionBlock otherTry = other.getTryBlock();
final InstructionBlock otherHandler = other.getHandlerBlock();
if (other.isCatch() &&
otherHandler.getLastInstruction().getNext() == handlerBlock.getFirstInstruction() &&
otherTry.getFirstInstruction() == tryBlock.getFirstInstruction() &&
otherTry.getLastInstruction().getOffset() < tryBlock.getLastInstruction().getOffset() &&
tryBlock.getLastInstruction().getEndOffset() > otherHandler.getFirstInstruction().getOffset()) {
handlers.set(
i,
ExceptionHandler.createFinally(
new InstructionBlock(
tryBlock.getFirstInstruction(),
otherHandler.getFirstInstruction().getPrevious()
),
handlerBlock
)
);
--i;
continue outer;
}
}
}
}
private void mergeSharedHandlers() {
final List handlers = _exceptionHandlers;
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
final List duplicates = findDuplicateHandlers(handler, handlers);
for (int j = 0; j < duplicates.size() - 1; j++) {
final ExceptionHandler h1 = duplicates.get(j);
final ExceptionHandler h2 = duplicates.get(1 + j);
final InstructionBlock try1 = h1.getTryBlock();
final InstructionBlock try2 = h2.getTryBlock();
final Instruction head = try1.getLastInstruction().getNext();
final Instruction tail = try2.getFirstInstruction().getPrevious();
final int i1 = handlers.indexOf(h1);
final int i2 = handlers.indexOf(h2);
if (head != tail) {
// if (tail.getOpCode().isUnconditionalBranch()) {
// switch (tail.getOpCode()) {
// case GOTO:
// case GOTO_W:
// case RETURN:
// tail = tail.getPrevious();
// break;
//
// case IRETURN:
// case LRETURN:
// case FRETURN:
// case DRETURN:
// case ARETURN:
// tail = tail.getPrevious().getPrevious();
// break;
// }
// }
//
// if (!areAllRemoved(head, tail)) {
// continue;
// }
if (h1.isCatch()) {
handlers.set(
i1,
ExceptionHandler.createCatch(
new InstructionBlock(try1.getFirstInstruction(), try2.getLastInstruction()),
h1.getHandlerBlock(),
h1.getCatchType()
)
);
}
else {
handlers.set(
i1,
ExceptionHandler.createFinally(
new InstructionBlock(try1.getFirstInstruction(), try2.getLastInstruction()),
h1.getHandlerBlock()
)
);
}
duplicates.set(j, handlers.get(i1));
duplicates.remove(j + 1);
handlers.remove(i2);
if (i2 <= i) {
--i;
}
--j;
}
}
}
}
private void trimAggressiveCatchBlocks() {
final List handlers = _exceptionHandlers;
outer:
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
final InstructionBlock tryBlock = handler.getTryBlock();
final InstructionBlock handlerBlock = handler.getHandlerBlock();
if (!handler.isCatch()) {
continue;
}
for (int j = 0; j < handlers.size(); j++) {
if (i == j) {
continue;
}
final ExceptionHandler other = handlers.get(j);
if (!other.isFinally()) {
continue;
}
final InstructionBlock otherTry = other.getTryBlock();
final InstructionBlock otherHandler = other.getHandlerBlock();
if (handlerBlock.getFirstInstruction().getOffset() < otherHandler.getFirstInstruction().getOffset() &&
handlerBlock.intersects(otherHandler) &&
!(handlerBlock.contains(otherTry) && handlerBlock.contains(otherHandler)) &&
!otherTry.contains(tryBlock)) {
handlers.set(
i--,
ExceptionHandler.createCatch(
tryBlock,
new InstructionBlock(
handlerBlock.getFirstInstruction(),
otherHandler.getFirstInstruction().getPrevious()
),
handler.getCatchType()
)
);
continue outer;
}
}
}
}
private void removeSelfHandlingFinallyHandlers() {
final List handlers = _exceptionHandlers;
//
// Remove self-handling finally blocks.
//
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
final InstructionBlock tryBlock = handler.getTryBlock();
final InstructionBlock handlerBlock = handler.getHandlerBlock();
if (handler.isFinally() &&
handlerBlock.getFirstInstruction() == tryBlock.getFirstInstruction() &&
tryBlock.getLastInstruction().getOffset() < handlerBlock.getLastInstruction().getEndOffset()) {
handlers.remove(i--);
}
}
}
private void trimAggressiveFinallyBlocks() {
final List handlers = _exceptionHandlers;
outer:
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
final InstructionBlock tryBlock = handler.getTryBlock();
final InstructionBlock handlerBlock = handler.getHandlerBlock();
if (!handler.isFinally()) {
continue;
}
for (int j = 0; j < handlers.size(); j++) {
if (i == j) {
continue;
}
final ExceptionHandler other = handlers.get(j);
if (!other.isCatch()) {
continue;
}
final InstructionBlock otherTry = other.getTryBlock();
final InstructionBlock otherHandler = other.getHandlerBlock();
if (tryBlock.getFirstInstruction() == otherTry.getFirstInstruction() &&
tryBlock.getLastInstruction() == otherHandler.getFirstInstruction()) {
handlers.set(
i--,
ExceptionHandler.createFinally(
new InstructionBlock(
tryBlock.getFirstInstruction(),
otherHandler.getFirstInstruction().getPrevious()
),
handlerBlock
)
);
continue outer;
}
}
}
}
private static ControlFlowNode findHandlerNode(final ControlFlowGraph cfg, final ExceptionHandler handler) {
final List nodes = cfg.getNodes();
for (int i = nodes.size() - 1; i >= 0; i--) {
final ControlFlowNode node = nodes.get(i);
if (node.getExceptionHandler() == handler) {
return node;
}
}
return null;
}
private ExceptionHandler findInnermostExceptionHandler(final int offsetInTryBlock, final ExceptionHandler exclude) {
ExceptionHandler result = null;
for (final ExceptionHandler handler : _exceptionHandlers) {
if (handler == exclude) {
continue;
}
final InstructionBlock tryBlock = handler.getTryBlock();
if (tryBlock.getFirstInstruction().getOffset() <= offsetInTryBlock &&
offsetInTryBlock < tryBlock.getLastInstruction().getEndOffset() &&
(result == null ||
tryBlock.getFirstInstruction().getOffset() > result.getTryBlock().getFirstInstruction().getOffset())) {
result = handler;
}
}
return result;
}
private void closeTryHandlerGaps() {
//
// Java does this retarded thing where a try block gets split along exit branches,
// but with the split parts sharing the same handler. We can't represent this in
// out AST, so just merge the parts back together.
//
final List handlers = _exceptionHandlers;
for (int i = 0; i < handlers.size() - 1; i++) {
final ExceptionHandler current = handlers.get(i);
final ExceptionHandler next = handlers.get(i + 1);
if (current.getHandlerBlock().equals(next.getHandlerBlock())) {
final Instruction lastInCurrent = current.getTryBlock().getLastInstruction();
final Instruction firstInNext = next.getTryBlock().getFirstInstruction();
final Instruction branchInBetween = firstInNext.getPrevious();
final Instruction beforeBranch;
if (branchInBetween != null) {
beforeBranch = branchInBetween.getPrevious();
}
else {
beforeBranch = null;
}
if (branchInBetween != null &&
branchInBetween.getOpCode().isBranch() &&
(lastInCurrent == beforeBranch || lastInCurrent == branchInBetween)) {
final ExceptionHandler newHandler;
if (current.isFinally()) {
newHandler = ExceptionHandler.createFinally(
new InstructionBlock(
current.getTryBlock().getFirstInstruction(),
next.getTryBlock().getLastInstruction()
),
new InstructionBlock(
current.getHandlerBlock().getFirstInstruction(),
current.getHandlerBlock().getLastInstruction()
)
);
}
else {
newHandler = ExceptionHandler.createCatch(
new InstructionBlock(
current.getTryBlock().getFirstInstruction(),
next.getTryBlock().getLastInstruction()
),
new InstructionBlock(
current.getHandlerBlock().getFirstInstruction(),
current.getHandlerBlock().getLastInstruction()
),
current.getCatchType()
);
}
handlers.set(i, newHandler);
handlers.remove(i + 1);
--i;
}
}
}
}
// private void extendHandlers() {
// final List handlers = _exceptionHandlers;
//
// outer:
// for (int i = 0; i < handlers.size(); i++) {
// final ExceptionHandler handler = handlers.get(i);
// final InstructionBlock tryBlock = handler.getTryBlock();
// final InstructionBlock handlerBlock = handler.getHandlerBlock();
//
// for (int j = 0; j < handlers.size(); j++) {
// if (i == j) {
// continue;
// }
//
// final ExceptionHandler other = handlers.get(j);
// final InstructionBlock otherHandler = other.getHandlerBlock();
//
// if (handlerBlock.intersects(otherHandler) &&
// !handlerBlock.contains(otherHandler) &&
// handlerBlock.getFirstInstruction().getOffset() <= otherHandler.getFirstInstruction().getOffset()) {
//
// if (handler.isCatch()) {
// handlers.set(
// i--,
// ExceptionHandler.createCatch(
// tryBlock,
// new InstructionBlock(
// handlerBlock.getFirstInstruction(),
// otherHandler.getLastInstruction()
// ),
// handler.getCatchType()
// )
// );
// }
// else {
// handlers.set(
// i--,
// ExceptionHandler.createFinally(
// tryBlock,
// new InstructionBlock(
// handlerBlock.getFirstInstruction(),
// otherHandler.getLastInstruction()
// )
// )
// );
// }
//
// continue outer;
// }
// }
// }
// }
private static ExceptionHandler findFirstHandler(final InstructionBlock tryBlock, final Collection handlers) {
ExceptionHandler result = null;
for (final ExceptionHandler handler : handlers) {
if (handler.getTryBlock().equals(tryBlock) &&
(result == null ||
handler.getHandlerBlock().getFirstInstruction().getOffset() < result.getHandlerBlock().getFirstInstruction().getOffset())) {
result = handler;
}
}
return result;
}
private static List findHandlers(final InstructionBlock tryBlock, final Collection handlers) {
List result = null;
for (final ExceptionHandler handler : handlers) {
if (handler.getTryBlock().equals(tryBlock)) {
if (result == null) {
result = new ArrayList<>();
}
result.add(handler);
}
}
if (result == null) {
return Collections.emptyList();
}
Collections.sort(
result,
new Comparator() {
@Override
public int compare(@NotNull final ExceptionHandler o1, @NotNull final ExceptionHandler o2) {
return Integer.compare(
o1.getHandlerBlock().getFirstInstruction().getOffset(),
o2.getHandlerBlock().getFirstInstruction().getOffset()
);
}
}
);
return result;
}
private static List findDuplicateHandlers(final ExceptionHandler handler, final Collection handlers) {
final List result = new ArrayList<>();
for (final ExceptionHandler other : handlers) {
if (other.getHandlerBlock().equals(handler.getHandlerBlock())) {
if (handler.isFinally()) {
if (other.isFinally()) {
result.add(other);
}
}
else if (other.isCatch() &&
MetadataHelper.isSameType(other.getCatchType(), handler.getCatchType())) {
result.add(other);
}
}
}
Collections.sort(
result,
new Comparator() {
@Override
public int compare(@NotNull final ExceptionHandler o1, @NotNull final ExceptionHandler o2) {
return Integer.compare(
o1.getTryBlock().getFirstInstruction().getOffset(),
o2.getTryBlock().getFirstInstruction().getOffset()
);
}
}
);
return result;
}
@SuppressWarnings("ConstantConditions")
private List performStackAnalysis() {
final Set handlerStarts = new HashSet<>();
final Map byteCodeMap = new LinkedHashMap<>();
final Map nodeMap = new IdentityHashMap<>();
final InstructionCollection instructions = _instructions;
final List exceptionHandlers = new ArrayList<>();
final List successors = new ArrayList<>();
for (final ControlFlowNode node : _cfg.getNodes()) {
if (node.getExceptionHandler() != null) {
exceptionHandlers.add(node.getExceptionHandler());
}
if (node.getNodeType() != ControlFlowNodeType.Normal) {
continue;
}
for (Instruction p = node.getStart();
p != null && p.getOffset() < node.getEnd().getEndOffset();
p = p.getNext()) {
nodeMap.put(p, node);
}
}
_exceptionHandlers.retainAll(exceptionHandlers);
final List body = new ArrayList<>(instructions.size());
final StackMappingVisitor stackMapper = new StackMappingVisitor();
final InstructionVisitor instructionVisitor = stackMapper.visitBody(_body);
final StrongBox codeBox = new StrongBox<>();
final StrongBox operandBox = new StrongBox<>();
_factory = CoreMetadataFactory.make(_context.getCurrentType(), _context.getCurrentMethod());
for (final Instruction instruction : instructions) {
final OpCode opCode = instruction.getOpCode();
AstCode code = CODES[opCode.ordinal()];
Object operand = instruction.hasOperand() ? instruction.getOperand(0) : null;
final Object secondOperand = instruction.getOperandCount() > 1 ? instruction.getOperand(1) : null;
codeBox.set(code);
operandBox.set(operand);
final int offset = mappedInstruction(_originalInstructionMap, instruction).getOffset();
if (AstCode.expandMacro(codeBox, operandBox, _body, offset)) {
code = codeBox.get();
operand = operandBox.get();
}
final ByteCode byteCode = new ByteCode();
byteCode.instruction = instruction;
byteCode.offset = instruction.getOffset();
byteCode.endOffset = instruction.getEndOffset();
byteCode.code = code;
byteCode.operand = operand;
byteCode.secondOperand = secondOperand;
byteCode.popCount = InstructionHelper.getPopDelta(instruction, _body);
byteCode.pushCount = InstructionHelper.getPushDelta(instruction, _body);
byteCodeMap.put(instruction, byteCode);
body.add(byteCode);
}
for (int i = 0, n = body.size() - 1; i < n; i++) {
final ByteCode next = body.get(i + 1);
final ByteCode current = body.get(i);
current.next = next;
next.previous = current;
}
final ArrayDeque agenda = new ArrayDeque<>();
final ArrayDeque handlerAgenda = new ArrayDeque<>();
final int variableCount = _body.getMaxLocals();
final VariableSlot[] unknownVariables = VariableSlot.makeUnknownState(variableCount);
final MethodReference method = _body.getMethod();
final List parameters = method.getParameters();
final boolean hasThis = _body.hasThis();
if (hasThis) {
if (method.isConstructor()) {
unknownVariables[0] = new VariableSlot(FrameValue.UNINITIALIZED_THIS, EMPTY_DEFINITIONS);
}
else {
unknownVariables[0] = new VariableSlot(FrameValue.makeReference(_context.getCurrentType()), EMPTY_DEFINITIONS);
}
}
final ByteCode[] definitions = new ByteCode[] { new ByteCode() };
for (int i = 0; i < parameters.size(); i++) {
final ParameterDefinition parameter = parameters.get(i);
final TypeReference parameterType = parameter.getParameterType();
final int slot = parameter.getSlot();
switch (parameterType.getSimpleType()) {
case Boolean:
case Byte:
case Character:
case Short:
case Integer:
unknownVariables[slot] = new VariableSlot(FrameValue.INTEGER, definitions);
break;
case Long:
unknownVariables[slot] = new VariableSlot(FrameValue.LONG, definitions);
unknownVariables[slot + 1] = new VariableSlot(FrameValue.TOP, definitions);
break;
case Float:
unknownVariables[slot] = new VariableSlot(FrameValue.FLOAT, definitions);
break;
case Double:
unknownVariables[slot] = new VariableSlot(FrameValue.DOUBLE, definitions);
unknownVariables[slot + 1] = new VariableSlot(FrameValue.TOP, definitions);
break;
default:
unknownVariables[slot] = new VariableSlot(FrameValue.makeReference(parameterType), definitions);
break;
}
}
for (final ExceptionHandler handler : exceptionHandlers) {
final ByteCode handlerStart = byteCodeMap.get(handler.getHandlerBlock().getFirstInstruction());
handlerStarts.add(handlerStart);
handlerStart.stackBefore = EMPTY_STACK;
handlerStart.variablesBefore = VariableSlot.cloneVariableState(unknownVariables);
final ByteCode loadException = new ByteCode();
final TypeReference catchType;
if (handler.isFinally()) {
catchType = _factory.makeNamedType("java.lang.Throwable");
}
else {
catchType = handler.getCatchType();
}
loadException.code = AstCode.LoadException;
loadException.operand = catchType;
loadException.popCount = 0;
loadException.pushCount = 1;
_loadExceptions.put(handler, loadException);
handlerStart.stackBefore = new StackSlot[] {
new StackSlot(
FrameValue.makeReference(catchType),
new ByteCode[] { loadException }
)
};
handlerAgenda.addLast(handlerStart);
}
body.get(0).stackBefore = EMPTY_STACK;
body.get(0).variablesBefore = unknownVariables;
agenda.addFirst(body.get(0));
//
// Process agenda.
//
while (!(agenda.isEmpty() && handlerAgenda.isEmpty())) {
final ByteCode byteCode = agenda.isEmpty() ? handlerAgenda.removeFirst() : agenda.removeFirst();
//
// Calculate new stack.
//
stackMapper.visitFrame(byteCode.getFrameBefore());
instructionVisitor.visit(byteCode.instruction);
final StackSlot[] newStack = createModifiedStack(byteCode, stackMapper);
//
// Calculate new variable state.
//
final VariableSlot[] newVariableState = VariableSlot.cloneVariableState(byteCode.variablesBefore);
final Map initializations = stackMapper.getInitializations();
for (int i = 0; i < newVariableState.length; i++) {
final VariableSlot slot = newVariableState[i];
if (slot.isUninitialized()) {
final Object parameter = slot.value.getParameter();
if (parameter instanceof Instruction) {
final Instruction instruction = (Instruction) parameter;
final TypeReference initializedType = initializations.get(instruction);
if (initializedType != null) {
newVariableState[i] = new VariableSlot(
FrameValue.makeReference(initializedType),
slot.definitions
);
}
}
}
}
if (byteCode.isVariableDefinition()) {
final int slot = ((VariableReference) byteCode.operand).getSlot();
newVariableState[slot] = new VariableSlot(
stackMapper.getLocalValue(slot),
new ByteCode[] { byteCode }
);
if (newVariableState[slot].value.getType().isDoubleWord()) {
newVariableState[slot + 1] = new VariableSlot(
stackMapper.getLocalValue(slot + 1),
new ByteCode[] { byteCode }
);
}
}
//
// Find all successors.
//
final ArrayList branchTargets = new ArrayList<>();
final ControlFlowNode node = nodeMap.get(byteCode.instruction);
successors.clear();
//
// Add normal control first.
//
if (byteCode.instruction != node.getEnd()) {
branchTargets.add(byteCode.next);
}
else {
if (!byteCode.instruction.getOpCode().isUnconditionalBranch()) {
branchTargets.add(byteCode.next);
}
for (final ControlFlowNode successor : node.getSuccessors()) {
if (successor.getNodeType() == ControlFlowNodeType.Normal) {
successors.add(successor);
}
else if (successor.getNodeType() == ControlFlowNodeType.EndFinally) {
for (final ControlFlowNode s : successor.getSuccessors()) {
successors.add(s);
}
}
}
}
//
// Then add the exceptional control flow.
//
for (final ControlFlowNode successor : node.getSuccessors()) {
if (successor.getExceptionHandler() != null) {
successors.add(
nodeMap.get(
successor.getExceptionHandler().getHandlerBlock().getFirstInstruction()
)
);
}
}
for (final ControlFlowNode successor : successors) {
if (successor.getNodeType() != ControlFlowNodeType.Normal) {
continue;
}
final Instruction targetInstruction = successor.getStart();
final ByteCode target = byteCodeMap.get(targetInstruction);
if (target.label == null) {
target.label = new Label();
target.label.setOffset(target.offset);
target.label.setName(target.makeLabelName());
}
branchTargets.add(target);
}
//
// Apply the state to successors.
//
for (final ByteCode branchTarget : branchTargets) {
final boolean isSubroutineJump = byteCode.code == AstCode.Jsr &&
byteCode.instruction.getOperand(0) == branchTarget.instruction;
final StackSlot[] effectiveStack;
if (isSubroutineJump) {
effectiveStack = ArrayUtilities.append(
newStack,
new StackSlot(
FrameValue.makeAddress(byteCode.next.instruction),
new ByteCode[] { byteCode }
)
);
}
else {
effectiveStack = newStack;
}
if (branchTarget.stackBefore == null && branchTarget.variablesBefore == null) {
// if (branchTargets.size() == 1) {
// branchTarget.stackBefore = effectiveStack;
// branchTarget.variablesBefore = newVariableState;
// }
// else {
//
// Do not share data for several bytecodes.
//
branchTarget.stackBefore = StackSlot.modifyStack(effectiveStack, 0, null);
branchTarget.variablesBefore = VariableSlot.cloneVariableState(newVariableState);
// }
agenda.push(branchTarget);
}
else {
final boolean isHandlerStart = handlerStarts.contains(branchTarget);
if (branchTarget.stackBefore.length != effectiveStack.length && !isHandlerStart && !isSubroutineJump) {
throw new IllegalStateException(
"Inconsistent stack size at " + branchTarget.name()
+ " (coming from " + byteCode.name() + ")."
);
}
//
// Be careful not to change our new data; it might be reused for several branch targets.
// In general, be careful that two bytecodes never share data structures.
//
boolean modified = false;
final int stackSize = newStack.length;
final Frame outputFrame = createFrame(effectiveStack, newVariableState);
@SuppressWarnings("UnnecessaryLocalVariable")
final Frame inputFrame = outputFrame; //createFrame(byteCode.stackBefore, byteCode.variablesBefore);
final Frame nextFrame = createFrame(
branchTarget.stackBefore.length > stackSize ? Arrays.copyOfRange(branchTarget.stackBefore, 0, stackSize)
: branchTarget.stackBefore,
branchTarget.variablesBefore
);
final Frame mergedFrame = Frame.merge(inputFrame, outputFrame, nextFrame, initializations);
final List stack = mergedFrame.getStackValues();
final List locals = mergedFrame.getLocalValues();
if (!isHandlerStart) {
final StackSlot[] oldStack = branchTarget.stackBefore;
final int oldStart = oldStack != null && oldStack.length > stackSize ? oldStack.length - 1
: stackSize - 1;
//
// Merge stacks; modify the target.
//
for (int i = stack.size() - 1, j = oldStart;
i >= 0 && j >= 0;
i--, j--) {
final FrameValue oldValue = oldStack[j].value;
final FrameValue newValue = stack.get(i);
final ByteCode[] oldDefinitions = oldStack[j].definitions;
final ByteCode[] newDefinitions = ArrayUtilities.union(oldDefinitions, effectiveStack[i].definitions);
if (!Comparer.equals(newValue, oldValue) || newDefinitions.length > oldDefinitions.length) {
oldStack[j] = new StackSlot(newValue, newDefinitions);
modified = true;
}
}
}
//
// Merge variables; modify the target;
//
for (int i = 0, n = locals.size(); i < n; i++) {
final VariableSlot oldSlot = branchTarget.variablesBefore[i];
final VariableSlot newSlot = newVariableState[i];
final FrameValue oldLocal = oldSlot.value;
final FrameValue newLocal = locals.get(i);
final ByteCode[] oldDefinitions = oldSlot.definitions;
final ByteCode[] newDefinitions = ArrayUtilities.union(oldSlot.definitions, newSlot.definitions);
if (!Comparer.equals(oldLocal, newLocal) || newDefinitions.length > oldDefinitions.length) {
branchTarget.variablesBefore[i] = new VariableSlot(newLocal, newDefinitions);
modified = true;
}
}
if (modified) {
agenda.addLast(branchTarget);
}
}
}
}
//
// Occasionally, compilers or obfuscators may generate unreachable code (which might be intentionally invalid).
// It should be safe to simply remove it.
//
ArrayList unreachable = null;
for (final ByteCode byteCode : body) {
if (byteCode.stackBefore == null) {
if (unreachable == null) {
unreachable = new ArrayList<>();
}
unreachable.add(byteCode);
}
}
if (unreachable != null) {
body.removeAll(unreachable);
}
//
// Generate temporary variables to replace stack values.
//
for (final ByteCode byteCode : body) {
final int popCount = byteCode.popCount != -1 ? byteCode.popCount : byteCode.stackBefore.length;
int argumentIndex = 0;
for (int i = byteCode.stackBefore.length - popCount; i < byteCode.stackBefore.length; i++) {
final Variable tempVariable = new Variable();
tempVariable.setName(format("stack_%1$02X_%2$d", byteCode.offset, argumentIndex));
tempVariable.setGenerated(true);
final FrameValue value = byteCode.stackBefore[i].value;
switch (value.getType()) {
case Integer:
tempVariable.setType(BuiltinTypes.Integer);
break;
case Float:
tempVariable.setType(BuiltinTypes.Float);
break;
case Long:
tempVariable.setType(BuiltinTypes.Long);
break;
case Double:
tempVariable.setType(BuiltinTypes.Double);
break;
case UninitializedThis:
tempVariable.setType(_context.getCurrentType());
break;
case Reference:
TypeReference refType = (TypeReference) value.getParameter();
if (refType.isWildcardType()) {
refType = refType.hasSuperBound() ? refType.getSuperBound() : refType.getExtendsBound();
}
tempVariable.setType(refType);
break;
}
byteCode.stackBefore[i] = new StackSlot(value, byteCode.stackBefore[i].definitions, tempVariable);
for (final ByteCode pushedBy : byteCode.stackBefore[i].definitions) {
if (pushedBy.storeTo == null) {
pushedBy.storeTo = new ArrayList<>();
}
pushedBy.storeTo.add(tempVariable);
}
argumentIndex++;
}
}
//
// Try to use a single temporary variable instead of several, if possible (especially useful for DUP).
// This has to be done after all temporary variables are assigned so we know about all loads.
//
for (final ByteCode byteCode : body) {
if (byteCode.storeTo != null && byteCode.storeTo.size() > 1) {
final List localVariables = byteCode.storeTo;
//
// For each of the variables, find the location where it is loaded; there should be exactly one.
//
List loadedBy = null;
for (final Variable local : localVariables) {
inner:
for (final ByteCode bc : body) {
for (final StackSlot s : bc.stackBefore) {
if (s.loadFrom == local) {
if (loadedBy == null) {
loadedBy = new ArrayList<>();
}
loadedBy.add(s);
break inner;
}
}
}
}
if (loadedBy == null) {
continue;
}
//
// We know that all the temp variables have a single load; now make sure they have a single store.
//
boolean singleStore = true;
TypeReference type = null;
for (final StackSlot slot : loadedBy) {
if (slot.definitions.length != 1) {
singleStore = false;
break;
}
else if (slot.definitions[0] != byteCode) {
singleStore = false;
break;
}
else if (type == null) {
switch (slot.value.getType()) {
case Integer:
type = BuiltinTypes.Integer;
break;
case Float:
type = BuiltinTypes.Float;
break;
case Long:
type = BuiltinTypes.Long;
break;
case Double:
type = BuiltinTypes.Double;
break;
case Reference:
type = (TypeReference) slot.value.getParameter();
if (type.isWildcardType()) {
type = type.hasSuperBound() ? type.getSuperBound() : type.getExtendsBound();
}
break;
}
}
}
if (!singleStore) {
continue;
}
//
// We can now reduce everything into a single variable.
//
final Variable tempVariable = new Variable();
tempVariable.setName(format("expr_%1$02X", byteCode.offset));
tempVariable.setGenerated(true);
tempVariable.setType(type);
byteCode.storeTo = Collections.singletonList(tempVariable);
for (final ByteCode bc : body) {
for (int i = 0; i < bc.stackBefore.length; i++) {
//
// Is it one of the variables we merged?
//
if (localVariables.contains(bc.stackBefore[i].loadFrom)) {
//
// Replace with the new temp variable.
//
bc.stackBefore[i] = new StackSlot(bc.stackBefore[i].value, bc.stackBefore[i].definitions, tempVariable);
}
}
}
}
}
//
// Split and convert the normal local variables.
//
convertLocalVariables(definitions, body);
//
// Convert branch targets to labels.
//
for (final ByteCode byteCode : body) {
if (byteCode.operand instanceof Instruction[]) {
final Instruction[] branchTargets = (Instruction[]) byteCode.operand;
final Label[] newOperand = new Label[branchTargets.length];
for (int i = 0; i < branchTargets.length; i++) {
newOperand[i] = byteCodeMap.get(branchTargets[i]).label;
}
byteCode.operand = newOperand;
}
else if (byteCode.operand instanceof Instruction) {
//noinspection SuspiciousMethodCalls
byteCode.operand = byteCodeMap.get(byteCode.operand).label;
}
else if (byteCode.operand instanceof SwitchInfo) {
final SwitchInfo switchInfo = (SwitchInfo) byteCode.operand;
final Instruction[] branchTargets = ArrayUtilities.prepend(switchInfo.getTargets(), switchInfo.getDefaultTarget());
final Label[] newOperand = new Label[branchTargets.length];
for (int i = 0; i < branchTargets.length; i++) {
newOperand[i] = byteCodeMap.get(branchTargets[i]).label;
}
byteCode.operand = newOperand;
}
}
return body;
}
private static Instruction mappedInstruction(final Map map, final Instruction instruction) {
Instruction current = instruction;
Instruction newInstruction;
while ((newInstruction = map.get(current)) != null) {
if (newInstruction == current) {
return current;
}
current = newInstruction;
}
return current;
}
private static StackSlot[] createModifiedStack(final ByteCode byteCode, final StackMappingVisitor stackMapper) {
final Map initializations = stackMapper.getInitializations();
final StackSlot[] oldStack = byteCode.stackBefore.clone();
for (int i = 0; i < oldStack.length; i++) {
if (oldStack[i].value.getParameter() instanceof Instruction) {
final TypeReference initializedType = initializations.get(oldStack[i].value.getParameter());
if (initializedType != null) {
oldStack[i] = new StackSlot(
FrameValue.makeReference(initializedType),
oldStack[i].definitions,
oldStack[i].loadFrom
);
}
}
}
if (byteCode.popCount == 0 && byteCode.pushCount == 0) {
return oldStack;
}
switch (byteCode.code) {
case Dup:
return ArrayUtilities.append(
oldStack,
new StackSlot(stackMapper.getStackValue(0), oldStack[oldStack.length - 1].definitions)
);
case DupX1:
return ArrayUtilities.insert(
oldStack,
oldStack.length - 2,
new StackSlot(stackMapper.getStackValue(0), oldStack[oldStack.length - 1].definitions)
);
case DupX2:
return ArrayUtilities.insert(
oldStack,
oldStack.length - 3,
new StackSlot(stackMapper.getStackValue(0), oldStack[oldStack.length - 1].definitions)
);
case Dup2:
return ArrayUtilities.append(
oldStack,
new StackSlot(stackMapper.getStackValue(1), oldStack[oldStack.length - 2].definitions),
new StackSlot(stackMapper.getStackValue(0), oldStack[oldStack.length - 1].definitions)
);
case Dup2X1:
return ArrayUtilities.insert(
oldStack,
oldStack.length - 3,
new StackSlot(stackMapper.getStackValue(1), oldStack[oldStack.length - 2].definitions),
new StackSlot(stackMapper.getStackValue(0), oldStack[oldStack.length - 1].definitions)
);
case Dup2X2:
return ArrayUtilities.insert(
oldStack,
oldStack.length - 4,
new StackSlot(stackMapper.getStackValue(1), oldStack[oldStack.length - 2].definitions),
new StackSlot(stackMapper.getStackValue(0), oldStack[oldStack.length - 1].definitions)
);
case Swap:
final StackSlot[] newStack = new StackSlot[oldStack.length];
ArrayUtilities.copy(oldStack, newStack);
final StackSlot temp = newStack[oldStack.length - 1];
newStack[oldStack.length - 1] = newStack[oldStack.length - 2];
newStack[oldStack.length - 2] = temp;
return newStack;
default:
final FrameValue[] pushValues = new FrameValue[byteCode.pushCount];
for (int i = 0; i < byteCode.pushCount; i++) {
pushValues[pushValues.length - i - 1] = stackMapper.getStackValue(i);
}
return StackSlot.modifyStack(
oldStack,
byteCode.popCount != -1 ? byteCode.popCount : oldStack.length,
byteCode,
pushValues
);
}
}
private final static class VariableInfo {
final int slot;
final Variable variable;
final List definitions;
final List references;
Range lifetime;
VariableInfo(final int slot, final Variable variable, final List definitions, final List references) {
this.slot = slot;
this.variable = variable;
this.definitions = definitions;
this.references = references;
}
void recomputeLifetime() {
int start = Integer.MAX_VALUE;
int end = Integer.MIN_VALUE;
for (final ByteCode d : definitions) {
start = Math.min(d.offset, start);
end = Math.max(d.offset, end);
}
for (final ByteCode r : references) {
start = Math.min(r.offset, start);
end = Math.max(r.offset, end);
}
lifetime = new Range(start, end);
}
}
@SuppressWarnings("ConstantConditions")
private void convertLocalVariables(final ByteCode[] parameterDefinitions, final List body) {
final MethodDefinition method = _context.getCurrentMethod();
final List parameters = method.getParameters();
final VariableDefinitionCollection variables = _body.getVariables();
final ParameterDefinition[] parameterMap = new ParameterDefinition[_body.getMaxLocals()];
final boolean hasThis = _body.hasThis();
if (hasThis) {
parameterMap[0] = _body.getThisParameter();
}
for (final ParameterDefinition parameter : parameters) {
parameterMap[parameter.getSlot()] = parameter;
}
final Set> undefinedSlots = new HashSet<>();
final List varReferences = new ArrayList<>();
final Map lookup = makeVariableLookup(variables);
for (final VariableDefinition variableDefinition : variables) {
varReferences.add(variableDefinition);
}
for (final ByteCode b : body) {
if (b.operand instanceof VariableReference && !(b.operand instanceof VariableDefinition)) {
final VariableReference reference = (VariableReference) b.operand;
if (undefinedSlots.add(Pair.create(reference.getSlot(), getStackType(reference.getVariableType())))) {
varReferences.add(reference);
}
}
}
for (final VariableReference vRef : varReferences) {
//
// Find all definitions of and references to this variable.
//
final int slot = vRef.getSlot();
final List definitions = new ArrayList<>();
final List references = new ArrayList<>();
final VariableDefinition vDef = vRef instanceof VariableDefinition ? lookup.get(key((VariableDefinition) vRef))
: null;
for (final ByteCode b : body) {
if (vDef != null) {
if (b.operand instanceof VariableDefinition &&
lookup.get(key((VariableDefinition) b.operand)) == vDef) {
if (b.isVariableDefinition()) {
definitions.add(b);
}
else {
references.add(b);
}
}
}
else if (b.operand instanceof VariableReference &&
variablesMatch(vRef, (VariableReference) b.operand)) {
if (b.isVariableDefinition()) {
definitions.add(b);
}
else {
references.add(b);
}
}
}
final List newVariables;
// boolean fromUnknownDefinition = false;
//
// if (_optimize) {
// for (final ByteCode b : references) {
// if (b.variablesBefore[slot].isUninitialized()) {
// fromUnknownDefinition = true;
// break;
// }
// }
// }
final ParameterDefinition parameter = parameterMap[slot];
/*if (parameter != null) {
final Variable variable = new Variable();
variable.setName(
StringUtilities.isNullOrEmpty(parameter.getName()) ? "p" + parameter.getPosition()
: parameter.getName()
);
variable.setType(parameter.getParameterType());
variable.setOriginalParameter(parameter);
final VariableInfo variableInfo = new VariableInfo(variable, parameterDefinitions, references);
newVariables = Collections.singletonList(variableInfo);
}
else*/
if (!_optimize/* || fromUnknownDefinition*/) {
final Variable variable = new Variable();
if (vDef != null) {
variable.setType(vDef.getVariableType());
variable.setName(
StringUtilities.isNullOrEmpty(vDef.getName()) ? "var_" + slot
: vDef.getName()
);
}
else {
variable.setName("var_" + slot);
for (final ByteCode b : definitions) {
final FrameValue stackValue = b.stackBefore[b.stackBefore.length - b.popCount].value;
if (stackValue != FrameValue.UNINITIALIZED &&
stackValue != FrameValue.UNINITIALIZED_THIS) {
final TypeReference variableType;
switch (stackValue.getType()) {
case Integer:
variableType = BuiltinTypes.Integer;
break;
case Float:
variableType = BuiltinTypes.Float;
break;
case Long:
variableType = BuiltinTypes.Long;
break;
case Double:
variableType = BuiltinTypes.Double;
break;
case Uninitialized:
if (stackValue.getParameter() instanceof Instruction &&
((Instruction) stackValue.getParameter()).getOpCode() == OpCode.NEW) {
variableType = ((Instruction) stackValue.getParameter()).getOperand(0);
}
else if (vDef != null) {
variableType = vDef.getVariableType();
}
else {
variableType = BuiltinTypes.Object;
}
break;
case UninitializedThis:
variableType = _context.getCurrentType();
break;
case Reference:
variableType = (TypeReference) stackValue.getParameter();
break;
case Address:
variableType = BuiltinTypes.Integer;
break;
case Null:
variableType = BuiltinTypes.Null;
break;
default:
if (vDef != null) {
variableType = vDef.getVariableType();
}
else {
variableType = BuiltinTypes.Object;
}
break;
}
variable.setType(variableType);
break;
}
}
if (variable.getType() == null) {
variable.setType(BuiltinTypes.Object);
}
}
if (vDef == null) {
variable.setOriginalVariable(new VariableDefinition(slot, variable.getName(), method, variable.getType()));
}
else {
variable.setOriginalVariable(vDef);
}
variable.setGenerated(false);
final VariableInfo variableInfo = new VariableInfo(slot, variable, definitions, references);
newVariables = Collections.singletonList(variableInfo);
}
else {
newVariables = new ArrayList<>();
boolean parameterVariableAdded = false;
VariableInfo parameterVariable = null;
if (parameter != null) {
final Variable variable = new Variable();
variable.setName(
StringUtilities.isNullOrEmpty(parameter.getName()) ? "p" + parameter.getPosition()
: parameter.getName()
);
variable.setType(parameter.getParameterType());
variable.setOriginalParameter(parameter);
variable.setOriginalVariable(vDef);
parameterVariable = new VariableInfo(
slot,
variable,
new ArrayList(),
new ArrayList()
);
Collections.addAll(parameterVariable.definitions, parameterDefinitions);
}
for (final ByteCode b : definitions) {
TypeReference variableType;
final FrameValue stackValue;
if (b.code == AstCode.Inc) {
stackValue = FrameValue.INTEGER;
}
else {
stackValue = b.stackBefore[b.stackBefore.length - b.popCount].value;
}
if (vDef != null && vDef.isFromMetadata()) {
variableType = vDef.getVariableType();
}
else {
switch (stackValue.getType()) {
case Integer:
variableType = BuiltinTypes.Integer;
break;
case Float:
variableType = BuiltinTypes.Float;
break;
case Long:
variableType = BuiltinTypes.Long;
break;
case Double:
variableType = BuiltinTypes.Double;
break;
case UninitializedThis:
variableType = _context.getCurrentType();
break;
case Reference:
variableType = (TypeReference) stackValue.getParameter();
break;
case Address:
variableType = BuiltinTypes.Integer;
break;
case Null:
variableType = BuiltinTypes.Null;
break;
default:
if (vDef != null) {
variableType = vDef.getVariableType();
}
else {
variableType = BuiltinTypes.Object;
}
break;
}
}
if (parameterVariable != null) {
final boolean useParameter;
if (variableType.isPrimitive() || parameterVariable.variable.getType().isPrimitive()) {
useParameter = variableType.getSimpleType() == parameterVariable.variable.getType().getSimpleType();
}
else {
useParameter = MetadataHelper.isSameType(variableType, parameterVariable.variable.getType());
}
if (useParameter) {
if (!parameterVariableAdded) {
newVariables.add(parameterVariable);
parameterVariableAdded = true;
}
parameterVariable.definitions.add(b);
continue;
}
}
final Variable variable = new Variable();
if (vDef != null && !StringUtilities.isNullOrEmpty(vDef.getName())) {
variable.setName(vDef.getName());
}
else {
variable.setName(format("var_%1$d_%2$02X", slot, b.offset));
}
variable.setType(variableType);
if (vDef == null) {
variable.setOriginalVariable(new VariableDefinition(slot, variable.getName(), method, variable.getType()));
}
else {
variable.setOriginalVariable(vDef);
}
variable.setGenerated(false);
final VariableInfo variableInfo = new VariableInfo(
slot,
variable,
new ArrayList(),
new ArrayList()
);
variableInfo.definitions.add(b);
newVariables.add(variableInfo);
}
//
// Add loads to the data structure; merge variables if necessary.
//
for (final ByteCode ref : references) {
final ByteCode[] refDefinitions = ref.variablesBefore[slot].definitions;
if (refDefinitions.length == 0 && parameterVariable != null) {
parameterVariable.references.add(ref);
if (!parameterVariableAdded) {
newVariables.add(parameterVariable);
parameterVariableAdded = true;
}
}
else if (refDefinitions.length == 1) {
VariableInfo newVariable = null;
for (final VariableInfo v : newVariables) {
if (v.definitions.contains(refDefinitions[0])) {
newVariable = v;
break;
}
}
if (newVariable == null && parameterVariable != null) {
newVariable = parameterVariable;
if (!parameterVariableAdded) {
newVariables.add(parameterVariable);
parameterVariableAdded = true;
}
}
assert newVariable != null;
newVariable.references.add(ref);
}
else {
final ArrayList mergeVariables = new ArrayList<>();
for (final VariableInfo v : newVariables) {
boolean hasIntersection = false;
outer:
for (final ByteCode b1 : v.definitions) {
for (final ByteCode b2 : refDefinitions) {
if (b1 == b2) {
hasIntersection = true;
break outer;
}
}
}
if (hasIntersection) {
mergeVariables.add(v);
}
}
// if (!mergeVariables.isEmpty()) {
// for (final VariableInfo v : newVariables) {
// if (!mergeVariables.contains(v) &&
// MetadataHelper.isSameType(mergeVariables.get(0).variable.getType(), v.variable.getType())) {
//
// mergeVariables.add(v);
// }
// }
// }
final ArrayList mergedDefinitions = new ArrayList<>();
final ArrayList mergedReferences = new ArrayList<>();
if (parameterVariable != null &&
(mergeVariables.isEmpty() ||
(!mergeVariables.contains(parameterVariable) &&
ArrayUtilities.contains(refDefinitions, parameterDefinitions[0])))) {
mergeVariables.add(parameterVariable);
parameterVariableAdded = true;
}
for (final VariableInfo v : mergeVariables) {
mergedDefinitions.addAll(v.definitions);
mergedReferences.addAll(v.references);
}
final VariableInfo mergedVariable = new VariableInfo(
slot,
mergeVariables.get(0).variable,
mergedDefinitions,
mergedReferences
);
if (parameterVariable != null && mergeVariables.contains(parameterVariable)) {
parameterVariable = mergedVariable;
parameterVariable.variable.setOriginalParameter(parameter);
parameterVariableAdded = true;
}
mergedVariable.variable.setType(mergeVariableType(mergeVariables));
mergedVariable.references.add(ref);
newVariables.removeAll(mergeVariables);
newVariables.add(mergedVariable);
}
}
}
if (_context.getSettings().getMergeVariables()) {
//
// Experiment: attempt to reduce the number of disjoint variables in the absence of debug info by
// merging primitive variables with adjacent lifespans and matching types.
//
for (final VariableInfo variable : newVariables) {
variable.recomputeLifetime();
}
Collections.sort(
newVariables,
new Comparator() {
@Override
public int compare(@NotNull final VariableInfo o1, @NotNull final VariableInfo o2) {
return o1.lifetime.compareTo(o2.lifetime);
}
}
);
outer:
for (int j = 0; j < newVariables.size() - 1; j++) {
final VariableInfo prev = newVariables.get(j);
if (!prev.variable.getType().isPrimitive() ||
prev.variable.getOriginalVariable() != null && prev.variable.getOriginalVariable().isFromMetadata()) {
continue;
}
for (int k = j + 1; k < newVariables.size(); k++) {
final VariableInfo next = newVariables.get(k);
if (next.variable.getOriginalVariable().isFromMetadata() ||
!MetadataHelper.isSameType(prev.variable.getType(), next.variable.getType()) ||
mightBeBoolean(prev) != mightBeBoolean(next)) {
continue outer;
}
prev.definitions.addAll(next.definitions);
prev.references.addAll(next.references);
newVariables.remove(k--);
prev.lifetime.setStart(Math.min(prev.lifetime.getStart(), next.lifetime.getStart()));
prev.lifetime.setEnd(Math.max(prev.lifetime.getEnd(), next.lifetime.getEnd()));
}
}
}
//
// Set bytecode operands.
//
for (final VariableInfo newVariable : newVariables) {
if (newVariable.variable.getType() == BuiltinTypes.Null) {
newVariable.variable.setType(BuiltinTypes.Null);
}
for (final ByteCode definition : newVariable.definitions) {
definition.operand = newVariable.variable;
}
for (final ByteCode reference : newVariable.references) {
reference.operand = newVariable.variable;
}
}
}
}
private boolean mightBeBoolean(final VariableInfo info) {
//
// Perform (limited) analysis to determine if a variable might be a boolean, in which
// case we may not merge it with another variable which is suspected to not be a boolean.
//
final TypeReference type = info.variable.getType();
if (type == BuiltinTypes.Boolean) {
return true;
}
if (type != BuiltinTypes.Integer) {
return false;
}
for (final ByteCode b : info.definitions) {
if (b.code != AstCode.Store || b.stackBefore.length < 1) {
return false;
}
final StackSlot value = b.stackBefore[b.stackBefore.length - 1];
for (final ByteCode d : value.definitions) {
switch (d.code) {
case LdC: {
if (!Objects.equals(d.operand, 0) && !Objects.equals(d.operand, 1)) {
return false;
}
break;
}
case GetField:
case GetStatic: {
if (((FieldReference) d.operand).getFieldType() != BuiltinTypes.Boolean) {
return false;
}
break;
}
case LoadElement: {
if (d.instruction.getOpCode() != OpCode.BALOAD) {
return false;
}
break;
}
case InvokeVirtual:
case InvokeSpecial:
case InvokeStatic:
case InvokeInterface: {
if (((MethodReference) d.operand).getReturnType() != BuiltinTypes.Boolean) {
return false;
}
break;
}
default: {
return false;
}
}
}
}
for (final ByteCode r : info.references) {
if (r.code == AstCode.Inc) {
return false;
}
}
return true;
}
private TypeReference mergeVariableType(final List info) {
TypeReference result = first(info).variable.getType();
for (int i = 0; i < info.size(); i++) {
final VariableInfo variableInfo = info.get(i);
final TypeReference t = variableInfo.variable.getType();
if (result == BuiltinTypes.Null) {
result = t;
}
else if (t == BuiltinTypes.Null) {
//noinspection UnnecessaryContinue
continue;
}
else {
result = MetadataHelper.findCommonSuperType(result, t);
}
}
return result != null ? result : BuiltinTypes.Object;
}
private JvmType getStackType(final TypeReference type) {
final JvmType t = type.getSimpleType();
switch (t) {
case Boolean:
case Byte:
case Character:
case Short:
case Integer:
return JvmType.Integer;
case Long:
case Float:
case Double:
return t;
default:
return JvmType.Object;
}
}
private boolean variablesMatch(final VariableReference v1, final VariableReference v2) {
if (v1.getSlot() == v2.getSlot()) {
final JvmType t1 = getStackType(v1.getVariableType());
final JvmType t2 = getStackType(v2.getVariableType());
return t1 == t2;
}
return false;
}
private static Map makeVariableLookup(final VariableDefinitionCollection variables) {
final Map lookup = new HashMap<>();
for (final VariableDefinition variable : variables) {
final String key = key(variable);
if (lookup.containsKey(key)) {
continue;
}
lookup.put(key, variable);
}
return lookup;
}
private static String key(final VariableDefinition variable) {
final StringBuilder sb = new StringBuilder().append(variable.getSlot()).append(':');
if (variable.hasName()) {
sb.append(variable.getName());
}
else {
sb.append("#unnamed_")
.append(variable.getScopeStart())
.append('_')
.append(variable.getScopeEnd());
}
return sb.append(':')
.append(variable.getVariableType().getSignature())
.toString();
}
@SuppressWarnings("ConstantConditions")
private List convertToAst(
final List body,
final Set exceptionHandlers,
final int startIndex,
final MutableInteger endIndex) {
final ArrayList ast = new ArrayList<>();
int headStartIndex = startIndex;
int tailStartIndex = startIndex;
final MutableInteger tempIndex = new MutableInteger();
while (!exceptionHandlers.isEmpty()) {
final TryCatchBlock tryCatchBlock = new TryCatchBlock();
final int minTryStart = body.get(headStartIndex).offset;
//
// Find the first and widest scope;
//
int tryStart = Integer.MAX_VALUE;
int tryEnd = -1;
int firstHandlerStart = -1;
headStartIndex = tailStartIndex;
for (final ExceptionHandler handler : exceptionHandlers) {
final int start = handler.getTryBlock().getFirstInstruction().getOffset();
if (start < tryStart && start >= minTryStart) {
tryStart = start;
}
}
for (final ExceptionHandler handler : exceptionHandlers) {
final int start = handler.getTryBlock().getFirstInstruction().getOffset();
if (start == tryStart) {
final Instruction lastInstruction = handler.getTryBlock().getLastInstruction();
final int end = lastInstruction.getEndOffset();
if (end > tryEnd) {
tryEnd = end;
final int handlerStart = handler.getHandlerBlock().getFirstInstruction().getOffset();
if (firstHandlerStart < 0 || handlerStart < firstHandlerStart) {
firstHandlerStart = handlerStart;
}
}
}
}
final ArrayList handlers = new ArrayList<>();
for (final ExceptionHandler handler : exceptionHandlers) {
final int start = handler.getTryBlock().getFirstInstruction().getOffset();
final int end = handler.getTryBlock().getLastInstruction().getEndOffset();
if (start == tryStart && end == tryEnd) {
handlers.add(handler);
}
}
Collections.sort(
handlers,
new Comparator() {
@Override
public int compare(@NotNull final ExceptionHandler o1, @NotNull final ExceptionHandler o2) {
return Integer.compare(
o1.getTryBlock().getFirstInstruction().getOffset(),
o2.getTryBlock().getFirstInstruction().getOffset()
);
}
}
);
//
// Remember that any part of the body might have been removed due to unreachability.
//
//
// Cut all instructions up to the try block.
//
int tryStartIndex = 0;
while (tryStartIndex < body.size() &&
body.get(tryStartIndex).offset < tryStart) {
tryStartIndex++;
}
if (headStartIndex < tryStartIndex) {
ast.addAll(convertToAst(body.subList(headStartIndex, tryStartIndex)));
}
//
// Cut the try block.
//
{
final Set nestedHandlers = new LinkedHashSet<>();
for (final ExceptionHandler eh : exceptionHandlers) {
final int ts = eh.getTryBlock().getFirstInstruction().getOffset();
final int te = eh.getTryBlock().getLastInstruction().getEndOffset();
if (tryStart < ts && te <= tryEnd || tryStart <= ts && te < tryEnd) {
nestedHandlers.add(eh);
}
}
exceptionHandlers.removeAll(nestedHandlers);
int tryEndIndex = 0;
while (tryEndIndex < body.size() && body.get(tryEndIndex).offset < tryEnd) {
tryEndIndex++;
}
final Block tryBlock = new Block();
/*
for (int i = 0; i < tryEndIndex; i++) {
body.remove(0);
}
*/
tempIndex.setValue(tryEndIndex);
final List tryAst = convertToAst(body, nestedHandlers, tryStartIndex, tempIndex);
if (tempIndex.getValue() > tailStartIndex) {
tailStartIndex = tempIndex.getValue();
}
final Node lastInTry = lastOrDefault(tryAst, NOT_A_LABEL_OR_NOP);
if (lastInTry == null || !lastInTry.isUnconditionalControlFlow()) {
tryAst.add(new Expression(AstCode.Leave, null, Expression.MYSTERY_OFFSET));
}
tryBlock.getBody().addAll(tryAst);
tryCatchBlock.setTryBlock(tryBlock);
tailStartIndex = Math.max(tryEndIndex, tailStartIndex);
}
//
// Cut from the end of the try to the beginning of the first handler.
//
/*
while (!body.isEmpty() && body.get(0).offset < firstHandlerStart) {
body.remove(0);
}
*/
//
// Cut all handlers.
//
HandlerLoop:
for (int i = 0, n = handlers.size(); i < n; i++) {
final ExceptionHandler eh = handlers.get(i);
final TypeReference catchType = eh.getCatchType();
final InstructionBlock handlerBlock = eh.getHandlerBlock();
final int handlerStart = handlerBlock.getFirstInstruction().getOffset();
final int handlerEnd = handlerBlock.getLastInstruction() != null
? handlerBlock.getLastInstruction().getEndOffset()
: _body.getCodeSize();
int handlersStartIndex = tailStartIndex;
while (handlersStartIndex < body.size() &&
body.get(handlersStartIndex).offset < handlerStart) {
handlersStartIndex++;
}
int handlersEndIndex = handlersStartIndex;
while (handlersEndIndex < body.size() &&
body.get(handlersEndIndex).offset < handlerEnd) {
handlersEndIndex++;
}
tailStartIndex = Math.max(tailStartIndex, handlersEndIndex);
if (eh.isCatch()) {
//
// See if we share a block with another handler; if so, add our catch type and move on.
//
for (final CatchBlock catchBlock : tryCatchBlock.getCatchBlocks()) {
final Expression firstExpression = firstOrDefault(
catchBlock.getSelfAndChildrenRecursive(Expression.class),
new Predicate() {
@Override
public boolean test(final Expression e) {
return !e.getRanges().isEmpty();
}
}
);
if (firstExpression == null) {
continue;
}
final int otherHandlerStart = firstExpression.getRanges().get(0).getStart();
if (otherHandlerStart == handlerStart) {
catchBlock.getCaughtTypes().add(catchType);
final TypeReference commonCatchType = MetadataHelper.findCommonSuperType(
catchBlock.getExceptionType(),
catchType
);
catchBlock.setExceptionType(commonCatchType);
if (catchBlock.getExceptionVariable() == null) {
updateExceptionVariable(catchBlock, eh);
}
continue HandlerLoop;
}
}
}
final Set nestedHandlers = new LinkedHashSet<>();
for (final ExceptionHandler e : exceptionHandlers) {
final int ts = e.getTryBlock().getFirstInstruction().getOffset();
final int te = e.getTryBlock().getLastInstruction().getOffset();
if (ts == tryStart && te == tryEnd || e == eh) {
continue;
}
if (handlerStart <= ts && te < handlerEnd) {
nestedHandlers.add(e);
final int nestedEndIndex = firstIndexWhere(
body,
new Predicate() {
@Override
public boolean test(final ByteCode code) {
return code.instruction == e.getHandlerBlock().getLastInstruction();
}
}
);
if (nestedEndIndex > handlersEndIndex) {
handlersEndIndex = nestedEndIndex;
}
}
}
tailStartIndex = Math.max(tailStartIndex, handlersEndIndex);
exceptionHandlers.removeAll(nestedHandlers);
tempIndex.setValue(handlersEndIndex);
final List handlerAst = convertToAst(body, nestedHandlers, handlersStartIndex, tempIndex);
final Node lastInHandler = lastOrDefault(handlerAst, NOT_A_LABEL_OR_NOP);
if (tempIndex.getValue() > tailStartIndex) {
tailStartIndex = tempIndex.getValue();
}
if (lastInHandler == null || !lastInHandler.isUnconditionalControlFlow()) {
handlerAst.add(new Expression(eh.isCatch() ? AstCode.Leave : AstCode.EndFinally, null, Expression.MYSTERY_OFFSET));
}
if (eh.isCatch()) {
final CatchBlock catchBlock = new CatchBlock();
catchBlock.setExceptionType(catchType);
catchBlock.getCaughtTypes().add(catchType);
catchBlock.getBody().addAll(handlerAst);
updateExceptionVariable(catchBlock, eh);
tryCatchBlock.getCatchBlocks().add(catchBlock);
}
else if (eh.isFinally()) {
final ByteCode loadException = _loadExceptions.get(eh);
final Block finallyBlock = new Block();
finallyBlock.getBody().addAll(handlerAst);
tryCatchBlock.setFinallyBlock(finallyBlock);
final Variable exceptionTemp = new Variable();
exceptionTemp.setName(format("ex_%1$02X", handlerStart));
exceptionTemp.setGenerated(true);
if (loadException == null || loadException.storeTo == null) {
final Expression finallyStart = firstOrDefault(finallyBlock.getSelfAndChildrenRecursive(Expression.class));
if (match(finallyStart, AstCode.Store)) {
finallyStart.getArguments().set(
0,
new Expression(AstCode.Load, exceptionTemp, Expression.MYSTERY_OFFSET)
);
}
}
else {
for (final Variable storeTo : loadException.storeTo) {
finallyBlock.getBody().add(
0,
new Expression(AstCode.Store, storeTo, Expression.MYSTERY_OFFSET, new Expression(AstCode.Load, exceptionTemp, Expression.MYSTERY_OFFSET))
);
}
}
finallyBlock.getBody().add(
0,
new Expression(
AstCode.Store,
exceptionTemp,
Expression.MYSTERY_OFFSET,
new Expression(
AstCode.LoadException,
_factory.makeNamedType("java.lang.Throwable"),
Expression.MYSTERY_OFFSET
)
)
);
}
}
exceptionHandlers.removeAll(handlers);
final Expression first;
final Expression last;
first = firstOrDefault(tryCatchBlock.getTryBlock().getSelfAndChildrenRecursive(Expression.class));
if (!tryCatchBlock.getCatchBlocks().isEmpty()) {
final CatchBlock lastCatch = lastOrDefault(tryCatchBlock.getCatchBlocks());
if (lastCatch == null) {
last = null;
}
else {
last = lastOrDefault(lastCatch.getSelfAndChildrenRecursive(Expression.class));
}
}
else {
final Block finallyBlock = tryCatchBlock.getFinallyBlock();
if (finallyBlock == null) {
last = null;
}
else {
last = lastOrDefault(finallyBlock.getSelfAndChildrenRecursive(Expression.class));
}
}
if (first == null && last == null) {
//
// Ignore empty handlers. These can crop up due to finally blocks which handle themselves.
//
continue;
}
ast.add(tryCatchBlock);
}
if (tailStartIndex < endIndex.getValue()) {
ast.addAll(convertToAst(body.subList(tailStartIndex, endIndex.getValue())));
}
else {
endIndex.setValue(tailStartIndex);
}
return ast;
}
private void updateExceptionVariable(final CatchBlock catchBlock, final ExceptionHandler handler) {
final ByteCode loadException = _loadExceptions.get(handler);
final int handlerStart = handler.getHandlerBlock().getFirstInstruction().getOffset();
if (loadException.storeTo == null || loadException.storeTo.isEmpty()) {
//
// Exception is not used.
//
catchBlock.setExceptionVariable(null);
}
else {
if (loadException.storeTo.size() == 1) {
if (!catchBlock.getBody().isEmpty() &&
catchBlock.getBody().get(0) instanceof Expression &&
!((Expression) catchBlock.getBody().get(0)).getArguments().isEmpty()) {
final Expression first = (Expression) catchBlock.getBody().get(0);
final AstCode firstCode = first.getCode();
final Expression firstArgument = first.getArguments().get(0);
if (firstCode == AstCode.Pop &&
firstArgument.getCode() == AstCode.Load &&
firstArgument.getOperand() == loadException.storeTo.get(0)) {
//
// The exception is just popped; optimize it away.
//
if (_context.getSettings().getAlwaysGenerateExceptionVariableForCatchBlocks()) {
final Variable exceptionVariable = new Variable();
exceptionVariable.setName(format("ex_%1$02X", handlerStart));
exceptionVariable.setGenerated(true);
// exceptionVariable.setType(catchType);
catchBlock.setExceptionVariable(exceptionVariable);
}
else {
catchBlock.setExceptionVariable(null);
}
}
else {
catchBlock.setExceptionVariable(loadException.storeTo.get(0));
// catchBlock.getExceptionVariable().setType(catchType);
}
}
else {
catchBlock.setExceptionVariable(loadException.storeTo.get(0));
// catchBlock.getExceptionVariable().setType(catchType);
}
}
else {
final Variable exceptionTemp = new Variable();
exceptionTemp.setName(format("ex_%1$02X", handlerStart));
exceptionTemp.setGenerated(true);
// exceptionTemp.setType(catchType);
catchBlock.setExceptionVariable(exceptionTemp);
for (final Variable storeTo : loadException.storeTo) {
catchBlock.getBody().add(
0,
new Expression(AstCode.Store, storeTo, Expression.MYSTERY_OFFSET, new Expression(AstCode.Load, exceptionTemp, Expression.MYSTERY_OFFSET))
);
}
}
}
}
@SuppressWarnings("ConstantConditions")
private List convertToAst(final List body) {
final ArrayList ast = new ArrayList<>();
//
// Convert stack-based bytecode to bytecode AST.
//
for (final ByteCode byteCode : body) {
final Instruction originalInstruction = mappedInstruction(_originalInstructionMap, byteCode.instruction);
final Range codeRange = new Range(originalInstruction.getOffset(), originalInstruction.getEndOffset());
if (byteCode.stackBefore == null /*|| _removed.contains(byteCode.instruction)*/) {
//
// Unreachable code.
//
continue;
}
//
// Include the instruction's label, if it has one.
//
if (byteCode.label != null) {
ast.add(byteCode.label);
}
switch (byteCode.code) {
case Dup:
case DupX1:
case DupX2:
case Dup2:
case Dup2X1:
case Dup2X2:
case Swap:
continue;
}
final Expression expression;
if (_removed.contains(byteCode.instruction)) {
expression = new Expression(AstCode.Nop, null, Expression.MYSTERY_OFFSET);
ast.add(expression);
continue;
}
expression = new Expression(byteCode.code, byteCode.operand, byteCode.offset);
if (byteCode.code == AstCode.Inc) {
assert byteCode.secondOperand instanceof Integer;
expression.setCode(AstCode.Inc);
expression.getArguments().add(new Expression(AstCode.LdC, byteCode.secondOperand, byteCode.offset));
}
else if (byteCode.code == AstCode.Switch) {
expression.putUserData(AstKeys.SWITCH_INFO, byteCode.instruction.getOperand(0));
}
expression.getRanges().add(codeRange);
//
// Reference arguments using temporary variables.
//
final int popCount = byteCode.popCount != -1 ? byteCode.popCount
: byteCode.stackBefore.length;
for (int i = byteCode.stackBefore.length - popCount; i < byteCode.stackBefore.length; i++) {
final StackSlot slot = byteCode.stackBefore[i];
if (slot.value.getType().isDoubleWord()) {
i++;
}
expression.getArguments().add(new Expression(AstCode.Load, slot.loadFrom, byteCode.offset));
}
//
// Store the result to temporary variables, if needed.
//
if (byteCode.storeTo == null || byteCode.storeTo.isEmpty()) {
ast.add(expression);
}
else if (byteCode.storeTo.size() == 1) {
ast.add(new Expression(AstCode.Store, byteCode.storeTo.get(0), expression.getOffset(), expression));
}
else {
final Variable tempVariable = new Variable();
tempVariable.setName(format("expr_%1$02X", byteCode.offset));
tempVariable.setGenerated(true);
ast.add(new Expression(AstCode.Store, tempVariable, expression.getOffset(), expression));
for (int i = byteCode.storeTo.size() - 1; i >= 0; i--) {
ast.add(
new Expression(
AstCode.Store,
byteCode.storeTo.get(i),
Expression.MYSTERY_OFFSET,
new Expression(AstCode.Load, tempVariable, byteCode.offset)
)
);
}
}
}
return ast;
}
//
private final static class StackSlot {
final FrameValue value;
final ByteCode[] definitions;
final Variable loadFrom;
public StackSlot(final FrameValue value, final ByteCode[] definitions) {
this.value = VerifyArgument.notNull(value, "value");
this.definitions = VerifyArgument.notNull(definitions, "definitions");
this.loadFrom = null;
}
public StackSlot(final FrameValue value, final ByteCode[] definitions, final Variable loadFrom) {
this.value = VerifyArgument.notNull(value, "value");
this.definitions = VerifyArgument.notNull(definitions, "definitions");
this.loadFrom = loadFrom;
}
public static StackSlot[] modifyStack(
final StackSlot[] stack,
final int popCount,
final ByteCode pushDefinition,
final FrameValue... pushTypes) {
VerifyArgument.notNull(stack, "stack");
VerifyArgument.isNonNegative(popCount, "popCount");
VerifyArgument.noNullElements(pushTypes, "pushTypes");
final StackSlot[] newStack = new StackSlot[stack.length - popCount + pushTypes.length];
System.arraycopy(stack, 0, newStack, 0, stack.length - popCount);
for (int i = stack.length - popCount, j = 0; i < newStack.length; i++, j++) {
newStack[i] = new StackSlot(pushTypes[j], new ByteCode[] { pushDefinition });
}
return newStack;
}
@Override
public String toString() {
return "StackSlot(" + value + ')';
}
@Override
@SuppressWarnings("CloneDoesntCallSuperClone")
protected final StackSlot clone() {
return new StackSlot(value, definitions.clone(), loadFrom);
}
}
//
//
private final static class VariableSlot {
final static VariableSlot UNKNOWN_INSTANCE = new VariableSlot(FrameValue.EMPTY, EMPTY_DEFINITIONS);
final ByteCode[] definitions;
final FrameValue value;
public VariableSlot(final FrameValue value, final ByteCode[] definitions) {
this.value = VerifyArgument.notNull(value, "value");
this.definitions = VerifyArgument.notNull(definitions, "definitions");
}
public static VariableSlot[] cloneVariableState(final VariableSlot[] state) {
return state.clone();
}
public static VariableSlot[] makeUnknownState(final int variableCount) {
final VariableSlot[] unknownVariableState = new VariableSlot[variableCount];
for (int i = 0; i < variableCount; i++) {
unknownVariableState[i] = UNKNOWN_INSTANCE;
}
return unknownVariableState;
}
public final boolean isUninitialized() {
return value == FrameValue.UNINITIALIZED || value == FrameValue.UNINITIALIZED_THIS;
}
@Override
@SuppressWarnings("CloneDoesntCallSuperClone")
protected final VariableSlot clone() {
return new VariableSlot(value, definitions.clone());
}
}
//
//
private final static class ByteCode {
Label label;
Instruction instruction;
String name;
int offset; // NOTE: If you change 'offset', clear out 'name'.
int endOffset;
AstCode code;
Object operand;
Object secondOperand;
int popCount = -1;
int pushCount;
ByteCode next;
ByteCode previous;
FrameValue type;
StackSlot[] stackBefore;
VariableSlot[] variablesBefore;
List storeTo;
public final String name() {
if (name == null) {
name = format("#%1$04d", offset);
}
return name;
}
public final String makeLabelName() {
return format("Label_%1$04d", offset);
}
public final Frame getFrameBefore() {
return createFrame(stackBefore, variablesBefore);
}
public final boolean isVariableDefinition() {
return code == AstCode.Store/* ||
code == AstCode.Inc*/;
}
@Override
@SuppressWarnings("ConstantConditions")
public final String toString() {
final StringBuilder sb = new StringBuilder();
//
// Label
//
sb.append(name()).append(':');
if (label != null) {
sb.append('*');
}
//
// Name
//
sb.append(' ');
sb.append(code.getName());
if (operand != null) {
sb.append(' ');
if (operand instanceof Instruction) {
sb.append(format("#%1$04d", ((Instruction) operand).getOffset()));
}
else if (operand instanceof Instruction[]) {
for (final Instruction instruction : (Instruction[]) operand) {
sb.append(format("#%1$04d", instruction.getOffset()));
sb.append(' ');
}
}
else if (operand instanceof Label) {
sb.append(((Label) operand).getName());
}
else if (operand instanceof Label[]) {
for (final Label l : (Label[]) operand) {
sb.append(l.getName());
sb.append(' ');
}
}
else if (operand instanceof VariableReference) {
final VariableReference variable = (VariableReference) operand;
if (variable.hasName()) {
sb.append(variable.getName());
}
else {
sb.append("$").append(String.valueOf(variable.getSlot()));
}
}
else {
sb.append(operand);
}
}
if (stackBefore != null) {
sb.append(" StackBefore={");
for (int i = 0; i < stackBefore.length; i++) {
if (i != 0) {
sb.append(',');
}
final StackSlot slot = stackBefore[i];
final ByteCode[] definitions = slot.definitions;
for (int j = 0; j < definitions.length; j++) {
if (j != 0) {
sb.append('|');
}
sb.append(format("#%1$04d", definitions[j].offset));
}
}
sb.append('}');
}
if (storeTo != null && !storeTo.isEmpty()) {
sb.append(" StoreTo={");
for (int i = 0; i < storeTo.size(); i++) {
if (i != 0) {
sb.append(',');
}
sb.append(storeTo.get(i).getName());
}
sb.append('}');
}
if (variablesBefore != null) {
sb.append(" VariablesBefore={");
for (int i = 0; i < variablesBefore.length; i++) {
if (i != 0) {
sb.append(',');
}
final VariableSlot slot = variablesBefore[i];
if (slot.isUninitialized()) {
sb.append('?');
}
else {
final ByteCode[] definitions = slot.definitions;
for (int j = 0; j < definitions.length; j++) {
if (j != 0) {
sb.append('|');
}
sb.append(format("#%1$04d", definitions[j].offset));
}
}
}
sb.append('}');
}
return sb.toString();
}
}
private static Frame createFrame(final StackSlot[] stack, final VariableSlot[] locals) {
final FrameValue[] stackValues;
final FrameValue[] variableValues;
if (stack.length == 0) {
stackValues = FrameValue.EMPTY_VALUES;
}
else {
stackValues = new FrameValue[stack.length];
for (int i = 0; i < stack.length; i++) {
stackValues[i] = stack[i].value;
}
}
if (locals.length == 0) {
variableValues = FrameValue.EMPTY_VALUES;
}
else {
variableValues = new FrameValue[locals.length];
for (int i = 0; i < locals.length; i++) {
variableValues[i] = locals[i].value;
}
}
return new Frame(FrameType.New, variableValues, stackValues);
}
//
//
private final static Predicate NOT_A_LABEL_OR_NOP = new Predicate() {
@Override
public boolean test(final Node node) {
return !(node instanceof Label || match(node, AstCode.Nop));
}
};
//
private final static class FinallyInlining {
private final MethodBody _body;
private final InstructionCollection _instructions;
private final List _exceptionHandlers;
private final Set _removed;
private final Function _previous;
private final ControlFlowGraph _cfg;
private final Map _nodeMap;
private final Map _handlerMap = new IdentityHashMap<>();
private final Set _processedNodes = new LinkedHashSet<>();
private final Set _allFinallyNodes = new LinkedHashSet<>();
private FinallyInlining(
final MethodBody body,
final InstructionCollection instructions,
final List handlers,
final Set removedInstructions) {
_body = body;
_instructions = instructions;
_exceptionHandlers = handlers;
_removed = removedInstructions;
_previous = new Function() {
@Override
public Instruction apply(final Instruction i) {
return previous(i);
}
};
preProcess();
_cfg = ControlFlowGraphBuilder.build(instructions, handlers);
_cfg.computeDominance();
_cfg.computeDominanceFrontier();
_nodeMap = createNodeMap(_cfg);
final Set terminals = new HashSet<>();
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
final InstructionBlock handlerBlock = handler.getHandlerBlock();
final ControlFlowNode handlerNode = findHandlerNode(_cfg, handler);
final ControlFlowNode head = _nodeMap.get(handlerBlock.getFirstInstruction());
final ControlFlowNode tryHead = _nodeMap.get(handler.getTryBlock().getFirstInstruction());
terminals.clear();
for (int j = 0; j < handlers.size(); j++) {
final ExceptionHandler otherHandler = handlers.get(j);
if (otherHandler.getTryBlock().equals(handler.getTryBlock())) {
terminals.add(findHandlerNode(_cfg, otherHandler));
}
}
final List tryNodes = new ArrayList<>(
findDominatedNodes(
_cfg,
tryHead,
true,
terminals
)
);
terminals.remove(handlerNode);
if (handler.isFinally()) {
terminals.add(handlerNode.getEndFinallyNode());
}
final List handlerNodes = new ArrayList<>(
findDominatedNodes(
_cfg,
head,
true,
terminals
)
);
Collections.sort(tryNodes);
Collections.sort(handlerNodes);
final ControlFlowNode tail = last(handlerNodes);
final HandlerInfo handlerInfo = new HandlerInfo(
handler,
handlerNode,
head,
tail,
tryNodes,
handlerNodes
);
_handlerMap.put(handler, handlerInfo);
if (handler.isFinally()) {
_allFinallyNodes.addAll(handlerNodes);
}
// dumpHandlerNodes(handler, tryNodes, handlerNodes);
}
}
@SuppressWarnings("UnusedDeclaration")
private static void dumpHandlerNodes(
final ExceptionHandler handler,
final List tryNodes,
final List handlerNodes) {
final ITextOutput output = new PlainTextOutput();
output.writeLine(handler.toString());
output.writeLine("Try Nodes:");
output.indent();
for (final ControlFlowNode node : tryNodes) {
output.writeLine(node.toString());
}
output.unindent();
output.writeLine("Handler Nodes:");
output.indent();
for (final ControlFlowNode node : handlerNodes) {
output.writeLine(node.toString());
}
output.unindent();
output.writeLine();
System.out.println(output);
}
static void run(
final MethodBody body,
final InstructionCollection instructions,
final List handlers,
final Set removedInstructions) {
Collections.reverse(handlers);
try {
LOG.fine("Removing inlined `finally` code...");
final FinallyInlining inlining = new FinallyInlining(body, instructions, handlers, removedInstructions);
inlining.runCore();
}
finally {
Collections.reverse(handlers);
}
}
private void runCore() {
final List handlers = _exceptionHandlers;
if (handlers.isEmpty()) {
return;
}
final List originalHandlers = toList(_exceptionHandlers);
final List sortedHandlers = toList(originalHandlers);
Collections.sort(
sortedHandlers,
new Comparator() {
@Override
public int compare(@NotNull final ExceptionHandler o1, @NotNull final ExceptionHandler o2) {
if (o1.getHandlerBlock().contains(o2.getHandlerBlock())) {
return -1;
}
if (o2.getHandlerBlock().contains(o1.getHandlerBlock())) {
return 1;
}
return Integer.compare(
originalHandlers.indexOf(o1),
originalHandlers.indexOf(o2)
);
}
}
);
for (final ExceptionHandler handler : sortedHandlers) {
if (handler.isFinally()) {
processFinally(handler);
}
}
}
private void processFinally(final ExceptionHandler handler) {
final HandlerInfo handlerInfo = _handlerMap.get(handler);
Instruction first = handlerInfo.head.getStart();
Instruction last = handlerInfo.handler.getHandlerBlock().getLastInstruction();
if (last.getOpCode() == OpCode.ENDFINALLY) {
first = first.getNext();
last = previous(last);
}
else {
if (first.getOpCode().isStore() || first.getOpCode() == OpCode.POP) {
first = first.getNext();
}
}
if (first == null || last == null) {
return;
}
int instructionCount = 0;
for (Instruction p = last; p != null && p.getOffset() >= first.getOffset(); p = previous(p)) {
++instructionCount;
}
if (instructionCount == 0 ||
instructionCount == 1 && !_removed.contains(last) && last.getOpCode().isUnconditionalBranch()) {
return;
}
final Set toProcess = collectNodes(handlerInfo);
final Set forbiddenNodes = new LinkedHashSet<>(_allFinallyNodes);
forbiddenNodes.removeAll(handlerInfo.tryNodes);
_processedNodes.clear();
processNodes(handlerInfo, first, last, instructionCount, toProcess, forbiddenNodes);
}
@SuppressWarnings("ConstantConditions")
private void processNodes(
final HandlerInfo handlerInfo,
final Instruction first,
final Instruction last,
final int instructionCount,
final Set toProcess,
final Set forbiddenNodes) {
final ExceptionHandler handler = handlerInfo.handler;
final ControlFlowNode tryHead = _nodeMap.get(handler.getTryBlock().getFirstInstruction());
final ControlFlowNode finallyTail = _nodeMap.get(handler.getHandlerBlock().getLastInstruction());
final List> startingPoints = new ArrayList<>();
nextNode:
for (ControlFlowNode node : toProcess) {
final ExceptionHandler nodeHandler = node.getExceptionHandler();
if (node.getNodeType() == ControlFlowNodeType.EndFinally) {
continue;
}
if (nodeHandler != null) {
node = _nodeMap.get(nodeHandler.getHandlerBlock().getLastInstruction());
}
if (_processedNodes.contains(node) || forbiddenNodes.contains(node)) {
continue;
}
Instruction tail = node.getEnd();
boolean isLeave = false;
boolean tryNext = false;
boolean tryPrevious = false;
if (finallyTail.getEnd().getOpCode().isReturn() ||
finallyTail.getEnd().getOpCode().isThrow()) {
isLeave = true;
}
if (last.getOpCode() == OpCode.GOTO || last.getOpCode() == OpCode.GOTO_W) {
tryNext = true;
}
if (tail.getOpCode().isUnconditionalBranch()) {
switch (tail.getOpCode()) {
case GOTO:
case GOTO_W:
tryPrevious = true;
break;
case RETURN:
tail = previous(tail);
tryPrevious = true;
break;
case IRETURN:
case LRETURN:
case FRETURN:
case DRETURN:
case ARETURN:
if (finallyTail.getEnd().getOpCode().getFlowControl() != FlowControl.Return) {
tail = previous(tail);
}
tryPrevious = true;
break;
case ATHROW:
tryNext = true;
tryPrevious = true;
break;
}
}
if (tail == null) {
continue;
}
startingPoints.add(Pair.create(last, tail));
if (tryPrevious) {
startingPoints.add(Pair.create(last, previous(tail)));
}
if (tryNext) {
startingPoints.add(Pair.create(last, tail.getNext()));
}
boolean matchFound = false;
for (final Pair startingPoint : startingPoints) {
if (forbiddenNodes.contains(_nodeMap.get(startingPoint.getSecond()))) {
continue;
}
if (opCodesMatch(startingPoint.getFirst(), startingPoint.getSecond(), instructionCount, _previous)) {
tail = startingPoint.getSecond();
matchFound = true;
break;
}
}
startingPoints.clear();
if (!matchFound) {
if (last.getOpCode() == OpCode.JSR) {
//
// If we failed to match against the last instruction in our 'try' block, see if our
// subroutine jump follows the finally block instead. This pattern has been seen
// in the wild.
//
final Instruction lastInTry = handlerInfo.handler.getTryBlock().getLastInstruction();
if (tail == lastInTry &&
(lastInTry.getOpCode() == OpCode.GOTO || lastInTry.getOpCode() == OpCode.GOTO_W)) {
final Instruction target = lastInTry.getOperand(0);
if (target.getOpCode() == OpCode.JSR &&
target.getOperand(0) == last.getOperand(0)) {
target.setOpCode(OpCode.NOP);
target.setOperand(null);
}
}
}
continue;
}
if (tail.getOffset() - tryHead.getOffset() == last.getOffset() - first.getOffset() &&
handlerInfo.tryNodes.contains(node)) {
//
// If the try block exactly matches the finally, don't remove it.
//
continue;
}
for (int i = 0; i < instructionCount; i++) {
_removed.add(tail);
tail = previous(tail);
if (tail == null) {
continue nextNode;
}
}
if (isLeave) {
if (tail != null &&
tail.getOpCode().isStore() &&
!_body.getMethod().getReturnType().isVoid()) {
final Instruction load = InstructionHelper.reverseLoadOrStore(tail);
final Instruction returnSite = node.getEnd();
final Instruction loadSite = returnSite.getPrevious();
loadSite.setOpCode(load.getOpCode());
if (load.getOperandCount() == 1) {
loadSite.setOperand(load.getOperand(0));
}
switch (load.getOpCode().name().charAt(0)) {
case 'I':
returnSite.setOpCode(OpCode.IRETURN);
break;
case 'L':
returnSite.setOpCode(OpCode.LRETURN);
break;
case 'F':
returnSite.setOpCode(OpCode.FRETURN);
break;
case 'D':
returnSite.setOpCode(OpCode.DRETURN);
break;
case 'A':
returnSite.setOpCode(OpCode.ARETURN);
break;
}
returnSite.setOperand(null);
_removed.remove(loadSite);
_removed.remove(returnSite);
}
else {
_removed.add(node.getEnd());
}
}
_processedNodes.add(node);
}
}
@SuppressWarnings("ConstantConditions")
private Set collectNodes(final HandlerInfo handlerInfo) {
final ControlFlowGraph cfg = _cfg;
final List successors = new ArrayList<>();
final Set toProcess = new LinkedHashSet<>();
final ControlFlowNode endFinallyNode = handlerInfo.handlerNode.getEndFinallyNode();
final Set exitOnlySuccessors = new LinkedHashSet<>();
final InstructionBlock tryBlock = handlerInfo.handler.getTryBlock();
if (endFinallyNode != null) {
successors.add(handlerInfo.handlerNode);
}
for (final ControlFlowNode exit : cfg.getRegularExit().getPredecessors()) {
if (exit.getNodeType() == ControlFlowNodeType.Normal &&
tryBlock.contains(exit.getEnd())) {
toProcess.add(exit);
}
}
for (final ControlFlowNode exit : cfg.getExceptionalExit().getPredecessors()) {
if (exit.getNodeType() == ControlFlowNodeType.Normal &&
tryBlock.contains(exit.getEnd())) {
toProcess.add(exit);
}
}
for (int i = 0; i < successors.size(); i++) {
final ControlFlowNode successor = successors.get(i);
for (final ControlFlowEdge edge : successor.getIncoming()) {
if (edge.getSource() == successor) {
continue;
}
if (edge.getType() == JumpType.Normal &&
edge.getSource().getNodeType() == ControlFlowNodeType.Normal &&
!exitOnlySuccessors.contains(successor)) {
toProcess.add(edge.getSource());
}
else if (edge.getType() == JumpType.JumpToExceptionHandler &&
edge.getSource().getNodeType() == ControlFlowNodeType.Normal &&
(edge.getSource().getEnd().getOpCode().isThrow() ||
edge.getSource().getEnd().getOpCode().isReturn())) {
toProcess.add(edge.getSource());
if (exitOnlySuccessors.contains(successor)) {
exitOnlySuccessors.add(edge.getSource());
}
}
else if (edge.getSource().getNodeType() == ControlFlowNodeType.CatchHandler) {
final ControlFlowNode endCatch = findNode(
cfg,
edge.getSource().getExceptionHandler().getHandlerBlock().getLastInstruction()
);
if (handlerInfo.handler.getTryBlock().contains(endCatch.getEnd())) {
toProcess.add(endCatch);
}
}
else if (edge.getSource().getNodeType() == ControlFlowNodeType.FinallyHandler) {
successors.add(edge.getSource());
exitOnlySuccessors.add(edge.getSource());
}
else if (edge.getSource().getNodeType() == ControlFlowNodeType.EndFinally) {
successors.add(edge.getSource());
final HandlerInfo precedingFinally = firstOrDefault(
_handlerMap.values(),
new Predicate() {
@Override
public boolean test(final HandlerInfo o) {
return o.handlerNode.getEndFinallyNode() == edge.getSource();
}
}
);
if (precedingFinally != null) {
successors.add(precedingFinally.handlerNode);
exitOnlySuccessors.remove(precedingFinally.handlerNode);
}
}
}
}
List finallyNodes = null;
for (final ControlFlowNode node : toProcess) {
if (_allFinallyNodes.contains(node)) {
if (finallyNodes == null) {
finallyNodes = new ArrayList<>();
}
finallyNodes.add(node);
}
}
if (finallyNodes != null) {
toProcess.removeAll(finallyNodes);
toProcess.addAll(finallyNodes);
}
return toProcess;
}
private void preProcess() {
final InstructionCollection instructions = _instructions;
final List handlers = _exceptionHandlers;
final ControlFlowGraph cfg = ControlFlowGraphBuilder.build(instructions, handlers);
cfg.computeDominance();
cfg.computeDominanceFrontier();
for (int i = 0; i < handlers.size(); i++) {
final ExceptionHandler handler = handlers.get(i);
if (handler.isFinally()) {
final InstructionBlock handlerBlock = handler.getHandlerBlock();
final ControlFlowNode finallyHead = findNode(cfg, handler.getHandlerBlock().getFirstInstruction());
final List finallyNodes = toList(
findDominatedNodes(
cfg,
finallyHead,
true,
Collections.emptySet()
)
);
Collections.sort(finallyNodes);
final Instruction first = handlerBlock.getFirstInstruction();
Instruction last = last(finallyNodes).getEnd();
Instruction nextToLast = last.getPrevious();
boolean firstPass = true;
while (true) {
if (first.getOpCode().isStore() &&
last.getOpCode() == OpCode.ATHROW &&
nextToLast.getOpCode().isLoad() &&
InstructionHelper.getLoadOrStoreSlot(first) == InstructionHelper.getLoadOrStoreSlot(nextToLast)) {
nextToLast.setOpCode(OpCode.NOP);
nextToLast.setOperand(null);
_removed.add(nextToLast);
last.setOpCode(OpCode.ENDFINALLY);
last.setOperand(null);
break;
}
if (firstPass = !firstPass) {
break;
}
last = handlerBlock.getLastInstruction();
nextToLast = last.getPrevious();
}
}
}
}
private Instruction previous(final Instruction i) {
Instruction p = i.getPrevious();
while (p != null && _removed.contains(p)) {
p = p.getPrevious();
}
return p;
}
}
}
