View Javadoc
1   /*
2    * Copyright (c) 2005, 2009, 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  /*
27   * This file is available under and governed by the GNU General Public
28   * License version 2 only, as published by the Free Software Foundation.
29   * However, the following notice accompanied the original version of this
30   * file:
31   *
32   * ASM: a very small and fast Java bytecode manipulation framework
33   * Copyright (c) 2000-2007 INRIA, France Telecom
34   * All rights reserved.
35   *
36   * Redistribution and use in source and binary forms, with or without
37   * modification, are permitted provided that the following conditions
38   * are met:
39   * 1. Redistributions of source code must retain the above copyright
40   *    notice, this list of conditions and the following disclaimer.
41   * 2. Redistributions in binary form must reproduce the above copyright
42   *    notice, this list of conditions and the following disclaimer in the
43   *    documentation and/or other materials provided with the distribution.
44   * 3. Neither the name of the copyright holders nor the names of its
45   *    contributors may be used to endorse or promote products derived from
46   *    this software without specific prior written permission.
47   *
48   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
49   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
52   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
53   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
54   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
55   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
56   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
57   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
58   * THE POSSIBILITY OF SUCH DAMAGE.
59   */
60  package com.sun.xml.internal.ws.org.objectweb.asm;
61  
62  /**
63   * A {@link ClassVisitor} that generates classes in bytecode form. More
64   * precisely this visitor generates a byte array conforming to the Java class
65   * file format. It can be used alone, to generate a Java class "from scratch",
66   * or with one or more {@link ClassReader ClassReader} and adapter class visitor
67   * to generate a modified class from one or more existing Java classes.
68   *
69   * @author Eric Bruneton
70   */
71  public class ClassWriter implements ClassVisitor {
72  
73      /**
74       * Flag to automatically compute the maximum stack size and the maximum
75       * number of local variables of methods. If this flag is set, then the
76       * arguments of the {@link MethodVisitor#visitMaxs visitMaxs} method of the
77       * {@link MethodVisitor} returned by the {@link #visitMethod visitMethod}
78       * method will be ignored, and computed automatically from the signature and
79       * the bytecode of each method.
80       *
81       * @see #ClassWriter(int)
82       */
83      public static final int COMPUTE_MAXS = 1;
84  
85      /**
86       * Flag to automatically compute the stack map frames of methods from
87       * scratch. If this flag is set, then the calls to the
88       * {@link MethodVisitor#visitFrame} method are ignored, and the stack map
89       * frames are recomputed from the methods bytecode. The arguments of the
90       * {@link MethodVisitor#visitMaxs visitMaxs} method are also ignored and
91       * recomputed from the bytecode. In other words, computeFrames implies
92       * computeMaxs.
93       *
94       * @see #ClassWriter(int)
95       */
96      public static final int COMPUTE_FRAMES = 2;
97  
98      /**
99       * The type of instructions without any argument.
100      */
101     static final int NOARG_INSN = 0;
102 
103     /**
104      * The type of instructions with an signed byte argument.
105      */
106     static final int SBYTE_INSN = 1;
107 
108     /**
109      * The type of instructions with an signed short argument.
110      */
111     static final int SHORT_INSN = 2;
112 
113     /**
114      * The type of instructions with a local variable index argument.
115      */
116     static final int VAR_INSN = 3;
117 
118     /**
119      * The type of instructions with an implicit local variable index argument.
120      */
121     static final int IMPLVAR_INSN = 4;
122 
123     /**
124      * The type of instructions with a type descriptor argument.
125      */
126     static final int TYPE_INSN = 5;
127 
128     /**
129      * The type of field and method invocations instructions.
130      */
131     static final int FIELDORMETH_INSN = 6;
132 
133     /**
134      * The type of the INVOKEINTERFACE instruction.
135      */
136     static final int ITFMETH_INSN = 7;
137 
138     /**
139      * The type of instructions with a 2 bytes bytecode offset label.
140      */
141     static final int LABEL_INSN = 8;
142 
143     /**
144      * The type of instructions with a 4 bytes bytecode offset label.
145      */
146     static final int LABELW_INSN = 9;
147 
148     /**
149      * The type of the LDC instruction.
150      */
151     static final int LDC_INSN = 10;
152 
153     /**
154      * The type of the LDC_W and LDC2_W instructions.
155      */
156     static final int LDCW_INSN = 11;
157 
158     /**
159      * The type of the IINC instruction.
160      */
161     static final int IINC_INSN = 12;
162 
163     /**
164      * The type of the TABLESWITCH instruction.
165      */
166     static final int TABL_INSN = 13;
167 
168     /**
169      * The type of the LOOKUPSWITCH instruction.
170      */
171     static final int LOOK_INSN = 14;
172 
173     /**
174      * The type of the MULTIANEWARRAY instruction.
175      */
176     static final int MANA_INSN = 15;
177 
178     /**
179      * The type of the WIDE instruction.
180      */
181     static final int WIDE_INSN = 16;
182 
183     /**
184      * The instruction types of all JVM opcodes.
185      */
186     static final byte[] TYPE;
187 
188     /**
189      * The type of CONSTANT_Class constant pool items.
190      */
191     static final int CLASS = 7;
192 
193     /**
194      * The type of CONSTANT_Fieldref constant pool items.
195      */
196     static final int FIELD = 9;
197 
198     /**
199      * The type of CONSTANT_Methodref constant pool items.
200      */
201     static final int METH = 10;
202 
203     /**
204      * The type of CONSTANT_InterfaceMethodref constant pool items.
205      */
206     static final int IMETH = 11;
207 
208     /**
209      * The type of CONSTANT_String constant pool items.
210      */
211     static final int STR = 8;
212 
213     /**
214      * The type of CONSTANT_Integer constant pool items.
215      */
216     static final int INT = 3;
217 
218     /**
219      * The type of CONSTANT_Float constant pool items.
220      */
221     static final int FLOAT = 4;
222 
223     /**
224      * The type of CONSTANT_Long constant pool items.
225      */
226     static final int LONG = 5;
227 
228     /**
229      * The type of CONSTANT_Double constant pool items.
230      */
231     static final int DOUBLE = 6;
232 
233     /**
234      * The type of CONSTANT_NameAndType constant pool items.
235      */
236     static final int NAME_TYPE = 12;
237 
238     /**
239      * The type of CONSTANT_Utf8 constant pool items.
240      */
241     static final int UTF8 = 1;
242 
243     /**
244      * Normal type Item stored in the ClassWriter {@link ClassWriter#typeTable},
245      * instead of the constant pool, in order to avoid clashes with normal
246      * constant pool items in the ClassWriter constant pool's hash table.
247      */
248     static final int TYPE_NORMAL = 13;
249 
250     /**
251      * Uninitialized type Item stored in the ClassWriter
252      * {@link ClassWriter#typeTable}, instead of the constant pool, in order to
253      * avoid clashes with normal constant pool items in the ClassWriter constant
254      * pool's hash table.
255      */
256     static final int TYPE_UNINIT = 14;
257 
258     /**
259      * Merged type Item stored in the ClassWriter {@link ClassWriter#typeTable},
260      * instead of the constant pool, in order to avoid clashes with normal
261      * constant pool items in the ClassWriter constant pool's hash table.
262      */
263     static final int TYPE_MERGED = 15;
264 
265     /**
266      * The class reader from which this class writer was constructed, if any.
267      */
268     ClassReader cr;
269 
270     /**
271      * Minor and major version numbers of the class to be generated.
272      */
273     int version;
274 
275     /**
276      * Index of the next item to be added in the constant pool.
277      */
278     int index;
279 
280     /**
281      * The constant pool of this class.
282      */
283     final ByteVector pool;
284 
285     /**
286      * The constant pool's hash table data.
287      */
288     Item[] items;
289 
290     /**
291      * The threshold of the constant pool's hash table.
292      */
293     int threshold;
294 
295     /**
296      * A reusable key used to look for items in the {@link #items} hash table.
297      */
298     final Item key;
299 
300     /**
301      * A reusable key used to look for items in the {@link #items} hash table.
302      */
303     final Item key2;
304 
305     /**
306      * A reusable key used to look for items in the {@link #items} hash table.
307      */
308     final Item key3;
309 
310     /**
311      * A type table used to temporarily store internal names that will not
312      * necessarily be stored in the constant pool. This type table is used by
313      * the control flow and data flow analysis algorithm used to compute stack
314      * map frames from scratch. This array associates to each index <tt>i</tt>
315      * the Item whose index is <tt>i</tt>. All Item objects stored in this
316      * array are also stored in the {@link #items} hash table. These two arrays
317      * allow to retrieve an Item from its index or, conversely, to get the index
318      * of an Item from its value. Each Item stores an internal name in its
319      * {@link Item#strVal1} field.
320      */
321     Item[] typeTable;
322 
323     /**
324      * Number of elements in the {@link #typeTable} array.
325      */
326     private short typeCount;
327 
328     /**
329      * The access flags of this class.
330      */
331     private int access;
332 
333     /**
334      * The constant pool item that contains the internal name of this class.
335      */
336     private int name;
337 
338     /**
339      * The internal name of this class.
340      */
341     String thisName;
342 
343     /**
344      * The constant pool item that contains the signature of this class.
345      */
346     private int signature;
347 
348     /**
349      * The constant pool item that contains the internal name of the super class
350      * of this class.
351      */
352     private int superName;
353 
354     /**
355      * Number of interfaces implemented or extended by this class or interface.
356      */
357     private int interfaceCount;
358 
359     /**
360      * The interfaces implemented or extended by this class or interface. More
361      * precisely, this array contains the indexes of the constant pool items
362      * that contain the internal names of these interfaces.
363      */
364     private int[] interfaces;
365 
366     /**
367      * The index of the constant pool item that contains the name of the source
368      * file from which this class was compiled.
369      */
370     private int sourceFile;
371 
372     /**
373      * The SourceDebug attribute of this class.
374      */
375     private ByteVector sourceDebug;
376 
377     /**
378      * The constant pool item that contains the name of the enclosing class of
379      * this class.
380      */
381     private int enclosingMethodOwner;
382 
383     /**
384      * The constant pool item that contains the name and descriptor of the
385      * enclosing method of this class.
386      */
387     private int enclosingMethod;
388 
389     /**
390      * The runtime visible annotations of this class.
391      */
392     private AnnotationWriter anns;
393 
394     /**
395      * The runtime invisible annotations of this class.
396      */
397     private AnnotationWriter ianns;
398 
399     /**
400      * The non standard attributes of this class.
401      */
402     private Attribute attrs;
403 
404     /**
405      * The number of entries in the InnerClasses attribute.
406      */
407     private int innerClassesCount;
408 
409     /**
410      * The InnerClasses attribute.
411      */
412     private ByteVector innerClasses;
413 
414     /**
415      * The fields of this class. These fields are stored in a linked list of
416      * {@link FieldWriter} objects, linked to each other by their
417      * {@link FieldWriter#next} field. This field stores the first element of
418      * this list.
419      */
420     FieldWriter firstField;
421 
422     /**
423      * The fields of this class. These fields are stored in a linked list of
424      * {@link FieldWriter} objects, linked to each other by their
425      * {@link FieldWriter#next} field. This field stores the last element of
426      * this list.
427      */
428     FieldWriter lastField;
429 
430     /**
431      * The methods of this class. These methods are stored in a linked list of
432      * {@link MethodWriter} objects, linked to each other by their
433      * {@link MethodWriter#next} field. This field stores the first element of
434      * this list.
435      */
436     MethodWriter firstMethod;
437 
438     /**
439      * The methods of this class. These methods are stored in a linked list of
440      * {@link MethodWriter} objects, linked to each other by their
441      * {@link MethodWriter#next} field. This field stores the last element of
442      * this list.
443      */
444     MethodWriter lastMethod;
445 
446     /**
447      * <tt>true</tt> if the maximum stack size and number of local variables
448      * must be automatically computed.
449      */
450     private final boolean computeMaxs;
451 
452     /**
453      * <tt>true</tt> if the stack map frames must be recomputed from scratch.
454      */
455     private final boolean computeFrames;
456 
457     /**
458      * <tt>true</tt> if the stack map tables of this class are invalid. The
459      * {@link MethodWriter#resizeInstructions} method cannot transform existing
460      * stack map tables, and so produces potentially invalid classes when it is
461      * executed. In this case the class is reread and rewritten with the
462      * {@link #COMPUTE_FRAMES} option (the resizeInstructions method can resize
463      * stack map tables when this option is used).
464      */
465     boolean invalidFrames;
466 
467     // ------------------------------------------------------------------------
468     // Static initializer
469     // ------------------------------------------------------------------------
470 
471     /**
472      * Computes the instruction types of JVM opcodes.
473      */
474     static {
475         int i;
476         byte[] b = new byte[220];
477         String s = "AAAAAAAAAAAAAAAABCKLLDDDDDEEEEEEEEEEEEEEEEEEEEAAAAAAAADD"
478                 + "DDDEEEEEEEEEEEEEEEEEEEEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
479                 + "AAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAIIIIIIIIIIIIIIIIDNOAA"
480                 + "AAAAGGGGGGGHAFBFAAFFAAQPIIJJIIIIIIIIIIIIIIIIII";
481         for (i = 0; i < b.length; ++i) {
482             b[i] = (byte) (s.charAt(i) - 'A');
483         }
484         TYPE = b;
485 
486         // code to generate the above string
487         //
488         // // SBYTE_INSN instructions
489         // b[Constants.NEWARRAY] = SBYTE_INSN;
490         // b[Constants.BIPUSH] = SBYTE_INSN;
491         //
492         // // SHORT_INSN instructions
493         // b[Constants.SIPUSH] = SHORT_INSN;
494         //
495         // // (IMPL)VAR_INSN instructions
496         // b[Constants.RET] = VAR_INSN;
497         // for (i = Constants.ILOAD; i <= Constants.ALOAD; ++i) {
498         // b[i] = VAR_INSN;
499         // }
500         // for (i = Constants.ISTORE; i <= Constants.ASTORE; ++i) {
501         // b[i] = VAR_INSN;
502         // }
503         // for (i = 26; i <= 45; ++i) { // ILOAD_0 to ALOAD_3
504         // b[i] = IMPLVAR_INSN;
505         // }
506         // for (i = 59; i <= 78; ++i) { // ISTORE_0 to ASTORE_3
507         // b[i] = IMPLVAR_INSN;
508         // }
509         //
510         // // TYPE_INSN instructions
511         // b[Constants.NEW] = TYPE_INSN;
512         // b[Constants.ANEWARRAY] = TYPE_INSN;
513         // b[Constants.CHECKCAST] = TYPE_INSN;
514         // b[Constants.INSTANCEOF] = TYPE_INSN;
515         //
516         // // (Set)FIELDORMETH_INSN instructions
517         // for (i = Constants.GETSTATIC; i <= Constants.INVOKESTATIC; ++i) {
518         // b[i] = FIELDORMETH_INSN;
519         // }
520         // b[Constants.INVOKEINTERFACE] = ITFMETH_INSN;
521         //
522         // // LABEL(W)_INSN instructions
523         // for (i = Constants.IFEQ; i <= Constants.JSR; ++i) {
524         // b[i] = LABEL_INSN;
525         // }
526         // b[Constants.IFNULL] = LABEL_INSN;
527         // b[Constants.IFNONNULL] = LABEL_INSN;
528         // b[200] = LABELW_INSN; // GOTO_W
529         // b[201] = LABELW_INSN; // JSR_W
530         // // temporary opcodes used internally by ASM - see Label and
531         // MethodWriter
532         // for (i = 202; i < 220; ++i) {
533         // b[i] = LABEL_INSN;
534         // }
535         //
536         // // LDC(_W) instructions
537         // b[Constants.LDC] = LDC_INSN;
538         // b[19] = LDCW_INSN; // LDC_W
539         // b[20] = LDCW_INSN; // LDC2_W
540         //
541         // // special instructions
542         // b[Constants.IINC] = IINC_INSN;
543         // b[Constants.TABLESWITCH] = TABL_INSN;
544         // b[Constants.LOOKUPSWITCH] = LOOK_INSN;
545         // b[Constants.MULTIANEWARRAY] = MANA_INSN;
546         // b[196] = WIDE_INSN; // WIDE
547         //
548         // for (i = 0; i < b.length; ++i) {
549         // System.err.print((char)('A' + b[i]));
550         // }
551         // System.err.println();
552     }
553 
554     // ------------------------------------------------------------------------
555     // Constructor
556     // ------------------------------------------------------------------------
557 
558     /**
559      * Constructs a new {@link ClassWriter} object.
560      *
561      * @param flags option flags that can be used to modify the default behavior
562      *        of this class. See {@link #COMPUTE_MAXS}, {@link #COMPUTE_FRAMES}.
563      */
564     public ClassWriter(final int flags) {
565         index = 1;
566         pool = new ByteVector();
567         items = new Item[256];
568         threshold = (int) (0.75d * items.length);
569         key = new Item();
570         key2 = new Item();
571         key3 = new Item();
572         this.computeMaxs = (flags & COMPUTE_MAXS) != 0;
573         this.computeFrames = (flags & COMPUTE_FRAMES) != 0;
574     }
575 
576     /**
577      * Constructs a new {@link ClassWriter} object and enables optimizations for
578      * "mostly add" bytecode transformations. These optimizations are the
579      * following:
580      *
581      * <ul> <li>The constant pool from the original class is copied as is in
582      * the new class, which saves time. New constant pool entries will be added
583      * at the end if necessary, but unused constant pool entries <i>won't be
584      * removed</i>.</li> <li>Methods that are not transformed are copied as
585      * is in the new class, directly from the original class bytecode (i.e.
586      * without emitting visit events for all the method instructions), which
587      * saves a <i>lot</i> of time. Untransformed methods are detected by the
588      * fact that the {@link ClassReader} receives {@link MethodVisitor} objects
589      * that come from a {@link ClassWriter} (and not from a custom
590      * {@link ClassAdapter} or any other {@link ClassVisitor} instance).</li>
591      * </ul>
592      *
593      * @param classReader the {@link ClassReader} used to read the original
594      *        class. It will be used to copy the entire constant pool from the
595      *        original class and also to copy other fragments of original
596      *        bytecode where applicable.
597      * @param flags option flags that can be used to modify the default behavior
598      *        of this class. See {@link #COMPUTE_MAXS}, {@link #COMPUTE_FRAMES}.
599      */
600     public ClassWriter(final ClassReader classReader, final int flags) {
601         this(flags);
602         classReader.copyPool(this);
603         this.cr = classReader;
604     }
605 
606     // ------------------------------------------------------------------------
607     // Implementation of the ClassVisitor interface
608     // ------------------------------------------------------------------------
609 
610     public void visit(
611         final int version,
612         final int access,
613         final String name,
614         final String signature,
615         final String superName,
616         final String[] interfaces)
617     {
618         this.version = version;
619         this.access = access;
620         this.name = newClass(name);
621         thisName = name;
622         if (ClassReader.SIGNATURES && signature != null) {
623             this.signature = newUTF8(signature);
624         }
625         this.superName = superName == null ? 0 : newClass(superName);
626         if (interfaces != null && interfaces.length > 0) {
627             interfaceCount = interfaces.length;
628             this.interfaces = new int[interfaceCount];
629             for (int i = 0; i < interfaceCount; ++i) {
630                 this.interfaces[i] = newClass(interfaces[i]);
631             }
632         }
633     }
634 
635     public void visitSource(final String file, final String debug) {
636         if (file != null) {
637             sourceFile = newUTF8(file);
638         }
639         if (debug != null) {
640             sourceDebug = new ByteVector().putUTF8(debug);
641         }
642     }
643 
644     public void visitOuterClass(
645         final String owner,
646         final String name,
647         final String desc)
648     {
649         enclosingMethodOwner = newClass(owner);
650         if (name != null && desc != null) {
651             enclosingMethod = newNameType(name, desc);
652         }
653     }
654 
655     public AnnotationVisitor visitAnnotation(
656         final String desc,
657         final boolean visible)
658     {
659         if (!ClassReader.ANNOTATIONS) {
660             return null;
661         }
662         ByteVector bv = new ByteVector();
663         // write type, and reserve space for values count
664         bv.putShort(newUTF8(desc)).putShort(0);
665         AnnotationWriter aw = new AnnotationWriter(this, true, bv, bv, 2);
666         if (visible) {
667             aw.next = anns;
668             anns = aw;
669         } else {
670             aw.next = ianns;
671             ianns = aw;
672         }
673         return aw;
674     }
675 
676     public void visitAttribute(final Attribute attr) {
677         attr.next = attrs;
678         attrs = attr;
679     }
680 
681     public void visitInnerClass(
682         final String name,
683         final String outerName,
684         final String innerName,
685         final int access)
686     {
687         if (innerClasses == null) {
688             innerClasses = new ByteVector();
689         }
690         ++innerClassesCount;
691         innerClasses.putShort(name == null ? 0 : newClass(name));
692         innerClasses.putShort(outerName == null ? 0 : newClass(outerName));
693         innerClasses.putShort(innerName == null ? 0 : newUTF8(innerName));
694         innerClasses.putShort(access);
695     }
696 
697     public FieldVisitor visitField(
698         final int access,
699         final String name,
700         final String desc,
701         final String signature,
702         final Object value)
703     {
704         return new FieldWriter(this, access, name, desc, signature, value);
705     }
706 
707     public MethodVisitor visitMethod(
708         final int access,
709         final String name,
710         final String desc,
711         final String signature,
712         final String[] exceptions)
713     {
714         return new MethodWriter(this,
715                 access,
716                 name,
717                 desc,
718                 signature,
719                 exceptions,
720                 computeMaxs,
721                 computeFrames);
722     }
723 
724     public void visitEnd() {
725     }
726 
727     // ------------------------------------------------------------------------
728     // Other public methods
729     // ------------------------------------------------------------------------
730 
731     /**
732      * Returns the bytecode of the class that was build with this class writer.
733      *
734      * @return the bytecode of the class that was build with this class writer.
735      */
736     public byte[] toByteArray() {
737         // computes the real size of the bytecode of this class
738         int size = 24 + 2 * interfaceCount;
739         int nbFields = 0;
740         FieldWriter fb = firstField;
741         while (fb != null) {
742             ++nbFields;
743             size += fb.getSize();
744             fb = fb.next;
745         }
746         int nbMethods = 0;
747         MethodWriter mb = firstMethod;
748         while (mb != null) {
749             ++nbMethods;
750             size += mb.getSize();
751             mb = mb.next;
752         }
753         int attributeCount = 0;
754         if (ClassReader.SIGNATURES && signature != 0) {
755             ++attributeCount;
756             size += 8;
757             newUTF8("Signature");
758         }
759         if (sourceFile != 0) {
760             ++attributeCount;
761             size += 8;
762             newUTF8("SourceFile");
763         }
764         if (sourceDebug != null) {
765             ++attributeCount;
766             size += sourceDebug.length + 4;
767             newUTF8("SourceDebugExtension");
768         }
769         if (enclosingMethodOwner != 0) {
770             ++attributeCount;
771             size += 10;
772             newUTF8("EnclosingMethod");
773         }
774         if ((access & Opcodes.ACC_DEPRECATED) != 0) {
775             ++attributeCount;
776             size += 6;
777             newUTF8("Deprecated");
778         }
779         if ((access & Opcodes.ACC_SYNTHETIC) != 0
780                 && (version & 0xffff) < Opcodes.V1_5)
781         {
782             ++attributeCount;
783             size += 6;
784             newUTF8("Synthetic");
785         }
786         if (innerClasses != null) {
787             ++attributeCount;
788             size += 8 + innerClasses.length;
789             newUTF8("InnerClasses");
790         }
791         if (ClassReader.ANNOTATIONS && anns != null) {
792             ++attributeCount;
793             size += 8 + anns.getSize();
794             newUTF8("RuntimeVisibleAnnotations");
795         }
796         if (ClassReader.ANNOTATIONS && ianns != null) {
797             ++attributeCount;
798             size += 8 + ianns.getSize();
799             newUTF8("RuntimeInvisibleAnnotations");
800         }
801         if (attrs != null) {
802             attributeCount += attrs.getCount();
803             size += attrs.getSize(this, null, 0, -1, -1);
804         }
805         size += pool.length;
806         // allocates a byte vector of this size, in order to avoid unnecessary
807         // arraycopy operations in the ByteVector.enlarge() method
808         ByteVector out = new ByteVector(size);
809         out.putInt(0xCAFEBABE).putInt(version);
810         out.putShort(index).putByteArray(pool.data, 0, pool.length);
811         out.putShort(access).putShort(name).putShort(superName);
812         out.putShort(interfaceCount);
813         for (int i = 0; i < interfaceCount; ++i) {
814             out.putShort(interfaces[i]);
815         }
816         out.putShort(nbFields);
817         fb = firstField;
818         while (fb != null) {
819             fb.put(out);
820             fb = fb.next;
821         }
822         out.putShort(nbMethods);
823         mb = firstMethod;
824         while (mb != null) {
825             mb.put(out);
826             mb = mb.next;
827         }
828         out.putShort(attributeCount);
829         if (ClassReader.SIGNATURES && signature != 0) {
830             out.putShort(newUTF8("Signature")).putInt(2).putShort(signature);
831         }
832         if (sourceFile != 0) {
833             out.putShort(newUTF8("SourceFile")).putInt(2).putShort(sourceFile);
834         }
835         if (sourceDebug != null) {
836             int len = sourceDebug.length - 2;
837             out.putShort(newUTF8("SourceDebugExtension")).putInt(len);
838             out.putByteArray(sourceDebug.data, 2, len);
839         }
840         if (enclosingMethodOwner != 0) {
841             out.putShort(newUTF8("EnclosingMethod")).putInt(4);
842             out.putShort(enclosingMethodOwner).putShort(enclosingMethod);
843         }
844         if ((access & Opcodes.ACC_DEPRECATED) != 0) {
845             out.putShort(newUTF8("Deprecated")).putInt(0);
846         }
847         if ((access & Opcodes.ACC_SYNTHETIC) != 0
848                 && (version & 0xffff) < Opcodes.V1_5)
849         {
850             out.putShort(newUTF8("Synthetic")).putInt(0);
851         }
852         if (innerClasses != null) {
853             out.putShort(newUTF8("InnerClasses"));
854             out.putInt(innerClasses.length + 2).putShort(innerClassesCount);
855             out.putByteArray(innerClasses.data, 0, innerClasses.length);
856         }
857         if (ClassReader.ANNOTATIONS && anns != null) {
858             out.putShort(newUTF8("RuntimeVisibleAnnotations"));
859             anns.put(out);
860         }
861         if (ClassReader.ANNOTATIONS && ianns != null) {
862             out.putShort(newUTF8("RuntimeInvisibleAnnotations"));
863             ianns.put(out);
864         }
865         if (attrs != null) {
866             attrs.put(this, null, 0, -1, -1, out);
867         }
868         if (invalidFrames) {
869             ClassWriter cw = new ClassWriter(COMPUTE_FRAMES);
870             new ClassReader(out.data).accept(cw, ClassReader.SKIP_FRAMES);
871             return cw.toByteArray();
872         }
873         return out.data;
874     }
875 
876     // ------------------------------------------------------------------------
877     // Utility methods: constant pool management
878     // ------------------------------------------------------------------------
879 
880     /**
881      * Adds a number or string constant to the constant pool of the class being
882      * build. Does nothing if the constant pool already contains a similar item.
883      *
884      * @param cst the value of the constant to be added to the constant pool.
885      *        This parameter must be an {@link Integer}, a {@link Float}, a
886      *        {@link Long}, a {@link Double}, a {@link String} or a
887      *        {@link Type}.
888      * @return a new or already existing constant item with the given value.
889      */
890     Item newConstItem(final Object cst) {
891         if (cst instanceof Integer) {
892             int val = ((Integer) cst).intValue();
893             return newInteger(val);
894         } else if (cst instanceof Byte) {
895             int val = ((Byte) cst).intValue();
896             return newInteger(val);
897         } else if (cst instanceof Character) {
898             int val = ((Character) cst).charValue();
899             return newInteger(val);
900         } else if (cst instanceof Short) {
901             int val = ((Short) cst).intValue();
902             return newInteger(val);
903         } else if (cst instanceof Boolean) {
904             int val = ((Boolean) cst).booleanValue() ? 1 : 0;
905             return newInteger(val);
906         } else if (cst instanceof Float) {
907             float val = ((Float) cst).floatValue();
908             return newFloat(val);
909         } else if (cst instanceof Long) {
910             long val = ((Long) cst).longValue();
911             return newLong(val);
912         } else if (cst instanceof Double) {
913             double val = ((Double) cst).doubleValue();
914             return newDouble(val);
915         } else if (cst instanceof String) {
916             return newString((String) cst);
917         } else if (cst instanceof Type) {
918             Type t = (Type) cst;
919             return newClassItem(t.getSort() == Type.OBJECT
920                     ? t.getInternalName()
921                     : t.getDescriptor());
922         } else {
923             throw new IllegalArgumentException("value " + cst);
924         }
925     }
926 
927     /**
928      * Adds a number or string constant to the constant pool of the class being
929      * build. Does nothing if the constant pool already contains a similar item.
930      * <i>This method is intended for {@link Attribute} sub classes, and is
931      * normally not needed by class generators or adapters.</i>
932      *
933      * @param cst the value of the constant to be added to the constant pool.
934      *        This parameter must be an {@link Integer}, a {@link Float}, a
935      *        {@link Long}, a {@link Double} or a {@link String}.
936      * @return the index of a new or already existing constant item with the
937      *         given value.
938      */
939     public int newConst(final Object cst) {
940         return newConstItem(cst).index;
941     }
942 
943     /**
944      * Adds an UTF8 string to the constant pool of the class being build. Does
945      * nothing if the constant pool already contains a similar item. <i>This
946      * method is intended for {@link Attribute} sub classes, and is normally not
947      * needed by class generators or adapters.</i>
948      *
949      * @param value the String value.
950      * @return the index of a new or already existing UTF8 item.
951      */
952     public int newUTF8(final String value) {
953         key.set(UTF8, value, null, null);
954         Item result = get(key);
955         if (result == null) {
956             pool.putByte(UTF8).putUTF8(value);
957             result = new Item(index++, key);
958             put(result);
959         }
960         return result.index;
961     }
962 
963     /**
964      * Adds a class reference to the constant pool of the class being build.
965      * Does nothing if the constant pool already contains a similar item.
966      * <i>This method is intended for {@link Attribute} sub classes, and is
967      * normally not needed by class generators or adapters.</i>
968      *
969      * @param value the internal name of the class.
970      * @return a new or already existing class reference item.
971      */
972     Item newClassItem(final String value) {
973         key2.set(CLASS, value, null, null);
974         Item result = get(key2);
975         if (result == null) {
976             pool.put12(CLASS, newUTF8(value));
977             result = new Item(index++, key2);
978             put(result);
979         }
980         return result;
981     }
982 
983     /**
984      * Adds a class reference to the constant pool of the class being build.
985      * Does nothing if the constant pool already contains a similar item.
986      * <i>This method is intended for {@link Attribute} sub classes, and is
987      * normally not needed by class generators or adapters.</i>
988      *
989      * @param value the internal name of the class.
990      * @return the index of a new or already existing class reference item.
991      */
992     public int newClass(final String value) {
993         return newClassItem(value).index;
994     }
995 
996     /**
997      * Adds a field reference to the constant pool of the class being build.
998      * Does nothing if the constant pool already contains a similar item.
999      *
1000      * @param owner the internal name of the field's owner class.
1001      * @param name the field's name.
1002      * @param desc the field's descriptor.
1003      * @return a new or already existing field reference item.
1004      */
1005     Item newFieldItem(final String owner, final String name, final String desc)
1006     {
1007         key3.set(FIELD, owner, name, desc);
1008         Item result = get(key3);
1009         if (result == null) {
1010             put122(FIELD, newClass(owner), newNameType(name, desc));
1011             result = new Item(index++, key3);
1012             put(result);
1013         }
1014         return result;
1015     }
1016 
1017     /**
1018      * Adds a field reference to the constant pool of the class being build.
1019      * Does nothing if the constant pool already contains a similar item.
1020      * <i>This method is intended for {@link Attribute} sub classes, and is
1021      * normally not needed by class generators or adapters.</i>
1022      *
1023      * @param owner the internal name of the field's owner class.
1024      * @param name the field's name.
1025      * @param desc the field's descriptor.
1026      * @return the index of a new or already existing field reference item.
1027      */
1028     public int newField(final String owner, final String name, final String desc)
1029     {
1030         return newFieldItem(owner, name, desc).index;
1031     }
1032 
1033     /**
1034      * Adds a method reference to the constant pool of the class being build.
1035      * Does nothing if the constant pool already contains a similar item.
1036      *
1037      * @param owner the internal name of the method's owner class.
1038      * @param name the method's name.
1039      * @param desc the method's descriptor.
1040      * @param itf <tt>true</tt> if <tt>owner</tt> is an interface.
1041      * @return a new or already existing method reference item.
1042      */
1043     Item newMethodItem(
1044         final String owner,
1045         final String name,
1046         final String desc,
1047         final boolean itf)
1048     {
1049         int type = itf ? IMETH : METH;
1050         key3.set(type, owner, name, desc);
1051         Item result = get(key3);
1052         if (result == null) {
1053             put122(type, newClass(owner), newNameType(name, desc));
1054             result = new Item(index++, key3);
1055             put(result);
1056         }
1057         return result;
1058     }
1059 
1060     /**
1061      * Adds a method reference to the constant pool of the class being build.
1062      * Does nothing if the constant pool already contains a similar item.
1063      * <i>This method is intended for {@link Attribute} sub classes, and is
1064      * normally not needed by class generators or adapters.</i>
1065      *
1066      * @param owner the internal name of the method's owner class.
1067      * @param name the method's name.
1068      * @param desc the method's descriptor.
1069      * @param itf <tt>true</tt> if <tt>owner</tt> is an interface.
1070      * @return the index of a new or already existing method reference item.
1071      */
1072     public int newMethod(
1073         final String owner,
1074         final String name,
1075         final String desc,
1076         final boolean itf)
1077     {
1078         return newMethodItem(owner, name, desc, itf).index;
1079     }
1080 
1081     /**
1082      * Adds an integer to the constant pool of the class being build. Does
1083      * nothing if the constant pool already contains a similar item.
1084      *
1085      * @param value the int value.
1086      * @return a new or already existing int item.
1087      */
1088     Item newInteger(final int value) {
1089         key.set(value);
1090         Item result = get(key);
1091         if (result == null) {
1092             pool.putByte(INT).putInt(value);
1093             result = new Item(index++, key);
1094             put(result);
1095         }
1096         return result;
1097     }
1098 
1099     /**
1100      * Adds a float to the constant pool of the class being build. Does nothing
1101      * if the constant pool already contains a similar item.
1102      *
1103      * @param value the float value.
1104      * @return a new or already existing float item.
1105      */
1106     Item newFloat(final float value) {
1107         key.set(value);
1108         Item result = get(key);
1109         if (result == null) {
1110             pool.putByte(FLOAT).putInt(key.intVal);
1111             result = new Item(index++, key);
1112             put(result);
1113         }
1114         return result;
1115     }
1116 
1117     /**
1118      * Adds a long to the constant pool of the class being build. Does nothing
1119      * if the constant pool already contains a similar item.
1120      *
1121      * @param value the long value.
1122      * @return a new or already existing long item.
1123      */
1124     Item newLong(final long value) {
1125         key.set(value);
1126         Item result = get(key);
1127         if (result == null) {
1128             pool.putByte(LONG).putLong(value);
1129             result = new Item(index, key);
1130             put(result);
1131             index += 2;
1132         }
1133         return result;
1134     }
1135 
1136     /**
1137      * Adds a double to the constant pool of the class being build. Does nothing
1138      * if the constant pool already contains a similar item.
1139      *
1140      * @param value the double value.
1141      * @return a new or already existing double item.
1142      */
1143     Item newDouble(final double value) {
1144         key.set(value);
1145         Item result = get(key);
1146         if (result == null) {
1147             pool.putByte(DOUBLE).putLong(key.longVal);
1148             result = new Item(index, key);
1149             put(result);
1150             index += 2;
1151         }
1152         return result;
1153     }
1154 
1155     /**
1156      * Adds a string to the constant pool of the class being build. Does nothing
1157      * if the constant pool already contains a similar item.
1158      *
1159      * @param value the String value.
1160      * @return a new or already existing string item.
1161      */
1162     private Item newString(final String value) {
1163         key2.set(STR, value, null, null);
1164         Item result = get(key2);
1165         if (result == null) {
1166             pool.put12(STR, newUTF8(value));
1167             result = new Item(index++, key2);
1168             put(result);
1169         }
1170         return result;
1171     }
1172 
1173     /**
1174      * Adds a name and type to the constant pool of the class being build. Does
1175      * nothing if the constant pool already contains a similar item. <i>This
1176      * method is intended for {@link Attribute} sub classes, and is normally not
1177      * needed by class generators or adapters.</i>
1178      *
1179      * @param name a name.
1180      * @param desc a type descriptor.
1181      * @return the index of a new or already existing name and type item.
1182      */
1183     public int newNameType(final String name, final String desc) {
1184         key2.set(NAME_TYPE, name, desc, null);
1185         Item result = get(key2);
1186         if (result == null) {
1187             put122(NAME_TYPE, newUTF8(name), newUTF8(desc));
1188             result = new Item(index++, key2);
1189             put(result);
1190         }
1191         return result.index;
1192     }
1193 
1194     /**
1195      * Adds the given internal name to {@link #typeTable} and returns its index.
1196      * Does nothing if the type table already contains this internal name.
1197      *
1198      * @param type the internal name to be added to the type table.
1199      * @return the index of this internal name in the type table.
1200      */
1201     int addType(final String type) {
1202         key.set(TYPE_NORMAL, type, null, null);
1203         Item result = get(key);
1204         if (result == null) {
1205             result = addType(key);
1206         }
1207         return result.index;
1208     }
1209 
1210     /**
1211      * Adds the given "uninitialized" type to {@link #typeTable} and returns its
1212      * index. This method is used for UNINITIALIZED types, made of an internal
1213      * name and a bytecode offset.
1214      *
1215      * @param type the internal name to be added to the type table.
1216      * @param offset the bytecode offset of the NEW instruction that created
1217      *        this UNINITIALIZED type value.
1218      * @return the index of this internal name in the type table.
1219      */
1220     int addUninitializedType(final String type, final int offset) {
1221         key.type = TYPE_UNINIT;
1222         key.intVal = offset;
1223         key.strVal1 = type;
1224         key.hashCode = 0x7FFFFFFF & (TYPE_UNINIT + type.hashCode() + offset);
1225         Item result = get(key);
1226         if (result == null) {
1227             result = addType(key);
1228         }
1229         return result.index;
1230     }
1231 
1232     /**
1233      * Adds the given Item to {@link #typeTable}.
1234      *
1235      * @param item the value to be added to the type table.
1236      * @return the added Item, which a new Item instance with the same value as
1237      *         the given Item.
1238      */
1239     private Item addType(final Item item) {
1240         ++typeCount;
1241         Item result = new Item(typeCount, key);
1242         put(result);
1243         if (typeTable == null) {
1244             typeTable = new Item[16];
1245         }
1246         if (typeCount == typeTable.length) {
1247             Item[] newTable = new Item[2 * typeTable.length];
1248             System.arraycopy(typeTable, 0, newTable, 0, typeTable.length);
1249             typeTable = newTable;
1250         }
1251         typeTable[typeCount] = result;
1252         return result;
1253     }
1254 
1255     /**
1256      * Returns the index of the common super type of the two given types. This
1257      * method calls {@link #getCommonSuperClass} and caches the result in the
1258      * {@link #items} hash table to speedup future calls with the same
1259      * parameters.
1260      *
1261      * @param type1 index of an internal name in {@link #typeTable}.
1262      * @param type2 index of an internal name in {@link #typeTable}.
1263      * @return the index of the common super type of the two given types.
1264      */
1265     int getMergedType(final int type1, final int type2) {
1266         key2.type = TYPE_MERGED;
1267         key2.longVal = type1 | (((long) type2) << 32);
1268         key2.hashCode = 0x7FFFFFFF & (TYPE_MERGED + type1 + type2);
1269         Item result = get(key2);
1270         if (result == null) {
1271             String t = typeTable[type1].strVal1;
1272             String u = typeTable[type2].strVal1;
1273             key2.intVal = addType(getCommonSuperClass(t, u));
1274             result = new Item((short) 0, key2);
1275             put(result);
1276         }
1277         return result.intVal;
1278     }
1279 
1280     /**
1281      * Returns the common super type of the two given types. The default
1282      * implementation of this method <i>loads<i> the two given classes and uses
1283      * the java.lang.Class methods to find the common super class. It can be
1284      * overridden to compute this common super type in other ways, in particular
1285      * without actually loading any class, or to take into account the class
1286      * that is currently being generated by this ClassWriter, which can of
1287      * course not be loaded since it is under construction.
1288      *
1289      * @param type1 the internal name of a class.
1290      * @param type2 the internal name of another class.
1291      * @return the internal name of the common super class of the two given
1292      *         classes.
1293      */
1294     protected String getCommonSuperClass(final String type1, final String type2)
1295     {
1296         Class c, d;
1297         try {
1298             c = Class.forName(type1.replace('/', '.'));
1299             d = Class.forName(type2.replace('/', '.'));
1300         } catch (Exception e) {
1301             throw new RuntimeException(e.toString());
1302         }
1303         if (c.isAssignableFrom(d)) {
1304             return type1;
1305         }
1306         if (d.isAssignableFrom(c)) {
1307             return type2;
1308         }
1309         if (c.isInterface() || d.isInterface()) {
1310             return "java/lang/Object";
1311         } else {
1312             do {
1313                 c = c.getSuperclass();
1314             } while (!c.isAssignableFrom(d));
1315             return c.getName().replace('.', '/');
1316         }
1317     }
1318 
1319     /**
1320      * Returns the constant pool's hash table item which is equal to the given
1321      * item.
1322      *
1323      * @param key a constant pool item.
1324      * @return the constant pool's hash table item which is equal to the given
1325      *         item, or <tt>null</tt> if there is no such item.
1326      */
1327     private Item get(final Item key) {
1328         Item i = items[key.hashCode % items.length];
1329         while (i != null && !key.isEqualTo(i)) {
1330             i = i.next;
1331         }
1332         return i;
1333     }
1334 
1335     /**
1336      * Puts the given item in the constant pool's hash table. The hash table
1337      * <i>must</i> not already contains this item.
1338      *
1339      * @param i the item to be added to the constant pool's hash table.
1340      */
1341     private void put(final Item i) {
1342         if (index > threshold) {
1343             int ll = items.length;
1344             int nl = ll * 2 + 1;
1345             Item[] newItems = new Item[nl];
1346             for (int l = ll - 1; l >= 0; --l) {
1347                 Item j = items[l];
1348                 while (j != null) {
1349                     int index = j.hashCode % newItems.length;
1350                     Item k = j.next;
1351                     j.next = newItems[index];
1352                     newItems[index] = j;
1353                     j = k;
1354                 }
1355             }
1356             items = newItems;
1357             threshold = (int) (nl * 0.75);
1358         }
1359         int index = i.hashCode % items.length;
1360         i.next = items[index];
1361         items[index] = i;
1362     }
1363 
1364     /**
1365      * Puts one byte and two shorts into the constant pool.
1366      *
1367      * @param b a byte.
1368      * @param s1 a short.
1369      * @param s2 another short.
1370      */
1371     private void put122(final int b, final int s1, final int s2) {
1372         pool.put12(b, s1).putShort(s2);
1373     }
1374 }