jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Flow.java

-:3c02d2f1a421
+:2ca9e7d50136
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.code.Symbol.*;
-import com.sun.tools.javac.comp.Resolve;
 import com.sun.tools.javac.tree.JCTree.*;
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.Flags.BLOCK;
 import static com.sun.tools.javac.code.Kinds.*;
 allowImprovedCatchAnalysis = source.allowImprovedCatchAnalysis();
 allowEffectivelyFinalInInnerClasses = source.allowEffectivelyFinalInInnerClasses();
 }
 /**
+* Utility method to reset several Bits instances.
+*/
+private void resetBits(Bits... bits) {
+for (Bits b : bits) {
+b.reset();
+}
+}
+/**
 * Base visitor class for all visitors implementing dataflow analysis logic.
 * This class define the shared logic for handling jumps (break/continue statements).
 */
 static abstract class BaseAnalyzer<P extends BaseAnalyzer.PendingExit> extends TreeScanner {
 */
 class AssignAnalyzer extends BaseAnalyzer<AssignAnalyzer.AssignPendingExit> {
 /** The set of definitely assigned variables.
 */
-Bits inits;
+final Bits inits;
 /** The set of definitely unassigned variables.
 */
-Bits uninits;
+final Bits uninits;
 /** The set of variables that are definitely unassigned everywhere
 *  in current try block. This variable is maintained lazily; it is
 *  updated only when something gets removed from uninits,
 *  typically by being assigned in reachable code.  To obtain the
 *  correct set of variables which are definitely unassigned
 *  anywhere in current try block, intersect uninitsTry and
 *  uninits.
 */
-Bits uninitsTry;
+final Bits uninitsTry;
 /** When analyzing a condition, inits and uninits are null.
 *  Instead we have:
 */
-Bits initsWhenTrue;
+final Bits initsWhenTrue;
-Bits initsWhenFalse;
+final Bits initsWhenFalse;
-Bits uninitsWhenTrue;
+final Bits uninitsWhenTrue;
-Bits uninitsWhenFalse;
+final Bits uninitsWhenFalse;
 /** A mapping from addresses to variable symbols.
 */
 VarSymbol[] vars;
 FlowKind flowKind = FlowKind.NORMAL;
 /** The starting position of the analysed tree */
 int startPos;
+AssignAnalyzer() {
+inits = new Bits();
+uninits = new Bits();
+uninitsTry = new Bits();
+initsWhenTrue = new Bits(true);
+initsWhenFalse = new Bits(true);
+uninitsWhenTrue = new Bits(true);
+uninitsWhenFalse = new Bits(true);
+}
 class AssignPendingExit extends BaseAnalyzer.PendingExit {
-Bits exit_inits;
+final Bits exit_inits = new Bits(true);
-Bits exit_uninits;
+final Bits exit_uninits = new Bits(true);
-AssignPendingExit(JCTree tree, Bits inits, Bits uninits) {
+AssignPendingExit(JCTree tree, final Bits inits, final Bits uninits) {
 super(tree);
-this.exit_inits = inits.dup();
+this.exit_inits.assign(inits);
-this.exit_uninits = uninits.dup();
+this.exit_uninits.assign(uninits);
 }
 void resolveJump() {
 inits.andSet(exit_inits);
 uninits.andSet(exit_uninits);
 }
 /** Split (duplicate) inits/uninits into WhenTrue/WhenFalse sets
 */
 void split(boolean setToNull) {
-initsWhenFalse = inits.dup();
+initsWhenFalse.assign(inits);
-uninitsWhenFalse = uninits.dup();
+uninitsWhenFalse.assign(uninits);
-initsWhenTrue = inits;
+initsWhenTrue.assign(inits);
-uninitsWhenTrue = uninits;
+uninitsWhenTrue.assign(uninits);
-if (setToNull)
+if (setToNull) {
-inits = uninits = null;
+resetBits(inits, uninits);
+}
 }
 /** Merge (intersect) inits/uninits from WhenTrue/WhenFalse sets.
 */
 void merge() {
-inits = initsWhenFalse.andSet(initsWhenTrue);
+inits.assign(initsWhenFalse.andSet(initsWhenTrue));
-uninits = uninitsWhenFalse.andSet(uninitsWhenTrue);
+uninits.assign(uninitsWhenFalse.andSet(uninitsWhenTrue));
 }
 /* ************************************************************************
 * Visitor methods for statements and definitions
 *************************************************************************/
 *  (un)initsWhenTrue(WhenFalse) on exit.
 */
 void scanExpr(JCTree tree) {
 if (tree != null) {
 scan(tree);
-if (inits == null) merge();
+if (inits.isReset()) merge();
 }
 }
 /** Analyze a list of expressions.
 */
 /** Analyze a condition. Make sure to set (un)initsWhenTrue(WhenFalse)
 *  rather than (un)inits on exit.
 */
 void scanCond(JCTree tree) {
 if (tree.type.isFalse()) {
-if (inits == null) merge();
+if (inits.isReset()) merge();
-initsWhenTrue = inits.dup();
+initsWhenTrue.assign(inits);
 initsWhenTrue.inclRange(firstadr, nextadr);
-uninitsWhenTrue = uninits.dup();
+uninitsWhenTrue.assign(uninits);
 uninitsWhenTrue.inclRange(firstadr, nextadr);
-initsWhenFalse = inits;
+initsWhenFalse.assign(inits);
-uninitsWhenFalse = uninits;
+uninitsWhenFalse.assign(uninits);
 } else if (tree.type.isTrue()) {
-if (inits == null) merge();
+if (inits.isReset()) merge();
-initsWhenFalse = inits.dup();
+initsWhenFalse.assign(inits);
 initsWhenFalse.inclRange(firstadr, nextadr);
-uninitsWhenFalse = uninits.dup();
+uninitsWhenFalse.assign(uninits);
 uninitsWhenFalse.inclRange(firstadr, nextadr);
-initsWhenTrue = inits;
+initsWhenTrue.assign(inits);
-uninitsWhenTrue = uninits;
+uninitsWhenTrue.assign(uninits);
 } else {
 scan(tree);
-if (inits != null)
+if (!inits.isReset())
 split(tree.type != syms.unknownType);
 }
-if (tree.type != syms.unknownType)
+if (tree.type != syms.unknownType) {
-inits = uninits = null;
+resetBits(inits, uninits);
+}
 }
 /* ------------ Visitor methods for various sorts of trees -------------*/
 public void visitClassDef(JCClassDecl tree) {
 }
 public void visitMethodDef(JCMethodDecl tree) {
 if (tree.body == null) return;
-Bits initsPrev = inits.dup();
+final Bits initsPrev = new Bits(inits);
-Bits uninitsPrev = uninits.dup();
+final Bits uninitsPrev = new Bits(uninits);
 int nextadrPrev = nextadr;
 int firstadrPrev = firstadr;
 int returnadrPrev = returnadr;
 Lint lintPrev = lint;
 while (exits.nonEmpty()) {
 AssignPendingExit exit = exits.head;
 exits = exits.tail;
 Assert.check(exit.tree.hasTag(RETURN), exit.tree);
 if (isInitialConstructor) {
-inits = exit.exit_inits;
+inits.assign(exit.exit_inits);
 for (int i = firstadr; i < nextadr; i++)
 checkInit(exit.tree.pos(), vars[i]);
 }
 }
 } finally {
-inits = initsPrev;
+inits.assign(initsPrev);
-uninits = uninitsPrev;
+uninits.assign(uninitsPrev);
 nextadr = nextadrPrev;
 firstadr = firstadrPrev;
 returnadr = returnadrPrev;
 lint = lintPrev;
 }
 public void visitDoLoop(JCDoWhileLoop tree) {
 ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
 FlowKind prevFlowKind = flowKind;
 flowKind = FlowKind.NORMAL;
-Bits initsSkip = null;
+final Bits initsSkip = new Bits(true);
-Bits uninitsSkip = null;
+final Bits uninitsSkip = new Bits(true);
 pendingExits = new ListBuffer<AssignPendingExit>();
 int prevErrors = log.nerrors;
 do {
-Bits uninitsEntry = uninits.dup();
+final Bits uninitsEntry = new Bits(uninits);
 uninitsEntry.excludeFrom(nextadr);
 scan(tree.body);
 resolveContinues(tree);
 scanCond(tree.cond);
 if (!flowKind.isFinal()) {
-initsSkip = initsWhenFalse;
+initsSkip.assign(initsWhenFalse);
-uninitsSkip = uninitsWhenFalse;
+uninitsSkip.assign(uninitsWhenFalse);
 }
 if (log.nerrors !=  prevErrors ||
 flowKind.isFinal() ||
-uninitsEntry.dup().diffSet(uninitsWhenTrue).nextBit(firstadr)==-1)
+new Bits(uninitsEntry).diffSet(uninitsWhenTrue).nextBit(firstadr)==-1)
 break;
-inits = initsWhenTrue;
+inits.assign(initsWhenTrue);
-uninits = uninitsEntry.andSet(uninitsWhenTrue);
+uninits.assign(uninitsEntry.andSet(uninitsWhenTrue));
 flowKind = FlowKind.SPECULATIVE_LOOP;
 } while (true);
 flowKind = prevFlowKind;
-inits = initsSkip;
+inits.assign(initsSkip);
-uninits = uninitsSkip;
+uninits.assign(uninitsSkip);
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitWhileLoop(JCWhileLoop tree) {
 ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
 FlowKind prevFlowKind = flowKind;
 flowKind = FlowKind.NORMAL;
-Bits initsSkip = null;
+final Bits initsSkip = new Bits(true);
-Bits uninitsSkip = null;
+final Bits uninitsSkip = new Bits(true);
 pendingExits = new ListBuffer<AssignPendingExit>();
 int prevErrors = log.nerrors;
-Bits uninitsEntry = uninits.dup();
+final Bits uninitsEntry = new Bits(uninits);
 uninitsEntry.excludeFrom(nextadr);
 do {
 scanCond(tree.cond);
 if (!flowKind.isFinal()) {
-initsSkip = initsWhenFalse;
+initsSkip.assign(initsWhenFalse) ;
-uninitsSkip = uninitsWhenFalse;
+uninitsSkip.assign(uninitsWhenFalse);
 }
-inits = initsWhenTrue;
+inits.assign(initsWhenTrue);
-uninits = uninitsWhenTrue;
+uninits.assign(uninitsWhenTrue);
 scan(tree.body);
 resolveContinues(tree);
 if (log.nerrors != prevErrors ||
 flowKind.isFinal() ||
-uninitsEntry.dup().diffSet(uninits).nextBit(firstadr) == -1)
+new Bits(uninitsEntry).diffSet(uninits).nextBit(firstadr) == -1)
 break;
-uninits = uninitsEntry.andSet(uninits);
+uninits.assign(uninitsEntry.andSet(uninits));
 flowKind = FlowKind.SPECULATIVE_LOOP;
 } while (true);
 flowKind = prevFlowKind;
 //a variable is DA/DU after the while statement, if it's DA/DU assuming the
 //branch is not taken AND if it's DA/DU before any break statement
-inits = initsSkip;
+inits.assign(initsSkip);
-uninits = uninitsSkip;
+uninits.assign(uninitsSkip);
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitForLoop(JCForLoop tree) {
 ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
 FlowKind prevFlowKind = flowKind;
 flowKind = FlowKind.NORMAL;
 int nextadrPrev = nextadr;
 scan(tree.init);
-Bits initsSkip = null;
+final Bits initsSkip = new Bits(true);
-Bits uninitsSkip = null;
+final Bits uninitsSkip = new Bits(true);
 pendingExits = new ListBuffer<AssignPendingExit>();
 int prevErrors = log.nerrors;
 do {
-Bits uninitsEntry = uninits.dup();
+final Bits uninitsEntry = new Bits(uninits);
 uninitsEntry.excludeFrom(nextadr);
 if (tree.cond != null) {
 scanCond(tree.cond);
 if (!flowKind.isFinal()) {
-initsSkip = initsWhenFalse;
+initsSkip.assign(initsWhenFalse);
-uninitsSkip = uninitsWhenFalse;
+uninitsSkip.assign(uninitsWhenFalse);
 }
-inits = initsWhenTrue;
+inits.assign(initsWhenTrue);
-uninits = uninitsWhenTrue;
+uninits.assign(uninitsWhenTrue);
 } else if (!flowKind.isFinal()) {
-initsSkip = inits.dup();
+initsSkip.assign(inits);
 initsSkip.inclRange(firstadr, nextadr);
-uninitsSkip = uninits.dup();
+uninitsSkip.assign(uninits);
 uninitsSkip.inclRange(firstadr, nextadr);
 }
 scan(tree.body);
 resolveContinues(tree);
 scan(tree.step);
 if (log.nerrors != prevErrors ||
 flowKind.isFinal() ||
-uninitsEntry.dup().diffSet(uninits).nextBit(firstadr) == -1)
+new Bits(uninitsEntry).diffSet(uninits).nextBit(firstadr) == -1)
 break;
-uninits = uninitsEntry.andSet(uninits);
+uninits.assign(uninitsEntry.andSet(uninits));
 flowKind = FlowKind.SPECULATIVE_LOOP;
 } while (true);
 flowKind = prevFlowKind;
 //a variable is DA/DU after a for loop, if it's DA/DU assuming the
 //branch is not taken AND if it's DA/DU before any break statement
-inits = initsSkip;
+inits.assign(initsSkip);
-uninits = uninitsSkip;
+uninits.assign(uninitsSkip);
 resolveBreaks(tree, prevPendingExits);
 nextadr = nextadrPrev;
 }
 public void visitForeachLoop(JCEnhancedForLoop tree) {
 ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
 FlowKind prevFlowKind = flowKind;
 flowKind = FlowKind.NORMAL;
 int nextadrPrev = nextadr;
 scan(tree.expr);
-Bits initsStart = inits.dup();
+final Bits initsStart = new Bits(inits);
-Bits uninitsStart = uninits.dup();
+final Bits uninitsStart = new Bits(uninits);
 letInit(tree.pos(), tree.var.sym);
 pendingExits = new ListBuffer<AssignPendingExit>();
 int prevErrors = log.nerrors;
 do {
-Bits uninitsEntry = uninits.dup();
+final Bits uninitsEntry = new Bits(uninits);
 uninitsEntry.excludeFrom(nextadr);
 scan(tree.body);
 resolveContinues(tree);
 if (log.nerrors != prevErrors ||
 flowKind.isFinal() ||
-uninitsEntry.dup().diffSet(uninits).nextBit(firstadr) == -1)
+new Bits(uninitsEntry).diffSet(uninits).nextBit(firstadr) == -1)
 break;
-uninits = uninitsEntry.andSet(uninits);
+uninits.assign(uninitsEntry.andSet(uninits));
 flowKind = FlowKind.SPECULATIVE_LOOP;
 } while (true);
 flowKind = prevFlowKind;
-inits = initsStart;
+inits.assign(initsStart);
-uninits = uninitsStart.andSet(uninits);
+uninits.assign(uninitsStart.andSet(uninits));
 resolveBreaks(tree, prevPendingExits);
 nextadr = nextadrPrev;
 }
 public void visitLabelled(JCLabeledStatement tree) {
 public void visitSwitch(JCSwitch tree) {
 ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<AssignPendingExit>();
 int nextadrPrev = nextadr;
 scanExpr(tree.selector);
-Bits initsSwitch = inits;
+final Bits initsSwitch = new Bits(inits);
-Bits uninitsSwitch = uninits.dup();
+final Bits uninitsSwitch = new Bits(uninits);
 boolean hasDefault = false;
 for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
-inits = initsSwitch.dup();
+inits.assign(initsSwitch);
-uninits = uninits.andSet(uninitsSwitch);
+uninits.assign(uninits.andSet(uninitsSwitch));
 JCCase c = l.head;
 if (c.pat == null)
 hasDefault = true;
 else
 scanExpr(c.pat);
 resolveBreaks(tree, prevPendingExits);
 nextadr = nextadrPrev;
 }
 // where
 /** Add any variables defined in stats to inits and uninits. */
-private void addVars(List<JCStatement> stats, Bits inits,
+private void addVars(List<JCStatement> stats, final Bits inits,
-Bits uninits) {
+final Bits uninits) {
 for (;stats.nonEmpty(); stats = stats.tail) {
 JCTree stat = stats.head;
 if (stat.hasTag(VARDEF)) {
 int adr = ((JCVariableDecl) stat).sym.adr;
 inits.excl(adr);
 }
 }
 public void visitTry(JCTry tree) {
 ListBuffer<JCVariableDecl> resourceVarDecls = ListBuffer.lb();
-Bits uninitsTryPrev = uninitsTry;
+final Bits uninitsTryPrev = new Bits(uninitsTry);
 ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<AssignPendingExit>();
-Bits initsTry = inits.dup();
+final Bits initsTry = new Bits(inits);
-uninitsTry = uninits.dup();
+uninitsTry.assign(uninits);
 for (JCTree resource : tree.resources) {
 if (resource instanceof JCVariableDecl) {
 JCVariableDecl vdecl = (JCVariableDecl) resource;
 visitVarDef(vdecl);
 unrefdResources.enter(vdecl.sym);
 throw new AssertionError(tree);  // parser error
 }
 }
 scan(tree.body);
 uninitsTry.andSet(uninits);
-Bits initsEnd = inits;
+final Bits initsEnd = new Bits(inits);
-Bits uninitsEnd = uninits;
+final Bits uninitsEnd = new Bits(uninits);
 int nextadrCatch = nextadr;
 if (!resourceVarDecls.isEmpty() &&
 lint.isEnabled(Lint.LintCategory.TRY)) {
 for (JCVariableDecl resVar : resourceVarDecls) {
 }
 }
 for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
 JCVariableDecl param = l.head.param;
-inits = initsTry.dup();
+inits.assign(initsTry);
-uninits = uninitsTry.dup();
+uninits.assign(uninitsTry);
 scan(param);
 inits.incl(param.sym.adr);
 uninits.excl(param.sym.adr);
 scan(l.head.body);
 initsEnd.andSet(inits);
 uninitsEnd.andSet(uninits);
 nextadr = nextadrCatch;
 }
 if (tree.finalizer != null) {
-inits = initsTry.dup();
+inits.assign(initsTry);
-uninits = uninitsTry.dup();
+uninits.assign(uninitsTry);
 ListBuffer<AssignPendingExit> exits = pendingExits;
 pendingExits = prevPendingExits;
 scan(tree.finalizer);
 if (!tree.finallyCanCompleteNormally) {
 // discard exits and exceptions from try and finally
 pendingExits.append(exit);
 }
 inits.orSet(initsEnd);
 }
 } else {
-inits = initsEnd;
+inits.assign(initsEnd);
-uninits = uninitsEnd;
+uninits.assign(uninitsEnd);
 ListBuffer<AssignPendingExit> exits = pendingExits;
 pendingExits = prevPendingExits;
 while (exits.nonEmpty()) pendingExits.append(exits.next());
 }
 uninitsTry.andSet(uninitsTryPrev).andSet(uninits);
 }
 public void visitConditional(JCConditional tree) {
 scanCond(tree.cond);
-Bits initsBeforeElse = initsWhenFalse;
+final Bits initsBeforeElse = new Bits(initsWhenFalse);
-Bits uninitsBeforeElse = uninitsWhenFalse;
+final Bits uninitsBeforeElse = new Bits(uninitsWhenFalse);
-inits = initsWhenTrue;
+inits.assign(initsWhenTrue);
-uninits = uninitsWhenTrue;
+uninits.assign(uninitsWhenTrue);
 if (tree.truepart.type.hasTag(BOOLEAN) &&
 tree.falsepart.type.hasTag(BOOLEAN)) {
 // if b and c are boolean valued, then
 // v is (un)assigned after a?b:c when true iff
 //    v is (un)assigned after b when true and
 //    v is (un)assigned after c when true
 scanCond(tree.truepart);
-Bits initsAfterThenWhenTrue = initsWhenTrue.dup();
+final Bits initsAfterThenWhenTrue = new Bits(initsWhenTrue);
-Bits initsAfterThenWhenFalse = initsWhenFalse.dup();
+final Bits initsAfterThenWhenFalse = new Bits(initsWhenFalse);
-Bits uninitsAfterThenWhenTrue = uninitsWhenTrue.dup();
+final Bits uninitsAfterThenWhenTrue = new Bits(uninitsWhenTrue);
-Bits uninitsAfterThenWhenFalse = uninitsWhenFalse.dup();
+final Bits uninitsAfterThenWhenFalse = new Bits(uninitsWhenFalse);
-inits = initsBeforeElse;
+inits.assign(initsBeforeElse);
-uninits = uninitsBeforeElse;
+uninits.assign(uninitsBeforeElse);
 scanCond(tree.falsepart);
 initsWhenTrue.andSet(initsAfterThenWhenTrue);
 initsWhenFalse.andSet(initsAfterThenWhenFalse);
 uninitsWhenTrue.andSet(uninitsAfterThenWhenTrue);
 uninitsWhenFalse.andSet(uninitsAfterThenWhenFalse);
 } else {
 scanExpr(tree.truepart);
-Bits initsAfterThen = inits.dup();
+final Bits initsAfterThen = new Bits(inits);
-Bits uninitsAfterThen = uninits.dup();
+final Bits uninitsAfterThen = new Bits(uninits);
-inits = initsBeforeElse;
+inits.assign(initsBeforeElse);
-uninits = uninitsBeforeElse;
+uninits.assign(uninitsBeforeElse);
 scanExpr(tree.falsepart);
 inits.andSet(initsAfterThen);
 uninits.andSet(uninitsAfterThen);
 }
 }
 public void visitIf(JCIf tree) {
 scanCond(tree.cond);
-Bits initsBeforeElse = initsWhenFalse;
+final Bits initsBeforeElse = new Bits(initsWhenFalse);
-Bits uninitsBeforeElse = uninitsWhenFalse;
+final Bits uninitsBeforeElse = new Bits(uninitsWhenFalse);
-inits = initsWhenTrue;
+inits.assign(initsWhenTrue);
-uninits = uninitsWhenTrue;
+uninits.assign(uninitsWhenTrue);
 scan(tree.thenpart);
 if (tree.elsepart != null) {
-Bits initsAfterThen = inits.dup();
+final Bits initsAfterThen = new Bits(inits);
-Bits uninitsAfterThen = uninits.dup();
+final Bits uninitsAfterThen = new Bits(uninits);
-inits = initsBeforeElse;
+inits.assign(initsBeforeElse);
-uninits = uninitsBeforeElse;
+uninits.assign(uninitsBeforeElse);
 scan(tree.elsepart);
 inits.andSet(initsAfterThen);
 uninits.andSet(uninitsAfterThen);
 } else {
 inits.andSet(initsBeforeElse);
 scan(tree.def);
 }
 @Override
 public void visitLambda(JCLambda tree) {
-Bits prevUninits = uninits;
+final Bits prevUninits = new Bits(uninits);
-Bits prevInits = inits;
+final Bits prevInits = new Bits(inits);
 int returnadrPrev = returnadr;
 ListBuffer<AssignPendingExit> prevPending = pendingExits;
 try {
 returnadr = nextadr;
 pendingExits = new ListBuffer<AssignPendingExit>();
 scan(tree.body);
 }
 }
 finally {
 returnadr = returnadrPrev;
-uninits = prevUninits;
+uninits.assign(prevUninits);
-inits = prevInits;
+inits.assign(prevInits);
 pendingExits = prevPending;
 }
 }
 public void visitNewArray(JCNewArray tree) {
 scanExprs(tree.dims);
 scanExprs(tree.elems);
 }
 public void visitAssert(JCAssert tree) {
-Bits initsExit = inits.dup();
+final Bits initsExit = new Bits(inits);
-Bits uninitsExit = uninits.dup();
+final Bits uninitsExit = new Bits(uninits);
 scanCond(tree.cond);
 uninitsExit.andSet(uninitsWhenTrue);
 if (tree.detail != null) {
-inits = initsWhenFalse;
+inits.assign(initsWhenFalse);
-uninits = uninitsWhenFalse;
+uninits.assign(uninitsWhenFalse);
 scanExpr(tree.detail);
 }
-inits = initsExit;
+inits.assign(initsExit);
-uninits = uninitsExit;
+uninits.assign(uninitsExit);
 }
 public void visitAssign(JCAssign tree) {
 JCTree lhs = TreeInfo.skipParens(tree.lhs);
 if (!(lhs instanceof JCIdent)) {
 public void visitUnary(JCUnary tree) {
 switch (tree.getTag()) {
 case NOT:
 scanCond(tree.arg);
-Bits t = initsWhenFalse;
+final Bits t = new Bits(initsWhenFalse);
-initsWhenFalse = initsWhenTrue;
+initsWhenFalse.assign(initsWhenTrue);
-initsWhenTrue = t;
+initsWhenTrue.assign(t);
-t = uninitsWhenFalse;
+t.assign(uninitsWhenFalse);
-uninitsWhenFalse = uninitsWhenTrue;
+uninitsWhenFalse.assign(uninitsWhenTrue);
-uninitsWhenTrue = t;
+uninitsWhenTrue.assign(t);
 break;
 case PREINC: case POSTINC:
 case PREDEC: case POSTDEC:
 scanExpr(tree.arg);
 letInit(tree.arg);
 public void visitBinary(JCBinary tree) {
 switch (tree.getTag()) {
 case AND:
 scanCond(tree.lhs);
-Bits initsWhenFalseLeft = initsWhenFalse;
+final Bits initsWhenFalseLeft = new Bits(initsWhenFalse);
-Bits uninitsWhenFalseLeft = uninitsWhenFalse;
+final Bits uninitsWhenFalseLeft = new Bits(uninitsWhenFalse);
-inits = initsWhenTrue;
+inits.assign(initsWhenTrue);
-uninits = uninitsWhenTrue;
+uninits.assign(uninitsWhenTrue);
 scanCond(tree.rhs);
 initsWhenFalse.andSet(initsWhenFalseLeft);
 uninitsWhenFalse.andSet(uninitsWhenFalseLeft);
 break;
 case OR:
 scanCond(tree.lhs);
-Bits initsWhenTrueLeft = initsWhenTrue;
+final Bits initsWhenTrueLeft = new Bits(initsWhenTrue);
-Bits uninitsWhenTrueLeft = uninitsWhenTrue;
+final Bits uninitsWhenTrueLeft = new Bits(uninitsWhenTrue);
-inits = initsWhenFalse;
+inits.assign(initsWhenFalse);
-uninits = uninitsWhenFalse;
+uninits.assign(uninitsWhenFalse);
 scanCond(tree.rhs);
 initsWhenTrue.andSet(initsWhenTrueLeft);
 uninitsWhenTrue.andSet(uninitsWhenTrueLeft);
 break;
 default:
 public void analyzeTree(Env<AttrContext> env, JCTree tree, TreeMaker make) {
 try {
 attrEnv = env;
 Flow.this.make = make;
 startPos = tree.pos().getStartPosition();
-inits = new Bits();
-uninits = new Bits();
-uninitsTry = new Bits();
-initsWhenTrue = initsWhenFalse =
-uninitsWhenTrue = uninitsWhenFalse = null;
 if (vars == null)
 vars = new VarSymbol[32];
 else
 for (int i=0; i<vars.length; i++)
 vars[i] = null;
 unrefdResources = new Scope(env.enclClass.sym);
 scan(tree);
 } finally {
 // note that recursive invocations of this method fail hard
 startPos = -1;
-inits = uninits = uninitsTry = null;
+resetBits(inits, uninits, uninitsTry, initsWhenTrue,
-initsWhenTrue = initsWhenFalse =
+initsWhenFalse, uninitsWhenTrue, uninitsWhenFalse);
-uninitsWhenTrue = uninitsWhenFalse = null;
 if (vars != null) for (int i=0; i<vars.length; i++)
 vars[i] = null;
 firstadr = 0;
 nextadr = 0;
 pendingExits = null;

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/Flow.java

src/share/classes/com/sun/tools/javac/comp/Flow.java