} else if (instr instanceof SSAAbstractInvokeInstruction) { SSAAbstractInvokeInstruction callInst = (SSAAbstractInvokeInstruction) instr; String sign = callInst.getDeclaredTarget().getSignature(); if (((SSAAbstractInvokeInstruction) instr).isStatic()) {
@Override public String getSignature() { return ref.getSignature(); }
@Override public String getSignature() { return ref.getSignature(); }
@Override public String getSignature() { return getReference().getSignature(); }
@Override public String getSignature() { return getReference().getSignature(); }
@Override public String getSignature() { return getReference().getSignature(); }
@Override public String getSignature() { return getReference().getSignature(); }
@Override public String getSignature() { return getReference().getSignature(); }
@Override public String getSignature() { return getReference().getSignature(); }
/** * Checks whether some instruction is both an {@link com.ibm.wala.ssa.SSAInvokeInstruction} and if its signature * matches a given signature * @param ins an {@link com.ibm.wala.ssa.SSAInstruction} * @param methodSignature a method signature to check against * @return */ public static boolean checkMethodSignature(final SSAInstruction ins, final String methodSignature) { if (ins instanceof SSAInvokeInstruction) { final SSAInvokeInstruction inv = (SSAInvokeInstruction) ins; return inv.getDeclaredTarget().getSignature().equals(methodSignature); } return false; }
public Export(LibDependencies deps) { this.version = deps.version.toString(); for (IMethod m: deps.api2Dependencies.keySet()) this.api2Dependencies.put(m.getSignature(), deps.api2Dependencies.get(m).stream().map(c -> c.getDeclaredTarget().getSignature()).collect(Collectors.toSet())); } }
protected Map<Version, DependencyAnalysis.LibDependencies> run(LibApiStats stats) { Map<Version, LibDependencies> version2Deps = new TreeMap<Version, LibDependencies>(); for (Version version: stats.getVersions()) { logger.info(Utils.INDENT + "- version: " + version); Map<IMethod, Set<CallSiteReference>> api2Dependencies = analyzeDependencies(stats.getDocumentedAPIs(version)); version2Deps.put(version, new LibDependencies(version, api2Dependencies)); } // debug collect all dependencies (APIs) per lib (incl. all versions) Set<String> signatures = new TreeSet<String>(); version2Deps.values(). forEach(ld -> { ld.api2Dependencies.values() .forEach(set -> { set.forEach(csf -> signatures.add(PackageUtils.getPackageName(csf.getDeclaredTarget().getSignature()))); }) ;} ); logger.info(Utils.INDENT + "-> Dependencies of " + stats.libName); signatures.forEach(s -> logger.info(Utils.INDENT2 + "- dep: " + s)); PackageTree pt = PackageTree.make(signatures); pt.print(true); /// TODO show empty packages + non-empty on depth == 1 return version2Deps; }
throw new IllegalArgumentException("The SSA-Value " + number + " (with added offset " + descriptorOffset + ") is beyond the number of Arguments (" + mRef.getNumberOfParameters() + ") of the Method " + mRef.getName() + '\n' + mRef.getSignature());
throw new IllegalArgumentException("The SSA-Value " + number + " (with added offset " + descriptorOffset + ") is beyond the number of Arguments (" + mRef.getNumberOfParameters() + ") of the Method " + mRef.getName() + '\n' + mRef.getSignature());
@Override public String descString() { if(isSource()) { SSAInvokeInstruction inv = (SSAInvokeInstruction)getBlock().getLastInstruction(); return "ret:" + inv.getDeclaredTarget().getSignature(); } else { return "ret"; } }
logger.trace(" ## unresolved call: " + csf.getDeclaredTarget().getSignature() + (csf.isInterface() ? " [Interface]" : "")); unresolvedCalls.add(csf); logger.debug("- Method: " + m.getSignature()); secDeps.get(m).stream() .map(c -> c.getDeclaredTarget().getSignature()) .sorted().distinct() .forEach(s -> logger.debug(" - dep: " + s));
if (csr.getDeclaredTarget().getSignature().startsWith(rootPckg) && !WalaUtils.simpleName(im.getDeclaringClass()).startsWith(rootPckg)) { logger.debug(Utils.INDENT + "Unresolvable class for lib method in use: " + csr.getDeclaredTarget().getSignature()); if (!unresolvableMethods.containsKey(rootPckg2Lib.get(rootPckg))) unresolvableMethods.put(rootPckg2Lib.get(rootPckg), new TreeSet<String>()); unresolvableMethods.get(rootPckg2Lib.get(rootPckg)).add(csr.getDeclaredTarget().getSignature()); break; logger.trace(Utils.INDENT + "- method in use (in " + (usedInApp? "app" : "lib") +"): " + csr.getDeclaredTarget().getSignature() + " in bm: "+ im.getSignature() + " access: " + accessSpec); String normalizedSig = csr.getDeclaredTarget().getSignature(); String rx2 = lib2Profile.get(rootPckg2Lib.get(rootPckg)).lib.packageTree.getRootPackage().replaceAll("\\.", "/"); normalizedSig = csr.getDeclaredTarget().getSignature().replaceAll(r,rx).replaceAll(r2,rx2);
@Override public String descString() { String s = "arg(" + argNum + ')'; if(!getBlock().isEntryBlock()) { SSAInvokeInstruction inv = (SSAInvokeInstruction) ((IExplodedBasicBlock) getBlock().getDelegate()).getInstruction(); s = s + ':' + inv.getDeclaredTarget().getSignature(); } return s; }
this.monitor.subTask(ep.getMethod().getReference().getSignature() );
/** * 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; } }