InstructionFactory


1   package com.sun.org.apache.bcel.internal.generic;
2   
3   /* ====================================================================
4    * The Apache Software License, Version 1.1
5    *
6    * Copyright (c) 2001 The Apache Software Foundation.  All rights
7    * reserved.
8    *
9    * Redistribution and use in source and binary forms, with or without
10   * modification, are permitted provided that the following conditions
11   * are met:
12   *
13   * 1. Redistributions of source code must retain the above copyright
14   *    notice, this list of conditions and the following disclaimer.
15   *
16   * 2. Redistributions in binary form must reproduce the above copyright
17   *    notice, this list of conditions and the following disclaimer in
18   *    the documentation and/or other materials provided with the
19   *    distribution.
20   *
21   * 3. The end-user documentation included with the redistribution,
22   *    if any, must include the following acknowledgment:
23   *       "This product includes software developed by the
24   *        Apache Software Foundation (http://www.apache.org/)."
25   *    Alternately, this acknowledgment may appear in the software itself,
26   *    if and wherever such third-party acknowledgments normally appear.
27   *
28   * 4. The names "Apache" and "Apache Software Foundation" and
29   *    "Apache BCEL" must not be used to endorse or promote products
30   *    derived from this software without prior written permission. For
31   *    written permission, please contact apache@apache.org.
32   *
33   * 5. Products derived from this software may not be called "Apache",
34   *    "Apache BCEL", nor may "Apache" appear in their name, without
35   *    prior written permission of the Apache Software Foundation.
36   *
37   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
38   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
39   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
41   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
42   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
43   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
44   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
45   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
46   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
47   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
48   * SUCH DAMAGE.
49   * ====================================================================
50   *
51   * This software consists of voluntary contributions made by many
52   * individuals on behalf of the Apache Software Foundation.  For more
53   * information on the Apache Software Foundation, please see
54   * <http://www.apache.org/>.
55   */
56  import com.sun.org.apache.bcel.internal.Constants;
57  
58  /** 
59   * Instances of this class may be used, e.g., to generate typed
60   * versions of instructions. Its main purpose is to be used as the
61   * byte code generating backend of a compiler. You can subclass it to
62   * add your own create methods.
63   *
64   * @version $Id: InstructionFactory.java,v 1.1.1.1 2001/10/29 20:00:19 jvanzyl Exp $
65   * @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
66   * @see Constants
67   */
68  public class InstructionFactory implements InstructionConstants {
69    protected ClassGen        cg;
70    protected ConstantPoolGen cp;
71  
72    public InstructionFactory(ClassGen cg, ConstantPoolGen cp) {
73      this.cg = cg;
74      this.cp = cp;
75    }
76  
77    /** Initialize with ClassGen object
78     */
79    public InstructionFactory(ClassGen cg) {
80      this(cg, cg.getConstantPool());
81    }
82  
83    /** Initialize just with ConstantPoolGen object
84     */
85    public InstructionFactory(ConstantPoolGen cp) {
86      this(null, cp);
87    }
88  
89    /** Create an invoke instruction.
90     *
91     * @param class_name name of the called class
92     * @param name name of the called method
93     * @param ret_type return type of method
94     * @param arg_types argument types of method
95     * @param kind how to invoke, i.e., INVOKEINTERFACE, INVOKESTATIC, INVOKEVIRTUAL,
96     * or INVOKESPECIAL
97     * @see Constants
98     */
99    public InvokeInstruction createInvoke(String   class_name, String   name, Type ret_type,
100                     Type[] arg_types, short kind) {
101     int    index;
102     int    nargs      = 0;
103     String   signature  = Type.getMethodSignature(ret_type, arg_types);
104 
105     for(int i=0; i < arg_types.length; i++) // Count size of arguments
106       nargs += arg_types[i].getSize();
107 
108     if(kind == Constants.INVOKEINTERFACE)
109       index = cp.addInterfaceMethodref(class_name, name, signature);
110     else
111       index = cp.addMethodref(class_name, name, signature);
112 
113     switch(kind) {
114     case Constants.INVOKESPECIAL:   return new INVOKESPECIAL(index);
115     case Constants.INVOKEVIRTUAL:   return new INVOKEVIRTUAL(index);
116     case Constants.INVOKESTATIC:    return new INVOKESTATIC(index);
117     case Constants.INVOKEINTERFACE: return new INVOKEINTERFACE(index, nargs + 1);
118     default:
119       throw new RuntimeException  ("Oops: Unknown invoke kind:" + kind);
120     }
121   }
122 
123   /** Create a call to the most popular System.out.println() method.
124    *
125    * @param s the string to print
126    */
127   public InstructionList createPrintln(String   s) {
128     InstructionList il      = new InstructionList();
129     int             out     = cp.addFieldref("java.lang.System", "out",
130                          "Ljava/io/PrintStream;");
131     int             println = cp.addMethodref("java.io.PrintStream", "println",
132                           "(Ljava/lang/String;)V");
133 
134     il.append(new GETSTATIC(out));
135     il.append(new PUSH(cp, s));
136     il.append(new INVOKEVIRTUAL(println));
137 
138     return il;
139   }
140 
141   private static class MethodObject {
142     Type[]   arg_types;
143     Type     result_type;
144     String  [] arg_names;
145     String     class_name;
146     String     name;
147     int      access;
148 
149     MethodObject(String   c, String   n, Type r, Type[] a, int acc) {
150       class_name  = c;
151       name        = n;
152       result_type = r;
153       arg_types   = a;
154       access      = acc;
155     }
156   }
157 
158   private InvokeInstruction createInvoke(MethodObject m, short kind) {
159     return createInvoke(m.class_name, m.name, m.result_type, m.arg_types, kind);
160   }
161 
162   private static MethodObject[] append_mos = {
163     new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER,
164              new Type[] { Type.STRING }, Constants.ACC_PUBLIC),
165     new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER,
166              new Type[] { Type.OBJECT }, Constants.ACC_PUBLIC),
167     null, null, // indices 2, 3
168     new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER,
169              new Type[] { Type.BOOLEAN }, Constants.ACC_PUBLIC),
170     new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER,
171              new Type[] { Type.CHAR }, Constants.ACC_PUBLIC),
172     new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER,
173              new Type[] { Type.FLOAT }, Constants.ACC_PUBLIC),
174     new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER,
175              new Type[] { Type.DOUBLE }, Constants.ACC_PUBLIC),
176     new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER,
177              new Type[] { Type.INT }, Constants.ACC_PUBLIC),
178     new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, // No append(byte)
179              new Type[] { Type.INT }, Constants.ACC_PUBLIC),
180     new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, // No append(short)
181              new Type[] { Type.INT }, Constants.ACC_PUBLIC),
182     new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER,
183              new Type[] { Type.LONG }, Constants.ACC_PUBLIC)    
184   };
185 
186   private static final boolean isString(Type type) {
187     return ((type instanceof ObjectType) && 
188             ((ObjectType)type).getClassName().equals("java.lang.String"));
189   }
190 
191   public Instruction createAppend(Type type) {
192     byte t = type.getType();
193 
194     if(isString(type))
195       return createInvoke(append_mos[0], Constants.INVOKEVIRTUAL);
196 
197     switch(t) {
198     case Constants.T_BOOLEAN:
199     case Constants.T_CHAR: 
200     case Constants.T_FLOAT:
201     case Constants.T_DOUBLE:
202     case Constants.T_BYTE:
203     case Constants.T_SHORT:
204     case Constants.T_INT:
205     case Constants.T_LONG
206       :   return createInvoke(append_mos[t], Constants.INVOKEVIRTUAL);
207     case Constants.T_ARRAY:
208     case Constants.T_OBJECT:
209       return createInvoke(append_mos[1], Constants.INVOKEVIRTUAL);
210     default:
211       throw new RuntimeException  ("Oops: No append for this type? " + type);
212     }
213   }
214 
215   /** Create a field instruction.
216    *
217    * @param class_name name of the accessed class
218    * @param name name of the referenced field
219    * @param type  type of field
220    * @param kind how to access, i.e., GETFIELD, PUTFIELD, GETSTATIC, PUTSTATIC
221    * @see Constants
222    */
223   public FieldInstruction createFieldAccess(String   class_name, String   name, Type type, short kind) {
224     int    index;
225     String   signature  = type.getSignature();
226 
227     index = cp.addFieldref(class_name, name, signature);
228 
229     switch(kind) {
230     case Constants.GETFIELD:  return new GETFIELD(index);
231     case Constants.PUTFIELD:  return new PUTFIELD(index);
232     case Constants.GETSTATIC: return new GETSTATIC(index);
233     case Constants.PUTSTATIC: return new PUTSTATIC(index);
234 
235     default:
236       throw new RuntimeException  ("Oops: Unknown getfield kind:" + kind);
237     }
238   }
239 
240   /** Create reference to `this'
241    */
242   public static Instruction createThis() {
243     return new ALOAD(0);
244   }
245 
246   /** Create typed return
247    */
248   public static ReturnInstruction createReturn(Type type) {
249     switch(type.getType()) {
250     case Constants.T_ARRAY:
251     case Constants.T_OBJECT:  return ARETURN;
252     case Constants.T_INT:
253     case Constants.T_SHORT:
254     case Constants.T_BOOLEAN:
255     case Constants.T_CHAR: 
256     case Constants.T_BYTE:    return IRETURN;
257     case Constants.T_FLOAT:   return FRETURN;
258     case Constants.T_DOUBLE:  return DRETURN;
259     case Constants.T_LONG:    return LRETURN;
260     case Constants.T_VOID:    return RETURN;
261 
262     default:
263       throw new RuntimeException  ("Invalid type: " + type);
264     }
265   }
266   
267   private static final ArithmeticInstruction createBinaryIntOp(char first, String   op) {
268     switch(first) {
269     case '-' : return ISUB;
270     case '+' : return IADD;
271     case '%' : return IREM;
272     case '*' : return IMUL;
273     case '/' : return IDIV;
274     case '&' : return IAND;
275     case '|' : return IOR;
276     case '^' : return IXOR;
277     case '<' : return ISHL;
278     case '>' : return op.equals(">>>")? (ArithmeticInstruction)IUSHR :
279       (ArithmeticInstruction)ISHR;
280     default: throw new RuntimeException  ("Invalid operand " + op);
281     }
282   }
283 
284   private static final ArithmeticInstruction createBinaryLongOp(char first, String   op) {
285     switch(first) {
286     case '-' : return LSUB;
287     case '+' : return LADD;
288     case '%' : return LREM;
289     case '*' : return LMUL;
290     case '/' : return LDIV;
291     case '&' : return LAND;
292     case '|' : return LOR;
293     case '^' : return LXOR;
294     case '<' : return LSHL;
295     case '>' : return op.equals(">>>")? (ArithmeticInstruction)LUSHR :
296       (ArithmeticInstruction)LSHR;
297     default: throw new RuntimeException  ("Invalid operand " + op);
298     }
299   }
300 
301   private static final ArithmeticInstruction createBinaryFloatOp(char op) {
302     switch(op) {
303     case '-' : return FSUB;
304     case '+' : return FADD;
305     case '*' : return FMUL;
306     case '/' : return FDIV;
307     default: throw new RuntimeException  ("Invalid operand " + op);
308     }
309   }
310 
311   private static final ArithmeticInstruction createBinaryDoubleOp(char op) {
312     switch(op) {
313     case '-' : return DSUB;
314     case '+' : return DADD;
315     case '*' : return DMUL;
316     case '/' : return DDIV;
317     default: throw new RuntimeException  ("Invalid operand " + op);
318     }
319   }
320 
321   /**
322    * Create binary operation for simple basic types, such as int and float.
323    *
324    * @param op operation, such as "+", "*", "<<", etc.
325    */
326   public static ArithmeticInstruction createBinaryOperation(String   op, Type type) {
327     char first = op.toCharArray()[0];
328 
329     switch(type.getType()) {
330     case Constants.T_BYTE:
331     case Constants.T_SHORT:
332     case Constants.T_INT:
333     case Constants.T_CHAR:    return createBinaryIntOp(first, op);
334     case Constants.T_LONG:    return createBinaryLongOp(first, op);
335     case Constants.T_FLOAT:   return createBinaryFloatOp(first);
336     case Constants.T_DOUBLE:  return createBinaryDoubleOp(first);
337     default:        throw new RuntimeException  ("Invalid type " + type);
338     }
339   }
340 
341   /**
342    * @param size size of operand, either 1 (int, e.g.) or 2 (double)
343    */
344   public static StackInstruction createPop(int size) {
345     return (size == 2)? (StackInstruction)POP2 :
346       (StackInstruction)POP;
347   }
348 
349   /**
350    * @param size size of operand, either 1 (int, e.g.) or 2 (double)
351    */
352   public static StackInstruction createDup(int size) {
353     return (size == 2)? (StackInstruction)DUP2 :
354       (StackInstruction)DUP;
355   }
356 
357   /**
358    * @param size size of operand, either 1 (int, e.g.) or 2 (double)
359    */
360   public static StackInstruction createDup_2(int size) {
361     return (size == 2)? (StackInstruction)DUP2_X2 :
362       (StackInstruction)DUP_X2;
363   }
364 
365   /**
366    * @param size size of operand, either 1 (int, e.g.) or 2 (double)
367    */
368   public static StackInstruction createDup_1(int size) {
369     return (size == 2)? (StackInstruction)DUP2_X1 :
370       (StackInstruction)DUP_X1;
371   }
372 
373   /**
374    * @param index index of local variable
375    */
376   public static LocalVariableInstruction createStore(Type type, int index) {
377     switch(type.getType()) {
378     case Constants.T_BOOLEAN:
379     case Constants.T_CHAR:
380     case Constants.T_BYTE:
381     case Constants.T_SHORT:
382     case Constants.T_INT:    return new ISTORE(index);
383     case Constants.T_FLOAT:  return new FSTORE(index);
384     case Constants.T_DOUBLE: return new DSTORE(index);
385     case Constants.T_LONG:   return new LSTORE(index);
386     case Constants.T_ARRAY:
387     case Constants.T_OBJECT: return new ASTORE(index);
388     default:       throw new RuntimeException  ("Invalid type " + type);
389     }
390   }
391 
392   /**
393    * @param index index of local variable
394    */
395   public static LocalVariableInstruction createLoad(Type type, int index) {
396     switch(type.getType()) {
397     case Constants.T_BOOLEAN:
398     case Constants.T_CHAR:
399     case Constants.T_BYTE:
400     case Constants.T_SHORT:
401     case Constants.T_INT:    return new ILOAD(index);
402     case Constants.T_FLOAT:  return new FLOAD(index);
403     case Constants.T_DOUBLE: return new DLOAD(index);
404     case Constants.T_LONG:   return new LLOAD(index);
405     case Constants.T_ARRAY:
406     case Constants.T_OBJECT: return new ALOAD(index);
407     default:       throw new RuntimeException  ("Invalid type " + type);
408     }
409   }
410 
411   /**
412    * @param type type of elements of array, i.e., array.getElementType()
413    */
414   public static ArrayInstruction createArrayLoad(Type type) {
415     switch(type.getType()) {
416     case Constants.T_BOOLEAN:
417     case Constants.T_BYTE:   return BALOAD;
418     case Constants.T_CHAR:   return CALOAD;
419     case Constants.T_SHORT:  return SALOAD;
420     case Constants.T_INT:    return IALOAD;
421     case Constants.T_FLOAT:  return FALOAD;
422     case Constants.T_DOUBLE: return DALOAD;
423     case Constants.T_LONG:   return LALOAD;
424     case Constants.T_ARRAY:
425     case Constants.T_OBJECT: return AALOAD;
426     default:       throw new RuntimeException  ("Invalid type " + type);
427     }
428   }
429 
430   /**
431    * @param type type of elements of array, i.e., array.getElementType()
432    */
433   public static ArrayInstruction createArrayStore(Type type) {
434     switch(type.getType()) {
435     case Constants.T_BOOLEAN:
436     case Constants.T_BYTE:   return BASTORE;
437     case Constants.T_CHAR:   return CASTORE;
438     case Constants.T_SHORT:  return SASTORE;
439     case Constants.T_INT:    return IASTORE;
440     case Constants.T_FLOAT:  return FASTORE;
441     case Constants.T_DOUBLE: return DASTORE;
442     case Constants.T_LONG:   return LASTORE;
443     case Constants.T_ARRAY:
444     case Constants.T_OBJECT: return AASTORE;
445     default:       throw new RuntimeException  ("Invalid type " + type);
446     }
447   }
448 
449 
450   /** Create conversion operation for two stack operands, this may be an I2C, instruction, e.g.,
451    * if the operands are basic types and CHECKCAST if they are reference types.
452    */
453   public Instruction createCast(Type src_type, Type dest_type) {
454     if((src_type instanceof BasicType) && (dest_type instanceof BasicType)) {
455       byte dest = dest_type.getType();
456       byte src  = src_type.getType();
457 
458       if(dest == Constants.T_LONG && (src == Constants.T_CHAR || src == Constants.T_BYTE ||
459                       src == Constants.T_SHORT))
460     src = Constants.T_INT;
461 
462       String  [] short_names = { "C", "F", "D", "B", "S", "I", "L" };
463 
464       String   name = "com.sun.org.apache.bcel.internal.generic." + short_names[src - Constants.T_CHAR] +
465     "2" + short_names[dest - Constants.T_CHAR];
466       
467       Instruction i = null;
468       try {
469     i = (Instruction)java.lang.Class.forName(name).newInstance();
470       } catch(Exception   e) {
471     throw new RuntimeException  ("Could not find instruction: " + name);
472       }
473 
474       return i;
475     } else if((src_type instanceof ReferenceType) && (dest_type instanceof ReferenceType)) {
476       if(dest_type instanceof ArrayType)
477     return new CHECKCAST(cp.addArrayClass((ArrayType)dest_type));
478       else
479     return new CHECKCAST(cp.addClass(((ObjectType)dest_type).getClassName()));
480     }
481     else
482       throw new RuntimeException  ("Can not cast " + src_type + " to " + dest_type);
483   }
484 
485   public GETFIELD createGetField(String   class_name, String   name, Type t) {
486     return new GETFIELD(cp.addFieldref(class_name, name, t.getSignature()));
487   }
488 
489   public GETSTATIC createGetStatic(String   class_name, String   name, Type t) {
490     return new GETSTATIC(cp.addFieldref(class_name, name, t.getSignature()));
491   }
492 
493   public PUTFIELD createPutField(String   class_name, String   name, Type t) {
494     return new PUTFIELD(cp.addFieldref(class_name, name, t.getSignature()));
495   }
496 
497   public PUTSTATIC createPutStatic(String   class_name, String   name, Type t) {
498     return new PUTSTATIC(cp.addFieldref(class_name, name, t.getSignature()));
499   }
500 
501   public CHECKCAST createCheckCast(ReferenceType t) {
502     if(t instanceof ArrayType)
503       return new CHECKCAST(cp.addArrayClass((ArrayType)t));
504     else
505       return new CHECKCAST(cp.addClass((ObjectType)t));
506   }
507 
508   public NEW createNew(ObjectType t) {
509     return new NEW(cp.addClass(t));
510   }
511 
512   public NEW createNew(String   s) {
513     return createNew(new ObjectType(s));
514   }
515 
516   /** Create new array of given size and type.
517    */
518   public AllocationInstruction createNewArray(Type t, short dim) {
519     if(dim == 1) {
520       if(t instanceof ObjectType)
521     return new ANEWARRAY(cp.addClass((ObjectType)t));
522       else if(t instanceof ArrayType)
523     return new ANEWARRAY(cp.addArrayClass((ArrayType)t));
524       else
525     return new NEWARRAY(((BasicType)t).getType());
526     } else {
527       ArrayType at;
528 
529       if(t instanceof ArrayType)
530     at = (ArrayType)t;
531       else
532     at = new ArrayType(t, dim);
533 
534       return new MULTIANEWARRAY(cp.addArrayClass(at), dim);
535     }
536   }
537 
538   /** Create "null" value for reference types, 0 for basic types like int
539    */
540   public static Instruction createNull(Type type) {
541     switch(type.getType()) {
542     case Constants.T_ARRAY:
543     case Constants.T_OBJECT:  return ACONST_NULL;
544     case Constants.T_INT:
545     case Constants.T_SHORT:
546     case Constants.T_BOOLEAN:
547     case Constants.T_CHAR: 
548     case Constants.T_BYTE:    return ICONST_0;
549     case Constants.T_FLOAT:   return FCONST_0;
550     case Constants.T_DOUBLE:  return DCONST_0;
551     case Constants.T_LONG:    return LCONST_0;
552     case Constants.T_VOID:    return NOP;
553 
554     default:
555       throw new RuntimeException  ("Invalid type: " + type);
556     }
557   }
558 
559   /** Create branch instruction by given opcode, except LOOKUPSWITCH and TABLESWITCH.
560    * For those you should use the SWITCH compeund instruction.
561    */
562   public static BranchInstruction createBranchInstruction(short opcode, InstructionHandle target) {
563     switch(opcode) {
564     case Constants.IFEQ:      return new IFEQ(target);
565     case Constants.IFNE:      return new IFNE(target);
566     case Constants.IFLT:      return new IFLT(target);
567     case Constants.IFGE:      return new IFGE(target);
568     case Constants.IFGT:      return new IFGT(target);
569     case Constants.IFLE:      return new IFLE(target);
570     case Constants.IF_ICMPEQ: return new IF_ICMPEQ(target);
571     case Constants.IF_ICMPNE: return new IF_ICMPNE(target);
572     case Constants.IF_ICMPLT: return new IF_ICMPLT(target);
573     case Constants.IF_ICMPGE: return new IF_ICMPGE(target);
574     case Constants.IF_ICMPGT: return new IF_ICMPGT(target);
575     case Constants.IF_ICMPLE: return new IF_ICMPLE(target);
576     case Constants.IF_ACMPEQ: return new IF_ACMPEQ(target);
577     case Constants.IF_ACMPNE: return new IF_ACMPNE(target);
578     case Constants.GOTO:      return new GOTO(target);
579     case Constants.JSR:       return new JSR(target);
580     case Constants.IFNULL:    return new IFNULL(target);
581     case Constants.IFNONNULL: return new IFNONNULL(target);
582     case Constants.GOTO_W:    return new GOTO_W(target);
583     case Constants.JSR_W:     return new JSR_W(target);
584     default:
585     throw new RuntimeException  ("Invalid opcode: " + opcode);
586     }
587   }
588 
589   public void            setClassGen(ClassGen c)            { cg = c; }
590   public ClassGen        getClassGen()                      { return cg; }
591   public void            setConstantPool(ConstantPoolGen c) { cp = c; }
592   public ConstantPoolGen getConstantPool()                  { return cp; }
593 }
594
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags