compiler/src/org/apache/flex/abc/optimize/DeadCodeFilter.java

/*
 *
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

package org.apache.flex.abc.optimize;

import java.util.Iterator;
import java.util.List;

import org.apache.flex.abc.ABCConstants;
import org.apache.flex.abc.graph.IBasicBlock;
import org.apache.flex.abc.graph.IFlowgraph;
import org.apache.flex.abc.semantics.ExceptionInfo;
import org.apache.flex.abc.semantics.Instruction;
import org.apache.flex.abc.semantics.InstructionFactory;
import org.apache.flex.abc.semantics.MethodBodyInfo;
import org.apache.flex.abc.visitors.DelegatingMethodBodyVisitor;
import org.apache.flex.abc.visitors.IDiagnosticsVisitor;
import org.apache.flex.abc.visitors.IMethodBodyVisitor;

/**
 * DeadCodeFilter rebuilds the method's result InstructionList by walking the
 * control flow graph at visitEnd() time, and resets its delegate's instructions
 * to the pruned InstructionList.
 */
public class DeadCodeFilter extends DelegatingMethodBodyVisitor
{
    /**
     * Constructor.
     * 
     * @param mbi - the MethodBodyInfo to be analyzed.
     * @param delegate - the next IMethodBodyVisitor in the chain.
     */
    public DeadCodeFilter(MethodBodyInfo mbi, IMethodBodyVisitor delegate, IDiagnosticsVisitor diagnostics)
    {
        super(delegate);
        this.mbi = mbi;
        this.diagnostics = diagnostics;
    }

    /**
     * The MethodBodyInfo under analysis.
     */
    protected final MethodBodyInfo mbi;

    /**
     */
    protected final IDiagnosticsVisitor diagnostics;

    /**
     * Walk the control flow graph and remove unreachable blocks.
     */
    @Override
    public void visitEnd()
    {
        IFlowgraph cfg = this.mbi.getCfg();
        List<IBasicBlock> blocks = cfg.getBlocksInEntryOrder();
        boolean lastBlockWasReachable = true;

        int blockIdx = 0;
        while ( blockIdx < blocks.size() )
        {
            IBasicBlock b = blocks.get(blockIdx);
            boolean isReachable = cfg.isReachable(b);

            // Only advance the block index if the current
            // block is removed.
            int previousBlockCount = blocks.size();

            if ( ! isReachable )
            {
                //  Don't remove unreachable blocks that are the final block in an exception handler,
                //  unless they're also the first block in the exception handler.  The AVM depends on
                //  these blocks under some circumstances.  However, the block's instructions can be
                //  coalesced to a single OP_nop.
                boolean safeToRemove = true;

                for ( ExceptionInfo ex: this.mbi.getExceptions() )
                {
                    IBasicBlock toBlock = this.mbi.getCfg().getBlock(ex.getTo());
                    if ( b.equals(toBlock) )
                    {
                        IBasicBlock fromBlock = this.mbi.getCfg().getBlock(ex.getFrom());

                        int tryFrom = blocks.indexOf(fromBlock);
                        int tryTo   = blocks.indexOf(toBlock);
                        assert tryFrom >= 0 && tryTo >= tryFrom;

                        for ( int j = tryTo - 1; safeToRemove && j >= tryFrom; j-- )
                            safeToRemove = !cfg.isReachable(blocks.get(j));
                        
                        if ( !safeToRemove )
                        {
                            //  Can't remove it, but compact it: remove executable
                            //  instructions, then write a single OP_nop as necessary.

                            Iterator<Instruction> it = b.getInstructions().iterator();

                            while ( it.hasNext() )
                            {
                                Instruction insn = it.next();

                                if ( insn.isExecutable() )
                                    it.remove();
                            }

                            b.getInstructions().add(InstructionFactory.getInstruction(ABCConstants.OP_nop));
                            break;
                        }
                    }
                }

                if ( safeToRemove )
                {
                    //  Only remove the Block if it contains executable and non-NOP instructions.
                    for ( int j = 0; j < b.size(); j++ )
                    {
                        Instruction insn = b.get(j);
                        if ( insn.isExecutable() && insn.getOpcode() != ABCConstants.OP_nop )
                        {
                            //  Only emit a diagnostic if b is the first unreachable block
                            //  encountered in this sequence.
                            if ( lastBlockWasReachable )
                                this.diagnostics.unreachableBlock(this.mbi, this.mbi.getCfg(), b);
                            cfg.removeUnreachableBlock(b);
                            break;
                        }
                    }
                }
            }

            if ( previousBlockCount == blocks.size() )
                blockIdx++;

            //  Remember the state of the last-visited block.
            lastBlockWasReachable = isReachable;
        }

        super.visitEnd();
    }
}