soot.SootClass.addMethod java code examples

Common ways to obtain SootClass

private void myMethod () {
 SootClass s =String className;Scene.v().getSootClass(className)
SootMethod sm;sm.getDeclaringClass()
RefType refType;refType.getSootClass()
Smart code suggestions by Tabnine
}

private void addProcedureToClass(soot.SootMethod method) {
 sootClass.addMethod(method);
}

/**
 * Changes the set of parameter types of this method.
 */
public synchronized void setParameterTypes(List<Type> l) {
 boolean wasDeclared = isDeclared;
 SootClass oldDeclaringClass = declaringClass;
 if (wasDeclared) {
  oldDeclaringClass.removeMethod(this);
 }
 this.parameterTypes = l.toArray(new Type[l.size()]);
 subSig = null;
 sig = null;
 subsignature = Scene.v().getSubSigNumberer().findOrAdd(getSubSignature());
 if (wasDeclared) {
  oldDeclaringClass.addMethod(this);
 }
}

public MonitorConverter(Singletons.Global g) {
 SootClass davaMonitor = new SootClass("soot.dava.toolkits.base.DavaMonitor.DavaMonitor", Modifier.PUBLIC);
 davaMonitor.setSuperclass(Scene.v().loadClassAndSupport("java.lang.Object"));
 LinkedList objectSingleton = new LinkedList();
 objectSingleton.add(RefType.v("java.lang.Object"));
 v = Scene.v().makeSootMethod("v", new LinkedList(), RefType.v("soot.dava.toolkits.base.DavaMonitor.DavaMonitor"),
   Modifier.PUBLIC | Modifier.STATIC);
 enter = Scene.v().makeSootMethod("enter", objectSingleton, VoidType.v(), Modifier.PUBLIC | Modifier.SYNCHRONIZED);
 exit = Scene.v().makeSootMethod("exit", objectSingleton, VoidType.v(), Modifier.PUBLIC | Modifier.SYNCHRONIZED);
 davaMonitor.addMethod(v);
 davaMonitor.addMethod(enter);
 davaMonitor.addMethod(exit);
 Scene.v().addClass(davaMonitor);
}

public void outAMethodMember(AMethodMember node) {
 int modifier = 0;
 Type type;
 String name;
 List parameterList = null;
 List<SootClass> throwsClause = null;
 if (node.getThrowsClause() != null) {
  throwsClause = (List<SootClass>) mProductions.removeLast();
 }
 if (node.getParameterList() != null) {
  parameterList = (List) mProductions.removeLast();
 } else {
  parameterList = new ArrayList();
 }
 Object o = mProductions.removeLast();
 name = (String) o;
 type = (Type) mProductions.removeLast();
 modifier = processModifiers(node.getModifier());
 SootMethod method;
 if (throwsClause != null) {
  method = Scene.v().makeSootMethod(name, parameterList, type, modifier, throwsClause);
 } else {
  method = Scene.v().makeSootMethod(name, parameterList, type, modifier);
 }
 mSootClass.addMethod(method);
}

private void addDispatch(String name, SootClass tclass, MethodType implMethodType, MethodType instantiatedMethodType,
  List<SootField> capFields, MethodHandle implMethod) {
 ThunkMethodSource ms = new ThunkMethodSource(capFields, implMethodType, implMethod, instantiatedMethodType);
 SootMethod m = new SootMethod(name, implMethodType.getParameterTypes(), implMethodType.getReturnType(), Modifier.PUBLIC);
 tclass.addMethod(m);
 m.setSource(ms);
}

/** Sets the name of this method. */
public synchronized void setName(String name) {
 boolean wasDeclared = isDeclared;
 SootClass oldDeclaringClass = declaringClass;
 if (wasDeclared) {
  oldDeclaringClass.removeMethod(this);
 }
 this.name = name;
 subSig = null;
 sig = null;
 subsignature = Scene.v().getSubSigNumberer().findOrAdd(getSubSignature());
 if (wasDeclared) {
  oldDeclaringClass.addMethod(this);
 }
}

/** Sets the return type of this method. */
public synchronized void setReturnType(Type t) {
 boolean wasDeclared = isDeclared;
 SootClass oldDeclaringClass = declaringClass;
 if (wasDeclared) {
  oldDeclaringClass.removeMethod(this);
 }
 returnType = t;
 subSig = null;
 sig = null;
 subsignature = Scene.v().getSubSigNumberer().findOrAdd(getSubSignature());
 if (wasDeclared) {
  oldDeclaringClass.addMethod(this);
 }
}

/**
 * @ast method
 * @aspect EmitJimple
 * @declaredat /Users/eric/Documents/workspaces/clara-soot/JastAddExtensions/JimpleBackend/EmitJimple.jrag:145
 */
public void jimplify1phase2() {
  if (needsClinit() && !getSootClassDecl().declaresMethod("<clinit>", new ArrayList())) {
    clinit = Scene.v().makeSootMethod("<clinit>", new ArrayList(), soot.VoidType.v(), soot.Modifier.STATIC,
        new ArrayList());
    getSootClassDecl().addMethod(clinit);
  }
  for (Iterator iter = nestedTypes().iterator(); iter.hasNext();) {
    TypeDecl typeDecl = (TypeDecl) iter.next();
    typeDecl.jimplify1phase2();
  }
  for (int i = 0; i < getNumBodyDecl(); i++)
    if (getBodyDecl(i).generate())
      getBodyDecl(i).jimplify1phase2();
  addAttributes();
}

mSootClass.addMethod(method);

/**
 * Loads a single method from a dex file
 *
 * @param method
 *          The method to load
 * @param declaringClass
 *          The class that declares the method to load
 * @param annotations
 *          The worker object for handling annotations
 * @param dexMethodFactory
 *          The factory method for creating dex methods
 */
protected void loadMethod(Method method, SootClass declaringClass, DexAnnotation annotations, DexMethod dexMethodFactory) {
 SootMethod sm = dexMethodFactory.makeSootMethod(method);
 if (declaringClass.declaresMethod(sm.getName(), sm.getParameterTypes(), sm.getReturnType())) {
  return;
 }
 declaringClass.addMethod(sm);
 annotations.handleMethodAnnotation(sm, method);
}

private soot.SootMethod makeLiFieldAccessMethod(soot.SootClass classToInvoke, polyglot.types.LocalInstance li) {
 String name = "access$" + soot.javaToJimple.InitialResolver.v().getNextPrivateAccessCounter() + "00";
 ArrayList paramTypes = new ArrayList();
 paramTypes.add(classToInvoke.getType());
 soot.SootMethod meth = Scene.v().makeSootMethod(name, paramTypes, Util.getSootType(li.type()), soot.Modifier.STATIC);
 classToInvoke.addMethod(meth);
 PrivateFieldAccMethodSource src
   = new PrivateFieldAccMethodSource(Util.getSootType(li.type()), "val$" + li.name(), false, classToInvoke);
 meth.setActiveBody(src.getBody(meth, null));
 meth.addTag(new soot.tagkit.SyntheticTag());
 return meth;
}

private static soot.SootMethod makeOuterThisAccessMethod(soot.SootClass classToInvoke) {
 String name = "access$" + soot.javaToJimple.InitialResolver.v().getNextPrivateAccessCounter() + "00";
 ArrayList paramTypes = new ArrayList();
 paramTypes.add(classToInvoke.getType());
 soot.SootMethod meth
   = Scene.v().makeSootMethod(name, paramTypes, classToInvoke.getFieldByName("this$0").getType(), soot.Modifier.STATIC);
 classToInvoke.addMethod(meth);
 PrivateFieldAccMethodSource src = new PrivateFieldAccMethodSource(classToInvoke.getFieldByName("this$0").getType(),
   "this$0", classToInvoke.getFieldByName("this$0").isStatic(), classToInvoke);
 meth.setActiveBody(src.getBody(meth, null));
 meth.addTag(new soot.tagkit.SyntheticTag());
 return meth;
}

addToClass.addMethod(sootMethod);
sootMethod.addTag(new soot.tagkit.SyntheticTag());

/**
 * @ast method
 * @aspect EmitJimple
 * @declaredat /Users/eric/Documents/workspaces/clara-soot/JastAddExtensions/JimpleBackend/EmitJimple.jrag:210
 */
public void jimplify1phase2() {
  String name = name();
  ArrayList parameters = new ArrayList();
  ArrayList paramnames = new ArrayList();
  for (int i = 0; i < getNumParameter(); i++) {
    parameters.add(getParameter(i).type().getSootType());
    paramnames.add(getParameter(i).name());
  }
  soot.Type returnType = type().getSootType();
  int modifiers = sootTypeModifiers();
  ArrayList throwtypes = new ArrayList();
  for (int i = 0; i < getNumException(); i++)
    throwtypes.add(getException(i).type().getSootClassDecl());
  String signature = SootMethod.getSubSignature(name, parameters, returnType);
  if (!hostType().getSootClassDecl().declaresMethod(signature)) {
    SootMethod m = Scene.v().makeSootMethod(name, parameters, returnType, modifiers, throwtypes);
    hostType().getSootClassDecl().addMethod(m);
    m.addTag(new soot.tagkit.ParamNamesTag(paramnames));
    sootMethod = m;
  } else {
    sootMethod = hostType().getSootClassDecl().getMethod(signature);
  }
  addAttributes();
}

private SootMethod getOrCreateInitializer(SootClass sc, Set<SootField> alreadyInitialized) {
 SootMethod smInit;
 // Create a static initializer if we don't already have one
 smInit = sc.getMethodByNameUnsafe(SootMethod.staticInitializerName);
 if (smInit == null) {
  smInit = Scene.v().makeSootMethod(SootMethod.staticInitializerName, Collections.<Type>emptyList(), VoidType.v());
  smInit.setActiveBody(Jimple.v().newBody(smInit));
  sc.addMethod(smInit);
  smInit.setModifiers(Modifier.PUBLIC | Modifier.STATIC);
 } else if (smInit.isPhantom()) {
  return null;
 } else {
  smInit.retrieveActiveBody();
  // We need to collect those variables that are already initialized
  // somewhere
  for (Unit u : smInit.getActiveBody().getUnits()) {
   Stmt s = (Stmt) u;
   for (ValueBox vb : s.getDefBoxes()) {
    if (vb.getValue() instanceof FieldRef) {
     alreadyInitialized.add(((FieldRef) vb.getValue()).getField());
    }
   }
  }
 }
 return smInit;
}

private soot.SootMethod addGetMethodAccessMeth(soot.SootClass conClass, polyglot.ast.Call call) {
 if ((InitialResolver.v().getPrivateMethodGetAccessMap() != null) && (InitialResolver.v().getPrivateMethodGetAccessMap()
   .containsKey(new polyglot.util.IdentityKey(call.methodInstance())))) {
  return InitialResolver.v().getPrivateMethodGetAccessMap().get(new polyglot.util.IdentityKey(call.methodInstance()));
 }
 String name = "access$" + soot.javaToJimple.InitialResolver.v().getNextPrivateAccessCounter() + "00";
 ArrayList paramTypes = new ArrayList();
 if (!call.methodInstance().flags().isStatic()) {
  // add this param type
  // paramTypes.add(Util.getSootType(call.methodInstance().container()));
  paramTypes.add(conClass.getType());
 }
 ArrayList sootParamsTypes = getSootParamsTypes(call);
 paramTypes.addAll(sootParamsTypes);
 soot.SootMethod meth = Scene.v().makeSootMethod(name, paramTypes, Util.getSootType(call.methodInstance().returnType()),
   soot.Modifier.STATIC);
 PrivateMethodAccMethodSource pmams = new PrivateMethodAccMethodSource(call.methodInstance());
 conClass.addMethod(meth);
 meth.setActiveBody(pmams.getBody(meth, null));
 InitialResolver.v().addToPrivateMethodGetAccessMap(call, meth);
 meth.addTag(new soot.tagkit.SyntheticTag());
 return meth;
}

private soot.SootMethod addGetFieldAccessMeth(soot.SootClass conClass, polyglot.ast.Field field) {
 if ((InitialResolver.v().getPrivateFieldGetAccessMap() != null) && (InitialResolver.v().getPrivateFieldGetAccessMap()
   .containsKey(new polyglot.util.IdentityKey(field.fieldInstance())))) {
  return InitialResolver.v().getPrivateFieldGetAccessMap().get(new polyglot.util.IdentityKey(field.fieldInstance()));
 }
 String name = "access$" + soot.javaToJimple.InitialResolver.v().getNextPrivateAccessCounter() + "00";
 ArrayList paramTypes = new ArrayList();
 if (!field.flags().isStatic()) {
  // add this param type
  paramTypes.add(conClass.getType());// (soot.Local)getBaseLocal(field.target()));
  // paramTypes.add(Util.getSootType(field.target().type()));
 }
 soot.SootMethod meth = Scene.v().makeSootMethod(name, paramTypes, Util.getSootType(field.type()), soot.Modifier.STATIC);
 PrivateFieldAccMethodSource pfams
   = new PrivateFieldAccMethodSource(Util.getSootType(field.type()), field.name(), field.flags().isStatic(), conClass);
 conClass.addMethod(meth);
 meth.setActiveBody(pfams.getBody(meth, null));
 InitialResolver.v().addToPrivateFieldGetAccessMap(field, meth);
 meth.addTag(new soot.tagkit.SyntheticTag());
 return meth;
}

private soot.SootMethod addSetAccessMeth(soot.SootClass conClass, polyglot.ast.Field field, soot.Value param) {
 if ((InitialResolver.v().getPrivateFieldSetAccessMap() != null) && (InitialResolver.v().getPrivateFieldSetAccessMap()
   .containsKey(new polyglot.util.IdentityKey(field.fieldInstance())))) {
  return InitialResolver.v().getPrivateFieldSetAccessMap().get(new polyglot.util.IdentityKey(field.fieldInstance()));
 }
 String name = "access$" + soot.javaToJimple.InitialResolver.v().getNextPrivateAccessCounter() + "00";
 ArrayList paramTypes = new ArrayList();
 if (!field.flags().isStatic()) {
  // add this param type
  paramTypes.add(conClass.getType());
  // paramTypes.add(Util.getSootType(field.target().type()));
 }
 soot.Type retType;
 paramTypes.add(Util.getSootType(field.type()));
 retType = Util.getSootType(field.type());
 /*
  * if (param.getType() instanceof soot.NullType){ paramTypes.add(soot.RefType.v("java.lang.Object")); retType =
  * soot.RefType.v("java.lang.Object"); } else { paramTypes.add(param.getType()); retType = param.getType(); }
  */
 soot.SootMethod meth = Scene.v().makeSootMethod(name, paramTypes, retType, soot.Modifier.STATIC);
 PrivateFieldSetMethodSource pfsms
   = new PrivateFieldSetMethodSource(Util.getSootType(field.type()), field.name(), field.flags().isStatic());
 conClass.addMethod(meth);
 meth.setActiveBody(pfsms.getBody(meth, null));
 InitialResolver.v().addToPrivateFieldSetAccessMap(field, meth);
 meth.addTag(new soot.tagkit.SyntheticTag());
 return meth;
}

private soot.SootMethod makeSuperAccessMethod(soot.SootClass classToInvoke, Object memberToAccess) {
 String name = "access$" + soot.javaToJimple.InitialResolver.v().getNextPrivateAccessCounter() + "00";
 ArrayList paramTypes = new ArrayList();
 paramTypes.add(classToInvoke.getType());
 soot.SootMethod meth;
 soot.MethodSource src;
 if (memberToAccess instanceof polyglot.ast.Field) {
  polyglot.ast.Field fieldToAccess = (polyglot.ast.Field) memberToAccess;
  meth = Scene.v().makeSootMethod(name, paramTypes, Util.getSootType(fieldToAccess.type()), soot.Modifier.STATIC);
  PrivateFieldAccMethodSource fSrc = new PrivateFieldAccMethodSource(Util.getSootType(fieldToAccess.type()),
    fieldToAccess.name(), fieldToAccess.flags().isStatic(),
    ((soot.RefType) Util.getSootType(fieldToAccess.target().type())).getSootClass());
  src = fSrc;
 } else if (memberToAccess instanceof polyglot.ast.Call) {
  polyglot.ast.Call methToAccess = (polyglot.ast.Call) memberToAccess;
  paramTypes.addAll(getSootParamsTypes(methToAccess));
  meth = Scene.v().makeSootMethod(name, paramTypes, Util.getSootType(methToAccess.methodInstance().returnType()),
    soot.Modifier.STATIC);
  PrivateMethodAccMethodSource mSrc = new PrivateMethodAccMethodSource(methToAccess.methodInstance());
  src = mSrc;
 } else {
  throw new RuntimeException("trying to access unhandled member type: " + memberToAccess);
 }
 classToInvoke.addMethod(meth);
 meth.setActiveBody(src.getBody(meth, null));
 meth.addTag(new soot.tagkit.SyntheticTag());
 return meth;
}

final SootMethod staticInitializerMethod = Scene.v().makeSootMethod(SootMethod.staticInitializerName,
  Collections.emptyList(), VoidType.v(), Modifier.STATIC);
sootClass.addMethod(staticInitializerMethod);
body = Jimple.v().newBody(staticInitializerMethod);
staticInitializerMethod.setActiveBody(body);

Javadoc

Adds the given method to this class.

Popular methods of SootClass

isInterface
Convenience method; returns true if this class is an interface.
getMethods
getName
Returns the name of this class.
setApplicationClass
Makes this class an application class.
getFields
Returns a backed Chain of fields.
getInterfaces
Returns a backed Chain of the interfaces that are directly implemented by this class. (see getInterf
getSuperclass
WARNING: interfaces are subclasses of the java.lang.Object class! Returns the superclass of this cla
hasSuperclass
WARNING: interfaces are subclasses of the java.lang.Object class! Does this class have a superclass?
resolvingLevel
declaresMethod
Does this class declare a method with the given subsignature?
getMethod
getType
Returns the RefType corresponding to this class.

Popular in Java

Parsing JSON documents to java classes using gson
scheduleAtFixedRate (ScheduledExecutorService)
onRequestPermissionsResult (Fragment)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
Window (java.awt)
A Window object is a top-level window with no borders and no menubar. The default layout for a windo
FileReader (java.io)
A specialized Reader that reads from a file in the file system. All read requests made by calling me
Executor (java.util.concurrent)
An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
Pattern (java.util.regex)
Patterns are compiled regular expressions. In many cases, convenience methods such as String#matches
Loader (org.hibernate.loader)
Abstract superclass of object loading (and querying) strategies. This class implements useful common
Location (org.springframework.beans.factory.parsing)
Class that models an arbitrary location in a Resource.Typically used to track the location of proble
21 Best Atom Packages for 2021

How to use addMethodmethodin soot.SootClass

Best Java code snippets using soot.SootClass.addMethod (Showing top 20 results out of 315)

How to use
addMethod
method
in
soot.SootClass