/*

 * Copyright (c) 2009, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package org.graalvm.compiler.java;

import static org.graalvm.compiler.bytecode.Bytecodes.AALOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.AASTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.ACONST_NULL;

import static org.graalvm.compiler.bytecode.Bytecodes.ALOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.ALOAD_0;

import static org.graalvm.compiler.bytecode.Bytecodes.ALOAD_1;

import static org.graalvm.compiler.bytecode.Bytecodes.ALOAD_2;

import static org.graalvm.compiler.bytecode.Bytecodes.ALOAD_3;

import static org.graalvm.compiler.bytecode.Bytecodes.ANEWARRAY;

import static org.graalvm.compiler.bytecode.Bytecodes.ARETURN;

import static org.graalvm.compiler.bytecode.Bytecodes.ARRAYLENGTH;

import static org.graalvm.compiler.bytecode.Bytecodes.ASTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.ASTORE_0;

import static org.graalvm.compiler.bytecode.Bytecodes.ASTORE_1;

import static org.graalvm.compiler.bytecode.Bytecodes.ASTORE_2;

import static org.graalvm.compiler.bytecode.Bytecodes.ASTORE_3;

import static org.graalvm.compiler.bytecode.Bytecodes.ATHROW;

import static org.graalvm.compiler.bytecode.Bytecodes.BALOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.BASTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.BIPUSH;

import static org.graalvm.compiler.bytecode.Bytecodes.BREAKPOINT;

import static org.graalvm.compiler.bytecode.Bytecodes.CALOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.CASTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.CHECKCAST;

import static org.graalvm.compiler.bytecode.Bytecodes.D2F;

import static org.graalvm.compiler.bytecode.Bytecodes.D2I;

import static org.graalvm.compiler.bytecode.Bytecodes.D2L;

import static org.graalvm.compiler.bytecode.Bytecodes.DADD;

import static org.graalvm.compiler.bytecode.Bytecodes.DALOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.DASTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.DCMPG;

import static org.graalvm.compiler.bytecode.Bytecodes.DCMPL;

import static org.graalvm.compiler.bytecode.Bytecodes.DCONST_0;

import static org.graalvm.compiler.bytecode.Bytecodes.DCONST_1;

import static org.graalvm.compiler.bytecode.Bytecodes.DDIV;

import static org.graalvm.compiler.bytecode.Bytecodes.DLOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.DLOAD_0;

import static org.graalvm.compiler.bytecode.Bytecodes.DLOAD_1;

import static org.graalvm.compiler.bytecode.Bytecodes.DLOAD_2;

import static org.graalvm.compiler.bytecode.Bytecodes.DLOAD_3;

import static org.graalvm.compiler.bytecode.Bytecodes.DMUL;

import static org.graalvm.compiler.bytecode.Bytecodes.DNEG;

import static org.graalvm.compiler.bytecode.Bytecodes.DREM;

import static org.graalvm.compiler.bytecode.Bytecodes.DRETURN;

import static org.graalvm.compiler.bytecode.Bytecodes.DSTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.DSTORE_0;

import static org.graalvm.compiler.bytecode.Bytecodes.DSTORE_1;

import static org.graalvm.compiler.bytecode.Bytecodes.DSTORE_2;

import static org.graalvm.compiler.bytecode.Bytecodes.DSTORE_3;

import static org.graalvm.compiler.bytecode.Bytecodes.DSUB;

import static org.graalvm.compiler.bytecode.Bytecodes.DUP;

import static org.graalvm.compiler.bytecode.Bytecodes.DUP2;

import static org.graalvm.compiler.bytecode.Bytecodes.DUP2_X1;

import static org.graalvm.compiler.bytecode.Bytecodes.DUP2_X2;

import static org.graalvm.compiler.bytecode.Bytecodes.DUP_X1;

import static org.graalvm.compiler.bytecode.Bytecodes.DUP_X2;

import static org.graalvm.compiler.bytecode.Bytecodes.F2D;

import static org.graalvm.compiler.bytecode.Bytecodes.F2I;

import static org.graalvm.compiler.bytecode.Bytecodes.F2L;

import static org.graalvm.compiler.bytecode.Bytecodes.FADD;

import static org.graalvm.compiler.bytecode.Bytecodes.FALOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.FASTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.FCMPG;

import static org.graalvm.compiler.bytecode.Bytecodes.FCMPL;

import static org.graalvm.compiler.bytecode.Bytecodes.FCONST_0;

import static org.graalvm.compiler.bytecode.Bytecodes.FCONST_1;

import static org.graalvm.compiler.bytecode.Bytecodes.FCONST_2;

import static org.graalvm.compiler.bytecode.Bytecodes.FDIV;

import static org.graalvm.compiler.bytecode.Bytecodes.FLOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.FLOAD_0;

import static org.graalvm.compiler.bytecode.Bytecodes.FLOAD_1;

import static org.graalvm.compiler.bytecode.Bytecodes.FLOAD_2;

import static org.graalvm.compiler.bytecode.Bytecodes.FLOAD_3;

import static org.graalvm.compiler.bytecode.Bytecodes.FMUL;

import static org.graalvm.compiler.bytecode.Bytecodes.FNEG;

import static org.graalvm.compiler.bytecode.Bytecodes.FREM;

import static org.graalvm.compiler.bytecode.Bytecodes.FRETURN;

import static org.graalvm.compiler.bytecode.Bytecodes.FSTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.FSTORE_0;

import static org.graalvm.compiler.bytecode.Bytecodes.FSTORE_1;

import static org.graalvm.compiler.bytecode.Bytecodes.FSTORE_2;

import static org.graalvm.compiler.bytecode.Bytecodes.FSTORE_3;

import static org.graalvm.compiler.bytecode.Bytecodes.FSUB;

import static org.graalvm.compiler.bytecode.Bytecodes.GETFIELD;

import static org.graalvm.compiler.bytecode.Bytecodes.GETSTATIC;

import static org.graalvm.compiler.bytecode.Bytecodes.GOTO;

import static org.graalvm.compiler.bytecode.Bytecodes.GOTO_W;

import static org.graalvm.compiler.bytecode.Bytecodes.I2B;

import static org.graalvm.compiler.bytecode.Bytecodes.I2C;

import static org.graalvm.compiler.bytecode.Bytecodes.I2D;

import static org.graalvm.compiler.bytecode.Bytecodes.I2F;

import static org.graalvm.compiler.bytecode.Bytecodes.I2L;

import static org.graalvm.compiler.bytecode.Bytecodes.I2S;

import static org.graalvm.compiler.bytecode.Bytecodes.IADD;

import static org.graalvm.compiler.bytecode.Bytecodes.IALOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.IAND;

import static org.graalvm.compiler.bytecode.Bytecodes.IASTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.ICONST_0;

import static org.graalvm.compiler.bytecode.Bytecodes.ICONST_1;

import static org.graalvm.compiler.bytecode.Bytecodes.ICONST_2;

import static org.graalvm.compiler.bytecode.Bytecodes.ICONST_3;

import static org.graalvm.compiler.bytecode.Bytecodes.ICONST_4;

import static org.graalvm.compiler.bytecode.Bytecodes.ICONST_5;

import static org.graalvm.compiler.bytecode.Bytecodes.ICONST_M1;

import static org.graalvm.compiler.bytecode.Bytecodes.IDIV;

import static org.graalvm.compiler.bytecode.Bytecodes.IFEQ;

import static org.graalvm.compiler.bytecode.Bytecodes.IFGE;

import static org.graalvm.compiler.bytecode.Bytecodes.IFGT;

import static org.graalvm.compiler.bytecode.Bytecodes.IFLE;

import static org.graalvm.compiler.bytecode.Bytecodes.IFLT;

import static org.graalvm.compiler.bytecode.Bytecodes.IFNE;

import static org.graalvm.compiler.bytecode.Bytecodes.IFNONNULL;

import static org.graalvm.compiler.bytecode.Bytecodes.IFNULL;

import static org.graalvm.compiler.bytecode.Bytecodes.IF_ACMPEQ;

import static org.graalvm.compiler.bytecode.Bytecodes.IF_ACMPNE;

import static org.graalvm.compiler.bytecode.Bytecodes.IF_ICMPEQ;

import static org.graalvm.compiler.bytecode.Bytecodes.IF_ICMPGE;

import static org.graalvm.compiler.bytecode.Bytecodes.IF_ICMPGT;

import static org.graalvm.compiler.bytecode.Bytecodes.IF_ICMPLE;

import static org.graalvm.compiler.bytecode.Bytecodes.IF_ICMPLT;

import static org.graalvm.compiler.bytecode.Bytecodes.IF_ICMPNE;

import static org.graalvm.compiler.bytecode.Bytecodes.IINC;

import static org.graalvm.compiler.bytecode.Bytecodes.ILOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.ILOAD_0;

import static org.graalvm.compiler.bytecode.Bytecodes.ILOAD_1;

import static org.graalvm.compiler.bytecode.Bytecodes.ILOAD_2;

import static org.graalvm.compiler.bytecode.Bytecodes.ILOAD_3;

import static org.graalvm.compiler.bytecode.Bytecodes.IMUL;

import static org.graalvm.compiler.bytecode.Bytecodes.INEG;

import static org.graalvm.compiler.bytecode.Bytecodes.INSTANCEOF;

import static org.graalvm.compiler.bytecode.Bytecodes.INVOKEDYNAMIC;

import static org.graalvm.compiler.bytecode.Bytecodes.INVOKEINTERFACE;

import static org.graalvm.compiler.bytecode.Bytecodes.INVOKESPECIAL;

import static org.graalvm.compiler.bytecode.Bytecodes.INVOKESTATIC;

import static org.graalvm.compiler.bytecode.Bytecodes.INVOKEVIRTUAL;

import static org.graalvm.compiler.bytecode.Bytecodes.IOR;

import static org.graalvm.compiler.bytecode.Bytecodes.IREM;

import static org.graalvm.compiler.bytecode.Bytecodes.IRETURN;

import static org.graalvm.compiler.bytecode.Bytecodes.ISHL;

import static org.graalvm.compiler.bytecode.Bytecodes.ISHR;

import static org.graalvm.compiler.bytecode.Bytecodes.ISTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.ISTORE_0;

import static org.graalvm.compiler.bytecode.Bytecodes.ISTORE_1;

import static org.graalvm.compiler.bytecode.Bytecodes.ISTORE_2;

import static org.graalvm.compiler.bytecode.Bytecodes.ISTORE_3;

import static org.graalvm.compiler.bytecode.Bytecodes.ISUB;

import static org.graalvm.compiler.bytecode.Bytecodes.IUSHR;

import static org.graalvm.compiler.bytecode.Bytecodes.IXOR;

import static org.graalvm.compiler.bytecode.Bytecodes.JSR;

import static org.graalvm.compiler.bytecode.Bytecodes.JSR_W;

import static org.graalvm.compiler.bytecode.Bytecodes.L2D;

import static org.graalvm.compiler.bytecode.Bytecodes.L2F;

import static org.graalvm.compiler.bytecode.Bytecodes.L2I;

import static org.graalvm.compiler.bytecode.Bytecodes.LADD;

import static org.graalvm.compiler.bytecode.Bytecodes.LALOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.LAND;

import static org.graalvm.compiler.bytecode.Bytecodes.LASTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.LCMP;

import static org.graalvm.compiler.bytecode.Bytecodes.LCONST_0;

import static org.graalvm.compiler.bytecode.Bytecodes.LCONST_1;

import static org.graalvm.compiler.bytecode.Bytecodes.LDC;

import static org.graalvm.compiler.bytecode.Bytecodes.LDC2_W;

import static org.graalvm.compiler.bytecode.Bytecodes.LDC_W;

import static org.graalvm.compiler.bytecode.Bytecodes.LDIV;

import static org.graalvm.compiler.bytecode.Bytecodes.LLOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.LLOAD_0;

import static org.graalvm.compiler.bytecode.Bytecodes.LLOAD_1;

import static org.graalvm.compiler.bytecode.Bytecodes.LLOAD_2;

import static org.graalvm.compiler.bytecode.Bytecodes.LLOAD_3;

import static org.graalvm.compiler.bytecode.Bytecodes.LMUL;

import static org.graalvm.compiler.bytecode.Bytecodes.LNEG;

import static org.graalvm.compiler.bytecode.Bytecodes.LOOKUPSWITCH;

import static org.graalvm.compiler.bytecode.Bytecodes.LOR;

import static org.graalvm.compiler.bytecode.Bytecodes.LREM;

import static org.graalvm.compiler.bytecode.Bytecodes.LRETURN;

import static org.graalvm.compiler.bytecode.Bytecodes.LSHL;

import static org.graalvm.compiler.bytecode.Bytecodes.LSHR;

import static org.graalvm.compiler.bytecode.Bytecodes.LSTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.LSTORE_0;

import static org.graalvm.compiler.bytecode.Bytecodes.LSTORE_1;

import static org.graalvm.compiler.bytecode.Bytecodes.LSTORE_2;

import static org.graalvm.compiler.bytecode.Bytecodes.LSTORE_3;

import static org.graalvm.compiler.bytecode.Bytecodes.LSUB;

import static org.graalvm.compiler.bytecode.Bytecodes.LUSHR;

import static org.graalvm.compiler.bytecode.Bytecodes.LXOR;

import static org.graalvm.compiler.bytecode.Bytecodes.MONITORENTER;

import static org.graalvm.compiler.bytecode.Bytecodes.MONITOREXIT;

import static org.graalvm.compiler.bytecode.Bytecodes.MULTIANEWARRAY;

import static org.graalvm.compiler.bytecode.Bytecodes.NEW;

import static org.graalvm.compiler.bytecode.Bytecodes.NEWARRAY;

import static org.graalvm.compiler.bytecode.Bytecodes.NOP;

import static org.graalvm.compiler.bytecode.Bytecodes.POP;

import static org.graalvm.compiler.bytecode.Bytecodes.POP2;

import static org.graalvm.compiler.bytecode.Bytecodes.PUTFIELD;

import static org.graalvm.compiler.bytecode.Bytecodes.PUTSTATIC;

import static org.graalvm.compiler.bytecode.Bytecodes.RET;

import static org.graalvm.compiler.bytecode.Bytecodes.RETURN;

import static org.graalvm.compiler.bytecode.Bytecodes.SALOAD;

import static org.graalvm.compiler.bytecode.Bytecodes.SASTORE;

import static org.graalvm.compiler.bytecode.Bytecodes.SIPUSH;

import static org.graalvm.compiler.bytecode.Bytecodes.SWAP;

import static org.graalvm.compiler.bytecode.Bytecodes.TABLESWITCH;

import static org.graalvm.compiler.bytecode.Bytecodes.WIDE;

import static org.graalvm.compiler.core.common.GraalOptions.SupportJsrBytecodes;

import java.util.ArrayDeque;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.TreeSet;

import jdk.internal.vm.compiler.collections.EconomicMap;

import jdk.internal.vm.compiler.collections.Equivalence;

import org.graalvm.compiler.bytecode.Bytecode;

import org.graalvm.compiler.bytecode.BytecodeLookupSwitch;

import org.graalvm.compiler.bytecode.BytecodeStream;

import org.graalvm.compiler.bytecode.BytecodeSwitch;

import org.graalvm.compiler.bytecode.BytecodeTableSwitch;

import org.graalvm.compiler.bytecode.Bytecodes;

import org.graalvm.compiler.core.common.PermanentBailoutException;

import org.graalvm.compiler.debug.DebugContext;

import org.graalvm.compiler.debug.GraalError;

import org.graalvm.compiler.options.OptionValues;

import jdk.vm.ci.code.BytecodeFrame;

import jdk.vm.ci.meta.ExceptionHandler;

/**

 * Builds a mapping between bytecodes and basic blocks and builds a conservative control flow graph

 * (CFG). It makes one linear pass over the bytecodes to build the CFG where it detects block

 * headers and connects them.

 * <p>

 * It also creates exception dispatch blocks for exception handling. These blocks are between a

 * bytecode that might throw an exception, and the actual exception handler entries, and are later

 * used to create the type checks with the exception handler catch types. If a bytecode is covered

 * by an exception handler, this bytecode ends the basic block. This guarantees that a) control flow

 * cannot be transferred to an exception dispatch block in the middle of a block, and b) that every

 * block has at most one exception dispatch block (which is always the last entry in the successor

 * list).

 * <p>

 * If a bytecode is covered by multiple exception handlers, a chain of exception dispatch blocks is

 * created so that multiple exception handler types can be checked. The chains are re-used if

 * multiple bytecodes are covered by the same exception handlers.

 * <p>

 * Note that exception unwinds, i.e., bytecodes that can throw an exception but the exception is not

 * handled in this method, do not end a basic block. Not modeling the exception unwind block reduces

 * the complexity of the CFG, and there is no algorithm yet where the exception unwind block would

 * matter.

 * <p>

 * The class also handles subroutines (jsr and ret bytecodes): subroutines are inlined by

 * duplicating the subroutine blocks. This is limited to simple, structured subroutines with a

 * maximum subroutine nesting of 4. Otherwise, a bailout is thrown.

 * <p>

 * Loops in the methods are detected. If a method contains an irreducible loop (a loop with more

 * than one entry), a bailout is thrown. This simplifies the compiler later on since only structured

 * loops need to be supported.

 * <p>

 * A data flow analysis computes the live local variables from the point of view of the interpreter.

 * The result is used later to prune frame states, i.e., remove local variable entries that are

 * guaranteed to be never used again (even in the case of deoptimization).

 * <p>

 * The algorithms and analysis in this class are conservative and do not use any assumptions or

 * profiling information.

 */

public final class BciBlockMapping {

    public static class BciBlock implements Cloneable {

        int id;

        final int startBci;

        int endBci; // The bci of the last bytecode in the block

        private boolean isExceptionEntry;

        private boolean isLoopHeader;

        int loopId;

        int loopEnd;

        List<BciBlock> successors;

        private int predecessorCount;

        private boolean visited;

        private boolean active;

        long loops;

        JSRData jsrData;

        public static class JSRData implements Cloneable {

            public EconomicMap<JsrScope, BciBlock> jsrAlternatives;

            public JsrScope jsrScope = JsrScope.EMPTY_SCOPE;

            public BciBlock jsrSuccessor;

            public int jsrReturnBci;

            public BciBlock retSuccessor;

            public boolean endsWithRet = false;

            public JSRData copy() {

                try {

                    return (JSRData) this.clone();

                } catch (CloneNotSupportedException e) {

                    return null;

                }

            }

        }

        BciBlock(int startBci) {

            this.startBci = startBci;

            this.successors = new ArrayList<>();

        }

        public int getStartBci() {

            return startBci;

        }

        public int getEndBci() {

            return endBci;

        }

        public long getLoops() {

            return loops;

        }

        public BciBlock exceptionDispatchBlock() {

            if (successors.size() > 0 && successors.get(successors.size() - 1) instanceof ExceptionDispatchBlock) {

                return successors.get(successors.size() - 1);

            }

            return null;

        }

        public int getId() {

            return id;

        }

        public int getPredecessorCount() {

            return this.predecessorCount;

        }

        public int numNormalSuccessors() {

            if (exceptionDispatchBlock() != null) {

                return successors.size() - 1;

            }

            return successors.size();

        }

        public BciBlock copy() {

            try {

                BciBlock block = (BciBlock) super.clone();

                if (block.jsrData != null) {

                    block.jsrData = block.jsrData.copy();

                }

                block.successors = new ArrayList<>(successors);

                return block;

            } catch (CloneNotSupportedException e) {

                throw new RuntimeException(e);

            }

        }

        @Override

        public String toString() {

            StringBuilder sb = new StringBuilder("B").append(getId());

            sb.append('[').append(startBci).append("..").append(endBci);

            if (isLoopHeader || isExceptionEntry || this instanceof ExceptionDispatchBlock) {

                sb.append(' ');

                if (isLoopHeader) {

                    sb.append('L');

                }

                if (isExceptionEntry) {

                    sb.append('!');

                } else if (this instanceof ExceptionDispatchBlock) {

                    sb.append("<!>");

                }

            }

            sb.append(']');

            return sb.toString();

        }

        public int getLoopDepth() {

            return Long.bitCount(loops);

        }

        public boolean isLoopHeader() {

            return isLoopHeader;

        }

        public boolean isExceptionEntry() {

            return isExceptionEntry;

        }

        public BciBlock getSuccessor(int index) {

            return successors.get(index);

        }

        /**

         * Get the loop id of the inner most loop.

         *

         * @return the loop id of the most inner loop or -1 if not part of any loop

         */

        public int getLoopId() {

            long l = loops;

            if (l == 0) {

                return -1;

            }

            int pos = 0;

            for (int lMask = 1; (l & lMask) == 0; lMask = lMask << 1) {

                pos++;

            }

            return pos;

        }

        /**

         * Iterate over loop ids.

         */

        public Iterable<Integer> loopIdIterable() {

            return new Iterable<Integer>() {

                @Override

                public Iterator<Integer> iterator() {

                    return idIterator(loops);

                }

            };

        }

        private static Iterator<Integer> idIterator(long field) {

            return new Iterator<Integer>() {

                long l = field;

                int pos = 0;

                int lMask = 1;

                @Override

                public Integer next() {

                    for (; (l & lMask) == 0; lMask = lMask << 1) {

                        pos++;

                    }

                    l &= ~lMask;

                    return pos;

                }

                @Override

                public boolean hasNext() {

                    return l != 0;

                }

            };

        }

        public double probability() {

            return 1D;

        }

        public BciBlock getPostdominator() {

            return null;

        }

        private JSRData getOrCreateJSRData() {

            if (jsrData == null) {

                jsrData = new JSRData();

            }

            return jsrData;

        }

        void setEndsWithRet() {

            getOrCreateJSRData().endsWithRet = true;

        }

        public JsrScope getJsrScope() {

            if (this.jsrData == null) {

                return JsrScope.EMPTY_SCOPE;

            } else {

                return jsrData.jsrScope;

            }

        }

        public boolean endsWithRet() {

            if (this.jsrData == null) {

                return false;

            } else {

                return jsrData.endsWithRet;

            }

        }

        void setRetSuccessor(BciBlock bciBlock) {

            this.getOrCreateJSRData().retSuccessor = bciBlock;

        }

        public BciBlock getRetSuccessor() {

            if (this.jsrData == null) {

                return null;