Add optimization mode for builtin nonnull attribute

bozicrHT · bozicrHT · commit 70f1cb6e6019 · 2025-11-25T08:57:55.000+01:00
Introduce two modes for the builtin nonnull attribute. Instead of always
emitting the GNU-style `nonnull` attribute, Clang now distinguishes
between:

* NonOptimizing: attaches Clang's `_Nonnull` type qualifier.
* Optimizing: emits GNU-style `nonnull` attribute.
diff --git a/clang/include/clang/Basic/Builtins.h b/clang/include/clang/Basic/Builtins.h
@@ -94,6 +94,12 @@ struct Info {
   ///
   /// Must be provided the `Shard` for this `Info` object.
   std::string getName(const InfosShard &Shard) const;
+
+  // Builtin non-null attribute modes.
+  // NonOptimizing: attaches Clang's `_Nonnull` type qualifier to parameters.
+  // Optimizing: emits the classic GNU-style `nonnull` attribute for
+  // optimization.
+  enum class NonNullMode { NonOptimizing, Optimizing };
 };
 
 /// A constexpr function to construct an infos array from X-macros.
@@ -394,7 +400,8 @@ class Context {
 
   /// Return true if this builtin has parameters that must be non-null.
   /// The parameter indices are appended into 'Indxs'.
-  bool isNonNull(unsigned ID, llvm::SmallVectorImpl<int> &Indxs) const;
+  bool isNonNull(unsigned ID, llvm::SmallVectorImpl<int> &Indxs,
+                 Info::NonNullMode &Mode) const;
 
   /// Return true if this function has no side effects and doesn't
   /// read memory, except for possibly errno or raising FP exceptions.
diff --git a/clang/include/clang/Basic/Builtins.td b/clang/include/clang/Basic/Builtins.td
@@ -3095,105 +3095,105 @@ def StrLen : LibBuiltin<"string.h"> {
 // FIXME: This list is incomplete.
 def Printf : LibBuiltin<"stdio.h"> {
   let Spellings = ["printf"];
-  let Attributes = [PrintfFormat<0>, NonNull<[0]>];
+  let Attributes = [PrintfFormat<0>, NonNull<NonOptimizing, [0]>];
   let Prototype = "int(char const*, ...)";
 }
 
 // FIXME: The builtin and library function should have the same signature.
 def BuiltinPrintf : Builtin {
   let Spellings = ["__builtin_printf"];
   let Attributes = [NoThrow, PrintfFormat<0>, FunctionWithBuiltinPrefix,
-                    NonNull<[0]>];
+                    NonNull<NonOptimizing, [0]>];
   let Prototype = "int(char const* restrict, ...)";
 }
 
 def FPrintf : LibBuiltin<"stdio.h"> {
   let Spellings = ["fprintf"];
-  let Attributes = [NoThrow, PrintfFormat<1>, NonNull<[0, 1]>];
+  let Attributes = [NoThrow, PrintfFormat<1>, NonNull<NonOptimizing, [0, 1]>];
   let Prototype = "int(FILE* restrict, char const* restrict, ...)";
   let AddBuiltinPrefixedAlias = 1;
 }
 
 def SnPrintf : LibBuiltin<"stdio.h"> {
   let Spellings = ["snprintf"];
-  let Attributes = [NoThrow, PrintfFormat<2>, NonNull<[2]>];
+  let Attributes = [NoThrow, PrintfFormat<2>, NonNull<NonOptimizing, [2]>];
   let Prototype = "int(char* restrict, size_t, char const* restrict, ...)";
   let AddBuiltinPrefixedAlias = 1;
 }
 
 def SPrintf : LibBuiltin<"stdio.h"> {
   let Spellings = ["sprintf"];
-  let Attributes = [NoThrow, PrintfFormat<1>, NonNull<[0, 1]>];
+  let Attributes = [NoThrow, PrintfFormat<1>, NonNull<NonOptimizing, [0, 1]>];
   let Prototype = "int(char* restrict, char const* restrict, ...)";
   let AddBuiltinPrefixedAlias = 1;
 }
 
 def VPrintf : LibBuiltin<"stdio.h"> {
   let Spellings = ["vprintf"];
-  let Attributes = [NoThrow, VPrintfFormat<0>, NonNull<[0]>];
+  let Attributes = [NoThrow, VPrintfFormat<0>, NonNull<NonOptimizing, [0]>];
   let Prototype = "int(char const* restrict, __builtin_va_list)";
   let AddBuiltinPrefixedAlias = 1;
 }
 
 def VfPrintf : LibBuiltin<"stdio.h"> {
   let Spellings = ["vfprintf"];
-  let Attributes = [NoThrow, VPrintfFormat<1>, NonNull<[0, 1]>];
+  let Attributes = [NoThrow, VPrintfFormat<1>, NonNull<NonOptimizing, [0, 1]>];
   let Prototype = "int(FILE* restrict, char const* restrict, __builtin_va_list)";
   let AddBuiltinPrefixedAlias = 1;
 }
 
 def VsnPrintf : LibBuiltin<"stdio.h"> {
   let Spellings = ["vsnprintf"];
-  let Attributes = [NoThrow, VPrintfFormat<2>, NonNull<[2]>];
+  let Attributes = [NoThrow, VPrintfFormat<2>, NonNull<NonOptimizing, [2]>];
   let Prototype = "int(char* restrict, size_t, char const* restrict, __builtin_va_list)";
   let AddBuiltinPrefixedAlias = 1;
 }
 
 def VsPrintf : LibBuiltin<"stdio.h"> {
   let Spellings = ["vsprintf"];
-  let Attributes = [NoThrow, VPrintfFormat<1>, NonNull<[0, 1]>];
+  let Attributes = [NoThrow, VPrintfFormat<1>, NonNull<NonOptimizing, [0, 1]>];
   let Prototype = "int(char* restrict, char const* restrict, __builtin_va_list)";
   let AddBuiltinPrefixedAlias = 1;
 }
 
 def Scanf : LibBuiltin<"stdio.h"> {
   let Spellings = ["scanf"];
-  let Attributes = [ScanfFormat<0>, NonNull<[0]>];
+  let Attributes = [ScanfFormat<0>, NonNull<NonOptimizing, [0]>];
   let Prototype = "int(char const* restrict, ...)";
   let AddBuiltinPrefixedAlias = 1;
 }
 
 def FScanf : LibBuiltin<"stdio.h"> {
   let Spellings = ["fscanf"];
-  let Attributes = [ScanfFormat<1>, NonNull<[0, 1]>];
+  let Attributes = [ScanfFormat<1>, NonNull<NonOptimizing, [0, 1]>];
   let Prototype = "int(FILE* restrict, char const* restrict, ...)";
   let AddBuiltinPrefixedAlias = 1;
 }
 
 def SScanf : LibBuiltin<"stdio.h"> {
   let Spellings = ["sscanf"];
-  let Attributes = [ScanfFormat<1>, NonNull<[0, 1]>];
+  let Attributes = [ScanfFormat<1>, NonNull<NonOptimizing, [0, 1]>];
   let Prototype = "int(char const* restrict, char const* restrict, ...)";
   let AddBuiltinPrefixedAlias = 1;
 }
 
 def VScanf : LibBuiltin<"stdio.h"> {
   let Spellings = ["vscanf"];
-  let Attributes = [VScanfFormat<0>, NonNull<[0]>];
+  let Attributes = [VScanfFormat<0>, NonNull<NonOptimizing, [0]>];
   let Prototype = "int(char const* restrict, __builtin_va_list)";
   let AddBuiltinPrefixedAlias = 1;
 }
 
 def VFScanf : LibBuiltin<"stdio.h"> {
   let Spellings = ["vfscanf"];
-  let Attributes = [VScanfFormat<1>, NonNull<[0, 1]>];
+  let Attributes = [VScanfFormat<1>, NonNull<NonOptimizing, [0, 1]>];
   let Prototype = "int(FILE* restrict, char const* restrict, __builtin_va_list)";
   let AddBuiltinPrefixedAlias = 1;
 }
 
 def VSScanf : LibBuiltin<"stdio.h"> {
   let Spellings = ["vsscanf"];
-  let Attributes = [VScanfFormat<1>, NonNull<[0, 1]>];
+  let Attributes = [VScanfFormat<1>, NonNull<NonOptimizing, [0, 1]>];
   let Prototype = "int(char const* restrict, char const* restrict, __builtin_va_list)";
   let AddBuiltinPrefixedAlias = 1;
 }
diff --git a/clang/include/clang/Basic/BuiltinsBase.td b/clang/include/clang/Basic/BuiltinsBase.td
@@ -33,6 +33,18 @@ def NoThrow : Attribute<"n">;
 def Pure : Attribute<"U">;
 def ReturnsTwice : Attribute<"j">;
 
+class NonNullOptMode {
+  int value;
+}
+
+def NonOptimizing : NonNullOptMode { let value = 0; }
+def Optimizing    : NonNullOptMode { let value = 1; }
+
+class NonNull<NonNullOptMode Mode, list<int> Is> : MultiIndexAttribute<"N", Is> {
+  int optMode = Mode.value;
+  let Mangling = "N:" # Mode.value # ":";
+}
+
 // builtin-specific attributes
 // ---------------------------
 
@@ -84,7 +96,6 @@ def Consteval : Attribute<"EG">;
 // Callback behavior: the first index argument is called with the arguments
 // indicated by the remaining indices.
 class Callback<list<int> ArgIndices> : MultiIndexAttribute<"C", ArgIndices>;
-class NonNull<list<int> ArgIndices> : MultiIndexAttribute<"N", ArgIndices>;
 
 // Prefixes
 // ========
diff --git a/clang/lib/Basic/Builtins.cpp b/clang/lib/Basic/Builtins.cpp
@@ -313,14 +313,22 @@ static void parseCommaSeparatedIndices(const char *CurrPos,
   assert(*EndPos == '>' && "Index list must end with '>'");
 }
 
-bool Builtin::Context::isNonNull(unsigned ID,
-                                 llvm::SmallVectorImpl<int> &Indxs) const {
+bool Builtin::Context::isNonNull(unsigned ID, llvm::SmallVectorImpl<int> &Indxs,
+                                 Info::NonNullMode &Mode) const {
 
   const char *AttrPos = ::strchr(getAttributesString(ID), 'N');
   if (!AttrPos)
     return false;
 
-  ++AttrPos;
+  AttrPos += 2; // skip 'N' and ':'
+  if (*AttrPos == '0')
+    Mode = Info::NonNullMode::NonOptimizing;
+  else if (*AttrPos == '1')
+    Mode = Info::NonNullMode::Optimizing;
+  else
+    llvm_unreachable("Unrecognized NonNull optimization mode");
+  AttrPos += 2; // skip mode and ':'
+
   parseCommaSeparatedIndices(AttrPos, Indxs);
 
   return true;
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
@@ -17142,13 +17142,23 @@ void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
     }
 
     SmallVector<int, 4> Indxs;
-    if (Context.BuiltinInfo.isNonNull(BuiltinID, Indxs) &&
+    Builtin::Info::NonNullMode OptMode;
+    if (Context.BuiltinInfo.isNonNull(BuiltinID, Indxs, OptMode) &&
         !FD->hasAttr<NonNullAttr>()) {
-      llvm::SmallVector<ParamIdx, 4> ParamIndxs;
-      for (int I : Indxs)
-        ParamIndxs.push_back(ParamIdx(I + 1, FD));
-      FD->addAttr(NonNullAttr::CreateImplicit(Context, ParamIndxs.data(),
-                                              ParamIndxs.size()));
+      if (OptMode == Builtin::Info::NonNullMode::NonOptimizing) {
+        for (int I : Indxs) {
+          ParmVarDecl *PVD = FD->getParamDecl(I);
+          QualType T = PVD->getType();
+          T = Context.getAttributedType(attr::TypeNonNull, T, T);
+          PVD->setType(T);
+        }
+      } else if (OptMode == Builtin::Info::NonNullMode::Optimizing) {
+        llvm::SmallVector<ParamIdx, 4> ParamIndxs;
+        for (int I : Indxs)
+          ParamIndxs.push_back(ParamIdx(I + 1, FD));
+        FD->addAttr(NonNullAttr::CreateImplicit(Context, ParamIndxs.data(),
+                                                ParamIndxs.size()));
+      }
     }
     if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) &&
         !FD->hasAttr<ReturnsTwiceAttr>())
diff --git a/clang/test/Analysis/stream.c b/clang/test/Analysis/stream.c
@@ -52,13 +52,13 @@ void check_fputs(void) {
 
 void check_fprintf(void) {
   FILE *fp = tmpfile();
-  fprintf(fp, "ABC"); // expected-warning {{Null pointer passed to 1st parameter expecting 'nonnull'}}
+  fprintf(fp, "ABC"); // expected-warning {{Stream pointer might be NULL}}
   fclose(fp);
 }
 
 void check_fscanf(void) {
   FILE *fp = tmpfile();
-  fscanf(fp, "ABC"); // expected-warning {{Null pointer passed to 1st parameter expecting 'nonnull'}}
+  fscanf(fp, "ABC"); // expected-warning {{Stream pointer might be NULL}}
   fclose(fp);
 }
 
@@ -152,13 +152,13 @@ void f_dopen(int fd) {
 
 void f_vfprintf(int fd, va_list args) {
   FILE *F = fdopen(fd, "r");
-  vfprintf(F, "%d", args); // expected-warning {{Null pointer passed to 1st parameter expecting 'nonnull'}}
+  vfprintf(F, "%d", args); // expected-warning {{Stream pointer might be NULL}}
   fclose(F);
 }
 
 void f_vfscanf(int fd, va_list args) {
   FILE *F = fdopen(fd, "r");
-  vfscanf(F, "%u", args); // expected-warning {{Null pointer passed to 1st parameter expecting 'nonnull'}}
+  vfscanf(F, "%u", args); // expected-warning {{Stream pointer might be NULL}}
   fclose(F);
 }
 
