00001 package ca.mcgill.sable.soot.coffi; 00002 00003 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00004 * Jimple, a 3-address code Java(TM) bytecode representation. * 00005 * Copyright (C) 1997, 1998 Raja Vallee-Rai (kor@sable.mcgill.ca) * 00006 * All rights reserved. * 00007 * * 00008 * This work was done as a project of the Sable Research Group, * 00009 * School of Computer Science, McGill University, Canada * 00010 * (http://www.sable.mcgill.ca/). It is understood that any * 00011 * modification not identified as such is not covered by the * 00012 * preceding statement. * 00013 * * 00014 * This work is free software; you can redistribute it and/or * 00015 * modify it under the terms of the GNU Library General Public * 00016 * License as published by the Free Software Foundation; either * 00017 * version 2 of the License, or (at your option) any later version. * 00018 * * 00019 * This work is distributed in the hope that it will be useful, * 00020 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00021 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00022 * Library General Public License for more details. * 00023 * * 00024 * You should have received a copy of the GNU Library General Public * 00025 * License along with this library; if not, write to the * 00026 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * 00027 * Boston, MA 02111-1307, USA. * 00028 * * 00029 * Java is a trademark of Sun Microsystems, Inc. * 00030 * * 00031 * To submit a bug report, send a comment, or get the latest news on * 00032 * this project and other Sable Research Group projects, please * 00033 * visit the web site: http://www.sable.mcgill.ca/ * 00034 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00035 00036 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 00037 * Coffi, a bytecode parser for the Java(TM) language. * 00038 * Copyright (C) 1996, 1997 Clark Verbrugge (clump@sable.mcgill.ca). * 00039 * All rights reserved. * 00040 * * 00041 * This work was done as a project of the Sable Research Group, * 00042 * School of Computer Science, McGill University, Canada * 00043 * (http://www.sable.mcgill.ca/). It is understood that any * 00044 * modification not identified as such is not covered by the * 00045 * preceding statement. * 00046 * * 00047 * This work is free software; you can redistribute it and/or * 00048 * modify it under the terms of the GNU Library General Public * 00049 * License as published by the Free Software Foundation; either * 00050 * version 2 of the License, or (at your option) any later version. * 00051 * * 00052 * This work is distributed in the hope that it will be useful, * 00053 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00054 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00055 * Library General Public License for more details. * 00056 * * 00057 * You should have received a copy of the GNU Library General Public * 00058 * License along with this library; if not, write to the * 00059 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * 00060 * Boston, MA 02111-1307, USA. * 00061 * * 00062 * Java is a trademark of Sun Microsystems, Inc. * 00063 * * 00064 * To submit a bug report, send a comment, or get the latest news on * 00065 * this project and other Sable Research Group projects, please * 00066 * visit the web site: http://www.sable.mcgill.ca/ * 00067 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 00068 00069 /* 00070 Reference Version 00071 ----------------- 00072 This is the latest official version on which this file is based. 00073 The reference version is: $CoffiVersion: 1.1 $ 00074 $SootVersion: 1.beta.4 $ 00075 00076 Change History 00077 -------------- 00078 A) Notes: 00079 00080 Please use the following template. Most recent changes should 00081 appear at the top of the list. 00082 00083 - Modified on [date (March 1, 1900)] by [name]. [(*) if appropriate] 00084 [description of modification]. 00085 00086 Any Modification flagged with "(*)" was done as a project of the 00087 Sable Research Group, School of Computer Science, 00088 McGill University, Canada (http://www.sable.mcgill.ca/). 00089 00090 You should add your copyright, using the following template, at 00091 the top of this file, along with other copyrights. 00092 00093 * * 00094 * Modifications by [name] are * 00095 * Copyright (C) [year(s)] [your name (or company)]. All rights * 00096 * reserved. * 00097 * * 00098 00099 B) Changes: 00100 00101 - Modified on November 2, 1998 by Raja Vallee-Rai (kor@sable.mcgill.ca) (*) 00102 Repackaged all source files and performed extensive modifications. 00103 First initial release of Soot. 00104 00105 - Modified on 15-Jun-1998 by Raja Vallee-Rai (kor@sable.mcgill.ca). (*) 00106 First internal release (Version 0.1). 00107 */ 00108 00109 import java.io.*; 00110 /** Instruction subclasses are used to represent parsed bytecode; each 00111 * bytecode operation has a corresponding subclass of Instruction. 00112 * <p> 00113 * Each subclass is derived from one of 00114 * <ul><li>Instruction</li> 00115 * <li>Instruction_noargs (an Instruction with no embedded arguments)</li> 00116 * <li>Instruction_byte (an Instruction with a single byte data argument)</li> 00117 * <li>Instruction_bytevar (a byte argument specifying a local variable)</li> 00118 * <li>Instruction_byteindex (a byte argument specifying a constant pool index)</li> 00119 * <li>Instruction_int (an Instruction with a single short data argument)</li> 00120 * <li>Instruction_intvar (a short argument specifying a local variable)</li> 00121 * <li>Instruction_intindex (a short argument specifying a constant pool index)</li> 00122 * <li>Instruction_intbranch (a short argument specifying a code offset)</li> 00123 * <li>Instruction_longbranch (an int argument specifying a code offset)</li> 00124 * </ul> 00125 * @author Clark Verbrugge 00126 * @see Instruction 00127 * @see Instruction_noargs 00128 * @see Instruction_byte 00129 * @see Instruction_bytevar 00130 * @see Instruction_byteindex 00131 * @see Instruction_int 00132 * @see Instruction_intvar 00133 * @see Instruction_intindex 00134 * @see Instruction_intbranch 00135 * @see Instruction_longbranch 00136 * @see Instruction_Unknown 00137 */ 00138 class Instruction_Lookupswitch extends Instruction { 00139 public byte pad; // number of bytes used for padding 00140 public int default_offset; 00141 public int npairs; 00142 public int match_offsets[]; 00143 public Instruction default_inst; 00144 public Instruction match_insts[]; 00145 public Instruction_Lookupswitch() { super((byte)ByteCode.LOOKUPSWITCH); name = "lookupswitch"; branches = true; } 00146 public Instruction[] branchpoints(Instruction next) { 00147 Instruction i[] = new Instruction[npairs+1]; 00148 int j; 00149 i[0] = default_inst; 00150 for (j=1;j<npairs+1;j++) 00151 i[j] = match_insts[j-1]; 00152 return i; 00153 } 00154 public int compile(byte bc[],int index) { 00155 int i; 00156 bc[index++] = code; 00157 // insert padding so next instruction is on a 4-byte boundary 00158 for (i=0;i<pad;i++) 00159 bc[index++] = 0; 00160 if (default_inst!=null) 00161 index = intToBytes(default_inst.label-label,bc,index); 00162 else 00163 index = intToBytes(default_offset,bc,index); 00164 index = intToBytes(npairs,bc,index); 00165 for (i=0;i<npairs;i++) { 00166 index = intToBytes(match_offsets[i*2],bc,index); 00167 if (match_insts[i]!=null) 00168 index = intToBytes((match_insts[i]).label-label,bc,index); 00169 else 00170 index = intToBytes(match_offsets[i*2+1],bc,index); 00171 } 00172 return index; 00173 } 00174 public int nextOffset(int curr) { 00175 int i,j,baseindex,siz=0; 00176 baseindex = curr; 00177 i = (curr+1) % 4; 00178 if (i != 0) 00179 siz = (4 - i); 00180 return (curr + siz + 9 + npairs*8); 00181 } 00182 public void offsetToPointer(ByteCode bc) { 00183 int i; 00184 default_inst = bc.locateInst(default_offset+label); 00185 if (default_inst==null) { 00186 System.out.println("Warning: can't locate target of instruction"); 00187 System.out.println(" which should be at byte address " + (label+default_offset)); 00188 } else 00189 default_inst.labelled = true; 00190 if (npairs>0) { 00191 match_insts = new Instruction[npairs]; 00192 for (i=0;i<npairs;i++) { 00193 match_insts[i] = bc.locateInst(match_offsets[i*2+1]+label); 00194 if (match_insts[i]==null) { 00195 System.out.println("Warning: can't locate target of instruction"); 00196 System.out.println(" which should be at byte address " + 00197 (label+match_offsets[i*2+1])); 00198 } else 00199 match_insts[i].labelled = true; 00200 } 00201 } 00202 } 00203 public int parse(byte bc[],int index) { 00204 // first figure out padding to next 4-byte quantity 00205 int i,j,baseindex; 00206 baseindex = index; 00207 i = index % 4; 00208 if (i != 0) 00209 pad = (byte)(4 - i); 00210 else 00211 pad = (byte)0; 00212 index += pad; 00213 default_offset = getInt(bc,index); 00214 index += 4; 00215 npairs = getInt(bc,index); 00216 index += 4; 00217 if (npairs>0) { 00218 match_offsets = new int[npairs*2]; 00219 j = 0; 00220 do { 00221 match_offsets[j] = getInt(bc,index); 00222 j++; 00223 index += 4; 00224 match_offsets[j] = getInt(bc,index); 00225 index += 4; 00226 j++; 00227 } while(j<npairs*2); 00228 } 00229 return index; 00230 } 00231 public String toString(cp_info constant_pool[]) { 00232 // first figure out padding to next 4-byte quantity 00233 String args; 00234 int i; 00235 args = super.toString(constant_pool) + argsep + "(" + 00236 Integer.toString(pad) + ")"; 00237 args = args + argsep + Integer.toString(default_inst.label); 00238 args = args + argsep + Integer.toString(npairs) + ": "; 00239 for (i=0;i<npairs;i++) 00240 args = args + "case " + Integer.toString(match_offsets[i*2]) + 00241 ": label_" + Integer.toString(match_insts[i].label); 00242 return args; 00243 } 00244 }
1.2.10 written by Dimitri van Heesch,
© 1997-2001