/*
* Copyright (c) 1994, 2003, 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. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* 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 sun.tools.tree;
import sun.tools.java.*;
import sun.tools.asm.Assembler;
import sun.tools.asm.Label;
import java.io.PrintStream;
import java.util.Hashtable;
/**
* WARNING: The contents of this source file are not part of any
* supported API. Code that depends on them does so at its own risk:
* they are subject to change or removal without notice.
*/
public
class IfStatement extends Statement {
Expression cond;
Statement ifTrue;
Statement ifFalse;
/**
* Constructor
*/
public IfStatement(long where, Expression cond, Statement ifTrue, Statement ifFalse) {
super(IF, where);
this.cond = cond;
this.ifTrue = ifTrue;
this.ifFalse = ifFalse;
}
/**
* Check statement
*/
Vset check(Environment env, Context ctx, Vset vset, Hashtable<Object, Object> exp) {
checkLabel(env, ctx);
CheckContext newctx = new CheckContext(ctx, this);
// Vset vsExtra = vset.copy(); // See comment below.
ConditionVars cvars =
cond.checkCondition(env, newctx, reach(env, vset), exp);
cond = convert(env, newctx, Type.tBoolean, cond);
// The following code, now deleted, was apparently an erroneous attempt
// at providing better error diagnostics. The comment read: 'If either
// the true clause or the false clause is unreachable, do a reasonable
// check on the child anyway.'
// Vset vsTrue = cvars.vsTrue.isDeadEnd() ? vsExtra : cvars.vsTrue;
// Vset vsFalse = cvars.vsFalse.isDeadEnd() ? vsExtra : cvars.vsFalse;
// Unfortunately, this violates the rules laid out in the JLS, and leads to
// blatantly incorrect results. For example, 'i' will not be recognized
// as definitely assigned following the statement 'if (true) i = 1;'.
// It is best to slavishly follow the JLS here. A cleverer approach could
// only correctly issue warnings, as JLS 16.2.6 is quite explicit, and it
// is OK for a dead branch of an if-statement to omit an assignment that
// would be required in the other branch. A complication: This code also
// had the effect of implementing the special-case rules for 'if-then' and
// 'if-then-else' in JLS 14.19, "Unreachable Statements". We now use
// 'Vset.clearDeadEnd' to remove the dead-end status of unreachable branches
// without affecting the definite-assignment status of the variables, thus
// maintaining a correct implementation of JLS 16.2.6. Fixes 4094353.
// Note that the code below will not consider the branches unreachable if
// the entire statement is unreachable. This is consistent with the error
// recovery policy that reports the only the first unreachable statement
// along an acyclic execution path.
Vset vsTrue = cvars.vsTrue.clearDeadEnd();
Vset vsFalse = cvars.vsFalse.clearDeadEnd();
vsTrue = ifTrue.check(env, newctx, vsTrue, exp);
if (ifFalse != null)
vsFalse = ifFalse.check(env, newctx, vsFalse, exp);
vset = vsTrue.join(vsFalse.join(newctx.vsBreak));
return ctx.removeAdditionalVars(vset);
}
/**
* Inline
*/
public Statement inline(Environment env, Context ctx) {
ctx = new Context(ctx, this);
cond = cond.inlineValue(env, ctx);
// The compiler currently needs to perform inlining on both
// branches of the if statement -- even if `cond' is a constant
// true or false. Why? The compiler will later try to compile
// all classes that it has seen; this includes classes that
// appear in dead code. If we don't inline the dead branch here
// then the compiler will never perform inlining on any local
// classes appearing on the dead code. When the compiler tries
// to compile an un-inlined local class with uplevel references,
// it dies. (bug 4059492)
//
// A better solution to this would be to walk the dead branch and
// mark any local classes appearing therein as unneeded. Then the
// compilation phase could skip these classes.
if (ifTrue != null) {
ifTrue = ifTrue.inline(env, ctx);
}
if (ifFalse != null) {
ifFalse = ifFalse.inline(env, ctx);
}
if (cond.equals(true)) {
return eliminate(env, ifTrue);
}
if (cond.equals(false)) {
return eliminate(env, ifFalse);
}
if ((ifTrue == null) && (ifFalse == null)) {
return eliminate(env, new ExpressionStatement(where, cond).inline(env, ctx));
}
if (ifTrue == null) {
cond = new NotExpression(cond.where, cond).inlineValue(env, ctx);
return eliminate(env, new IfStatement(where, cond, ifFalse, null));
}
return this;
}
/**
* Create a copy of the statement for method inlining
*/
public Statement copyInline(Context ctx, boolean valNeeded) {
IfStatement s = (IfStatement)clone();
s.cond = cond.copyInline(ctx);
if (ifTrue != null) {
s.ifTrue = ifTrue.copyInline(ctx, valNeeded);
}
if (ifFalse != null) {
s.ifFalse = ifFalse.copyInline(ctx, valNeeded);
}
return s;
}
/**
* The cost of inlining this statement
*/
public int costInline(int thresh, Environment env, Context ctx) {
int cost = 1 + cond.costInline(thresh, env, ctx);
if (ifTrue != null) {
cost += ifTrue.costInline(thresh, env, ctx);
}
if (ifFalse != null) {
cost += ifFalse.costInline(thresh, env, ctx);
}
return cost;
}
/**
* Code
*/
public void code(Environment env, Context ctx, Assembler asm) {
CodeContext newctx = new CodeContext(ctx, this);
Label l1 = new Label();
cond.codeBranch(env, newctx, asm, l1, false);
ifTrue.code(env, newctx, asm);
if (ifFalse != null) {
Label l2 = new Label();
asm.add(true, where, opc_goto, l2);
asm.add(l1);
ifFalse.code(env, newctx, asm);
asm.add(l2);
} else {
asm.add(l1);
}
asm.add(newctx.breakLabel);
}
/**
* Print
*/
public void print(PrintStream out, int indent) {
super.print(out, indent);
out.print("if ");
cond.print(out);
out.print(" ");
ifTrue.print(out, indent);
if (ifFalse != null) {
out.print(" else ");
ifFalse.print(out, indent);
}
}
}