History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/reflect/ClassFileAssembler.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/reflect/ClassFileAssembler.java+671−0
@@ -0,0 +1,671 @@
1+/*
2+ * Copyright (c) 2001, 2004, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+
26+package sun.reflect;
27+
28+class ClassFileAssembler implements ClassFileConstants {
29+ private ByteVector vec;
30+ private short cpIdx = 0;
31+
32+ public ClassFileAssembler() {
33+ this(ByteVectorFactory.create());
34+ }
35+
36+ public ClassFileAssembler(ByteVector vec) {
37+ this.vec = vec;
38+ }
39+
40+ public ByteVector getData() {
41+ return vec;
42+ }
43+
44+ /** Length in bytes */
45+ public short getLength() {
46+ return (short) vec.getLength();
47+ }
48+
49+ public void emitMagicAndVersion() {
50+ emitInt(0xCAFEBABE);
51+ emitShort((short) 0);
52+ emitShort((short) 49);
53+ }
54+
55+ public void emitInt(int val) {
56+ emitByte((byte) (val >> 24));
57+ emitByte((byte) ((val >> 16) & 0xFF));
58+ emitByte((byte) ((val >> 8) & 0xFF));
59+ emitByte((byte) (val & 0xFF));
60+ }
61+
62+ public void emitShort(short val) {
63+ emitByte((byte) ((val >> 8) & 0xFF));
64+ emitByte((byte) (val & 0xFF));
65+ }
66+
67+ // Support for labels; package-private
68+ void emitShort(short bci, short val) {
69+ vec.put(bci, (byte) ((val >> 8) & 0xFF));
70+ vec.put(bci + 1, (byte) (val & 0xFF));
71+ }
72+
73+ public void emitByte(byte val) {
74+ vec.add(val);
75+ }
76+
77+ public void append(ClassFileAssembler asm) {
78+ append(asm.vec);
79+ }
80+
81+ public void append(ByteVector vec) {
82+ for (int i = 0; i < vec.getLength(); i++) {
83+ emitByte(vec.get(i));
84+ }
85+ }
86+
87+ /** Keeps track of the current (one-based) constant pool index;
88+ incremented after emitting one of the following constant pool
89+ entries. Can fetch the current constant pool index for use in
90+ later entries. Index points at the last valid constant pool
91+ entry; initially invalid. It is illegal to fetch the constant
92+ pool index before emitting at least one constant pool entry. */
93+ public short cpi() {
94+ if (cpIdx == 0) {
95+ throw new RuntimeException("Illegal use of ClassFileAssembler");
96+ }
97+ return cpIdx;
98+ }
99+
100+ public void emitConstantPoolUTF8(String str) {
101+ // NOTE: can not use str.getBytes("UTF-8") here because of
102+ // bootstrapping issues with the character set converters.
103+ byte[] bytes = UTF8.encode(str);
104+ emitByte(CONSTANT_Utf8);
105+ emitShort((short) bytes.length);
106+ for (int i = 0; i < bytes.length; i++) {
107+ emitByte(bytes[i]);
108+ }
109+ cpIdx++;
110+ }
111+
112+ public void emitConstantPoolClass(short index) {
113+ emitByte(CONSTANT_Class);
114+ emitShort(index);
115+ cpIdx++;
116+ }
117+
118+ public void emitConstantPoolNameAndType(short nameIndex, short typeIndex) {
119+ emitByte(CONSTANT_NameAndType);
120+ emitShort(nameIndex);
121+ emitShort(typeIndex);
122+ cpIdx++;
123+ }
124+
125+ public void emitConstantPoolFieldref
126+ (short classIndex, short nameAndTypeIndex)
127+ {
128+ emitByte(CONSTANT_Fieldref);
129+ emitShort(classIndex);
130+ emitShort(nameAndTypeIndex);
131+ cpIdx++;
132+ }
133+
134+ public void emitConstantPoolMethodref
135+ (short classIndex, short nameAndTypeIndex)
136+ {
137+ emitByte(CONSTANT_Methodref);
138+ emitShort(classIndex);
139+ emitShort(nameAndTypeIndex);
140+ cpIdx++;
141+ }
142+
143+ public void emitConstantPoolInterfaceMethodref
144+ (short classIndex, short nameAndTypeIndex)
145+ {
146+ emitByte(CONSTANT_InterfaceMethodref);
147+ emitShort(classIndex);
148+ emitShort(nameAndTypeIndex);
149+ cpIdx++;
150+ }
151+
152+ public void emitConstantPoolString(short utf8Index) {
153+ emitByte(CONSTANT_String);
154+ emitShort(utf8Index);
155+ cpIdx++;
156+ }
157+
158+ //----------------------------------------------------------------------
159+ // Opcodes. Keeps track of maximum stack and locals. Make a new
160+ // assembler for each piece of assembled code, then append the
161+ // result to the previous assembler's class file.
162+ //
163+
164+ private int stack = 0;
165+ private int maxStack = 0;
166+ private int maxLocals = 0;
167+
168+ private void incStack() {
169+ setStack(stack + 1);
170+ }
171+
172+ private void decStack() {
173+ --stack;
174+ }
175+
176+ public short getMaxStack() {
177+ return (short) maxStack;
178+ }
179+
180+ public short getMaxLocals() {
181+ return (short) maxLocals;
182+ }
183+
184+ /** It's necessary to be able to specify the number of arguments at
185+ the beginning of the method (which translates to the initial
186+ value of max locals) */
187+ public void setMaxLocals(int maxLocals) {
188+ this.maxLocals = maxLocals;
189+ }
190+
191+ /** Needed to do flow control. Returns current stack depth. */
192+ public int getStack() {
193+ return stack;
194+ }
195+
196+ /** Needed to do flow control. */
197+ public void setStack(int value) {
198+ stack = value;
199+ if (stack > maxStack) {
200+ maxStack = stack;
201+ }
202+ }
203+
204+ ///////////////
205+ // Constants //
206+ ///////////////
207+
208+ public void opc_aconst_null() {
209+ emitByte(opc_aconst_null);
210+ incStack();
211+ }
212+
213+ public void opc_sipush(short constant) {
214+ emitByte(opc_sipush);
215+ emitShort(constant);
216+ incStack();
217+ }
218+
219+ public void opc_ldc(byte cpIdx) {
220+ emitByte(opc_ldc);
221+ emitByte(cpIdx);
222+ incStack();
223+ }
224+
225+ /////////////////////////////////////
226+ // Local variable loads and stores //
227+ /////////////////////////////////////
228+
229+ public void opc_iload_0() {
230+ emitByte(opc_iload_0);
231+ if (maxLocals < 1) maxLocals = 1;
232+ incStack();
233+ }
234+
235+ public void opc_iload_1() {
236+ emitByte(opc_iload_1);
237+ if (maxLocals < 2) maxLocals = 2;
238+ incStack();
239+ }
240+
241+ public void opc_iload_2() {
242+ emitByte(opc_iload_2);
243+ if (maxLocals < 3) maxLocals = 3;
244+ incStack();
245+ }
246+
247+ public void opc_iload_3() {
248+ emitByte(opc_iload_3);
249+ if (maxLocals < 4) maxLocals = 4;
250+ incStack();
251+ }
252+
253+ public void opc_lload_0() {
254+ emitByte(opc_lload_0);
255+ if (maxLocals < 2) maxLocals = 2;
256+ incStack();
257+ incStack();
258+ }
259+
260+ public void opc_lload_1() {
261+ emitByte(opc_lload_1);
262+ if (maxLocals < 3) maxLocals = 3;
263+ incStack();
264+ incStack();
265+ }
266+
267+ public void opc_lload_2() {
268+ emitByte(opc_lload_2);
269+ if (maxLocals < 4) maxLocals = 4;
270+ incStack();
271+ incStack();
272+ }
273+
274+ public void opc_lload_3() {
275+ emitByte(opc_lload_3);
276+ if (maxLocals < 5) maxLocals = 5;
277+ incStack();
278+ incStack();
279+ }
280+
281+ public void opc_fload_0() {
282+ emitByte(opc_fload_0);
283+ if (maxLocals < 1) maxLocals = 1;
284+ incStack();
285+ }
286+
287+ public void opc_fload_1() {
288+ emitByte(opc_fload_1);
289+ if (maxLocals < 2) maxLocals = 2;
290+ incStack();
291+ }
292+
293+ public void opc_fload_2() {
294+ emitByte(opc_fload_2);
295+ if (maxLocals < 3) maxLocals = 3;
296+ incStack();
297+ }
298+
299+ public void opc_fload_3() {
300+ emitByte(opc_fload_3);
301+ if (maxLocals < 4) maxLocals = 4;
302+ incStack();
303+ }
304+
305+ public void opc_dload_0() {
306+ emitByte(opc_dload_0);
307+ if (maxLocals < 2) maxLocals = 2;
308+ incStack();
309+ incStack();
310+ }
311+
312+ public void opc_dload_1() {
313+ emitByte(opc_dload_1);
314+ if (maxLocals < 3) maxLocals = 3;
315+ incStack();
316+ incStack();
317+ }
318+
319+ public void opc_dload_2() {
320+ emitByte(opc_dload_2);
321+ if (maxLocals < 4) maxLocals = 4;
322+ incStack();
323+ incStack();
324+ }
325+
326+ public void opc_dload_3() {
327+ emitByte(opc_dload_3);
328+ if (maxLocals < 5) maxLocals = 5;
329+ incStack();
330+ incStack();
331+ }
332+
333+ public void opc_aload_0() {
334+ emitByte(opc_aload_0);
335+ if (maxLocals < 1) maxLocals = 1;
336+ incStack();
337+ }
338+
339+ public void opc_aload_1() {
340+ emitByte(opc_aload_1);
341+ if (maxLocals < 2) maxLocals = 2;
342+ incStack();
343+ }
344+
345+ public void opc_aload_2() {
346+ emitByte(opc_aload_2);
347+ if (maxLocals < 3) maxLocals = 3;
348+ incStack();
349+ }
350+
351+ public void opc_aload_3() {
352+ emitByte(opc_aload_3);
353+ if (maxLocals < 4) maxLocals = 4;
354+ incStack();
355+ }
356+
357+ public void opc_aaload() {
358+ emitByte(opc_aaload);
359+ decStack();
360+ }
361+
362+ public void opc_astore_0() {
363+ emitByte(opc_astore_0);
364+ if (maxLocals < 1) maxLocals = 1;
365+ decStack();
366+ }
367+
368+ public void opc_astore_1() {
369+ emitByte(opc_astore_1);
370+ if (maxLocals < 2) maxLocals = 2;
371+ decStack();
372+ }
373+
374+ public void opc_astore_2() {
375+ emitByte(opc_astore_2);
376+ if (maxLocals < 3) maxLocals = 3;
377+ decStack();
378+ }
379+
380+ public void opc_astore_3() {
381+ emitByte(opc_astore_3);
382+ if (maxLocals < 4) maxLocals = 4;
383+ decStack();
384+ }
385+
386+ ////////////////////////
387+ // Stack manipulation //
388+ ////////////////////////
389+
390+ public void opc_pop() {
391+ emitByte(opc_pop);
392+ decStack();
393+ }
394+
395+ public void opc_dup() {
396+ emitByte(opc_dup);
397+ incStack();
398+ }
399+
400+ public void opc_dup_x1() {
401+ emitByte(opc_dup_x1);
402+ incStack();
403+ }
404+
405+ public void opc_swap() {
406+ emitByte(opc_swap);
407+ }
408+
409+ ///////////////////////////////
410+ // Widening conversions only //
411+ ///////////////////////////////
412+
413+ public void opc_i2l() {
414+ emitByte(opc_i2l);
415+ }
416+
417+ public void opc_i2f() {
418+ emitByte(opc_i2f);
419+ }
420+
421+ public void opc_i2d() {
422+ emitByte(opc_i2d);
423+ }
424+
425+ public void opc_l2f() {
426+ emitByte(opc_l2f);
427+ }
428+
429+ public void opc_l2d() {
430+ emitByte(opc_l2d);
431+ }
432+
433+ public void opc_f2d() {
434+ emitByte(opc_f2d);
435+ }
436+
437+ //////////////////
438+ // Control flow //
439+ //////////////////
440+
441+ public void opc_ifeq(short bciOffset) {
442+ emitByte(opc_ifeq);
443+ emitShort(bciOffset);
444+ decStack();
445+ }
446+
447+ /** Control flow with forward-reference BCI. Stack assumes
448+ straight-through control flow. */
449+ public void opc_ifeq(Label l) {
450+ short instrBCI = getLength();
451+ emitByte(opc_ifeq);
452+ l.add(this, instrBCI, getLength(), getStack() - 1);
453+ emitShort((short) -1); // Must be patched later
454+ }
455+
456+ public void opc_if_icmpeq(short bciOffset) {
457+ emitByte(opc_if_icmpeq);
458+ emitShort(bciOffset);
459+ setStack(getStack() - 2);
460+ }
461+
462+ /** Control flow with forward-reference BCI. Stack assumes straight
463+ control flow. */
464+ public void opc_if_icmpeq(Label l) {
465+ short instrBCI = getLength();
466+ emitByte(opc_if_icmpeq);
467+ l.add(this, instrBCI, getLength(), getStack() - 2);
468+ emitShort((short) -1); // Must be patched later
469+ }
470+
471+ public void opc_goto(short bciOffset) {
472+ emitByte(opc_goto);
473+ emitShort(bciOffset);
474+ }
475+
476+ /** Control flow with forward-reference BCI. Stack assumes straight
477+ control flow. */
478+ public void opc_goto(Label l) {
479+ short instrBCI = getLength();
480+ emitByte(opc_goto);
481+ l.add(this, instrBCI, getLength(), getStack());
482+ emitShort((short) -1); // Must be patched later
483+ }
484+
485+ public void opc_ifnull(short bciOffset) {
486+ emitByte(opc_ifnull);
487+ emitShort(bciOffset);
488+ decStack();
489+ }
490+
491+ /** Control flow with forward-reference BCI. Stack assumes straight
492+ control flow. */
493+ public void opc_ifnull(Label l) {
494+ short instrBCI = getLength();
495+ emitByte(opc_ifnull);
496+ l.add(this, instrBCI, getLength(), getStack() - 1);
497+ emitShort((short) -1); // Must be patched later
498+ decStack();
499+ }
500+
501+ public void opc_ifnonnull(short bciOffset) {
502+ emitByte(opc_ifnonnull);
503+ emitShort(bciOffset);
504+ decStack();
505+ }
506+
507+ /** Control flow with forward-reference BCI. Stack assumes straight
508+ control flow. */
509+ public void opc_ifnonnull(Label l) {
510+ short instrBCI = getLength();
511+ emitByte(opc_ifnonnull);
512+ l.add(this, instrBCI, getLength(), getStack() - 1);
513+ emitShort((short) -1); // Must be patched later
514+ decStack();
515+ }
516+
517+ /////////////////////////
518+ // Return instructions //
519+ /////////////////////////
520+
521+ public void opc_ireturn() {
522+ emitByte(opc_ireturn);
523+ setStack(0);
524+ }
525+
526+ public void opc_lreturn() {
527+ emitByte(opc_lreturn);
528+ setStack(0);
529+ }
530+
531+ public void opc_freturn() {
532+ emitByte(opc_freturn);
533+ setStack(0);
534+ }
535+
536+ public void opc_dreturn() {
537+ emitByte(opc_dreturn);
538+ setStack(0);
539+ }
540+
541+ public void opc_areturn() {
542+ emitByte(opc_areturn);
543+ setStack(0);
544+ }
545+
546+ public void opc_return() {
547+ emitByte(opc_return);
548+ setStack(0);
549+ }
550+
551+ //////////////////////
552+ // Field operations //
553+ //////////////////////
554+
555+ public void opc_getstatic(short fieldIndex, int fieldSizeInStackSlots) {
556+ emitByte(opc_getstatic);
557+ emitShort(fieldIndex);
558+ setStack(getStack() + fieldSizeInStackSlots);
559+ }
560+
561+ public void opc_putstatic(short fieldIndex, int fieldSizeInStackSlots) {
562+ emitByte(opc_putstatic);
563+ emitShort(fieldIndex);
564+ setStack(getStack() - fieldSizeInStackSlots);
565+ }
566+
567+ public void opc_getfield(short fieldIndex, int fieldSizeInStackSlots) {
568+ emitByte(opc_getfield);
569+ emitShort(fieldIndex);
570+ setStack(getStack() + fieldSizeInStackSlots - 1);
571+ }
572+
573+ public void opc_putfield(short fieldIndex, int fieldSizeInStackSlots) {
574+ emitByte(opc_putfield);
575+ emitShort(fieldIndex);
576+ setStack(getStack() - fieldSizeInStackSlots - 1);
577+ }
578+
579+ ////////////////////////
580+ // Method invocations //
581+ ////////////////////////
582+
583+ /** Long and double arguments and return types count as 2 arguments;
584+ other values count as 1. */
585+ public void opc_invokevirtual(short methodIndex,
586+ int numArgs,
587+ int numReturnValues)
588+ {
589+ emitByte(opc_invokevirtual);
590+ emitShort(methodIndex);
591+ setStack(getStack() - numArgs - 1 + numReturnValues);
592+ }
593+
594+ /** Long and double arguments and return types count as 2 arguments;
595+ other values count as 1. */
596+ public void opc_invokespecial(short methodIndex,
597+ int numArgs,
598+ int numReturnValues)
599+ {
600+ emitByte(opc_invokespecial);
601+ emitShort(methodIndex);
602+ setStack(getStack() - numArgs - 1 + numReturnValues);
603+ }
604+
605+ /** Long and double arguments and return types count as 2 arguments;
606+ other values count as 1. */
607+ public void opc_invokestatic(short methodIndex,
608+ int numArgs,
609+ int numReturnValues)
610+ {
611+ emitByte(opc_invokestatic);
612+ emitShort(methodIndex);
613+ setStack(getStack() - numArgs + numReturnValues);
614+ }
615+
616+ /** Long and double arguments and return types count as 2 arguments;
617+ other values count as 1. */
618+ public void opc_invokeinterface(short methodIndex,
619+ int numArgs,
620+ byte count,
621+ int numReturnValues)
622+ {
623+ emitByte(opc_invokeinterface);
624+ emitShort(methodIndex);
625+ emitByte(count);
626+ emitByte((byte) 0);
627+ setStack(getStack() - numArgs - 1 + numReturnValues);
628+ }
629+
630+ //////////////////
631+ // Array length //
632+ //////////////////
633+
634+ public void opc_arraylength() {
635+ emitByte(opc_arraylength);
636+ }
637+
638+ /////////
639+ // New //
640+ /////////
641+
642+ public void opc_new(short classIndex) {
643+ emitByte(opc_new);
644+ emitShort(classIndex);
645+ incStack();
646+ }
647+
648+ ////////////
649+ // Athrow //
650+ ////////////
651+
652+ public void opc_athrow() {
653+ emitByte(opc_athrow);
654+ setStack(1);
655+ }
656+
657+ //////////////////////////////
658+ // Checkcast and instanceof //
659+ //////////////////////////////
660+
661+ /** Assumes the checkcast succeeds */
662+ public void opc_checkcast(short classIndex) {
663+ emitByte(opc_checkcast);
664+ emitShort(classIndex);
665+ }
666+
667+ public void opc_instanceof(short classIndex) {
668+ emitByte(opc_instanceof);
669+ emitShort(classIndex);
670+ }
671+}