src/share/classes/com/sun/tools/javac/jvm/ClassWriter.java

Tue, 28 Jul 2009 12:12:59 -0700

author
xdono
date
Tue, 28 Jul 2009 12:12:59 -0700
changeset 323
14b1a8ede954
parent 310
7c154fdc3547
child 415
49359d0e6a9c
permissions
-rw-r--r--

6862919: Update copyright year
Summary: Update copyright for files that have been modified in 2009, up to 07/09
Reviewed-by: tbell, ohair

duke@1 1 /*
xdono@323 2 * Copyright 1999-2009 Sun Microsystems, Inc. All Rights Reserved.
duke@1 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@1 4 *
duke@1 5 * This code is free software; you can redistribute it and/or modify it
duke@1 6 * under the terms of the GNU General Public License version 2 only, as
duke@1 7 * published by the Free Software Foundation. Sun designates this
duke@1 8 * particular file as subject to the "Classpath" exception as provided
duke@1 9 * by Sun in the LICENSE file that accompanied this code.
duke@1 10 *
duke@1 11 * This code is distributed in the hope that it will be useful, but WITHOUT
duke@1 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@1 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@1 14 * version 2 for more details (a copy is included in the LICENSE file that
duke@1 15 * accompanied this code).
duke@1 16 *
duke@1 17 * You should have received a copy of the GNU General Public License version
duke@1 18 * 2 along with this work; if not, write to the Free Software Foundation,
duke@1 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@1 20 *
duke@1 21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@1 22 * CA 95054 USA or visit www.sun.com if you need additional information or
duke@1 23 * have any questions.
duke@1 24 */
duke@1 25
duke@1 26 package com.sun.tools.javac.jvm;
duke@1 27
duke@1 28 import java.io.*;
duke@1 29 import java.util.Set;
duke@1 30 import java.util.HashSet;
duke@1 31
duke@1 32 import javax.tools.JavaFileManager;
duke@1 33 import javax.tools.FileObject;
duke@1 34 import javax.tools.JavaFileObject;
duke@1 35
duke@1 36 import com.sun.tools.javac.code.*;
duke@1 37 import com.sun.tools.javac.code.Symbol.*;
duke@1 38 import com.sun.tools.javac.code.Type.*;
duke@1 39 import com.sun.tools.javac.util.*;
duke@1 40
duke@1 41 import static com.sun.tools.javac.code.BoundKind.*;
duke@1 42 import static com.sun.tools.javac.code.Flags.*;
duke@1 43 import static com.sun.tools.javac.code.Kinds.*;
duke@1 44 import static com.sun.tools.javac.code.TypeTags.*;
duke@1 45 import static com.sun.tools.javac.jvm.UninitializedType.*;
duke@1 46 import static javax.tools.StandardLocation.CLASS_OUTPUT;
duke@1 47
duke@1 48 /** This class provides operations to map an internal symbol table graph
duke@1 49 * rooted in a ClassSymbol into a classfile.
duke@1 50 *
duke@1 51 * <p><b>This is NOT part of any API supported by Sun Microsystems. If
duke@1 52 * you write code that depends on this, you do so at your own risk.
duke@1 53 * This code and its internal interfaces are subject to change or
duke@1 54 * deletion without notice.</b>
duke@1 55 */
duke@1 56 public class ClassWriter extends ClassFile {
duke@1 57 protected static final Context.Key<ClassWriter> classWriterKey =
duke@1 58 new Context.Key<ClassWriter>();
duke@1 59
duke@1 60 private final Symtab syms;
duke@1 61
duke@1 62 private final Options options;
duke@1 63
jjg@308 64 /** Switch: debugging output for JSR 308-related operations.
jjg@308 65 */
jjg@308 66 private boolean debugJSR308;
jjg@308 67
duke@1 68 /** Switch: verbose output.
duke@1 69 */
duke@1 70 private boolean verbose;
duke@1 71
duke@1 72 /** Switch: scrable private names.
duke@1 73 */
duke@1 74 private boolean scramble;
duke@1 75
duke@1 76 /** Switch: scrable private names.
duke@1 77 */
duke@1 78 private boolean scrambleAll;
duke@1 79
duke@1 80 /** Switch: retrofit mode.
duke@1 81 */
duke@1 82 private boolean retrofit;
duke@1 83
duke@1 84 /** Switch: emit source file attribute.
duke@1 85 */
duke@1 86 private boolean emitSourceFile;
duke@1 87
duke@1 88 /** Switch: generate CharacterRangeTable attribute.
duke@1 89 */
duke@1 90 private boolean genCrt;
duke@1 91
duke@1 92 /** Switch: describe the generated stackmap
duke@1 93 */
duke@1 94 boolean debugstackmap;
duke@1 95
duke@1 96 /**
duke@1 97 * Target class version.
duke@1 98 */
duke@1 99 private Target target;
duke@1 100
duke@1 101 /**
duke@1 102 * Source language version.
duke@1 103 */
duke@1 104 private Source source;
duke@1 105
duke@1 106 /** Type utilities. */
duke@1 107 private Types types;
duke@1 108
duke@1 109 /** The initial sizes of the data and constant pool buffers.
duke@1 110 * sizes are increased when buffers get full.
duke@1 111 */
duke@1 112 static final int DATA_BUF_SIZE = 0x0fff0;
duke@1 113 static final int POOL_BUF_SIZE = 0x1fff0;
duke@1 114
duke@1 115 /** An output buffer for member info.
duke@1 116 */
duke@1 117 ByteBuffer databuf = new ByteBuffer(DATA_BUF_SIZE);
duke@1 118
duke@1 119 /** An output buffer for the constant pool.
duke@1 120 */
duke@1 121 ByteBuffer poolbuf = new ByteBuffer(POOL_BUF_SIZE);
duke@1 122
duke@1 123 /** An output buffer for type signatures.
duke@1 124 */
duke@1 125 ByteBuffer sigbuf = new ByteBuffer();
duke@1 126
duke@1 127 /** The constant pool.
duke@1 128 */
duke@1 129 Pool pool;
duke@1 130
duke@1 131 /** The inner classes to be written, as a set.
duke@1 132 */
duke@1 133 Set<ClassSymbol> innerClasses;
duke@1 134
duke@1 135 /** The inner classes to be written, as a queue where
duke@1 136 * enclosing classes come first.
duke@1 137 */
duke@1 138 ListBuffer<ClassSymbol> innerClassesQueue;
duke@1 139
duke@1 140 /** The log to use for verbose output.
duke@1 141 */
duke@1 142 private final Log log;
duke@1 143
duke@1 144 /** The name table. */
jjg@113 145 private final Names names;
duke@1 146
duke@1 147 /** Access to files. */
duke@1 148 private final JavaFileManager fileManager;
duke@1 149
duke@1 150 /** The tags and constants used in compressed stackmap. */
duke@1 151 static final int SAME_FRAME_SIZE = 64;
duke@1 152 static final int SAME_LOCALS_1_STACK_ITEM_EXTENDED = 247;
duke@1 153 static final int SAME_FRAME_EXTENDED = 251;
duke@1 154 static final int FULL_FRAME = 255;
duke@1 155 static final int MAX_LOCAL_LENGTH_DIFF = 4;
duke@1 156
duke@1 157 /** Get the ClassWriter instance for this context. */
duke@1 158 public static ClassWriter instance(Context context) {
duke@1 159 ClassWriter instance = context.get(classWriterKey);
duke@1 160 if (instance == null)
duke@1 161 instance = new ClassWriter(context);
duke@1 162 return instance;
duke@1 163 }
duke@1 164
duke@1 165 /** Construct a class writer, given an options table.
duke@1 166 */
duke@1 167 private ClassWriter(Context context) {
duke@1 168 context.put(classWriterKey, this);
duke@1 169
duke@1 170 log = Log.instance(context);
jjg@113 171 names = Names.instance(context);
duke@1 172 syms = Symtab.instance(context);
duke@1 173 options = Options.instance(context);
duke@1 174 target = Target.instance(context);
duke@1 175 source = Source.instance(context);
duke@1 176 types = Types.instance(context);
duke@1 177 fileManager = context.get(JavaFileManager.class);
duke@1 178
jjg@308 179 debugJSR308 = options.get("TA:writer") != null;
duke@1 180 verbose = options.get("-verbose") != null;
duke@1 181 scramble = options.get("-scramble") != null;
duke@1 182 scrambleAll = options.get("-scrambleAll") != null;
duke@1 183 retrofit = options.get("-retrofit") != null;
duke@1 184 genCrt = options.get("-Xjcov") != null;
duke@1 185 debugstackmap = options.get("debugstackmap") != null;
duke@1 186
duke@1 187 emitSourceFile = options.get("-g:")==null || options.get("-g:source")!=null;
duke@1 188
duke@1 189 String dumpModFlags = options.get("dumpmodifiers");
duke@1 190 dumpClassModifiers =
duke@1 191 (dumpModFlags != null && dumpModFlags.indexOf('c') != -1);
duke@1 192 dumpFieldModifiers =
duke@1 193 (dumpModFlags != null && dumpModFlags.indexOf('f') != -1);
duke@1 194 dumpInnerClassModifiers =
duke@1 195 (dumpModFlags != null && dumpModFlags.indexOf('i') != -1);
duke@1 196 dumpMethodModifiers =
duke@1 197 (dumpModFlags != null && dumpModFlags.indexOf('m') != -1);
duke@1 198 }
duke@1 199
duke@1 200 /******************************************************************
duke@1 201 * Diagnostics: dump generated class names and modifiers
duke@1 202 ******************************************************************/
duke@1 203
duke@1 204 /** Value of option 'dumpmodifiers' is a string
duke@1 205 * indicating which modifiers should be dumped for debugging:
duke@1 206 * 'c' -- classes
duke@1 207 * 'f' -- fields
duke@1 208 * 'i' -- innerclass attributes
duke@1 209 * 'm' -- methods
duke@1 210 * For example, to dump everything:
duke@1 211 * javac -XDdumpmodifiers=cifm MyProg.java
duke@1 212 */
duke@1 213 private final boolean dumpClassModifiers; // -XDdumpmodifiers=c
duke@1 214 private final boolean dumpFieldModifiers; // -XDdumpmodifiers=f
duke@1 215 private final boolean dumpInnerClassModifiers; // -XDdumpmodifiers=i
duke@1 216 private final boolean dumpMethodModifiers; // -XDdumpmodifiers=m
duke@1 217
duke@1 218
duke@1 219 /** Return flags as a string, separated by " ".
duke@1 220 */
duke@1 221 public static String flagNames(long flags) {
duke@1 222 StringBuffer sbuf = new StringBuffer();
duke@1 223 int i = 0;
duke@1 224 long f = flags & StandardFlags;
duke@1 225 while (f != 0) {
duke@1 226 if ((f & 1) != 0) sbuf.append(" " + flagName[i]);
duke@1 227 f = f >> 1;
duke@1 228 i++;
duke@1 229 }
duke@1 230 return sbuf.toString();
duke@1 231 }
duke@1 232 //where
duke@1 233 private final static String[] flagName = {
duke@1 234 "PUBLIC", "PRIVATE", "PROTECTED", "STATIC", "FINAL",
duke@1 235 "SUPER", "VOLATILE", "TRANSIENT", "NATIVE", "INTERFACE",
duke@1 236 "ABSTRACT", "STRICTFP"};
duke@1 237
duke@1 238 /******************************************************************
duke@1 239 * Output routines
duke@1 240 ******************************************************************/
duke@1 241
duke@1 242 /** Write a character into given byte buffer;
duke@1 243 * byte buffer will not be grown.
duke@1 244 */
duke@1 245 void putChar(ByteBuffer buf, int op, int x) {
duke@1 246 buf.elems[op ] = (byte)((x >> 8) & 0xFF);
duke@1 247 buf.elems[op+1] = (byte)((x ) & 0xFF);
duke@1 248 }
duke@1 249
duke@1 250 /** Write an integer into given byte buffer;
duke@1 251 * byte buffer will not be grown.
duke@1 252 */
duke@1 253 void putInt(ByteBuffer buf, int adr, int x) {
duke@1 254 buf.elems[adr ] = (byte)((x >> 24) & 0xFF);
duke@1 255 buf.elems[adr+1] = (byte)((x >> 16) & 0xFF);
duke@1 256 buf.elems[adr+2] = (byte)((x >> 8) & 0xFF);
duke@1 257 buf.elems[adr+3] = (byte)((x ) & 0xFF);
duke@1 258 }
duke@1 259
duke@1 260 /******************************************************************
duke@1 261 * Signature Generation
duke@1 262 ******************************************************************/
duke@1 263
duke@1 264 /** Assemble signature of given type in string buffer.
duke@1 265 */
duke@1 266 void assembleSig(Type type) {
duke@1 267 switch (type.tag) {
duke@1 268 case BYTE:
duke@1 269 sigbuf.appendByte('B');
duke@1 270 break;
duke@1 271 case SHORT:
duke@1 272 sigbuf.appendByte('S');
duke@1 273 break;
duke@1 274 case CHAR:
duke@1 275 sigbuf.appendByte('C');
duke@1 276 break;
duke@1 277 case INT:
duke@1 278 sigbuf.appendByte('I');
duke@1 279 break;
duke@1 280 case LONG:
duke@1 281 sigbuf.appendByte('J');
duke@1 282 break;
duke@1 283 case FLOAT:
duke@1 284 sigbuf.appendByte('F');
duke@1 285 break;
duke@1 286 case DOUBLE:
duke@1 287 sigbuf.appendByte('D');
duke@1 288 break;
duke@1 289 case BOOLEAN:
duke@1 290 sigbuf.appendByte('Z');
duke@1 291 break;
duke@1 292 case VOID:
duke@1 293 sigbuf.appendByte('V');
duke@1 294 break;
duke@1 295 case CLASS:
duke@1 296 sigbuf.appendByte('L');
duke@1 297 assembleClassSig(type);
duke@1 298 sigbuf.appendByte(';');
duke@1 299 break;
duke@1 300 case ARRAY:
duke@1 301 ArrayType at = (ArrayType)type;
duke@1 302 sigbuf.appendByte('[');
duke@1 303 assembleSig(at.elemtype);
duke@1 304 break;
duke@1 305 case METHOD:
duke@1 306 MethodType mt = (MethodType)type;
duke@1 307 sigbuf.appendByte('(');
duke@1 308 assembleSig(mt.argtypes);
duke@1 309 sigbuf.appendByte(')');
duke@1 310 assembleSig(mt.restype);
duke@1 311 if (hasTypeVar(mt.thrown)) {
duke@1 312 for (List<Type> l = mt.thrown; l.nonEmpty(); l = l.tail) {
duke@1 313 sigbuf.appendByte('^');
duke@1 314 assembleSig(l.head);
duke@1 315 }
duke@1 316 }
duke@1 317 break;
duke@1 318 case WILDCARD: {
duke@1 319 WildcardType ta = (WildcardType) type;
duke@1 320 switch (ta.kind) {
duke@1 321 case SUPER:
duke@1 322 sigbuf.appendByte('-');
duke@1 323 assembleSig(ta.type);
duke@1 324 break;
duke@1 325 case EXTENDS:
duke@1 326 sigbuf.appendByte('+');
duke@1 327 assembleSig(ta.type);
duke@1 328 break;
duke@1 329 case UNBOUND:
duke@1 330 sigbuf.appendByte('*');
duke@1 331 break;
duke@1 332 default:
duke@1 333 throw new AssertionError(ta.kind);
duke@1 334 }
duke@1 335 break;
duke@1 336 }
duke@1 337 case TYPEVAR:
duke@1 338 sigbuf.appendByte('T');
duke@1 339 sigbuf.appendName(type.tsym.name);
duke@1 340 sigbuf.appendByte(';');
duke@1 341 break;
duke@1 342 case FORALL:
duke@1 343 ForAll ft = (ForAll)type;
duke@1 344 assembleParamsSig(ft.tvars);
duke@1 345 assembleSig(ft.qtype);
duke@1 346 break;
duke@1 347 case UNINITIALIZED_THIS:
duke@1 348 case UNINITIALIZED_OBJECT:
duke@1 349 // we don't yet have a spec for uninitialized types in the
duke@1 350 // local variable table
duke@1 351 assembleSig(types.erasure(((UninitializedType)type).qtype));
duke@1 352 break;
duke@1 353 default:
duke@1 354 throw new AssertionError("typeSig " + type.tag);
duke@1 355 }
duke@1 356 }
duke@1 357
duke@1 358 boolean hasTypeVar(List<Type> l) {
duke@1 359 while (l.nonEmpty()) {
duke@1 360 if (l.head.tag == TypeTags.TYPEVAR) return true;
duke@1 361 l = l.tail;
duke@1 362 }
duke@1 363 return false;
duke@1 364 }
duke@1 365
duke@1 366 void assembleClassSig(Type type) {
duke@1 367 ClassType ct = (ClassType)type;
duke@1 368 ClassSymbol c = (ClassSymbol)ct.tsym;
duke@1 369 enterInner(c);
duke@1 370 Type outer = ct.getEnclosingType();
duke@1 371 if (outer.allparams().nonEmpty()) {
duke@1 372 boolean rawOuter =
duke@1 373 c.owner.kind == MTH || // either a local class
duke@1 374 c.name == names.empty; // or anonymous
duke@1 375 assembleClassSig(rawOuter
duke@1 376 ? types.erasure(outer)
duke@1 377 : outer);
duke@1 378 sigbuf.appendByte('.');
duke@1 379 assert c.flatname.startsWith(c.owner.enclClass().flatname);
duke@1 380 sigbuf.appendName(rawOuter
jjg@113 381 ? c.flatname.subName(c.owner.enclClass().flatname.getByteLength()+1,c.flatname.getByteLength())
duke@1 382 : c.name);
duke@1 383 } else {
duke@1 384 sigbuf.appendBytes(externalize(c.flatname));
duke@1 385 }
duke@1 386 if (ct.getTypeArguments().nonEmpty()) {
duke@1 387 sigbuf.appendByte('<');
duke@1 388 assembleSig(ct.getTypeArguments());
duke@1 389 sigbuf.appendByte('>');
duke@1 390 }
duke@1 391 }
duke@1 392
duke@1 393
duke@1 394 void assembleSig(List<Type> types) {
duke@1 395 for (List<Type> ts = types; ts.nonEmpty(); ts = ts.tail)
duke@1 396 assembleSig(ts.head);
duke@1 397 }
duke@1 398
duke@1 399 void assembleParamsSig(List<Type> typarams) {
duke@1 400 sigbuf.appendByte('<');
duke@1 401 for (List<Type> ts = typarams; ts.nonEmpty(); ts = ts.tail) {
duke@1 402 TypeVar tvar = (TypeVar)ts.head;
duke@1 403 sigbuf.appendName(tvar.tsym.name);
duke@1 404 List<Type> bounds = types.getBounds(tvar);
duke@1 405 if ((bounds.head.tsym.flags() & INTERFACE) != 0) {
duke@1 406 sigbuf.appendByte(':');
duke@1 407 }
duke@1 408 for (List<Type> l = bounds; l.nonEmpty(); l = l.tail) {
duke@1 409 sigbuf.appendByte(':');
duke@1 410 assembleSig(l.head);
duke@1 411 }
duke@1 412 }
duke@1 413 sigbuf.appendByte('>');
duke@1 414 }
duke@1 415
duke@1 416 /** Return signature of given type
duke@1 417 */
duke@1 418 Name typeSig(Type type) {
duke@1 419 assert sigbuf.length == 0;
duke@1 420 //- System.out.println(" ? " + type);
duke@1 421 assembleSig(type);
duke@1 422 Name n = sigbuf.toName(names);
duke@1 423 sigbuf.reset();
duke@1 424 //- System.out.println(" " + n);
duke@1 425 return n;
duke@1 426 }
duke@1 427
duke@1 428 /** Given a type t, return the extended class name of its erasure in
duke@1 429 * external representation.
duke@1 430 */
duke@1 431 public Name xClassName(Type t) {
duke@1 432 if (t.tag == CLASS) {
duke@1 433 return names.fromUtf(externalize(t.tsym.flatName()));
duke@1 434 } else if (t.tag == ARRAY) {
duke@1 435 return typeSig(types.erasure(t));
duke@1 436 } else {
duke@1 437 throw new AssertionError("xClassName");
duke@1 438 }
duke@1 439 }
duke@1 440
duke@1 441 /******************************************************************
duke@1 442 * Writing the Constant Pool
duke@1 443 ******************************************************************/
duke@1 444
duke@1 445 /** Thrown when the constant pool is over full.
duke@1 446 */
duke@1 447 public static class PoolOverflow extends Exception {
duke@1 448 private static final long serialVersionUID = 0;
duke@1 449 public PoolOverflow() {}
duke@1 450 }
duke@1 451 public static class StringOverflow extends Exception {
duke@1 452 private static final long serialVersionUID = 0;
duke@1 453 public final String value;
duke@1 454 public StringOverflow(String s) {
duke@1 455 value = s;
duke@1 456 }
duke@1 457 }
duke@1 458
duke@1 459 /** Write constant pool to pool buffer.
duke@1 460 * Note: during writing, constant pool
duke@1 461 * might grow since some parts of constants still need to be entered.
duke@1 462 */
duke@1 463 void writePool(Pool pool) throws PoolOverflow, StringOverflow {
duke@1 464 int poolCountIdx = poolbuf.length;
duke@1 465 poolbuf.appendChar(0);
duke@1 466 int i = 1;
duke@1 467 while (i < pool.pp) {
duke@1 468 Object value = pool.pool[i];
duke@1 469 assert value != null;
duke@1 470 if (value instanceof Pool.Method)
duke@1 471 value = ((Pool.Method)value).m;
duke@1 472 else if (value instanceof Pool.Variable)
duke@1 473 value = ((Pool.Variable)value).v;
duke@1 474
duke@1 475 if (value instanceof MethodSymbol) {
duke@1 476 MethodSymbol m = (MethodSymbol)value;
duke@1 477 poolbuf.appendByte((m.owner.flags() & INTERFACE) != 0
duke@1 478 ? CONSTANT_InterfaceMethodref
duke@1 479 : CONSTANT_Methodref);
duke@1 480 poolbuf.appendChar(pool.put(m.owner));
duke@1 481 poolbuf.appendChar(pool.put(nameType(m)));
duke@1 482 } else if (value instanceof VarSymbol) {
duke@1 483 VarSymbol v = (VarSymbol)value;
duke@1 484 poolbuf.appendByte(CONSTANT_Fieldref);
duke@1 485 poolbuf.appendChar(pool.put(v.owner));
duke@1 486 poolbuf.appendChar(pool.put(nameType(v)));
duke@1 487 } else if (value instanceof Name) {
duke@1 488 poolbuf.appendByte(CONSTANT_Utf8);
duke@1 489 byte[] bs = ((Name)value).toUtf();
duke@1 490 poolbuf.appendChar(bs.length);
duke@1 491 poolbuf.appendBytes(bs, 0, bs.length);
duke@1 492 if (bs.length > Pool.MAX_STRING_LENGTH)
duke@1 493 throw new StringOverflow(value.toString());
duke@1 494 } else if (value instanceof ClassSymbol) {
duke@1 495 ClassSymbol c = (ClassSymbol)value;
duke@1 496 if (c.owner.kind == TYP) pool.put(c.owner);
duke@1 497 poolbuf.appendByte(CONSTANT_Class);
duke@1 498 if (c.type.tag == ARRAY) {
duke@1 499 poolbuf.appendChar(pool.put(typeSig(c.type)));
duke@1 500 } else {
duke@1 501 poolbuf.appendChar(pool.put(names.fromUtf(externalize(c.flatname))));
duke@1 502 enterInner(c);
duke@1 503 }
duke@1 504 } else if (value instanceof NameAndType) {
duke@1 505 NameAndType nt = (NameAndType)value;
duke@1 506 poolbuf.appendByte(CONSTANT_NameandType);
duke@1 507 poolbuf.appendChar(pool.put(nt.name));
duke@1 508 poolbuf.appendChar(pool.put(typeSig(nt.type)));
duke@1 509 } else if (value instanceof Integer) {
duke@1 510 poolbuf.appendByte(CONSTANT_Integer);
duke@1 511 poolbuf.appendInt(((Integer)value).intValue());
duke@1 512 } else if (value instanceof Long) {
duke@1 513 poolbuf.appendByte(CONSTANT_Long);
duke@1 514 poolbuf.appendLong(((Long)value).longValue());
duke@1 515 i++;
duke@1 516 } else if (value instanceof Float) {
duke@1 517 poolbuf.appendByte(CONSTANT_Float);
duke@1 518 poolbuf.appendFloat(((Float)value).floatValue());
duke@1 519 } else if (value instanceof Double) {
duke@1 520 poolbuf.appendByte(CONSTANT_Double);
duke@1 521 poolbuf.appendDouble(((Double)value).doubleValue());
duke@1 522 i++;
duke@1 523 } else if (value instanceof String) {
duke@1 524 poolbuf.appendByte(CONSTANT_String);
duke@1 525 poolbuf.appendChar(pool.put(names.fromString((String)value)));
duke@1 526 } else if (value instanceof Type) {
duke@1 527 Type type = (Type)value;
duke@1 528 if (type.tag == CLASS) enterInner((ClassSymbol)type.tsym);
duke@1 529 poolbuf.appendByte(CONSTANT_Class);
duke@1 530 poolbuf.appendChar(pool.put(xClassName(type)));
duke@1 531 } else {
duke@1 532 assert false : "writePool " + value;
duke@1 533 }
duke@1 534 i++;
duke@1 535 }
duke@1 536 if (pool.pp > Pool.MAX_ENTRIES)
duke@1 537 throw new PoolOverflow();
duke@1 538 putChar(poolbuf, poolCountIdx, pool.pp);
duke@1 539 }
duke@1 540
duke@1 541 /** Given a field, return its name.
duke@1 542 */
duke@1 543 Name fieldName(Symbol sym) {
duke@1 544 if (scramble && (sym.flags() & PRIVATE) != 0 ||
duke@1 545 scrambleAll && (sym.flags() & (PROTECTED | PUBLIC)) == 0)
jjg@113 546 return names.fromString("_$" + sym.name.getIndex());
duke@1 547 else
duke@1 548 return sym.name;
duke@1 549 }
duke@1 550
duke@1 551 /** Given a symbol, return its name-and-type.
duke@1 552 */
duke@1 553 NameAndType nameType(Symbol sym) {
duke@1 554 return new NameAndType(fieldName(sym),
duke@1 555 retrofit
duke@1 556 ? sym.erasure(types)
duke@1 557 : sym.externalType(types));
duke@1 558 // if we retrofit, then the NameAndType has been read in as is
duke@1 559 // and no change is necessary. If we compile normally, the
duke@1 560 // NameAndType is generated from a symbol reference, and the
duke@1 561 // adjustment of adding an additional this$n parameter needs to be made.
duke@1 562 }
duke@1 563
duke@1 564 /******************************************************************
duke@1 565 * Writing Attributes
duke@1 566 ******************************************************************/
duke@1 567
duke@1 568 /** Write header for an attribute to data buffer and return
duke@1 569 * position past attribute length index.
duke@1 570 */
duke@1 571 int writeAttr(Name attrName) {
duke@1 572 databuf.appendChar(pool.put(attrName));
duke@1 573 databuf.appendInt(0);
duke@1 574 return databuf.length;
duke@1 575 }
duke@1 576
duke@1 577 /** Fill in attribute length.
duke@1 578 */
duke@1 579 void endAttr(int index) {
duke@1 580 putInt(databuf, index - 4, databuf.length - index);
duke@1 581 }
duke@1 582
duke@1 583 /** Leave space for attribute count and return index for
duke@1 584 * number of attributes field.
duke@1 585 */
duke@1 586 int beginAttrs() {
duke@1 587 databuf.appendChar(0);
duke@1 588 return databuf.length;
duke@1 589 }
duke@1 590
duke@1 591 /** Fill in number of attributes.
duke@1 592 */
duke@1 593 void endAttrs(int index, int count) {
duke@1 594 putChar(databuf, index - 2, count);
duke@1 595 }
duke@1 596
duke@1 597 /** Write the EnclosingMethod attribute if needed.
duke@1 598 * Returns the number of attributes written (0 or 1).
duke@1 599 */
duke@1 600 int writeEnclosingMethodAttribute(ClassSymbol c) {
duke@1 601 if (!target.hasEnclosingMethodAttribute() ||
duke@1 602 c.owner.kind != MTH && // neither a local class
duke@1 603 c.name != names.empty) // nor anonymous
duke@1 604 return 0;
duke@1 605
duke@1 606 int alenIdx = writeAttr(names.EnclosingMethod);
duke@1 607 ClassSymbol enclClass = c.owner.enclClass();
duke@1 608 MethodSymbol enclMethod =
duke@1 609 (c.owner.type == null // local to init block
duke@1 610 || c.owner.kind != MTH) // or member init
duke@1 611 ? null
duke@1 612 : (MethodSymbol)c.owner;
duke@1 613 databuf.appendChar(pool.put(enclClass));
duke@1 614 databuf.appendChar(enclMethod == null ? 0 : pool.put(nameType(c.owner)));
duke@1 615 endAttr(alenIdx);
duke@1 616 return 1;
duke@1 617 }
duke@1 618
duke@1 619 /** Write flag attributes; return number of attributes written.
duke@1 620 */
duke@1 621 int writeFlagAttrs(long flags) {
duke@1 622 int acount = 0;
duke@1 623 if ((flags & DEPRECATED) != 0) {
duke@1 624 int alenIdx = writeAttr(names.Deprecated);
duke@1 625 endAttr(alenIdx);
duke@1 626 acount++;
duke@1 627 }
duke@1 628 if ((flags & ENUM) != 0 && !target.useEnumFlag()) {
duke@1 629 int alenIdx = writeAttr(names.Enum);
duke@1 630 endAttr(alenIdx);
duke@1 631 acount++;
duke@1 632 }
duke@1 633 if ((flags & SYNTHETIC) != 0 && !target.useSyntheticFlag()) {
duke@1 634 int alenIdx = writeAttr(names.Synthetic);
duke@1 635 endAttr(alenIdx);
duke@1 636 acount++;
duke@1 637 }
duke@1 638 if ((flags & BRIDGE) != 0 && !target.useBridgeFlag()) {
duke@1 639 int alenIdx = writeAttr(names.Bridge);
duke@1 640 endAttr(alenIdx);
duke@1 641 acount++;
duke@1 642 }
duke@1 643 if ((flags & VARARGS) != 0 && !target.useVarargsFlag()) {
duke@1 644 int alenIdx = writeAttr(names.Varargs);
duke@1 645 endAttr(alenIdx);
duke@1 646 acount++;
duke@1 647 }
duke@1 648 if ((flags & ANNOTATION) != 0 && !target.useAnnotationFlag()) {
duke@1 649 int alenIdx = writeAttr(names.Annotation);
duke@1 650 endAttr(alenIdx);
duke@1 651 acount++;
duke@1 652 }
duke@1 653 return acount;
duke@1 654 }
duke@1 655
duke@1 656 /** Write member (field or method) attributes;
duke@1 657 * return number of attributes written.
duke@1 658 */
duke@1 659 int writeMemberAttrs(Symbol sym) {
duke@1 660 int acount = writeFlagAttrs(sym.flags());
duke@1 661 long flags = sym.flags();
duke@1 662 if (source.allowGenerics() &&
duke@1 663 (flags & (SYNTHETIC|BRIDGE)) != SYNTHETIC &&
duke@1 664 (flags & ANONCONSTR) == 0 &&
duke@1 665 (!types.isSameType(sym.type, sym.erasure(types)) ||
duke@1 666 hasTypeVar(sym.type.getThrownTypes()))) {
duke@1 667 // note that a local class with captured variables
duke@1 668 // will get a signature attribute
duke@1 669 int alenIdx = writeAttr(names.Signature);
duke@1 670 databuf.appendChar(pool.put(typeSig(sym.type)));
duke@1 671 endAttr(alenIdx);
duke@1 672 acount++;
duke@1 673 }
duke@1 674 acount += writeJavaAnnotations(sym.getAnnotationMirrors());
jjg@308 675 acount += writeTypeAnnotations(sym.typeAnnotations);
duke@1 676 return acount;
duke@1 677 }
duke@1 678
duke@1 679 /** Write method parameter annotations;
duke@1 680 * return number of attributes written.
duke@1 681 */
duke@1 682 int writeParameterAttrs(MethodSymbol m) {
duke@1 683 boolean hasVisible = false;
duke@1 684 boolean hasInvisible = false;
duke@1 685 if (m.params != null) for (VarSymbol s : m.params) {
duke@1 686 for (Attribute.Compound a : s.getAnnotationMirrors()) {
duke@1 687 switch (getRetention(a.type.tsym)) {
duke@1 688 case SOURCE: break;
duke@1 689 case CLASS: hasInvisible = true; break;
duke@1 690 case RUNTIME: hasVisible = true; break;
duke@1 691 default: ;// /* fail soft */ throw new AssertionError(vis);
duke@1 692 }
duke@1 693 }
duke@1 694 }
duke@1 695
duke@1 696 int attrCount = 0;
duke@1 697 if (hasVisible) {
duke@1 698 int attrIndex = writeAttr(names.RuntimeVisibleParameterAnnotations);
duke@1 699 databuf.appendByte(m.params.length());
duke@1 700 for (VarSymbol s : m.params) {
duke@1 701 ListBuffer<Attribute.Compound> buf = new ListBuffer<Attribute.Compound>();
duke@1 702 for (Attribute.Compound a : s.getAnnotationMirrors())
duke@1 703 if (getRetention(a.type.tsym) == RetentionPolicy.RUNTIME)
duke@1 704 buf.append(a);
duke@1 705 databuf.appendChar(buf.length());
duke@1 706 for (Attribute.Compound a : buf)
duke@1 707 writeCompoundAttribute(a);
duke@1 708 }
duke@1 709 endAttr(attrIndex);
duke@1 710 attrCount++;
duke@1 711 }
duke@1 712 if (hasInvisible) {
duke@1 713 int attrIndex = writeAttr(names.RuntimeInvisibleParameterAnnotations);
duke@1 714 databuf.appendByte(m.params.length());
duke@1 715 for (VarSymbol s : m.params) {
duke@1 716 ListBuffer<Attribute.Compound> buf = new ListBuffer<Attribute.Compound>();
duke@1 717 for (Attribute.Compound a : s.getAnnotationMirrors())
duke@1 718 if (getRetention(a.type.tsym) == RetentionPolicy.CLASS)
duke@1 719 buf.append(a);
duke@1 720 databuf.appendChar(buf.length());
duke@1 721 for (Attribute.Compound a : buf)
duke@1 722 writeCompoundAttribute(a);
duke@1 723 }
duke@1 724 endAttr(attrIndex);
duke@1 725 attrCount++;
duke@1 726 }
duke@1 727 return attrCount;
duke@1 728 }
duke@1 729
duke@1 730 /**********************************************************************
duke@1 731 * Writing Java-language annotations (aka metadata, attributes)
duke@1 732 **********************************************************************/
duke@1 733
duke@1 734 /** Write Java-language annotations; return number of JVM
duke@1 735 * attributes written (zero or one).
duke@1 736 */
duke@1 737 int writeJavaAnnotations(List<Attribute.Compound> attrs) {
duke@1 738 if (attrs.isEmpty()) return 0;
duke@1 739 ListBuffer<Attribute.Compound> visibles = new ListBuffer<Attribute.Compound>();
duke@1 740 ListBuffer<Attribute.Compound> invisibles = new ListBuffer<Attribute.Compound>();
duke@1 741 for (Attribute.Compound a : attrs) {
duke@1 742 switch (getRetention(a.type.tsym)) {
duke@1 743 case SOURCE: break;
duke@1 744 case CLASS: invisibles.append(a); break;
duke@1 745 case RUNTIME: visibles.append(a); break;
duke@1 746 default: ;// /* fail soft */ throw new AssertionError(vis);
duke@1 747 }
duke@1 748 }
duke@1 749
duke@1 750 int attrCount = 0;
duke@1 751 if (visibles.length() != 0) {
duke@1 752 int attrIndex = writeAttr(names.RuntimeVisibleAnnotations);
duke@1 753 databuf.appendChar(visibles.length());
duke@1 754 for (Attribute.Compound a : visibles)
duke@1 755 writeCompoundAttribute(a);
duke@1 756 endAttr(attrIndex);
duke@1 757 attrCount++;
duke@1 758 }
duke@1 759 if (invisibles.length() != 0) {
duke@1 760 int attrIndex = writeAttr(names.RuntimeInvisibleAnnotations);
duke@1 761 databuf.appendChar(invisibles.length());
duke@1 762 for (Attribute.Compound a : invisibles)
duke@1 763 writeCompoundAttribute(a);
duke@1 764 endAttr(attrIndex);
duke@1 765 attrCount++;
duke@1 766 }
duke@1 767 return attrCount;
duke@1 768 }
duke@1 769
jjg@308 770 int writeTypeAnnotations(List<Attribute.TypeCompound> typeAnnos) {
jjg@308 771 if (typeAnnos.isEmpty()) return 0;
jjg@308 772
jjg@308 773 ListBuffer<Attribute.TypeCompound> visibles = ListBuffer.lb();
jjg@308 774 ListBuffer<Attribute.TypeCompound> invisibles = ListBuffer.lb();
jjg@308 775
jjg@308 776 for (Attribute.TypeCompound tc : typeAnnos) {
jjg@310 777 if (tc.position.type == TargetType.UNKNOWN
jjg@310 778 || !tc.position.emitToClassfile())
jjg@310 779 continue;
jjg@310 780 switch (getRetention(tc.type.tsym)) {
jjg@310 781 case SOURCE: break;
jjg@310 782 case CLASS: invisibles.append(tc); break;
jjg@310 783 case RUNTIME: visibles.append(tc); break;
jjg@310 784 default: ;// /* fail soft */ throw new AssertionError(vis);
jjg@308 785 }
jjg@308 786 }
jjg@308 787
jjg@308 788 int attrCount = 0;
jjg@308 789 if (visibles.length() != 0) {
jjg@308 790 int attrIndex = writeAttr(names.RuntimeVisibleTypeAnnotations);
jjg@308 791 databuf.appendChar(visibles.length());
jjg@308 792 for (Attribute.TypeCompound p : visibles)
jjg@308 793 writeTypeAnnotation(p);
jjg@308 794 endAttr(attrIndex);
jjg@308 795 attrCount++;
jjg@308 796 }
jjg@308 797
jjg@308 798 if (invisibles.length() != 0) {
jjg@308 799 int attrIndex = writeAttr(names.RuntimeInvisibleTypeAnnotations);
jjg@308 800 databuf.appendChar(invisibles.length());
jjg@308 801 for (Attribute.TypeCompound p : invisibles)
jjg@308 802 writeTypeAnnotation(p);
jjg@308 803 endAttr(attrIndex);
jjg@308 804 attrCount++;
jjg@308 805 }
jjg@308 806
jjg@308 807 return attrCount;
jjg@308 808 }
jjg@308 809
duke@1 810 /** A mirror of java.lang.annotation.RetentionPolicy. */
duke@1 811 enum RetentionPolicy {
duke@1 812 SOURCE,
duke@1 813 CLASS,
duke@1 814 RUNTIME
duke@1 815 }
duke@1 816
duke@1 817 RetentionPolicy getRetention(TypeSymbol annotationType) {
duke@1 818 RetentionPolicy vis = RetentionPolicy.CLASS; // the default
duke@1 819 Attribute.Compound c = annotationType.attribute(syms.retentionType.tsym);
duke@1 820 if (c != null) {
duke@1 821 Attribute value = c.member(names.value);
duke@1 822 if (value != null && value instanceof Attribute.Enum) {
duke@1 823 Name levelName = ((Attribute.Enum)value).value.name;
duke@1 824 if (levelName == names.SOURCE) vis = RetentionPolicy.SOURCE;
duke@1 825 else if (levelName == names.CLASS) vis = RetentionPolicy.CLASS;
duke@1 826 else if (levelName == names.RUNTIME) vis = RetentionPolicy.RUNTIME;
duke@1 827 else ;// /* fail soft */ throw new AssertionError(levelName);
duke@1 828 }
duke@1 829 }
duke@1 830 return vis;
duke@1 831 }
duke@1 832
duke@1 833 /** A visitor to write an attribute including its leading
duke@1 834 * single-character marker.
duke@1 835 */
duke@1 836 class AttributeWriter implements Attribute.Visitor {
duke@1 837 public void visitConstant(Attribute.Constant _value) {
duke@1 838 Object value = _value.value;
duke@1 839 switch (_value.type.tag) {
duke@1 840 case BYTE:
duke@1 841 databuf.appendByte('B');
duke@1 842 break;
duke@1 843 case CHAR:
duke@1 844 databuf.appendByte('C');
duke@1 845 break;
duke@1 846 case SHORT:
duke@1 847 databuf.appendByte('S');
duke@1 848 break;
duke@1 849 case INT:
duke@1 850 databuf.appendByte('I');
duke@1 851 break;
duke@1 852 case LONG:
duke@1 853 databuf.appendByte('J');
duke@1 854 break;
duke@1 855 case FLOAT:
duke@1 856 databuf.appendByte('F');
duke@1 857 break;
duke@1 858 case DOUBLE:
duke@1 859 databuf.appendByte('D');
duke@1 860 break;
duke@1 861 case BOOLEAN:
duke@1 862 databuf.appendByte('Z');
duke@1 863 break;
duke@1 864 case CLASS:
duke@1 865 assert value instanceof String;
duke@1 866 databuf.appendByte('s');
duke@1 867 value = names.fromString(value.toString()); // CONSTANT_Utf8
duke@1 868 break;
duke@1 869 default:
duke@1 870 throw new AssertionError(_value.type);
duke@1 871 }
duke@1 872 databuf.appendChar(pool.put(value));
duke@1 873 }
duke@1 874 public void visitEnum(Attribute.Enum e) {
duke@1 875 databuf.appendByte('e');
duke@1 876 databuf.appendChar(pool.put(typeSig(e.value.type)));
duke@1 877 databuf.appendChar(pool.put(e.value.name));
duke@1 878 }
duke@1 879 public void visitClass(Attribute.Class clazz) {
duke@1 880 databuf.appendByte('c');
duke@1 881 databuf.appendChar(pool.put(typeSig(clazz.type)));
duke@1 882 }
duke@1 883 public void visitCompound(Attribute.Compound compound) {
duke@1 884 databuf.appendByte('@');
duke@1 885 writeCompoundAttribute(compound);
duke@1 886 }
duke@1 887 public void visitError(Attribute.Error x) {
duke@1 888 throw new AssertionError(x);
duke@1 889 }
duke@1 890 public void visitArray(Attribute.Array array) {
duke@1 891 databuf.appendByte('[');
duke@1 892 databuf.appendChar(array.values.length);
duke@1 893 for (Attribute a : array.values) {
duke@1 894 a.accept(this);
duke@1 895 }
duke@1 896 }
duke@1 897 }
duke@1 898 AttributeWriter awriter = new AttributeWriter();
duke@1 899
duke@1 900 /** Write a compound attribute excluding the '@' marker. */
duke@1 901 void writeCompoundAttribute(Attribute.Compound c) {
duke@1 902 databuf.appendChar(pool.put(typeSig(c.type)));
duke@1 903 databuf.appendChar(c.values.length());
duke@1 904 for (Pair<Symbol.MethodSymbol,Attribute> p : c.values) {
duke@1 905 databuf.appendChar(pool.put(p.fst.name));
duke@1 906 p.snd.accept(awriter);
duke@1 907 }
duke@1 908 }
duke@1 909
jjg@308 910 void writeTypeAnnotation(Attribute.TypeCompound c) {
jjg@310 911 if (debugJSR308)
jjg@310 912 System.out.println("TA: writing " + c + " at " + c.position
jjg@310 913 + " in " + log.currentSourceFile());
jjg@310 914 writeCompoundAttribute(c);
jjg@310 915 writePosition(c.position);
jjg@308 916 }
jjg@308 917
jjg@308 918 void writePosition(TypeAnnotationPosition p) {
jjg@308 919 databuf.appendByte(p.type.targetTypeValue());
jjg@308 920 switch (p.type) {
jjg@308 921 // type case
jjg@308 922 case TYPECAST:
jjg@308 923 case TYPECAST_GENERIC_OR_ARRAY:
jjg@308 924 // object creation
jjg@308 925 case INSTANCEOF:
jjg@308 926 case INSTANCEOF_GENERIC_OR_ARRAY:
jjg@308 927 // new expression
jjg@308 928 case NEW:
jjg@308 929 case NEW_GENERIC_OR_ARRAY:
jjg@308 930 databuf.appendChar(p.offset);
jjg@308 931 break;
jjg@308 932 // local variable
jjg@308 933 case LOCAL_VARIABLE:
jjg@308 934 case LOCAL_VARIABLE_GENERIC_OR_ARRAY:
jjg@308 935 databuf.appendChar(p.lvarOffset.length); // for table length
jjg@308 936 for (int i = 0; i < p.lvarOffset.length; ++i) {
jjg@308 937 databuf.appendChar(p.lvarOffset[i]);
jjg@308 938 databuf.appendChar(p.lvarLength[i]);
jjg@308 939 databuf.appendChar(p.lvarIndex[i]);
jjg@308 940 }
jjg@308 941 break;
jjg@308 942 // method receiver
jjg@308 943 case METHOD_RECEIVER:
jjg@308 944 // Do nothing
jjg@308 945 break;
jjg@308 946 // type parameters
jjg@308 947 case CLASS_TYPE_PARAMETER:
jjg@308 948 case METHOD_TYPE_PARAMETER:
jjg@308 949 databuf.appendByte(p.parameter_index);
jjg@308 950 break;
jjg@308 951 // type parameters bounds
jjg@308 952 case CLASS_TYPE_PARAMETER_BOUND:
jjg@308 953 case CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
jjg@308 954 case METHOD_TYPE_PARAMETER_BOUND:
jjg@308 955 case METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
jjg@308 956 databuf.appendByte(p.parameter_index);
jjg@308 957 databuf.appendByte(p.bound_index);
jjg@308 958 break;
jjg@308 959 // wildcards
jjg@308 960 case WILDCARD_BOUND:
jjg@308 961 case WILDCARD_BOUND_GENERIC_OR_ARRAY:
jjg@308 962 writePosition(p.wildcard_position);
jjg@308 963 break;
jjg@308 964 // Class extends and implements clauses
jjg@308 965 case CLASS_EXTENDS:
jjg@308 966 case CLASS_EXTENDS_GENERIC_OR_ARRAY:
jjg@308 967 databuf.appendByte(p.type_index);
jjg@308 968 break;
jjg@308 969 // throws
jjg@308 970 case THROWS:
jjg@308 971 databuf.appendByte(p.type_index);
jjg@308 972 break;
jjg@308 973 case CLASS_LITERAL:
jjg@308 974 case CLASS_LITERAL_GENERIC_OR_ARRAY:
jjg@308 975 databuf.appendChar(p.offset);
jjg@308 976 break;
jjg@308 977 // method parameter: not specified
jjg@308 978 case METHOD_PARAMETER_GENERIC_OR_ARRAY:
jjg@308 979 databuf.appendByte(p.parameter_index);
jjg@308 980 break;
jjg@308 981 // method type argument: wasn't specified
jjg@308 982 case NEW_TYPE_ARGUMENT:
jjg@308 983 case NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
jjg@308 984 case METHOD_TYPE_ARGUMENT:
jjg@308 985 case METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
jjg@308 986 databuf.appendChar(p.offset);
jjg@308 987 databuf.appendByte(p.type_index);
jjg@308 988 break;
jjg@308 989 // We don't need to worry abut these
jjg@308 990 case METHOD_RETURN_GENERIC_OR_ARRAY:
jjg@308 991 case FIELD_GENERIC_OR_ARRAY:
jjg@308 992 break;
jjg@308 993 case UNKNOWN:
jjg@308 994 break;
jjg@308 995 default:
jjg@308 996 throw new AssertionError("unknown position: " + p);
jjg@308 997 }
jjg@308 998
jjg@308 999 // Append location data for generics/arrays.
jjg@308 1000 if (p.type.hasLocation()) {
jjg@308 1001 databuf.appendChar(p.location.size());
jjg@308 1002 for (int i : p.location)
jjg@308 1003 databuf.appendByte((byte)i);
jjg@308 1004 }
jjg@308 1005 }
jjg@308 1006
duke@1 1007 /**********************************************************************
duke@1 1008 * Writing Objects
duke@1 1009 **********************************************************************/
duke@1 1010
duke@1 1011 /** Enter an inner class into the `innerClasses' set/queue.
duke@1 1012 */
duke@1 1013 void enterInner(ClassSymbol c) {
duke@1 1014 assert !c.type.isCompound();
duke@1 1015 try {
duke@1 1016 c.complete();
duke@1 1017 } catch (CompletionFailure ex) {
duke@1 1018 System.err.println("error: " + c + ": " + ex.getMessage());
duke@1 1019 throw ex;
duke@1 1020 }
duke@1 1021 if (c.type.tag != CLASS) return; // arrays
duke@1 1022 if (pool != null && // pool might be null if called from xClassName
duke@1 1023 c.owner.kind != PCK &&
duke@1 1024 (innerClasses == null || !innerClasses.contains(c))) {
duke@1 1025 // log.errWriter.println("enter inner " + c);//DEBUG
duke@1 1026 if (c.owner.kind == TYP) enterInner((ClassSymbol)c.owner);
duke@1 1027 pool.put(c);
duke@1 1028 pool.put(c.name);
duke@1 1029 if (innerClasses == null) {
duke@1 1030 innerClasses = new HashSet<ClassSymbol>();
duke@1 1031 innerClassesQueue = new ListBuffer<ClassSymbol>();
duke@1 1032 pool.put(names.InnerClasses);
duke@1 1033 }
duke@1 1034 innerClasses.add(c);
duke@1 1035 innerClassesQueue.append(c);
duke@1 1036 }
duke@1 1037 }
duke@1 1038
duke@1 1039 /** Write "inner classes" attribute.
duke@1 1040 */
duke@1 1041 void writeInnerClasses() {
duke@1 1042 int alenIdx = writeAttr(names.InnerClasses);
duke@1 1043 databuf.appendChar(innerClassesQueue.length());
duke@1 1044 for (List<ClassSymbol> l = innerClassesQueue.toList();
duke@1 1045 l.nonEmpty();
duke@1 1046 l = l.tail) {
duke@1 1047 ClassSymbol inner = l.head;
duke@1 1048 char flags = (char) adjustFlags(inner.flags_field);
duke@1 1049 if ((flags & INTERFACE) != 0) flags |= ABSTRACT; // Interfaces are always ABSTRACT
duke@1 1050 if (inner.name.isEmpty()) flags &= ~FINAL; // Anonymous class: unset FINAL flag
duke@1 1051 if (dumpInnerClassModifiers) {
duke@1 1052 log.errWriter.println("INNERCLASS " + inner.name);
duke@1 1053 log.errWriter.println("---" + flagNames(flags));
duke@1 1054 }
duke@1 1055 databuf.appendChar(pool.get(inner));
duke@1 1056 databuf.appendChar(
duke@1 1057 inner.owner.kind == TYP ? pool.get(inner.owner) : 0);
duke@1 1058 databuf.appendChar(
jjg@113 1059 !inner.name.isEmpty() ? pool.get(inner.name) : 0);
duke@1 1060 databuf.appendChar(flags);
duke@1 1061 }
duke@1 1062 endAttr(alenIdx);
duke@1 1063 }
duke@1 1064
duke@1 1065 /** Write field symbol, entering all references into constant pool.
duke@1 1066 */
duke@1 1067 void writeField(VarSymbol v) {
duke@1 1068 int flags = adjustFlags(v.flags());
duke@1 1069 databuf.appendChar(flags);
duke@1 1070 if (dumpFieldModifiers) {
duke@1 1071 log.errWriter.println("FIELD " + fieldName(v));
duke@1 1072 log.errWriter.println("---" + flagNames(v.flags()));
duke@1 1073 }
duke@1 1074 databuf.appendChar(pool.put(fieldName(v)));
duke@1 1075 databuf.appendChar(pool.put(typeSig(v.erasure(types))));
duke@1 1076 int acountIdx = beginAttrs();
duke@1 1077 int acount = 0;
duke@1 1078 if (v.getConstValue() != null) {
duke@1 1079 int alenIdx = writeAttr(names.ConstantValue);
duke@1 1080 databuf.appendChar(pool.put(v.getConstValue()));
duke@1 1081 endAttr(alenIdx);
duke@1 1082 acount++;
duke@1 1083 }
duke@1 1084 acount += writeMemberAttrs(v);
duke@1 1085 endAttrs(acountIdx, acount);
duke@1 1086 }
duke@1 1087
duke@1 1088 /** Write method symbol, entering all references into constant pool.
duke@1 1089 */
duke@1 1090 void writeMethod(MethodSymbol m) {
duke@1 1091 int flags = adjustFlags(m.flags());
duke@1 1092 databuf.appendChar(flags);
duke@1 1093 if (dumpMethodModifiers) {
duke@1 1094 log.errWriter.println("METHOD " + fieldName(m));
duke@1 1095 log.errWriter.println("---" + flagNames(m.flags()));
duke@1 1096 }
duke@1 1097 databuf.appendChar(pool.put(fieldName(m)));
duke@1 1098 databuf.appendChar(pool.put(typeSig(m.externalType(types))));
duke@1 1099 int acountIdx = beginAttrs();
duke@1 1100 int acount = 0;
duke@1 1101 if (m.code != null) {
duke@1 1102 int alenIdx = writeAttr(names.Code);
duke@1 1103 writeCode(m.code);
duke@1 1104 m.code = null; // to conserve space
duke@1 1105 endAttr(alenIdx);
duke@1 1106 acount++;
duke@1 1107 }
duke@1 1108 List<Type> thrown = m.erasure(types).getThrownTypes();
duke@1 1109 if (thrown.nonEmpty()) {
duke@1 1110 int alenIdx = writeAttr(names.Exceptions);
duke@1 1111 databuf.appendChar(thrown.length());
duke@1 1112 for (List<Type> l = thrown; l.nonEmpty(); l = l.tail)
duke@1 1113 databuf.appendChar(pool.put(l.head.tsym));
duke@1 1114 endAttr(alenIdx);
duke@1 1115 acount++;
duke@1 1116 }
duke@1 1117 if (m.defaultValue != null) {
duke@1 1118 int alenIdx = writeAttr(names.AnnotationDefault);
duke@1 1119 m.defaultValue.accept(awriter);
duke@1 1120 endAttr(alenIdx);
duke@1 1121 acount++;
duke@1 1122 }
duke@1 1123 acount += writeMemberAttrs(m);
duke@1 1124 acount += writeParameterAttrs(m);
duke@1 1125 endAttrs(acountIdx, acount);
duke@1 1126 }
duke@1 1127
duke@1 1128 /** Write code attribute of method.
duke@1 1129 */
duke@1 1130 void writeCode(Code code) {
duke@1 1131 databuf.appendChar(code.max_stack);
duke@1 1132 databuf.appendChar(code.max_locals);
duke@1 1133 databuf.appendInt(code.cp);
duke@1 1134 databuf.appendBytes(code.code, 0, code.cp);
duke@1 1135 databuf.appendChar(code.catchInfo.length());
duke@1 1136 for (List<char[]> l = code.catchInfo.toList();
duke@1 1137 l.nonEmpty();
duke@1 1138 l = l.tail) {
duke@1 1139 for (int i = 0; i < l.head.length; i++)
duke@1 1140 databuf.appendChar(l.head[i]);
duke@1 1141 }
duke@1 1142 int acountIdx = beginAttrs();
duke@1 1143 int acount = 0;
duke@1 1144
duke@1 1145 if (code.lineInfo.nonEmpty()) {
duke@1 1146 int alenIdx = writeAttr(names.LineNumberTable);
duke@1 1147 databuf.appendChar(code.lineInfo.length());
duke@1 1148 for (List<char[]> l = code.lineInfo.reverse();
duke@1 1149 l.nonEmpty();
duke@1 1150 l = l.tail)
duke@1 1151 for (int i = 0; i < l.head.length; i++)
duke@1 1152 databuf.appendChar(l.head[i]);
duke@1 1153 endAttr(alenIdx);
duke@1 1154 acount++;
duke@1 1155 }
duke@1 1156
duke@1 1157 if (genCrt && (code.crt != null)) {
duke@1 1158 CRTable crt = code.crt;
duke@1 1159 int alenIdx = writeAttr(names.CharacterRangeTable);
duke@1 1160 int crtIdx = beginAttrs();
duke@1 1161 int crtEntries = crt.writeCRT(databuf, code.lineMap, log);
duke@1 1162 endAttrs(crtIdx, crtEntries);
duke@1 1163 endAttr(alenIdx);
duke@1 1164 acount++;
duke@1 1165 }
duke@1 1166
duke@1 1167 // counter for number of generic local variables
duke@1 1168 int nGenericVars = 0;
duke@1 1169
duke@1 1170 if (code.varBufferSize > 0) {
duke@1 1171 int alenIdx = writeAttr(names.LocalVariableTable);
duke@1 1172 databuf.appendChar(code.varBufferSize);
duke@1 1173
duke@1 1174 for (int i=0; i<code.varBufferSize; i++) {
duke@1 1175 Code.LocalVar var = code.varBuffer[i];
duke@1 1176
duke@1 1177 // write variable info
duke@1 1178 assert var.start_pc >= 0;
duke@1 1179 assert var.start_pc <= code.cp;
duke@1 1180 databuf.appendChar(var.start_pc);
duke@1 1181 assert var.length >= 0;
duke@1 1182 assert (var.start_pc + var.length) <= code.cp;
duke@1 1183 databuf.appendChar(var.length);
duke@1 1184 VarSymbol sym = var.sym;
duke@1 1185 databuf.appendChar(pool.put(sym.name));
duke@1 1186 Type vartype = sym.erasure(types);
duke@1 1187 if (!types.isSameType(sym.type, vartype))
duke@1 1188 nGenericVars++;
duke@1 1189 databuf.appendChar(pool.put(typeSig(vartype)));
duke@1 1190 databuf.appendChar(var.reg);
duke@1 1191 }
duke@1 1192 endAttr(alenIdx);
duke@1 1193 acount++;
duke@1 1194 }
duke@1 1195
duke@1 1196 if (nGenericVars > 0) {
duke@1 1197 int alenIdx = writeAttr(names.LocalVariableTypeTable);
duke@1 1198 databuf.appendChar(nGenericVars);
duke@1 1199 int count = 0;
duke@1 1200
duke@1 1201 for (int i=0; i<code.varBufferSize; i++) {
duke@1 1202 Code.LocalVar var = code.varBuffer[i];
duke@1 1203 VarSymbol sym = var.sym;
duke@1 1204 if (types.isSameType(sym.type, sym.erasure(types)))
duke@1 1205 continue;
duke@1 1206 count++;
duke@1 1207 // write variable info
duke@1 1208 databuf.appendChar(var.start_pc);
duke@1 1209 databuf.appendChar(var.length);
duke@1 1210 databuf.appendChar(pool.put(sym.name));
duke@1 1211 databuf.appendChar(pool.put(typeSig(sym.type)));
duke@1 1212 databuf.appendChar(var.reg);
duke@1 1213 }
duke@1 1214 assert count == nGenericVars;
duke@1 1215 endAttr(alenIdx);
duke@1 1216 acount++;
duke@1 1217 }
duke@1 1218
duke@1 1219 if (code.stackMapBufferSize > 0) {
duke@1 1220 if (debugstackmap) System.out.println("Stack map for " + code.meth);
duke@1 1221 int alenIdx = writeAttr(code.stackMap.getAttributeName(names));
duke@1 1222 writeStackMap(code);
duke@1 1223 endAttr(alenIdx);
duke@1 1224 acount++;
duke@1 1225 }
duke@1 1226 endAttrs(acountIdx, acount);
duke@1 1227 }
duke@1 1228
duke@1 1229 void writeStackMap(Code code) {
duke@1 1230 int nframes = code.stackMapBufferSize;
duke@1 1231 if (debugstackmap) System.out.println(" nframes = " + nframes);
duke@1 1232 databuf.appendChar(nframes);
duke@1 1233
duke@1 1234 switch (code.stackMap) {
duke@1 1235 case CLDC:
duke@1 1236 for (int i=0; i<nframes; i++) {
duke@1 1237 if (debugstackmap) System.out.print(" " + i + ":");
duke@1 1238 Code.StackMapFrame frame = code.stackMapBuffer[i];
duke@1 1239
duke@1 1240 // output PC
duke@1 1241 if (debugstackmap) System.out.print(" pc=" + frame.pc);
duke@1 1242 databuf.appendChar(frame.pc);
duke@1 1243
duke@1 1244 // output locals
duke@1 1245 int localCount = 0;
duke@1 1246 for (int j=0; j<frame.locals.length;
duke@1 1247 j += (target.generateEmptyAfterBig() ? 1 : Code.width(frame.locals[j]))) {
duke@1 1248 localCount++;
duke@1 1249 }
duke@1 1250 if (debugstackmap) System.out.print(" nlocals=" +
duke@1 1251 localCount);
duke@1 1252 databuf.appendChar(localCount);
duke@1 1253 for (int j=0; j<frame.locals.length;
duke@1 1254 j += (target.generateEmptyAfterBig() ? 1 : Code.width(frame.locals[j]))) {
duke@1 1255 if (debugstackmap) System.out.print(" local[" + j + "]=");
duke@1 1256 writeStackMapType(frame.locals[j]);
duke@1 1257 }
duke@1 1258
duke@1 1259 // output stack
duke@1 1260 int stackCount = 0;
duke@1 1261 for (int j=0; j<frame.stack.length;
duke@1 1262 j += (target.generateEmptyAfterBig() ? 1 : Code.width(frame.stack[j]))) {
duke@1 1263 stackCount++;
duke@1 1264 }
duke@1 1265 if (debugstackmap) System.out.print(" nstack=" +
duke@1 1266 stackCount);
duke@1 1267 databuf.appendChar(stackCount);
duke@1 1268 for (int j=0; j<frame.stack.length;
duke@1 1269 j += (target.generateEmptyAfterBig() ? 1 : Code.width(frame.stack[j]))) {
duke@1 1270 if (debugstackmap) System.out.print(" stack[" + j + "]=");
duke@1 1271 writeStackMapType(frame.stack[j]);
duke@1 1272 }
duke@1 1273 if (debugstackmap) System.out.println();
duke@1 1274 }
duke@1 1275 break;
duke@1 1276 case JSR202: {
duke@1 1277 assert code.stackMapBuffer == null;
duke@1 1278 for (int i=0; i<nframes; i++) {
duke@1 1279 if (debugstackmap) System.out.print(" " + i + ":");
duke@1 1280 StackMapTableFrame frame = code.stackMapTableBuffer[i];
duke@1 1281 frame.write(this);
duke@1 1282 if (debugstackmap) System.out.println();
duke@1 1283 }
duke@1 1284 break;
duke@1 1285 }
duke@1 1286 default:
duke@1 1287 throw new AssertionError("Unexpected stackmap format value");
duke@1 1288 }
duke@1 1289 }
duke@1 1290
duke@1 1291 //where
duke@1 1292 void writeStackMapType(Type t) {
duke@1 1293 if (t == null) {
duke@1 1294 if (debugstackmap) System.out.print("empty");
duke@1 1295 databuf.appendByte(0);
duke@1 1296 }
duke@1 1297 else switch(t.tag) {
duke@1 1298 case BYTE:
duke@1 1299 case CHAR:
duke@1 1300 case SHORT:
duke@1 1301 case INT:
duke@1 1302 case BOOLEAN:
duke@1 1303 if (debugstackmap) System.out.print("int");
duke@1 1304 databuf.appendByte(1);
duke@1 1305 break;
duke@1 1306 case FLOAT:
duke@1 1307 if (debugstackmap) System.out.print("float");
duke@1 1308 databuf.appendByte(2);
duke@1 1309 break;
duke@1 1310 case DOUBLE:
duke@1 1311 if (debugstackmap) System.out.print("double");
duke@1 1312 databuf.appendByte(3);
duke@1 1313 break;
duke@1 1314 case LONG:
duke@1 1315 if (debugstackmap) System.out.print("long");
duke@1 1316 databuf.appendByte(4);
duke@1 1317 break;
duke@1 1318 case BOT: // null
duke@1 1319 if (debugstackmap) System.out.print("null");
duke@1 1320 databuf.appendByte(5);
duke@1 1321 break;
duke@1 1322 case CLASS:
duke@1 1323 case ARRAY:
duke@1 1324 if (debugstackmap) System.out.print("object(" + t + ")");
duke@1 1325 databuf.appendByte(7);
duke@1 1326 databuf.appendChar(pool.put(t));
duke@1 1327 break;
duke@1 1328 case TYPEVAR:
duke@1 1329 if (debugstackmap) System.out.print("object(" + types.erasure(t).tsym + ")");
duke@1 1330 databuf.appendByte(7);
duke@1 1331 databuf.appendChar(pool.put(types.erasure(t).tsym));
duke@1 1332 break;
duke@1 1333 case UNINITIALIZED_THIS:
duke@1 1334 if (debugstackmap) System.out.print("uninit_this");
duke@1 1335 databuf.appendByte(6);
duke@1 1336 break;
duke@1 1337 case UNINITIALIZED_OBJECT:
duke@1 1338 { UninitializedType uninitType = (UninitializedType)t;
duke@1 1339 databuf.appendByte(8);
duke@1 1340 if (debugstackmap) System.out.print("uninit_object@" + uninitType.offset);
duke@1 1341 databuf.appendChar(uninitType.offset);
duke@1 1342 }
duke@1 1343 break;
duke@1 1344 default:
duke@1 1345 throw new AssertionError();
duke@1 1346 }
duke@1 1347 }
duke@1 1348
duke@1 1349 /** An entry in the JSR202 StackMapTable */
duke@1 1350 abstract static class StackMapTableFrame {
duke@1 1351 abstract int getFrameType();
duke@1 1352
duke@1 1353 void write(ClassWriter writer) {
duke@1 1354 int frameType = getFrameType();
duke@1 1355 writer.databuf.appendByte(frameType);
duke@1 1356 if (writer.debugstackmap) System.out.print(" frame_type=" + frameType);
duke@1 1357 }
duke@1 1358
duke@1 1359 static class SameFrame extends StackMapTableFrame {
duke@1 1360 final int offsetDelta;
duke@1 1361 SameFrame(int offsetDelta) {
duke@1 1362 this.offsetDelta = offsetDelta;
duke@1 1363 }
duke@1 1364 int getFrameType() {
duke@1 1365 return (offsetDelta < SAME_FRAME_SIZE) ? offsetDelta : SAME_FRAME_EXTENDED;
duke@1 1366 }
duke@1 1367 @Override
duke@1 1368 void write(ClassWriter writer) {
duke@1 1369 super.write(writer);
duke@1 1370 if (getFrameType() == SAME_FRAME_EXTENDED) {
duke@1 1371 writer.databuf.appendChar(offsetDelta);
duke@1 1372 if (writer.debugstackmap){
duke@1 1373 System.out.print(" offset_delta=" + offsetDelta);
duke@1 1374 }
duke@1 1375 }
duke@1 1376 }
duke@1 1377 }
duke@1 1378
duke@1 1379 static class SameLocals1StackItemFrame extends StackMapTableFrame {
duke@1 1380 final int offsetDelta;
duke@1 1381 final Type stack;
duke@1 1382 SameLocals1StackItemFrame(int offsetDelta, Type stack) {
duke@1 1383 this.offsetDelta = offsetDelta;
duke@1 1384 this.stack = stack;
duke@1 1385 }
duke@1 1386 int getFrameType() {
duke@1 1387 return (offsetDelta < SAME_FRAME_SIZE) ?
duke@1 1388 (SAME_FRAME_SIZE + offsetDelta) :
duke@1 1389 SAME_LOCALS_1_STACK_ITEM_EXTENDED;
duke@1 1390 }
duke@1 1391 @Override
duke@1 1392 void write(ClassWriter writer) {
duke@1 1393 super.write(writer);
duke@1 1394 if (getFrameType() == SAME_LOCALS_1_STACK_ITEM_EXTENDED) {
duke@1 1395 writer.databuf.appendChar(offsetDelta);
duke@1 1396 if (writer.debugstackmap) {
duke@1 1397 System.out.print(" offset_delta=" + offsetDelta);
duke@1 1398 }
duke@1 1399 }
duke@1 1400 if (writer.debugstackmap) {
duke@1 1401 System.out.print(" stack[" + 0 + "]=");
duke@1 1402 }
duke@1 1403 writer.writeStackMapType(stack);
duke@1 1404 }
duke@1 1405 }
duke@1 1406
duke@1 1407 static class ChopFrame extends StackMapTableFrame {
duke@1 1408 final int frameType;
duke@1 1409 final int offsetDelta;
duke@1 1410 ChopFrame(int frameType, int offsetDelta) {
duke@1 1411 this.frameType = frameType;
duke@1 1412 this.offsetDelta = offsetDelta;
duke@1 1413 }
duke@1 1414 int getFrameType() { return frameType; }
duke@1 1415 @Override
duke@1 1416 void write(ClassWriter writer) {
duke@1 1417 super.write(writer);
duke@1 1418 writer.databuf.appendChar(offsetDelta);
duke@1 1419 if (writer.debugstackmap) {
duke@1 1420 System.out.print(" offset_delta=" + offsetDelta);
duke@1 1421 }
duke@1 1422 }
duke@1 1423 }
duke@1 1424
duke@1 1425 static class AppendFrame extends StackMapTableFrame {
duke@1 1426 final int frameType;
duke@1 1427 final int offsetDelta;
duke@1 1428 final Type[] locals;
duke@1 1429 AppendFrame(int frameType, int offsetDelta, Type[] locals) {
duke@1 1430 this.frameType = frameType;
duke@1 1431 this.offsetDelta = offsetDelta;
duke@1 1432 this.locals = locals;
duke@1 1433 }
duke@1 1434 int getFrameType() { return frameType; }
duke@1 1435 @Override
duke@1 1436 void write(ClassWriter writer) {
duke@1 1437 super.write(writer);
duke@1 1438 writer.databuf.appendChar(offsetDelta);
duke@1 1439 if (writer.debugstackmap) {
duke@1 1440 System.out.print(" offset_delta=" + offsetDelta);
duke@1 1441 }
duke@1 1442 for (int i=0; i<locals.length; i++) {
duke@1 1443 if (writer.debugstackmap) System.out.print(" locals[" + i + "]=");
duke@1 1444 writer.writeStackMapType(locals[i]);
duke@1 1445 }
duke@1 1446 }
duke@1 1447 }
duke@1 1448
duke@1 1449 static class FullFrame extends StackMapTableFrame {
duke@1 1450 final int offsetDelta;
duke@1 1451 final Type[] locals;
duke@1 1452 final Type[] stack;
duke@1 1453 FullFrame(int offsetDelta, Type[] locals, Type[] stack) {
duke@1 1454 this.offsetDelta = offsetDelta;
duke@1 1455 this.locals = locals;
duke@1 1456 this.stack = stack;
duke@1 1457 }
duke@1 1458 int getFrameType() { return FULL_FRAME; }
duke@1 1459 @Override
duke@1 1460 void write(ClassWriter writer) {
duke@1 1461 super.write(writer);
duke@1 1462 writer.databuf.appendChar(offsetDelta);
duke@1 1463 writer.databuf.appendChar(locals.length);
duke@1 1464 if (writer.debugstackmap) {
duke@1 1465 System.out.print(" offset_delta=" + offsetDelta);
duke@1 1466 System.out.print(" nlocals=" + locals.length);
duke@1 1467 }
duke@1 1468 for (int i=0; i<locals.length; i++) {
duke@1 1469 if (writer.debugstackmap) System.out.print(" locals[" + i + "]=");
duke@1 1470 writer.writeStackMapType(locals[i]);
duke@1 1471 }
duke@1 1472
duke@1 1473 writer.databuf.appendChar(stack.length);
duke@1 1474 if (writer.debugstackmap) { System.out.print(" nstack=" + stack.length); }
duke@1 1475 for (int i=0; i<stack.length; i++) {
duke@1 1476 if (writer.debugstackmap) System.out.print(" stack[" + i + "]=");
duke@1 1477 writer.writeStackMapType(stack[i]);
duke@1 1478 }
duke@1 1479 }
duke@1 1480 }
duke@1 1481
duke@1 1482 /** Compare this frame with the previous frame and produce
duke@1 1483 * an entry of compressed stack map frame. */
duke@1 1484 static StackMapTableFrame getInstance(Code.StackMapFrame this_frame,
duke@1 1485 int prev_pc,
duke@1 1486 Type[] prev_locals,
duke@1 1487 Types types) {
duke@1 1488 Type[] locals = this_frame.locals;
duke@1 1489 Type[] stack = this_frame.stack;
duke@1 1490 int offset_delta = this_frame.pc - prev_pc - 1;
duke@1 1491 if (stack.length == 1) {
duke@1 1492 if (locals.length == prev_locals.length
duke@1 1493 && compare(prev_locals, locals, types) == 0) {
duke@1 1494 return new SameLocals1StackItemFrame(offset_delta, stack[0]);
duke@1 1495 }
duke@1 1496 } else if (stack.length == 0) {
duke@1 1497 int diff_length = compare(prev_locals, locals, types);
duke@1 1498 if (diff_length == 0) {
duke@1 1499 return new SameFrame(offset_delta);
duke@1 1500 } else if (-MAX_LOCAL_LENGTH_DIFF < diff_length && diff_length < 0) {
duke@1 1501 // APPEND
duke@1 1502 Type[] local_diff = new Type[-diff_length];
duke@1 1503 for (int i=prev_locals.length, j=0; i<locals.length; i++,j++) {
duke@1 1504 local_diff[j] = locals[i];
duke@1 1505 }
duke@1 1506 return new AppendFrame(SAME_FRAME_EXTENDED - diff_length,
duke@1 1507 offset_delta,
duke@1 1508 local_diff);
duke@1 1509 } else if (0 < diff_length && diff_length < MAX_LOCAL_LENGTH_DIFF) {
duke@1 1510 // CHOP
duke@1 1511 return new ChopFrame(SAME_FRAME_EXTENDED - diff_length,
duke@1 1512 offset_delta);
duke@1 1513 }
duke@1 1514 }
duke@1 1515 // FULL_FRAME
duke@1 1516 return new FullFrame(offset_delta, locals, stack);
duke@1 1517 }
duke@1 1518
duke@1 1519 static boolean isInt(Type t) {
duke@1 1520 return (t.tag < TypeTags.INT || t.tag == TypeTags.BOOLEAN);
duke@1 1521 }
duke@1 1522
duke@1 1523 static boolean isSameType(Type t1, Type t2, Types types) {
duke@1 1524 if (t1 == null) { return t2 == null; }
duke@1 1525 if (t2 == null) { return false; }
duke@1 1526
duke@1 1527 if (isInt(t1) && isInt(t2)) { return true; }
duke@1 1528
duke@1 1529 if (t1.tag == UNINITIALIZED_THIS) {
duke@1 1530 return t2.tag == UNINITIALIZED_THIS;
duke@1 1531 } else if (t1.tag == UNINITIALIZED_OBJECT) {
duke@1 1532 if (t2.tag == UNINITIALIZED_OBJECT) {
duke@1 1533 return ((UninitializedType)t1).offset == ((UninitializedType)t2).offset;
duke@1 1534 } else {
duke@1 1535 return false;
duke@1 1536 }
duke@1 1537 } else if (t2.tag == UNINITIALIZED_THIS || t2.tag == UNINITIALIZED_OBJECT) {
duke@1 1538 return false;
duke@1 1539 }
duke@1 1540
duke@1 1541 return types.isSameType(t1, t2);
duke@1 1542 }
duke@1 1543
duke@1 1544 static int compare(Type[] arr1, Type[] arr2, Types types) {
duke@1 1545 int diff_length = arr1.length - arr2.length;
duke@1 1546 if (diff_length > MAX_LOCAL_LENGTH_DIFF || diff_length < -MAX_LOCAL_LENGTH_DIFF) {
duke@1 1547 return Integer.MAX_VALUE;
duke@1 1548 }
duke@1 1549 int len = (diff_length > 0) ? arr2.length : arr1.length;
duke@1 1550 for (int i=0; i<len; i++) {
duke@1 1551 if (!isSameType(arr1[i], arr2[i], types)) {
duke@1 1552 return Integer.MAX_VALUE;
duke@1 1553 }
duke@1 1554 }
duke@1 1555 return diff_length;
duke@1 1556 }
duke@1 1557 }
duke@1 1558
duke@1 1559 void writeFields(Scope.Entry e) {
duke@1 1560 // process them in reverse sibling order;
duke@1 1561 // i.e., process them in declaration order.
duke@1 1562 List<VarSymbol> vars = List.nil();
duke@1 1563 for (Scope.Entry i = e; i != null; i = i.sibling) {
duke@1 1564 if (i.sym.kind == VAR) vars = vars.prepend((VarSymbol)i.sym);
duke@1 1565 }
duke@1 1566 while (vars.nonEmpty()) {
duke@1 1567 writeField(vars.head);
duke@1 1568 vars = vars.tail;
duke@1 1569 }
duke@1 1570 }
duke@1 1571
duke@1 1572 void writeMethods(Scope.Entry e) {
duke@1 1573 List<MethodSymbol> methods = List.nil();
duke@1 1574 for (Scope.Entry i = e; i != null; i = i.sibling) {
duke@1 1575 if (i.sym.kind == MTH && (i.sym.flags() & HYPOTHETICAL) == 0)
duke@1 1576 methods = methods.prepend((MethodSymbol)i.sym);
duke@1 1577 }
duke@1 1578 while (methods.nonEmpty()) {
duke@1 1579 writeMethod(methods.head);
duke@1 1580 methods = methods.tail;
duke@1 1581 }
duke@1 1582 }
duke@1 1583
duke@1 1584 /** Emit a class file for a given class.
duke@1 1585 * @param c The class from which a class file is generated.
duke@1 1586 */
duke@1 1587 public JavaFileObject writeClass(ClassSymbol c)
duke@1 1588 throws IOException, PoolOverflow, StringOverflow
duke@1 1589 {
duke@1 1590 JavaFileObject outFile
duke@1 1591 = fileManager.getJavaFileForOutput(CLASS_OUTPUT,
duke@1 1592 c.flatname.toString(),
duke@1 1593 JavaFileObject.Kind.CLASS,
duke@1 1594 c.sourcefile);
duke@1 1595 OutputStream out = outFile.openOutputStream();
duke@1 1596 try {
duke@1 1597 writeClassFile(out, c);
duke@1 1598 if (verbose)
jjg@113 1599 log.errWriter.println(Log.getLocalizedString("verbose.wrote.file", outFile));
duke@1 1600 out.close();
duke@1 1601 out = null;
duke@1 1602 } finally {
duke@1 1603 if (out != null) {
duke@1 1604 // if we are propogating an exception, delete the file
duke@1 1605 out.close();
duke@1 1606 outFile.delete();
duke@1 1607 outFile = null;
duke@1 1608 }
duke@1 1609 }
duke@1 1610 return outFile; // may be null if write failed
duke@1 1611 }
duke@1 1612
duke@1 1613 /** Write class `c' to outstream `out'.
duke@1 1614 */
duke@1 1615 public void writeClassFile(OutputStream out, ClassSymbol c)
duke@1 1616 throws IOException, PoolOverflow, StringOverflow {
duke@1 1617 assert (c.flags() & COMPOUND) == 0;
duke@1 1618 databuf.reset();
duke@1 1619 poolbuf.reset();
duke@1 1620 sigbuf.reset();
duke@1 1621 pool = c.pool;
duke@1 1622 innerClasses = null;
duke@1 1623 innerClassesQueue = null;
duke@1 1624
duke@1 1625 Type supertype = types.supertype(c.type);
duke@1 1626 List<Type> interfaces = types.interfaces(c.type);
duke@1 1627 List<Type> typarams = c.type.getTypeArguments();
duke@1 1628
duke@1 1629 int flags = adjustFlags(c.flags());
duke@1 1630 if ((flags & PROTECTED) != 0) flags |= PUBLIC;
duke@1 1631 flags = flags & ClassFlags & ~STRICTFP;
duke@1 1632 if ((flags & INTERFACE) == 0) flags |= ACC_SUPER;
duke@1 1633 if (c.isInner() && c.name.isEmpty()) flags &= ~FINAL;
duke@1 1634 if (dumpClassModifiers) {
duke@1 1635 log.errWriter.println();
duke@1 1636 log.errWriter.println("CLASSFILE " + c.getQualifiedName());
duke@1 1637 log.errWriter.println("---" + flagNames(flags));
duke@1 1638 }
duke@1 1639 databuf.appendChar(flags);
duke@1 1640
duke@1 1641 databuf.appendChar(pool.put(c));
duke@1 1642 databuf.appendChar(supertype.tag == CLASS ? pool.put(supertype.tsym) : 0);
duke@1 1643 databuf.appendChar(interfaces.length());
duke@1 1644 for (List<Type> l = interfaces; l.nonEmpty(); l = l.tail)
duke@1 1645 databuf.appendChar(pool.put(l.head.tsym));
duke@1 1646 int fieldsCount = 0;
duke@1 1647 int methodsCount = 0;
duke@1 1648 for (Scope.Entry e = c.members().elems; e != null; e = e.sibling) {
duke@1 1649 switch (e.sym.kind) {
duke@1 1650 case VAR: fieldsCount++; break;
duke@1 1651 case MTH: if ((e.sym.flags() & HYPOTHETICAL) == 0) methodsCount++;
duke@1 1652 break;
duke@1 1653 case TYP: enterInner((ClassSymbol)e.sym); break;
duke@1 1654 default : assert false;
duke@1 1655 }
duke@1 1656 }
duke@1 1657 databuf.appendChar(fieldsCount);
duke@1 1658 writeFields(c.members().elems);
duke@1 1659 databuf.appendChar(methodsCount);
duke@1 1660 writeMethods(c.members().elems);
duke@1 1661
duke@1 1662 int acountIdx = beginAttrs();
duke@1 1663 int acount = 0;
duke@1 1664
duke@1 1665 boolean sigReq =
mcimadamore@297 1666 typarams.length() != 0 || supertype.allparams().length() != 0;
duke@1 1667 for (List<Type> l = interfaces; !sigReq && l.nonEmpty(); l = l.tail)
mcimadamore@297 1668 sigReq = l.head.allparams().length() != 0;
duke@1 1669 if (sigReq) {
duke@1 1670 assert source.allowGenerics();
duke@1 1671 int alenIdx = writeAttr(names.Signature);
duke@1 1672 if (typarams.length() != 0) assembleParamsSig(typarams);
duke@1 1673 assembleSig(supertype);
duke@1 1674 for (List<Type> l = interfaces; l.nonEmpty(); l = l.tail)
duke@1 1675 assembleSig(l.head);
duke@1 1676 databuf.appendChar(pool.put(sigbuf.toName(names)));
duke@1 1677 sigbuf.reset();
duke@1 1678 endAttr(alenIdx);
duke@1 1679 acount++;
duke@1 1680 }
duke@1 1681
duke@1 1682 if (c.sourcefile != null && emitSourceFile) {
duke@1 1683 int alenIdx = writeAttr(names.SourceFile);
duke@1 1684 // WHM 6/29/1999: Strip file path prefix. We do it here at
duke@1 1685 // the last possible moment because the sourcefile may be used
duke@1 1686 // elsewhere in error diagnostics. Fixes 4241573.
duke@1 1687 //databuf.appendChar(c.pool.put(c.sourcefile));
duke@1 1688 String filename = c.sourcefile.toString();
duke@1 1689 int sepIdx = filename.lastIndexOf(File.separatorChar);
duke@1 1690 // Allow '/' as separator on all platforms, e.g., on Win32.
duke@1 1691 int slashIdx = filename.lastIndexOf('/');
duke@1 1692 if (slashIdx > sepIdx) sepIdx = slashIdx;
duke@1 1693 if (sepIdx >= 0) filename = filename.substring(sepIdx + 1);
duke@1 1694 databuf.appendChar(c.pool.put(names.fromString(filename)));
duke@1 1695 endAttr(alenIdx);
duke@1 1696 acount++;
duke@1 1697 }
duke@1 1698
duke@1 1699 if (genCrt) {
duke@1 1700 // Append SourceID attribute
duke@1 1701 int alenIdx = writeAttr(names.SourceID);
duke@1 1702 databuf.appendChar(c.pool.put(names.fromString(Long.toString(getLastModified(c.sourcefile)))));
duke@1 1703 endAttr(alenIdx);
duke@1 1704 acount++;
duke@1 1705 // Append CompilationID attribute
duke@1 1706 alenIdx = writeAttr(names.CompilationID);
duke@1 1707 databuf.appendChar(c.pool.put(names.fromString(Long.toString(System.currentTimeMillis()))));
duke@1 1708 endAttr(alenIdx);
duke@1 1709 acount++;
duke@1 1710 }
duke@1 1711
duke@1 1712 acount += writeFlagAttrs(c.flags());
duke@1 1713 acount += writeJavaAnnotations(c.getAnnotationMirrors());
jjg@308 1714 acount += writeTypeAnnotations(c.typeAnnotations);
duke@1 1715 acount += writeEnclosingMethodAttribute(c);
duke@1 1716
duke@1 1717 poolbuf.appendInt(JAVA_MAGIC);
duke@1 1718 poolbuf.appendChar(target.minorVersion);
duke@1 1719 poolbuf.appendChar(target.majorVersion);
duke@1 1720
duke@1 1721 writePool(c.pool);
duke@1 1722
duke@1 1723 if (innerClasses != null) {
duke@1 1724 writeInnerClasses();
duke@1 1725 acount++;
duke@1 1726 }
duke@1 1727 endAttrs(acountIdx, acount);
duke@1 1728
duke@1 1729 poolbuf.appendBytes(databuf.elems, 0, databuf.length);
duke@1 1730 out.write(poolbuf.elems, 0, poolbuf.length);
duke@1 1731
duke@1 1732 pool = c.pool = null; // to conserve space
duke@1 1733 }
duke@1 1734
duke@1 1735 int adjustFlags(final long flags) {
duke@1 1736 int result = (int)flags;
duke@1 1737 if ((flags & SYNTHETIC) != 0 && !target.useSyntheticFlag())
duke@1 1738 result &= ~SYNTHETIC;
duke@1 1739 if ((flags & ENUM) != 0 && !target.useEnumFlag())
duke@1 1740 result &= ~ENUM;
duke@1 1741 if ((flags & ANNOTATION) != 0 && !target.useAnnotationFlag())
duke@1 1742 result &= ~ANNOTATION;
duke@1 1743
duke@1 1744 if ((flags & BRIDGE) != 0 && target.useBridgeFlag())
duke@1 1745 result |= ACC_BRIDGE;
duke@1 1746 if ((flags & VARARGS) != 0 && target.useVarargsFlag())
duke@1 1747 result |= ACC_VARARGS;
duke@1 1748 return result;
duke@1 1749 }
duke@1 1750
duke@1 1751 long getLastModified(FileObject filename) {
duke@1 1752 long mod = 0;
duke@1 1753 try {
duke@1 1754 mod = filename.getLastModified();
duke@1 1755 } catch (SecurityException e) {
duke@1 1756 throw new AssertionError("CRT: couldn't get source file modification date: " + e.getMessage());
duke@1 1757 }
duke@1 1758 return mod;
duke@1 1759 }
duke@1 1760 }

mercurial