1 /* 2 * Copyright (c) 2019, 2021, 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 com.sun.tools.javac.jvm; 27 28 import com.sun.tools.javac.code.Kinds.Kind; 29 import com.sun.tools.javac.code.Symbol; 30 import com.sun.tools.javac.code.Symbol.ClassSymbol; 31 import com.sun.tools.javac.code.Symbol.DynamicMethodSymbol; 32 import com.sun.tools.javac.code.Symbol.MethodHandleSymbol; 33 import com.sun.tools.javac.code.Symbol.ModuleSymbol; 34 import com.sun.tools.javac.code.Symbol.PackageSymbol; 35 import com.sun.tools.javac.code.Type; 36 import com.sun.tools.javac.code.Types; 37 import com.sun.tools.javac.jvm.ClassWriter.PoolOverflow; 38 import com.sun.tools.javac.jvm.ClassWriter.StringOverflow; 39 import com.sun.tools.javac.jvm.PoolConstant.LoadableConstant; 40 import com.sun.tools.javac.jvm.PoolConstant.LoadableConstant.BasicConstant; 41 import com.sun.tools.javac.jvm.PoolConstant.Dynamic; 42 import com.sun.tools.javac.jvm.PoolConstant.Dynamic.BsmKey; 43 import com.sun.tools.javac.jvm.PoolConstant.NameAndType; 44 import com.sun.tools.javac.util.ByteBuffer; 45 import com.sun.tools.javac.util.InvalidUtfException; 46 import com.sun.tools.javac.util.List; 47 import com.sun.tools.javac.util.Name; 48 import com.sun.tools.javac.util.Names; 49 50 import java.io.IOException; 51 import java.io.OutputStream; 52 import java.util.ArrayDeque; 53 import java.util.HashMap; 54 import java.util.HashSet; 55 import java.util.LinkedHashMap; 56 import java.util.LinkedHashSet; 57 import java.util.Map; 58 import java.util.Set; 59 60 import static com.sun.tools.javac.code.Kinds.Kind.TYP; 61 import static com.sun.tools.javac.code.TypeTag.ARRAY; 62 import static com.sun.tools.javac.code.TypeTag.CLASS; 63 import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_Class; 64 import static com.sun.tools.javac.jvm.ClassFile.CONSTANT_MethodType; 65 import static com.sun.tools.javac.jvm.ClassFile.externalize; 66 67 /** 68 * Pool interface towards {@code ClassWriter}. Exposes methods to encode and write javac entities 69 * into the constant pool. 70 * 71 * <p><b>This is NOT part of any supported API. 72 * If you write code that depends on this, you do so at your own risk. 73 * This code and its internal interfaces are subject to change or 74 * deletion without notice.</b> 75 */ 76 public class PoolWriter { 77 78 /** Max number of constant pool entries. */ 79 public static final int MAX_ENTRIES = 0xFFFF; 80 81 /** Max number of char in a string constant. */ 82 public static final int MAX_STRING_LENGTH = 0xFFFF; 83 84 private static final int POOL_BUF_SIZE = 0x7fff; 85 86 private final Types types; 87 88 private final Names names; 89 90 /** Pool helper **/ 91 final WriteablePoolHelper pool; 92 93 /** Sole signature generator */ 94 final SharedSignatureGenerator signatureGen; 95 96 /** The inner classes to be written, as an ordered set (enclosing first). */ 97 LinkedHashSet<ClassSymbol> innerClasses = new LinkedHashSet<>(); 98 99 Set<Symbol> loadableDescriptors = new HashSet<>(); 100 101 /** The list of entries in the BootstrapMethods attribute. */ 102 Map<BsmKey, Integer> bootstrapMethods = new LinkedHashMap<>(); 103 104 public PoolWriter(Types types, Names names) { 105 this.types = types; 106 this.names = names; 107 this.signatureGen = new SharedSignatureGenerator(types); 108 this.pool = new WriteablePoolHelper(); 109 } 110 111 /** 112 * Puts a class symbol into the pool and return its index. 113 */ 114 int putClass(ClassSymbol csym) { 115 return putClass(csym.type); 116 } 117 118 /** 119 * Puts a type into the pool and return its index. The type could be either a class, a type variable 120 * or an array type. 121 */ 122 int putClass(Type t) { 123 return pool.writeIfNeeded(types.erasure(t)); 124 } 125 126 /** 127 * Puts a member reference into the constant pool. Valid members are either field or method symbols. 128 */ 129 int putMember(Symbol s) { 130 return pool.writeIfNeeded(s); 131 } 132 133 /** 134 * Puts a dynamic reference into the constant pool and return its index. 135 */ 136 int putDynamic(Dynamic d) { 137 return pool.writeIfNeeded(d); 138 } 139 140 /** 141 * Puts a field or method descriptor into the constant pool and return its index. 142 */ 143 int putDescriptor(Type t) { 144 return putName(typeSig(types.erasure(t))); 145 } 146 147 /** 148 * Puts a field or method descriptor into the constant pool and return its index. 149 */ 150 int putDescriptor(Symbol s) { 151 return putDescriptor(descriptorType(s)); 152 } 153 154 /** 155 * Puts a signature (see {@code Signature} attribute in JVMS 4.4) into the constant pool and 156 * return its index. 157 */ 158 int putSignature(Symbol s) { 159 if (s.kind == TYP) { 160 return putName(classSig(s.type)); 161 } else { 162 return putName(typeSig(s.type)); 163 } 164 } 165 166 /** 167 * Puts a constant value into the pool and return its index. Supported values are int, float, long, 168 * double and String. 169 */ 170 int putConstant(Object o) { 171 if (o instanceof Integer intVal) { 172 return putConstant(LoadableConstant.Int(intVal)); 173 } else if (o instanceof Float floatVal) { 174 return putConstant(LoadableConstant.Float(floatVal)); 175 } else if (o instanceof Long longVal) { 176 return putConstant(LoadableConstant.Long(longVal)); 177 } else if (o instanceof Double doubleVal) { 178 return putConstant(LoadableConstant.Double(doubleVal)); 179 } else if (o instanceof String strVal) { 180 return putConstant(LoadableConstant.String(strVal)); 181 } else { 182 throw new AssertionError("unexpected constant: " + o); 183 } 184 } 185 186 /** 187 * Puts a constant into the pool and return its index. 188 */ 189 int putConstant(LoadableConstant c) { 190 switch (c.poolTag()) { 191 case CONSTANT_Class: 192 return putClass((Type)c); 193 case CONSTANT_MethodType: 194 return pool.writeIfNeeded(types.erasure((Type)c)); 195 default: 196 return pool.writeIfNeeded(c); 197 } 198 } 199 200 int putName(Name name) { 201 return pool.writeIfNeeded(name); 202 } 203 204 /** 205 * Puts a name and type pair into the pool and returns its index. 206 */ 207 int putNameAndType(Symbol s) { 208 return pool.writeIfNeeded(new NameAndType(s.name, descriptorType(s))); 209 } 210 211 /** 212 * Puts a package entry into the pool and returns its index. 213 */ 214 int putPackage(PackageSymbol pkg) { 215 return pool.writeIfNeeded(pkg); 216 } 217 218 /** 219 * Puts a module entry into the pool and returns its index. 220 */ 221 int putModule(ModuleSymbol mod) { 222 return pool.writeIfNeeded(mod); 223 } 224 225 /** 226 * Enter an inner class into the `innerClasses' set. 227 */ 228 void enterInner(ClassSymbol c) { 229 if (c.type.isCompound()) { 230 throw new AssertionError("Unexpected intersection type: " + c.type); 231 } 232 c.complete(); 233 if (c.owner.enclClass() != null && !innerClasses.contains(c)) { 234 enterInner(c.owner.enclClass()); 235 innerClasses.add(c); 236 } 237 } 238 239 /** Enter a value class into the `loadableDescriptorsClasses' set. 240 */ 241 void enterLoadableDescriptorsClass(Symbol c) { 242 if (c.type.isCompound()) { 243 throw new AssertionError("Unexpected intersection type: " + c.type); 244 } 245 c.complete(); 246 loadableDescriptors.add(c); 247 } 248 249 /** 250 * Create a new Utf8 entry representing a descriptor for given (member) symbol. 251 */ 252 private Type descriptorType(Symbol s) { 253 return s.kind == Kind.MTH ? s.externalType(types) : s.erasure(types); 254 } 255 256 private int makeBootstrapEntry(Dynamic dynamic) { 257 BsmKey bsmKey = dynamic.bsmKey(types); 258 259 // Figure out the index for existing BSM; create a new BSM if no key 260 Integer index = bootstrapMethods.get(bsmKey); 261 if (index == null) { 262 index = bootstrapMethods.size(); 263 bootstrapMethods.put(bsmKey, index); 264 } 265 266 return index; 267 } 268 269 /** 270 * Write pool contents into given byte buffer. 271 */ 272 void writePool(OutputStream out) throws IOException, PoolOverflow { 273 if (pool.overflowString != null) { 274 throw new StringOverflow(pool.overflowString); 275 } 276 int size = size(); 277 if (size > MAX_ENTRIES) { 278 throw new PoolOverflow(); 279 } 280 out.write(size >> 8); 281 out.write(size); 282 out.write(pool.poolbuf.elems, 0, pool.poolbuf.length); 283 } 284 285 /** 286 * Signature Generation 287 */ 288 class SharedSignatureGenerator extends Types.SignatureGenerator { 289 290 /** 291 * An output buffer for type signatures. 292 */ 293 ByteBuffer sigbuf = new ByteBuffer(); 294 295 SharedSignatureGenerator(Types types) { 296 super(types); 297 } 298 299 /** 300 * Assemble signature of given type in string buffer. 301 * Check for uninitialized types before calling the general case. 302 */ 303 @Override 304 public void assembleSig(Type type) { 305 switch (type.getTag()) { 306 case UNINITIALIZED_THIS: 307 case UNINITIALIZED_OBJECT: 308 // we don't yet have a spec for uninitialized types in the 309 // local variable table 310 assembleSig(types.erasure(((UninitializedType)type).qtype)); 311 break; 312 default: 313 super.assembleSig(type); 314 } 315 } 316 317 @Override 318 protected void append(char ch) { 319 sigbuf.appendByte(ch); 320 } 321 322 @Override 323 protected void append(byte[] ba) { 324 sigbuf.appendBytes(ba); 325 } 326 327 @Override 328 protected void append(Name name) { 329 sigbuf.appendName(name); 330 } 331 332 @Override 333 protected void classReference(ClassSymbol c) { 334 enterInner(c); 335 } 336 337 protected void reset() { 338 sigbuf.reset(); 339 } 340 341 protected Name toName() { 342 try { 343 return sigbuf.toName(names); 344 } catch (InvalidUtfException e) { 345 throw new AssertionError(e); 346 } 347 } 348 } 349 350 class WriteablePoolHelper { 351 352 /** Pool entries. */ 353 private final Map<Object, Integer> keysToPos = new HashMap<>(64); 354 355 final ByteBuffer poolbuf = new ByteBuffer(POOL_BUF_SIZE); 356 357 int currentIndex = 1; 358 359 ArrayDeque<PoolConstant> todo = new ArrayDeque<>(); 360 361 String overflowString = null; 362 363 private <P extends PoolConstant> int writeIfNeeded(P p) { 364 Object key = p.poolKey(types); 365 Integer index = keysToPos.get(key); 366 if (index == null) { 367 keysToPos.put(key, index = currentIndex++); 368 boolean first = todo.isEmpty(); 369 todo.addLast(p); 370 if (first) { 371 while (!todo.isEmpty()) { 372 writeConstant(todo.peekFirst()); 373 todo.removeFirst(); 374 } 375 } 376 } 377 return index; 378 } 379 380 void writeConstant(PoolConstant c) { 381 int tag = c.poolTag(); 382 switch (tag) { 383 case ClassFile.CONSTANT_Class: { 384 Type ct = (Type)c; 385 Name name = ct.hasTag(ARRAY) ? 386 typeSig(ct) : 387 externalize(ct.tsym.flatName()); 388 poolbuf.appendByte(tag); 389 poolbuf.appendChar(putName(name)); 390 if (ct.hasTag(CLASS)) { 391 enterInner((ClassSymbol)ct.tsym); 392 } 393 break; 394 } 395 case ClassFile.CONSTANT_Utf8: { 396 Name name = (Name)c; 397 poolbuf.appendByte(tag); 398 byte[] bs = name.toUtf(); 399 poolbuf.appendChar(bs.length); 400 poolbuf.appendBytes(bs, 0, bs.length); 401 if (overflowString == null && bs.length > MAX_STRING_LENGTH) { 402 //report error only once 403 overflowString = new String(bs); 404 } 405 break; 406 } 407 case ClassFile.CONSTANT_InterfaceMethodref: 408 case ClassFile.CONSTANT_Methodref: 409 case ClassFile.CONSTANT_Fieldref: { 410 Symbol sym = (Symbol)c; 411 poolbuf.appendByte(tag); 412 poolbuf.appendChar(putClass((ClassSymbol)sym.owner)); 413 poolbuf.appendChar(putNameAndType(sym)); 414 break; 415 } 416 case ClassFile.CONSTANT_Package: { 417 PackageSymbol pkg = (PackageSymbol)c; 418 Name pkgName = externalize(pkg.flatName()); 419 poolbuf.appendByte(tag); 420 poolbuf.appendChar(putName(pkgName)); 421 break; 422 } 423 case ClassFile.CONSTANT_Module: { 424 ModuleSymbol mod = (ModuleSymbol)c; 425 int modName = putName(mod.name); 426 poolbuf.appendByte(mod.poolTag()); 427 poolbuf.appendChar(modName); 428 break; 429 } 430 case ClassFile.CONSTANT_Integer: 431 poolbuf.appendByte(tag); 432 poolbuf.appendInt((int)((BasicConstant)c).data); 433 break; 434 case ClassFile.CONSTANT_Float: 435 poolbuf.appendByte(tag); 436 poolbuf.appendFloat((float)((BasicConstant)c).data); 437 break; 438 case ClassFile.CONSTANT_Long: 439 currentIndex++; 440 poolbuf.appendByte(tag); 441 poolbuf.appendLong((long)((BasicConstant)c).data); 442 break; 443 case ClassFile.CONSTANT_Double: 444 currentIndex++; 445 poolbuf.appendByte(tag); 446 poolbuf.appendDouble((double)((BasicConstant)c).data); 447 break; 448 case ClassFile.CONSTANT_MethodHandle: { 449 MethodHandleSymbol h = (MethodHandleSymbol)c; 450 poolbuf.appendByte(tag); 451 poolbuf.appendByte(h.referenceKind()); 452 poolbuf.appendChar(putMember(h.baseSymbol())); 453 break; 454 } 455 case ClassFile.CONSTANT_MethodType: { 456 Type.MethodType mt = (Type.MethodType)c; 457 poolbuf.appendByte(tag); 458 poolbuf.appendChar(putDescriptor(mt.baseType())); 459 break; 460 } 461 case ClassFile.CONSTANT_String: { 462 Name utf = names.fromString((String)((BasicConstant)c).data); 463 poolbuf.appendByte(tag); 464 poolbuf.appendChar(putName(utf)); 465 break; 466 } 467 case ClassFile.CONSTANT_NameandType: { 468 NameAndType nt = (NameAndType)c; 469 poolbuf.appendByte(tag); 470 poolbuf.appendChar(putName(nt.name)); 471 poolbuf.appendChar(putDescriptor(nt.type)); 472 break; 473 } 474 case ClassFile.CONSTANT_InvokeDynamic: { 475 DynamicMethodSymbol d = (DynamicMethodSymbol)c; 476 poolbuf.appendByte(tag); 477 poolbuf.appendChar(makeBootstrapEntry(d)); 478 poolbuf.appendChar(putNameAndType(d)); 479 break; 480 } 481 case ClassFile.CONSTANT_Dynamic: { 482 Symbol.DynamicVarSymbol d = (Symbol.DynamicVarSymbol)c; 483 poolbuf.appendByte(tag); 484 poolbuf.appendChar(makeBootstrapEntry(d)); 485 poolbuf.appendChar(putNameAndType(d)); 486 break; 487 } 488 default: 489 throw new AssertionError("Unexpected constant tag: " + tag); 490 } 491 } 492 493 void reset() { 494 keysToPos.clear(); 495 currentIndex = 1; 496 todo.clear(); 497 overflowString = null; 498 poolbuf.reset(); 499 } 500 } 501 502 int size() { 503 return pool.currentIndex; 504 } 505 506 /** 507 * Return signature of given type 508 */ 509 private Name typeSig(Type type) { 510 signatureGen.reset(); 511 signatureGen.assembleSig(type); 512 return signatureGen.toName(); 513 } 514 515 private Name classSig(Type t) { 516 signatureGen.reset(); 517 List<Type> typarams = t.getTypeArguments(); 518 if (typarams.nonEmpty()) { 519 signatureGen.assembleParamsSig(typarams); 520 } 521 signatureGen.assembleSig(types.supertype(t)); 522 for (Type i : types.interfaces(t)) 523 signatureGen.assembleSig(i); 524 return signatureGen.toName(); 525 } 526 527 void reset() { 528 innerClasses.clear(); 529 loadableDescriptors.clear(); 530 bootstrapMethods.clear(); 531 pool.reset(); 532 } 533 }