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 the object index. The object map points at
273 // the cpCache index and the cpCache entry points at the original constant
274 // pool index.
275 public int invokedynamicCPCacheIndex(int index) {
276 Assert.that(isInvokedynamicIndex(index), "should be a invokedynamic index");
277 int rawIndex = decodeInvokedynamicIndex(index);
278 return referenceMap().at(rawIndex);
279 }
280
281 ConstantPoolCacheEntry invokedynamicCPCacheEntryAt(int index) {
282 // decode index that invokedynamic points to.
283 int cpCacheIndex = invokedynamicCPCacheIndex(index);
284 return getCache().getEntryAt(cpCacheIndex);
285 }
286
287 private int implNameAndTypeRefIndexAt(int which, boolean uncached) {
288 int i = which;
289 if (!uncached && getCache() != null) {
290 if (isInvokedynamicIndex(which)) {
291 // Invokedynamic index is index into resolved_references
292 int poolIndex = invokedynamicCPCacheEntryAt(which).getConstantPoolIndex();
293 poolIndex = invokeDynamicNameAndTypeRefIndexAt(poolIndex);
294 Assert.that(getTagAt(poolIndex).isNameAndType(), "");
295 return poolIndex;
296 }
297 // change byte-ordering and go via cache
298 i = remapInstructionOperandFromCache(which);
299 } else {
300 if (getTagAt(which).isInvokeDynamic()) {
301 int poolIndex = invokeDynamicNameAndTypeRefIndexAt(which);
302 Assert.that(getTagAt(poolIndex).isNameAndType(), "");
303 return poolIndex;
304 }
305 }
306 // assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");
307 // assert(!tag_at(i).is_invoke_dynamic(), "Must be handled above");
308 int refIndex = getIntAt(i);
309 return extractHighShortFromInt(refIndex);
310 }
311
312 private int remapInstructionOperandFromCache(int operand) {
313 int cpc_index = operand;
314 // DEBUG_ONLY(cpc_index -= CPCACHE_INDEX_TAG);
315 // assert((int)(u2)cpc_index == cpc_index, "clean u2");
316 int member_index = getCache().getEntryAt(cpc_index).getConstantPoolIndex();
317 return member_index;
318 }
319
320 public int invokeDynamicNameAndTypeRefIndexAt(int which) {
321 // assert(tag_at(which).is_invoke_dynamic(), "Corrupted constant pool");
322 return extractHighShortFromInt(getIntAt(which));
323 }
324
325 // returns null, if not resolved.
326 public Klass getKlassAt(int which) {
327 if( ! getTagAt(which).isKlass()) return null;
328 int resolved_klass_index = getKlassSlotAt(which).getResolvedKlassIndex();
329 KlassArray resolved_klasses = getResolvedKlasses();
330 return resolved_klasses.getAt(resolved_klass_index);
331 }
332
333 public Symbol getKlassNameAt(int which) {
334 int name_index = getKlassSlotAt(which).getNameIndex();
335 return getSymbolAt(name_index);
336 }
337
338 public Symbol getUnresolvedStringAt(int which) {
339 return getSlotAt(which).getSymbol();
340 }
341
342 // returns null, if not resolved.
343 public InstanceKlass getFieldOrMethodKlassRefAt(int which) {
344 int refIndex = getFieldOrMethodAt(which);
345 int klassIndex = extractLowShortFromInt(refIndex);
346 return (InstanceKlass) getKlassAt(klassIndex);
347 }
348
349 // returns null, if not resolved.
350 public Method getMethodRefAt(int which) {
351 InstanceKlass klass = getFieldOrMethodKlassRefAt(which);
352 if (klass == null) return null;
353 Symbol name = getNameRefAt(which);
354 Symbol sig = getSignatureRefAt(which);
355 return klass.findMethod(name, sig);
356 }
357
358 // returns null, if not resolved.
359 public Field getFieldRefAt(int which) {
360 InstanceKlass klass = getFieldOrMethodKlassRefAt(which);
361 if (klass == null) return null;
362 Symbol name = getNameRefAt(which);
363 Symbol sig = getSignatureRefAt(which);
364 return klass.findField(name, sig);
365 }
366
367 public int getNameAndTypeRefIndexAt(int index) {
368 return implNameAndTypeRefIndexAt(index, false);
369 }
370
371 /** Lookup for entries consisting of (name_index, signature_index) */
372 public int getNameRefIndexAt(int index) {
373 int[] refIndex = getNameAndTypeAt(index);
374 if (DEBUG) {
375 System.err.println("ConstantPool.getNameRefIndexAt(" + index + "): refIndex = " + refIndex[0]+"/"+refIndex[1]);
376 }
377 int i = refIndex[0];
378 if (DEBUG) {
379 System.err.println("ConstantPool.getNameRefIndexAt(" + index + "): result = " + i);
380 }
381 return i;
382 }
383
384 /** Lookup for entries consisting of (name_index, signature_index) */
385 public int getSignatureRefIndexAt(int index) {
386 int[] refIndex = getNameAndTypeAt(index);
387 if (DEBUG) {
388 System.err.println("ConstantPool.getSignatureRefIndexAt(" + index + "): refIndex = " + refIndex[0]+"/"+refIndex[1]);
389 }
390 int i = refIndex[1];
391 if (DEBUG) {
392 System.err.println("ConstantPool.getSignatureRefIndexAt(" + index + "): result = " + i);
393 }
394 return i;
395 }
396
397 /** Lookup for MethodHandle entries. */
398 public int getMethodHandleIndexAt(int i) {
399 if (Assert.ASSERTS_ENABLED) {
400 Assert.that(getTagAt(i).isMethodHandle(), "Corrupted constant pool");
401 }
402 int res = extractHighShortFromInt(getIntAt(i));
403 if (DEBUG) {
404 System.err.println("ConstantPool.getMethodHandleIndexAt(" + i + "): result = " + res);
405 }
406 return res;
407 }
408
409 /** Lookup for MethodHandle entries. */
410 public int getMethodHandleRefKindAt(int i) {
411 if (Assert.ASSERTS_ENABLED) {
412 Assert.that(getTagAt(i).isMethodHandle(), "Corrupted constant pool");
413 }
414 int res = extractLowShortFromInt(getIntAt(i));
415 if (DEBUG) {
416 System.err.println("ConstantPool.getMethodHandleRefKindAt(" + i + "): result = " + res);
417 }
418 return res;
419 }
420
421 /** Lookup for MethodType entries. */
422 public int getMethodTypeIndexAt(int i) {
423 if (Assert.ASSERTS_ENABLED) {
424 Assert.that(getTagAt(i).isMethodType(), "Corrupted constant pool");
425 }
426 int res = getIntAt(i);
427 if (DEBUG) {
428 System.err.println("ConstantPool.getMethodHandleTypeAt(" + i + "): result = " + res);
429 }
430 return res;
431 }
432
433 /** Lookup for multi-operand (InvokeDynamic) entries. */
434 public short[] getBootstrapSpecifierAt(int i) {
435 if (Assert.ASSERTS_ENABLED) {
436 Assert.that(getTagAt(i).isInvokeDynamic(), "Corrupted constant pool");
437 }
438 int bsmSpec = extractLowShortFromInt(this.getIntAt(i));
439 U2Array operands = getOperands();
440 if (operands == null) return null; // safety first
441 int basePos = VM.getVM().buildIntFromShorts(operands.at(bsmSpec * 2 + 0),
442 operands.at(bsmSpec * 2 + 1));
443 int argv = basePos + INDY_ARGV_OFFSET;
444 int argc = operands.at(basePos + INDY_ARGC_OFFSET);
445 int endPos = argv + argc;
446 short[] values = new short[endPos - basePos];
447 for (int j = 0; j < values.length; j++) {
448 values[j] = operands.at(basePos+j);
449 }
450 return values;
451 }
452
453 final private static String[] nameForTag = new String[] {
454 };
455
456 private String nameForTag(int tag) {
457 switch (tag) {
458 case JVM_CONSTANT_Utf8: return "JVM_CONSTANT_Utf8";
459 case JVM_CONSTANT_Unicode: return "JVM_CONSTANT_Unicode";
460 case JVM_CONSTANT_Integer: return "JVM_CONSTANT_Integer";
461 case JVM_CONSTANT_Float: return "JVM_CONSTANT_Float";
462 case JVM_CONSTANT_Long: return "JVM_CONSTANT_Long";
463 case JVM_CONSTANT_Double: return "JVM_CONSTANT_Double";
464 case JVM_CONSTANT_Class: return "JVM_CONSTANT_Class";
465 case JVM_CONSTANT_String: return "JVM_CONSTANT_String";
466 case JVM_CONSTANT_Fieldref: return "JVM_CONSTANT_Fieldref";
467 case JVM_CONSTANT_Methodref: return "JVM_CONSTANT_Methodref";
468 case JVM_CONSTANT_InterfaceMethodref: return "JVM_CONSTANT_InterfaceMethodref";
469 case JVM_CONSTANT_NameAndType: return "JVM_CONSTANT_NameAndType";
470 case JVM_CONSTANT_MethodHandle: return "JVM_CONSTANT_MethodHandle";
471 case JVM_CONSTANT_MethodType: return "JVM_CONSTANT_MethodType";
472 case JVM_CONSTANT_InvokeDynamic: return "JVM_CONSTANT_InvokeDynamic";
473 case JVM_CONSTANT_Invalid: return "JVM_CONSTANT_Invalid";
474 case JVM_CONSTANT_UnresolvedClass: return "JVM_CONSTANT_UnresolvedClass";
475 case JVM_CONSTANT_ClassIndex: return "JVM_CONSTANT_ClassIndex";
476 case JVM_CONSTANT_StringIndex: return "JVM_CONSTANT_StringIndex";
477 case JVM_CONSTANT_UnresolvedClassInError: return "JVM_CONSTANT_UnresolvedClassInError";
478 case JVM_CONSTANT_MethodHandleInError:return "JVM_CONSTANT_MethodHandleInError";
479 case JVM_CONSTANT_MethodTypeInError: return "JVM_CONSTANT_MethodTypeInError";
480 }
481 throw new InternalError("Unknown tag: " + tag);
482 }
483
484 public void iterateFields(MetadataVisitor visitor) {
485 super.iterateFields(visitor);
486 visitor.doMetadata(poolHolder, true);
487
488 final int length = (int) getLength();
489 // zero'th pool entry is always invalid. ignore it.
490 for (int index = 1; index < length; index++) {
491 int ctag = (int) getTags().at((int) index);
492 switch (ctag) {
493 case JVM_CONSTANT_ClassIndex:
494 case JVM_CONSTANT_StringIndex:
495 case JVM_CONSTANT_Integer:
496 visitor.doInt(new IntField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);
497 break;
498
499 case JVM_CONSTANT_Float:
500 visitor.doFloat(new FloatField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);
501 break;
502
503 case JVM_CONSTANT_Long:
504 visitor.doLong(new LongField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);
505 // long entries occupy two slots
506 index++;
507 break;
508
509 case JVM_CONSTANT_Double:
510 visitor.doDouble(new DoubleField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);
511 // double entries occupy two slots
512 index++;
513 break;
514
515 case JVM_CONSTANT_UnresolvedClassInError:
516 case JVM_CONSTANT_UnresolvedClass:
517 case JVM_CONSTANT_Class:
518 case JVM_CONSTANT_Utf8:
519 visitor.doOop(new OopField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);
520 break;
521
522 case JVM_CONSTANT_Fieldref:
523 case JVM_CONSTANT_Methodref:
524 case JVM_CONSTANT_InterfaceMethodref:
525 case JVM_CONSTANT_NameAndType:
526 case JVM_CONSTANT_MethodHandle:
527 case JVM_CONSTANT_MethodType:
528 case JVM_CONSTANT_InvokeDynamic:
529 visitor.doInt(new IntField(new NamedFieldIdentifier(nameForTag(ctag)), indexOffset(index), true), true);
530 break;
531 }
532 }
533 }
534
535 public void writeBytes(OutputStream os) throws IOException {
536 // Map between any modified UTF-8 and it's constant pool index.
537 Map utf8ToIndex = new HashMap();
538 DataOutputStream dos = new DataOutputStream(os);
539 U1Array tags = getTags();
540 int len = (int)getLength();
541 int ci = 0; // constant pool index
542
543 // collect all modified UTF-8 Strings from Constant Pool
544
545 for (ci = 1; ci < len; ci++) {
546 int cpConstType = tags.at(ci);
547 if(cpConstType == JVM_CONSTANT_Utf8) {
548 Symbol sym = getSymbolAt(ci);
549 utf8ToIndex.put(sym.asString(), new Short((short) ci));
550 }
551 else if(cpConstType == JVM_CONSTANT_Long ||
552 cpConstType == JVM_CONSTANT_Double) {
553 ci++;
554 }
555 }
556
557
558 for(ci = 1; ci < len; ci++) {
559 int cpConstType = tags.at(ci);
560 // write cp_info
561 // write constant type
562 switch(cpConstType) {
563 case JVM_CONSTANT_Utf8: {
564 dos.writeByte(cpConstType);
565 Symbol sym = getSymbolAt(ci);
566 dos.writeShort((short)sym.getLength());
567 dos.write(sym.asByteArray());
568 if (DEBUG) debugMessage("CP[" + ci + "] = modified UTF-8 " + sym.asString());
569 break;
570 }
571
572 case JVM_CONSTANT_Unicode:
573 throw new IllegalArgumentException("Unicode constant!");
574
575 case JVM_CONSTANT_Integer:
576 dos.writeByte(cpConstType);
577 dos.writeInt(getIntAt(ci));
578 if (DEBUG) debugMessage("CP[" + ci + "] = int " + getIntAt(ci));
579 break;
580
581 case JVM_CONSTANT_Float:
582 dos.writeByte(cpConstType);
583 dos.writeFloat(getFloatAt(ci));
584 if (DEBUG) debugMessage("CP[" + ci + "] = float " + getFloatAt(ci));
585 break;
586
587 case JVM_CONSTANT_Long: {
588 dos.writeByte(cpConstType);
589 long l = getLongAt(ci);
590 // long entries occupy two pool entries
591 ci++;
592 dos.writeLong(l);
593 break;
594 }
595
596 case JVM_CONSTANT_Double:
597 dos.writeByte(cpConstType);
598 dos.writeDouble(getDoubleAt(ci));
599 // double entries occupy two pool entries
600 ci++;
601 break;
602
603 case JVM_CONSTANT_Class: {
604 dos.writeByte(cpConstType);
605 // Klass already resolved. ConstantPool constains Klass*.
606 Klass refKls = (Klass)Metadata.instantiateWrapperFor(getAddressAtRaw(ci));
607 String klassName = refKls.getName().asString();
608 Short s = (Short) utf8ToIndex.get(klassName);
609 dos.writeShort(s.shortValue());
610 if (DEBUG) debugMessage("CP[" + ci + "] = class " + s);
611 break;
612 }
613
614 // case JVM_CONSTANT_ClassIndex:
615 case JVM_CONSTANT_UnresolvedClassInError:
616 case JVM_CONSTANT_UnresolvedClass: {
617 dos.writeByte(JVM_CONSTANT_Class);
618 String klassName = getSymbolAt(ci).asString();
619 Short s = (Short) utf8ToIndex.get(klassName);
620 dos.writeShort(s.shortValue());
621 if (DEBUG) debugMessage("CP[" + ci + "] = class " + s);
622 break;
623 }
624
625 case JVM_CONSTANT_String: {
626 dos.writeByte(cpConstType);
627 String str = getUnresolvedStringAt(ci).asString();
628 Short s = (Short) utf8ToIndex.get(str);
629 dos.writeShort(s.shortValue());
630 if (DEBUG) debugMessage("CP[" + ci + "] = string " + s);
631 break;
632 }
633
634 // all external, internal method/field references
635 case JVM_CONSTANT_Fieldref:
636 case JVM_CONSTANT_Methodref:
637 case JVM_CONSTANT_InterfaceMethodref: {
638 dos.writeByte(cpConstType);
639 int value = getIntAt(ci);
640 short klassIndex = (short) extractLowShortFromInt(value);
641 short nameAndTypeIndex = (short) extractHighShortFromInt(value);
642 dos.writeShort(klassIndex);
643 dos.writeShort(nameAndTypeIndex);
644 if (DEBUG) debugMessage("CP[" + ci + "] = ref klass = " +
645 klassIndex + ", N&T = " + nameAndTypeIndex);
646 break;
647 }
648
649 case JVM_CONSTANT_NameAndType: {
650 dos.writeByte(cpConstType);
651 int value = getIntAt(ci);
652 short nameIndex = (short) extractLowShortFromInt(value);
653 short signatureIndex = (short) extractHighShortFromInt(value);
654 dos.writeShort(nameIndex);
655 dos.writeShort(signatureIndex);
656 if (DEBUG) debugMessage("CP[" + ci + "] = N&T name = " + nameIndex
657 + ", type = " + signatureIndex);
658 break;
659 }
660
661 case JVM_CONSTANT_MethodHandle: {
662 dos.writeByte(cpConstType);
663 int value = getIntAt(ci);
664 byte refKind = (byte) extractLowShortFromInt(value);
665 short memberIndex = (short) extractHighShortFromInt(value);
666 dos.writeByte(refKind);
667 dos.writeShort(memberIndex);
668 if (DEBUG) debugMessage("CP[" + ci + "] = MH kind = " +
669 refKind + ", mem = " + memberIndex);
670 break;
671 }
672
673 case JVM_CONSTANT_MethodType: {
674 dos.writeByte(cpConstType);
675 int value = getIntAt(ci);
676 short refIndex = (short) value;
677 dos.writeShort(refIndex);
678 if (DEBUG) debugMessage("CP[" + ci + "] = MT index = " + refIndex);
679 break;
680 }
681
682 case JVM_CONSTANT_InvokeDynamic: {
683 dos.writeByte(cpConstType);
684 int value = getIntAt(ci);
685 short bsmIndex = (short) extractLowShortFromInt(value);
686 short nameAndTypeIndex = (short) extractHighShortFromInt(value);
687 dos.writeShort(bsmIndex);
688 dos.writeShort(nameAndTypeIndex);
689 if (DEBUG) debugMessage("CP[" + ci + "] = INDY bsm = " +
690 bsmIndex + ", N&T = " + nameAndTypeIndex);
691 break;
692 }
693
694 default:
695 throw new InternalError("Unknown tag: " + cpConstType);
696 } // switch
697 }
698 dos.flush();
699 return;
700 }
701
702 public void printValueOn(PrintStream tty) {
703 tty.print("ConstantPool for " + getPoolHolder().getName().asString());
704 }
705
706 public long getSize() {
707 return alignSize(headerSize + getLength());
708 }
709
710 //----------------------------------------------------------------------
711 // Internals only below this point
712 //
713
714 private static int extractHighShortFromInt(int val) {
715 // must stay in sync with ConstantPool::name_and_type_at_put, method_at_put, etc.
716 return (val >> 16) & 0xFFFF;
717 }
718
719 private static int extractLowShortFromInt(int val) {
720 // must stay in sync with ConstantPool::name_and_type_at_put, method_at_put, etc.
721 return val & 0xFFFF;
722 }
723 }