View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.nabla.forward.analysis;
18  
19  import java.util.Iterator;
20  import java.util.List;
21  
22  import org.apache.commons.nabla.DifferentiationException;
23  import org.apache.commons.nabla.NablaMessages;
24  import org.objectweb.asm.Handle;
25  import org.objectweb.asm.Opcodes;
26  import org.objectweb.asm.Type;
27  import org.objectweb.asm.tree.AbstractInsnNode;
28  import org.objectweb.asm.tree.FieldInsnNode;
29  import org.objectweb.asm.tree.IntInsnNode;
30  import org.objectweb.asm.tree.InvokeDynamicInsnNode;
31  import org.objectweb.asm.tree.LdcInsnNode;
32  import org.objectweb.asm.tree.MethodInsnNode;
33  import org.objectweb.asm.tree.MultiANewArrayInsnNode;
34  import org.objectweb.asm.tree.TypeInsnNode;
35  import org.objectweb.asm.tree.analysis.AnalyzerException;
36  import org.objectweb.asm.tree.analysis.Interpreter;
37  
38  /** An interpreter tracking which instructions use which values.
39   * <p>
40   * The implementation of this class is largely copied from the original BasicInterpreter from asm,
41   * which is distributed under the following terms:
42   * </p>
43   * <p>
44   * ASM: a very small and fast Java bytecode manipulation framework
45   * Copyright (c) 2000-2011 INRIA, France Telecom
46   * All rights reserved.
47   *
48   * Redistribution and use in source and binary forms, with or without
49   * modification, are permitted provided that the following conditions
50   * are met:
51   * 1. Redistributions of source code must retain the above copyright
52   *    notice, this list of conditions and the following disclaimer.
53   * 2. Redistributions in binary form must reproduce the above copyright
54   *    notice, this list of conditions and the following disclaimer in the
55   *    documentation and/or other materials provided with the distribution.
56   * 3. Neither the name of the copyright holders nor the names of its
57   *    contributors may be used to endorse or promote products derived from
58   *    this software without specific prior written permission.
59   *
60   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
61   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
62   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
63   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
64   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
65   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
66   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
67   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
68   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
69   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
70   * THE POSSIBILITY OF SUCH DAMAGE.
71   * </p>
72   * @see TrackingValue
73   * @version $Id$
74   */
75  public class TrackingInterpreter extends Interpreter<TrackingValue> {
76  
77      /** Build an interpreter.
78       */
79      public TrackingInterpreter() {
80          super(Opcodes.ASM4);
81      }
82  
83      /** {@inheritDoc} */
84      @Override
85      public TrackingValue newValue(final Type type) {
86          return (type == null) ? TrackingValue.UNINITIALIZED_VALUE : new TrackingValue(type);
87      }
88  
89      /** {@inheritDoc} */
90      @Override
91      public TrackingValue newOperation(final AbstractInsnNode insn) throws AnalyzerException {
92          switch (insn.getOpcode()) {
93              case Opcodes.ACONST_NULL:
94                  return new TrackingValue(Type.getObjectType("null"), insn);
95              case Opcodes.ICONST_M1:
96              case Opcodes.ICONST_0:
97              case Opcodes.ICONST_1:
98              case Opcodes.ICONST_2:
99              case Opcodes.ICONST_3:
100             case Opcodes.ICONST_4:
101             case Opcodes.ICONST_5:
102                 return new TrackingValue(Type.INT_TYPE, insn);
103             case Opcodes.LCONST_0:
104             case Opcodes.LCONST_1:
105                 return new TrackingValue(Type.LONG_TYPE, insn);
106             case Opcodes.FCONST_0:
107             case Opcodes.FCONST_1:
108             case Opcodes.FCONST_2:
109                 return new TrackingValue(Type.FLOAT_TYPE, insn);
110             case Opcodes.DCONST_0:
111             case Opcodes.DCONST_1:
112                 return new TrackingValue(Type.DOUBLE_TYPE, insn);
113             case Opcodes.BIPUSH:
114             case Opcodes.SIPUSH:
115                 return new TrackingValue(Type.INT_TYPE, insn);
116             case Opcodes.LDC:
117                 final Object cst = ((LdcInsnNode) insn).cst;
118                 if (cst instanceof Integer) {
119                     return new TrackingValue(Type.INT_TYPE, insn);
120                 } else if (cst instanceof Float) {
121                     return new TrackingValue(Type.FLOAT_TYPE, insn);
122                 } else if (cst instanceof Long) {
123                     return new TrackingValue(Type.LONG_TYPE, insn);
124                 } else if (cst instanceof Double) {
125                     return new TrackingValue(Type.DOUBLE_TYPE, insn);
126                 } else if (cst instanceof String) {
127                     return new TrackingValue(Type.getType(String.class), insn);
128                 } else if (cst instanceof Type) {
129                     final int sort = ((Type) cst).getSort();
130                     if (sort == Type.OBJECT || sort == Type.ARRAY) {
131                         return new TrackingValue(Type.getType(Class.class), insn);
132                     } else if (sort == Type.METHOD) {
133                         return new TrackingValue(Type.getObjectType("java/lang/invoke/MethodType"), insn);
134                     } else {
135                         throw DifferentiationException.createIllegalArgumentException(NablaMessages.ILLEGAL_LDC_CONSTANT,
136                                                                                       cst);
137                     }
138                 } else if (cst instanceof Handle) {
139                     return new TrackingValue(Type.getObjectType("java/lang/invoke/MethodHandle"), insn);
140                 } else {
141                     throw DifferentiationException.createIllegalArgumentException(NablaMessages.ILLEGAL_LDC_CONSTANT,
142                                                                                   cst);
143                 }
144             case Opcodes.JSR:
145                 return new TrackingValue(Type.VOID_TYPE, insn); // return address value
146             case Opcodes.GETSTATIC:
147                 return new TrackingValue(Type.getType(((FieldInsnNode) insn).desc), insn);
148             case Opcodes.NEW:
149                 return new TrackingValue(Type.getObjectType(((TypeInsnNode) insn).desc), insn);
150             default:
151                 throw DifferentiationException.createInternalError(null);
152         }
153     }
154 
155     /** {@inheritDoc} */
156     public TrackingValue unaryOperation(final AbstractInsnNode insn, final TrackingValue value)
157         throws AnalyzerException {
158         ((TrackingValue) value).addConsumer(insn);
159         switch (insn.getOpcode()) {
160             case Opcodes.INEG:
161             case Opcodes.IINC:
162             case Opcodes.L2I:
163             case Opcodes.F2I:
164             case Opcodes.D2I:
165             case Opcodes.I2B:
166             case Opcodes.I2C:
167             case Opcodes.I2S:
168                 return new TrackingValue(Type.INT_TYPE, insn);
169             case Opcodes.FNEG:
170             case Opcodes.I2F:
171             case Opcodes.L2F:
172             case Opcodes.D2F:
173                 return new TrackingValue(Type.FLOAT_TYPE, insn);
174             case Opcodes.LNEG:
175             case Opcodes.I2L:
176             case Opcodes.F2L:
177             case Opcodes.D2L:
178                 return new TrackingValue(Type.LONG_TYPE, insn);
179             case Opcodes.DNEG:
180             case Opcodes.I2D:
181             case Opcodes.L2D:
182             case Opcodes.F2D:
183                 return new TrackingValue(Type.DOUBLE_TYPE, insn);
184             case Opcodes.IFEQ:
185             case Opcodes.IFNE:
186             case Opcodes.IFLT:
187             case Opcodes.IFGE:
188             case Opcodes.IFGT:
189             case Opcodes.IFLE:
190             case Opcodes.TABLESWITCH:
191             case Opcodes.LOOKUPSWITCH:
192             case Opcodes.IRETURN:
193             case Opcodes.LRETURN:
194             case Opcodes.FRETURN:
195             case Opcodes.DRETURN:
196             case Opcodes.ARETURN:
197             case Opcodes.PUTSTATIC:
198                 return null;
199             case Opcodes.GETFIELD:
200                 return new TrackingValue(Type.getType(((FieldInsnNode) insn).desc), insn);
201             case Opcodes.NEWARRAY:
202                 switch (((IntInsnNode) insn).operand) {
203                     case Opcodes.T_BOOLEAN:
204                         return new TrackingValue(Type.getType("[Z"), insn);
205                     case Opcodes.T_CHAR:
206                         return new TrackingValue(Type.getType("[C"), insn);
207                     case Opcodes.T_BYTE:
208                         return new TrackingValue(Type.getType("[B"), insn);
209                     case Opcodes.T_SHORT:
210                         return new TrackingValue(Type.getType("[S"), insn);
211                     case Opcodes.T_INT:
212                         return new TrackingValue(Type.getType("[I"), insn);
213                     case Opcodes.T_FLOAT:
214                         return new TrackingValue(Type.getType("[F"), insn);
215                     case Opcodes.T_DOUBLE:
216                         return new TrackingValue(Type.getType("[D"), insn);
217                     case Opcodes.T_LONG:
218                         return new TrackingValue(Type.getType("[J"), insn);
219                     default:
220                         throw new AnalyzerException(insn, "Invalid array type");
221                 }
222             case Opcodes.ANEWARRAY: {
223                 final String desc = ((TypeInsnNode) insn).desc;
224                 return new TrackingValue(Type.getType("[" + Type.getObjectType(desc)), insn);
225             }
226             case Opcodes.ARRAYLENGTH:
227                 return new TrackingValue(Type.INT_TYPE, insn);
228             case Opcodes.ATHROW:
229                 return null;
230             case Opcodes.CHECKCAST: {
231                 final String desc = ((TypeInsnNode) insn).desc;
232                 return new TrackingValue(Type.getObjectType(desc), insn);
233             }
234             case Opcodes.INSTANCEOF:
235                 return new TrackingValue(Type.INT_TYPE, insn);
236             case Opcodes.MONITORENTER:
237             case Opcodes.MONITOREXIT:
238             case Opcodes.IFNULL:
239             case Opcodes.IFNONNULL:
240                 return null;
241             default:
242                 throw DifferentiationException.createInternalError(null);
243         }
244     }
245 
246     /** {@inheritDoc} */
247     public TrackingValue binaryOperation(final AbstractInsnNode insn,
248                                          final TrackingValue value1, final TrackingValue value2)
249         throws AnalyzerException {
250         ((TrackingValue) value1).addConsumer(insn);
251         ((TrackingValue) value2).addConsumer(insn);
252         switch (insn.getOpcode()) {
253             case Opcodes.IALOAD:
254             case Opcodes.BALOAD:
255             case Opcodes.CALOAD:
256             case Opcodes.SALOAD:
257             case Opcodes.IADD:
258             case Opcodes.ISUB:
259             case Opcodes.IMUL:
260             case Opcodes.IDIV:
261             case Opcodes.IREM:
262             case Opcodes.ISHL:
263             case Opcodes.ISHR:
264             case Opcodes.IUSHR:
265             case Opcodes.IAND:
266             case Opcodes.IOR:
267             case Opcodes.IXOR:
268                 return new TrackingValue(Type.INT_TYPE, insn);
269             case Opcodes.FALOAD:
270             case Opcodes.FADD:
271             case Opcodes.FSUB:
272             case Opcodes.FMUL:
273             case Opcodes.FDIV:
274             case Opcodes.FREM:
275                 return new TrackingValue(Type.FLOAT_TYPE, insn);
276             case Opcodes.LALOAD:
277             case Opcodes.LADD:
278             case Opcodes.LSUB:
279             case Opcodes.LMUL:
280             case Opcodes.LDIV:
281             case Opcodes.LREM:
282             case Opcodes.LSHL:
283             case Opcodes.LSHR:
284             case Opcodes.LUSHR:
285             case Opcodes.LAND:
286             case Opcodes.LOR:
287             case Opcodes.LXOR:
288                 return new TrackingValue(Type.LONG_TYPE, insn);
289             case Opcodes.DALOAD:
290             case Opcodes.DADD:
291             case Opcodes.DSUB:
292             case Opcodes.DMUL:
293             case Opcodes.DDIV:
294             case Opcodes.DREM:
295                 return new TrackingValue(Type.DOUBLE_TYPE, insn);
296             case Opcodes.AALOAD:
297                 return new TrackingValue(Type.getType(Object.class), insn); // reference value
298             case Opcodes.LCMP:
299             case Opcodes.FCMPL:
300             case Opcodes.FCMPG:
301             case Opcodes.DCMPL:
302             case Opcodes.DCMPG:
303                 return new TrackingValue(Type.INT_TYPE, insn);
304             case Opcodes.IF_ICMPEQ:
305             case Opcodes.IF_ICMPNE:
306             case Opcodes.IF_ICMPLT:
307             case Opcodes.IF_ICMPGE:
308             case Opcodes.IF_ICMPGT:
309             case Opcodes.IF_ICMPLE:
310             case Opcodes.IF_ACMPEQ:
311             case Opcodes.IF_ACMPNE:
312             case Opcodes.PUTFIELD:
313                 return null;
314             default:
315                 throw DifferentiationException.createInternalError(null);
316         }
317     }
318 
319     /** {@inheritDoc} */
320     public TrackingValue ternaryOperation(final AbstractInsnNode insn,
321                                           final TrackingValue value1, final TrackingValue value2,
322                                           final TrackingValue value3)
323         throws AnalyzerException {
324         value1.addConsumer(insn);
325         value2.addConsumer(insn);
326         value3.addConsumer(insn);
327         return new TrackingValue(null, insn);
328     }
329 
330     /** {@inheritDoc} */
331     public TrackingValue naryOperation(final AbstractInsnNode insn, final List<? extends TrackingValue> values)
332         throws AnalyzerException {
333         for (final Iterator<?> iterator = values.iterator(); iterator.hasNext();) {
334             ((TrackingValue) iterator.next()).addConsumer(insn);
335         }
336         final int opcode = insn.getOpcode();
337         if (opcode == Opcodes.MULTIANEWARRAY) {
338             return new TrackingValue(Type.getType(((MultiANewArrayInsnNode) insn).desc), insn);
339         } else if (opcode == Opcodes.INVOKEDYNAMIC) {
340             return new TrackingValue(Type.getReturnType(((InvokeDynamicInsnNode) insn).desc), insn);
341         } else {
342             return new TrackingValue(Type.getReturnType(((MethodInsnNode) insn).desc), insn);
343         }
344     }
345 
346     /** {@inheritDoc} */
347     public TrackingValue copyOperation(final AbstractInsnNode insn, final TrackingValue value)
348         throws AnalyzerException {
349         // we reuse the same instance instead of wrapping it again
350         // thus simplifying transitive dependencies propagation
351         value.addConsumer(insn);
352         value.addProducer(insn);
353         return value;
354     }
355 
356     /** {@inheritDoc} */
357     public TrackingValue merge(final TrackingValue v, final TrackingValue w) {
358         TrackingValue.merge(v, w);
359         return v;
360     }
361 
362     /** {@inheritDoc} */
363     public void returnOperation(final AbstractInsnNode insn,
364                                 final TrackingValue value, final TrackingValue expected) {
365         // nothing to do here, as unaryOperation has already been called
366     }
367 
368 }