code: private void markSubroutineWalk(final BitSet sub, final int index,
              final BitSet anyvisited) {
          if (LOGGING) {
              log("markSubroutineWalk: sub=" + sub + " index=" + index);
          }
  
          // First find those instructions reachable via normal execution
          markSubroutineWalkDFS(sub, index, anyvisited);
  
          // Now, make sure we also include any applicable exception handlers
          boolean loop = true;
          while (loop) {
              loop = false;
              for (Iterator<TryCatchBlockNode> it = tryCatchBlocks.iterator(); it
                      .hasNext();) {
                  TryCatchBlockNode trycatch = it.next();
  
                  if (LOGGING) {
                      // TODO use of default toString().
                      log("Scanning try/catch " + trycatch);
                  }
  
                  // If the handler has already been processed, skip it.
                  int handlerindex = instructions.indexOf(trycatch.handler);
                  if (sub.get(handlerindex)) {
                      continue;
                  }
  
                  int startindex = instructions.indexOf(trycatch.start);
                  int endindex = instructions.indexOf(trycatch.end);
                  int nextbit = sub.nextSetBit(startindex);
                  if (nextbit != -1 && nextbit < endindex) {
                      if (LOGGING) {
                          log("Adding exception handler: " + startindex + '-'
                                  + endindex + " due to " + nextbit + " handler "
                                  + handlerindex);
                      }
                      markSubroutineWalkDFS(sub, handlerindex, anyvisited);
                      loop = true;
                  }
              }
          }
      }
docs: Performs a depth first search walking the normal byte code path starting
  at <code>index</code>, and adding each instruction encountered into the
  subroutine <code>sub</code>. After this walk is complete, iterates over
  the exception handlers to ensure that we also include those byte codes
  which are reachable through an exception that may be thrown during the
  execution of the subroutine. Invoked from <code>markSubroutines()</code>.
  
  @param sub
  the subroutine whose instructions must be computed.
  @param index
  an instruction of this subroutine.
  @param anyvisited
  indexes of the already visited instructions, i.e. marked as
  part of this subroutine or any previously computed subroutine.