/** * @return something like: com.foo.bar.createLargeOrder(IILjava/lang/String;Ljava/sql/Date;)Ljava/lang/Integer; */ @Override public String getSignature() { // TODO: check that we're not calling this often. String s = getDeclaringClass().getName().toString().substring(1).replace('/', '.') + '.' + getName() + getDescriptor(); return s; }
@Override public Selector getSelector() { return ref.getSelector(); }
@Override public TypeReference getReturnType() { return ref.getReturnType(); }
@Override public TypeReference getParameterType(int i) { if (isStatic()) { return method.getParameterType(i); } else { if (i == 0) { return method.getDeclaringClass(); } else { return method.getParameterType(i - 1); } } }
/** * return true iff m represents one of the well-known methods in * java.lang.reflect.Arrays that do some sort of arraycopy */ private static boolean isArrayCopyMethod(MethodReference m) { if (m.getDeclaringClass().equals(Arrays)) { if (m.getName().equals(asList) || m.getName().equals(copyOf) || m.getName().equals(copyOfRange)) { return true; } } return false; }
public static MethodReference findOrCreate(Language l, ClassLoaderReference loader, String methodClass, String methodName, String methodSignature) throws IllegalArgumentException { TypeReference t = ShrikeUtil.makeTypeReference(loader, methodClass); Atom name = Atom.findOrCreateUnicodeAtom(methodName); Descriptor d = Descriptor.findOrCreateUTF8(l, methodSignature); return findOrCreate(t, name, d); }
@Override protected boolean sameMethod(CGNode opNode, String definingMethod) { MethodReference reference = opNode.getMethod().getReference(); String selector = reference.getSelector().toString(); String containingClass = reference.getDeclaringClass().getName().toString(); return definingMethod.equals(containingClass + '/' + selector); }
private static Atom getLanguage(CallSiteReference site) { return site .getDeclaredTarget() .getDeclaringClass() .getClassLoader() .getLanguage(); }
private MethodReference trampoline() { try { return MethodReference.findOrCreate(LambdaSummaryClass.this.getReference(), invoke.getDeclaredTarget().getName(), Descriptor.findOrCreateUTF8(getLambdaDeclaredSignature())); } catch (IllegalArgumentException | InvalidClassFileException e) { assert false : e; return null; } }
} else if (instr instanceof SSAAbstractInvokeInstruction) { SSAAbstractInvokeInstruction callInst = (SSAAbstractInvokeInstruction) instr; String sign = callInst.getDeclaredTarget().getSignature(); if (((SSAAbstractInvokeInstruction) instr).isStatic()) {
@Override public String toString() { return "ctxt:" + method.getName(); } }
/** * If s is a call statement, return the statement representing the normal return from s */ public static Statement getReturnStatementForCall(Statement s) { if (s.getKind() == Kind.NORMAL) { NormalStatement n = (NormalStatement) s; SSAInstruction st = n.getInstruction(); if (st instanceof SSAInvokeInstruction) { SSAAbstractInvokeInstruction call = (SSAAbstractInvokeInstruction) st; if (call.getCallSite().getDeclaredTarget().getReturnType().equals(TypeReference.Void)) { throw new IllegalArgumentException("this driver computes forward slices from the return value of calls.\n" + "Method " + call.getCallSite().getDeclaredTarget().getSignature() + " returns void."); } return new NormalReturnCaller(s.getNode(), n.getInstructionIndex()); } else { return s; } } else { return s; } }
@Override public Descriptor getDescriptor() { return ref.getDescriptor(); }
/** * return true iff m represents one of the well-known methods in java.lang.reflect.Arrays that do toString() on an array */ private static boolean isArrayToStringMethod(MethodReference m) { if (m.getDeclaringClass().equals(Arrays)) { if (m.getName().equals(toString)) { return true; } } return false; }
private static MethodReference genSyntheticMethodRef(IClass receiver) { Atom atom = Atom.findOrCreateUnicodeAtom(SYNTHETIC_APPLY_METHOD_PREFIX); Descriptor desc = Descriptor.findOrCreateUTF8(JavaScriptLoader.JS, "()LRoot;"); MethodReference ref = MethodReference.findOrCreate(receiver.getReference(), atom, desc); return ref; }
@Override protected boolean sameMethod(CGNode opNode, String definingMethod) { MethodReference reference = opNode.getMethod().getReference(); String selector = reference.getSelector().toString(); String containingClass = reference.getDeclaringClass().getName().toString(); return definingMethod.equals(containingClass + '/' + selector); }
@Override public void visitNew(NewInstruction instruction) { ClassLoaderReference loader = getReference().getDeclaringClass().getClassLoader(); TypeReference t = ShrikeUtil.makeTypeReference(loader, instruction.getType()); newSites.add(NewSiteReference.make(getProgramCounter(), t)); }
private MethodReference trampoline() { try { return MethodReference.findOrCreate(LambdaSummaryClass.this.getReference(), invoke.getDeclaredTarget().getName(), Descriptor.findOrCreateUTF8(getLambdaDeclaredSignature())); } catch (IllegalArgumentException | InvalidClassFileException e) { assert false : e; return null; } }
@Override public String getSignature() { return ref.getSignature(); }