return b(1, Exprs.nNewArray("D", local)); default: throw new AnalyzerException(insn, "Invalid array type");
throw new AnalyzerException(insnNode, "RET instruction outside of a sub routine"); throw new AnalyzerException(e.node, "Error at instruction " + insn + ": " + e.getMessage(), e); } catch (Exception e) { throw new AnalyzerException(insnNode, "Error at instruction " + insn + ": " + e.getMessage(), e);
ex.printStackTrace(); throw new InternalError(ex.getMessage());
private void generateCDG(MethodNode mn) { if(BytecodeInstructionPool.getInstance(classLoader).hasMethod(className, mn.name + mn.desc)) return; BytecodeInstructionPool.getInstance(classLoader).registerMethodNode(mn, className, mn.name + mn.desc); // TODO: Adapt for multiple classLoaders BytecodeAnalyzer bytecodeAnalyzer = new BytecodeAnalyzer(); logger.info("Generating initial CFG for method " + mn.name); try { bytecodeAnalyzer.analyze(classLoader, className, mn.name + mn.desc, mn); // TODO } catch (AnalyzerException e) { logger.error("Analyzer exception while analyzing " + className + "." + mn.name + ": " + e); e.printStackTrace(); } // compute Raw and ActualCFG and put both into GraphPool bytecodeAnalyzer.retrieveCFGGenerator().registerCFGs(); }
throw new AnalyzerException(insnNode, "RET instruction outside of a sub routine"); throw new AnalyzerException(e.node, "Error at instruction " + insn + ": " + e.getMessage(), e); } catch (Exception e) { throw new AnalyzerException(insnNode, "Error at instruction " + insn + ": " + e.getMessage(), e);
logger.error("Analyzer exception while analyzing " + className + "." + methodName + ": " + e); e.printStackTrace();
@Override public void returnOperation(final AbstractInsnNode insn, final BasicValue value, final BasicValue expected) throws AnalyzerException { if (!isSubTypeOf(value, expected)) { throw new AnalyzerException(insn, "Incompatible return type", expected, value); } }
analyzer.analyze(classNode.name, method); } catch (AnalyzerException e) { e.printStackTrace(printWriter);
/** * Merges this frame with the given frame. * * @param frame * a frame. * @param interpreter * the interpreter used to merge values. * @return <tt>true</tt> if this frame has been changed as a result of the * merge operation, or <tt>false</tt> otherwise. * @throws AnalyzerException * if the frames have incompatible sizes. */ public boolean merge(final Frame<? extends V> frame, final Interpreter<V> interpreter) throws AnalyzerException { if (top != frame.top) { throw new AnalyzerException(null, "Incompatible stack heights"); } boolean changes = false; for (int i = 0; i < locals + top; ++i) { V v = interpreter.merge(values[i], frame.values[i]); if (!v.equals(values[i])) { values[i] = v; changes = true; } } return changes; }
analyzer.analyze(classNode.name, method); } catch (AnalyzerException e) { e.printStackTrace(printWriter);
public InstrumentMethod(MethodDatabase db, String className, MethodNode mn) throws AnalyzerException { this.db = db; this.className = className; this.mn = mn; try { Analyzer a = new TypeAnalyzer(db); this.frames = a.analyze(className, mn); this.lvarStack = mn.maxLocals; this.firstLocal = ((mn.access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC) ? 0 : 1; } catch (UnsupportedOperationException ex) { throw new AnalyzerException(null, ex.getMessage(), ex); } }
ex.printStackTrace(); accept(mv);
@Override public BasicValue binaryOperation(AbstractInsnNode insn, BasicValue value1, BasicValue value2) throws AnalyzerException { if(insn.getOpcode() == Opcodes.AALOAD) { Type t1 = value1.getType(); if(t1 == null || t1.getSort() != Type.ARRAY) { throw new AnalyzerException(insn, "AALOAD needs an array as first parameter"); } Type resultType = Type.getType(t1.getDescriptor().substring(1)); return new BasicValue(resultType); } return super.binaryOperation(insn, value1, value2); }
case ALOAD: if (!value.isReference()) { throw new AnalyzerException(insn, null, "an object reference", value); if (!value.isReference() && !BasicValue.RETURNADDRESS_VALUE.equals(value)) { throw new AnalyzerException(insn, null, "an object reference or a return address", value); throw new AnalyzerException(insn, null, expected, value);
for (int i = 0; i < values.size(); ++i) { if (!BasicValue.INT_VALUE.equals(values.get(i))) { throw new AnalyzerException(insn, null, BasicValue.INT_VALUE, values.get(i)); Type owner = Type.getObjectType(((MethodInsnNode) insn).owner); if (!isSubTypeOf(values.get(i++), newValue(owner))) { throw new AnalyzerException(insn, "Method owner", newValue(owner), values.get(0)); BasicValue encountered = values.get(i++); if (!isSubTypeOf(encountered, expected)) { throw new AnalyzerException(insn, "Argument " + j, expected, encountered);
throw new AnalyzerException(insn, "First argument", "a " + expected1 + " array reference", value1); } else if (!BasicValue.INT_VALUE.equals(value2)) { throw new AnalyzerException(insn, "Second argument", BasicValue.INT_VALUE, value2); } else if (!isSubTypeOf(value3, expected3)) { throw new AnalyzerException(insn, "Third argument", expected3, value3);
case CHECKCAST: if (!value.isReference()) { throw new AnalyzerException(insn, null, "an object reference", value); case ARRAYLENGTH: if (!isArrayValue(value)) { throw new AnalyzerException(insn, null, "an array reference", value); case IFNONNULL: if (!value.isReference()) { throw new AnalyzerException(insn, null, "an object reference", value); throw new AnalyzerException(insn, null, expected, value);
return newValue(Type.getType("[J")); default: throw new AnalyzerException(insn, "Invalid array type");
throw new AnalyzerException(insn, "First argument", expected1, value1); } else if (!isSubTypeOf(value2, expected2)) { throw new AnalyzerException(insn, "Second argument", expected2, value2);