1 /*
2 * Copyright (c) 2002, 2023, 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.tools.jcore;
26
27 import java.io.*;
28 import java.util.*;
29 import sun.jvm.hotspot.oops.*;
30 import sun.jvm.hotspot.runtime.*;
31 import sun.jvm.hotspot.utilities.*;
32
33 public class ClassWriter implements /* imports */ ClassConstants
34 {
35 public static final boolean DEBUG = false;
36
37 protected void debugMessage(String message) {
38 System.out.println(message);
39 }
40
41 protected InstanceKlass klass;
42 protected DataOutputStream dos;
43 protected ConstantPool cpool;
44
45 // Map between class name to index of type CONSTANT_Class
46 protected Map<String, Short> classToIndex = new HashMap<String, Short>();
47
48 // Map between any modified UTF-8 and it's constant pool index.
49 protected Map<String, Short> utf8ToIndex = new HashMap<String, Short>();
50
51 // constant pool index for attribute names.
52
53 protected short _sourceFileIndex;
54 protected short _innerClassesIndex;
55 protected short _nestHostIndex;
56 protected short _nestMembersIndex;
57 protected short _syntheticIndex;
58 protected short _deprecatedIndex;
59 protected short _constantValueIndex;
60 protected short _codeIndex;
61 protected short _exceptionsIndex;
62 protected short _stackMapTableIndex;
63 protected short _lineNumberTableIndex;
64 protected short _localVariableTableIndex;
65 protected short _signatureIndex;
66 protected short _bootstrapMethodsIndex;
67
68 protected static int extractHighShortFromInt(int val) {
69 // must stay in sync with ConstantPool::name_and_type_at_put, method_at_put, etc.
70 return (val >> 16) & 0xFFFF;
71 }
72
73 protected static int extractLowShortFromInt(int val) {
74 // must stay in sync with ConstantPool::name_and_type_at_put, method_at_put, etc.
75 return val & 0xFFFF;
76 }
77
78 public ClassWriter(InstanceKlass kls, OutputStream os) {
79 klass = kls;
80 dos = new DataOutputStream(os);
81 cpool = klass.getConstants();
82 }
83
84 public void write() throws IOException {
85 if (DEBUG) debugMessage("class name = " + klass.getName().asString());
86
87 // write magic
88 dos.writeInt(0xCAFEBABE);
89
90 writeVersion();
91 writeConstantPool();
92 writeClassAccessFlags();
93 writeThisClass();
94 writeSuperClass();
95 writeInterfaces();
96 writeFields();
97 writeMethods();
98 writeClassAttributes();
99
100 // flush output
101 dos.flush();
102 }
103
104 protected void writeVersion() throws IOException {
105 dos.writeShort((short)klass.minorVersion());
106 dos.writeShort((short)klass.majorVersion());
107 }
108
109 protected void writeIndex(int index) throws IOException {
110 if (index == 0) throw new InternalError();
111 dos.writeShort(index);
112 }
113
114 protected void writeConstantPool() throws IOException {
115 final U1Array tags = cpool.getTags();
116 final long len = tags.length();
117 dos.writeShort((short) len);
118
119 if (DEBUG) debugMessage("constant pool length = " + len);
120
121 int ci = 0; // constant pool index
122
123 // collect all modified UTF-8 Strings from Constant Pool
124
125 for (ci = 1; ci < len; ci++) {
126 int cpConstType = tags.at(ci);
127 if(cpConstType == JVM_CONSTANT_Utf8) {
128 Symbol sym = cpool.getSymbolAt(ci);
129 utf8ToIndex.put(sym.asString(), (short) ci);
130 }
131 else if(cpConstType == JVM_CONSTANT_Long ||
132 cpConstType == JVM_CONSTANT_Double) {
133 ci++;
134 }
135 }
136
137 // remember index of attribute name modified UTF-8 strings
138
139 // class attributes
140 Short sourceFileIndex = utf8ToIndex.get("SourceFile");
141 _sourceFileIndex = (sourceFileIndex != null)? sourceFileIndex.shortValue() : 0;
142 if (DEBUG) debugMessage("SourceFile index = " + _sourceFileIndex);
143
144 Short innerClassesIndex = utf8ToIndex.get("InnerClasses");
145 _innerClassesIndex = (innerClassesIndex != null)? innerClassesIndex.shortValue() : 0;
146 if (DEBUG) debugMessage("InnerClasses index = " + _innerClassesIndex);
147
148 Short nestHostIndex = utf8ToIndex.get("NestHost");
149 _nestHostIndex = (nestHostIndex != null)? nestHostIndex.shortValue() : 0;
150 if (DEBUG) debugMessage("NestHost index = " + _nestHostIndex);
151
152 Short nestMembersIndex = utf8ToIndex.get("NestMembers");
153 _nestMembersIndex = (nestMembersIndex != null)? nestMembersIndex.shortValue() : 0;
154 if (DEBUG) debugMessage("NestMembers index = " + _nestMembersIndex);
155
156 Short bootstrapMethodsIndex = utf8ToIndex.get("BootstrapMethods");
157 _bootstrapMethodsIndex = (bootstrapMethodsIndex != null) ? bootstrapMethodsIndex.shortValue() : 0;
158 // field attributes
159 Short constantValueIndex = utf8ToIndex.get("ConstantValue");
160 _constantValueIndex = (constantValueIndex != null)?
161 constantValueIndex.shortValue() : 0;
162 if (DEBUG) debugMessage("ConstantValue index = " + _constantValueIndex);
163
164 Short syntheticIndex = utf8ToIndex.get("Synthetic");
165 _syntheticIndex = (syntheticIndex != null)? syntheticIndex.shortValue() : 0;
166 if (DEBUG) debugMessage("Synthetic index = " + _syntheticIndex);
167
168 Short deprecatedIndex = utf8ToIndex.get("Deprecated");
169 _deprecatedIndex = (deprecatedIndex != null)? deprecatedIndex.shortValue() : 0;
170 if (DEBUG) debugMessage("Deprecated index = " + _deprecatedIndex);
171
172 // method attributes
173 Short codeIndex = utf8ToIndex.get("Code");
174 _codeIndex = (codeIndex != null)? codeIndex.shortValue() : 0;
175 if (DEBUG) debugMessage("Code index = " + _codeIndex);
176
177 Short exceptionsIndex = utf8ToIndex.get("Exceptions");
178 _exceptionsIndex = (exceptionsIndex != null)? exceptionsIndex.shortValue() : 0;
179 if (DEBUG) debugMessage("Exceptions index = " + _exceptionsIndex);
180
181 // Short syntheticIndex = (Short) utf8ToIndex.get("Synthetic");
182 // Short deprecatedIndex = (Short) utf8ToIndex.get("Deprecated");
183
184 // Code attributes
185 Short stackMapTableIndex = utf8ToIndex.get("StackMapTable");
186 _stackMapTableIndex = (stackMapTableIndex != null) ?
187 stackMapTableIndex.shortValue() : 0;
188 if (DEBUG) debugMessage("StackMapTable index = " + _stackMapTableIndex);
189
190 Short lineNumberTableIndex = utf8ToIndex.get("LineNumberTable");
191 _lineNumberTableIndex = (lineNumberTableIndex != null)?
192 lineNumberTableIndex.shortValue() : 0;
193 if (DEBUG) debugMessage("LineNumberTable index = " + _lineNumberTableIndex);
194
195 Short localVariableTableIndex = utf8ToIndex.get("LocalVariableTable");
196 _localVariableTableIndex = (localVariableTableIndex != null)?
197 localVariableTableIndex.shortValue() : 0;
198 if (DEBUG) debugMessage("LocalVariableTable index = " + _localVariableTableIndex);
199
200 Short signatureIdx = utf8ToIndex.get("Signature");
201 _signatureIndex = (signatureIdx != null)? signatureIdx.shortValue() : 0;
202 if (DEBUG) debugMessage("Signature index = " + _signatureIndex);
203
204 for(ci = 1; ci < len; ci++) {
205 int cpConstType = tags.at(ci);
206 // write cp_info
207 // write constant type
208 switch(cpConstType) {
209 case JVM_CONSTANT_Utf8: {
210 dos.writeByte(cpConstType);
211 Symbol sym = cpool.getSymbolAt(ci);
212 dos.writeShort((short)sym.getLength());
213 dos.write(sym.asByteArray());
214 if (DEBUG) debugMessage("CP[" + ci + "] = modified UTF-8 " + sym.asString());
215 break;
216 }
217
218 case JVM_CONSTANT_Unicode:
219 throw new IllegalArgumentException("Unicode constant!");
220
221 case JVM_CONSTANT_Integer:
222 dos.writeByte(cpConstType);
223 dos.writeInt(cpool.getIntAt(ci));
224 if (DEBUG) debugMessage("CP[" + ci + "] = int " + cpool.getIntAt(ci));
225 break;
226
227 case JVM_CONSTANT_Float:
228 dos.writeByte(cpConstType);
229 dos.writeFloat(cpool.getFloatAt(ci));
230 if (DEBUG) debugMessage("CP[" + ci + "] = float " + cpool.getFloatAt(ci));
231 break;
232
233 case JVM_CONSTANT_Long: {
234 dos.writeByte(cpConstType);
235 long l = cpool.getLongAt(ci);
236 // long entries occupy two pool entries
237 ci++;
238 dos.writeLong(l);
239 break;
240 }
241
242 case JVM_CONSTANT_Double:
243 dos.writeByte(cpConstType);
244 dos.writeDouble(cpool.getDoubleAt(ci));
245 // double entries occupy two pool entries
246 ci++;
247 break;
248
249 case JVM_CONSTANT_Class:
250 case JVM_CONSTANT_UnresolvedClass:
251 case JVM_CONSTANT_UnresolvedClassInError: {
252 dos.writeByte(JVM_CONSTANT_Class);
253 String klassName = cpool.getKlassNameAt(ci).asString();
254 Short s = utf8ToIndex.get(klassName);
255 classToIndex.put(klassName, (short) ci);
256 dos.writeShort(s.shortValue());
257 if (DEBUG) debugMessage("CP[" + ci + "] = class " + s);
258 break;
259 }
260
261 case JVM_CONSTANT_String: {
262 dos.writeByte(cpConstType);
263 String str = cpool.getUnresolvedStringAt(ci).asString();
264 Short s = utf8ToIndex.get(str);
265 dos.writeShort(s.shortValue());
266 if (DEBUG) debugMessage("CP[" + ci + "] = string " + s);
267 break;
268 }
269
270 // all external, internal method/field references
271 case JVM_CONSTANT_Fieldref:
272 case JVM_CONSTANT_Methodref:
273 case JVM_CONSTANT_InterfaceMethodref: {
274 dos.writeByte(cpConstType);
275 int value = cpool.getIntAt(ci);
276 short klassIndex = (short) extractLowShortFromInt(value);
277 short nameAndTypeIndex = (short) extractHighShortFromInt(value);
278 dos.writeShort(klassIndex);
279 dos.writeShort(nameAndTypeIndex);
280 if (DEBUG) debugMessage("CP[" + ci + "] = ref klass = " +
281 klassIndex + ", N&T = " + nameAndTypeIndex);
282 break;
283 }
284
285 case JVM_CONSTANT_NameAndType: {
286 dos.writeByte(cpConstType);
287 int value = cpool.getIntAt(ci);
288 short nameIndex = (short) extractLowShortFromInt(value);
289 short signatureIndex = (short) extractHighShortFromInt(value);
290 dos.writeShort(nameIndex);
291 dos.writeShort(signatureIndex);
292 if (DEBUG) debugMessage("CP[" + ci + "] = N&T name = " + nameIndex
293 + ", type = " + signatureIndex);
294 break;
295 }
296
297 case JVM_CONSTANT_MethodHandle: {
298 dos.writeByte(cpConstType);
299 int value = cpool.getIntAt(ci);
300 byte refKind = (byte) extractLowShortFromInt(value);
301 short memberIndex = (short) extractHighShortFromInt(value);
302 dos.writeByte(refKind);
303 dos.writeShort(memberIndex);
304 if (DEBUG) debugMessage("CP[" + ci + "] = MH kind = " +
305 refKind + ", mem = " + memberIndex);
306 break;
307 }
308
309 case JVM_CONSTANT_MethodType: {
310 dos.writeByte(cpConstType);
311 int value = cpool.getIntAt(ci);
312 short refIndex = (short) value;
313 dos.writeShort(refIndex);
314 if (DEBUG) debugMessage("CP[" + ci + "] = MT index = " + refIndex);
315 break;
316 }
317
318 case JVM_CONSTANT_Dynamic: {
319 dos.writeByte(cpConstType);
320 int value = cpool.getIntAt(ci);
321 short bsmIndex = (short) extractLowShortFromInt(value);
322 short nameAndTypeIndex = (short) extractHighShortFromInt(value);
323 dos.writeShort(bsmIndex);
324 dos.writeShort(nameAndTypeIndex);
325 if (DEBUG) debugMessage("CP[" + ci + "] = CONDY bsm = " +
326 bsmIndex + ", N&T = " + nameAndTypeIndex);
327 break;
328 }
329
330 case JVM_CONSTANT_InvokeDynamic: {
331 dos.writeByte(cpConstType);
332 int value = cpool.getIntAt(ci);
333 short bsmIndex = (short) extractLowShortFromInt(value);
334 short nameAndTypeIndex = (short) extractHighShortFromInt(value);
335 dos.writeShort(bsmIndex);
336 dos.writeShort(nameAndTypeIndex);
337 if (DEBUG) debugMessage("CP[" + ci + "] = INDY bsm = " +
338 bsmIndex + ", N&T = " + nameAndTypeIndex);
339 break;
340 }
341
342 default:
343 throw new InternalError("Unknown tag: " + cpConstType);
344 } // switch
345 }
346 }
347
348 protected void writeClassAccessFlags() throws IOException {
349 int flags = (int)(klass.getAccessFlags() & JVM_RECOGNIZED_CLASS_MODIFIERS);
350 dos.writeShort((short)flags);
351 }
352
353 protected void writeThisClass() throws IOException {
354 String klassName = klass.getName().asString();
355 Short index = classToIndex.get(klassName);
356 dos.writeShort(index.shortValue());
357 if (DEBUG) debugMessage("this class = " + index);
358 }
359
360 protected void writeSuperClass() throws IOException {
361 Klass superKlass = klass.getSuper();
362 if (superKlass != null) { // is not java.lang.Object
363 String superName = superKlass.getName().asString();
364 Short index = classToIndex.get(superName);
365 if (DEBUG) debugMessage("super class = " + index);
366 dos.writeShort(index.shortValue());
367 } else {
368 dos.writeShort(0); // no super class
369 }
370 }
371 protected void writeInterfaces() throws IOException {
372 KlassArray interfaces = klass.getLocalInterfaces();
373 final int len = interfaces.length();
374 int nb_interfaces = len;
375
376 if (DEBUG) debugMessage("number of interfaces = " + nb_interfaces);
377
378 // write interfaces count
379 dos.writeShort((short) nb_interfaces);
380 for (int i = 0; i < len; i++) {
381 Klass k = interfaces.getAt(i);
382 Short index = classToIndex.get(k.getName().asString());
383 dos.writeShort(index.shortValue());
384 if (DEBUG) debugMessage("\t" + index);
385 }
386 }
387
388 protected void writeFields() throws IOException {
389 final int javaFieldsCount = klass.getJavaFieldsCount();
390
391 // write number of fields
392 dos.writeShort((short) javaFieldsCount);
393
394 if (DEBUG) debugMessage("number of fields = " + javaFieldsCount);
395
396 for (int index = 0; index < javaFieldsCount; index++) {
397 short accessFlags = klass.getFieldAccessFlags(index);
398 dos.writeShort(accessFlags & (short) JVM_RECOGNIZED_FIELD_MODIFIERS);
399
400 int nameIndex = klass.getFieldNameIndex(index);
401 dos.writeShort(nameIndex);
402
403 int signatureIndex = klass.getFieldSignatureIndex(index);
404 dos.writeShort(signatureIndex);
405 if (DEBUG) debugMessage("\tfield name = " + nameIndex + ", signature = " + signatureIndex);
406
407 short fieldAttributeCount = 0;
408 boolean hasSyn = hasSyntheticAttribute(accessFlags);
409 if (hasSyn)
410 fieldAttributeCount++;
411
412 int initvalIndex = klass.getFieldInitialValueIndex(index);
413 if (initvalIndex != 0)
414 fieldAttributeCount++;
415
416 int genSigIndex = klass.getFieldGenericSignatureIndex(index);
417 if (genSigIndex != 0)
418 fieldAttributeCount++;
419
420 U1Array fieldAnnotations = klass.getFieldAnnotations(index);
421 if (fieldAnnotations != null) {
422 fieldAttributeCount++;
423 }
424
425 U1Array fieldTypeAnnotations = klass.getFieldTypeAnnotations(index);
426 if (fieldTypeAnnotations != null) {
427 fieldAttributeCount++;
428 }
429
430 dos.writeShort(fieldAttributeCount);
431
432 // write synthetic, if applicable
433 if (hasSyn)
434 writeSynthetic();
435
436 if (initvalIndex != 0) {
437 writeIndex(_constantValueIndex);
438 dos.writeInt(2);
439 dos.writeShort(initvalIndex);
440 if (DEBUG) debugMessage("\tfield init value = " + initvalIndex);
441 }
442
443 if (genSigIndex != 0) {
444 writeIndex(_signatureIndex);
445 dos.writeInt(2);
446 dos.writeShort(genSigIndex);
447 if (DEBUG) debugMessage("\tfield generic signature index " + genSigIndex);
448 }
449
450 if (fieldAnnotations != null) {
451 writeAnnotationAttribute("RuntimeVisibleAnnotations", fieldAnnotations);
452 }
453
454 if (fieldTypeAnnotations != null) {
455 writeAnnotationAttribute("RuntimeVisibleTypeAnnotations", fieldTypeAnnotations);
456 }
457 }
458 }
459
460 protected boolean isSynthetic(short accessFlags) {
461 return (accessFlags & (short) JVM_ACC_SYNTHETIC) != 0;
462 }
463
464 protected boolean hasSyntheticAttribute(short accessFlags) {
465 // Check if flags have the attribute and if the constant pool contains an entry for it.
466 return isSynthetic(accessFlags) && _syntheticIndex != 0;
467 }
468
469 protected void writeSynthetic() throws IOException {
470 writeIndex(_syntheticIndex);
471 dos.writeInt(0);
472 }
473
474 protected void writeMethods() throws IOException {
475 MethodArray methods = klass.getMethods();
476 ArrayList<Method> valid_methods = new ArrayList<Method>();
477 for (int i = 0; i < methods.length(); i++) {
478 Method m = methods.at(i);
479 long accessFlags = m.getAccessFlags() & JVM_RECOGNIZED_METHOD_MODIFIERS;
480 // skip overpass methods
481 if (accessFlags == (JVM_ACC_PUBLIC | JVM_ACC_SYNTHETIC | JVM_ACC_BRIDGE)) {
482 continue;
483 }
484 valid_methods.add(m);
485 }
486 final int len = valid_methods.size();
487 // write number of methods
488 dos.writeShort((short) len);
489 if (DEBUG) debugMessage("number of methods = " + len);
490 for (int m = 0; m < len; m++) {
491 writeMethod(valid_methods.get(m));
492 }
493 }
494
495 protected void writeMethod(Method m) throws IOException {
496 long accessFlags = m.getAccessFlags();
497 dos.writeShort((short) (accessFlags & JVM_RECOGNIZED_METHOD_MODIFIERS));
498 dos.writeShort((short) m.getNameIndex());
499 dos.writeShort((short) m.getSignatureIndex());
500 if (DEBUG) debugMessage("\tmethod name = " + m.getNameIndex() + ", signature = "
501 + m.getSignatureIndex());
502
503 final boolean isNative = ((accessFlags & JVM_ACC_NATIVE) != 0);
504 final boolean isAbstract = ((accessFlags & JVM_ACC_ABSTRACT) != 0);
505
506 short methodAttributeCount = 0;
507
508 final boolean hasSyn = hasSyntheticAttribute((short)accessFlags);
509 if (hasSyn)
510 methodAttributeCount++;
511
512 final boolean hasCheckedExceptions = m.hasCheckedExceptions();
513 if (hasCheckedExceptions)
514 methodAttributeCount++;
515
516 final boolean isCodeAvailable = (!isNative) && (!isAbstract);
517 if (isCodeAvailable)
518 methodAttributeCount++;
519
520 final boolean isGeneric = (m.getGenericSignature() != null);
521 if (isGeneric)
522 methodAttributeCount++;
523
524 final U1Array annotations = m.getAnnotations();
525 if (annotations != null) {
526 methodAttributeCount++;
527 }
528
529 final U1Array parameterAnnotations = m.getParameterAnnotations();
530 if (parameterAnnotations != null) {
531 methodAttributeCount++;
532 }
533
534 final U1Array typeAnnotations = m.getTypeAnnotations();
535 if (typeAnnotations != null) {
536 methodAttributeCount++;
537 }
538
539 final U1Array annotationDefault = m.getAnnotationDefault();
540 if (annotationDefault != null) {
541 methodAttributeCount++;
542 }
543
544 dos.writeShort(methodAttributeCount);
545 if (DEBUG) debugMessage("\tmethod attribute count = " + methodAttributeCount);
546
547 if (hasSyn) {
548 if (DEBUG) debugMessage("\tmethod is synthetic");
549 writeSynthetic();
550 }
551
552 if (isCodeAvailable) {
553 byte[] code = m.getByteCode();
554 short codeAttrCount = 0;
555 int codeSize = 2 /* max_stack */ +
556 2 /* max_locals */ +
557 4 /* code_length */ +
558 code.length /* code */ +
559 2 /* exp. table len. */ +
560 2 /* code attr. count */;
561
562 boolean hasExceptionTable = m.hasExceptionTable();
563 ExceptionTableElement[] exceptionTable = null;
564 int exceptionTableLen = 0;
565 if (hasExceptionTable) {
566 exceptionTable = m.getExceptionTable();
567 exceptionTableLen = exceptionTable.length;
568 if (DEBUG) debugMessage("\tmethod has exception table");
569 codeSize += exceptionTableLen /* exception table is 4-tuple array */
570 * (2 /* start_pc */ +
571 2 /* end_pc */ +
572 2 /* handler_pc */ +
573 2 /* catch_type */);
574 }
575
576 boolean hasStackMapTable = m.hasStackMapTable();
577 U1Array stackMapData = null;
578 int stackMapAttrLen = 0;
579
580 if (hasStackMapTable) {
581 if (DEBUG) debugMessage("\tmethod has stack map table");
582 stackMapData = m.getStackMapData();
583 if (DEBUG) debugMessage("\t\tstack map table length = " + stackMapData.length());
584
585 stackMapAttrLen = stackMapData.length();
586
587 codeSize += 2 /* stack map table attr index */ +
588 4 /* stack map table attr length */ +
589 stackMapAttrLen;
590
591 if (DEBUG) debugMessage("\t\tstack map table attr size = " +
592 stackMapAttrLen);
593
594 codeAttrCount++;
595 }
596
597 boolean hasLineNumberTable = m.hasLineNumberTable();
598 LineNumberTableElement[] lineNumberTable = null;
599 int lineNumberAttrLen = 0;
600
601 if (hasLineNumberTable) {
602 if (DEBUG) debugMessage("\tmethod has line number table");
603 lineNumberTable = m.getLineNumberTable();
604 if (DEBUG) debugMessage("\t\tline table length = " + lineNumberTable.length);
605
606 lineNumberAttrLen = 2 /* line number table length */ +
607 lineNumberTable.length * (2 /* start_pc */ + 2 /* line_number */);
608
609 codeSize += 2 /* line number table attr index */ +
610 4 /* line number table attr length */ +
611 lineNumberAttrLen;
612
613 if (DEBUG) debugMessage("\t\tline number table attr size = " +
614 lineNumberAttrLen);
615
616 codeAttrCount++;
617 }
618
619 boolean hasLocalVariableTable = m.hasLocalVariableTable();
620 LocalVariableTableElement[] localVariableTable = null;
621 int localVarAttrLen = 0;
622
623 if (hasLocalVariableTable) {
624 if (DEBUG) debugMessage("\tmethod has local variable table");
625 localVariableTable = m.getLocalVariableTable();
626 if (DEBUG) debugMessage("\t\tlocal variable table length = "
627 + localVariableTable.length);
628 localVarAttrLen =
629 2 /* local variable table length */ +
630 localVariableTable.length * ( 2 /* start_pc */ +
631 2 /* length */ +
632 2 /* name_index */ +
633 2 /* signature_index */ +
634 2 /* variable index */ );
635
636 if (DEBUG) debugMessage("\t\tlocal variable attr size = " +
637 localVarAttrLen);
638
639 codeSize += 2 /* local variable table attr index */ +
640 4 /* local variable table attr length */ +
641 localVarAttrLen;
642
643 codeAttrCount++;
644 }
645
646 // fix ConstantPoolCache indices to ConstantPool indices.
647 rewriteByteCode(m, code);
648
649 // start writing Code
650
651 writeIndex(_codeIndex);
652
653 dos.writeInt(codeSize);
654 if (DEBUG) debugMessage("\tcode attribute length = " + codeSize);
655
656 dos.writeShort((short) m.getMaxStack());
657 if (DEBUG) debugMessage("\tmax stack = " + m.getMaxStack());
658
659 dos.writeShort((short) m.getMaxLocals());
660 if (DEBUG) debugMessage("\tmax locals = " + m.getMaxLocals());
661
662 dos.writeInt(code.length);
663 if (DEBUG) debugMessage("\tcode size = " + code.length);
664
665 dos.write(code);
666
667 // write exception table size
668 dos.writeShort((short) exceptionTableLen);
669 if (DEBUG) debugMessage("\texception table length = " + exceptionTableLen);
670
671 if (exceptionTableLen != 0) {
672 for (int e = 0; e < exceptionTableLen; e++) {
673 dos.writeShort((short) exceptionTable[e].getStartPC());
674 dos.writeShort((short) exceptionTable[e].getEndPC());
675 dos.writeShort((short) exceptionTable[e].getHandlerPC());
676 dos.writeShort((short) exceptionTable[e].getCatchTypeIndex());
677 }
678 }
679
680 dos.writeShort(codeAttrCount);
681 if (DEBUG) debugMessage("\tcode attribute count = " + codeAttrCount);
682
683 // write StackMapTable, if available
684 if (hasStackMapTable) {
685 writeIndex(_stackMapTableIndex);
686 dos.writeInt(stackMapAttrLen);
687 // We write bytes directly as stackMapData is
688 // raw data (#entries + entries)
689 for (int i = 0; i < stackMapData.length(); i++) {
690 dos.writeByte(stackMapData.at(i));
691 }
692 }
693
694 // write LineNumberTable, if available.
695 if (hasLineNumberTable) {
696 writeIndex(_lineNumberTableIndex);
697 dos.writeInt(lineNumberAttrLen);
698 dos.writeShort((short) lineNumberTable.length);
699 for (int l = 0; l < lineNumberTable.length; l++) {
700 dos.writeShort((short) lineNumberTable[l].getStartBCI());
701 dos.writeShort((short) lineNumberTable[l].getLineNumber());
702 }
703 }
704
705 // write LocalVariableTable, if available.
706 if (hasLocalVariableTable) {
707 writeIndex(_localVariableTableIndex);
708 dos.writeInt(localVarAttrLen);
709 dos.writeShort((short) localVariableTable.length);
710 for (int l = 0; l < localVariableTable.length; l++) {
711 dos.writeShort((short) localVariableTable[l].getStartBCI());
712 dos.writeShort((short) localVariableTable[l].getLength());
713 dos.writeShort((short) localVariableTable[l].getNameCPIndex());
714 dos.writeShort((short) localVariableTable[l].getDescriptorCPIndex());
715 dos.writeShort((short) localVariableTable[l].getSlot());
716 }
717 }
718 }
719
720 if (hasCheckedExceptions) {
721 CheckedExceptionElement[] exceptions = m.getCheckedExceptions();
722 writeIndex(_exceptionsIndex);
723
724 int attrSize = 2 /* number_of_exceptions */ +
725 exceptions.length * 2 /* exception_index */;
726 dos.writeInt(attrSize);
727 dos.writeShort(exceptions.length);
728 if (DEBUG) debugMessage("\tmethod has " + exceptions.length
729 + " checked exception(s)");
730 for (int e = 0; e < exceptions.length; e++) {
731 short cpIndex = (short) exceptions[e].getClassCPIndex();
732 dos.writeShort(cpIndex);
733 }
734 }
735
736 if (isGeneric) {
737 writeGenericSignature(m.getGenericSignature().asString());
738 }
739
740 if (annotationDefault != null) {
741 writeAnnotationAttribute("AnnotationDefault", annotationDefault);
742 }
743
744 if (annotations != null) {
745 writeAnnotationAttribute("RuntimeVisibleAnnotations", annotations);
746 }
747
748 if (parameterAnnotations != null) {
749 writeAnnotationAttribute("RuntimeVisibleParameterAnnotations", parameterAnnotations);
750 }
751
752 if (typeAnnotations != null) {
753 writeAnnotationAttribute("RuntimeVisibleTypeAnnotations", typeAnnotations);
754 }
755 }
756
757 protected void rewriteByteCode(Method m, byte[] code) {
758 ByteCodeRewriter r = new ByteCodeRewriter(m, cpool, code);
759 r.rewrite();
760 }
761
762 protected void writeGenericSignature(String signature) throws IOException {
763 writeIndex(_signatureIndex);
764 if (DEBUG) debugMessage("signature attribute = " + _signatureIndex);
765 dos.writeInt(2);
766 Short index = utf8ToIndex.get(signature);
767 dos.writeShort(index.shortValue());
768 if (DEBUG) debugMessage("generic signature = " + index);
769 }
770
771 protected void writeClassAttributes() throws IOException {
772 final long flags = klass.getAccessFlags();
773 final boolean hasSyn = hasSyntheticAttribute((short) flags);
774
775 // check for source file
776 short classAttributeCount = 0;
777
778 if (hasSyn)
779 classAttributeCount++;
780
781 Symbol sourceFileName = klass.getSourceFileName();
782 if (sourceFileName != null)
783 classAttributeCount++;
784
785 Symbol genericSignature = klass.getGenericSignature();
786 if (genericSignature != null)
787 classAttributeCount++;
788
789 U2Array innerClasses = klass.getInnerClasses();
790 final int numInnerClasses = innerClasses.length() / 4;
791 if (numInnerClasses != 0)
792 classAttributeCount++;
793
794 short nestHost = klass.getNestHostIndex();
795 if (nestHost != 0) {
796 classAttributeCount++;
797 }
798
799 U2Array nestMembers = klass.getNestMembers();
800 final int numNestMembers = nestMembers.length();
801 if (numNestMembers != 0) {
802 classAttributeCount++;
803 }
804
805 int bsmCount = klass.getConstants().getBootstrapMethodsCount();
806 if (bsmCount != 0) {
807 classAttributeCount++;
808 }
809
810 U1Array classAnnotations = klass.getClassAnnotations();
811 if (classAnnotations != null) {
812 classAttributeCount++;
813 }
814
815 U1Array classTypeAnnotations = klass.getClassTypeAnnotations();
816 if (classTypeAnnotations != null) {
817 classAttributeCount++;
818 }
819
820 dos.writeShort(classAttributeCount);
821 if (DEBUG) debugMessage("class attribute count = " + classAttributeCount);
822
823 if (hasSyn)
824 writeSynthetic();
825
826 // write SourceFile, if any
827 if (sourceFileName != null) {
828 writeIndex(_sourceFileIndex);
829 if (DEBUG) debugMessage("source file attribute = " + _sourceFileIndex);
830 dos.writeInt(2);
831 Short index = utf8ToIndex.get(sourceFileName.asString());
832 dos.writeShort(index.shortValue());
833 if (DEBUG) debugMessage("source file name = " + index);
834 }
835
836 // write Signature, if any
837 if (genericSignature != null) {
838 writeGenericSignature(genericSignature.asString());
839 }
840
841 // write inner classes, if any
842 if (numInnerClasses != 0) {
843 writeIndex(_innerClassesIndex);
844 final int innerAttrLen = 2 /* number_of_inner_classes */ +
845 numInnerClasses * (
846 2 /* inner_class_info_index */ +
847 2 /* outer_class_info_index */ +
848 2 /* inner_class_name_index */ +
849 2 /* inner_class_access_flags */);
850 dos.writeInt(innerAttrLen);
851
852 dos.writeShort(numInnerClasses);
853 if (DEBUG) debugMessage("class has " + numInnerClasses + " inner class entries");
854
855 for (int index = 0; index < numInnerClasses * 4; index++) {
856 dos.writeShort(innerClasses.at(index));
857 }
858 }
859
860 if (nestHost != 0) {
861 writeIndex(_nestHostIndex);
862 final int nestHostAttrLen = 2;
863 dos.writeInt(nestHostAttrLen);
864 dos.writeShort(nestHost);
865 }
866
867 if (numNestMembers != 0) {
868 writeIndex(_nestMembersIndex);
869 final int nestMembersAttrLen = 2 + numNestMembers * 2;
870 dos.writeInt(nestMembersAttrLen);
871 dos.writeShort(numNestMembers);
872 for (int index = 0; index < numNestMembers; index++) {
873 dos.writeShort(nestMembers.at(index));
874 }
875 }
876
877 // write bootstrap method attribute, if any
878 if (bsmCount != 0) {
879 ConstantPool cpool = klass.getConstants();
880 writeIndex(_bootstrapMethodsIndex);
881 if (DEBUG) debugMessage("bootstrap methods attribute = " + _bootstrapMethodsIndex);
882 int attrLen = 2; // num_bootstrap_methods
883 for (int index = 0; index < bsmCount; index++) {
884 int bsmArgsCount = cpool.getBootstrapMethodArgsCount(index);
885 attrLen += 2 // bootstrap_method_ref
886 + 2 // num_bootstrap_arguments
887 + bsmArgsCount * 2;
888 }
889 dos.writeInt(attrLen);
890 dos.writeShort(bsmCount);
891 for (int index = 0; index < bsmCount; index++) {
892 short value[] = cpool.getBootstrapMethodAt(index);
893 for (int i = 0; i < value.length; i++) {
894 dos.writeShort(value[i]);
895 }
896 }
897 }
898
899 if (classAnnotations != null) {
900 writeAnnotationAttribute("RuntimeVisibleAnnotations", classAnnotations);
901 }
902
903 if (classTypeAnnotations != null) {
904 writeAnnotationAttribute("RuntimeVisibleTypeAnnotations", classTypeAnnotations);
905 }
906 }
907
908 protected void writeAnnotationAttribute(String annotationName, U1Array annotation) throws IOException {
909 int length = annotation.length();
910 Short annotationNameIndex = utf8ToIndex.get(annotationName);
911 if (Assert.ASSERTS_ENABLED) {
912 Assert.that(annotationNameIndex != null, "should not be null");
913 }
914 writeIndex(annotationNameIndex.shortValue());
915 dos.writeInt(length);
916 for (int index = 0; index < length; index++) {
917 dos.writeByte(annotation.at(index));
918 }
919 }
920 }