[-Wunsafe-buffer-usage] Group diagnostics by variable

[jkorous]

Summary

• Add notes to our diagnostics.
• Change the way we present diagnostic information.
  • For declarations involved in unsafe operations emit a single warning at the variable declaration and attach a per-unsafe-operation note.
  • For unsafe operations that don't refer to a variable emit a per-operation warning.
• Change wording of our diagnostics.

[NoQ]

LGTM! I like the new diagnostics a lot better!

clang/include/clang/Basic/DiagnosticSemaKinds.td

11761

Folks asked me to do this in my initial patch, I guess we should preserve the tradition, though of course we're still way past the 80-column limit.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

11761

Errr, not certain where the confusion came in, but the 80-col limit still exists for these files (we are more relaxed in .td files though because clang-format used to really struggle with them).

So I would re-wrap this as:

def warn_unsafe_buffer_variable : Warning<
  "%0 is an %select{unsafe pointer used for buffer access|unsafe buffer that "
  "does not perform bounds checks}1">,
  InGroup<UnsafeBufferUsage>, DefaultIgnore;

and similar for the rest.

[jkorous]

Respect 80-char line limit in changes to DiagnosticSemaKinds.td.

clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h

public:
   UnsafeBufferUsageHandler() = default;
   virtual ~UnsafeBufferUsageHandler() = default;
 
   /// This analyses produces large fixits that are organized into lists
   /// of primitive fixits (individual insertions/removals/replacements).
   using FixItList = llvm::SmallVectorImpl<FixItHint>;
 
   /// Invoked when an unsafe operation over raw pointers is found.
-  virtual void handleUnsafeOperation(const Stmt *Operation) = 0;
+  virtual void handleUnsafeOperation(const Stmt *Operation,
+                                     bool IsRelatedToDecl) = 0;
 
   /// Invoked when a fix is suggested against a variable.
   virtual void handleFixableVariable(const VarDecl *Variable,
                                      FixItList &&List) = 0;
 };
 
 // This function invokes the analysis and allows the caller to react to it
 // through the handler class.
 void checkUnsafeBufferUsage(const Decl *D, UnsafeBufferUsageHandler &Handler);
 
 } // end namespace clang
 
 #endif /* LLVM_CLANG_ANALYSIS_ANALYSES_UNSAFEBUFFERUSAGE_H */

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_cast_from_randomized_struct : Error<
   "casting from randomized structure pointer type %0 to %1">;
 
 // LoongArch-specific Diagnostics
 def err_loongarch_builtin_requires_la64 : Error<
   "this builtin requires target: loongarch64">;
 
 // Unsafe buffer usage diagnostics.
-def warn_unsafe_buffer_expression : Warning<
-  "unchecked operation on raw buffer in expression">,
+def warn_unsafe_buffer_variable : Warning<"%0 is an %select{unsafe pointer used for buffer access|unsafe buffer that does not perform bounds checks}1">,
   InGroup<UnsafeBufferUsage>, DefaultIgnore;
-def warn_unsafe_buffer_variable : Warning<
-  "variable %0 participates in unchecked buffer operations">,
+def warn_unsafe_buffer_operation : Warning<"%select{unsafe pointer operation|unsafe pointer arithmetic|unsafe buffer access}0">,
   InGroup<UnsafeBufferUsage>, DefaultIgnore;
+def note_unsafe_buffer_operation : Note<"used%select{| in pointer arithmetic| in buffer access}0 here">;
 def err_loongarch_builtin_requires_la32 : Error<
   "this builtin requires target: loongarch32">;
 } // end of sema component.

clang/lib/Analysis/UnsafeBufferUsage.cpp

void clang::checkUnsafeBufferUsage(const Decl *D,
 
   Strategy NaiveStrategy = getNaiveStrategy(UnsafeVars);
   std::map<const VarDecl *, FixItList> FixItsForVariable =
       getFixIts(FixablesForUnsafeVars, NaiveStrategy);
 
   // FIXME Detect overlapping FixIts.
 
   for (auto G : UnsafeOps.noVar) {
-    Handler.handleUnsafeOperation(G->getBaseStmt());
+    Handler.handleUnsafeOperation(G->getBaseStmt(), /*IsRelatedToDecl=*/false);
   }
 
   for (const auto &[VD, WarningGadgets] : UnsafeOps.byVar) {
     auto FixItsIt = FixItsForVariable.find(VD);
-    if (FixItsIt != FixItsForVariable.end()) {
-      Handler.handleFixableVariable(VD, std::move(FixItsIt->second));
-    } else {
-      for (const WarningGadget *G : WarningGadgets) {
-        Handler.handleUnsafeOperation(G->getBaseStmt());
-      }
+    Handler.handleFixableVariable(VD, FixItsIt != FixItsForVariable.end()
+                                          ? std::move(FixItsIt->second)
+                                          : FixItList{});
+      Handler.handleUnsafeOperation(G->getBaseStmt(), /*IsRelatedToDecl=*/true);
     }
   }
 }

clang/lib/Sema/AnalysisBasedWarnings.cpp

 //===----------------------------------------------------------------------===//
 
 class UnsafeBufferUsageReporter : public UnsafeBufferUsageHandler {
   Sema &S;
 
 public:
   UnsafeBufferUsageReporter(Sema &S) : S(S) {}
 
-  void handleUnsafeOperation(const Stmt *Operation) override {
+  void handleUnsafeOperation(const Stmt *Operation,
+                             bool IsRelatedToDecl) override {
     SourceLocation Loc;
     SourceRange Range;
+    unsigned MsgParam = 0;
     if (auto ASE = dyn_cast<ArraySubscriptExpr>(Operation)) {
       Loc = ASE->getBase()->getExprLoc();
       Range = ASE->getBase()->getSourceRange();
+      MsgParam = 2;
     } else if (auto BO = dyn_cast<BinaryOperator>(Operation)) {
       const auto Op = BO->getOpcode();
       if (Op == BO_Add || Op == BO_AddAssign || Op == BO_Sub ||
           Op == BO_SubAssign) {
         if (BO->getRHS()->getType()->isIntegerType()) {
           Loc = BO->getLHS()->getExprLoc();
           Range = BO->getLHS()->getSourceRange();
         } else {
           Loc = BO->getRHS()->getExprLoc();
           Range = BO->getRHS()->getSourceRange();
         }
+        MsgParam = 1;
       }
     } else if (auto UO = dyn_cast<UnaryOperator>(Operation)) {
       const auto Op = UO->getOpcode();
       if (Op == UO_PreInc || Op == UO_PreDec || Op == UO_PostInc ||
           Op == UO_PostDec) {
         Loc = UO->getSubExpr()->getExprLoc();
         Range = UO->getSubExpr()->getSourceRange();
+        MsgParam = 1;
       }
     } else {
       Loc = Operation->getBeginLoc();
       Range = Operation->getSourceRange();
     }
-    S.Diag(Loc, diag::warn_unsafe_buffer_expression) << Range;
+    if (IsRelatedToDecl)
+      S.Diag(Loc, diag::note_unsafe_buffer_operation) << MsgParam << Range;
+    else
+      S.Diag(Loc, diag::warn_unsafe_buffer_operation) << MsgParam << Range;
   }
 
+  // FIXME: rename to handleUnsafeVariable
   void handleFixableVariable(const VarDecl *Variable,
                              FixItList &&Fixes) override {
     const auto &D =
-        S.Diag(Variable->getBeginLoc(), diag::warn_unsafe_buffer_variable);
-    D << Variable << Variable->getSourceRange();
-    for (const auto &F: Fixes)
+        S.Diag(Variable->getLocation(), diag::warn_unsafe_buffer_variable);
+    D << Variable;
+    D << (Variable->getType()->isPointerType() ? 0 : 1);
+    D << Variable->getSourceRange();
+    for (const auto &F : Fixes)
       D << F;
   }
 };
 
 
 //===----------------------------------------------------------------------===//
 // AnalysisBasedWarnings - Worker object used by Sema to execute analysis-based
 //  warnings on a function, method, or block.
void clang::sema::AnalysisBasedWarnings::IssueWarnings(
 
   // Check for throw out of non-throwing function.
   if (!Diags.isIgnored(diag::warn_throw_in_noexcept_func, D->getBeginLoc()))
     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
       if (S.getLangOpts().CPlusPlus && isNoexcept(FD))
         checkThrowInNonThrowingFunc(S, FD, AC);
 
   // Emit unsafe buffer usage warnings and fixits.
-  if (!Diags.isIgnored(diag::warn_unsafe_buffer_expression, D->getBeginLoc()) ||
+  if (!Diags.isIgnored(diag::warn_unsafe_buffer_operation, D->getBeginLoc()) ||
       !Diags.isIgnored(diag::warn_unsafe_buffer_variable, D->getBeginLoc())) {
     UnsafeBufferUsageReporter R(S);
     checkUnsafeBufferUsage(D, R);
   }
 
   // If none of the previous checks caused a CFG build, trigger one here
   // for the logical error handler.
   if (LogicalErrorHandler::hasActiveDiagnostics(Diags, D->getBeginLoc())) {

clang/test/SemaCXX/unsafe-buffer-usage-diag-type.cpp

+// RUN: %clang_cc1 -std=c++20 -Wno-all -Wunsafe-buffer-usage -verify %s
+
+namespace localVar {
+void testRefersPtrLocalVarDecl(int i) {
+  int * ptr;    // expected-warning{{'ptr' is an unsafe pointer used for buffer access}}
+  ptr + i;      // expected-note{{used in pointer arithmetic here}}
+  ptr[i];       // expected-note{{used in buffer access here}}
+}
+
+void testRefersArrayLocalVarDecl(int i) {
+  int array[i];   // expected-warning{{'array' is an unsafe buffer that does not perform bounds}}
+  array[i/2];     // expected-note{{used in buffer access here}}
+}
+}
+
+namespace globalVar {
+int * ptr;      // expected-warning{{'ptr' is an unsafe pointer used for buffer access}}
+void testRefersPtrGlobalVarDecl(int i) {
+  ptr + i;      // expected-note{{used in pointer arithmetic here}}
+  ptr[i];       // expected-note{{used in buffer access here}}
+}
+
+int array[10];     // expected-warning{{'array' is an unsafe buffer that does not perform bounds}}
+void testRefersArrayGlobalVarDecl(int i) {
+  array[i/2];     // expected-note{{used in buffer access here}}
+}
+}
+
+namespace functionParm {
+void testRefersPtrParmVarDecl(int * ptr) {
+                // expected-warning@-1{{'ptr' is an unsafe pointer used for buffer access}}
+  ptr + 5;      // expected-note{{used in pointer arithmetic here}}
+  ptr[5];       // expected-note{{used in buffer access here}}
+}
+
+// FIXME: shall we explain the array to pointer decay to make the warning more understandable?
+void testRefersArrayParmVarDecl(int array[10]) {
+                // expected-warning@-1{{'array' is an unsafe pointer used for buffer access}}
+  array[2];     // expected-note{{used in buffer access here}}
+}
+}
+
+namespace structField {
+struct Struct1 {
+  int * ptr;      // FIXME: per-declaration warning aggregated at the struct definition?
+};
+
+void testRefersPtrStructFieldDecl(int i) {
+  Struct1 s1;
+  s1.ptr + i;     // expected-warning{{unsafe pointer arithmetic}}
+  s1.ptr[i];      // expected-warning{{unsafe buffer access}}
+}
+
+struct Struct2 {
+  int array[10];  // FIXME: per-declaration warning aggregated at the struct definition?
+};
+
+void testRefersArrayStructFieldDecl(int i) {
+  Struct2 s2;
+  s2.array[i/2];  // expected-warning{{unsafe buffer access}}
+}
+}
+
+namespace structFieldFromMethod {
+struct Struct1 {
+  int * ptr;      // FIXME: per-declaration warning aggregated at the struct definition
+
+  void testRefersPtrStructFieldDecl(int i) {
+    ptr + i;     // expected-warning{{unsafe pointer arithmetic}}
+    ptr[i];      // expected-warning{{unsafe buffer access}}
+  }
+};
+
+struct Struct2 {
+  int array[10];  // FIXME: per-declaration warning aggregated at the struct definition
+
+  void testRefersArrayStructFieldDecl(int i) {
+    Struct2 s2;
+    s2.array[i/2];  // expected-warning{{unsafe buffer access}}
+  }
+};
+}
+
+namespace staticStructField {
+struct Struct1 {
+  static int * ptr;      // expected-warning{{'ptr' is an unsafe pointer used for buffer access}}
+};
+
+void testRefersPtrStructFieldDecl(int i) {
+  Struct1::ptr + i;      // expected-note{{used in pointer arithmetic here}}
+  Struct1::ptr[i];       // expected-note{{used in buffer access here}}
+}
+
+struct Struct2 {
+  static int array[10];     // expected-warning{{'array' is an unsafe buffer that does not perform bounds}}
+};
+
+void testRefersArrayStructFieldDecl(int i) {
+  Struct2::array[i/2];     // expected-note{{used in buffer access here}}
+}
+}
+
+int * return_ptr();
+
+void testNoDeclRef(int i) {
+  return_ptr() + i;   // expected-warning{{unsafe pointer arithmetic}}
+  return_ptr()[i];    // expected-warning{{unsafe buffer access}}
+}

clang/test/SemaCXX/warn-unsafe-buffer-usage-source-ranges.cpp

 // RUN: %clang_cc1 -Wno-everything -Wunsafe-buffer-usage -fdiagnostics-print-source-range-info %s 2>&1 | FileCheck %s
 
 void foo(int i) {
   int * ptr;
 
-
   ptr++;
-  // CHECK-DAG: {7:3-7:6}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:3-[[@LINE-1]]:6}
   ptr--;
-  // CHECK-DAG: {9:3-9:6}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:3-[[@LINE-1]]:6}
   ++ptr;
-  // CHECK-DAG: {11:5-11:8}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:5-[[@LINE-1]]:8}
   --ptr;
-  // CHECK-DAG: {13:5-13:8}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:5-[[@LINE-1]]:8}
 
 
   ptr + 1;
-  // CHECK-DAG: {17:3-17:6}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:3-[[@LINE-1]]:6}
   2 + ptr;
-  // CHECK-DAG: {19:7-19:10}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:7-[[@LINE-1]]:10}
   ptr + i;
-  // CHECK-DAG: {21:3-21:6}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:3-[[@LINE-1]]:6}
   i + ptr;
-  // CHECK-DAG: {23:7-23:10}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:7-[[@LINE-1]]:10}
 
 
   ptr - 3;
-  // CHECK-DAG: {27:3-27:6}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:3-[[@LINE-1]]:6}
   ptr - i;
-  // CHECK-DAG: {29:3-29:6}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:3-[[@LINE-1]]:6}
 
 
   ptr += 4;
-  // CHECK-DAG: {33:3-33:6}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:3-[[@LINE-1]]:6}
   ptr += i;
-  // CHECK-DAG: {35:3-35:6}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:3-[[@LINE-1]]:6}
 
 
   ptr -= 5;
-  // CHECK-DAG: {39:3-39:6}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:3-[[@LINE-1]]:6}
   ptr -= i;
-  // CHECK-DAG: {41:3-41:6}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:3-[[@LINE-1]]:6}
 
 
   ptr[5];
-  // CHECK-DAG: {45:3-45:6}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:3-[[@LINE-1]]:6}
   5[ptr];
-  // CHECK-DAG: {47:5-47:8}{{.*}}[-Wunsafe-buffer-usage]
+  // CHECK-DAG: {[[@LINE-1]]:5-[[@LINE-1]]:8}
 }

clang/test/SemaCXX/warn-unsafe-buffer-usage.cpp

-// RUN: %clang_cc1 -std=c++20 -Wunsafe-buffer-usage -fblocks -include %s -verify %s
+// RUN: %clang_cc1 -std=c++20 -Wno-all -Wunsafe-buffer-usage -fblocks -include %s -verify %s
+
+// RUN: %clang -x c++ -fsyntax-only -fblocks -include %s %s 2>&1 | FileCheck --allow-empty %s
+// RUN: %clang_cc1 -std=c++11 -fblocks -include %s %s 2>&1 | FileCheck --allow-empty %s
+// RUN: %clang_cc1 -std=c++20 -fblocks -include %s %s 2>&1 | FileCheck --allow-empty %s
+// CHECK-NOT: [-Wunsafe-buffer-usage]
+
 #ifndef INCLUDED
 #define INCLUDED
 #pragma clang system_header
 
 // no spanification warnings for system headers
 void foo(...);  // let arguments of `foo` to hold testing expressions
 void testAsSystemHeader(char *p) {
   ++p;
 
   auto ap1 = p;
   auto ap2 = &p;
 
   foo(p[1],
       ap1[1],
       ap2[2][3]);
 }
 
 #else
 
-void testIncrement(char *p) {
-  ++p; // expected-warning{{unchecked operation on raw buffer in expression}}
-  p++; // expected-warning{{unchecked operation on raw buffer in expression}}
-  --p; // expected-warning{{unchecked operation on raw buffer in expression}}
-  p--; // expected-warning{{unchecked operation on raw buffer in expression}}
+void testIncrement(char *p) { // expected-warning{{'p' is an unsafe pointer used for buffer access}}
+  ++p; // expected-note{{used in pointer arithmetic here}}
+  p++; // expected-note{{used in pointer arithmetic here}}
+  --p; // expected-note{{used in pointer arithmetic here}}
+  p--; // expected-note{{used in pointer arithmetic here}}
 }
 
 void * voidPtrCall(void);
 char * charPtrCall(void);
 
 void testArraySubscripts(int *p, int **pp) {
-  foo(p[1],             // expected-warning{{unchecked operation on raw buffer in expression}}
-      pp[1][1],         // expected-warning2{{unchecked operation on raw buffer in expression}}
-      1[1[pp]],         // expected-warning2{{unchecked operation on raw buffer in expression}}
-      1[pp][1]          // expected-warning2{{unchecked operation on raw buffer in expression}}
+// expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
+// expected-warning@-2{{'pp' is an unsafe pointer used for buffer access}}
+  foo(p[1],             // expected-note{{used in buffer access here}}
+      pp[1][1],         // expected-note{{used in buffer access here}}
+                        // expected-warning@-1{{unsafe buffer access}}
+      1[1[pp]],         // expected-note{{used in buffer access here}}
+                        // expected-warning@-1{{unsafe buffer access}}
+      1[pp][1]          // expected-note{{used in buffer access here}}
+                        // expected-warning@-1{{unsafe buffer access}}
       );
 
-  if (p[3]) {           // expected-warning{{unchecked operation on raw buffer in expression}}
+  if (p[3]) {           // expected-note{{used in buffer access here}}
     void * q = p;
 
-    foo(((int*)q)[10]); // expected-warning{{unchecked operation on raw buffer in expression}}
+    foo(((int*)q)[10]); // expected-warning{{unsafe buffer access}}
   }
 
-  foo(((int*)voidPtrCall())[3], // expected-warning{{unchecked operation on raw buffer in expression}}
-      3[(int*)voidPtrCall()],   // expected-warning{{unchecked operation on raw buffer in expression}}
-      charPtrCall()[3],         // expected-warning{{unchecked operation on raw buffer in expression}}
-      3[charPtrCall()]          // expected-warning{{unchecked operation on raw buffer in expression}}
+  foo(((int*)voidPtrCall())[3], // expected-warning{{unsafe buffer access}}
+      3[(int*)voidPtrCall()],   // expected-warning{{unsafe buffer access}}
+      charPtrCall()[3],         // expected-warning{{unsafe buffer access}}
+      3[charPtrCall()]          // expected-warning{{unsafe buffer access}}
       );
 
-  int a[10], b[10][10];
+    int a[10];          // expected-warning{{'a' is an unsafe buffer that does not perform bounds checks}}
+    int b[10][10];      // expected-warning{{'b' is an unsafe buffer that does not perform bounds checks}}
 
-  foo(a[1], 1[a],   // expected-warning2{{unchecked operation on raw buffer in expression}}
-      b[3][4],      // expected-warning2{{unchecked operation on raw buffer in expression}}
-      4[b][3],      // expected-warning2{{unchecked operation on raw buffer in expression}}
-      4[3[b]]);     // expected-warning2{{unchecked operation on raw buffer in expression}}
+  foo(a[1], 1[a],   // expected-note2{{used in buffer access here}}
+      b[3][4],      // expected-warning{{unsafe buffer access}}
+                    // expected-note@-1{{used in buffer access here}}
+      4[b][3],      // expected-warning{{unsafe buffer access}}
+                    // expected-note@-1{{used in buffer access here}}
+      4[3[b]]);     // expected-warning{{unsafe buffer access}}
+                    // expected-note@-1{{used in buffer access here}}
 
   // Not to warn when index is zero
   foo(p[0], pp[0][0], 0[0[pp]], 0[pp][0],
       ((int*)voidPtrCall())[0],
       0[(int*)voidPtrCall()],
       charPtrCall()[0],
       0[charPtrCall()]
       );
 }
 
 void testArraySubscriptsWithAuto(int *p, int **pp) {
   int a[10];
-  auto ap1 = a;
+  auto ap1 = a;   // expected-warning{{'ap1' is an unsafe pointer used for buffer access}}
 
-  foo(ap1[1]);  // expected-warning{{unchecked operation on raw buffer in expression}}
+  foo(ap1[1]);    // expected-note{{used in buffer access here}}
 
-  auto ap2 = p;
+  auto ap2 = p;   // expected-warning{{'ap2' is an unsafe pointer used for buffer access}}
 
-  foo(ap2[1]);  // expected-warning{{unchecked operation on raw buffer in expression}}
+  foo(ap2[1]);    // expected-note{{used in buffer access here}}
 
-  auto ap3 = pp;
+  auto ap3 = pp;  // expected-warning{{'ap3' is an unsafe pointer used for buffer access}}
 
-  foo(ap3[1][1]); // expected-warning2{{unchecked operation on raw buffer in expression}}
+  foo(ap3[1][1]); // expected-note{{used in buffer access here}}
+                  // expected-warning@-1{{unsafe buffer access}}
 
-  auto ap4 = *pp;
+  auto ap4 = *pp; // expected-warning{{'ap4' is an unsafe pointer used for buffer access}}
 
-  foo(ap4[1]);  // expected-warning{{unchecked operation on raw buffer in expression}}
+  foo(ap4[1]);    // expected-note{{used in buffer access here}}
 }
 
-void testUnevaluatedContext(int * p) {
-  //TODO: do not warn for unevaluated context
-  foo(sizeof(p[1]),             // expected-warning{{unchecked operation on raw buffer in expression}}
-      sizeof(decltype(p[1])));  // expected-warning{{unchecked operation on raw buffer in expression}}
-}
+void testQualifiedParameters(const int * p, const int * const q, const int a[10], const int b[10][10]) {
+  // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
+  // expected-warning@-2{{'q' is an unsafe pointer used for buffer access}}
+  // expected-warning@-3{{'a' is an unsafe pointer used for buffer access}}
+  // expected-warning@-4{{'b' is an unsafe pointer used for buffer access}}
 
-void testQualifiedParameters(const int * p, const int * const q,
-           const int a[10], const int b[10][10],
-           int (&c)[10]) {
-  foo(p[1], 1[p], p[-1],   // expected-warning3{{unchecked operation on raw buffer in expression}}
-      q[1], 1[q], q[-1],   // expected-warning3{{unchecked operation on raw buffer in expression}}
-      a[1],                // expected-warning{{unchecked operation on raw buffer in expression}}     `a` is of pointer type
-      b[1][2]              // expected-warning2{{unchecked operation on raw buffer in expression}}     `b[1]` is of array type
+  foo(p[1], 1[p], p[-1],    // expected-note3{{used in buffer access here}}
+      q[1], 1[q], q[-1],    // expected-note3{{used in buffer access here}}
+      a[1],                 // expected-note{{used in buffer access here}}     `a` is of pointer type
+      b[1][2]               // expected-note{{used in buffer access here}}     `b[1]` is of array type
+                            // expected-warning@-1{{unsafe buffer access}}
       );
 }
 
 struct T {
   int a[10];
   int * b;
   struct {
     int a[10];
     int * b;
   } c;
 };
 
 typedef struct T T_t;
 
 T_t funRetT();
 T_t * funRetTStar();
 
 void testStructMembers(struct T * sp, struct T s, T_t * sp2, T_t s2) {
-  foo(sp->a[1],   // expected-warning{{unchecked operation on raw buffer in expression}}
-      sp->b[1],     // expected-warning{{unchecked operation on raw buffer in expression}}
-      sp->c.a[1],   // expected-warning{{unchecked operation on raw buffer in expression}}
-      sp->c.b[1],   // expected-warning{{unchecked operation on raw buffer in expression}}
-      s.a[1],       // expected-warning{{unchecked operation on raw buffer in expression}}
-      s.b[1],       // expected-warning{{unchecked operation on raw buffer in expression}}
-      s.c.a[1],     // expected-warning{{unchecked operation on raw buffer in expression}}
-      s.c.b[1],     // expected-warning{{unchecked operation on raw buffer in expression}}
-      sp2->a[1],    // expected-warning{{unchecked operation on raw buffer in expression}}
-      sp2->b[1],    // expected-warning{{unchecked operation on raw buffer in expression}}
-      sp2->c.a[1],  // expected-warning{{unchecked operation on raw buffer in expression}}
-      sp2->c.b[1],  // expected-warning{{unchecked operation on raw buffer in expression}}
-      s2.a[1],    // expected-warning{{unchecked operation on raw buffer in expression}}
-      s2.b[1],      // expected-warning{{unchecked operation on raw buffer in expression}}
-      s2.c.a[1],           // expected-warning{{unchecked operation on raw buffer in expression}}
-      s2.c.b[1],           // expected-warning{{unchecked operation on raw buffer in expression}}
-      funRetT().a[1],      // expected-warning{{unchecked operation on raw buffer in expression}}
-      funRetT().b[1],      // expected-warning{{unchecked operation on raw buffer in expression}}
-      funRetTStar()->a[1], // expected-warning{{unchecked operation on raw buffer in expression}}
-      funRetTStar()->b[1]  // expected-warning{{unchecked operation on raw buffer in expression}}
+  foo(sp->a[1],     // expected-warning{{unsafe buffer access}}
+      sp->b[1],     // expected-warning{{unsafe buffer access}}
+      sp->c.a[1],   // expected-warning{{unsafe buffer access}}
+      sp->c.b[1],   // expected-warning{{unsafe buffer access}}
+      s.a[1],       // expected-warning{{unsafe buffer access}}
+      s.b[1],       // expected-warning{{unsafe buffer access}}
+      s.c.a[1],     // expected-warning{{unsafe buffer access}}
+      s.c.b[1],     // expected-warning{{unsafe buffer access}}
+      sp2->a[1],    // expected-warning{{unsafe buffer access}}
+      sp2->b[1],    // expected-warning{{unsafe buffer access}}
+      sp2->c.a[1],  // expected-warning{{unsafe buffer access}}
+      sp2->c.b[1],  // expected-warning{{unsafe buffer access}}
+      s2.a[1],      // expected-warning{{unsafe buffer access}}
+      s2.b[1],      // expected-warning{{unsafe buffer access}}
+      s2.c.a[1],           // expected-warning{{unsafe buffer access}}
+      s2.c.b[1],           // expected-warning{{unsafe buffer access}}
+      funRetT().a[1],      // expected-warning{{unsafe buffer access}}
+      funRetT().b[1],      // expected-warning{{unsafe buffer access}}
+      funRetTStar()->a[1], // expected-warning{{unsafe buffer access}}
+      funRetTStar()->b[1]  // expected-warning{{unsafe buffer access}}
       );
 }
 
-int garray[10];
-int * gp = garray;
-int gvar = gp[1];  // FIXME: file scope unsafe buffer access is not warned
+int garray[10];     // expected-warning{{'garray' is an unsafe buffer that does not perform bounds checks}}
+int * gp = garray;  // expected-warning{{'gp' is an unsafe pointer used for buffer access}}
+int gvar = gp[1];   // FIXME: file scope unsafe buffer access is not warned
 
+// FIXME: Add test for lambda capture with initializer. E. g. auto Lam = [new_p = p]() {...
 void testLambdaCaptureAndGlobal(int * p) {
-  int a[10];
+  // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
+  int a[10];              // expected-warning{{'a' is an unsafe buffer that does not perform bounds checks}}
 
   auto Lam = [p, a]() {
-    return p[1] // expected-warning{{unchecked operation on raw buffer in expression}}
-      + a[1] + garray[1] // expected-warning2{{unchecked operation on raw buffer in expression}}
-      + gp[1];  // expected-warning{{unchecked operation on raw buffer in expression}}
+    return p[1]           // expected-note{{used in buffer access here}}
+      + a[1] + garray[1]  // expected-note2{{used in buffer access here}}
+      + gp[1];            // expected-note{{used in buffer access here}}
   };
 }
 
 typedef T_t * T_ptr_t;
 
 void testTypedefs(T_ptr_t p) {
-  foo(p[1],      // expected-warning{{unchecked operation on raw buffer in expression}}
-      p[1].a[1], // expected-warning2{{unchecked operation on raw buffer in expression}}
-      p[1].b[1]  // expected-warning2{{unchecked operation on raw buffer in expression}}
+  // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
+  foo(p[1],       // expected-note{{used in buffer access here}}
+      p[1].a[1],  // expected-note{{used in buffer access here}}
+                  // expected-warning@-1{{unsafe buffer access}}
+      p[1].b[1]   // expected-note{{used in buffer access here}}
+                  // expected-warning@-1{{unsafe buffer access}}
       );
 }
 
-template<typename T, int N> T f(T t, T * pt, T a[N], T (&b)[N]) {
-  foo(pt[1],    // expected-warning{{unchecked operation on raw buffer in expression}}
-      a[1],     // expected-warning{{unchecked operation on raw buffer in expression}}
-      b[1]);    // `b` is of array type
-  return &t[1]; // expected-warning{{unchecked operation on raw buffer in expression}}
+template<typename T> T f(T t) {
+  // expected-warning@-1{{'t' is an unsafe pointer used for buffer access}}
+  return &t[1]; // expected-note{{used in buffer access here}}
 }
 
 // Testing pointer arithmetic for pointer-to-int, qualified multi-level
 // pointer, pointer to a template type, and auto type
 T_ptr_t getPtr();
 
 template<typename T>
 void testPointerArithmetic(int * p, const int **q, T * x) {
+// expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
+// expected-warning@-2{{'x' is an unsafe pointer used for buffer access}}
   int a[10];
-  auto y = &a[0];
+  auto y = &a[0]; // expected-warning{{'y' is an unsafe pointer used for buffer access}}
 
-  foo(p + 1, 1 + p, p - 1,      // expected-warning3{{unchecked operation on raw buffer in expression}}
-      *q + 1, 1 + *q, *q - 1,   // expected-warning3{{unchecked operation on raw buffer in expression}}
-      x + 1, 1 + x, x - 1,      // expected-warning3{{unchecked operation on raw buffer in expression}}
-      y + 1, 1 + y, y - 1,      // expected-warning3{{unchecked operation on raw buffer in expression}}
-      getPtr() + 1, 1 + getPtr(), getPtr() - 1 // expected-warning3{{unchecked operation on raw buffer in expression}}
+  foo(p + 1, 1 + p, p - 1,      // expected-note3{{used in pointer arithmetic here}}
+      *q + 1, 1 + *q, *q - 1,   // expected-warning3{{unsafe pointer arithmetic}}
+      x + 1, 1 + x, x - 1,      // expected-note3{{used in pointer arithmetic here}}
+      y + 1, 1 + y, y - 1,      // expected-note3{{used in pointer arithmetic here}}
+      getPtr() + 1, 1 + getPtr(), getPtr() - 1 // expected-warning3{{unsafe pointer arithmetic}}
       );
   
-  p += 1;  p -= 1;  // expected-warning2{{unchecked operation on raw buffer in expression}}
-  *q += 1; *q -= 1; // expected-warning2{{unchecked operation on raw buffer in expression}}
-  y += 1; y -= 1;   // expected-warning2{{unchecked operation on raw buffer in expression}}
-  x += 1; x -= 1;   // expected-warning2{{unchecked operation on raw buffer in expression}}
+  p += 1;  p -= 1;  // expected-note2{{used in pointer arithmetic here}}
+  *q += 1; *q -= 1; // expected-warning2{{unsafe pointer arithmetic}}
+  y += 1; y -= 1;   // expected-note2{{used in pointer arithmetic here}}
+  x += 1; x -= 1;   // expected-note2{{used in pointer arithmetic here}}
 }
 
 void testTemplate(int * p) {
-  int *a[10];
-  foo(f(p, &p, a, a)[1]); // expected-warning{{unchecked operation on raw buffer in expression}}, \
-                             expected-note{{in instantiation of function template specialization 'f<int *, 10>' requested here}}
+  foo(f(p)[1]); // expected-warning{{unsafe buffer access}}
+                // expected-note@-1{{in instantiation of function template specialization 'f<int *>' requested here}}
 
   const int **q = const_cast<const int **>(&p);
 
-  testPointerArithmetic(p, q, p); //expected-note{{in instantiation of function template specialization 'testPointerArithmetic<int>' requested here}}
+  testPointerArithmetic(p, q, p); //expected-note{{in instantiation of}}
 }
 
 void testPointerToMember() {
   struct S_t {
     int x;
     int * y;
   } S;
 
   int S_t::* p = &S_t::x;
   int * S_t::* q = &S_t::y;
 
   foo(S.*p,
-      (S.*q)[1]);  // expected-warning{{unchecked operation on raw buffer in expression}}
+      (S.*q)[1]);  // expected-warning{{unsafe buffer access}}
 }
 
 // test that nested callable definitions are scanned only once
 void testNestedCallableDefinition(int * p) {
   class A {
     void inner(int * p) {
-      p++; // expected-warning{{unchecked operation on raw buffer in expression}}
+      // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
+      p++; // expected-note{{used in pointer arithmetic here}}
     }
 
     static void innerStatic(int * p) {
-      p++; // expected-warning{{unchecked operation on raw buffer in expression}}
+      // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
+      p++; // expected-note{{used in pointer arithmetic here}}
     }
 
     void innerInner(int * p) {
       auto Lam = [p]() {
-        int * q = p;
-        q++;   // expected-warning{{unchecked operation on raw buffer in expression}}
+        int * q = p;    // expected-warning{{'q' is an unsafe pointer used for buffer access}}
+        q++;            // expected-note{{used in pointer arithmetic here}}
         return *q;
       };
     }
   };
 
   auto Lam = [p]() {
-    int * q = p;
-    q++;  // expected-warning{{unchecked operation on raw buffer in expression}}
+    int * q = p;  // expected-warning{{'q' is an unsafe pointer used for buffer access}}
+    q++;          // expected-note{{used in pointer arithmetic here}}
     return *q;
   };
 
   auto LamLam = [p]() {
     auto Lam = [p]() {
-      int * q = p;
-      q++;  // expected-warning{{unchecked operation on raw buffer in expression}}
+      int * q = p;  // expected-warning{{'q' is an unsafe pointer used for buffer access}}
+      q++;          // expected-note{{used in pointer arithmetic here}}
       return *q;
     };
   };
 
   void (^Blk)(int*) = ^(int *p) {
-    p++;   // expected-warning{{unchecked operation on raw buffer in expression}}
+    // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
+    p++;   // expected-note{{used in pointer arithmetic here}}
   };
 
   void (^BlkBlk)(int*) = ^(int *p) {
     void (^Blk)(int*) = ^(int *p) {
-      p++;   // expected-warning{{unchecked operation on raw buffer in expression}}
+      // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
+      p++;   // expected-note{{used in pointer arithmetic here}}
     };
     Blk(p);
   };
 
   // lambda and block as call arguments...
-  foo( [p]() { int * q = p;
-              q++;  // expected-warning{{unchecked operation on raw buffer in expression}}
+  foo( [p]() { int * q = p; // expected-warning{{'q' is an unsafe pointer used for buffer access}}
+              q++;          // expected-note{{used in pointer arithmetic here}}
               return *q;
        },
-       ^(int *p) { p++;   // expected-warning{{unchecked operation on raw buffer in expression}}
+       ^(int *p) {  // expected-warning{{'p' is an unsafe pointer used for buffer access}}
+        p++;        // expected-note{{used in pointer arithmetic here}}
        }
      );
 }
 
 int testVariableDecls(int * p) {
-  int * q = p++;      // expected-warning{{unchecked operation on raw buffer in expression}}
-  int a[p[1]];        // expected-warning{{unchecked operation on raw buffer in expression}}
-  int b = p[1];       // expected-warning{{unchecked operation on raw buffer in expression}}
-  return p[1];        // expected-warning{{unchecked operation on raw buffer in expression}}
+  // expected-warning@-1{{'p' is an unsafe pointer used for buffer access}}
+  int * q = p++;      // expected-note{{used in pointer arithmetic here}}
+  int a[p[1]];        // expected-note{{used in buffer access here}}
+  int b = p[1];       // expected-note{{used in buffer access here}}
+  return p[1];        // expected-note{{used in buffer access here}}
 }
 
 template<typename T> void fArr(T t[]) {
-  foo(t[1]);   // expected-warning{{unchecked operation on raw buffer in expression}}
-  T ar[8];
-  foo(ar[5]);  // expected-warning{{unchecked operation on raw buffer in expression}}
+  // expected-warning@-1{{'t' is an unsafe pointer used for buffer access}}
+  foo(t[1]);    // expected-note{{used in buffer access here}}
+  T ar[8];      // expected-warning{{'ar' is an unsafe buffer that does not perform bounds checks}}
+  foo(ar[5]);   // expected-note{{used in buffer access here}}
 }
 
-template void fArr<int>(int t[]); // expected-note {{in instantiation of function template specialization 'fArr<int>' requested here}}
+template void fArr<int>(int t[]); // expected-note {{in instantiation of}}
 
 int testReturn(int t[]) {
-   return t[1]; // expected-warning{{unchecked operation on raw buffer in expression}}
+  // expected-warning@-1{{'t' is an unsafe pointer used for buffer access}}
+  return t[1]; // expected-note{{used in buffer access here}}
 }
 
-//FIXME: Array access warnings on 0-indices;ArraySubscriptGadget excludes 0 index for both raw pointers and arrays!
 int testArrayAccesses(int n) {
     
     // auto deduced array type
     int cArr[2][3] = {{1, 2, 3}, {4, 5, 6}};
+    // expected-warning@-1{{'cArr' is an unsafe buffer that does not perform bounds checks}}
     int d = cArr[0][0];
     foo(cArr[0][0]);
-    foo(cArr[1][2]);     // expected-warning2{{unchecked operation on raw buffer in expression}}
-    auto cPtr = cArr[1][2];  // expected-warning2{{unchecked operation on raw buffer in expression}}
+    foo(cArr[1][2]);        // expected-note{{used in buffer access here}}
+                            // expected-warning@-1{{unsafe buffer access}}
+    auto cPtr = cArr[1][2]; // expected-note{{used in buffer access here}}
+                            // expected-warning@-1{{unsafe buffer access}}
     foo(cPtr);
     
     // Typdefs
     typedef int A[3];
     const A tArr = {4, 5, 6};
-    foo(tArr[0], tArr[1]);  // expected-warning{{unchecked operation on raw buffer in expression}}
-    return cArr[0][1];  // expected-warning{{unchecked operation on raw buffer in expression}}
+    // expected-warning@-1{{'tArr' is an unsafe buffer that does not perform bounds checks}}
+    foo(tArr[0], tArr[1]);  // expected-note{{used in buffer access here}}
+    return cArr[0][1];      // expected-warning{{unsafe buffer access}}
 }
 
+void testMultiLineDeclStmt(int * p) {
+  auto
 
 
+  ap1 = p;      // expected-warning{{'ap1' is an unsafe pointer used for buffer access}}
 
+  foo(ap1[1]);  // expected-note{{used in buffer access here}}
+}
 
 #endif