1 /*
2 * Copyright (c) 2000, 2017, 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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 package sun.jvm.hotspot.oops;
26
27 import java.io.*;
28 import java.util.*;
29 import sun.jvm.hotspot.debugger.*;
30 import sun.jvm.hotspot.runtime.*;
31 import sun.jvm.hotspot.types.*;
32 import sun.jvm.hotspot.utilities.*;
33
34 // A ConstantPool is an oop containing class constants
35 // as described in the class file
36
37 public class ConstantPool extends Metadata implements ClassConstants {
38 private class CPSlot {
39 private Address ptr;
40
41 CPSlot(Address ptr) {
42 this.ptr = ptr;
43 }
44
45 public Symbol getSymbol() {
46 // (Lowest bit == 1) -> this is an pseudo string.
47 return Symbol.create(ptr.andWithMask(~1));
48 }
49 }
50 private class CPKlassSlot {
51 private int name_index;
52 private int resolved_klass_index;
53 private static final int temp_resolved_klass_index = 0xffff;
54
55 public CPKlassSlot(int n, int rk) {
56 name_index = n;
57 resolved_klass_index = rk;
58 }
59 public int getNameIndex() {
60 return name_index;
61 }
62 public int getResolvedKlassIndex() {
63 if (Assert.ASSERTS_ENABLED) {
64 Assert.that(resolved_klass_index != temp_resolved_klass_index, "constant pool merging was incomplete");
65 }
66 return resolved_klass_index;
67 }
68 }
69
70 // Used for debugging this code
71 private static final boolean DEBUG = false;
72
73 protected void debugMessage(String message) {
74 System.out.println(message);
75 }
76
77 static {
78 VM.registerVMInitializedObserver(new Observer() {
79 public void update(Observable o, Object data) {
80 initialize(VM.getVM().getTypeDataBase());
81 }
82 });
83 }
84
85 private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
86 Type type = db.lookupType("ConstantPool");
87 tags = type.getAddressField("_tags");
88 operands = type.getAddressField("_operands");
89 cache = type.getAddressField("_cache");
90 poolHolder = new MetadataField(type.getAddressField("_pool_holder"), 0);
91 length = new CIntField(type.getCIntegerField("_length"), 0);
92 resolved_klasses = type.getAddressField("_resolved_klasses");
93 headerSize = type.getSize();
94 elementSize = 0;
95 // fetch constants:
96 INDY_BSM_OFFSET = db.lookupIntConstant("ConstantPool::_indy_bsm_offset").intValue();
97 INDY_ARGC_OFFSET = db.lookupIntConstant("ConstantPool::_indy_argc_offset").intValue();
98 INDY_ARGV_OFFSET = db.lookupIntConstant("ConstantPool::_indy_argv_offset").intValue();
99 }
100
101 public ConstantPool(Address addr) {
102 super(addr);
103 }
104
105 public boolean isConstantPool() { return true; }
106
107 private static AddressField tags;
108 private static AddressField operands;
109 private static AddressField cache;
110 private static AddressField resolved_klasses;
111 private static MetadataField poolHolder;
112 private static CIntField length; // number of elements in oop
113
114 private static long headerSize;
115 private static long elementSize;
116
117 private static int INDY_BSM_OFFSET;
118 private static int INDY_ARGC_OFFSET;
119 private static int INDY_ARGV_OFFSET;
120
121 public U1Array getTags() { return new U1Array(tags.getValue(getAddress())); }
122 public U2Array getOperands() { return new U2Array(operands.getValue(getAddress())); }
123 public ConstantPoolCache getCache() {
124 Address addr = cache.getValue(getAddress());
125 return (ConstantPoolCache) VMObjectFactory.newObject(ConstantPoolCache.class, addr);
126 }
127 public InstanceKlass getPoolHolder() { return (InstanceKlass)poolHolder.getValue(this); }
128 public int getLength() { return (int)length.getValue(getAddress()); }
129 public Oop getResolvedReferences() {
130 return getCache().getResolvedReferences();
131 }
132 public KlassArray getResolvedKlasses() {
133 return new KlassArray(resolved_klasses.getValue(getAddress()));
134 }
135
136 public U2Array referenceMap() {
137 return getCache().referenceMap();
138 }
139
140 public int objectToCPIndex(int index) {
141 return referenceMap().at(index);
142 }
143
144 private long getElementSize() {
145 if (elementSize !=0 ) {
146 return elementSize;
147 } else {
148 elementSize = VM.getVM().getOopSize();
149 }
150 return elementSize;
151 }
152
153 private long indexOffset(long index) {
154 if (Assert.ASSERTS_ENABLED) {
155 Assert.that(index >= 0 && index < getLength(), "invalid cp index " + index + " " + getLength());
156 }
157 return (index * getElementSize()) + headerSize;
158 }
159
160 public ConstantTag getTagAt(long index) {
161 return new ConstantTag((byte)getTags().at((int) index));
162 }
163
164 public CPSlot getSlotAt(long index) {
165 return new CPSlot(getAddressAtRaw(index));
166 }
167
168 public CPKlassSlot getKlassSlotAt(long index) {
169 if (Assert.ASSERTS_ENABLED) {
170 Assert.that(getTagAt(index).isUnresolvedKlass() || getTagAt(index).isKlass(), "Corrupted constant pool");
171 }
172 int value = getIntAt(index);
173 int name_index = extractHighShortFromInt(value);
174 int resolved_klass_index = extractLowShortFromInt(value);
175 return new CPKlassSlot(name_index, resolved_klass_index);
176 }
177
178 public Address getAddressAtRaw(long index) {
179 return getAddress().getAddressAt(indexOffset(index));
180 }
181
182 public Symbol getSymbolAt(long index) {
183 return Symbol.create(getAddressAtRaw(index));
184 }
185
186 public int getIntAt(long index){
187 return getAddress().getJIntAt(indexOffset(index));
188 }
189
190 public float getFloatAt(long index){
191 return getAddress().getJFloatAt(indexOffset(index));
192 }
193
194 public long getLongAt(long index) {
195 int oneHalf = getAddress().getJIntAt(indexOffset(index + 1));
196 int otherHalf = getAddress().getJIntAt(indexOffset(index));
197 // buildLongFromIntsPD accepts higher address value, lower address value
198 // in that order.
199 return VM.getVM().buildLongFromIntsPD(oneHalf, otherHalf);
200 }
201
202 public double getDoubleAt(long index) {
203 return Double.longBitsToDouble(getLongAt(index));
204 }
205
206 public int getFieldOrMethodAt(int which) {
207 if (DEBUG) {
208 System.err.print("ConstantPool.getFieldOrMethodAt(" + which + "): new index = ");
209 }
210 int i = -1;
211 ConstantPoolCache cache = getCache();
212 if (cache == null) {
213 i = which;
214 } else {
215 // change byte-ordering and go via cache
216 i = cache.getEntryAt(0xFFFF & which).getConstantPoolIndex();
217 }
218 if (Assert.ASSERTS_ENABLED) {
219 Assert.that(getTagAt(i).isFieldOrMethod(), "Corrupted constant pool");
220 }
221 if (DEBUG) {
222 System.err.println(i);
223 }
224 int res = getIntAt(i);
225 if (DEBUG) {
226 System.err.println("ConstantPool.getFieldOrMethodAt(" + i + "): result = " + res);
227 }
228 return res;
229 }
230
231 public int[] getNameAndTypeAt(int which) {
232 if (Assert.ASSERTS_ENABLED) {
233 Assert.that(getTagAt(which).isNameAndType(), "Corrupted constant pool: " + which + " " + getTagAt(which));
234 }
235 int i = getIntAt(which);
236 if (DEBUG) {
237 System.err.println("ConstantPool.getNameAndTypeAt(" + which + "): result = " + i);
238 }
239 return new int[] { extractLowShortFromInt(i), extractHighShortFromInt(i) };
240 }
241
242 public Symbol getNameRefAt(int which) {
243 return implGetNameRefAt(which, false);
244 }
245
246 public Symbol uncachedGetNameRefAt(int which) {
247 return implGetNameRefAt(which, true);
248 }
249
250 private Symbol implGetNameRefAt(int which, boolean uncached) {
251 int signatureIndex = getNameRefIndexAt(implNameAndTypeRefIndexAt(which, uncached));
252 return getSymbolAt(signatureIndex);
253 }
254
255 public Symbol getSignatureRefAt(int which) {
256 return implGetSignatureRefAt(which, false);
257 }
258
259 public Symbol uncachedGetSignatureRefAt(int which) {
260 return implGetSignatureRefAt(which, true);
261 }
262
263 private Symbol implGetSignatureRefAt(int which, boolean uncached) {
264 int signatureIndex = getSignatureRefIndexAt(implNameAndTypeRefIndexAt(which, uncached));
265 return getSymbolAt(signatureIndex);
266 }
267
268 public static boolean isInvokedynamicIndex(int i) { return (i < 0); }
269
270 public static int decodeInvokedynamicIndex(int i) { Assert.that(isInvokedynamicIndex(i), ""); return ~i; }
271
272 // The invokedynamic points at a CP cache entry. This entry points back
273 // at the original CP entry (CONSTANT_InvokeDynamic) and also (via f2) at an entry
274 // in the resolved_references array (which provides the appendix argument).
275 public int invokedynamicCPCacheIndex(int index) {
276 Assert.that(isInvokedynamicIndex(index), "should be a invokedynamic index");
277 return decodeInvokedynamicIndex(index);
278 }
279
280 ConstantPoolCacheEntry invokedynamicCPCacheEntryAt(int index) {
281 // decode index that invokedynamic points to.
282 int cpCacheIndex = invokedynamicCPCacheIndex(index);
283 return getCache().getEntryAt(cpCacheIndex);
284 }
285
286 private int implNameAndTypeRefIndexAt(int which, boolean uncached) {
287 int i = which;
288 if (!uncached && getCache() != null) {
289 if (isInvokedynamicIndex(which)) {
290 // Invokedynamic index is index into resolved_references
291 int poolIndex = invokedynamicCPCacheEntryAt(which).getConstantPoolIndex();
292 poolIndex = invokeDynamicNameAndTypeRefIndexAt(poolIndex);
293 Assert.that(getTagAt(poolIndex).isNameAndType(), "");
294 return poolIndex;
295 }
296 // change byte-ordering and go via cache
297 i = remapInstructionOperandFromCache(which);
298 } else {
299 if (getTagAt(which).isInvokeDynamic()) {
300 int poolIndex = invokeDynamicNameAndTypeRefIndexAt(which);
301 Assert.that(getTagAt(poolIndex).isNameAndType(), "");
302 return poolIndex;
303 }
304 }
305 // assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");
306 // assert(!tag_at(i).is_invoke_dynamic(), "Must be handled above");
307 int refIndex = getIntAt(i);
308 return extractHighShortFromInt(refIndex);
309 }
310
311 private int remapInstructionOperandFromCache(int operand) {
312 int cpc_index = operand;
313 // DEBUG_ONLY(cpc_index -= CPCACHE_INDEX_TAG);
314 // assert((int)(u2)cpc_index == cpc_index, "clean u2");
315 int member_index = getCache().getEntryAt(cpc_index).getConstantPoolIndex();
316 return member_index;
317 }
318
319 public int invokeDynamicNameAndTypeRefIndexAt(int which) {
320 // assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool");
321 return extractHighShortFromInt(getIntAt(which));
322 }
323
324 // returns null, if not resolved.
325 public Klass getKlassAt(int which) {
326 if( ! getTagAt(which).isKlass()) return null;
327 int resolved_klass_index = getKlassSlotAt(which).getResolvedKlassIndex();
328 KlassArray resolved_klasses = getResolvedKlasses();
329 return resolved_klasses.getAt(resolved_klass_index);
330 }
331
332 public Symbol getKlassNameAt(int which) {
333 int name_index = getKlassSlotAt(which).getNameIndex();
334 return getSymbolAt(name_index);
335 }
336
337 public Symbol getUnresolvedStringAt(int which) {
338 return getSlotAt(which).getSymbol();
339 }
340
341 // returns null, if not resolved.
342 public InstanceKlass getFieldOrMethodKlassRefAt(int which) {
343 int refIndex = getFieldOrMethodAt(which);
344 int klassIndex = extractLowShortFromInt(refIndex);
345 return (InstanceKlass) getKlassAt(klassIndex);
346 }
347
348 // returns null, if not resolved.
349 public Method getMethodRefAt(int which) {
350 InstanceKlass klass = getFieldOrMethodKlassRefAt(which);
351 if (klass == null) return null;
352 Symbol name = getNameRefAt(which);
353 Symbol sig = getSignatureRefAt(which);
354 return klass.findMethod(name, sig);
355 }
356
357 // returns null, if not resolved.
358 public Field getFieldRefAt(int which) {
359 InstanceKlass klass = getFieldOrMethodKlassRefAt(which);
360 if (klass == null) return null;
361 Symbol name = getNameRefAt(which);
362 Symbol sig = getSignatureRefAt(which);
363 return klass.findField(name, sig);
364 }
365
366 public int getNameAndTypeRefIndexAt(int index) {
367 return implNameAndTypeRefIndexAt(index, false);
368 }
369
370 /** Lookup for entries consisting of (name_index, signature_index) */
371 public int getNameRefIndexAt(int index) {
372 int[] refIndex = getNameAndTypeAt(index);
373 if (DEBUG) {
374 System.err.println("ConstantPool.getNameRefIndexAt(" + index + "): refIndex = " + refIndex[0]+"/"+refIndex[1]);
375 }
376 int i = refIndex[0];
377 if (DEBUG) {
378 System.err.println("ConstantPool.getNameRefIndexAt(" + index + "): result = " + i);
379 }
380 return i;
381 }
382
383 /** Lookup for entries consisting of (name_index, signature_index) */
384 public int getSignatureRefIndexAt(int index) {
385 int[] refIndex = getNameAndTypeAt(index);
386 if (DEBUG) {
387 System.err.println("ConstantPool.getSignatureRefIndexAt(" + index + "): refIndex = " + refIndex[0]+"/"+refIndex[1]);
388 }
389 int i = refIndex[1];
390 if (DEBUG) {
391 System.err.println("ConstantPool.getSignatureRefIndexAt(" + index + "): result = " + i);
392 }
393 return i;
394 }
395
396 /** Lookup for MethodHandle entries. */
397 public int getMethodHandleIndexAt(int i) {
398 if (Assert.ASSERTS_ENABLED) {
399 Assert.that(getTagAt(i).isMethodHandle(), "Corrupted constant pool");
400 }
401 int res = extractHighShortFromInt(getIntAt(i));
402 if (DEBUG) {
403 System.err.println("ConstantPool.getMethodHandleIndexAt(" + i + "): result = " + res);
404 }
405 return res;
406 }
407
408 /** Lookup for MethodHandle entries. */
409 public int getMethodHandleRefKindAt(int i) {
410 if (Assert.ASSERTS_ENABLED) {
411 Assert.that(getTagAt(i).isMethodHandle(), "Corrupted constant pool");
412 }
413 int res = extractLowShortFromInt(getIntAt(i));
414 if (DEBUG) {
415 System.err.println("ConstantPool.getMethodHandleRefKindAt(" + i + "): result = " + res);
416 }
417 return res;
418 }
419
420 /** Lookup for MethodType entries. */
421 public int getMethodTypeIndexAt(int i) {
422 if (Assert.ASSERTS_ENABLED) {
423 Assert.that(getTagAt(i).isMethodType(), "Corrupted constant pool");
424 }
425 int res = getIntAt(i);
426 if (DEBUG) {
427 System.err.println("ConstantPool.getMethodHandleTypeAt(" + i + "): result = " + res);
428 }
429 return res;
430 }
431
432 /** Lookup for multi-operand (InvokeDynamic) entries. */
433 public short[] getBootstrapSpecifierAt(int i) {
434 if (Assert.ASSERTS_ENABLED) {
435 Assert.that(getTagAt(i).isInvokeDynamic(), "Corrupted constant pool");
436 }
437 int bsmSpec = extractLowShortFromInt(this.getIntAt(i));
438 U2Array operands = getOperands();
439 if (operands == null) return null; // safety first
440 int basePos = VM.getVM().buildIntFromShorts(operands.at(bsmSpec * 2 + 0),
441 operands.at(bsmSpec * 2 + 1));
442 int argv = basePos + INDY_ARGV_OFFSET;
443 int argc = operands.at(basePos + INDY_ARGC_OFFSET);
444 int endPos = argv + argc;
445 short[] values = new short[endPos - basePos];
446 for (int j = 0; j < values.length; j++) {
447 values[j] = operands.at(basePos+j);
448 }
449 return values;
450 }
451
452 final private static String[] nameForTag = new String[] {
453 };
454
455 private String nameForTag(int tag) {
456 switch (tag) {
457 case JVM_CONSTANT_Utf8: return "JVM_CONSTANT_Utf8";
458 case JVM_CONSTANT_Unicode: return "JVM_CONSTANT_Unicode";
459 case JVM_CONSTANT_Integer: return "JVM_CONSTANT_Integer";
460 case JVM_CONSTANT_Float: return "JVM_CONSTANT_Float";
461 case JVM_CONSTANT_Long: return "JVM_CONSTANT_Long";
462 case JVM_CONSTANT_Double: return "JVM_CONSTANT_Double";
463 case JVM_CONSTANT_Class: return "JVM_CONSTANT_Class";
464 case JVM_CONSTANT_String: return "JVM_CONSTANT_String";
465 case JVM_CONSTANT_Fieldref: return "JVM_CONSTANT_Fieldref";
466 case JVM_CONSTANT_Methodref: return "JVM_CONSTANT_Methodref";
467 case JVM_CONSTANT_InterfaceMethodref: return "JVM_CONSTANT_InterfaceMethodref";
468 case JVM_CONSTANT_NameAndType: return "JVM_CONSTANT_NameAndType";
469 case JVM_CONSTANT_MethodHandle: return "JVM_CONSTANT_MethodHandle";
470 case JVM_CONSTANT_MethodType: return "JVM_CONSTANT_MethodType";
471 case JVM_CONSTANT_InvokeDynamic: return "JVM_CONSTANT_InvokeDynamic";
472 case JVM_CONSTANT_Invalid: return "JVM_CONSTANT_Invalid";
473 case JVM_CONSTANT_UnresolvedClass: return "JVM_CONSTANT_UnresolvedClass";
474 case JVM_CONSTANT_ClassIndex: return "JVM_CONSTANT_ClassIndex";
475 case JVM_CONSTANT_StringIndex: return "JVM_CONSTANT_StringIndex";
476 case JVM_CONSTANT_UnresolvedClassInError: return "JVM_CONSTANT_UnresolvedClassInError";
477 case JVM_CONSTANT_MethodHandleInError:return "JVM_CONSTANT_MethodHandleInError";
478 case JVM_CONSTANT_MethodTypeInError: return "JVM_CONSTANT_MethodTypeInError";
479 }
480 throw new InternalError("Unknown tag: " + tag);
481 }
482
483 public void iterateFields(MetadataVisitor visitor) {
484 super.iterateFields(visitor);
485 visitor.doMetadata(poolHolder, true);
486
487 final int length = (int) getLength();
488 // zero'th pool entry is always invalid. ignore it.
489 for (int index = 1; index < length; index++) {
490 int ctag = (int) getTags().at((int) index);
491 switch (ctag) {
492 case JVM_CONSTANT_ClassIndex:
493 case JVM_CONSTANT_StringIndex:
494 case JVM_CONSTANT_Integer:
495 visitor.doInt(new IntField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);
496 break;
497
498 case JVM_CONSTANT_Float:
499 visitor.doFloat(new FloatField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);
500 break;
501
502 case JVM_CONSTANT_Long:
503 visitor.doLong(new LongField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);
504 // long entries occupy two slots
505 index++;
506 break;
507
508 case JVM_CONSTANT_Double:
509 visitor.doDouble(new DoubleField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);
510 // double entries occupy two slots
511 index++;
512 break;
513
514 case JVM_CONSTANT_UnresolvedClassInError:
515 case JVM_CONSTANT_UnresolvedClass:
516 case JVM_CONSTANT_Class:
517 case JVM_CONSTANT_Utf8:
518 visitor.doOop(new OopField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);
519 break;
520
521 case JVM_CONSTANT_Fieldref:
522 case JVM_CONSTANT_Methodref:
523 case JVM_CONSTANT_InterfaceMethodref:
524 case JVM_CONSTANT_NameAndType:
525 case JVM_CONSTANT_MethodHandle:
526 case JVM_CONSTANT_MethodType:
527 case JVM_CONSTANT_InvokeDynamic:
528 visitor.doInt(new IntField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);
529 break;
530 }
531 }
532 }
533
534 public void writeBytes(OutputStream os) throws IOException {
535 // Map between any modified UTF-8 and it's constant pool index.
536 Map utf8ToIndex = new HashMap();
537 DataOutputStream dos = new DataOutputStream(os);
538 U1Array tags = getTags();
539 int len = (int)getLength();
540 int ci = 0; // constant pool index
541
542 // collect all modified UTF-8 Strings from Constant Pool
543
544 for (ci = 1; ci < len; ci++) {
545 int cpConstType = tags.at(ci);
546 if(cpConstType == JVM_CONSTANT_Utf8) {
547 Symbol sym = getSymbolAt(ci);
548 utf8ToIndex.put(sym.asString(), new Short((short) ci));
549 }
550 else if(cpConstType == JVM_CONSTANT_Long ||
551 cpConstType == JVM_CONSTANT_Double) {
552 ci++;
553 }
554 }
555
556
557 for(ci = 1; ci < len; ci++) {
558 int cpConstType = tags.at(ci);
559 // write cp_info
560 // write constant type
561 switch(cpConstType) {
562 case JVM_CONSTANT_Utf8: {
563 dos.writeByte(cpConstType);
564 Symbol sym = getSymbolAt(ci);
565 dos.writeShort((short)sym.getLength());
566 dos.write(sym.asByteArray());
567 if (DEBUG) debugMessage("CP[" + ci + "] = modified UTF-8 " + sym.asString());
568 break;
569 }
570
571 case JVM_CONSTANT_Unicode:
572 throw new IllegalArgumentException("Unicode constant!");
573
574 case JVM_CONSTANT_Integer:
575 dos.writeByte(cpConstType);
576 dos.writeInt(getIntAt(ci));
577 if (DEBUG) debugMessage("CP[" + ci + "] = int " + getIntAt(ci));
578 break;
579
580 case JVM_CONSTANT_Float:
581 dos.writeByte(cpConstType);
582 dos.writeFloat(getFloatAt(ci));
583 if (DEBUG) debugMessage("CP[" + ci + "] = float " + getFloatAt(ci));
584 break;
585
586 case JVM_CONSTANT_Long: {
587 dos.writeByte(cpConstType);
588 long l = getLongAt(ci);
589 // long entries occupy two pool entries
590 ci++;
591 dos.writeLong(l);
592 break;
593 }
594
595 case JVM_CONSTANT_Double:
596 dos.writeByte(cpConstType);
597 dos.writeDouble(getDoubleAt(ci));
598 // double entries occupy two pool entries
599 ci++;
600 break;
601
602 case JVM_CONSTANT_Class: {
603 dos.writeByte(cpConstType);
604 // Klass already resolved. ConstantPool constains Klass*.
605 Klass refKls = (Klass)Metadata.instantiateWrapperFor(getAddressAtRaw(ci));
606 String klassName = refKls.getName().asString();
607 Short s = (Short) utf8ToIndex.get(klassName);
608 dos.writeShort(s.shortValue());
609 if (DEBUG) debugMessage("CP[" + ci + "] = class " + s);
610 break;
611 }
612
613 // case JVM_CONSTANT_ClassIndex:
614 case JVM_CONSTANT_UnresolvedClassInError:
615 case JVM_CONSTANT_UnresolvedClass: {
616 dos.writeByte(JVM_CONSTANT_Class);
617 String klassName = getSymbolAt(ci).asString();
618 Short s = (Short) utf8ToIndex.get(klassName);
619 dos.writeShort(s.shortValue());
620 if (DEBUG) debugMessage("CP[" + ci + "] = class " + s);
621 break;
622 }
623
624 case JVM_CONSTANT_String: {
625 dos.writeByte(cpConstType);
626 String str = getUnresolvedStringAt(ci).asString();
627 Short s = (Short) utf8ToIndex.get(str);
628 dos.writeShort(s.shortValue());
629 if (DEBUG) debugMessage("CP[" + ci + "] = string " + s);
630 break;
631 }
632
633 // all external, internal method/field references
634 case JVM_CONSTANT_Fieldref:
635 case JVM_CONSTANT_Methodref:
636 case JVM_CONSTANT_InterfaceMethodref: {
637 dos.writeByte(cpConstType);
638 int value = getIntAt(ci);
639 short klassIndex = (short) extractLowShortFromInt(value);
640 short nameAndTypeIndex = (short) extractHighShortFromInt(value);
641 dos.writeShort(klassIndex);
642 dos.writeShort(nameAndTypeIndex);
643 if (DEBUG) debugMessage("CP[" + ci + "] = ref klass = " +
644 klassIndex + ", N&T = " + nameAndTypeIndex);
645 break;
646 }
647
648 case JVM_CONSTANT_NameAndType: {
649 dos.writeByte(cpConstType);
650 int value = getIntAt(ci);
651 short nameIndex = (short) extractLowShortFromInt(value);
652 short signatureIndex = (short) extractHighShortFromInt(value);
653 dos.writeShort(nameIndex);
654 dos.writeShort(signatureIndex);
655 if (DEBUG) debugMessage("CP[" + ci + "] = N&T name = " + nameIndex
656 + ", type = " + signatureIndex);
657 break;
658 }
659
660 case JVM_CONSTANT_MethodHandle: {
661 dos.writeByte(cpConstType);
662 int value = getIntAt(ci);
663 byte refKind = (byte) extractLowShortFromInt(value);
664 short memberIndex = (short) extractHighShortFromInt(value);
665 dos.writeByte(refKind);
666 dos.writeShort(memberIndex);
667 if (DEBUG) debugMessage("CP[" + ci + "] = MH kind = " +
668 refKind + ", mem = " + memberIndex);
669 break;
670 }
671
672 case JVM_CONSTANT_MethodType: {
673 dos.writeByte(cpConstType);
674 int value = getIntAt(ci);
675 short refIndex = (short) value;
676 dos.writeShort(refIndex);
677 if (DEBUG) debugMessage("CP[" + ci + "] = MT index = " + refIndex);
678 break;
679 }
680
681 case JVM_CONSTANT_InvokeDynamic: {
682 dos.writeByte(cpConstType);
683 int value = getIntAt(ci);
684 short bsmIndex = (short) extractLowShortFromInt(value);
685 short nameAndTypeIndex = (short) extractHighShortFromInt(value);
686 dos.writeShort(bsmIndex);
687 dos.writeShort(nameAndTypeIndex);
688 if (DEBUG) debugMessage("CP[" + ci + "] = INDY bsm = " +
689 bsmIndex + ", N&T = " + nameAndTypeIndex);
690 break;
691 }
692
693 default:
694 throw new InternalError("Unknown tag: " + cpConstType);
695 } // switch
696 }
697 dos.flush();
698 return;
699 }
700
701 public void printValueOn(PrintStream tty) {
702 tty.print("ConstantPool for " + getPoolHolder().getName().asString());
703 }
704
705 public long getSize() {
706 return alignSize(headerSize + getLength());
707 }
708
709 //----------------------------------------------------------------------
710 // Internals only below this point
711 //
712
713 private static int extractHighShortFromInt(int val) {
714 // must stay in sync with ConstantPool::name_and_type_at_put, method_at_put, etc.
715 return (val >> 16) & 0xFFFF;
716 }
717
718 private static int extractLowShortFromInt(int val) {
719 // must stay in sync with ConstantPool::name_and_type_at_put, method_at_put, etc.
720 return val & 0xFFFF;
721 }
722 }