Normalize bounds for BoundsDeclFacts (#1113)

* Add NormalizedBounds field to BoundsDeclFact

* Add getVarDecl and getBoundsExpr methods to BoundsDeclFact

* Add a NormalizeBounds method to Sema for BoundsDeclFact

* Do not normalize bounds for BoundsDeclFacts with invalid VarDecls

* Normalize bounds when creating a BoundsDeclFact

* Make BoundsUtil::ExpandToRange for VarDecl private

* Make BoundsDeclFact members private

Author: kkjeer

clang/include/clang/AST/Expr.h

@@ -7156,17 +7156,63 @@ class WhereClauseFact {
 
 /// \brief Represents a Checked C where clause bounds decl fact.
 class BoundsDeclFact : public WhereClauseFact {
-public:
+private:
   VarDecl *Var;
   BoundsExpr *Bounds;
+  BoundsExpr *NormalizedBounds;
 
+public:
   BoundsDeclFact(VarDecl *Var, BoundsExpr *Bounds, SourceLocation Loc)
     : WhereClauseFact(FactKind::BoundsDeclFact, Loc),
-      Var(Var), Bounds(Bounds) {}
+      Var(Var), Bounds(Bounds), NormalizedBounds(nullptr) {}
 
   static bool classof(const WhereClauseFact *Fact) {
     return Fact->Kind == FactKind::BoundsDeclFact;
   }
+
+  // \brief The variable declaration associated with this bounds fact.
+  VarDecl *getVarDecl() const {
+    return const_cast<BoundsDeclFact *>(this)->getVarDecl();
+  }
+
+  // \brief The variable declaration associated with this bounds fact.
+  VarDecl *getVarDecl() {
+    return Var;
+  }
+
+  // \brief The bounds expression associated with this bounds fact.
+  BoundsExpr *getBoundsExpr() const {
+    return const_cast<BoundsDeclFact *>(this)->getBoundsExpr();
+  }
+
+  // \brief The bounds expression associated with this bounds fact.
+  BoundsExpr *getBoundsExpr() {
+    return Bounds;
+  }
+
+  // \brief The bounds expression for this bounds fact, expanded to a
+  // range bounds expression.
+  BoundsExpr *getNormalizedBounds() const {
+    return const_cast<BoundsDeclFact *>(this)->getNormalizedBounds();
+  }
+
+  // \brief The bounds expression for this bounds fact, expanded to a
+  // range bounds expression.
+  BoundsExpr *getNormalizedBounds() {
+    return NormalizedBounds;
+  }
+
+  // \brief Set the bounds expression for this bounds fact, expanded to a
+  // range bounds expression.
+  void setNormalizedBounds(BoundsExpr *E) const {
+    const_cast<BoundsDeclFact *>(this)->setNormalizedBounds(E);
+  }
+
+  // \brief Set the bounds expression for this bounds fact, expanded to a
+  // range bounds expression.
+  void setNormalizedBounds(BoundsExpr *E) {
+    NormalizedBounds = E;
+  }
 };
 
 /// \brief Represents a Checked C relational operator fact.

clang/include/clang/Sema/BoundsUtils.h

@@ -53,6 +53,11 @@ class BoundsUtil {
 
   // Given a byte_count or count bounds expression for the VarDecl D,
   // ExpandBoundsToRange will expand it to a range bounds expression.
+  //
+  // ExpandBoundsToRange creates a DeclRefExpr for D. Clients should not
+  // call ExpandBoundsToRange directly. Instead, clients should call
+  // Sema::NormalizeBounds, which computes the expanded bounds for D once
+  // and attaches the expanded bounds to D.
   static BoundsExpr *ExpandBoundsToRange(Sema &S, VarDecl *D, BoundsExpr *B);
 
   // Given a byte_count or count bounds expression for the expression Base,
@@ -62,10 +67,6 @@ class BoundsUtil {
   //                                      (array_ptr<char>) E + C)
   static BoundsExpr *ExpandToRange(Sema &S, Expr *Base, BoundsExpr *B);
 
-  // ExpandToRange expands the bounds expression for a variable declaration
-  // to a range bounds expression.
-  static BoundsExpr *ExpandToRange(Sema &S, VarDecl *D, BoundsExpr *B);
-
   // If Bounds uses the value of LValue and an original value is provided,
   // ReplaceLValueInBounds will return a bounds expression where the uses
   // of LValue are replaced with the original value.
@@ -82,6 +83,11 @@ class BoundsUtil {
   static Expr *ReplaceLValue(Sema &S, Expr *E, Expr *LValue,
                              Expr *OriginalValue,
                              CheckedScopeSpecifier CSS);
+
+private:
+  // ExpandToRange expands the bounds expression for a variable declaration
+  // to a range bounds expression.
+  static BoundsExpr *ExpandToRange(Sema &S, VarDecl *D, BoundsExpr *B);
 };
 
 } // end namespace clang

clang/include/clang/Sema/Sema.h

@@ -5732,6 +5732,12 @@ class Sema final {
   // normalized bounds for D.
   BoundsExpr *NormalizeBounds(const VarDecl *D);
 
+  // If the BoundsDeclFact F has a byte_count or count bounds expression,
+  // NormalizeBounds expands it to a range bounds expression.  The expanded
+  // range bounds are attached to the BoundsDeclFact F to avoid recomputing
+  // the normalized bounds for F.
+  BoundsExpr *NormalizeBounds(const BoundsDeclFact *F);
+
   // Returns the declared bounds for the lvalue expression E. Assignments
   // to E must satisfy these bounds. After checking a top-level statement,
   // the inferred bounds of E must imply these declared bounds.

clang/lib/Sema/CheckedCAnalysesPrepass.cpp

@@ -216,8 +216,8 @@ class PrepassHelper : public RecursiveASTVisitor<PrepassHelper> {
 
       for (WhereClauseFact *Fact : WC->getFacts()) {
         if (BoundsDeclFact *BDF = dyn_cast<BoundsDeclFact>(Fact)) {
-          VarDecl *V = BDF->Var;
-          BoundsExpr *B = BDF->Bounds;
+          VarDecl *V = BDF->getVarDecl();
+          BoundsExpr *B = BDF->getBoundsExpr();
 
           VarDecl *OrigVarWithBounds = VarWithBounds;
           VarWithBounds = V;

clang/lib/Sema/SemaBounds.cpp

@@ -3941,8 +3941,7 @@ namespace {
                 << Init->getSourceRange();
           InitBounds = S.CreateInvalidBoundsExpr();
         } else if (CheckBounds) {
-          BoundsExpr *NormalizedDeclaredBounds =
-            BoundsUtil::ExpandToRange(S, D, DeclaredBounds);
+          BoundsExpr *NormalizedDeclaredBounds = S.NormalizeBounds(D);
           CheckBoundsDeclAtInitializer(D->getLocation(), D, NormalizedDeclaredBounds,
             Init, InitBounds, State.EquivExprs, CSS);
         }
@@ -6386,6 +6385,34 @@ BoundsExpr *Sema::NormalizeBounds(const VarDecl *D) {
   return ExpandedBounds;
 }
 
+// If the BoundsDeclFact F has a byte_count or count bounds expression,
+// NormalizeBounds expands it to a range bounds expression.  The expanded
+// range bounds are attached to the BoundsDeclFact F to avoid recomputing
+// the normalized bounds for F.
+BoundsExpr *Sema::NormalizeBounds(const BoundsDeclFact *F) {
+  // Do not attempt to normalize bounds for bounds facts that are
+  // associated with invalid declarations.
+  const VarDecl *D = F->getVarDecl();
+  if (D->isInvalidDecl())
+    return nullptr;
+
+  // If F already has a normalized bounds expression, do not recompute it.
+  if (BoundsExpr *NormalizedBounds = F->getNormalizedBounds())
+    return NormalizedBounds;
+
+  // Expand the bounds expression of F to a RangeBoundsExpr if possible.
+  const BoundsExpr *B = F->getBoundsExpr();
+  BoundsExpr *ExpandedBounds = BoundsUtil::ExpandBoundsToRange(*this,
+                                             const_cast<VarDecl *>(D),
+                                             const_cast<BoundsExpr *>(B));
+  if (!ExpandedBounds)
+    return nullptr;
+
+  // Attach the normalized bounds to F to avoid recomputing them.
+  F->setNormalizedBounds(ExpandedBounds);
+  return ExpandedBounds;
+}
+
 // Returns the declared bounds for the lvalue expression E. Assignments
 // to E must satisfy these bounds. After checking a top-level statement,
 // the inferred bounds of E must imply these declared bounds.

clang/lib/Sema/SemaStmt.cpp

@@ -4533,7 +4533,9 @@ BoundsDeclFact
     return nullptr;
   }
 
-  return new (Context) BoundsDeclFact(VD, Bounds, IdLoc);
+  BoundsDeclFact *F = new (Context) BoundsDeclFact(VD, Bounds, IdLoc);
+  NormalizeBounds(F);
+  return F;
 }
 
 EqualityOpFact *Sema::ActOnEqualityOpFact(Expr *E, SourceLocation ExprLoc) {