src/share/classes/jdk/internal/org/objectweb/asm/commons/RemappingMethodAdapter.java

Print this page




  47  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  48  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  49  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  50  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  51  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  52  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  53  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  54  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  55  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  56  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  57  * THE POSSIBILITY OF SUCH DAMAGE.
  58  */
  59 
  60 package jdk.internal.org.objectweb.asm.commons;
  61 
  62 import jdk.internal.org.objectweb.asm.AnnotationVisitor;
  63 import jdk.internal.org.objectweb.asm.Handle;
  64 import jdk.internal.org.objectweb.asm.Label;
  65 import jdk.internal.org.objectweb.asm.MethodVisitor;
  66 import jdk.internal.org.objectweb.asm.Opcodes;

  67 
  68 /**
  69  * A {@link LocalVariablesSorter} for type mapping.
  70  *
  71  * @author Eugene Kuleshov
  72  */
  73 public class RemappingMethodAdapter extends LocalVariablesSorter {
  74 
  75     protected final Remapper remapper;
  76 
  77     public RemappingMethodAdapter(
  78         final int access,
  79         final String desc,
  80         final MethodVisitor mv,
  81         final Remapper remapper)
  82     {
  83         this(Opcodes.ASM4, access, desc, mv, remapper);
  84     }
  85 
  86     protected RemappingMethodAdapter(
  87         final int api,
  88         final int access,
  89         final String desc,
  90         final MethodVisitor mv,
  91         final Remapper remapper)
  92     {
  93         super(api, access, desc, mv);
  94         this.remapper = remapper;
  95     }
  96 
  97     @Override
  98     public AnnotationVisitor visitAnnotationDefault() {
  99         AnnotationVisitor av = mv.visitAnnotationDefault();
 100         return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
 101     }
 102 
 103     @Override
 104     public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
 105         AnnotationVisitor av = mv.visitAnnotation(remapper.mapDesc(desc), visible);

 106         return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
 107     }
 108 
 109     @Override
 110     public AnnotationVisitor visitParameterAnnotation(
 111         int parameter,
 112         String desc,
 113         boolean visible)
 114     {
 115         AnnotationVisitor av = mv.visitParameterAnnotation(parameter,
 116                 remapper.mapDesc(desc),
 117                 visible);
 118         return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
 119     }
 120 
 121     @Override
 122     public void visitFrame(
 123         int type,
 124         int nLocal,
 125         Object[] local,
 126         int nStack,
 127         Object[] stack)
 128     {
 129         super.visitFrame(type, nLocal, remapEntries(nLocal, local), nStack, remapEntries(nStack, stack));
 130     }
 131 







 132     private Object[] remapEntries(int n, Object[] entries) {
 133         for (int i = 0; i < n; i++) {
 134             if (entries[i] instanceof String) {
 135                 Object[] newEntries = new Object[n];
 136                 if (i > 0) {
 137                     System.arraycopy(entries, 0, newEntries, 0, i);
 138                 }
 139                 do {
 140                     Object t = entries[i];
 141                     newEntries[i++] = t instanceof String
 142                             ? remapper.mapType((String) t)
 143                             : t;
 144                 } while (i < n);
 145                 return newEntries;
 146             }
 147         }
 148         return entries;
 149     }
 150 
 151     @Override
 152     public void visitFieldInsn(
 153         int opcode,
 154         String owner,
 155         String name,
 156         String desc)
 157     {
 158         super.visitFieldInsn(opcode,
 159                 remapper.mapType(owner),
 160                 remapper.mapFieldName(owner, name, desc),
 161                 remapper.mapDesc(desc));
 162     }
 163 
 164     @Override
 165     public void visitMethodInsn(
 166         int opcode,
 167         String owner,
 168         String name,
 169         String desc)
 170     {
 171         super.visitMethodInsn(opcode,
 172                 remapper.mapType(owner),
 173                 remapper.mapMethodName(owner, name, desc),
 174                 remapper.mapMethodDesc(desc));
 175     }
 176 
 177     @Override
 178     public void visitInvokeDynamicInsn(
 179         String name,
 180         String desc,
 181         Handle bsm,
 182         Object... bsmArgs)
 183     {
 184         for(int i=0; i<bsmArgs.length; i++) {
 185             bsmArgs[i] = remapper.mapValue(bsmArgs[i]);
 186         }
 187         super.visitInvokeDynamicInsn(
 188                 remapper.mapInvokeDynamicMethodName(name, desc),
 189                 remapper.mapMethodDesc(desc),
 190                 (Handle)remapper.mapValue(bsm),
 191                 bsmArgs);
 192     }
 193 
 194     @Override
 195     public void visitTypeInsn(int opcode, String type) {
 196         super.visitTypeInsn(opcode, remapper.mapType(type));
 197     }
 198 
 199     @Override
 200     public void visitLdcInsn(Object cst) {
 201         super.visitLdcInsn(remapper.mapValue(cst));
 202     }
 203 
 204     @Override
 205     public void visitMultiANewArrayInsn(String desc, int dims) {
 206         super.visitMultiANewArrayInsn(remapper.mapDesc(desc), dims);
 207     }
 208 
 209     @Override
 210     public void visitTryCatchBlock(
 211         Label start,
 212         Label end,
 213         Label handler,
 214         String type)
 215     {
 216         super.visitTryCatchBlock(start, end, handler,
 217                 type == null ? null : remapper.mapType(type));
 218     }
 219 
 220     @Override
 221     public void visitLocalVariable(
 222         String name,
 223         String desc,
 224         String signature,
 225         Label start,
 226         Label end,
 227         int index)
 228     {
 229         super.visitLocalVariable(name,
 230                 remapper.mapDesc(desc),
 231                 remapper.mapSignature(signature, true),
 232                 start,
 233                 end,
 234                 index);
 235     }
























 236 }


  47  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  48  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  49  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  50  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  51  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  52  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  53  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  54  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  55  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  56  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  57  * THE POSSIBILITY OF SUCH DAMAGE.
  58  */
  59 
  60 package jdk.internal.org.objectweb.asm.commons;
  61 
  62 import jdk.internal.org.objectweb.asm.AnnotationVisitor;
  63 import jdk.internal.org.objectweb.asm.Handle;
  64 import jdk.internal.org.objectweb.asm.Label;
  65 import jdk.internal.org.objectweb.asm.MethodVisitor;
  66 import jdk.internal.org.objectweb.asm.Opcodes;
  67 import jdk.internal.org.objectweb.asm.TypePath;
  68 
  69 /**
  70  * A {@link LocalVariablesSorter} for type mapping.
  71  *
  72  * @author Eugene Kuleshov
  73  */
  74 public class RemappingMethodAdapter extends LocalVariablesSorter {
  75 
  76     protected final Remapper remapper;
  77 
  78     public RemappingMethodAdapter(final int access, final String desc,
  79             final MethodVisitor mv, final Remapper remapper) {
  80         this(Opcodes.ASM5, access, desc, mv, remapper);




  81     }
  82 
  83     protected RemappingMethodAdapter(final int api, final int access,
  84             final String desc, final MethodVisitor mv, final Remapper remapper) {





  85         super(api, access, desc, mv);
  86         this.remapper = remapper;
  87     }
  88 
  89     @Override
  90     public AnnotationVisitor visitAnnotationDefault() {
  91         AnnotationVisitor av = super.visitAnnotationDefault();
  92         return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
  93     }
  94 
  95     @Override
  96     public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
  97         AnnotationVisitor av = super.visitAnnotation(remapper.mapDesc(desc),
  98                 visible);
  99         return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
 100     }
 101 
 102     @Override
 103     public AnnotationVisitor visitTypeAnnotation(int typeRef,
 104             TypePath typePath, String desc, boolean visible) {
 105         AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath,
 106                 remapper.mapDesc(desc), visible);




 107         return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
 108     }
 109 
 110     @Override
 111     public AnnotationVisitor visitParameterAnnotation(int parameter,
 112             String desc, boolean visible) {
 113         AnnotationVisitor av = super.visitParameterAnnotation(parameter,
 114                 remapper.mapDesc(desc), visible);
 115         return av == null ? av : new RemappingAnnotationAdapter(av, remapper);



 116     }
 117 
 118     @Override
 119     public void visitFrame(int type, int nLocal, Object[] local, int nStack,
 120             Object[] stack) {
 121         super.visitFrame(type, nLocal, remapEntries(nLocal, local), nStack,
 122                 remapEntries(nStack, stack));
 123     }
 124 
 125     private Object[] remapEntries(int n, Object[] entries) {
 126         for (int i = 0; i < n; i++) {
 127             if (entries[i] instanceof String) {
 128                 Object[] newEntries = new Object[n];
 129                 if (i > 0) {
 130                     System.arraycopy(entries, 0, newEntries, 0, i);
 131                 }
 132                 do {
 133                     Object t = entries[i];
 134                     newEntries[i++] = t instanceof String ? remapper
 135                             .mapType((String) t) : t;

 136                 } while (i < n);
 137                 return newEntries;
 138             }
 139         }
 140         return entries;
 141     }
 142 
 143     @Override
 144     public void visitFieldInsn(int opcode, String owner, String name,
 145             String desc) {
 146         super.visitFieldInsn(opcode, remapper.mapType(owner),





 147                 remapper.mapFieldName(owner, name, desc),
 148                 remapper.mapDesc(desc));
 149     }
 150 
 151     @Override
 152     public void visitMethodInsn(int opcode, String owner, String name,
 153             String desc) {
 154         super.visitMethodInsn(opcode, remapper.mapType(owner),





 155                 remapper.mapMethodName(owner, name, desc),
 156                 remapper.mapMethodDesc(desc));
 157     }
 158 
 159     @Override
 160     public void visitInvokeDynamicInsn(String name, String desc, Handle bsm,
 161             Object... bsmArgs) {
 162         for (int i = 0; i < bsmArgs.length; i++) {




 163             bsmArgs[i] = remapper.mapValue(bsmArgs[i]);
 164         }
 165         super.visitInvokeDynamicInsn(
 166                 remapper.mapInvokeDynamicMethodName(name, desc),
 167                 remapper.mapMethodDesc(desc), (Handle) remapper.mapValue(bsm),

 168                 bsmArgs);
 169     }
 170 
 171     @Override
 172     public void visitTypeInsn(int opcode, String type) {
 173         super.visitTypeInsn(opcode, remapper.mapType(type));
 174     }
 175 
 176     @Override
 177     public void visitLdcInsn(Object cst) {
 178         super.visitLdcInsn(remapper.mapValue(cst));
 179     }
 180 
 181     @Override
 182     public void visitMultiANewArrayInsn(String desc, int dims) {
 183         super.visitMultiANewArrayInsn(remapper.mapDesc(desc), dims);
 184     }
 185 
 186     @Override
 187     public AnnotationVisitor visitInsnAnnotation(int typeRef,
 188             TypePath typePath, String desc, boolean visible) {
 189         AnnotationVisitor av = super.visitInsnAnnotation(typeRef, typePath,
 190                 remapper.mapDesc(desc), visible);
 191         return av == null ? av : new RemappingAnnotationAdapter(av, remapper);



 192     }
 193 
 194     @Override
 195     public void visitTryCatchBlock(Label start, Label end, Label handler,
 196             String type) {
 197         super.visitTryCatchBlock(start, end, handler, type == null ? null
 198                 : remapper.mapType(type));










 199     }
 200 
 201     @Override
 202     public AnnotationVisitor visitTryCatchAnnotation(int typeRef,
 203             TypePath typePath, String desc, boolean visible) {
 204         AnnotationVisitor av = super.visitTryCatchAnnotation(typeRef, typePath,
 205                 remapper.mapDesc(desc), visible);
 206         return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
 207     }
 208 
 209     @Override
 210     public void visitLocalVariable(String name, String desc, String signature,
 211             Label start, Label end, int index) {
 212         super.visitLocalVariable(name, remapper.mapDesc(desc),
 213                 remapper.mapSignature(signature, true), start, end, index);
 214     }
 215 
 216     @Override
 217     public AnnotationVisitor visitLocalVariableAnnotation(int typeRef,
 218             TypePath typePath, Label[] start, Label[] end, int[] index,
 219             String desc, boolean visible) {
 220         AnnotationVisitor av = super.visitLocalVariableAnnotation(typeRef,
 221                 typePath, start, end, index, remapper.mapDesc(desc), visible);
 222         return av == null ? av : new RemappingAnnotationAdapter(av, remapper);
 223     }
 224 }