Add address_is_null capture component

Author: nikic

llvm/docs/LangRef.rst

@@ -1388,10 +1388,11 @@ Currently, only the following parameter attributes are defined:
     which may be ``none``, or a combination of:
 
     - ``address``: The integral address of the pointer.
+    - ``address_is_null`` (subet of ``address``): Whether the address is null.
     - ``provenance``: The ability to access the pointer for both read and write
       after the function returns.
-    - ``read_provenance``: The ability to access the pointer only for reads
-      after the function returns.
+    - ``read_provenance`` (subset of ``provenance``): The ability to access the
+      pointer only for reads after the function returns.
 
     Additionally, it is possible to specify that the pointer is captured via
     the return value only, by using ``captures(ret: ...)``.
@@ -1404,6 +1405,7 @@ Currently, only the following parameter attributes are defined:
     - ``captures(none)``: Pointer not captured.
     - ``captures(address, provenance)``: Equivalent to omitting the attribute.
     - ``captures(address)``: Address may be captured, but not provenance.
+    - ``captures(address_is_null)``: Only captures whether the address is null.
     - ``captures(address, read_provenance)``: Both address and provenance
       captured, but only for read-only access.
     - ``captures(ret: address, provenance)``: Pointer captured through return
@@ -3352,7 +3354,8 @@ memory before the call, the call may capture two components of the pointer:
 
   * The address of the pointer, which is its integral value. This also includes
     parts of the address or any information about the address, including the
-    fact that it does not equal one specific value.
+    fact that it does not equal one specific value. We further distinguish
+    whether only the fact that the address is/isn't null is captured.
   * The provenance of the pointer, which is the ability to perform memory
     accesses through the pointer, in the sense of the :ref:`pointer aliasing
     rules <pointeraliasing>`. We further distinguish whether only read acceses
@@ -3400,19 +3403,6 @@ function, provenance capture refers exclusively to the ability to perform
 accesses *after* the function returns. Memory accesses within the function
 itself are not considered pointer captures.
 
-Comparison of a pointer with a null pointer is generally also considered an
-address capture. As an exception, if the pointer is known to be either null
-or in bounds of an allocated object, it is not considered an address capture.
-As such, the following example does not capture the pointer argument due to
-the presence of the ``dereferenceable_or_null`` attribute:
-
-.. code-block:: llvm
-
-    define i1 @f(ptr dereferenceable_or_null(4) %a) {
-      %c = icmp eq ptr %a, null
-      ret i1 %c
-    }
-
 We can further say that the capture only occurs through a specific location.
 In the following example, the pointer (both address and provenance) is captured
 through the return value only:

llvm/include/llvm/AsmParser/LLToken.h

@@ -209,6 +209,7 @@ enum Kind {
 
   // Captures attribute:
   kw_address,
+  kw_address_is_null,
   kw_provenance,
   kw_read_provenance,
 

llvm/include/llvm/Support/ModRef.h

@@ -276,9 +276,10 @@ using FunctionModRefBehavior = MemoryEffects;
 /// Components of the pointer that may be captured.
 enum class CaptureComponents : uint8_t {
   None = 0,
-  Address = (1 << 0),
-  ReadProvenance = (1 << 1),
-  Provenance = (1 << 2) | ReadProvenance,
+  AddressIsNull = (1 << 0),
+  Address = (1 << 1) | AddressIsNull,
+  ReadProvenance = (1 << 2),
+  Provenance = (1 << 3) | ReadProvenance,
   All = Address | Provenance,
   LLVM_MARK_AS_BITMASK_ENUM(Provenance),
 };
@@ -291,6 +292,10 @@ inline bool capturesAnything(CaptureComponents CC) {
   return CC != CaptureComponents::None;
 }
 
+inline bool capturesAddressIsNullOnly(CaptureComponents CC) {
+  return (CC & CaptureComponents::Address) == CaptureComponents::AddressIsNull;
+}
+
 inline bool capturesAddress(CaptureComponents CC) {
   return (CC & CaptureComponents::Address) != CaptureComponents::None;
 }

llvm/lib/AsmParser/LLLexer.cpp

@@ -704,6 +704,7 @@ lltok::Kind LLLexer::LexIdentifier() {
   KEYWORD(argmemonly);
   KEYWORD(inaccessiblememonly);
   KEYWORD(inaccessiblemem_or_argmemonly);
+  KEYWORD(address_is_null);
   KEYWORD(address);
   KEYWORD(provenance);
   KEYWORD(read_provenance);

llvm/lib/AsmParser/LLParser.cpp

@@ -3192,15 +3192,17 @@ bool LLParser::parseCapturesAttr(AttrBuilder &B) {
       return true;
   } else {
     while (true) {
-      if (EatIfPresent(lltok::kw_address))
+      if (EatIfPresent(lltok::kw_address_is_null))
+        CC |= CaptureComponents::AddressIsNull;
+      else if (EatIfPresent(lltok::kw_address))
         CC |= CaptureComponents::Address;
       else if (EatIfPresent(lltok::kw_provenance))
         CC |= CaptureComponents::Provenance;
       else if (EatIfPresent(lltok::kw_read_provenance))
         CC |= CaptureComponents::ReadProvenance;
       else
-        return tokError(
-            "expected one of 'address', 'provenance' or 'read_provenance'");
+        return tokError("expected one of 'address', 'address_is_null', "
+                        "'provenance' or 'read_provenance'");
 
       if (EatIfPresent(lltok::rparen))
         break;

llvm/lib/Support/ModRef.cpp

@@ -59,7 +59,9 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, CaptureComponents CC) {
   }
 
   ListSeparator LS;
-  if (capturesAddress(CC))
+  if (capturesAddressIsNullOnly(CC))
+    OS << LS << "address_is_null";
+  else if (capturesAddress(CC))
     OS << LS << "address";
   if (capturesReadProvenanceOnly(CC))
     OS << LS << "read_provenance";

llvm/test/Assembler/captures-errors.ll

@@ -35,7 +35,7 @@ define void @test(ptr captures(ret address) %p) {
 
 ;--- invalid-component.ll
 
-; CHECK-INVALID-COMPONENT: <stdin>:[[@LINE+1]]:32: error: expected one of 'address', 'provenance' or 'read_provenance'
+; CHECK-INVALID-COMPONENT: <stdin>:[[@LINE+1]]:32: error: expected one of 'address', 'address_is_null', 'provenance' or 'read_provenance'
 define void @test(ptr captures(foo) %p) {
   ret void
 }

llvm/test/Assembler/captures.ll

@@ -18,6 +18,14 @@ define void @test_address(ptr captures(address) %p) {
   ret void
 }
 
+define void @test_address_is_null(ptr captures(address_is_null) %p) {
+; CHECK-LABEL: define void @test_address_is_null(
+; CHECK-SAME: ptr captures(address_is_null) [[P:%.*]]) {
+; CHECK-NEXT:    ret void
+;
+  ret void
+}
+
 define void @test_address_provenance(ptr captures(address, provenance) %p) {
 ; CHECK-LABEL: define void @test_address_provenance(
 ; CHECK-SAME: ptr captures(address, provenance) [[P:%.*]]) {
@@ -60,6 +68,15 @@ define void @test_duplicate_read_provenance(ptr captures(read_provenance, proven
   ret void
 }
 
+; address_is_null is a subset of address.
+define void @test_duplicate_address_is_null(ptr captures(address_is_null, address) %p) {
+; CHECK-LABEL: define void @test_duplicate_address_is_null(
+; CHECK-SAME: ptr captures(address) [[P:%.*]]) {
+; CHECK-NEXT:    ret void
+;
+  ret void
+}
+
 ; Return-only none is same as plain none.
 define void @test_ret_none(ptr captures(ret: none) %p) {
 ; CHECK-LABEL: define void @test_ret_none(