Merge pull request #282 from rdmarsh2/rdmarsh/cpp/simple-range-analysis-caching

C++: add cached module to SimpleRangeAnalysis

cpp/ql/src/semmle/code/cpp/rangeanalysis/SimpleRangeAnalysis.qll

@@ -44,6 +44,7 @@
 import cpp
 private import RangeAnalysisUtils
 import RangeSSA
+import SimpleRangeAnalysisCached
 
 /**
  * This fixed set of lower bounds is used when the lower bounds of an
@@ -406,27 +407,6 @@ deprecated predicate negative_overflow(Expr expr) {
   exprMightOverflowNegatively(expr)
 }
 
-/**
- * Holds if the expression might overflow negatively. This predicate
- * does not consider the possibility that the expression might overflow
- * due to a conversion.
- */
-cached
-predicate exprMightOverflowNegatively(Expr expr) {
-  getLowerBoundsImpl(expr) < exprMinVal(expr)
-}
-
-/**
- * Holds if the expression might overflow negatively. Conversions
- * are also taken into account. For example the expression
- * `(int16)(x+y)` might overflow due to the `(int16)` cast, rather than
- * due to the addition.
- */
-cached
-predicate convertedExprMightOverflowNegatively(Expr expr) {
-  exprMightOverflowNegatively(expr) or
-  convertedExprMightOverflowNegatively(expr.getConversion())
-}
 
 /**
  * Holds if the expression might overflow positively. This predicate
@@ -439,39 +419,6 @@ deprecated predicate positive_overflow(Expr expr) {
   exprMightOverflowPositively(expr)
 }
 
-/**
- * Holds if the expression might overflow positively. This predicate
- * does not consider the possibility that the expression might overflow
- * due to a conversion.
- */
-cached
-predicate exprMightOverflowPositively(Expr expr) {
-  getUpperBoundsImpl(expr) > exprMaxVal(expr)
-}
-
-/**
- * Holds if the expression might overflow positively. Conversions
- * are also taken into account. For example the expression
- * `(int16)(x+y)` might overflow due to the `(int16)` cast, rather than
- * due to the addition.
- */
-cached
-predicate convertedExprMightOverflowPositively(Expr expr) {
-  exprMightOverflowPositively(expr) or
-  convertedExprMightOverflowPositively(expr.getConversion())
-}
-
-/**
- * Holds if the expression might overflow (either positively or
- * negatively). The possibility that the expression might overflow
- * due to an implicit or explicit cast is also considered.
- */
-cached
-predicate convertedExprMightOverflow(Expr expr) {
-  convertedExprMightOverflowNegatively(expr) or
-  convertedExprMightOverflowPositively(expr)
-}
-
 /** Only to be called by `getTruncatedLowerBounds`. */
 private
 float getLowerBoundsImpl(Expr expr) {
@@ -921,28 +868,6 @@ float getDefUpperBoundsImpl(RangeSsaDefinition def, LocalScopeVariable v) {
   unanalyzableDefBounds(def, v, _, result)
 }
 
-/** Holds if the definition might overflow negatively. */
-cached
-predicate defMightOverflowNegatively(RangeSsaDefinition def, LocalScopeVariable v) {
-  getDefLowerBoundsImpl(def, v) < varMinVal(v)
-}
-
-/** Holds if the definition might overflow positively. */
-cached
-predicate defMightOverflowPositively(RangeSsaDefinition def, LocalScopeVariable v) {
-  getDefUpperBoundsImpl(def, v) > varMaxVal(v)
-}
-
-/**
- * Holds if the definition might overflow (either positively or
- * negatively).
- */
-cached
-predicate defMightOverflow(RangeSsaDefinition def, LocalScopeVariable v) {
-  defMightOverflowNegatively(def, v) or
-  defMightOverflowPositively(def, v)
-}
-
 /**
  * Get the lower bounds for a `RangeSsaDefinition`. Most of the work is
  * done by `getDefLowerBoundsImpl`, but this is where widening is applied
@@ -1133,63 +1058,142 @@ predicate exprTypeBounds(Expr expr, float boundValue, boolean isLowerBound) {
   (isLowerBound = false and boundValue = exprMaxVal(expr.getFullyConverted()))
 }
 
-/**
- * Gets the lower bound of the expression.
- *
- * Note: expressions in C/C++ are often implicitly or explicitly cast to a
- * different result type. Such casts can cause the value of the expression
- * to overflow or to be truncated. This predicate computes the lower bound
- * of the expression without including the effect of the casts. To compute
- * the lower bound of the expression after all the casts have been applied,
- * call `lowerBound` like this:
- *
- *    `lowerBound(expr.getFullyConverted())`
- */
-cached
-float lowerBound(Expr expr) {
-  // Combine the lower bounds returned by getTruncatedLowerBounds into a
-  // single minimum value.
-  result = min(float lb | lb = getTruncatedLowerBounds(expr) | lb)
-}
+private cached module SimpleRangeAnalysisCached {
+    /**
+   * Gets the lower bound of the expression.
+   *
+   * Note: expressions in C/C++ are often implicitly or explicitly cast to a
+   * different result type. Such casts can cause the value of the expression
+   * to overflow or to be truncated. This predicate computes the lower bound
+   * of the expression without including the effect of the casts. To compute
+   * the lower bound of the expression after all the casts have been applied,
+   * call `lowerBound` like this:
+   *
+   *    `lowerBound(expr.getFullyConverted())`
+   */
+  cached
+  float lowerBound(Expr expr) {
+    // Combine the lower bounds returned by getTruncatedLowerBounds into a
+    // single minimum value.
+    result = min(float lb | lb = getTruncatedLowerBounds(expr) | lb)
+  }
+  
+  /**
+   * Gets the upper bound of the expression.
+   *
+   * Note: expressions in C/C++ are often implicitly or explicitly cast to a
+   * different result type. Such casts can cause the value of the expression
+   * to overflow or to be truncated. This predicate computes the upper bound
+   * of the expression without including the effect of the casts. To compute
+   * the upper bound of the expression after all the casts have been applied,
+   * call `upperBound` like this:
+   *
+   *    `upperBound(expr.getFullyConverted())`
+   */
+  cached
+  float upperBound(Expr expr) {
+    // Combine the upper bounds returned by getTruncatedUpperBounds into a
+    // single maximum value.
+    result = max(float ub | ub = getTruncatedUpperBounds(expr) | ub)
+  }
+  
+  /**
+   * Holds if `expr` has a provably empty range. For example:
+   *
+   *   10 < expr and expr < 5
+   *
+   * The range of an expression can only be empty if it can never be
+   * executed. For example:
+   *
+   *   if (10 < x) {
+   *     if (x < 5) {
+   *       // Unreachable code
+   *       return x; // x has an empty range: 10 < x && x < 5
+   *     }
+   *   }
+   */
+  cached
+  predicate exprWithEmptyRange(Expr expr) {
+    analyzableExpr(expr) and
+    (not exists(lowerBound(expr)) or
+     not exists(upperBound(expr)) or
+     lowerBound(expr) > upperBound(expr))
+  }
 
-/**
- * Gets the upper bound of the expression.
- *
- * Note: expressions in C/C++ are often implicitly or explicitly cast to a
- * different result type. Such casts can cause the value of the expression
- * to overflow or to be truncated. This predicate computes the upper bound
- * of the expression without including the effect of the casts. To compute
- * the upper bound of the expression after all the casts have been applied,
- * call `upperBound` like this:
- *
- *    `upperBound(expr.getFullyConverted())`
- */
-cached
-float upperBound(Expr expr) {
-  // Combine the upper bounds returned by getTruncatedUpperBounds into a
-  // single maximum value.
-  result = max(float ub | ub = getTruncatedUpperBounds(expr) | ub)
-}
-
-/**
- * Holds if `expr` has a provably empty range. For example:
- *
- *   10 < expr and expr < 5
- *
- * The range of an expression can only be empty if it can never be
- * executed. For example:
- *
- *   if (10 < x) {
- *     if (x < 5) {
- *       // Unreachable code
- *       return x; // x has an empty range: 10 < x && x < 5
- *     }
- *   }
- */
-cached
-predicate exprWithEmptyRange(Expr expr) {
-  analyzableExpr(expr) and
-  (not exists(lowerBound(expr)) or
-   not exists(upperBound(expr)) or
-   lowerBound(expr) > upperBound(expr))
+  /** Holds if the definition might overflow negatively. */
+  cached
+  predicate defMightOverflowNegatively(RangeSsaDefinition def, LocalScopeVariable v) {
+    getDefLowerBoundsImpl(def, v) < varMinVal(v)
+  }
+  
+  /** Holds if the definition might overflow positively. */
+  cached
+  predicate defMightOverflowPositively(RangeSsaDefinition def, LocalScopeVariable v) {
+    getDefUpperBoundsImpl(def, v) > varMaxVal(v)
+  }
+  
+  /**
+   * Holds if the definition might overflow (either positively or
+   * negatively).
+   */
+  cached
+  predicate defMightOverflow(RangeSsaDefinition def, LocalScopeVariable v) {
+    defMightOverflowNegatively(def, v) or
+    defMightOverflowPositively(def, v)
+  }
+  
+  /**
+   * Holds if the expression might overflow negatively. This predicate
+   * does not consider the possibility that the expression might overflow
+   * due to a conversion.
+   */
+  cached
+  predicate exprMightOverflowNegatively(Expr expr) {
+    getLowerBoundsImpl(expr) < exprMinVal(expr)
+  }
+  
+  /**
+   * Holds if the expression might overflow negatively. Conversions
+   * are also taken into account. For example the expression
+   * `(int16)(x+y)` might overflow due to the `(int16)` cast, rather than
+   * due to the addition.
+   */
+  cached
+  predicate convertedExprMightOverflowNegatively(Expr expr) {
+    exprMightOverflowNegatively(expr) or
+    convertedExprMightOverflowNegatively(expr.getConversion())
+  }
+  
+    /**
+   * Holds if the expression might overflow positively. This predicate
+   * does not consider the possibility that the expression might overflow
+   * due to a conversion.
+   */
+  cached
+  predicate exprMightOverflowPositively(Expr expr) {
+    getUpperBoundsImpl(expr) > exprMaxVal(expr)
+  }
+  
+  /**
+   * Holds if the expression might overflow positively. Conversions
+   * are also taken into account. For example the expression
+   * `(int16)(x+y)` might overflow due to the `(int16)` cast, rather than
+   * due to the addition.
+   */
+  cached
+  predicate convertedExprMightOverflowPositively(Expr expr) {
+    exprMightOverflowPositively(expr) or
+    convertedExprMightOverflowPositively(expr.getConversion())
+  }
+  
+  /**
+   * Holds if the expression might overflow (either positively or
+   * negatively). The possibility that the expression might overflow
+   * due to an implicit or explicit cast is also considered.
+   */
+  cached
+  predicate convertedExprMightOverflow(Expr expr) {
+    convertedExprMightOverflowNegatively(expr) or
+    convertedExprMightOverflowPositively(expr)
+  }
 }