1 /* 2 * Copyright (c) 1994, 2003, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package sun.tools.tree; 27 28 import sun.tools.java.*; 29 import sun.tools.asm.Assembler; 30 import sun.tools.asm.Label; 31 import java.io.PrintStream; 32 import java.util.Hashtable; 33 34 /** 35 * WARNING: The contents of this source file are not part of any 36 * supported API. Code that depends on them does so at its own risk: 37 * they are subject to change or removal without notice. 38 */ 39 public 40 class Statement extends Node { 41 public static final Vset DEAD_END = Vset.DEAD_END; 42 Identifier labels[] = null; 43 44 /** 45 * Constructor 46 */ Statement(int op, long where)47 Statement(int op, long where) { 48 super(op, where); 49 } 50 51 /** 52 * An empty statement. Its costInline is infinite. 53 */ 54 public static final Statement empty = new Statement(STAT, 0); 55 56 /** 57 * The largest possible interesting inline cost value. 58 */ 59 public static final int MAXINLINECOST = 60 Integer.getInteger("javac.maxinlinecost", 61 30).intValue(); 62 63 /** 64 * Insert a bit of code at the front of a statement. 65 * Side-effect s2, if it is a CompoundStatement. 66 */ insertStatement(Statement s1, Statement s2)67 public static Statement insertStatement(Statement s1, Statement s2) { 68 if (s2 == null) { 69 s2 = s1; 70 } else if (s2 instanceof CompoundStatement) { 71 // Do not add another level of block nesting. 72 ((CompoundStatement)s2).insertStatement(s1); 73 } else { 74 Statement body[] = { s1, s2 }; 75 s2 = new CompoundStatement(s1.getWhere(), body); 76 } 77 return s2; 78 } 79 80 /** 81 * Set the label of a statement 82 */ setLabel(Environment env, Expression e)83 public void setLabel(Environment env, Expression e) { 84 if (e.op == IDENT) { 85 if (labels == null) { 86 labels = new Identifier[1]; 87 } else { 88 // this should almost never happen. Multiple labels on 89 // the same statement. But handle it gracefully. 90 Identifier newLabels[] = new Identifier[labels.length + 1]; 91 System.arraycopy(labels, 0, newLabels, 1, labels.length); 92 labels = newLabels; 93 } 94 labels[0] = ((IdentifierExpression)e).id; 95 } else { 96 env.error(e.where, "invalid.label"); 97 } 98 } 99 100 /** 101 * Check a statement 102 */ checkMethod(Environment env, Context ctx, Vset vset, Hashtable<Object, Object> exp)103 public Vset checkMethod(Environment env, Context ctx, Vset vset, Hashtable<Object, Object> exp) { 104 // Set up ctx.getReturnContext() for the sake of ReturnStatement.check(). 105 CheckContext mctx = new CheckContext(ctx, new Statement(METHOD, 0)); 106 ctx = mctx; 107 108 vset = check(env, ctx, vset, exp); 109 110 // Check for return 111 if (!ctx.field.getType().getReturnType().isType(TC_VOID)) { 112 // In general, we suppress further error messages due to 113 // unreachable statements after reporting the first error 114 // along a flow path (using 'clearDeadEnd'). Here, we 115 // report an error anyway, because the end of the method 116 // should be unreachable despite the earlier error. The 117 // difference in treatment is due to the fact that, in this 118 // case, the error is reachability, not unreachability. 119 // NOTE: In addition to this subtle difference in the quality 120 // of the error diagnostics, this treatment is essential to 121 // preserve the correctness of using 'clearDeadEnd' to implement 122 // the special-case reachability rules for if-then and if-then-else. 123 if (!vset.isDeadEnd()) { 124 env.error(ctx.field.getWhere(), "return.required.at.end", ctx.field); 125 } 126 } 127 128 // Simulate a return at the end. 129 vset = vset.join(mctx.vsBreak); 130 131 return vset; 132 } checkDeclaration(Environment env, Context ctx, Vset vset, int mod, Type t, Hashtable<Object, Object> exp)133 Vset checkDeclaration(Environment env, Context ctx, Vset vset, int mod, Type t, Hashtable<Object, Object> exp) { 134 throw new CompilerError("checkDeclaration"); 135 } 136 137 /** 138 * Make sure the labels on this statement do not duplicate the 139 * labels on any enclosing statement. Provided as a convenience 140 * for subclasses. 141 */ checkLabel(Environment env, Context ctx)142 protected void checkLabel(Environment env, Context ctx) { 143 if (labels != null) { 144 loop: for (int i = 0; i < labels.length; i++) { 145 // Make sure there is not a double label on this statement. 146 for (int j = i+1; j < labels.length; j++) { 147 if (labels[i] == labels[j]) { 148 env.error(where, "nested.duplicate.label", labels[i]); 149 continue loop; 150 } 151 } 152 153 // Make sure no enclosing statement has the same label. 154 CheckContext destCtx = 155 (CheckContext) ctx.getLabelContext(labels[i]); 156 157 if (destCtx != null) { 158 // Check to make sure the label is in not uplevel. 159 if (destCtx.frameNumber == ctx.frameNumber) { 160 env.error(where, "nested.duplicate.label", labels[i]); 161 } 162 } 163 } // end loop 164 } 165 } 166 check(Environment env, Context ctx, Vset vset, Hashtable<Object, Object> exp)167 Vset check(Environment env, Context ctx, Vset vset, Hashtable<Object, Object> exp) { 168 throw new CompilerError("check"); 169 } 170 171 /** This is called in contexts where declarations are valid. */ checkBlockStatement(Environment env, Context ctx, Vset vset, Hashtable<Object, Object> exp)172 Vset checkBlockStatement(Environment env, Context ctx, Vset vset, Hashtable<Object, Object> exp) { 173 return check(env, ctx, vset, exp); 174 } 175 reach(Environment env, Vset vset)176 Vset reach(Environment env, Vset vset) { 177 if (vset.isDeadEnd()) { 178 env.error(where, "stat.not.reached"); 179 vset = vset.clearDeadEnd(); 180 } 181 return vset; 182 } 183 184 /** 185 * Inline 186 */ inline(Environment env, Context ctx)187 public Statement inline(Environment env, Context ctx) { 188 return this; 189 } 190 191 /** 192 * Eliminate this statement, which is only possible if it has no label. 193 */ eliminate(Environment env, Statement s)194 public Statement eliminate(Environment env, Statement s) { 195 if ((s != null) && (labels != null)) { 196 Statement args[] = {s}; 197 s = new CompoundStatement(where, args); 198 s.labels = labels; 199 } 200 return s; 201 } 202 203 204 /** 205 * Code 206 */ code(Environment env, Context ctx, Assembler asm)207 public void code(Environment env, Context ctx, Assembler asm) { 208 throw new CompilerError("code"); 209 } 210 211 /** 212 * Generate the code to call all finally's for a break, continue, or 213 * return statement. We must call "jsr" on all the cleanup code between 214 * the current context "ctx", and the destination context "stopctx". 215 * If 'save' isn't null, there is also a value on the top of the stack 216 */ codeFinally(Environment env, Context ctx, Assembler asm, Context stopctx, Type save)217 void codeFinally(Environment env, Context ctx, Assembler asm, 218 Context stopctx, Type save) { 219 Integer num = null; 220 boolean haveCleanup = false; // there is a finally or synchronize; 221 boolean haveNonLocalFinally = false; // some finally doesn't return; 222 223 for (Context c = ctx; (c != null) && (c != stopctx); c = c.prev) { 224 if (c.node == null) 225 continue; 226 if (c.node.op == SYNCHRONIZED) { 227 haveCleanup = true; 228 } else if (c.node.op == FINALLY 229 && ((CodeContext)c).contLabel != null) { 230 // c.contLabel == null indicates we're in the "finally" part 231 haveCleanup = true; 232 FinallyStatement st = ((FinallyStatement)(c.node)); 233 if (!st.finallyCanFinish) { 234 haveNonLocalFinally = true; 235 // after hitting a non-local finally, no need generating 236 // further code, because it won't get executed. 237 break; 238 } 239 } 240 } 241 if (!haveCleanup) { 242 // there is no cleanup that needs to be done. Just quit. 243 return; 244 } 245 if (save != null) { 246 // This statement has a return value on the stack. 247 ClassDefinition def = ctx.field.getClassDefinition(); 248 if (!haveNonLocalFinally) { 249 // Save the return value in the register which should have 250 // been reserved. 251 LocalMember lf = ctx.getLocalField(idFinallyReturnValue); 252 num = lf.number; 253 asm.add(where, opc_istore + save.getTypeCodeOffset(), num); 254 } else { 255 // Pop the return value. 256 switch(ctx.field.getType().getReturnType().getTypeCode()) { 257 case TC_VOID: 258 break; 259 case TC_DOUBLE: case TC_LONG: 260 asm.add(where, opc_pop2); break; 261 default: 262 asm.add(where, opc_pop); break; 263 } 264 } 265 } 266 // Call each of the cleanup functions, as necessary. 267 for (Context c = ctx ; (c != null) && (c != stopctx) ; c = c.prev) { 268 if (c.node == null) 269 continue; 270 if (c.node.op == SYNCHRONIZED) { 271 asm.add(where, opc_jsr, ((CodeContext)c).contLabel); 272 } else if (c.node.op == FINALLY 273 && ((CodeContext)c).contLabel != null) { 274 FinallyStatement st = ((FinallyStatement)(c.node)); 275 Label label = ((CodeContext)c).contLabel; 276 if (st.finallyCanFinish) { 277 asm.add(where, opc_jsr, label); 278 } else { 279 // the code never returns, so we're done. 280 asm.add(where, opc_goto, label); 281 break; 282 } 283 } 284 } 285 // Move the return value from the register back to the stack. 286 if (num != null) { 287 asm.add(where, opc_iload + save.getTypeCodeOffset(), num); 288 } 289 } 290 291 /* 292 * Return true if the statement has the given label 293 */ hasLabel(Identifier lbl)294 public boolean hasLabel (Identifier lbl) { 295 Identifier labels[] = this.labels; 296 if (labels != null) { 297 for (int i = labels.length; --i >= 0; ) { 298 if (labels[i].equals(lbl)) { 299 return true; 300 } 301 } 302 } 303 return false; 304 } 305 306 /** 307 * Check if the first thing is a constructor invocation 308 */ firstConstructor()309 public Expression firstConstructor() { 310 return null; 311 } 312 313 /** 314 * Create a copy of the statement for method inlining 315 */ copyInline(Context ctx, boolean valNeeded)316 public Statement copyInline(Context ctx, boolean valNeeded) { 317 return (Statement)clone(); 318 } 319 costInline(int thresh, Environment env, Context ctx)320 public int costInline(int thresh, Environment env, Context ctx) { 321 return thresh; 322 } 323 324 325 /** 326 * Print 327 */ printIndent(PrintStream out, int indent)328 void printIndent(PrintStream out, int indent) { 329 for (int i = 0 ; i < indent ; i++) { 330 out.print(" "); 331 } 332 } print(PrintStream out, int indent)333 public void print(PrintStream out, int indent) { 334 if (labels != null) { 335 for (int i = labels.length; --i >= 0; ) 336 out.print(labels[i] + ": "); 337 } 338 } print(PrintStream out)339 public void print(PrintStream out) { 340 print(out, 0); 341 } 342 } 343