    View Javadoc
    1   package org.apache.bcel.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
    57  import org.apache.bcel.Constants;
    58  import org.apache.bcel.classfile.Constant;
    59  import org.apache.bcel.util.ByteSequence;
    60  import java.io.*;
    61  import java.util.Iterator;
    62  import java.util.HashMap;
    63  import java.util.ArrayList;
    64
    65  /***
    66   * This class is a container for a list of <a
    67   * href="Instruction.html">Instruction</a> objects. Instructions can
    68   * be appended, inserted, moved, deleted, etc.. Instructions are being
    69   * wrapped into <a
    70   * href="InstructionHandle.html">InstructionHandles</a> objects that
    71   * are returned upon append/insert operations. They give the user
    72   * (read only) access to the list structure, such that it can be traversed and
    73   * manipulated in a controlled way.
    74   *
    75   * A list is finally dumped to a byte code array with <a
    76   * href="#getByteCode()">getByteCode</a>.
    77   *
    78   * @version $Id: InstructionList.java,v 1.2 2002/03/11 16:16:38 mdahm Exp $
    79   * @author  <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
    80   * @see     Instruction
    81   * @see     InstructionHandle
    82   * @see BranchHandle
    83   */
    84  public class InstructionList implements Serializable {
    85    private InstructionHandle start  = null, end = null;
    86    private int               length = 0; // number of elements in list
    87    private int[]             byte_positions; // byte code offsets corresponding to instructions
    88
    89    /***
    90     * Create (empty) instruction list.
    91     */
    92    public InstructionList() {}
    93
    94    /***
    95     * Create instruction list containing one instruction.
    96     * @param i initial instruction
    97     */
    98    public InstructionList(Instruction i) {
    99      append(i);
    100   }
    101
    102   /***
    103    * Create instruction list containing one instruction.
    104    * @param i initial instruction
    105    */
    106   public InstructionList(BranchInstruction i) {
    107     append(i);
    108   }
    109
    110   /***
    111    * Initialize list with (nonnull) compound instruction. Consumes argument
    112    * list, i.e., it becomes empty.
    113    *
    114    * @param c compound instruction (list)
    115    */
    116   public InstructionList(CompoundInstruction c) {
    117     append(c.getInstructionList());
    118   }
    119
    120   /***
    121    * Test for empty list.
    122    */
    123   public boolean isEmpty() { return start == null; } // && end == null
    124
    125   /***
    126    * Find the target instruction (handle) that corresponds to the given target
    127    * position (byte code offset).
    128    *
    129    * @param ihs array of instruction handles, i.e. il.getInstructionHandles()
    130    * @param pos array of positions corresponding to ihs, i.e. il.getInstructionPositions()
    131    * @param count length of arrays
    132    * @param target target position to search for
    133    * @return target position's instruction handle if available
    134    */
    135   public static InstructionHandle findHandle(InstructionHandle[] ihs,
    136 					     int[] pos, int count,
    137 					     int target) {
    138     int l=0, r = count - 1;
    139
    140     /* Do a binary search since the pos array is orderd.
    141      */
    142     do {
    143       int i = (l + r) / 2;
    144       int j = pos[i];
    145
    146       if(j == target) // target found
    147  	return ihs[i];
    148       else if(target < j) // else constrain search area
    149 	r = i - 1;
    150       else // target > j
    151 	l = i + 1;
    152     } while(l <= r);
    153
    154     return null;
    155   }
    156
    157   /***
    158    * Get instruction handle for instruction at byte code position pos.
    159    * This only works properly, if the list is freshly initialized from a byte array or
    160    * setPositions() has been called before this method.
    161    *
    162    * @param pos byte code position to search for
    163    * @return target position's instruction handle if available
    164    */
    165   public InstructionHandle findHandle(int pos) {
    166     InstructionHandle[] ihs = getInstructionHandles();
    167     return findHandle(ihs, byte_positions, length, pos);
    168   }
    169
    170   /***
    171    * Initialize instruction list from byte array.
    172    *
    173    * @param code byte array containing the instructions
    174    */
    175   public InstructionList(byte[] code) {
    176     ByteSequence        bytes = new ByteSequence(code);
    177     InstructionHandle[] ihs   = new InstructionHandle[code.length];
    178     int[]               pos   = new int[code.length]; // Can't be more than that
    179     int                 count = 0; // Contains actual length
    180
    181     /* Pass 1: Create an object for each byte code and append them
    182      * to the list.
    183      */
    184     try {
    185       while(bytes.available() > 0) {
    186 	// Remember byte offset and associate it with the instruction
    187 	int off =  bytes.getIndex();
    188 	pos[count] = off;
    189
    190 	/* Read one instruction from the byte stream, the byte position is set
    191 	 * accordingly.
    192 	 */
    193 	Instruction       i = Instruction.readInstruction(bytes);
    194 	InstructionHandle ih;
    195 	if(i instanceof BranchInstruction) // Use proper append() method
    196 	  ih = append((BranchInstruction)i);
    197 	else
    198 	  ih = append(i);
    199
    200 	ih.setPosition(off);
    201 	ihs[count] = ih;
    202
    203 	count++;
    204       }
    205     } catch(IOException e) { throw new ClassGenException(e.toString()); }
    206
    207     byte_positions = new int[count]; // Trim to proper size
    208     System.arraycopy(pos, 0, byte_positions, 0, count);
    209
    210     /* Pass 2: Look for BranchInstruction and update their targets, i.e.,
    211      * convert offsets to instruction handles.
    212      */
    213     for(int i=0; i < count; i++) {
    214       if(ihs[i] instanceof BranchHandle) {
    215 	BranchInstruction bi = (BranchInstruction)ihs[i].instruction;
    216 	int target = bi.position + bi.getIndex(); /* Byte code position:
    217 						   * relative -> absolute. */
    218 	// Search for target position
    219 	InstructionHandle ih = findHandle(ihs, pos, count, target);
    220
    221 	if(ih == null) // Search failed
    222 	  throw new ClassGenException("Couldn't find target for branch: " + bi);
    223
    224 	bi.setTarget(ih); // Update target
    225
    226 	// If it is a Select instruction, update all branch targets
    227 	if(bi instanceof Select) { // Either LOOKUPSWITCH or TABLESWITCH
    228           Select s       = (Select)bi;
    229           int[]  indices = s.getIndices();
    230
    231 	  for(int j=0; j < indices.length; j++) {
    232 	    target = bi.position + indices[j];
    233 	    ih     = findHandle(ihs, pos, count, target);
    234
    235 	    if(ih == null) // Search failed
    236 	      throw new ClassGenException("Couldn't find target for switch: " + bi);
    237
    238 	    s.setTarget(j, ih); // Update target
    239 	  }
    240 	}
    241       }
    242     }
    243   }
    244
    245   /***
    246    * Append another list after instruction (handle) ih contained in this list.
    247    * Consumes argument list, i.e., it becomes empty.
    248    *
    249    * @param ih where to append the instruction list
    250    * @param il Instruction list to append to this one
    251    * @return instruction handle pointing to the <B>first</B> appended instruction
    252    */
    253   public InstructionHandle append(InstructionHandle ih, InstructionList il) {
    254     if(il == null)
    255       throw new ClassGenException("Appending null InstructionList");
    256
    257     if(il.isEmpty()) // Nothing to do
    258       return ih;
    259
    260     InstructionHandle next = ih.next, ret = il.start;
    261
    262     ih.next = il.start;
    263     il.start.prev = ih;
    264
    265     il.end.next = next;
    266
    267     if(next != null) // i == end ?
    268       next.prev = il.end;
    269     else
    270       end = il.end; // Update end ...
    271
    272     length += il.length; // Update length
    273
    274     il.clear();
    275
    276     return ret;
    277   }
    278
    279   /***
    280    * Append another list after instruction i contained in this list.
    281    * Consumes argument list, i.e., it becomes empty.
    282    *
    283    * @param i  where to append the instruction list
    284    * @param il Instruction list to append to this one
    285    * @return instruction handle pointing to the <B>first</B> appended instruction
    286    */
    287   public InstructionHandle append(Instruction i, InstructionList il) {
    288     InstructionHandle ih;
    289
    290     if((ih = findInstruction2(i)) == null) // Also applies for empty list
    291       throw new ClassGenException("Instruction " + i +
    292 				  " is not contained in this list.");
    293
    294     return append(ih, il);
    295   }
    296
    297   /***
    298    * Append another list to this one.
    299    * Consumes argument list, i.e., it becomes empty.
    300    *
    301    * @param il list to append to end of this list
    302    * @return instruction handle of the <B>first</B> appended instruction
    303    */
    304   public InstructionHandle append(InstructionList il) {
    305     if(il == null)
    306       throw new ClassGenException("Appending null InstructionList");
    307
    308     if(il.isEmpty()) // Nothing to do
    309       return null;
    310
    311     if(isEmpty()) {
    312       start  = il.start;
    313       end    = il.end;
    314       length = il.length;
    315
    316       il.clear();
    317
    318       return start;
    319     } else
    320       return append(end, il);  // was end.instruction
    321   }
    322
    323   /***
    324    * Append an instruction to the end of this list.
    325    *
    326    * @param ih instruction to append
    327    */
    328   private void append(InstructionHandle ih) {
    329     if(isEmpty()) {
    330       start = end = ih;
    331       ih.next = ih.prev = null;
    332     }
    333     else {
    334       end.next = ih;
    335       ih.prev  = end;
    336       ih.next  = null;
    337       end      = ih;
    338     }
    339
    340     length++; // Update length
    341   }
    342
    343   /***
    344    * Append an instruction to the end of this list.
    345    *
    346    * @param i instruction to append
    347    * @return instruction handle of the appended instruction
    348    */
    349   public InstructionHandle append(Instruction i) {
    350     InstructionHandle ih = InstructionHandle.getInstructionHandle(i);
    351     append(ih);
    352
    353     return ih;
    354   }
    355
    356   /***
    357    * Append a branch instruction to the end of this list.
    358    *
    359    * @param i branch instruction to append
    360    * @return branch instruction handle of the appended instruction
    361    */
    362   public BranchHandle append(BranchInstruction i) {
    363     BranchHandle ih = BranchHandle.getBranchHandle(i);
    364     append(ih);
    365
    366     return ih;
    367   }
    368
    369   /***
    370    * Append a single instruction j after another instruction i, which
    371    * must be in this list of course!
    372    *
    373    * @param i Instruction in list
    374    * @param j Instruction to append after i in list
    375    * @return instruction handle of the first appended instruction
    376    */
    377   public InstructionHandle append(Instruction i, Instruction j) {
    378     return append(i, new InstructionList(j));
    379   }
    380
    381   /***
    382    * Append a compound instruction, after instruction i.
    383    *
    384    * @param i Instruction in list
    385    * @param c The composite instruction (containing an InstructionList)
    386    * @return instruction handle of the first appended instruction
    387    */
    388   public InstructionHandle append(Instruction i, CompoundInstruction c) {
    389     return append(i, c.getInstructionList());
    390   }
    391
    392   /***
    393    * Append a compound instruction.
    394    *
    395    * @param c The composite instruction (containing an InstructionList)
    396    * @return instruction handle of the first appended instruction
    397    */
    398   public InstructionHandle append(CompoundInstruction c) {
    399     return append(c.getInstructionList());
    400   }
    401
    402   /***
    403    * Append a compound instruction.
    404    *
    405    * @param ih where to append the instruction list
    406    * @param c The composite instruction (containing an InstructionList)
    407    * @return instruction handle of the first appended instruction
    408    */
    409   public InstructionHandle append(InstructionHandle ih, CompoundInstruction c) {
    410     return append(ih, c.getInstructionList());
    411   }
    412
    413   /***
    414    * Append an instruction after instruction (handle) ih contained in this list.
    415    *
    416    * @param ih where to append the instruction list
    417    * @param i Instruction to append
    418    * @return instruction handle pointing to the <B>first</B> appended instruction
    419    */
    420   public InstructionHandle append(InstructionHandle ih, Instruction i) {
    421     return append(ih, new InstructionList(i));
    422   }
    423
    424   /***
    425    * Append an instruction after instruction (handle) ih contained in this list.
    426    *
    427    * @param ih where to append the instruction list
    428    * @param i Instruction to append
    429    * @return instruction handle pointing to the <B>first</B> appended instruction
    430    */
    431   public BranchHandle append(InstructionHandle ih, BranchInstruction i) {
    432     BranchHandle    bh = BranchHandle.getBranchHandle(i);
    433     InstructionList il = new InstructionList();
    434     il.append(bh);
    435
    436     append(ih, il);
    437
    438     return bh;
    439   }
    440
    441   /***
    442    * Insert another list before Instruction handle ih contained in this list.
    443    * Consumes argument list, i.e., it becomes empty.
    444    *
    445    * @param i  where to append the instruction list
    446    * @param il Instruction list to insert
    447    * @return instruction handle of the first inserted instruction
    448    */
    449   public InstructionHandle insert(InstructionHandle ih, InstructionList il) {
    450     if(il == null)
    451       throw new ClassGenException("Inserting null InstructionList");
    452
    453     if(il.isEmpty()) // Nothing to do
    454       return ih;
    455
    456     InstructionHandle prev = ih.prev, ret = il.start;
    457
    458     ih.prev = il.end;
    459     il.end.next = ih;
    460
    461     il.start.prev = prev;
    462
    463     if(prev != null) // ih == start ?
    464       prev.next = il.start;
    465     else
    466       start = il.start; // Update start ...
    467
    468     length += il.length; // Update length
    469
    470     il.clear();
    471
    472     return ret;
    473   }
    474
    475   /***
    476    * Insert another list.
    477    *
    478    * @param il list to insert before start of this list
    479    * @return instruction handle of the first inserted instruction
    480    */
    481   public InstructionHandle insert(InstructionList il) {
    482     if(isEmpty()) {
    483       append(il); // Code is identical for this case
    484       return start;
    485     }
    486     else
    487       return insert(start, il);
    488   }
    489
    490   /***
    491    * Insert an instruction at start of this list.
    492    *
    493    * @param ih instruction to insert
    494    */
    495   private void insert(InstructionHandle ih) {
    496     if(isEmpty()) {
    497       start = end = ih;
    498       ih.next = ih.prev = null;
    499     } else {
    500       start.prev = ih;
    501       ih.next    = start;
    502       ih.prev    = null;
    503       start      = ih;
    504     }
    505
    506     length++;
    507   }
    508
    509   /***
    510    * Insert another list before Instruction i contained in this list.
    511    * Consumes argument list, i.e., it becomes empty.
    512    *
    513    * @param i  where to append the instruction list
    514    * @param il Instruction list to insert
    515    * @return instruction handle pointing to the first inserted instruction,
    516    * i.e., il.getStart()
    517    */
    518   public InstructionHandle insert(Instruction i, InstructionList il) {
    519     InstructionHandle ih;
    520
    521     if((ih = findInstruction1(i)) == null)
    522       throw new ClassGenException("Instruction " + i +
    523 				  " is not contained in this list.");
    524
    525     return insert(ih, il);
    526   }
    527
    528   /***
    529    * Insert an instruction at start of this list.
    530    *
    531    * @param i instruction to insert
    532    * @return instruction handle of the inserted instruction
    533    */
    534   public InstructionHandle insert(Instruction i) {
    535     InstructionHandle ih = InstructionHandle.getInstructionHandle(i);
    536     insert(ih);
    537
    538     return ih;
    539   }
    540
    541   /***
    542    * Insert a branch instruction at start of this list.
    543    *
    544    * @param i branch instruction to insert
    545    * @return branch instruction handle of the appended instruction
    546    */
    547   public BranchHandle insert(BranchInstruction i) {
    548     BranchHandle ih = BranchHandle.getBranchHandle(i);
    549     insert(ih);
    550     return ih;
    551   }
    552
    553   /***
    554    * Insert a single instruction j before another instruction i, which
    555    * must be in this list of course!
    556    *
    557    * @param i Instruction in list
    558    * @param j Instruction to insert before i in list
    559    * @return instruction handle of the first inserted instruction
    560    */
    561   public InstructionHandle insert(Instruction i, Instruction j) {
    562     return insert(i, new InstructionList(j));
    563   }
    564
    565   /***
    566    * Insert a compound instruction before instruction i.
    567    *
    568    * @param i Instruction in list
    569    * @param c The composite instruction (containing an InstructionList)
    570    * @return instruction handle of the first inserted instruction
    571    */
    572   public InstructionHandle insert(Instruction i, CompoundInstruction c) {
    573     return insert(i, c.getInstructionList());
    574   }
    575
    576   /***
    577    * Insert a compound instruction.
    578    *
    579    * @param c The composite instruction (containing an InstructionList)
    580    * @return instruction handle of the first inserted instruction
    581    */
    582   public InstructionHandle insert(CompoundInstruction c) {
    583     return insert(c.getInstructionList());
    584   }
    585
    586   /***
    587    * Insert an instruction before instruction (handle) ih contained in this list.
    588    *
    589    * @param ih where to insert to the instruction list
    590    * @param i Instruction to insert
    591    * @return instruction handle of the first inserted instruction
    592    */
    593   public InstructionHandle insert(InstructionHandle ih, Instruction i) {
    594     return insert(ih, new InstructionList(i));
    595   }
    596
    597   /***
    598    * Insert a compound instruction.
    599    *
    600    * @param ih where to insert the instruction list
    601    * @param c The composite instruction (containing an InstructionList)
    602    * @return instruction handle of the first inserted instruction
    603    */
    604   public InstructionHandle insert(InstructionHandle ih, CompoundInstruction c) {
    605     return insert(ih, c.getInstructionList());
    606   }
    607
    608   /***
    609    * Insert an instruction before instruction (handle) ih contained in this list.
    610    *
    611    * @param ih where to insert to the instruction list
    612    * @param i Instruction to insert
    613    * @return instruction handle of the first inserted instruction
    614    */
    615   public BranchHandle insert(InstructionHandle ih, BranchInstruction i) {
    616     BranchHandle    bh = BranchHandle.getBranchHandle(i);
    617     InstructionList il = new InstructionList();
    618     il.append(bh);
    619
    620     insert(ih, il);
    621
    622     return bh;
    623   }
    624
    625   /***
    626    * Take all instructions (handles) from "start" to "end" and append them after the
    627    * new location "target". Of course, "end" must be after "start" and target must
    628    * not be located withing this range. If you want to move something to the start of
    629    * the list use null as value for target.<br>
    630    * Any instruction targeters pointing to handles within the block, keep their targets.
    631    *
    632    * @param start  of moved block
    633    * @param end    of moved block
    634    * @param target of moved block
    635    */
    636   public void move(InstructionHandle start, InstructionHandle end, InstructionHandle target) {
    637     // Step 1: Check constraints
    638
    639     if((start == null) || (end == null))
    640       throw new ClassGenException("Invalid null handle: From " + start + " to " + end);
    641
    642     if((target == start) || (target == end))
    643       throw new ClassGenException("Invalid range: From " + start + " to " + end +
    644 				  " contains target " + target);
    645
    646     for(InstructionHandle ih = start; ih != end.next; ih = ih.next) {
    647       if(ih == null) // At end of list, end not found yet
    648 	throw new ClassGenException("Invalid range: From " + start + " to " + end);
    649       else if(ih == target) // target may be null
    650 	throw new ClassGenException("Invalid range: From " + start + " to " + end +
    651 				    " contains target " + target);
    652     }
    653
    654     // Step 2: Temporarily remove the given instructions from the list
    655
    656     InstructionHandle prev = start.prev, next = end.next;
    657
    658     if(prev != null)
    659       prev.next = next;
    660     else // start == this.start!
    661       this.start = next;
    662
    663     if(next != null)
    664       next.prev = prev;
    665     else // end == this.end!
    666       this.end = prev;
    667
    668     start.prev = end.next = null;
    669
    670     // Step 3: append after target
    671
    672     if(target == null) { // append to start of list
    673       end.next = this.start;
    674       this.start = start;
    675     } else {
    676       next = target.next;
    677
    678       target.next = start;
    679       start.prev  = target;
    680       end.next    = next;
    681
    682       if(next != null)
    683 	next.prev = end;
    684     }
    685   }
    686
    687   /***
    688    * Move a single instruction (handle) to a new location.
    689    *
    690    * @param ih     moved instruction
    691    * @param target new location of moved instruction
    692    */
    693   public void move(InstructionHandle ih, InstructionHandle target) {
    694     move(ih, ih, target);
    695   }
    696
    697   /***
    698    * Remove from instruction `prev' to instruction `next' both contained
    699    * in this list. Throws TargetLostException when one of the removed instruction handles
    700    * is still being targeted.
    701    *
    702    * @param prev where to start deleting (predecessor, exclusive)
    703    * @param next where to end deleting (successor, exclusive)
    704    */
    705   private void remove(InstructionHandle prev, InstructionHandle next)
    706     throws TargetLostException
    707   {
    708     InstructionHandle first, last; // First and last deleted instruction
    709
    710     if((prev == null) && (next == null)) { // singleton list
    711       first = last = start;
    712       start = end = null;
    713     } else {
    714       if(prev == null) { // At start of list
    715 	first = start;
    716 	start = next;
    717       } else {
    718 	first     = prev.next;
    719 	prev.next = next;
    720       }
    721
    722       if(next == null) { // At end of list
    723 	last = end;
    724 	end  = prev;
    725       } else {
    726 	last      = next.prev;
    727 	next.prev = prev;
    728       }
    729     }
    730
    731     first.prev = null; // Completely separated from rest of list
    732     last.next  = null;
    733
    734     ArrayList target_vec = new ArrayList();
    735
    736     for(InstructionHandle ih=first; ih != null; ih = ih.next)
    737       ih.getInstruction().dispose(); // e.g. BranchInstructions release their targets
    738
    739     StringBuffer buf = new StringBuffer("{ ");
    740     for(InstructionHandle ih=first; ih != null; ih = next) {
    741       next = ih.next;
    742       length--;
    743
    744       if(ih.hasTargeters()) { // Still got targeters?
    745 	target_vec.add(ih);
    746 	buf.append(ih.toString(true) + " ");
    747 	ih.next = ih.prev = null;
    748       } else
    749 	ih.dispose();
    750     }
    751
    752     buf.append("}");
    753
    754     if(!target_vec.isEmpty()) {
    755       InstructionHandle[] targeted = new InstructionHandle[target_vec.size()];
    756       target_vec.toArray(targeted);
    757       throw new TargetLostException(targeted, buf.toString());
    758     }
    759   }
    760
    761   /***
    762    * Remove instruction from this list. The corresponding Instruction
    763    * handles must not be reused!
    764    *
    765    * @param ih instruction (handle) to remove
    766    */
    767   public void delete(InstructionHandle ih) throws TargetLostException {
    768     remove(ih.prev, ih.next);
    769   }
    770
    771   /***
    772    * Remove instruction from this list. The corresponding Instruction
    773    * handles must not be reused!
    774    *
    775    * @param i instruction to remove
    776    */
    777   public void delete(Instruction i) throws TargetLostException {
    778     InstructionHandle ih;
    779
    780     if((ih = findInstruction1(i)) == null)
    781       throw new ClassGenException("Instruction " + i +
    782 				  " is not contained in this list.");
    783     delete(ih);
    784   }
    785
    786   /***
    787    * Remove instructions from instruction `from' to instruction `to' contained
    788    * in this list. The user must ensure that `from' is an instruction before
    789    * `to', or risk havoc. The corresponding Instruction handles must not be reused!
    790    *
    791    * @param from where to start deleting (inclusive)
    792    * @param to   where to end deleting (inclusive)
    793    */
    794   public void delete(InstructionHandle from, InstructionHandle to)
    795     throws TargetLostException
    796   {
    797     remove(from.prev, to.next);
    798   }
    799
    800   /***
    801    * Remove instructions from instruction `from' to instruction `to' contained
    802    * in this list. The user must ensure that `from' is an instruction before
    803    * `to', or risk havoc. The corresponding Instruction handles must not be reused!
    804    *
    805    * @param from where to start deleting (inclusive)
    806    * @param to   where to end deleting (inclusive)
    807    */
    808   public void delete(Instruction from, Instruction to) throws TargetLostException {
    809     InstructionHandle from_ih, to_ih;
    810
    811     if((from_ih = findInstruction1(from)) == null)
    812       throw new ClassGenException("Instruction " + from +
    813 				  " is not contained in this list.");
    814
    815     if((to_ih = findInstruction2(to)) == null)
    816       throw new ClassGenException("Instruction " + to +
    817 				  " is not contained in this list.");
    818     delete(from_ih, to_ih);
    819   }
    820
    821   /***
    822    * Search for given Instruction reference, start at beginning of list.
    823    *
    824    * @param i instruction to search for
    825    * @return instruction found on success, null otherwise
    826    */
    827   private InstructionHandle findInstruction1(Instruction i) {
    828     for(InstructionHandle ih=start; ih != null; ih = ih.next)
    829       if(ih.instruction == i)
    830 	return ih;
    831
    832     return null;
    833   }
    834
    835   /***
    836    * Search for given Instruction reference, start at end of list
    837    *
    838    * @param i instruction to search for
    839    * @return instruction found on success, null otherwise
    840    */
    841   private InstructionHandle findInstruction2(Instruction i) {
    842     for(InstructionHandle ih=end; ih != null; ih = ih.prev)
    843       if(ih.instruction == i)
    844 	return ih;
    845
    846     return null;
    847   }
    848
    849   public boolean contains(InstructionHandle i) {
    850     if(i == null)
    851       return false;
    852
    853     for(InstructionHandle ih=start; ih != null; ih = ih.next)
    854       if(ih == i)
    855 	return true;
    856
    857     return false;
    858   }
    859
    860   public boolean contains(Instruction i) {
    861     return findInstruction1(i) != null;
    862   }
    863
    864   public void setPositions() {
    865     setPositions(false);
    866   }
    867
    868   /***
    869    * Give all instructions their position number (offset in byte stream), i.e.,
    870    * make the list ready to be dumped.
    871    *
    872    * @param check Perform sanity checks, e.g. if all targeted instructions really belong
    873    * to this list
    874    */
    875   public void setPositions(boolean check) {
    876     int max_additional_bytes = 0, additional_bytes = 0;
    877     int index = 0, count = 0;
    878     int[] pos = new int[length];
    879
    880     /* Pass 0: Sanity checks
    881      */
    882     if(check) {
    883       for(InstructionHandle ih=start; ih != null; ih = ih.next) {
    884 	Instruction i = ih.instruction;
    885
    886 	if(i instanceof BranchInstruction) { // target instruction within list?
    887 	  Instruction inst = ((BranchInstruction)i).getTarget().instruction;
    888 	  if(!contains(inst))
    889 	    throw new ClassGenException("Branch target of " +
    890 					Constants.OPCODE_NAMES[i.opcode] + ":" +
    891 					inst + " not in instruction list");
    892
    893 	  if(i instanceof Select) {
    894 	    InstructionHandle[] targets = ((Select)i).getTargets();
    895
    896 	    for(int j=0; j < targets.length; j++) {
    897 	      inst = targets[j].instruction;
    898 	      if(!contains(inst))
    899 		throw new ClassGenException("Branch target of " +
    900 					    Constants.OPCODE_NAMES[i.opcode] + ":" +
    901 					    inst + " not in instruction list");
    902 	    }
    903 	  }
    904
    905 	  if(!(ih instanceof BranchHandle))
    906 	    throw new ClassGenException("Branch instruction " +
    907 					Constants.OPCODE_NAMES[i.opcode] + ":" +
    908 					inst + " not contained in BranchHandle.");
    909
    910 	}
    911       }
    912     }
    913
    914     /* Pass 1: Set position numbers and sum up the maximum number of bytes an
    915      * instruction may be shifted.
    916      */
    917     for(InstructionHandle ih=start; ih != null; ih = ih.next) {
    918       Instruction i = ih.instruction;
    919
    920       ih.setPosition(index);
    921       pos[count++] = index;
    922
    923       /* Get an estimate about how many additional bytes may be added, because
    924        * BranchInstructions may have variable length depending on the target
    925        * offset (short vs. int) or alignment issues (TABLESWITCH and
    926        * LOOKUPSWITCH).
    927        */
    928       switch(i.getOpcode()) {
    929       case Constants.JSR: case Constants.GOTO:
    930 	max_additional_bytes += 2;
    931 	break;
    932
    933       case Constants.TABLESWITCH: case Constants.LOOKUPSWITCH:
    934 	max_additional_bytes += 3;
    935 	break;
    936       }
    937
    938       index += i.getLength();
    939     }
    940
    941     /* Pass 2: Expand the variable-length (Branch)Instructions depending on
    942      * the target offset (short or int) and ensure that branch targets are
    943      * within this list.
    944      */
    945     for(InstructionHandle ih=start; ih != null; ih = ih.next)
    946       additional_bytes += ih.updatePosition(additional_bytes, max_additional_bytes);
    947
    948     /* Pass 3: Update position numbers (which may have changed due to the
    949      * preceding expansions), like pass 1.
    950      */
    951     index=count=0;
    952     for(InstructionHandle ih=start; ih != null; ih = ih.next) {
    953       Instruction i = ih.instruction;
    954
    955       ih.setPosition(index);
    956       pos[count++] = index;
    957       index += i.getLength();
    958     }
    959
    960     byte_positions = new int[count]; // Trim to proper size
    961     System.arraycopy(pos, 0, byte_positions, 0, count);
    962   }
    963
    964   /***
    965    * When everything is finished, use this method to convert the instruction
    966    * list into an array of bytes.
    967    *
    968    * @return the byte code ready to be dumped
    969    */
    970   public byte[] getByteCode() {
    971     // Update position indices of instructions
    972     setPositions();
    973
    974     ByteArrayOutputStream b   = new ByteArrayOutputStream();
    975     DataOutputStream      out = new DataOutputStream(b);
    976
    977     try {
    978       for(InstructionHandle ih=start; ih != null; ih = ih.next) {
    979 	Instruction i = ih.instruction;
    980 	i.dump(out); // Traverse list
    981       }
    982     } catch(IOException e) {
    983       System.err.println(e);
    984       return null;
    985     }
    986
    987     return b.toByteArray();
    988   }
    989
    990   /***
    991    * @return an array of instructions without target information for branch instructions.
    992    */
    993   public Instruction[] getInstructions() {
    994     ByteSequence  bytes        = new ByteSequence(getByteCode());
    995     ArrayList     instructions = new ArrayList();
    996
    997     try {
    998       while(bytes.available() > 0) {
    999 	instructions.add(Instruction.readInstruction(bytes));
    1000       }
    1001     } catch(IOException e) { throw new ClassGenException(e.toString()); }
    1002
    1003     Instruction[] result = new Instruction[instructions.size()];
    1004     instructions.toArray(result);
    1005     return result;
    1006   }
    1007
    1008   public String toString() {
    1009     return toString(true);
    1010   }
    1011
    1012   /***
    1013    * @param verbose toggle output format
    1014    * @return String containing all instructions in this list.
    1015    */
    1016   public String toString(boolean verbose) {
    1017     StringBuffer buf = new StringBuffer();
    1018
    1019     for(InstructionHandle ih=start; ih != null; ih = ih.next) {
    1020       buf.append(ih.toString(verbose) + "\n");
    1021     }
    1022
    1023     return buf.toString();
    1024   }
    1025
    1026   /***
    1027    * @return Enumeration that lists all instructions (handles)
    1028    */
    1029   public Iterator iterator() {
    1030     return new Iterator() {
    1031       private InstructionHandle ih = start;
    1032
    1033       public Object next() {
    1034 	InstructionHandle i = ih;
    1035 	ih = ih.next;
    1036 	return i;
    1037       }
    1038
    1039       public void remove() {
    1040 	throw new UnsupportedOperationException();
    1041       }
    1042
    1043       public boolean hasNext() { return ih != null; }
    1044     };
    1045   }
    1046
    1047   /***
    1048    * @return array containing all instructions (handles)
    1049    */
    1050   public InstructionHandle[] getInstructionHandles() {
    1051     InstructionHandle[] ihs = new InstructionHandle[length];
    1052     InstructionHandle   ih  = start;
    1053
    1054     for(int i=0; i < length; i++) {
    1055       ihs[i] = ih;
    1056       ih = ih.next;
    1057     }
    1058
    1059     return ihs;
    1060   }
    1061
    1062   /***
    1063    * Get positions (offsets) of all instructions in the list. This relies on that
    1064    * the list has been freshly created from an byte code array, or that setPositions()
    1065    * has been called. Otherwise this may be inaccurate.
    1066    *
    1067    * @return array containing all instruction's offset in byte code
    1068    */
    1069   public int[] getInstructionPositions() { return byte_positions; }
    1070
    1071   /***
    1072    * @return complete, i.e., deep copy of this list
    1073    */
    1074   public InstructionList copy() {
    1075     HashMap         map = new HashMap();
    1076     InstructionList il  = new InstructionList();
    1077
    1078     /* Pass 1: Make copies of all instructions, append them to the new list
    1079      * and associate old instruction references with the new ones, i.e.,
    1080      * a 1:1 mapping.
    1081      */
    1082     for(InstructionHandle ih=start; ih != null; ih = ih.next) {
    1083       Instruction i = ih.instruction;
    1084       Instruction c = i.copy(); // Use clone for shallow copy
    1085
    1086       if(c instanceof BranchInstruction)
    1087 	map.put(ih, il.append((BranchInstruction)c));
    1088       else
    1089 	map.put(ih, il.append(c));
    1090     }
    1091
    1092     /* Pass 2: Update branch targets.
    1093      */
    1094     InstructionHandle ih=start;
    1095     InstructionHandle ch=il.start;
    1096
    1097     while(ih != null) {
    1098       Instruction i = ih.instruction;
    1099       Instruction c = ch.instruction;
    1100
    1101       if(i instanceof BranchInstruction) {
    1102 	BranchInstruction bi      = (BranchInstruction)i;
    1103 	BranchInstruction bc      = (BranchInstruction)c;
    1104 	InstructionHandle itarget = bi.getTarget(); // old target
    1105
    1106 	// New target is in hash map
    1107 	bc.setTarget((InstructionHandle)map.get(itarget));
    1108
    1109 	if(bi instanceof Select) { // Either LOOKUPSWITCH or TABLESWITCH
    1110 	  InstructionHandle[] itargets = ((Select)bi).getTargets();
    1111 	  InstructionHandle[] ctargets = ((Select)bc).getTargets();
    1112
    1113 	  for(int j=0; j < itargets.length; j++) { // Update all targets
    1114 	    ctargets[j] = (InstructionHandle)map.get(itargets[j]);
    1115 	  }
    1116 	}
    1117       }
    1118
    1119       ih = ih.next;
    1120       ch = ch.next;
    1121     }
    1122
    1123     return il;
    1124   }
    1125
    1126   /*** Replace all references to the old constant pool with references to the new
    1127    *  constant pool
    1128    */
    1129   public void replaceConstantPool(ConstantPoolGen old_cp, ConstantPoolGen new_cp) {
    1130     for(InstructionHandle ih=start; ih != null; ih = ih.next) {
    1131       Instruction i = ih.instruction;
    1132
    1133       if(i instanceof CPInstruction) {
    1134 	CPInstruction ci = (CPInstruction)i;
    1135 	Constant      c  = old_cp.getConstant(ci.getIndex());
    1136 	ci.setIndex(new_cp.addConstant(c, old_cp));
    1137       }
    1138     }
    1139   }
    1140
    1141   private void clear() {
    1142     start = end = null;
    1143     length = 0;
    1144   }
    1145
    1146   /***
    1147    * Delete contents of list. Provides besser memory utilization,
    1148    * because the system then may reuse the instruction handles. This
    1149    * method is typically called right after
    1150    * <href="MethodGen.html#getMethod()">MethodGen.getMethod()</a>.
    1151    */
    1152   public void dispose() {
    1153     // Traverse in reverse order, because ih.next is overwritten
    1154     for(InstructionHandle ih=end; ih != null; ih = ih.prev)
    1155       /* Causes BranchInstructions to release target and targeters, because it
    1156        * calls dispose() on the contained instruction.
    1157        */
    1158       ih.dispose();
    1159
    1160     clear();
    1161   }
    1162
    1163   /***
    1164    * @return start of list
    1165    */
    1166   public InstructionHandle getStart() { return start; }
    1167
    1168   /***
    1169    * @return end of list
    1170    */
    1171   public InstructionHandle getEnd()   { return end; }
    1172
    1173   /***
    1174    * @return length of list (Number of instructions, not bytes)
    1175    */
    1176   public int getLength() { return length; }
    1177
    1178   /***
    1179    * @return length of list (Number of instructions, not bytes)
    1180    */
    1181   public int size() { return length; }
    1182
    1183   /***
    1184    * Redirect all references from old_target to new_target, i.e., update targets
    1185    * of branch instructions.
    1186    *
    1187    * @param old_target the old target instruction handle
    1188    * @param new_target the new target instruction handle
    1189    */
    1190   public void redirectBranches(InstructionHandle old_target,
    1191 			       InstructionHandle new_target) {
    1192     for(InstructionHandle ih = start; ih != null; ih = ih.next) {
    1193       Instruction i  = ih.getInstruction();
    1194
    1195       if(i instanceof BranchInstruction) {
    1196 	BranchInstruction b      = (BranchInstruction)i;
    1197 	InstructionHandle target = b.getTarget();
    1198
    1199 	if(target == old_target)
    1200 	  b.setTarget(new_target);
    1201
    1202 	if(b instanceof Select) { // Either LOOKUPSWITCH or TABLESWITCH
    1203 	  InstructionHandle[] targets = ((Select)b).getTargets();
    1204
    1205 	  for(int j=0; j < targets.length; j++) // Update targets
    1206 	    if(targets[j] == old_target)
    1207 	      ((Select)b).setTarget(j, new_target);
    1208 	}
    1209       }
    1210     }
    1211   }
    1212
    1213   /***
    1214    * Redirect all references of local variables from old_target to new_target.
    1215    *
    1216    * @param lg array of local variables
    1217    * @param old_target the old target instruction handle
    1218    * @param new_target the new target instruction handle
    1219    * @see MethodGen
    1220    */
    1221   public void redirectLocalVariables(LocalVariableGen[] lg,
    1222 				     InstructionHandle old_target,
    1223 				     InstructionHandle new_target) {
    1224     for(int i=0; i < lg.length; i++) {
    1225       InstructionHandle start = lg[i].getStart();
    1226       InstructionHandle end   = lg[i].getEnd();
    1227
    1228       if(start == old_target)
    1229 	lg[i].setStart(new_target);
    1230
    1231       if(end == old_target)
    1232 	lg[i].setEnd(new_target);
    1233     }
    1234   }
    1235
    1236   /***
    1237    * Redirect all references of exception handlers from old_target to new_target.
    1238    *
    1239    * @param exceptions array of exception handlers
    1240    * @param old_target the old target instruction handle
    1241    * @param new_target the new target instruction handle
    1242    * @see MethodGen
    1243    */
    1244   public void redirectExceptionHandlers(CodeExceptionGen[] exceptions,
    1245 					InstructionHandle old_target,
    1246 					InstructionHandle new_target) {
    1247     for(int i=0; i < exceptions.length; i++) {
    1248       if(exceptions[i].getStartPC() == old_target)
    1249 	exceptions[i].setStartPC(new_target);
    1250
    1251       if(exceptions[i].getEndPC() == old_target)
    1252 	exceptions[i].setEndPC(new_target);
    1253
    1254       if(exceptions[i].getHandlerPC() == old_target)
    1255 	exceptions[i].setHandlerPC(new_target);
    1256     }
    1257   }
    1258
    1259   private ArrayList observers;
    1260
    1261   /*** Add observer for this object.
    1262    */
    1263   public void addObserver(InstructionListObserver o) {
    1264     if(observers == null)
    1265       observers = new ArrayList();
    1266
    1267     observers.add(o);
    1268   }
    1269
    1270   /*** Remove observer for this object.
    1271    */
    1272   public void removeObserver(InstructionListObserver o) {
    1273     if(observers != null)
    1274       observers.remove(o);
    1275   }
    1276
    1277   /*** Call notify() method on all observers. This method is not called
    1278    * automatically whenever the state has changed, but has to be
    1279    * called by the user after he has finished editing the object.
    1280    */
    1281   public void update() {
    1282     if(observers != null)
    1283       for(Iterator e = observers.iterator(); e.hasNext(); )
    1284 	((InstructionListObserver)e.next()).notify(this);
    1285   }
    1286 }
    1287

This page was automatically generated by Maven