1   package org.apache.bcel.verifier.structurals;
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  
57  import org.apache.bcel.Constants;
58  import org.apache.bcel.Repository;
59  import org.apache.bcel.generic.*;
60  import org.apache.bcel.classfile.JavaClass;
61  import org.apache.bcel.classfile.Constant;
62  import org.apache.bcel.classfile.ConstantDouble;
63  import org.apache.bcel.classfile.ConstantFloat;
64  import org.apache.bcel.classfile.ConstantInteger;
65  import org.apache.bcel.classfile.ConstantLong;
66  import org.apache.bcel.classfile.ConstantString;
67  import org.apache.bcel.verifier.Verifier;
68  import org.apache.bcel.verifier.exc.*;
69  import java.util.ArrayList;
70  import java.util.Hashtable;
71  
72  /***
73   * This Visitor class may be used for a type-based Java Virtual Machine
74   * simulation.
75   * It does not check for correct types on the OperandStack or in the
76   * LocalVariables; nor does it check their sizes are sufficiently big.
77   * Thus, to use this Visitor for bytecode verifying, you have to make sure
78   * externally that the type constraints of the Java Virtual Machine instructions
79   * are satisfied. An InstConstraintVisitor may be used for this.
80   * Anyway, this Visitor does not mandate it. For example, when you
81   * visitIADD(IADD o), then there are two stack slots popped and one
82   * stack slot containing a Type.INT is pushed (where you could also
83   * pop only one slot if you know there are two Type.INT on top of the
84   * stack). Monitor-specific behaviour is not simulated.
85   * 
86   * </P><B>Conventions:</B>
87   *
88   * Type.VOID will never be pushed onto the stack. Type.DOUBLE and Type.LONG
89   * that would normally take up two stack slots (like Double_HIGH and
90   * Double_LOW) are represented by a simple single Type.DOUBLE or Type.LONG
91   * object on the stack here.
92   * If a two-slot type is stored into a local variable, the next variable
93   * is given the type Type.UNKNOWN.
94   *
95   * @version $Id: ExecutionVisitor.java,v 1.1.1.1 2001/10/29 20:00:39 jvanzyl Exp $
96   * @author <A HREF="http://www.inf.fu-berlin.de/~ehaase"/>Enver Haase</A>
97   * @see #visitDSTORE(DSTORE o)
98   * @see InstConstraintVisitor
99   */
100 public class ExecutionVisitor extends EmptyVisitor implements Visitor{
101 
102 	/***
103 	 * The executionframe we're operating on.
104 	 */
105 	private Frame frame = null;
106 
107 	/***
108 	 * The ConstantPoolGen we're working with.
109 	 * @see #setConstantPoolGen(ConstantPoolGen)
110 	 */
111 	private ConstantPoolGen cpg = null;
112 
113 	/***
114 	 * Constructor. Constructs a new instance of this class.
115 	 */
116 	public ExecutionVisitor(){}
117 
118 	/***
119 	 * The OperandStack from the current Frame we're operating on.
120 	 * @see #setFrame(Frame)
121 	 */
122 	private OperandStack stack(){
123 		return frame.getStack();
124 	}
125 
126 	/***
127 	 * The LocalVariables from the current Frame we're operating on.
128 	 * @see #setFrame(Frame)
129 	 */
130 	private LocalVariables locals(){
131 		return frame.getLocals();
132 	}
133 
134 	/***
135 	 * Sets the ConstantPoolGen needed for symbolic execution.
136 	 */
137 	public void setConstantPoolGen(ConstantPoolGen cpg){
138 		this.cpg = cpg;
139 	}
140 	
141 	/***
142 	 * The only method granting access to the single instance of
143 	 * the ExecutionVisitor class. Before actively using this
144 	 * instance, <B>SET THE ConstantPoolGen FIRST</B>.
145 	 * @see #setConstantPoolGen(ConstantPoolGen)
146 	 */
147 	public void setFrame(Frame f){
148 		this.frame = f;
149 	}
150 
151 	///*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
152 	//public void visitWIDE(WIDE o){
153 	// The WIDE instruction is modelled as a flag
154 	// of the embedded instructions in BCEL.
155 	// Therefore BCEL checks for possible errors
156 	// when parsing in the .class file: We don't
157 	// have even the possibilty to care for WIDE
158 	// here.
159 	//}
160 
161 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
162 	public void visitAALOAD(AALOAD o){
163 		stack().pop();														// pop the index int
164 //System.out.print(stack().peek());
165 		Type t = stack().pop(); // Pop Array type
166 		if (t == Type.NULL){
167 			stack().push(Type.NULL);
168 		}	// Do nothing stackwise --- a NullPointerException is thrown at Run-Time
169 		else{
170 			ArrayType at = (ArrayType) t;	
171 			stack().push(at.getElementType());
172 		}
173 	}
174 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
175 	public void visitAASTORE(AASTORE o){
176 		stack().pop();
177 		stack().pop();
178 		stack().pop();
179 	}
180 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
181 	public void visitACONST_NULL(ACONST_NULL o){
182 		stack().push(Type.NULL);
183 	}
184 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
185 	public void visitALOAD(ALOAD o){
186 		stack().push(locals().get(o.getIndex()));
187 	}
188 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
189 	public void visitANEWARRAY(ANEWARRAY o){
190 		stack().pop(); //count
191 		stack().push( new ArrayType(o.getType(cpg), 1) );
192 	}
193 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
194 	public void visitARETURN(ARETURN o){
195 		stack().pop();
196 	}
197 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
198 	public void visitARRAYLENGTH(ARRAYLENGTH o){
199 		stack().pop();
200 		stack().push(Type.INT);
201 	}
202 
203 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
204 	public void visitASTORE(ASTORE o){
205 		locals().set(o.getIndex(), stack().pop());
206 		//System.err.println("TODO-DEBUG:	set LV '"+o.getIndex()+"' to '"+locals().get(o.getIndex())+"'.");
207 	}
208 
209 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
210 	public void visitATHROW(ATHROW o){
211 		Type t = stack().pop();
212 		stack().clear();
213 		if (t.equals(Type.NULL))
214 			stack().push(Type.getType("Ljava/lang/NullPointerException;"));
215 		else
216 			stack().push(t);
217 	}
218 
219 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
220 	public void visitBALOAD(BALOAD o){
221 		stack().pop();
222 		stack().pop();
223 		stack().push(Type.INT);
224 	}
225 
226 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
227 	public void visitBASTORE(BASTORE o){
228 		stack().pop();
229 		stack().pop();
230 		stack().pop();
231 	}
232 
233 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
234 	public void visitBIPUSH(BIPUSH o){
235 		stack().push(Type.INT);
236 	}
237 
238 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
239 	public void visitCALOAD(CALOAD o){
240 		stack().pop();
241 		stack().pop();
242 		stack().push(Type.INT);
243 	}
244 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
245 	public void visitCASTORE(CASTORE o){
246 		stack().pop();
247 		stack().pop();
248 		stack().pop();
249 	}
250 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
251 	public void visitCHECKCAST(CHECKCAST o){
252 		// It's possibly wrong to do so, but SUN's
253 		// ByteCode verifier seems to do (only) this, too.
254 		// TODO: One could use a sophisticated analysis here to check
255 		//       if a type cannot possibly be cated to another and by
256 		//       so doing predict the ClassCastException at run-time.
257 		stack().pop();
258 		stack().push(o.getType(cpg));
259 	}
260 
261 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
262 	public void visitD2F(D2F o){
263 		stack().pop();
264 		stack().push(Type.FLOAT);
265 	}
266 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
267 	public void visitD2I(D2I o){
268 		stack().pop();
269 		stack().push(Type.INT);
270 	}
271 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
272 	public void visitD2L(D2L o){
273 		stack().pop();
274 		stack().push(Type.LONG);
275 	}
276 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
277 	public void visitDADD(DADD o){
278 		stack().pop();
279 		stack().pop();
280 		stack().push(Type.DOUBLE);
281 	}
282 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
283 	public void visitDALOAD(DALOAD o){
284 		stack().pop();
285 		stack().pop();
286 		stack().push(Type.DOUBLE);
287 	}
288 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
289 	public void visitDASTORE(DASTORE o){
290 		stack().pop();
291 		stack().pop();
292 		stack().pop();
293 	}
294 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
295 	public void visitDCMPG(DCMPG o){
296 		stack().pop();
297 		stack().pop();
298 		stack().push(Type.INT);
299 	}
300 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
301 	public void visitDCMPL(DCMPL o){
302 		stack().pop();
303 		stack().pop();
304 		stack().push(Type.INT);
305 	}
306 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
307 	public void visitDCONST(DCONST o){
308 		stack().push(Type.DOUBLE);
309 	}
310 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
311 	public void visitDDIV(DDIV o){
312 		stack().pop();
313 		stack().pop();
314 		stack().push(Type.DOUBLE);
315 	}
316 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
317 	public void visitDLOAD(DLOAD o){
318 		stack().push(Type.DOUBLE);
319 	}
320 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
321 	public void visitDMUL(DMUL o){
322 		stack().pop();
323 		stack().pop();
324 		stack().push(Type.DOUBLE);
325 	}
326 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
327 	public void visitDNEG(DNEG o){
328 		stack().pop();
329 		stack().push(Type.DOUBLE);
330 	}
331 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
332 	public void visitDREM(DREM o){
333 		stack().pop();
334 		stack().pop();
335 		stack().push(Type.DOUBLE);
336 	}
337 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
338 	public void visitDRETURN(DRETURN o){
339 		stack().pop();
340 	}
341 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
342 	public void visitDSTORE(DSTORE o){
343 		locals().set(o.getIndex(), stack().pop());
344 		locals().set(o.getIndex()+1, Type.UNKNOWN);
345 	}
346 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
347 	public void visitDSUB(DSUB o){
348 		stack().pop();
349 		stack().pop();
350 		stack().push(Type.DOUBLE);
351 	}
352 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
353 	public void visitDUP(DUP o){
354 		Type t = stack().pop();
355 		stack().push(t);
356 		stack().push(t);
357 	}
358 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
359 	public void visitDUP_X1(DUP_X1 o){
360 		Type w1 = stack().pop();
361 		Type w2 = stack().pop();
362 		stack().push(w1);
363 		stack().push(w2);
364 		stack().push(w1);
365 	}
366 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
367 	public void visitDUP_X2(DUP_X2 o){
368 		Type w1 = stack().pop();
369 		Type w2 = stack().pop();
370 		if (w2.getSize() == 2){
371 			stack().push(w1);
372 			stack().push(w2);
373 			stack().push(w1);
374 		}
375 		else{
376 			Type w3 = stack().pop();
377 			stack().push(w1);
378 			stack().push(w3);
379 			stack().push(w2);
380 			stack().push(w1);
381 		}
382 	}
383 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
384 	public void visitDUP2(DUP2 o){
385 		Type t = stack().pop();
386 		if (t.getSize() == 2){
387 			stack().push(t);
388 			stack().push(t);
389 		}
390 		else{ // t.getSize() is 1
391 			Type u = stack().pop();
392 			stack().push(u);
393 			stack().push(t);
394 			stack().push(u);
395 			stack().push(t);
396 		}
397 	}
398 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
399 	public void visitDUP2_X1(DUP2_X1 o){
400 		Type t = stack().pop();
401 		if (t.getSize() == 2){
402 			Type u = stack().pop();
403 			stack().push(t);
404 			stack().push(u);
405 			stack().push(t);
406 		}
407 		else{ //t.getSize() is1
408 			Type u = stack().pop();
409 			Type v = stack().pop();
410 			stack().push(u);
411 			stack().push(t);
412 			stack().push(v);
413 			stack().push(u);
414 			stack().push(t);
415 		}
416 	}
417 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
418 	public void visitDUP2_X2(DUP2_X2 o){
419 		Type t = stack().pop();
420 		if (t.getSize() == 2){
421 			Type u = stack().pop();
422 			if (u.getSize() == 2){
423 				stack().push(t);
424 				stack().push(u);
425 				stack().push(t);
426 			}else{
427 				Type v = stack().pop();
428 				stack().push(t);
429 				stack().push(v);
430 				stack().push(u);
431 				stack().push(t);
432 			}
433 		}
434 		else{ //t.getSize() is 1
435 			Type u = stack().pop();
436 			Type v = stack().pop();
437 			if (v.getSize() == 2){
438 				stack().push(u);
439 				stack().push(t);
440 				stack().push(v);
441 				stack().push(u);
442 				stack().push(t);
443 			}else{
444 				Type w = stack().pop();
445 				stack().push(u);
446 				stack().push(t);
447 				stack().push(w);
448 				stack().push(v);
449 				stack().push(u);
450 				stack().push(t);
451 			}
452 		}
453 	}
454 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
455 	public void visitF2D(F2D o){
456 		stack().pop();
457 		stack().push(Type.DOUBLE);
458 	}
459 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
460 	public void visitF2I(F2I o){
461 		stack().pop();
462 		stack().push(Type.INT);
463 	}
464 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
465 	public void visitF2L(F2L o){
466 		stack().pop();
467 		stack().push(Type.LONG);
468 	}
469 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
470 	public void visitFADD(FADD o){
471 		stack().pop();
472 		stack().pop();
473 		stack().push(Type.FLOAT);
474 	}
475 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
476 	public void visitFALOAD(FALOAD o){
477 		stack().pop();
478 		stack().pop();
479 		stack().push(Type.FLOAT);
480 	}
481 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
482 	public void visitFASTORE(FASTORE o){
483 		stack().pop();
484 		stack().pop();
485 		stack().pop();
486 	}
487 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
488 	public void visitFCMPG(FCMPG o){
489 		stack().pop();
490 		stack().pop();
491 		stack().push(Type.INT);
492 	}
493 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
494 	public void visitFCMPL(FCMPL o){
495 		stack().pop();
496 		stack().pop();
497 		stack().push(Type.INT);
498 	}
499 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
500 	public void visitFCONST(FCONST o){
501 		stack().push(Type.FLOAT);
502 	}
503 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
504 	public void visitFDIV(FDIV o){
505 		stack().pop();
506 		stack().pop();
507 		stack().push(Type.FLOAT);
508 	}
509 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
510 	public void visitFLOAD(FLOAD o){
511 		stack().push(Type.FLOAT);
512 	}
513 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
514 	public void visitFMUL(FMUL o){
515 		stack().pop();
516 		stack().pop();
517 		stack().push(Type.FLOAT);
518 	}
519 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
520 	public void visitFNEG(FNEG o){
521 		stack().pop();
522 		stack().push(Type.FLOAT);
523 	}
524 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
525 	public void visitFREM(FREM o){
526 		stack().pop();
527 		stack().pop();
528 		stack().push(Type.FLOAT);
529 	}
530 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
531 	public void visitFRETURN(FRETURN o){
532 		stack().pop();
533 	}
534 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
535 	public void visitFSTORE(FSTORE o){
536 		locals().set(o.getIndex(), stack().pop());
537 	}
538 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
539 	public void visitFSUB(FSUB o){
540 		stack().pop();
541 		stack().pop();
542 		stack().push(Type.FLOAT);
543 	}
544 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
545 	public void visitGETFIELD(GETFIELD o){
546 		stack().pop();
547 		Type t = o.getFieldType(cpg);
548 		if (	t.equals(Type.BOOLEAN)	||
549 					t.equals(Type.CHAR)			||
550 					t.equals(Type.BYTE) 		||
551 					t.equals(Type.SHORT)		)
552 			t = Type.INT;
553 		stack().push(t);
554 	}
555 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
556 	public void visitGETSTATIC(GETSTATIC o){
557 		Type t = o.getFieldType(cpg);
558 		if (	t.equals(Type.BOOLEAN)	||
559 					t.equals(Type.CHAR)			||
560 					t.equals(Type.BYTE) 		||
561 					t.equals(Type.SHORT)		)
562 			t = Type.INT;
563 		stack().push(t);
564 	}
565 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
566 	public void visitGOTO(GOTO o){
567 		// no stack changes.
568 	}
569 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
570 	public void visitGOTO_W(GOTO_W o){
571 		// no stack changes.
572 	}
573 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
574 	public void visitI2B(I2B o){
575 		stack().pop();
576 		stack().push(Type.INT);
577 	}
578 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
579 	public void visitI2C(I2C o){
580 		stack().pop();
581 		stack().push(Type.INT);
582 	}
583 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
584 	public void visitI2D(I2D o){
585 		stack().pop();
586 		stack().push(Type.DOUBLE);
587 	}
588 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
589 	public void visitI2F(I2F o){
590 		stack().pop();
591 		stack().push(Type.FLOAT);
592 	}
593 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
594 	public void visitI2L(I2L o){
595 		stack().pop();
596 		stack().push(Type.LONG);
597 	}
598 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
599 	public void visitI2S(I2S o){
600 		stack().pop();
601 		stack().push(Type.INT);
602 	}
603 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
604 	public void visitIADD(IADD o){
605 		stack().pop();
606 		stack().pop();
607 		stack().push(Type.INT);
608 	}
609 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
610 	public void visitIALOAD(IALOAD o){
611 		stack().pop();
612 		stack().pop();
613 		stack().push(Type.INT);
614 	}
615 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
616 	public void visitIAND(IAND o){
617 		stack().pop();
618 		stack().pop();
619 		stack().push(Type.INT);
620 	}
621 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
622 	public void visitIASTORE(IASTORE o){
623 		stack().pop();
624 		stack().pop();
625 		stack().pop();
626 	}
627 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
628 	public void visitICONST(ICONST o){
629 		stack().push(Type.INT);
630 	}
631 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
632 	public void visitIDIV(IDIV o){
633 		stack().pop();
634 		stack().pop();
635 		stack().push(Type.INT);
636 	}
637 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
638 	public void visitIF_ACMPEQ(IF_ACMPEQ o){
639 		stack().pop();
640 		stack().pop();
641 	}
642 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
643 	public void visitIF_ACMPNE(IF_ACMPNE o){
644 		stack().pop();
645 		stack().pop();
646 	}
647 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
648 	public void visitIF_ICMPEQ(IF_ICMPEQ o){
649 		stack().pop();
650 		stack().pop();
651 	}
652 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
653 	public void visitIF_ICMPGE(IF_ICMPGE o){
654 		stack().pop();
655 		stack().pop();
656 	}
657 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
658 	public void visitIF_ICMPGT(IF_ICMPGT o){
659 		stack().pop();
660 		stack().pop();
661 	}
662 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
663 	public void visitIF_ICMPLE(IF_ICMPLE o){
664 		stack().pop();
665 		stack().pop();
666 	}
667 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
668 	public void visitIF_ICMPLT(IF_ICMPLT o){
669 		stack().pop();
670 		stack().pop();
671 	}
672 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
673 	public void visitIF_ICMPNE(IF_ICMPNE o){
674 		stack().pop();
675 		stack().pop();
676 	}
677 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
678 	public void visitIFEQ(IFEQ o){
679 		stack().pop();
680 	}
681 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
682 	public void visitIFGE(IFGE o){
683 		stack().pop();
684 	}
685 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
686 	public void visitIFGT(IFGT o){
687 		stack().pop();
688 	}
689 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
690 	public void visitIFLE(IFLE o){
691 		stack().pop();
692 	}
693 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
694 	public void visitIFLT(IFLT o){
695 		stack().pop();
696 	}
697 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
698 	public void visitIFNE(IFNE o){
699 		stack().pop();
700 	}
701 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
702 	public void visitIFNONNULL(IFNONNULL o){
703 		stack().pop();
704 	}
705 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
706 	public void visitIFNULL(IFNULL o){
707 		stack().pop();
708 	}
709 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
710 	public void visitIINC(IINC o){
711 		// stack is not changed.
712 	}
713 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
714 	public void visitILOAD(ILOAD o){
715 		stack().push(Type.INT);
716 	}
717 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
718 	public void visitIMUL(IMUL o){
719 		stack().pop();
720 		stack().pop();
721 		stack().push(Type.INT);
722 	}
723 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
724 	public void visitINEG(INEG o){
725 		stack().pop();
726 		stack().push(Type.INT);
727 	}
728 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
729 	public void visitINSTANCEOF(INSTANCEOF o){
730 		stack().pop();
731 		stack().push(Type.INT);
732 	}
733 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
734 	public void visitINVOKEINTERFACE(INVOKEINTERFACE o){
735 		stack().pop();	//objectref
736 		for (int i=0; i<o.getArgumentTypes(cpg).length; i++){
737 			stack().pop();
738 		}
739 		// We are sure the invoked method will xRETURN eventually
740 		// We simulate xRETURNs functionality here because we
741 		// don't really "jump into" and simulate the invoked
742 		// method.
743 		if (o.getReturnType(cpg) != Type.VOID){
744 			Type t = o.getReturnType(cpg);
745 			if (	t.equals(Type.BOOLEAN)	||
746 						t.equals(Type.CHAR)			||
747 						t.equals(Type.BYTE) 		||
748 						t.equals(Type.SHORT)		)
749 				t = Type.INT;
750 			stack().push(t);
751 		}
752 	}
753 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
754 	public void visitINVOKESPECIAL(INVOKESPECIAL o){
755 		if (o.getMethodName(cpg).equals(Constants.CONSTRUCTOR_NAME)){
756 			UninitializedObjectType t = (UninitializedObjectType) stack().peek(o.getArgumentTypes(cpg).length);
757 			if (t == frame._this){	
758 				frame._this = null;
759 			}
760 			stack().initializeObject(t);
761 			locals().initializeObject(t);
762 		}
763 		stack().pop();	//objectref
764 		for (int i=0; i<o.getArgumentTypes(cpg).length; i++){
765 			stack().pop();
766 		}
767 		// We are sure the invoked method will xRETURN eventually
768 		// We simulate xRETURNs functionality here because we
769 		// don't really "jump into" and simulate the invoked
770 		// method.
771 		if (o.getReturnType(cpg) != Type.VOID){
772 			Type t = o.getReturnType(cpg);
773 			if (	t.equals(Type.BOOLEAN)	||
774 						t.equals(Type.CHAR)			||
775 						t.equals(Type.BYTE) 		||
776 						t.equals(Type.SHORT)		)
777 				t = Type.INT;
778 			stack().push(t);
779 		}
780 	}
781 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
782 	public void visitINVOKESTATIC(INVOKESTATIC o){
783 		for (int i=0; i<o.getArgumentTypes(cpg).length; i++){
784 			stack().pop();
785 		}
786 		// We are sure the invoked method will xRETURN eventually
787 		// We simulate xRETURNs functionality here because we
788 		// don't really "jump into" and simulate the invoked
789 		// method.
790 		if (o.getReturnType(cpg) != Type.VOID){
791 			Type t = o.getReturnType(cpg);
792 			if (	t.equals(Type.BOOLEAN)	||
793 						t.equals(Type.CHAR)			||
794 						t.equals(Type.BYTE) 		||
795 						t.equals(Type.SHORT)		)
796 				t = Type.INT;
797 			stack().push(t);
798 		}
799 	}
800 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
801 	public void visitINVOKEVIRTUAL(INVOKEVIRTUAL o){
802 		stack().pop(); //objectref
803 		for (int i=0; i<o.getArgumentTypes(cpg).length; i++){
804 			stack().pop();
805 		}
806 		// We are sure the invoked method will xRETURN eventually
807 		// We simulate xRETURNs functionality here because we
808 		// don't really "jump into" and simulate the invoked
809 		// method.
810 		if (o.getReturnType(cpg) != Type.VOID){
811 			Type t = o.getReturnType(cpg);
812 			if (	t.equals(Type.BOOLEAN)	||
813 						t.equals(Type.CHAR)			||
814 						t.equals(Type.BYTE) 		||
815 						t.equals(Type.SHORT)		)
816 				t = Type.INT;
817 			stack().push(t);
818 		}
819 	}
820 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
821 	public void visitIOR(IOR o){
822 		stack().pop();
823 		stack().pop();
824 		stack().push(Type.INT);
825 	}
826 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
827 	public void visitIREM(IREM o){
828 		stack().pop();
829 		stack().pop();
830 		stack().push(Type.INT);
831 	}
832 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
833 	public void visitIRETURN(IRETURN o){
834 		stack().pop();
835 	}
836 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
837 	public void visitISHL(ISHL o){
838 		stack().pop();
839 		stack().pop();
840 		stack().push(Type.INT);
841 	}
842 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
843 	public void visitISHR(ISHR o){
844 		stack().pop();
845 		stack().pop();
846 		stack().push(Type.INT);
847 	}
848 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
849 	public void visitISTORE(ISTORE o){
850 		locals().set(o.getIndex(), stack().pop());
851 	}
852 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
853 	public void visitISUB(ISUB o){
854 		stack().pop();
855 		stack().pop();
856 		stack().push(Type.INT);
857 	}
858 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
859 	public void visitIUSHR(IUSHR o){
860 		stack().pop();
861 		stack().pop();
862 		stack().push(Type.INT);
863 	}
864 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
865 	public void visitIXOR(IXOR o){
866 		stack().pop();
867 		stack().pop();
868 		stack().push(Type.INT);
869 	}
870 
871 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
872 	public void visitJSR(JSR o){
873 		stack().push(new ReturnaddressType(o.physicalSuccessor()));
874 //System.err.println("TODO-----------:"+o.physicalSuccessor());
875 	}
876 
877 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
878 	public void visitJSR_W(JSR_W o){
879 		stack().push(new ReturnaddressType(o.physicalSuccessor()));
880 	}
881 
882 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
883 	public void visitL2D(L2D o){
884 		stack().pop();
885 		stack().push(Type.DOUBLE);
886 	}
887 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
888 	public void visitL2F(L2F o){
889 		stack().pop();
890 		stack().push(Type.FLOAT);
891 	}
892 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
893 	public void visitL2I(L2I o){
894 		stack().pop();
895 		stack().push(Type.INT);
896 	}
897 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
898 	public void visitLADD(LADD o){
899 		stack().pop();
900 		stack().pop();
901 		stack().push(Type.LONG);
902 	}
903 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
904 	public void visitLALOAD(LALOAD o){
905 		stack().pop();
906 		stack().pop();
907 		stack().push(Type.LONG);
908 	}
909 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
910 	public void visitLAND(LAND o){
911 		stack().pop();
912 		stack().pop();
913 		stack().push(Type.LONG);
914 	}
915 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
916 	public void visitLASTORE(LASTORE o){
917 		stack().pop();
918 		stack().pop();
919 		stack().pop();
920 	}
921 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
922 	public void visitLCMP(LCMP o){
923 		stack().pop();
924 		stack().pop();
925 		stack().push(Type.INT);
926 	}
927 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
928 	public void visitLCONST(LCONST o){
929 		stack().push(Type.LONG);
930 	}
931 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
932 	public void visitLDC(LDC o){
933 		Constant c = cpg.getConstant(o.getIndex());
934 		if (c instanceof ConstantInteger){
935 			stack().push(Type.INT);
936 		}
937 		if (c instanceof ConstantFloat){
938 			stack().push(Type.FLOAT);
939 		}
940 		if (c instanceof ConstantString){
941 			stack().push(Type.STRING);
942 		}
943 	}
944 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
945 	public void visitLDC_W(LDC_W o){
946 		Constant c = cpg.getConstant(o.getIndex());
947 		if (c instanceof ConstantInteger){
948 			stack().push(Type.INT);
949 		}
950 		if (c instanceof ConstantFloat){
951 			stack().push(Type.FLOAT);
952 		}
953 		if (c instanceof ConstantString){
954 			stack().push(Type.STRING);
955 		}
956 	}
957 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
958 	public void visitLDC2_W(LDC2_W o){
959 		Constant c = cpg.getConstant(o.getIndex());
960 		if (c instanceof ConstantLong){
961 			stack().push(Type.LONG);
962 		}
963 		if (c instanceof ConstantDouble){
964 			stack().push(Type.DOUBLE);
965 		}
966 	}
967 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
968 	public void visitLDIV(LDIV o){
969 		stack().pop();
970 		stack().pop();
971 		stack().push(Type.LONG);
972 	}
973 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
974 	public void visitLLOAD(LLOAD o){
975 		stack().push(locals().get(o.getIndex()));
976 	}
977 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
978 	public void visitLMUL(LMUL o){
979 		stack().pop();
980 		stack().pop();
981 		stack().push(Type.LONG);
982 	}
983 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
984 	public void visitLNEG(LNEG o){
985 		stack().pop();
986 		stack().push(Type.LONG);
987 	}
988 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
989 	public void visitLOOKUPSWITCH(LOOKUPSWITCH o){
990 		stack().pop(); //key
991 	}
992 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
993 	public void visitLOR(LOR o){
994 		stack().pop();
995 		stack().pop();
996 		stack().push(Type.LONG);
997 	}
998 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
999 	public void visitLREM(LREM o){
1000 		stack().pop();
1001 		stack().pop();
1002 		stack().push(Type.LONG);
1003 	}
1004 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1005 	public void visitLRETURN(LRETURN o){
1006 		stack().pop();
1007 	}
1008 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1009 	public void visitLSHL(LSHL o){
1010 		stack().pop();
1011 		stack().pop();
1012 		stack().push(Type.LONG);
1013 	}
1014 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1015 	public void visitLSHR(LSHR o){
1016 		stack().pop();
1017 		stack().pop();
1018 		stack().push(Type.LONG);
1019 	}
1020 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1021 	public void visitLSTORE(LSTORE o){
1022 		locals().set(o.getIndex(), stack().pop());
1023 		locals().set(o.getIndex()+1, Type.UNKNOWN);		
1024 	}
1025 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1026 	public void visitLSUB(LSUB o){
1027 		stack().pop();
1028 		stack().pop();
1029 		stack().push(Type.LONG);
1030 	}
1031 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1032 	public void visitLUSHR(LUSHR o){
1033 		stack().pop();
1034 		stack().pop();
1035 		stack().push(Type.LONG);
1036 	}
1037 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1038 	public void visitLXOR(LXOR o){
1039 		stack().pop();
1040 		stack().pop();
1041 		stack().push(Type.LONG);
1042 	}
1043 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1044 	public void visitMONITORENTER(MONITORENTER o){
1045 		stack().pop();
1046 	}
1047 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1048 	public void visitMONITOREXIT(MONITOREXIT o){
1049 		stack().pop();
1050 	}
1051 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1052 	public void visitMULTIANEWARRAY(MULTIANEWARRAY o){
1053 		for (int i=0; i<o.getDimensions(); i++){
1054 			stack().pop();
1055 		}
1056 		stack().push(o.getType(cpg));
1057 	}
1058 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1059 	public void visitNEW(NEW o){
1060 		stack().push(new UninitializedObjectType((ObjectType) (o.getType(cpg))));
1061 	}
1062 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1063 	public void visitNEWARRAY(NEWARRAY o){
1064 		stack().pop();
1065 		stack().push(o.getType());
1066 	}
1067 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1068 	public void visitNOP(NOP o){
1069 	}
1070 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1071 	public void visitPOP(POP o){
1072 		stack().pop();
1073 	}
1074 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1075 	public void visitPOP2(POP2 o){
1076 		Type t = stack().pop();
1077 		if (t.getSize() == 1){
1078 			stack().pop();
1079 		}		
1080 	}
1081 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1082 	public void visitPUTFIELD(PUTFIELD o){
1083 		stack().pop();
1084 		stack().pop();
1085 	}
1086 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1087 	public void visitPUTSTATIC(PUTSTATIC o){
1088 		stack().pop();
1089 	}
1090 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1091 	public void visitRET(RET o){
1092 		// do nothing, return address
1093 		// is in in the local variables.
1094 	}
1095 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1096 	public void visitRETURN(RETURN o){
1097 		// do nothing.
1098 	}
1099 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1100 	public void visitSALOAD(SALOAD o){
1101 		stack().pop();
1102 		stack().pop();
1103 		stack().push(Type.INT);
1104 	}
1105 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1106 	public void visitSASTORE(SASTORE o){
1107 		stack().pop();
1108 		stack().pop();
1109 		stack().pop();
1110 	}
1111 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1112 	public void visitSIPUSH(SIPUSH o){
1113 		stack().push(Type.INT);
1114 	}
1115 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1116 	public void visitSWAP(SWAP o){
1117 		Type t = stack().pop();
1118 		Type u = stack().pop();
1119 		stack().push(t);
1120 		stack().push(u);
1121 	}
1122 	/*** Symbolically executes the corresponding Java Virtual Machine instruction. */ 
1123 	public void visitTABLESWITCH(TABLESWITCH o){
1124 		stack().pop();
1125 	}
1126 }
This page was automatically generated by Maven