1 /* 2 * Copyright (c) 2008, 2012, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package com.sun.tools.classfile; 27 28 import java.util.Map; 29 30 import com.sun.tools.classfile.ConstantPool.CONSTANT_Class_info; 31 import com.sun.tools.classfile.ConstantPool.CONSTANT_Dynamic_info; 32 import com.sun.tools.classfile.ConstantPool.CONSTANT_Double_info; 33 import com.sun.tools.classfile.ConstantPool.CONSTANT_Fieldref_info; 34 import com.sun.tools.classfile.ConstantPool.CONSTANT_Float_info; 35 import com.sun.tools.classfile.ConstantPool.CONSTANT_Integer_info; 36 import com.sun.tools.classfile.ConstantPool.CONSTANT_InterfaceMethodref_info; 37 import com.sun.tools.classfile.ConstantPool.CONSTANT_InvokeDynamic_info; 38 import com.sun.tools.classfile.ConstantPool.CONSTANT_Long_info; 39 import com.sun.tools.classfile.ConstantPool.CONSTANT_MethodHandle_info; 40 import com.sun.tools.classfile.ConstantPool.CONSTANT_MethodType_info; 41 import com.sun.tools.classfile.ConstantPool.CONSTANT_Methodref_info; 42 import com.sun.tools.classfile.ConstantPool.CONSTANT_Module_info; 43 import com.sun.tools.classfile.ConstantPool.CONSTANT_NameAndType_info; 44 import com.sun.tools.classfile.ConstantPool.CONSTANT_Package_info; 45 import com.sun.tools.classfile.ConstantPool.CONSTANT_String_info; 46 import com.sun.tools.classfile.ConstantPool.CONSTANT_Utf8_info; 47 import com.sun.tools.classfile.ConstantPool.CPInfo; 48 49 /** 50 * Rewrites a class file using a map of translations. 51 * 52 * <p><b>This is NOT part of any supported API. 53 * If you write code that depends on this, you do so at your own risk. 54 * This code and its internal interfaces are subject to change or 55 * deletion without notice.</b> 56 */ 57 public class ClassTranslator 58 implements ConstantPool.Visitor<ConstantPool.CPInfo,Map<Object,Object>> { 59 /** 60 * Create a new ClassFile from {@code cf}, such that for all entries 61 * {@code k -\> v} in {@code translations}, 62 * each occurrence of {@code k} in {@code cf} will be replaced by {@code v}. 63 * in 64 * @param cf the class file to be processed 65 * @param translations the set of translations to be applied 66 * @return a copy of {@code} with the values in {@code translations} substituted 67 */ translate(ClassFile cf, Map<Object,Object> translations)68 public ClassFile translate(ClassFile cf, Map<Object,Object> translations) { 69 ClassFile cf2 = (ClassFile) translations.get(cf); 70 if (cf2 == null) { 71 ConstantPool constant_pool2 = translate(cf.constant_pool, translations); 72 Field[] fields2 = translate(cf.fields, cf.constant_pool, translations); 73 Method[] methods2 = translateMethods(cf.methods, cf.constant_pool, translations); 74 Attributes attributes2 = translateAttributes(cf.attributes, cf.constant_pool, 75 translations); 76 77 if (constant_pool2 == cf.constant_pool && 78 fields2 == cf.fields && 79 methods2 == cf.methods && 80 attributes2 == cf.attributes) 81 cf2 = cf; 82 else 83 cf2 = new ClassFile( 84 cf.magic, 85 cf.minor_version, 86 cf.major_version, 87 constant_pool2, 88 cf.access_flags, 89 cf.this_class, 90 cf.super_class, 91 cf.interfaces, 92 fields2, 93 methods2, 94 attributes2); 95 translations.put(cf, cf2); 96 } 97 return cf2; 98 } 99 translate(ConstantPool cp, Map<Object,Object> translations)100 ConstantPool translate(ConstantPool cp, Map<Object,Object> translations) { 101 ConstantPool cp2 = (ConstantPool) translations.get(cp); 102 if (cp2 == null) { 103 ConstantPool.CPInfo[] pool2 = new ConstantPool.CPInfo[cp.size()]; 104 boolean eq = true; 105 for (int i = 0; i < cp.size(); ) { 106 ConstantPool.CPInfo cpInfo; 107 try { 108 cpInfo = cp.get(i); 109 } catch (ConstantPool.InvalidIndex e) { 110 throw new IllegalStateException(e); 111 } 112 ConstantPool.CPInfo cpInfo2 = translate(cpInfo, translations); 113 eq &= (cpInfo == cpInfo2); 114 pool2[i] = cpInfo2; 115 if (cpInfo.getTag() != cpInfo2.getTag()) 116 throw new IllegalStateException(); 117 i += cpInfo.size(); 118 } 119 120 if (eq) 121 cp2 = cp; 122 else 123 cp2 = new ConstantPool(pool2); 124 125 translations.put(cp, cp2); 126 } 127 return cp2; 128 } 129 translate(ConstantPool.CPInfo cpInfo, Map<Object,Object> translations)130 ConstantPool.CPInfo translate(ConstantPool.CPInfo cpInfo, Map<Object,Object> translations) { 131 ConstantPool.CPInfo cpInfo2 = (ConstantPool.CPInfo) translations.get(cpInfo); 132 if (cpInfo2 == null) { 133 cpInfo2 = cpInfo.accept(this, translations); 134 translations.put(cpInfo, cpInfo2); 135 } 136 return cpInfo2; 137 } 138 translate(Field[] fields, ConstantPool constant_pool, Map<Object,Object> translations)139 Field[] translate(Field[] fields, ConstantPool constant_pool, Map<Object,Object> translations) { 140 Field[] fields2 = (Field[]) translations.get(fields); 141 if (fields2 == null) { 142 fields2 = new Field[fields.length]; 143 for (int i = 0; i < fields.length; i++) 144 fields2[i] = translate(fields[i], constant_pool, translations); 145 if (equal(fields, fields2)) 146 fields2 = fields; 147 translations.put(fields, fields2); 148 } 149 return fields2; 150 } 151 translate(Field field, ConstantPool constant_pool, Map<Object,Object> translations)152 Field translate(Field field, ConstantPool constant_pool, Map<Object,Object> translations) { 153 Field field2 = (Field) translations.get(field); 154 if (field2 == null) { 155 Attributes attributes2 = translateAttributes(field.attributes, constant_pool, 156 translations); 157 158 if (attributes2 == field.attributes) 159 field2 = field; 160 else 161 field2 = new Field( 162 field.access_flags, 163 field.name_index, 164 field.descriptor, 165 attributes2); 166 translations.put(field, field2); 167 } 168 return field2; 169 } 170 translateMethods(Method[] methods, ConstantPool constant_pool, Map<Object,Object> translations)171 Method[] translateMethods(Method[] methods, ConstantPool constant_pool, Map<Object,Object> translations) { 172 Method[] methods2 = (Method[]) translations.get(methods); 173 if (methods2 == null) { 174 methods2 = new Method[methods.length]; 175 for (int i = 0; i < methods.length; i++) 176 methods2[i] = translate(methods[i], constant_pool, translations); 177 if (equal(methods, methods2)) 178 methods2 = methods; 179 translations.put(methods, methods2); 180 } 181 return methods2; 182 } 183 translate(Method method, ConstantPool constant_pool, Map<Object,Object> translations)184 Method translate(Method method, ConstantPool constant_pool, Map<Object,Object> translations) { 185 Method method2 = (Method) translations.get(method); 186 if (method2 == null) { 187 Attributes attributes2 = translateAttributes(method.attributes, constant_pool, 188 translations); 189 190 if (attributes2 == method.attributes) 191 method2 = method; 192 else 193 method2 = new Method( 194 method.access_flags, 195 method.name_index, 196 method.descriptor, 197 attributes2); 198 translations.put(method, method2); 199 } 200 return method2; 201 } 202 translateAttributes(Attributes attributes, ConstantPool constant_pool, Map<Object,Object> translations)203 Attributes translateAttributes(Attributes attributes, 204 ConstantPool constant_pool, Map<Object,Object> translations) { 205 Attributes attributes2 = (Attributes) translations.get(attributes); 206 if (attributes2 == null) { 207 Attribute[] attrArray2 = new Attribute[attributes.size()]; 208 ConstantPool constant_pool2 = translate(constant_pool, translations); 209 boolean attrsEqual = true; 210 for (int i = 0; i < attributes.size(); i++) { 211 Attribute attr = attributes.get(i); 212 Attribute attr2 = translate(attr, translations); 213 if (attr2 != attr) 214 attrsEqual = false; 215 attrArray2[i] = attr2; 216 } 217 if ((constant_pool2 == constant_pool) && attrsEqual) 218 attributes2 = attributes; 219 else 220 attributes2 = new Attributes(constant_pool2, attrArray2); 221 translations.put(attributes, attributes2); 222 } 223 return attributes2; 224 } 225 translate(Attribute attribute, Map<Object,Object> translations)226 Attribute translate(Attribute attribute, Map<Object,Object> translations) { 227 Attribute attribute2 = (Attribute) translations.get(attribute); 228 if (attribute2 == null) { 229 attribute2 = attribute; // don't support translation within attributes yet 230 // (what about Code attribute) 231 translations.put(attribute, attribute2); 232 } 233 return attribute2; 234 } 235 equal(T[] a1, T[] a2)236 private static <T> boolean equal(T[] a1, T[] a2) { 237 if (a1 == null || a2 == null) 238 return (a1 == a2); 239 if (a1.length != a2.length) 240 return false; 241 for (int i = 0; i < a1.length; i++) { 242 if (a1[i] != a2[i]) 243 return false; 244 } 245 return true; 246 } 247 248 @Override visitClass(CONSTANT_Class_info info, Map<Object, Object> translations)249 public CPInfo visitClass(CONSTANT_Class_info info, Map<Object, Object> translations) { 250 CONSTANT_Class_info info2 = (CONSTANT_Class_info) translations.get(info); 251 if (info2 == null) { 252 ConstantPool cp2 = translate(info.cp, translations); 253 if (cp2 == info.cp) 254 info2 = info; 255 else 256 info2 = new CONSTANT_Class_info(cp2, info.name_index); 257 translations.put(info, info2); 258 } 259 return info; 260 } 261 262 @Override visitDouble(CONSTANT_Double_info info, Map<Object, Object> translations)263 public CPInfo visitDouble(CONSTANT_Double_info info, Map<Object, Object> translations) { 264 CONSTANT_Double_info info2 = (CONSTANT_Double_info) translations.get(info); 265 if (info2 == null) { 266 info2 = info; 267 translations.put(info, info2); 268 } 269 return info; 270 } 271 272 @Override visitFieldref(CONSTANT_Fieldref_info info, Map<Object, Object> translations)273 public CPInfo visitFieldref(CONSTANT_Fieldref_info info, Map<Object, Object> translations) { 274 CONSTANT_Fieldref_info info2 = (CONSTANT_Fieldref_info) translations.get(info); 275 if (info2 == null) { 276 ConstantPool cp2 = translate(info.cp, translations); 277 if (cp2 == info.cp) 278 info2 = info; 279 else 280 info2 = new CONSTANT_Fieldref_info(cp2, info.class_index, info.name_and_type_index); 281 translations.put(info, info2); 282 } 283 return info; 284 } 285 286 @Override visitFloat(CONSTANT_Float_info info, Map<Object, Object> translations)287 public CPInfo visitFloat(CONSTANT_Float_info info, Map<Object, Object> translations) { 288 CONSTANT_Float_info info2 = (CONSTANT_Float_info) translations.get(info); 289 if (info2 == null) { 290 info2 = info; 291 translations.put(info, info2); 292 } 293 return info; 294 } 295 296 @Override visitInteger(CONSTANT_Integer_info info, Map<Object, Object> translations)297 public CPInfo visitInteger(CONSTANT_Integer_info info, Map<Object, Object> translations) { 298 CONSTANT_Integer_info info2 = (CONSTANT_Integer_info) translations.get(info); 299 if (info2 == null) { 300 info2 = info; 301 translations.put(info, info2); 302 } 303 return info; 304 } 305 306 @Override visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, Map<Object, Object> translations)307 public CPInfo visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, Map<Object, Object> translations) { 308 CONSTANT_InterfaceMethodref_info info2 = (CONSTANT_InterfaceMethodref_info) translations.get(info); 309 if (info2 == null) { 310 ConstantPool cp2 = translate(info.cp, translations); 311 if (cp2 == info.cp) 312 info2 = info; 313 else 314 info2 = new CONSTANT_InterfaceMethodref_info(cp2, info.class_index, info.name_and_type_index); 315 translations.put(info, info2); 316 } 317 return info; 318 } 319 320 @Override visitInvokeDynamic(CONSTANT_InvokeDynamic_info info, Map<Object, Object> translations)321 public CPInfo visitInvokeDynamic(CONSTANT_InvokeDynamic_info info, Map<Object, Object> translations) { 322 CONSTANT_InvokeDynamic_info info2 = (CONSTANT_InvokeDynamic_info) translations.get(info); 323 if (info2 == null) { 324 ConstantPool cp2 = translate(info.cp, translations); 325 if (cp2 == info.cp) { 326 info2 = info; 327 } else { 328 info2 = new CONSTANT_InvokeDynamic_info(cp2, info.bootstrap_method_attr_index, info.name_and_type_index); 329 } 330 translations.put(info, info2); 331 } 332 return info; 333 } 334 visitDynamicConstant(CONSTANT_Dynamic_info info, Map<Object, Object> translations)335 public CPInfo visitDynamicConstant(CONSTANT_Dynamic_info info, Map<Object, Object> translations) { 336 CONSTANT_Dynamic_info info2 = (CONSTANT_Dynamic_info) translations.get(info); 337 if (info2 == null) { 338 ConstantPool cp2 = translate(info.cp, translations); 339 if (cp2 == info.cp) { 340 info2 = info; 341 } else { 342 info2 = new CONSTANT_Dynamic_info(cp2, info.bootstrap_method_attr_index, info.name_and_type_index); 343 } 344 translations.put(info, info2); 345 } 346 return info; 347 } 348 349 @Override visitLong(CONSTANT_Long_info info, Map<Object, Object> translations)350 public CPInfo visitLong(CONSTANT_Long_info info, Map<Object, Object> translations) { 351 CONSTANT_Long_info info2 = (CONSTANT_Long_info) translations.get(info); 352 if (info2 == null) { 353 info2 = info; 354 translations.put(info, info2); 355 } 356 return info; 357 } 358 359 @Override visitMethodref(CONSTANT_Methodref_info info, Map<Object, Object> translations)360 public CPInfo visitMethodref(CONSTANT_Methodref_info info, Map<Object, Object> translations) { 361 CONSTANT_Methodref_info info2 = (CONSTANT_Methodref_info) translations.get(info); 362 if (info2 == null) { 363 ConstantPool cp2 = translate(info.cp, translations); 364 if (cp2 == info.cp) 365 info2 = info; 366 else 367 info2 = new CONSTANT_Methodref_info(cp2, info.class_index, info.name_and_type_index); 368 translations.put(info, info2); 369 } 370 return info; 371 } 372 373 @Override visitMethodHandle(CONSTANT_MethodHandle_info info, Map<Object, Object> translations)374 public CPInfo visitMethodHandle(CONSTANT_MethodHandle_info info, Map<Object, Object> translations) { 375 CONSTANT_MethodHandle_info info2 = (CONSTANT_MethodHandle_info) translations.get(info); 376 if (info2 == null) { 377 ConstantPool cp2 = translate(info.cp, translations); 378 if (cp2 == info.cp) { 379 info2 = info; 380 } else { 381 info2 = new CONSTANT_MethodHandle_info(cp2, info.reference_kind, info.reference_index); 382 } 383 translations.put(info, info2); 384 } 385 return info; 386 } 387 388 @Override visitMethodType(CONSTANT_MethodType_info info, Map<Object, Object> translations)389 public CPInfo visitMethodType(CONSTANT_MethodType_info info, Map<Object, Object> translations) { 390 CONSTANT_MethodType_info info2 = (CONSTANT_MethodType_info) translations.get(info); 391 if (info2 == null) { 392 ConstantPool cp2 = translate(info.cp, translations); 393 if (cp2 == info.cp) { 394 info2 = info; 395 } else { 396 info2 = new CONSTANT_MethodType_info(cp2, info.descriptor_index); 397 } 398 translations.put(info, info2); 399 } 400 return info; 401 } 402 403 @Override visitModule(CONSTANT_Module_info info, Map<Object, Object> translations)404 public CPInfo visitModule(CONSTANT_Module_info info, Map<Object, Object> translations) { 405 CONSTANT_Module_info info2 = (CONSTANT_Module_info) translations.get(info); 406 if (info2 == null) { 407 ConstantPool cp2 = translate(info.cp, translations); 408 if (cp2 == info.cp) 409 info2 = info; 410 else 411 info2 = new CONSTANT_Module_info(cp2, info.name_index); 412 translations.put(info, info2); 413 } 414 return info; 415 } 416 417 @Override visitNameAndType(CONSTANT_NameAndType_info info, Map<Object, Object> translations)418 public CPInfo visitNameAndType(CONSTANT_NameAndType_info info, Map<Object, Object> translations) { 419 CONSTANT_NameAndType_info info2 = (CONSTANT_NameAndType_info) translations.get(info); 420 if (info2 == null) { 421 ConstantPool cp2 = translate(info.cp, translations); 422 if (cp2 == info.cp) 423 info2 = info; 424 else 425 info2 = new CONSTANT_NameAndType_info(cp2, info.name_index, info.type_index); 426 translations.put(info, info2); 427 } 428 return info; 429 } 430 431 @Override visitPackage(CONSTANT_Package_info info, Map<Object, Object> translations)432 public CPInfo visitPackage(CONSTANT_Package_info info, Map<Object, Object> translations) { 433 CONSTANT_Package_info info2 = (CONSTANT_Package_info) translations.get(info); 434 if (info2 == null) { 435 ConstantPool cp2 = translate(info.cp, translations); 436 if (cp2 == info.cp) 437 info2 = info; 438 else 439 info2 = new CONSTANT_Package_info(cp2, info.name_index); 440 translations.put(info, info2); 441 } 442 return info; 443 } 444 445 @Override visitString(CONSTANT_String_info info, Map<Object, Object> translations)446 public CPInfo visitString(CONSTANT_String_info info, Map<Object, Object> translations) { 447 CONSTANT_String_info info2 = (CONSTANT_String_info) translations.get(info); 448 if (info2 == null) { 449 ConstantPool cp2 = translate(info.cp, translations); 450 if (cp2 == info.cp) 451 info2 = info; 452 else 453 info2 = new CONSTANT_String_info(cp2, info.string_index); 454 translations.put(info, info2); 455 } 456 return info; 457 } 458 459 @Override visitUtf8(CONSTANT_Utf8_info info, Map<Object, Object> translations)460 public CPInfo visitUtf8(CONSTANT_Utf8_info info, Map<Object, Object> translations) { 461 CONSTANT_Utf8_info info2 = (CONSTANT_Utf8_info) translations.get(info); 462 if (info2 == null) { 463 info2 = info; 464 translations.put(info, info2); 465 } 466 return info; 467 } 468 469 } 470