Bounds context: validate [4/n]

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -10164,17 +10164,20 @@ def err_bounds_type_annotation_lost_checking : Error<
 
   def warn_bounds_declaration_invalid : Warning<
     "cannot prove declared bounds for %1 are valid after "
-    "%select{assignment|initialization}0">,
+    "%select{assignment|initialization|statement}0">,
     InGroup<CheckBoundsDeclsUnchecked>;
 
   def warn_checked_scope_bounds_declaration_invalid : Warning<
     "cannot prove declared bounds for %1 are valid after "
-    "%select{assignment|initialization}0">,
+    "%select{assignment|initialization|statement}0">,
     InGroup<CheckBoundsDeclsChecked>;
 
   def error_bounds_declaration_invalid : Error<
     "declared bounds for %1 are invalid after "
-    "%select{assignment|initialization}0">;
+    "%select{assignment|initialization|statement}0">;
+
+  def err_unknown_inferred_bounds : Error<
+    "inferred bounds for %0 are unknown after statement">;
 
   def note_declared_bounds : Note<
     "(expanded) declared bounds are '%0'">;
@@ -10188,6 +10191,13 @@ def err_bounds_type_annotation_lost_checking : Error<
   def note_required_bounds : Note<
     "(expanded) required bounds are '%0'">;
 
+  def note_lost_variable : Note<
+    "lost the value of the variable '%0' "
+    "which is used in the (expanded) inferred bounds '%1' of %2">;
+
+  def note_unknown_source_bounds : Note<
+    "assigned expression '%0' with unknown bounds to %1">;
+
   def err_modifying_expr_not_supported : Error<
    "argument must be a non-modifying expression because %ordinal0 parameter "
    "is used in a bounds expression">;

clang/include/clang/Sema/Sema.h

@@ -5186,7 +5186,8 @@ class Sema {
 
   enum BoundsDeclarationCheck {
       BDC_Assignment,
-      BDC_Initialization
+      BDC_Initialization,
+      BDC_Statement
   };
 
   /// \brief Check that address=of operation is not taking the

clang/test/CheckedC/inferred-bounds/basic.c

@@ -131,7 +131,7 @@ void f5(void) {
 // CHECK: NullaryBoundsExpr {{0x[0-9a-f]+}} 'NULL TYPE' Any
 
 void f6(_Array_ptr<int> a : bounds(a, a + 5)) {
-  a = (_Array_ptr<int>) 5; // expected-error {{expression has unknown bounds}}
+  a = (_Array_ptr<int>) 5; // expected-error {{inferred bounds for 'a' are unknown after statement}}
 }
 
 // CHECK: BinaryOperator {{0x[0-9a-f]+}} '_Array_ptr<int>' '='
@@ -150,7 +150,7 @@ void f6(_Array_ptr<int> a : bounds(a, a + 5)) {
 // CHECK: NullaryBoundsExpr {{0x[0-9a-f]+}} 'NULL TYPE' Invalid
 
 void f7(void) {
-  _Array_ptr<int> d : count(5) = (_Array_ptr<int>) 5; // expected-error {{expression has unknown bounds}}
+  _Array_ptr<int> d : count(5) = (_Array_ptr<int>) 5; // expected-error {{inferred bounds for 'd' are unknown after statement}}
 }
 
 // CHECK: VarDecl {{0x[0-9a-f]+}} {{.*}} d '_Array_ptr<int>' cinit
@@ -190,7 +190,7 @@ void f8(_Array_ptr<int> a, _Array_ptr<int> b : count(5)) {
 // CHECK:   `-IntegerLiteral {{0x[0-9a-f]+}} 'int' 5
 
 void f9(int a) {
-  _Array_ptr<int> b : count(5) = (_Array_ptr<int>) !a; // expected-error {{expression has unknown bounds}}
+  _Array_ptr<int> b : count(5) = (_Array_ptr<int>) !a; // expected-error {{inferred bounds for 'b' are unknown after statement}}
 }
 
 // CHECK: VarDecl {{0x[0-9a-f]+}} {{.*}} b '_Array_ptr<int>' cinit
@@ -207,7 +207,7 @@ void f9(int a) {
 // CHECK: NullaryBoundsExpr {{0x[0-9a-f]+}} 'NULL TYPE' Invalid
 
 void f10(float a) {
-  _Array_ptr<int> b : count(5) = (_Array_ptr<int>)((int)a); // expected-error {{expression has unknown bounds}}
+  _Array_ptr<int> b : count(5) = (_Array_ptr<int>)((int)a); // expected-error {{inferred bounds for 'b' are unknown after statement}}
 }
 
 // CHECK: VarDecl {{0x[0-9a-f]+}} {{.*}} b '_Array_ptr<int>' cinit
@@ -260,7 +260,7 @@ void f20(_Array_ptr<int> a : count(len),
 
 void f21(_Array_ptr<int> a : count(5),
          _Array_ptr<int> b) {
-  a = b;  // expected-error {{expression has unknown bounds}}
+  a = b;  // expected-error {{inferred bounds for 'a' are unknown after statement}}
 }
 
 // CHECK: BinaryOperator {{0x[0-9a-f]+}} '_Array_ptr<int>' '='
@@ -280,7 +280,7 @@ void f21(_Array_ptr<int> a : count(5),
 
 // Only test declarations for the negative case (where an error is expected}
 void f22(_Array_ptr<int> b) {
-  _Array_ptr<int> a : count(5) = b;  // expected-error {{expression has unknown bounds}}
+  _Array_ptr<int> a : count(5) = b;  // expected-error {{inferred bounds for 'a' are unknown after statement}}
 }
 
 // CHECK: VarDecl {{0x[0-9a-f]+}} {{.*}} a '_Array_ptr<int>' cinit

clang/test/CheckedC/inferred-bounds/calls.c

@@ -170,7 +170,8 @@ void f10(_Array_ptr<int> a, _Array_ptr<int> b) {
 void f11(_Array_ptr<int> a, _Array_ptr<int> b) {
     _Array_ptr<int> c : bounds(a, a+1) = f_bounds(b++, a); // \
     // expected-error {{expression not allowed in argument for parameter used in function return bounds}} \
-    // expected-error {{initializer expected to have bounds}}
+    // expected-error {{inferred bounds for 'c' are unknown after statement}} \
+    // expected-note {{(expanded) declared bounds are 'bounds(a, a + 1)'}}
 }
 
 // CHECK: VarDecl {{0x[0-9a-f]+}} {{.*}} c '_Array_ptr<int>' cinit
@@ -230,7 +231,8 @@ void f12(int i, int j) {
 void f13(int i, int j) {
     _Array_ptr<int> b : count(i) = f_count(j++, i); // \
     // expected-error {{expression not allowed in argument for parameter used in function return bounds}} \
-    // expected-error {{initializer expected to have bounds}}
+    // expected-error {{inferred bounds for 'b' are unknown after statement}} \
+    // expected-note {{(expanded) declared bounds are 'bounds(b, b + i)'}}
 }
 
 // CHECK: VarDecl {{0x[0-9a-f]+}} {{.*}} b '_Array_ptr<int>' cinit
@@ -284,7 +286,8 @@ void f14(int i, int j) {
 void f15(int i, int j) {
     _Array_ptr<int> b : byte_count(i) = f_byte(j++, i); // \
     // expected-error {{expression not allowed in argument for parameter used in function return bounds}} \
-    // expected-error {{initializer expected to have bounds}}
+    // expected-error {{inferred bounds for 'b' are unknown after statement}} \
+    // expected-note {{(expanded) declared bounds are 'bounds((_Array_ptr<char>)b, (_Array_ptr<char>)b + i)'}}
 }
 
 // CHECK: VarDecl {{0x[0-9a-f]+}} {{.*}} b '_Array_ptr<int>' cinit
@@ -347,7 +350,8 @@ void f20(int* a, int* b) {
 void f21(int* a, int* b) {
     _Array_ptr<int> c : bounds(a, a+1) = f_boundsi(b++, a); // \
     // expected-error {{expression not allowed in argument for parameter used in function return bounds}} \
-    // expected-error {{initializer expected to have bounds}}
+    // expected-error {{inferred bounds for 'c' are unknown after statement}} \
+    // expected-note {{(expanded) declared bounds are 'bounds(a, a + 1)'}}
 }
 
 // CHECK: VarDecl {{0x[0-9a-f]+}} {{.*}} c '_Array_ptr<int>' cinit
@@ -409,7 +413,8 @@ void f22(int i, int j) {
 void f23(int i, int j) {
     _Array_ptr<int> b : count(i) = f_counti(j++, i); // \
     // expected-error {{expression not allowed in argument for parameter used in function return bounds}} \
-    // expected-error {{initializer expected to have bounds}}
+    // expected-error {{inferred bounds for 'b' are unknown after statement}} \
+    // expected-note {{(expanded) declared bounds are 'bounds(b, b + i)'}}
 }
 
 // CHECK: VarDecl {{0x[0-9a-f]+}} {{.*}} b '_Array_ptr<int>' cinit
@@ -465,7 +470,8 @@ void f24(int i, int j) {
 void f25(int i, int j) {
     _Array_ptr<int> b : byte_count(i) = f_bytei(j++, i); // \
     // expected-error {{expression not allowed in argument for parameter used in function return bounds}} \
-    // expected-error {{initializer expected to have bounds}}
+    // expected-error {{inferred bounds for 'b' are unknown after statement}} \
+    // expected-note {{(expanded) declared bounds are 'bounds((_Array_ptr<char>)b, (_Array_ptr<char>)b + i)'}}
 }
 
 // CHECK: VarDecl {{0x[0-9a-f]+}} {{.*}} b '_Array_ptr<int>' cinit

clang/test/CheckedC/inferred-bounds/widened-bounds-check.c

@@ -13,7 +13,7 @@ void f1() {
   {}
 
   if (*p) {
-    p++; // expected-error {{declared bounds for p are invalid after assignment}}
+    p++; // expected-error {{declared bounds for 'p' are invalid after statement}}
     if (*(p + 1)) // expected-error {{out-of-bounds memory access}}
     {}
   }

clang/test/CheckedC/inferred-bounds/widened-bounds-strings-examples.c

@@ -1,8 +1,6 @@
 // Tests for bounds widening for K&R string related functions.
 //
-// RUN: %clang_cc1 -fdump-widened-bounds -verify -verify-ignore-unexpected=note -verify-ignore-unexpected=warning %s 2>&1 | FileCheck %s
-
-// expected-no-diagnostics
+// RUN: %clang_cc1 -fdump-widened-bounds -verify -verify-ignore-unexpected=note -verify-ignore-unexpected=warning %s | FileCheck %s
 
 // Return length of p (adapted from p. 39, K&R 2nd Edition).
 // p implicitly has count(0).
@@ -14,7 +12,7 @@ int my_strlen(_Nt_array_ptr<char> p) {
   // s[i] implies that the count can increase
   // by 1.
   while (s[i])
-    ++i;
+    ++i; // expected-error {{inferred bounds for 's' are unknown after statement}}
   return i;
 
 // CHECK: In function: my_strlen
@@ -30,7 +28,8 @@ void squeeze(_Nt_array_ptr<char> p, char c) {
   // Create a temporary whose count of elements can
   // change.
   _Nt_array_ptr<char> s : count(i) = p;
-  for ( ; s[i]; i++) {
+  for ( ; s[i]; i++) { // expected-error {{inferred bounds for 's' are unknown after statement}} \
+                       // expected-error {{inferred bounds for 'tmp' are unknown after statement}}
     // We will widen the bounds of s so that we
     // can assign to s[j] when j == i.
     _Nt_array_ptr<char> tmp : count(i + 1) = s;
@@ -63,7 +62,7 @@ void reverse(_Nt_array_ptr<char> p) {
   int len = 0;
   // Calculate the length of the string.
   _Nt_array_ptr<char> s : count(len) = p;
-  for (; s[len]; len++);
+  for (; s[len]; len++); // expected-error {{inferred bounds for 's' are unknown after statement}}
 
   // Now that we know the length, use s just like we would use an array_ptr.
   for (int i = 0, j = len - 1; i < j; i++, j--) {

clang/test/CheckedC/inferred-bounds/widened-bounds.c

@@ -1,6 +1,6 @@
 // Tests for datafow analysis for bounds widening of _Nt_array_ptr's.
 //
-// RUN: %clang_cc1 -fdump-widened-bounds -verify -verify-ignore-unexpected=note -verify-ignore-unexpected=warning %s 2>&1 | FileCheck %s
+// RUN: %clang_cc1 -fdump-widened-bounds -verify -verify-ignore-unexpected=note -verify-ignore-unexpected=warning %s | FileCheck %s
 
 #include <limits.h>
 #include <stdint.h>
@@ -105,7 +105,7 @@ void f6(int i) {
   char p _Nt_checked[] : bounds(p + i, p)  = "abc";
 
   if (p[0]) {
-    i = 0;
+    i = 0; // expected-error {{inferred bounds for 'p' are unknown after statement}}
     if (p[1]) {}
   }
 
@@ -212,7 +212,7 @@ void f11(int i, int j) {
   _Nt_array_ptr<char> p : bounds(p + i, p + j) = "a";
 
   if (*(p + j)) {
-    i = 0;
+    i = 0; // expected-error {{inferred bounds for 'p' are unknown after statement}}
     if (*(p + j + 1)) {}
   }
 
@@ -227,7 +227,7 @@ void f11(int i, int j) {
 // CHECK-NOT: upper_bound(p)
 
   if (*(p + j)) {
-    j = 0;
+    j = 0; // expected-error {{inferred bounds for 'p' are unknown after statement}}
     if (*(p + j + 1)) {}
   }
 
@@ -470,7 +470,7 @@ void f19() {
 
 void f20() {
   // Declared bounds and deref offset are both INT_MAX. Valid widening.
-  _Nt_array_ptr<char> p : count(INT_MAX) = "";      // expected-error {{declared bounds for 'p' are invalid after initialization}}
+  _Nt_array_ptr<char> p : count(INT_MAX) = "";      // expected-error {{declared bounds for 'p' are invalid after statement}}
   if (*(p + INT_MAX))
   {}
 
@@ -526,7 +526,7 @@ void f20() {
 // CHECK: upper_bound(t) = 1
 
   // Declared bounds and deref offset are both (INT_MIN + -1). Integer underflow. No widening.
-  _Nt_array_ptr<char> u : count(INT_MIN + -1) = ""; // expected-error {{declared bounds for 'u' are invalid after initialization}}
+  _Nt_array_ptr<char> u : count(INT_MIN + -1) = ""; // expected-error {{declared bounds for 'u' are invalid after statement}}
   if (*(u + INT_MIN + -1))
   {}
 

clang/test/CheckedC/static-checking/bounds-decl-challenges.c

@@ -8,12 +8,12 @@ extern void check_assign(int val, int p[10], int q[], int r _Checked[10], int s
                          int s2d _Checked[10][10], int v _Nt_checked[10], int w _Nt_checked[],
                          int w2d _Checked[10]_Nt_checked[10]) {
   int x2d _Checked[10]_Nt_checked[10];
-  _Nt_array_ptr<int> t13b = w2d[0];  // expected-warning {{cannot prove declared bounds for 't13b' are valid after initialization}}
-  _Nt_array_ptr<int> t15b = x2d[0];  // expected-warning {{cannot prove declared bounds for 't15b' are valid after initialization}}
+  _Nt_array_ptr<int> t13b = w2d[0];  // expected-warning {{cannot prove declared bounds for 't13b' are valid after statement}}
+  _Nt_array_ptr<int> t15b = x2d[0];  // expected-warning {{cannot prove declared bounds for 't15b' are valid after statement}}
 }
 
 // Creating a pointer with count bounds into an existing array.
 void passing_test_1(void) {
   int a _Checked[10] = { 9, 8, 7, 6, 5, 4, 3, 2, 1};
-  _Array_ptr<int> b : count(5) = &a[2];  // expected-warning {{cannot prove declared bounds for 'b' are valid after initialization}}
+  _Array_ptr<int> b : count(5) = &a[2];  // expected-warning {{cannot prove declared bounds for 'b' are valid after statement}}
 }

clang/test/CheckedC/static-checking/bounds-decl-checking-bsi.c

@@ -50,7 +50,7 @@ _Array_ptr<int> f11(unsigned num) {
 }
 
 _Array_ptr<int> f12(unsigned num1, unsigned num2){
-  _Array_ptr<int> p : count(num1) = test_f10(num2); // expected-warning {{cannot prove declared bounds for 'p' are valid after initialization}} \
+  _Array_ptr<int> p : count(num1) = test_f10(num2); // expected-warning {{cannot prove declared bounds for 'p' are valid after statement}} \
                                                     // expected-note {{(expanded) declared bounds are 'bounds(p, p + num1)'}} \
                                                     // expected-note {{(expanded) inferred bounds are 'bounds(value of test_f10(num2), value of test_f10(num2) + num2)'}}
   return p;
@@ -64,7 +64,7 @@ _Array_ptr<int> f14(unsigned num) {
 }
 
 _Array_ptr<int> f15(unsigned num1, unsigned num2){
-  _Array_ptr<int> p : byte_count(num1) = test_f13(num2); // expected-warning {{cannot prove declared bounds for 'p' are valid after initialization}} \
+  _Array_ptr<int> p : byte_count(num1) = test_f13(num2); // expected-warning {{cannot prove declared bounds for 'p' are valid after statement}} \
                                                          // expected-note {{(expanded) declared bounds are 'bounds((_Array_ptr<char>)p, (_Array_ptr<char>)p + num1)'}} \
                                                          // expected-note {{inferred bounds are 'bounds((_Array_ptr<char>)value of test_f13(num2), (_Array_ptr<char>)value of test_f13(num2) + num2)'}}
   return p;
@@ -78,7 +78,7 @@ _Array_ptr<int> f17(unsigned num) {
 }
 
 _Array_ptr<int> f18(unsigned num) {
-  _Array_ptr<int> p : count(2) = test_f16(num);         // expected-error {{declared bounds for 'p' are invalid after initialization}} \
+  _Array_ptr<int> p : count(2) = test_f16(num);         // expected-error {{declared bounds for 'p' are invalid after statement}} \
                                                         // expected-note {{destination bounds are wider than the source bounds}} \
                                                         // expected-note {{destination upper bound is above source upper bound}} \
                                                         // expected-note {{(expanded) declared bounds are 'bounds(p, p + 2)'}} \