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.generic.*;
58 import org.apache.bcel.verifier.exc.*;
59 import java.awt.Color;
60 import java.util.ArrayList;
61 import java.util.Enumeration;
62 import java.util.HashSet;
63 import java.util.Hashtable;
64 import java.util.Iterator;
65
66 /***
67 * Instances of this class contain information about the subroutines
68 * found in a code array of a method.
69 * This implementation considers the top-level (the instructions
70 * reachable without a JSR or JSR_W starting off from the first
71 * instruction in a code array of a method) being a special subroutine;
72 * see getTopLevel() for that.
73 * Please note that the definition of subroutines in the Java Virtual
74 * Machine Specification, Second Edition is somewhat incomplete.
75 * Therefore, JustIce uses an own, more rigid notion.
76 * Basically, a subroutine is a piece of code that starts at the target
77 * of a JSR of JSR_W instruction and ends at a corresponding RET
78 * instruction. Note also that the control flow of a subroutine
79 * may be complex and non-linear; and that subroutines may be nested.
80 * JustIce also mandates subroutines not to be protected by exception
81 * handling code (for the sake of control flow predictability).
82 * To understand JustIce's notion of subroutines, please read
83 *
84 * TODO: refer to the paper.
85 *
86 * @version $Id: Subroutines.java,v 1.1.1.1 2001/10/29 20:00:42 jvanzyl Exp $
87 * @author <A HREF="http://www.inf.fu-berlin.de/~ehaase"/>Enver Haase</A>
88 * @see #getTopLevel()
89 */
90 public class Subroutines{
91 /***
92 * This inner class implements the Subroutine interface.
93 */
94 private class SubroutineImpl implements Subroutine{
95 /***
96 * UNSET, a symbol for an uninitialized localVariable
97 * field. This is used for the "top-level" Subroutine;
98 * i.e. no subroutine.
99 */
100 private final int UNSET = -1;
101
102 /***
103 * The Local Variable slot where the first
104 * instruction of this subroutine (an ASTORE) stores
105 * the JsrInstruction's ReturnAddress in and
106 * the RET of this subroutine operates on.
107 */
108 private int localVariable = UNSET;
109
110 /*** The instructions that belong to this subroutine. */
111 private HashSet instructions = new HashSet(); // Elements: InstructionHandle
112
113 /*
114 * Refer to the Subroutine interface for documentation.
115 */
116 public boolean contains(InstructionHandle inst){
117 return instructions.contains(inst);
118 }
119
120 /***
121 * The JSR or JSR_W instructions that define this
122 * subroutine by targeting it.
123 */
124 private HashSet theJSRs = new HashSet();
125
126 /***
127 * The RET instruction that leaves this subroutine.
128 */
129 private InstructionHandle theRET;
130
131 /***
132 * Returns a String representation of this object, merely
133 * for debugging purposes.
134 * (Internal) Warning: Verbosity on a problematic subroutine may cause
135 * stack overflow errors due to recursive subSubs() calls.
136 * Don't use this, then.
137 */
138 public String toString(){
139 String ret = "Subroutine: Local variable is '"+localVariable+"', JSRs are '"+theJSRs+"', RET is '"+theRET+"', Instructions: '"+instructions.toString()+"'.";
140
141 ret += " Accessed local variable slots: '";
142 int[] alv = getAccessedLocalsIndices();
143 for (int i=0; i<alv.length; i++){
144 ret += alv[i]+" ";
145 }
146 ret+="'.";
147
148 ret += " Recursively (via subsub...routines) accessed local variable slots: '";
149 alv = getRecursivelyAccessedLocalsIndices();
150 for (int i=0; i<alv.length; i++){
151 ret += alv[i]+" ";
152 }
153 ret+="'.";
154
155 return ret;
156 }
157
158 /***
159 * Sets the leaving RET instruction. Must be invoked after all instructions are added.
160 * Must not be invoked for top-level 'subroutine'.
161 */
162 void setLeavingRET(){
163 if (localVariable == UNSET){
164 throw new AssertionViolatedException("setLeavingRET() called for top-level 'subroutine' or forgot to set local variable first.");
165 }
166 Iterator iter = instructions.iterator();
167 InstructionHandle ret = null;
168 while(iter.hasNext()){
169 InstructionHandle actual = (InstructionHandle) iter.next();
170 if (actual.getInstruction() instanceof RET){
171 if (ret != null){
172 throw new StructuralCodeConstraintException("Subroutine with more then one RET detected: '"+ret+"' and '"+actual+"'.");
173 }
174 else{
175 ret = actual;
176 }
177 }
178 }
179 if (ret == null){
180 throw new StructuralCodeConstraintException("Subroutine without a RET detected.");
181 }
182 if (((RET) ret.getInstruction()).getIndex() != localVariable){
183 throw new StructuralCodeConstraintException("Subroutine uses '"+ret+"' which does not match the correct local variable '"+localVariable+"'.");
184 }
185 theRET = ret;
186 }
187
188 /*
189 * Refer to the Subroutine interface for documentation.
190 */
191 public InstructionHandle[] getEnteringJsrInstructions(){
192 if (this == TOPLEVEL) {
193 throw new AssertionViolatedException("getLeavingRET() called on top level pseudo-subroutine.");
194 }
195 InstructionHandle[] jsrs = new InstructionHandle[theJSRs.size()];
196 return (InstructionHandle[]) (theJSRs.toArray(jsrs));
197 }
198
199 /***
200 * Adds a new JSR or JSR_W that has this subroutine as its target.
201 */
202 public void addEnteringJsrInstruction(InstructionHandle jsrInst){
203 if ( (jsrInst == null) || (! (jsrInst.getInstruction() instanceof JsrInstruction))){
204 throw new AssertionViolatedException("Expecting JsrInstruction InstructionHandle.");
205 }
206 if (localVariable == UNSET){
207 throw new AssertionViolatedException("Set the localVariable first!");
208 }
209 else{
210 // Something is wrong when an ASTORE is targeted that does not operate on the same local variable than the rest of the
211 // JsrInstruction-targets and the RET.
212 // (We don't know out leader here so we cannot check if we're really targeted!)
213 if (localVariable != ((ASTORE) (((JsrInstruction) jsrInst.getInstruction()).getTarget().getInstruction())).getIndex()){
214 throw new AssertionViolatedException("Setting a wrong JsrInstruction.");
215 }
216 }
217 theJSRs.add(jsrInst);
218 }
219
220 /*
221 * Refer to the Subroutine interface for documentation.
222 */
223 public InstructionHandle getLeavingRET(){
224 if (this == TOPLEVEL) {
225 throw new AssertionViolatedException("getLeavingRET() called on top level pseudo-subroutine.");
226 }
227 return theRET;
228 }
229
230 /*
231 * Refer to the Subroutine interface for documentation.
232 */
233 public InstructionHandle[] getInstructions(){
234 InstructionHandle[] ret = new InstructionHandle[instructions.size()];
235 return (InstructionHandle[]) instructions.toArray(ret);
236 }
237
238 /*
239 * Adds an instruction to this subroutine.
240 * All instructions must have been added before invoking setLeavingRET().
241 * @see #setLeavingRET
242 */
243 void addInstruction(InstructionHandle ih){
244 if (theRET != null){
245 throw new AssertionViolatedException("All instructions must have been added before invoking setLeavingRET().");
246 }
247 instructions.add(ih);
248 }
249
250 /* Satisfies Subroutine.getRecursivelyAccessedLocalsIndices(). */
251 public int[] getRecursivelyAccessedLocalsIndices(){
252 HashSet s = new HashSet();
253 int[] lvs = getAccessedLocalsIndices();
254 for (int j=0; j<lvs.length; j++){
255 s.add(new Integer(lvs[j]));
256 }
257 _getRecursivelyAccessedLocalsIndicesHelper(s, this.subSubs());
258 int[] ret = new int[s.size()];
259 Iterator i = s.iterator();
260 int j=-1;
261 while (i.hasNext()){
262 j++;
263 ret[j] = ((Integer) i.next()).intValue();
264 }
265 return ret;
266 }
267
268 /***
269 * A recursive helper method for getRecursivelyAccessedLocalsIndices().
270 * @see #getRecursivelyAccessedLocalsIndices()
271 */
272 private void _getRecursivelyAccessedLocalsIndicesHelper(HashSet s, Subroutine[] subs){
273 for (int i=0; i<subs.length; i++){
274 int[] lvs = subs[i].getAccessedLocalsIndices();
275 for (int j=0; j<lvs.length; j++){
276 s.add(new Integer(lvs[j]));
277 }
278 if(subs[i].subSubs().length != 0){
279 _getRecursivelyAccessedLocalsIndicesHelper(s, subs[i].subSubs());
280 }
281 }
282 }
283
284 /*
285 * Satisfies Subroutine.getAccessedLocalIndices().
286 */
287 public int[] getAccessedLocalsIndices(){
288 //TODO: Implement caching.
289 HashSet acc = new HashSet();
290 if (theRET == null && this != TOPLEVEL){
291 throw new AssertionViolatedException("This subroutine object must be built up completely before calculating accessed locals.");
292 }
293 Iterator i = instructions.iterator();
294 while (i.hasNext()){
295 InstructionHandle ih = (InstructionHandle) i.next();
296 // RET is not a LocalVariableInstruction in the current version of BCEL.
297 if (ih.getInstruction() instanceof LocalVariableInstruction || ih.getInstruction() instanceof RET){
298 int idx = ((IndexedInstruction) (ih.getInstruction())).getIndex();
299 acc.add(new Integer(idx));
300 // LONG? DOUBLE?.
301 try{
302 // LocalVariableInstruction instances are typed without the need to look into
303 // the constant pool.
304 if (ih.getInstruction() instanceof LocalVariableInstruction){
305 int s = ((LocalVariableInstruction) ih.getInstruction()).getType(null).getSize();
306 if (s==2) acc.add(new Integer(idx+1));
307 }
308 }
309 catch(RuntimeException re){
310 throw new AssertionViolatedException("Oops. BCEL did not like NULL as a ConstantPoolGen object.");
311 }
312 }
313 }
314
315 int[] ret = new int[acc.size()];
316 i = acc.iterator();
317 int j=-1;
318 while (i.hasNext()){
319 j++;
320 ret[j] = ((Integer) i.next()).intValue();
321 }
322 return ret;
323 }
324
325 /*
326 * Satisfies Subroutine.subSubs().
327 */
328 public Subroutine[] subSubs(){
329 HashSet h = new HashSet();
330
331 Iterator i = instructions.iterator();
332 while (i.hasNext()){
333 Instruction inst = ((InstructionHandle) i.next()).getInstruction();
334 if (inst instanceof JsrInstruction){
335 InstructionHandle targ = ((JsrInstruction) inst).getTarget();
336 h.add(getSubroutine(targ));
337 }
338 }
339 Subroutine[] ret = new Subroutine[h.size()];
340 return (Subroutine[]) h.toArray(ret);
341 }
342
343 /*
344 * Sets the local variable slot the ASTORE that is targeted
345 * by the JsrInstructions of this subroutine operates on.
346 * This subroutine's RET operates on that same local variable
347 * slot, of course.
348 */
349 void setLocalVariable(int i){
350 if (localVariable != UNSET){
351 throw new AssertionViolatedException("localVariable set twice.");
352 }
353 else{
354 localVariable = i;
355 }
356 }
357
358 /***
359 * The default constructor.
360 */
361 public SubroutineImpl(){
362 }
363
364 }// end Inner Class SubrouteImpl
365
366 /***
367 * The Hashtable containing the subroutines found.
368 * Key: InstructionHandle of the leader of the subroutine.
369 * Elements: SubroutineImpl objects.
370 */
371 private Hashtable subroutines = new Hashtable();
372
373 /***
374 * This is referring to a special subroutine, namely the
375 * top level. This is not really a subroutine but we use
376 * it to distinguish between top level instructions and
377 * unreachable instructions.
378 */
379 public final Subroutine TOPLEVEL;
380
381 /***
382 * Constructor.
383 * @param il A MethodGen object representing method to
384 * create the Subroutine objects of.
385 */
386 public Subroutines(MethodGen mg){
387
388 InstructionHandle[] all = mg.getInstructionList().getInstructionHandles();
389 CodeExceptionGen[] handlers = mg.getExceptionHandlers();
390
391 // Define our "Toplevel" fake subroutine.
392 TOPLEVEL = new SubroutineImpl();
393
394 // Calculate "real" subroutines.
395 HashSet sub_leaders = new HashSet(); // Elements: InstructionHandle
396 InstructionHandle ih = all[0];
397 for (int i=0; i<all.length; i++){
398 Instruction inst = all[i].getInstruction();
399 if (inst instanceof JsrInstruction){
400 sub_leaders.add(((JsrInstruction) inst).getTarget());
401 }
402 }
403
404 // Build up the database.
405 Iterator iter = sub_leaders.iterator();
406 while (iter.hasNext()){
407 SubroutineImpl sr = new SubroutineImpl();
408 InstructionHandle astore = (InstructionHandle) (iter.next());
409 sr.setLocalVariable( ((ASTORE) (astore.getInstruction())).getIndex() );
410 subroutines.put(astore, sr);
411 }
412
413 // Fake it a bit. We want a virtual "TopLevel" subroutine.
414 subroutines.put(all[0], TOPLEVEL);
415 sub_leaders.add(all[0]);
416
417 // Tell the subroutines about their JsrInstructions.
418 // Note that there cannot be a JSR targeting the top-level
419 // since "Jsr 0" is disallowed in Pass 3a.
420 // Instructions shared by a subroutine and the toplevel are
421 // disallowed and checked below, after the BFS.
422 for (int i=0; i<all.length; i++){
423 Instruction inst = all[i].getInstruction();
424 if (inst instanceof JsrInstruction){
425 InstructionHandle leader = ((JsrInstruction) inst).getTarget();
426 ((SubroutineImpl) getSubroutine(leader)).addEnteringJsrInstruction(all[i]);
427 }
428 }
429
430 // Now do a BFS from every subroutine leader to find all the
431 // instructions that belong to a subroutine.
432 HashSet instructions_assigned = new HashSet(); // we don't want to assign an instruction to two or more Subroutine objects.
433
434 Hashtable colors = new Hashtable(); //Graph colouring. Key: InstructionHandle, Value: java.awt.Color .
435
436 iter = sub_leaders.iterator();
437 while (iter.hasNext()){
438 // Do some BFS with "actual" as the root of the graph.
439 InstructionHandle actual = (InstructionHandle) (iter.next());
440 // Init colors
441 for (int i=0; i<all.length; i++){
442 colors.put(all[i], Color.white);
443 }
444 colors.put(actual, Color.gray);
445 // Init Queue
446 ArrayList Q = new ArrayList();
447 Q.add(actual); // add(Obj) adds to the end, remove(0) removes from the start.
448
449 /* BFS ALGORITHM MODIFICATION: Start out with multiple "root" nodes, as exception handlers are starting points of top-level code, too. [why top-level? TODO: Refer to the special JustIce notion of subroutines.]*/
450 if (actual == all[0]){
451 for (int j=0; j<handlers.length; j++){
452 colors.put(handlers[j].getHandlerPC(), Color.gray);
453 Q.add(handlers[j].getHandlerPC());
454 }
455 }
456 /* CONTINUE NORMAL BFS ALGORITHM */
457
458 // Loop until Queue is empty
459 while (Q.size() != 0){
460 InstructionHandle u = (InstructionHandle) Q.remove(0);
461 InstructionHandle[] successors = getSuccessors(u);
462 for (int i=0; i<successors.length; i++){
463 if (((Color) colors.get(successors[i])) == Color.white){
464 colors.put(successors[i], Color.gray);
465 Q.add(successors[i]);
466 }
467 }
468 colors.put(u, Color.black);
469 }
470 // BFS ended above.
471 for (int i=0; i<all.length; i++){
472 if (colors.get(all[i]) == Color.black){
473 ((SubroutineImpl) (actual==all[0]?getTopLevel():getSubroutine(actual))).addInstruction(all[i]);
474 if (instructions_assigned.contains(all[i])){
475 throw new StructuralCodeConstraintException("Instruction '"+all[i]+"' is part of more than one subroutine (or of the top level and a subroutine).");
476 }
477 else{
478 instructions_assigned.add(all[i]);
479 }
480 }
481 }
482 if (actual != all[0]){// If we don't deal with the top-level 'subroutine'
483 ((SubroutineImpl) getSubroutine(actual)).setLeavingRET();
484 }
485 }
486
487 // Now make sure no instruction of a Subroutine is protected by exception handling code
488 // as is mandated by JustIces notion of subroutines.
489 for (int i=0; i<handlers.length; i++){
490 InstructionHandle _protected = handlers[i].getStartPC();
491 while (_protected != handlers[i].getEndPC().getNext()){// Note the inclusive/inclusive notation of "generic API" exception handlers!
492 Enumeration subs = subroutines.elements();
493 while (subs.hasMoreElements()){
494 Subroutine sub = (Subroutine) subs.nextElement();
495 if (sub != subroutines.get(all[0])){ // We don't want to forbid top-level exception handlers.
496 if (sub.contains(_protected)){
497 throw new StructuralCodeConstraintException("Subroutine instruction '"+_protected+"' is protected by an exception handler, '"+handlers[i]+"'. This is forbidden by the JustIce verifier due to its clear definition of subroutines.");
498 }
499 }
500 }
501 _protected = _protected.getNext();
502 }
503 }
504
505 // Now make sure no subroutine is calling a subroutine
506 // that uses the same local variable for the RET as themselves
507 // (recursively).
508 // This includes that subroutines may not call themselves
509 // recursively, even not through intermediate calls to other
510 // subroutines.
511 noRecursiveCalls(getTopLevel(), new HashSet());
512
513 }
514
515 /***
516 * This (recursive) utility method makes sure that
517 * no subroutine is calling a subroutine
518 * that uses the same local variable for the RET as themselves
519 * (recursively).
520 * This includes that subroutines may not call themselves
521 * recursively, even not through intermediate calls to other
522 * subroutines.
523 *
524 * @throws StructuralCodeConstraintException if the above constraint is not satisfied.
525 */
526 private void noRecursiveCalls(Subroutine sub, HashSet set){
527 Subroutine[] subs = sub.subSubs();
528
529 for (int i=0; i<subs.length; i++){
530 int index = ((RET) (subs[i].getLeavingRET().getInstruction())).getIndex();
531
532 if (!set.add(new Integer(index))){
533 // Don't use toString() here because of possibly infinite recursive subSubs() calls then.
534 SubroutineImpl si = (SubroutineImpl) subs[i];
535 throw new StructuralCodeConstraintException("Subroutine with local variable '"+si.localVariable+"', JSRs '"+si.theJSRs+"', RET '"+si.theRET+"' is called by a subroutine which uses the same local variable index as itself; maybe even a recursive call? JustIce's clean definition of a subroutine forbids both.");
536 }
537
538 noRecursiveCalls(subs[i], set);
539
540 set.remove(new Integer(index));
541 }
542 }
543
544 /***
545 * Returns the Subroutine object associated with the given
546 * leader (that is, the first instruction of the subroutine).
547 * You must not use this to get the top-level instructions
548 * modeled as a Subroutine object.
549 *
550 * @see #getTopLevel()
551 */
552 public Subroutine getSubroutine(InstructionHandle leader){
553 Subroutine ret = (Subroutine) subroutines.get(leader);
554
555 if (ret == null){
556 throw new AssertionViolatedException("Subroutine requested for an InstructionHandle that is not a leader of a subroutine.");
557 }
558
559 if (ret == TOPLEVEL){
560 throw new AssertionViolatedException("TOPLEVEL special subroutine requested; use getTopLevel().");
561 }
562
563 return ret;
564 }
565
566 /***
567 * Returns the subroutine object associated with the
568 * given instruction. This is a costly operation, you
569 * should consider using getSubroutine(InstructionHandle).
570 * Returns 'null' if the given InstructionHandle lies
571 * in so-called 'dead code', i.e. code that can never
572 * be executed.
573 *
574 * @see #getSubroutine(InstructionHandle)
575 * @see #getTopLevel()
576 */
577 public Subroutine subroutineOf(InstructionHandle any){
578 Iterator i = subroutines.values().iterator();
579 while (i.hasNext()){
580 Subroutine s = (Subroutine) i.next();
581 if (s.contains(any)) return s;
582 }
583 System.err.println("DEBUG: Please verify '"+any+"' lies in dead code.");
584 return null;
585 //throw new AssertionViolatedException("No subroutine for InstructionHandle found (DEAD CODE?).");
586 }
587
588 /***
589 * For easy handling, the piece of code that is <B>not</B> a
590 * subroutine, the top-level, is also modeled as a Subroutine
591 * object.
592 * It is a special Subroutine object where <B>you must not invoke
593 * getEnteringJsrInstructions() or getLeavingRET()</B>.
594 *
595 * @see Subroutine#getEnteringJsrInstructions()
596 * @see Subroutine#getLeavingRET()
597 */
598 public Subroutine getTopLevel(){
599 return TOPLEVEL;
600 }
601 /***
602 * A utility method that calculates the successors of a given InstructionHandle
603 * <B>in the same subroutine</B>. That means, a RET does not have any successors
604 * as defined here. A JsrInstruction has its physical successor as its successor
605 * (opposed to its target) as defined here.
606 */
607 private static InstructionHandle[] getSuccessors(InstructionHandle instruction){
608 final InstructionHandle[] empty = new InstructionHandle[0];
609 final InstructionHandle[] single = new InstructionHandle[1];
610 final InstructionHandle[] pair = new InstructionHandle[2];
611
612 Instruction inst = instruction.getInstruction();
613
614 if (inst instanceof RET){
615 return empty;
616 }
617
618 // Terminates method normally.
619 if (inst instanceof ReturnInstruction){
620 return empty;
621 }
622
623 // Terminates method abnormally, because JustIce mandates
624 // subroutines not to be protected by exception handlers.
625 if (inst instanceof ATHROW){
626 return empty;
627 }
628
629 // See method comment.
630 if (inst instanceof JsrInstruction){
631 single[0] = instruction.getNext();
632 return single;
633 }
634
635 if (inst instanceof GotoInstruction){
636 single[0] = ((GotoInstruction) inst).getTarget();
637 return single;
638 }
639
640 if (inst instanceof BranchInstruction){
641 if (inst instanceof Select){
642 // BCEL's getTargets() returns only the non-default targets,
643 // thanks to Eli Tilevich for reporting.
644 InstructionHandle[] matchTargets = ((Select) inst).getTargets();
645 InstructionHandle[] ret = new InstructionHandle[matchTargets.length+1];
646 ret[0] = ((Select) inst).getTarget();
647 System.arraycopy(matchTargets, 0, ret, 1, matchTargets.length);
648 return ret;
649 }
650 else{
651 pair[0] = instruction.getNext();
652 pair[1] = ((BranchInstruction) inst).getTarget();
653 return pair;
654 }
655 }
656
657 // default case: Fall through.
658 single[0] = instruction.getNext();
659 return single;
660 }
661
662 /***
663 * Returns a String representation of this object; merely for debugging puposes.
664 */
665 public String toString(){
666 return "---\n"+subroutines.toString()+"\n---\n";
667 }
668 }
This page was automatically generated by Maven