Examples of de.petris.dynamicaspects.util.InstructionSearcher$LoadStoreConstraint

de.petris.dynamicaspects.util.InstructionSearcher
A constraint which checks the local variable index of a load- or store-instruction. We want a specific load or store so we need to check the variable index which is not included in the instruction for load/stores with indices higher than 3, but given as an argument: ASTORE_2 but ASTORE 5 @author Marco Petris

        targetClass.getMethods()[methodIdx], 
        targetClass.getClassName(),
      constPoolGen );


    // a searcher to look for the joinpoints
    InstructionSearcher searcher = 
      new InstructionSearcher( constPoolGen, mGen.getInstructionList() );
    
    // look for joinpoints
    List<CallMatch> targets = 
      searcher.lookUpMethodCall( 
          Pattern.compile( joinpointPattern ) );
    
    // a patcher for the given method
    CallWrapperMethodPatcher mp = 
      new CallWrapperMethodPatcher(

View Full Code Here

          targetClass.getMethods()[methodIdx.intValue()], 
          targetClass.getClassName(),
        constPoolGen );
      
      // get a searcher for the joinpoints
      InstructionSearcher searcher = 
        new InstructionSearcher( constPoolGen, mGen.getInstructionList() );
            
      // look for joinpoints
      List<CallMatch> targets = 
        searcher.lookUpMethodCall( joinpointPattern );
      
      // are there any joinpoints  matching the pattern in this methdod?
      if( !targets.isEmpty() ) {
        
        // yes, so we install a wrapper here

View Full Code Here

   */
  private void patchMethod() {
    
    // patch before starts here
    
    InstructionSearcher aFinder = 
      new InstructionSearcher( constPoolGen, iList );
    
    InstructionHandle first = null;
    
    // respect the super() and this(...)-call at the 
    // beginning of constructors
    if( mGen.getName().equals( CONSTRUCTOR_NAME ) ) {
      first = aFinder.lookUpSuperConstructorCall().getNext(); 
    }
    else {  
      first = iList.getStart();
    }
    
    // save return statement
    InstructionHandle last = iList.getEnd();


    ExecutionWrapperVariableHandler vHandler 
      = new ExecutionWrapperVariableHandler( 
          mGen, iList, factory, constPoolGen );
    
    // create variable for argumentList
    int argListVarIdx = 
      vHandler.createArgumentList( first );
    
    // create variable for executionwrapper
    int executionWrapperIdx = 
      vHandler.createExecutionWrapper( first );
    
    // BEFORE CALL
    
    // load the executionwrapper
    iList.insert( first, 
      InstructionFactory.createLoad( 
        EXECUTIONWRAPPERTYPE,  executionWrapperIdx ) );
    
    // load parameter for before()-call
    iList.insert( 
      first, 
      InstructionFactory.createLoad( 
        ExecutionWrapperVariableHandler.ARGLIST_TYPE, 
        argListVarIdx ) );
      
    // call before()
    iList.insert( 
      first,
      factory.createInvoke(
        ExecutionWrapper.class.getName(), 
        Wrapper.getBeforeName(), 
        Type.VOID, 
        new Type[] { 
          ExecutionWrapperVariableHandler.ARGLIST_TYPE },
        INVOKEVIRTUAL ) );


    
    // look for all return-statements
    List<InstructionHandle> returnStatements = 
      aFinder.lookUpReturnStatements();
    Iterator<InstructionHandle> iter = returnStatements.iterator();
    
    while( iter.hasNext() ) {
      
      InstructionHandle curReturnStatement = iter.next();

View Full Code Here

   * Unpatches the method.
   */
  private void unpatchMethod() {


    // a finder for instructions
    InstructionSearcher aFinder = 
      new InstructionSearcher( constPoolGen, iList );
    
    // lookup before() call
    List<InstructionHandle> beforeList = 
      aFinder.lookUpMethodCall( 
        ExecutionWrapper.class.getName(),
        Wrapper.getBeforeName(), 
        Wrapper.getBeforeSignature() );  
    
    // save before() call
    InstructionHandle beforeCall = beforeList.get(0);
    
    // look for all return-statements
    List<InstructionHandle> returnStatements =
      aFinder.lookUpReturnStatementsSkipLast();
    Iterator<InstructionHandle> iter = returnStatements.iterator();


    InstructionHandle exceptionHandler = null;
    
    while( iter.hasNext() ) {
      
      InstructionHandle curReturnStatement = iter.next();
      
      InstructionHandle last = curReturnStatement.getPrev();
      // save the exceptionhandler for the removeExceptionHandler-call, 
      // ( we want the statement before the last return ) 
      
      exceptionHandler = curReturnStatement.getNext();
      
      InstructionHandle first = last;
      
            // after()-call may have been complex or simple
            // depending on the return type of the target method
      if( mGen.getReturnType().equals( Type.VOID ) ) {
        first = first.getPrev();
      }
      else {
                // two instructions backward for cat2type-operation
        if( Reflection.isCat2Type( 
            mGen.getReturnType() ) ) {
          first = first.getPrev().getPrev();
        }
        else {
          first = first.getPrev();
        }


        first = first.getPrev();
        
        if( !(mGen.getReturnType() instanceof BasicType) ) {
          first = first.getPrev();
        }
      }
    
      // remove the after()-calls 
      try {
        iList.delete( first, last );
      }
      catch( TargetLostException tle ) {
        Logger.debug( "removing after()-calls: %s", tle.toString() );
      }
    }
    
    removeExceptionHandler( exceptionHandler );
    
    // remove catch() block
    try {
      iList.delete( 
        exceptionHandler,
        iList.getEnd() );
    }
    catch( TargetLostException tle ) {
      Logger.debug( "removing catch-block: %s", tle.toString() );
    }
    
    
    // remove variable creation and before call
    
    InstructionHandle first = null;
    
    // respect the super() and this(...)-call at the 
    // beginning of constructors
    if( mGen.getName().equals( CONSTRUCTOR_NAME ) ) {
      first = aFinder.lookUpSuperConstructorCall().getNext(); 
    }
    else {  
      first = iList.getStart();
    }

View Full Code Here

  /**
   * Installs the wrapper for all the target calls within this method.
   */
  private void patchMethod() {
    
    InstructionSearcher aFinder = 
      new InstructionSearcher( constPoolGen, iList );
    
    InstructionHandle first = null;
    
    // respect the super() or this(...)-call at the 
    // beginning of constructors
    if( mGen.getName().equals( CONSTRUCTOR_NAME ) ) {
      first = aFinder.lookUpSuperConstructorCall().getNext(); 
    }
    else {  
      first = iList.getStart();
    }

View Full Code Here

  /**
   * Removes the wrapper from all the target calls within this method.
   */
  private void unpatchMethod() {
    
    InstructionSearcher aFinder = 
      new InstructionSearcher( constPoolGen, iList );
    
    CallWrapperVariableHandler vHandler =
      new CallWrapperVariableHandler( 
        mGen, iList, 
        factory, constPoolGen,
        joinpointPattern );
    
        // the index of the wrapper to be deinstalled
    int callWrapperIdx = vHandler.getCallWrapperVariableIndex();
    
        // get the loads of this wrapper variable
    aFinder.setCallWrapperLoads( callWrapperIdx, targets );
    Iterator<CallMatch> cmIter = targets.iterator();
    
        // loop over the target calls
    while( cmIter.hasNext() ) {
    
      // REMOVE before()-call
      
            // get the argumentList variable
      int curArgListVarIdx = 
        vHandler.getNextArgumentListVariableIndex();
      InstructionHandle curArgListInit = 
        aFinder.lookUpArgumentListInit( curArgListVarIdx );
      
      CallMatch curCallMatch = cmIter.next();


      InstructionHandle beforeLoad = 
        curCallMatch.getBeforeLoad();
      
      try {
        iList.delete( curArgListInit, 
          vHandler.getLastReloadInstruction( 
            beforeLoad.getNext().getNext(), 
            curCallMatch.getCallInfo() ) );
      }
      catch( TargetLostException tle ) {
        Logger.debug( "removing before()-calls: %s", tle.toString() );
      }
      
      
      // REMOVE after-call
      InstructionHandle afterLoad = 
        curCallMatch.getAfterLoad();
      
      try {
        iList.delete( afterLoad, 
          getLastAfterInstruction( 
            afterLoad, curCallMatch.getCallInfo() ) ); 
      }
      catch( TargetLostException tle ) {
        Logger.debug( "removing after()-calls: %s", tle.toString() );
      }
      
      
      // REMOVE Exception-handler
      InstructionHandle afterExceptionLoad =
        curCallMatch.getAfterExceptionLoad();


      removeExceptionHandler( afterExceptionLoad );
      
      try {
        iList.delete( afterExceptionLoad.getPrev(),
          afterExceptionLoad.getNext().getNext().
            getNext().getNext().getNext() );
      }
      catch( TargetLostException tle ) {
        Logger.debug( 
          "removing afterException()-calls: %s", tle.toString() );
      }
    }
    
        // remove the creation of the wrapper variable
    List<InstructionHandle> callWrapperStores = 
      aFinder.lookUpCallWrapperStores( callWrapperIdx );
    
    try {
      iList.delete( 
          callWrapperStores.get(0).getPrev(),
          callWrapperStores.get(1) );

View Full Code Here

TOP

Related Classes of de.petris.dynamicaspects.util.InstructionSearcher$LoadStoreConstraint

de.petris.dynamicaspects.classhandler.CallClassHandler

de.petris.dynamicaspects.wrapper.CallInfo

de.petris.dynamicaspects.wrapper.CallMatch

de.petris.dynamicaspects.wrapper.CallWrapperMethodPatcher

de.petris.dynamicaspects.wrapper.ExecutionWrapperMethodPatcher

org.apache.bcel.classfile.ConstantClass

org.apache.bcel.classfile.ConstantCP

org.apache.bcel.classfile.ConstantNameAndType

org.apache.bcel.generic.ALOAD

org.apache.bcel.generic.ASTORE

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.