Brodes/seh flow overhaul2

cpp/ql/lib/semmle/code/cpp/ir/implementation/EdgeKind.qll

@@ -3,12 +3,13 @@
  */
 
 private import internal.EdgeKindInternal
+private import codeql.util.Boolean
 
 private newtype TEdgeKind =
   TGotoEdge() or // Single successor (including fall-through)
   TTrueEdge() or // 'true' edge of conditional branch
   TFalseEdge() or // 'false' edge of conditional branch
-  TExceptionEdge() or // Thrown exception
+  TExceptionEdge(Boolean isSEH) or // Thrown exception, true for SEH exceptions, false otherwise
   TDefaultEdge() or // 'default' label of switch
   TCaseEdge(string minValue, string maxValue) {
     // Case label of switch
@@ -54,7 +55,18 @@
  * instruction's evaluation throws an exception.
  */
 class ExceptionEdge extends EdgeKind, TExceptionEdge {
-  final override string toString() { result = "Exception" }
+  boolean isSEH; //true for Structured Exception Handling, false for C++ exceptions
+
+  ExceptionEdge() { this = TExceptionEdge(isSEH) }
+
+  /**
+   * Holds if the exception is a Structured Exception Handling (SEH) exception.
+   */
+  final predicate isSEH() { isSEH = true }
+
+  final override string toString() {
+    if isSEH = true then result = "SEH Exception" else result = "C++ Exception"
+  }
 }
 
 /**
@@ -121,9 +133,10 @@
   FalseEdge falseEdge() { result = TFalseEdge() }
 
   /**
-   * Gets the single instance of the `ExceptionEdge` class.
+   * Gets the instance of the `ExceptionEdge` class.
+   * `isSEH` is true if the exception is an SEH exception, and false for a C++ edge.
    */
-  ExceptionEdge exceptionEdge() { result = TExceptionEdge() }
+  ExceptionEdge exceptionEdge(boolean isSEH) { result = TExceptionEdge(isSEH) }
 
   /**
    * Gets the single instance of the `DefaultEdge` class.

cpp/ql/lib/semmle/code/cpp/ir/implementation/raw/internal/TranslatedCall.qll

@@ -10,6 +10,7 @@
 private import TranslatedExpr
 private import TranslatedFunction
 private import DefaultOptions as DefaultOptions
+private import EdgeKind
 
 /**
  * Gets the `CallInstruction` from the `TranslatedCallExpr` for the specified expression.
@@ -83,14 +84,36 @@
         any(UnreachedInstruction instr |
           this.getEnclosingFunction().getFunction() = instr.getEnclosingFunction()
         )
-    else (
-      not this.mustThrowException() and
-      result = this.getParent().getChildSuccessor(this, kind)
-      or
-      this.mayThrowException() and
-      kind instanceof ExceptionEdge and
-      result = this.getParent().getExceptionSuccessorInstruction(any(GotoEdge edge))
-    )
+    else
+      exists(boolean isSEH | kind = exceptionEdge(isSEH) |
+        // Call throw behavior is resolved from most restricted to least restricted in order
+        // if there are conflicting throwing specificaitons for a function.
+        // Enumerating all scenarios to be explicit.
+        (
+          // If the call is known to never throw, regardless of other defined throwing behavior,
+          // do not generate any exception edges, only an ordinary successor
+          if this.(TranslatedCallExpr).neverRaiseException(isSEH)
+          then result = this.getParent().getChildSuccessor(this, any(GotoEdge edge))
+          else
+            // If the call is known to always throw, regardless of other defined throwing behavior,
+            // only generate an exception edge.
+            if this.(TranslatedCallExpr).alwaysRaiseException(isSEH)
+            then
+              result = this.getParent().getExceptionSuccessorInstruction(any(GotoEdge edge), isSEH)
+            else
+              if this.(TranslatedCallExpr).mayRaiseException(isSEH)
+              then (
+                // if the call is known to conditionally throw, generate both an exception edge and an
+                // ordinary successor
+                result =
+                  this.getParent().getExceptionSuccessorInstruction(any(GotoEdge edge), isSEH)
+                or
+                result = this.getParent().getChildSuccessor(this, kind)
+              ) else
+                // fallthrough case, no exceptions, just get the ordinary successor
+                result = this.getParent().getChildSuccessor(this, kind)
+        )
+      )
   }
 
   override Instruction getInstructionSuccessorInternal(InstructionTag tag, EdgeKind kind) {
@@ -117,14 +140,28 @@
   final override Instruction getResult() { result = this.getInstruction(CallTag()) }
 
   /**
-   * Holds if the evaluation of this call may throw an exception.
+   * The call target is known to always raise an exception.
+   * Note that `alwaysRaiseException`, `mayRaiseException`,
+   * and `neverRaiseException` may conflict (e.g., all hold for a given target).
+   * Conflicting results are resolved during IR generation.
    */
-  abstract predicate mayThrowException();
+  abstract predicate alwaysRaiseException(boolean isSEH);
 
   /**
-   * Holds if the evaluation of this call always throws an exception.
+   * The call target is known to conditionally raise an exception.
+   * Note that `alwaysRaiseException`, `mayRaiseException`,
+   * and `neverRaiseException` may conflict (e.g., all hold for a given target).
+   * Conflicting results are resolved during IR generation.
    */
-  abstract predicate mustThrowException();
+  abstract predicate mayRaiseException(boolean isSEH);
+
+  /**
+   * The call target is known to never raise an exception.
+   * Note that `alwaysRaiseException`, `mayRaiseException`,
+   * and `neverRaiseException` may conflict (e.g., all hold for a given target).
+   * Conflicting results are resolved during IR generation.
+   */
+  abstract predicate neverRaiseException(boolean isSEH);
 
   /**
    * Gets the result type of the call.
@@ -320,6 +357,34 @@
   final override int getNumberOfArguments() { result = expr.getNumberOfArguments() }
 
   final override predicate isNoReturn() { any(Options opt).exits(expr.getTarget()) }
+
+  override Function getInstructionFunction(InstructionTag tag) {
+    tag = CallTargetTag() and result = expr.getTarget()
+  }
+
+  override predicate alwaysRaiseException(boolean isSEH) {
+    exists(ThrowingFunction f | f = expr.getTarget() |
+      f.alwaysRaisesException() and f.isSEH() and isSEH = true
+      or
+      f.alwaysRaisesException() and f.isCxx() and isSEH = false
+    )
+  }
+
+  override predicate mayRaiseException(boolean isSEH) {
+    exists(ThrowingFunction f | f = expr.getTarget() |
+      f.mayRaiseException() and f.isSEH() and isSEH = true
+      or
+      f.mayRaiseException() and f.isCxx() and isSEH = false
+    )
+  }
+
+  override predicate neverRaiseException(boolean isSEH) {
+    exists(NonThrowingFunction f | f = expr.getTarget() |
+      f.isSEH() and isSEH = true
+      or
+      f.isCxx() and isSEH = false
+    )
+  }
 }
 
 /**
@@ -332,14 +397,42 @@
     result = getTranslatedExpr(expr.getExpr().getFullyConverted())
   }
 
-  final override predicate mayThrowException() {
-    // We assume that a call to a function pointer will not throw an exception.
+  override predicate alwaysRaiseException(boolean isSEH) {
+    // We assume that a call to a function pointer will not throw a CXX exception.
     // This is not sound in general, but this will greatly reduce the number of
     // exceptional edges.
-    none()
+    // For SEH exceptions, use the defined ThrowingFunction behavior and
+    // if no throwing function is found, assume a conditional SEH exception
+    // see `mayRaiseException`
+    exists(ThrowingFunction f | f = expr.getTarget() |
+      f.alwaysRaisesException() and f.isSEH() and isSEH = true
+    )
+  }
+
+  override predicate mayRaiseException(boolean isSEH) {
+    // We assume that a call to a function pointer will not throw a CXX exception.
+    // This is not sound in general, but this will greatly reduce the number of
+    // exceptional edges.
+    // For SEH exceptions, use the defined ThrowingFunction behavior.
+    // ASSUMPTION: if no ThrowingFunction is found for the given call, assume a conditional SEH exception
+    // on the call.
+    exists(ThrowingFunction f | f = expr.getTarget() |
+      f.mayRaiseException() and f.isSEH() and isSEH = true
+    )
+    or
+    not exists(ThrowingFunction f | f = expr.getTarget() and f.isSEH()) and
+    isSEH = true
   }
 
-  final override predicate mustThrowException() { none() }
+  override predicate neverRaiseException(boolean isSEH) {
+    // We assume that a call to a function pointer will not throw a CXX exception.
+    // This is not sound in general, but this will greatly reduce the number of
+    // exceptional edges.
+    // For SEH exceptions, use the defined ThrowingFunction behavior and
+    // if no throwing function is found, assume a conditional SEH exception
+    // see `mayRaiseException`
+    exists(NonThrowingFunction f | f = expr.getTarget() | f.isSEH() and isSEH = true)
+  }
 }
 
 /**
@@ -348,10 +441,6 @@
 class TranslatedFunctionCall extends TranslatedCallExpr, TranslatedDirectCall {
   override FunctionCall expr;
 
-  override Function getInstructionFunction(InstructionTag tag) {
-    tag = CallTargetTag() and result = expr.getTarget()
-  }
-
   override Instruction getQualifierResult() {
     this.hasQualifier() and
     result = this.getQualifier().getResult()
@@ -361,14 +450,6 @@
     exists(this.getQualifier()) and
     not exists(MemberFunction func | expr.getTarget() = func and func.isStatic())
   }
-
-  final override predicate mayThrowException() {
-    expr.getTarget().(ThrowingFunction).mayThrowException(_)
-  }
-
-  final override predicate mustThrowException() {
-    expr.getTarget().(ThrowingFunction).mayThrowException(true)
-  }
 }
 
 /**

cpp/ql/lib/semmle/code/cpp/ir/implementation/raw/internal/TranslatedDeclarationEntry.qll

@@ -165,8 +165,10 @@ class TranslatedStaticLocalVariableDeclarationEntry extends TranslatedDeclaratio
     result = this.getInstruction(DynamicInitializationFlagLoadTag())
     or
     tag = DynamicInitializationFlagLoadTag() and
-    kind instanceof GotoEdge and
-    result = this.getInstruction(DynamicInitializationConditionalBranchTag())
+    (
+      kind instanceof GotoEdge and
+      result = this.getInstruction(DynamicInitializationConditionalBranchTag())
+    )
     or
     tag = DynamicInitializationConditionalBranchTag() and
     (

cpp/ql/lib/semmle/code/cpp/ir/implementation/raw/internal/TranslatedElement.qll

@@ -1104,9 +1104,13 @@
    * within this element. This will generally return first `catch` block of the
    * nearest enclosing `try`, or the `Unwind` instruction for the function if
    * there is no enclosing `try`. The successor edge kind is specified by `kind`.
+   * 
+   * `isSEH` is true if the exception is a structured exception, false if otherwise.
+   * The boolean value can be extracted from `ExceptionEdge` from the exception 
+   * edge triggering the call to this function.
    */
-  Instruction getExceptionSuccessorInstruction(EdgeKind kind) {
-    result = this.getParent().getExceptionSuccessorInstruction(kind)
+  Instruction getExceptionSuccessorInstruction(EdgeKind kind, boolean isSEH) {
+    result = this.getParent().getExceptionSuccessorInstruction(kind, isSEH)
   }
 
   /**