Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2015 The Pennsylvania State University and the University of Wisconsin
   * Systems and Internet Infrastructure Security Laboratory
   *
   * Author: Damien Octeau
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package edu.psu.cse.siis.coal.arguments;
 
 import java.util.Map;
 import java.util.Set;
 
 
 import soot.Unit;
A singleton manager for method argument values, which trigger argument value analyses.
 
 public class ArgumentValueManager {
   private static final short MAX_TIME = 300;
   private static final short MIN_TIME = 120;
   private static final float DECREASE_FACTOR = 0.90f;
 
   private static final ArgumentValueManager instance = new ArgumentValueManager();
 
   private final Logger logger = LoggerFactory.getLogger(getClass());
 
   private final Map<StringArgumentValueAnalysisargumentValueAnalysisMap = new HashMap<>();
   private final Map<ArgumentValueIdentifierSet<Object>> cachedValues = new HashMap<>();
   private final Map<StringFieldTransformertopFieldTransformerMap = new HashMap<>();
 
   private short timeBudget = ;
 
   private ArgumentValueManager() {
   }
 
   public static ArgumentValueManager v() {
     return ;
   }

  
Registers the argument value analysis associated with a given type.

Parameters:
type An argument value type.
analysis An analysis for the argument value type.
 
   public void registerArgumentValueAnalysis(String typeArgumentValueAnalysis analysis) {
     .put(typeanalysis);
   }

  
Registers default argument value analyses, which are provided as part of the vanilla COAL solver.
 
   }

  
Returns the possible argument values for a given program statement and a given Argument .

Parameters:
argument An argument.
callSite A call statement.
Returns:
The possible argument values.
 
   public Set<ObjectgetArgumentValues(Argument argumentUnit callSite) {
     String type = argument.getType();
     if (type == null) {
       return null;
    }
    if (AnalysisParameters.v().isIterative()) {
      ArgumentValueIdentifier argumentValueIdentifier =
          new ArgumentValueIdentifier(callSiteargument);
      Set<Objectresult = .get(argumentValueIdentifier);
      if (result != null) {
        return result;
      } else {
        result = computeNewArgumentValues(argumentcallSite);
        .put(argumentValueIdentifierresult);
        return result;
      }
    } else {
      return computeNewArgumentValues(argumentcallSite);
    }
  }

  
Returns a field transformer that indicates an unknown field value.

Parameters:
type An argument type.
Returns:
A field transformer.
    if (analysis == null) {
      throw new RuntimeException("No analysis for type " + type);
    }
    FieldTransformer fieldTransformer = .get(type);
    if (fieldTransformer == null) {
      throw new RuntimeException("No top field transformer defined for type " + type);
    }
    return fieldTransformer;
  }

  
Generates a field transformer that indicates an unknown value for a given field type.

Parameters:
type A field type.
Returns:
An field transformer.
    if (analysis == null) {
      throw new RuntimeException("No analysis for type " + type);
    }
    return FieldTransformerManager.v().makeFieldTransformer(..,
        analysis.getTopValue());
  }

  
Returns possible arguments values for a given program statement and a given Argument (helper function).

Parameters:
argument An argument.
callSite A call statement.
Returns:
The possible argument values.
  private Set<ObjectcomputeNewArgumentValues(Argument argumentUnit callSite) {
    String type = argument.getType();
    String[] inlineValues = argument.getInlineValues();
    if (analysis == null) {
      throw new RuntimeException("No analysis for type " + type + " in argument "
          + argument.toString());
    }
    if (inlineValues == null) {
      ExecutorService pool = Executors.newFixedThreadPool(1);
      // long start = System.currentTimeMillis();
      Future<Set<Object>> valuesFuture =
          startComputingNewArgumentValues(poolanalysisargumentcallSite);
      try {
        return valuesFuture.get(.);
      } catch (InterruptedException | ExecutionException | TimeoutException exc) {
        valuesFuture.cancel(true);
        synchronized (this) {
          if ( > ) {
             *= ;
            if ( < ) {
               = ;
            }
          }
        }
        .warn("Could not infer argument value at statement " + callSite.toString(), exc);
        return Collections.singleton(analysis.getTopValue());
      } catch (Error error) {
        // Bad practice in general, but we don't control the analyses (especially the string
        // analysis, which is sometimes very greedy). So we still attempt to recover from this.
        valuesFuture.cancel(true);
        // OutOfMemoryError is a very likely candidate.
        System.gc();
        .warn("Could not infer argument value at statement " + callSite.toString(), error);
        return Collections.singleton(analysis.getTopValue());
      } finally {
        pool.shutdownNow();
        // int duration = (int) (System.currentTimeMillis() - start);
        // synchronized (PropagationTimers.v().argumentValueTime) {
        // PropagationTimers.v().argumentValueTime += duration;
        // }
      }
    } else {
      return analysis.computeInlineArgumentValues(inlineValues);
    }
  }

  
Generates a future for a new argument value computation.

Parameters:
analysis An argument value analysis.
argument An argument.
callSite A call statement.
Returns:
A future for the new argument value computation.
      final ArgumentValueAnalysis analysisfinal Argument argumentfinal Unit callSite) {
    Callable<Set<Object>> callable = new Callable<Set<Object>>() {
      @Override
      public Set<Objectcall() {
        return analysis.computeArgumentValues(argumentcallSite);
      }
    };
    return pool.submit(callable);
  }
New to GrepCode? Check out our FAQ X