private void updateKillGenSet(String methodName, StoreStmt stmt, BlockDataFlowState bFlow) {
    if (stmt == null) return;

    BitSet gen = bFlow.getGen();

    gen.set(this.uniqueGlobals.get(methodName).indexOf(stmt.getVariable()));
  }
  private void updateKillGenSet(String methodName, CallStmt stmt, BlockDataFlowState bFlow) {
    if (stmt.getMethodLabel().equals(ProgramFlattener.exceptionHandlerLabel)) return;

    // Kill all stores!
    for (int i = 0; i < bFlow.getOut().size(); i++) {
      if (bFlow.getOut().get(i)) {
        bFlow.getKill().set(i);
      }
    }

    bFlow.getGen().clear();
  }
  public void updateKillGenSet(String methodName, QuadrupletStmt stmt, BlockDataFlowState bFlow) {
    if (stmt == null) return;

    BitSet out = bFlow.getOut();
    BitSet gen = bFlow.getGen();
    BitSet kill = bFlow.getKill();

    for (Name name : this.uniqueGlobals.get(methodName)) {
      int i = this.uniqueGlobals.get(methodName).indexOf(name);

      boolean resetName = false;

      if (name.isArray()) {
        Name myName = name;

        do {
          ArrayName array = (ArrayName) myName;
          if (array.getIndex().equals(stmt.getDestination())) { // Index being reassigned, KILL!
            resetName = true;
          }

          myName = array.getIndex();

        } while (myName.isArray());

        if (stmt.getDestination().isArray()) {
          ArrayName dest = (ArrayName) stmt.getDestination();
          ArrayName arrName = (ArrayName) name;
          if (dest.getIndex().getClass().equals(ConstantName.class)
              && !arrName.getIndex().getClass().equals(ConstantName.class)) {
            if (arrName.getId().equals(dest.getId())) {
              resetName = true;
            }
          }
        }
      }

      if (resetName) {
        if (out.get(i)) {
          kill.set(i);
        }

        gen.clear(i);
      }

      if (name.equals(stmt.getDestination())) {
        gen.set(i);
      }
    }
  }
  private BlockDataFlowState generateDFState(CFGBlock block) {
    int totalGlobals = this.uniqueGlobals.get(block.getMethodName()).size();

    // Get the original inBitSet for this block
    BitSet origIn;
    if (this.cfgBlocksState.containsKey(block)) {
      origIn = this.cfgBlocksState.get(block).getIn();
    } else {
      origIn = new BitSet(totalGlobals);
      origIn.set(0, totalGlobals);
    }

    // Calculate the in BitSet by taking intersection of predecessors
    BlockDataFlowState bFlow = new BlockDataFlowState(totalGlobals);

    // If there exist at least one successor, set Out to all True
    if (block.getSuccessors().size() > 0) {
      bFlow.getOut().set(0, totalGlobals);
    }

    BitSet out = bFlow.getOut();
    for (CFGBlock pred : block.getSuccessors()) {
      if (this.cfgBlocksState.containsKey(pred)) {
        out.and(this.cfgBlocksState.get(pred).getIn());
      }
    }

    calculateGenKillSets(block, bFlow);

    // Calculate Out
    BitSet in = bFlow.getIn(); // IN = (OUT - KILL) U GEN
    in.or(out);
    in.xor(bFlow.getKill());
    in.or(bFlow.getGen());

    if (!in.equals(origIn)) {
      // Add successors to cfgBlocks list
      for (CFGBlock pred : block.getPredecessors()) {
        if (!cfgBlocksToProcess.contains(pred)) {
          cfgBlocksToProcess.add(pred);
        }
      }
    }

    // Remove this block, since it has been processed
    cfgBlocksToProcess.remove(block);

    return bFlow;
  }
  private void setExitBlock(String methodName) {
    for (CFGBlock block : this.mMap.get(methodName).getCfgBlocks()) {
      if (block.getSuccessors().size() == 0) {
        //				return block;
        CFGBlock exit = block;
        BlockDataFlowState entryBlockFlow =
            new BlockDataFlowState(
                this.uniqueGlobals.get(methodName).size()); // IN = GEN for entry block
        calculateGenKillSets(exit, entryBlockFlow);
        entryBlockFlow.setIn(entryBlockFlow.getGen());
        cfgBlocksToProcess.remove(exit);

        this.cfgBlocksState.put(exit, entryBlockFlow);
      }
    }
  }