Add NormalizeUpperBound method to CheckBoundsDeclarations

clang/lib/Sema/SemaBounds.cpp

@@ -43,6 +43,7 @@
 #include "clang/AST/AbstractSet.h"
 #include "clang/AST/CanonBounds.h"
 #include "clang/AST/ExprUtils.h"
+#include "clang/AST/NormalizeUtils.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Sema/AvailableFactsAnalysis.h"
 #include "clang/Sema/BoundsAnalysis.h"
@@ -2013,6 +2014,82 @@ namespace {
       return ProofResult::Maybe;
     }
 
+    // NormalizeUpperBound attempts to extract a Variable part and a Constant
+    // part from the upper bound expression E.
+    //
+    // If E can be expressed as:
+    // 1. (E1 + (E2 op1 A)) op2 B, or:
+    // 2. B + (E1 + (E2 op1 A))
+    // where:
+    // 1. E1 has pointer type, and:
+    // 2. E2 has integer type, and:
+    // 3. A and B are integer constants, and:
+    // 4. op1 and op2 are + or -
+    // then:
+    // 1. Variable = E1 + E2
+    // 2. Constant = A' + B', where A' is -A if op1 is - and B' is -B if
+    //    op2 is -.
+    //
+    // If we cannot normalize E to one of these two forms, then Variable = E,
+    // Constant = 0, and NormalizeUpperBound returns false.
+    bool NormalizeUpperBound(Expr *E, Expr *&Variable, llvm::APSInt &Constant) {
+      Expr *PointerExpr;
+      Expr *ConstExpr;
+      llvm::APSInt C;
+
+      // E must be of the form X op2 Y, where op2 is + or -.
+      BinaryOperator *BO = dyn_cast<BinaryOperator>(E->IgnoreParens());
+      if (!BO)
+        goto exit;
+      if (!BinaryOperator::isAdditiveOp(BO->getOpcode()))
+        goto exit;
+
+      // E must be of the form P op2 B or B + P, where P has pointer type
+      // and B is an integer constant expression.
+      if (BO->getLHS()->getType()->isPointerType() &&
+          BO->getRHS()->isIntegerConstantExpr(C, S.Context)) {
+        PointerExpr = BO->getLHS();
+        ConstExpr = BO->getRHS();
+      } else if (BO->getOpcode() == BinaryOperatorKind::BO_Add &&
+                 BO->getRHS()->getType()->isPointerType() &&
+                 BO->getLHS()->isIntegerConstantExpr(C, S.Context)) {
+        PointerExpr = BO->getRHS();
+        ConstExpr = BO->getLHS();
+      } else
+        goto exit;
+
+      // Normalize X - Y operators in PointerExpr and its children to X + -Y.
+      // If we cannot, then PointerExpr is not a +/- operator, so we cannot
+      // continue to normalize.
+      PointerExpr = NormalizeUtil::TransformAdditiveOp(S, PointerExpr);
+      if (!PointerExpr)
+        goto exit;
+
+      // Associate PointerExpr to the left to get (E1 + E2) + E3.
+      // If we cannot, then we cannot continue to normalize.
+      PointerExpr = NormalizeUtil::TransformAssocLeft(S, PointerExpr);
+      if (!PointerExpr)
+        goto exit;
+
+      // We have PointerExpr of the form (E1 + E2) + E3. Try to constant fold
+      // ((E1 + E2) + E3) op2 B to (E1 + E2) + (E3 op2 B).
+      // If we can perform this constant folding, then Variable = E1 + E2 and
+      // Constant = E3 op2 B.
+      // Otherwise, Variable = E and Constant = 0.
+      Expr *PointerAndConst =
+        ExprCreatorUtil::CreateBinaryOperator(S, PointerExpr, ConstExpr,
+                                              BO->getOpcode());
+      return NormalizeUtil::ConstantFold(S, PointerAndConst, E->getType(),
+                                         Variable, Constant);
+
+      exit:
+        // Return (E, 0).
+        Variable = E;
+        uint64_t PointerWidth = S.Context.getTargetInfo().getPointerWidth(0);
+        Constant = llvm::APSInt(PointerWidth, false);
+        return false;
+    }
+
     // Try to prove that PtrBase + Offset is within Bounds, where PtrBase has pointer type.
     // Offset is optional and may be a nullptr.
     ProofResult ProveMemoryAccessInRange(Expr *PtrBase, Expr *Offset, BoundsExpr *Bounds,