[WIP][IR][Constants] Use ptr addrspace(N) zeroinitializer to represent a zero-value pointer

Author: shiltian

llvm/include/llvm/IR/Constant.h

@@ -189,6 +189,8 @@ class Constant : public User {
 
   LLVM_ABI static Constant *getNullValue(Type *Ty);
 
+  LLVM_ABI static Constant *getZeroValue(Type *Ty);
+
   /// @returns the value for an integer or vector of integer constant of the
   /// given type that has all its bits set to true.
   /// Get the all ones value

llvm/include/llvm/IR/DataLayout.h

@@ -83,6 +83,11 @@ class DataLayout {
     /// for additional metadata (e.g. AMDGPU buffer fat pointers with bounds
     /// and other flags or CHERI capabilities that contain bounds+permissions).
     uint32_t IndexBitWidth;
+    /// The value of the nullptr in this address space. It can be three values:
+    /// all-zeros, all-ones, or std::nullopt. Since we don't have a way to
+    /// represent an arbitrary bit pattern, we use std::nullopt to represent the
+    /// case where the nullptr value is neither 0 nor -1.
+    std::optional<APInt> NullPtrValue;
     /// Pointers in this address space don't have a well-defined bitwise
     /// representation (e.g. they may be relocated by a copying garbage
     /// collector and thus have different addresses at different times).
@@ -158,7 +163,8 @@ class DataLayout {
   /// Sets or updates the specification for pointer in the given address space.
   void setPointerSpec(uint32_t AddrSpace, uint32_t BitWidth, Align ABIAlign,
                       Align PrefAlign, uint32_t IndexBitWidth,
-                      bool HasUnstableRepr, bool HasExternalState);
+                      std::optional<APInt> NullPtrValue, bool HasUnstableRepr,
+                      bool HasExternalState);
 
   /// Internal helper to get alignment for integer of given bitwidth.
   LLVM_ABI Align getIntegerAlignment(uint32_t BitWidth, bool abi_or_pref) const;
@@ -697,6 +703,11 @@ class DataLayout {
   ///
   /// This includes an explicitly requested alignment (if the global has one).
   LLVM_ABI Align getPreferredAlign(const GlobalVariable *GV) const;
+
+  /// Returns the value of the nullptr in the given address space.
+  LLVM_ABI std::optional<APInt> getNullPtrValue(unsigned AddrSpace) const {
+    return getPointerSpec(AddrSpace).NullPtrValue;
+  }
 };
 
 inline DataLayout *unwrap(LLVMTargetDataRef P) {

llvm/lib/Analysis/ConstantFolding.cpp

@@ -1497,6 +1497,19 @@ Constant *llvm::ConstantFoldCastOperand(unsigned Opcode, Constant *C,
     llvm_unreachable("Missing case");
   case Instruction::PtrToAddr:
   case Instruction::PtrToInt:
+    // If the input is a nullptr, we can fold it to the corresponding nullptr
+    // value.
+    if (Opcode == Instruction::PtrToInt && C->isNullValue()) {
+      if (std::optional<APInt> NullPtrValue = DL.getNullPtrValue(
+              C->getType()->getScalarType()->getPointerAddressSpace())) {
+        if (NullPtrValue->isZero())
+          return Constant::getZeroValue(DestTy);
+        else if (NullPtrValue->isAllOnes())
+          return Constant::getAllOnesValue(DestTy);
+        else
+          llvm_unreachable("invalid nullptr value");
+      }
+    }
     if (auto *CE = dyn_cast<ConstantExpr>(C)) {
       Constant *FoldedValue = nullptr;
       // If the input is an inttoptr, eliminate the pair.  This requires knowing
@@ -1543,6 +1556,13 @@ Constant *llvm::ConstantFoldCastOperand(unsigned Opcode, Constant *C,
     }
     break;
   case Instruction::IntToPtr:
+    // We can fold it to a null pointer if the input is the nullptr value.
+    if (std::optional<APInt> NullPtrValue = DL.getNullPtrValue(
+            DestTy->getScalarType()->getPointerAddressSpace())) {
+      if ((NullPtrValue->isZero() && C->isZeroValue()) ||
+          (NullPtrValue->isAllOnes() && C->isAllOnesValue()))
+        return Constant::getNullValue(DestTy);
+    }
     // If the input is a ptrtoint, turn the pair into a ptr to ptr bitcast if
     // the int size is >= the ptr size and the address spaces are the same.
     // This requires knowing the width of a pointer, so it can't be done in

llvm/lib/AsmParser/LLParser.cpp

@@ -6575,7 +6575,7 @@ bool LLParser::convertValIDToValue(Type *Ty, ValID &ID, Value *&V,
     if (auto *TETy = dyn_cast<TargetExtType>(Ty))
       if (!TETy->hasProperty(TargetExtType::HasZeroInit))
         return error(ID.Loc, "invalid type for null constant");
-    V = Constant::getNullValue(Ty);
+    V = Constant::getZeroValue(Ty);
     return false;
   case ValID::t_None:
     if (!Ty->isTokenTy())

llvm/lib/IR/AsmWriter.cpp

@@ -1806,6 +1806,15 @@ static void writeConstantInternal(raw_ostream &Out, const Constant *CV,
       }
     }
 
+    // Use zeroinitializer for inttoptr(0) constant expression.
+    if (CE->getOpcode() == Instruction::IntToPtr) {
+      Constant *SrcCI = cast<Constant>(CE->getOperand(0));
+      if (SrcCI->isZeroValue()) {
+        Out << "zeroinitializer";
+        return;
+      }
+    }
+
     Out << CE->getOpcodeName();
     writeOptimizationInfo(Out, CE);
     Out << " (";

llvm/lib/IR/ConstantFold.cpp

@@ -126,6 +126,16 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, Constant *V,
   if (isa<PoisonValue>(V))
     return PoisonValue::get(DestTy);
 
+  // TODO: For the following two cases, we can fold the constant to a constant
+  // according to the data layout.
+
+  // We can't fold inttoptr(0) to ConstantNullPointer.
+  if (opc == Instruction::IntToPtr && V->isZeroValue())
+    return nullptr;
+  // We can't fold ptrtoint(nullptr) to null.
+  if (opc == Instruction::PtrToInt && V->isNullValue())
+    return nullptr;
+
   if (isa<UndefValue>(V)) {
     // zext(undef) = 0, because the top bits will be zero.
     // sext(undef) = 0, because the top bits will all be the same.

llvm/lib/IR/Constants.cpp

@@ -72,12 +72,21 @@ bool Constant::isNegativeZeroValue() const {
 }
 
 // Return true iff this constant is positive zero (floating point), negative
-// zero (floating point), or a null value.
+// zero (floating point), zero-value pointer, or a null value.
 bool Constant::isZeroValue() const {
   // Floating point values have an explicit -0.0 value.
   if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this))
     return CFP->isZero();
 
+  // Zero value pointer is a constant expression of inttoptr(0).
+  if (const auto *CE = dyn_cast<ConstantExpr>(this)) {
+    if (CE->getOpcode() == Instruction::IntToPtr) {
+      Constant *SrcCI = cast<Constant>(CE->getOperand(0));
+      if (SrcCI->isZeroValue())
+        return true;
+    }
+  }
+
   // Check for constant splat vectors of 1 values.
   if (getType()->isVectorTy())
     if (const auto *SplatCFP = dyn_cast_or_null<ConstantFP>(getSplatValue()))
@@ -369,7 +378,10 @@ bool Constant::containsConstantExpression() const {
   return false;
 }
 
-/// Constructor to create a '0' constant of arbitrary type.
+/// Constructor that creates a null constant of any type. For most types, this
+/// means a constant with value '0', but for pointer types, it represents a
+/// nullptr constant. A nullptr isn't always a zero-value pointer in certain
+/// address spaces on some targets.
 Constant *Constant::getNullValue(Type *Ty) {
   switch (Ty->getTypeID()) {
   case Type::IntegerTyID:
@@ -400,6 +412,19 @@ Constant *Constant::getNullValue(Type *Ty) {
   }
 }
 
+/// Constructor that creates a zero constant of any type. For most types, this
+/// is equivalent to getNullValue. For pointer types, it creates an inttoptr
+/// constant expression.
+Constant *Constant::getZeroValue(Type *Ty) {
+  switch (Ty->getTypeID()) {
+  case Type::PointerTyID:
+    return ConstantExpr::getIntToPtr(
+        ConstantInt::get(Type::getInt8Ty(Ty->getContext()), 0), Ty);
+  default:
+    return Constant::getNullValue(Ty);
+  }
+}
+
 Constant *Constant::getIntegerValue(Type *Ty, const APInt &V) {
   Type *ScalarTy = Ty->getScalarType();
 
@@ -735,7 +760,7 @@ static bool constantIsDead(const Constant *C, bool RemoveDeadUsers) {
     ReplaceableMetadataImpl::SalvageDebugInfo(*C);
     const_cast<Constant *>(C)->destroyConstant();
   }
-  
+
   return true;
 }
 

llvm/lib/IR/DataLayout.cpp

@@ -193,9 +193,11 @@ constexpr DataLayout::PrimitiveSpec DefaultVectorSpecs[] = {
 };
 
 // Default pointer type specifications.
-constexpr DataLayout::PointerSpec DefaultPointerSpecs[] = {
+const DataLayout::PointerSpec DefaultPointerSpecs[] = {
     // p0:64:64:64:64
-    {0, 64, Align::Constant<8>(), Align::Constant<8>(), 64, false, false},
+    {0, 64, Align::Constant<8>(), Align::Constant<8>(), /*IndexBitWidth=*/64,
+     /*NullPtrValue=*/APInt(64, 0), /*HasUnstableRepr=*/false,
+     /*HasExternalState=*/false},
 };
 
 DataLayout::DataLayout()
@@ -461,8 +463,9 @@ Error DataLayout::parsePointerSpec(StringRef Spec) {
     return createStringError(
         "index size cannot be larger than the pointer size");
 
+  // TODO: update the spec string parser to get the correct nullptr value.
   setPointerSpec(AddrSpace, BitWidth, ABIAlign, PrefAlign, IndexBitWidth,
-                 UnstableRepr, ExternalState);
+                 APInt(BitWidth, 0), UnstableRepr, ExternalState);
   return Error::success();
 }
 
@@ -638,6 +641,7 @@ Error DataLayout::parseLayoutString(StringRef LayoutString) {
     // the spec for AS0, and we then update that to mark it non-integral.
     const PointerSpec &PS = getPointerSpec(AS);
     setPointerSpec(AS, PS.BitWidth, PS.ABIAlign, PS.PrefAlign, PS.IndexBitWidth,
+                   PS.NullPtrValue,
                    /*HasUnstableRepr=*/true, /*HasExternalState=*/false);
   }
 
@@ -686,18 +690,20 @@ DataLayout::getPointerSpec(uint32_t AddrSpace) const {
 
 void DataLayout::setPointerSpec(uint32_t AddrSpace, uint32_t BitWidth,
                                 Align ABIAlign, Align PrefAlign,
-                                uint32_t IndexBitWidth, bool HasUnstableRepr,
-                                bool HasExternalState) {
+                                uint32_t IndexBitWidth,
+                                std::optional<APInt> NullPtrValue,
+                                bool HasUnstableRepr, bool HasExternalState) {
   auto I = lower_bound(PointerSpecs, AddrSpace, LessPointerAddrSpace());
   if (I == PointerSpecs.end() || I->AddrSpace != AddrSpace) {
     PointerSpecs.insert(I, PointerSpec{AddrSpace, BitWidth, ABIAlign, PrefAlign,
-                                       IndexBitWidth, HasUnstableRepr,
-                                       HasExternalState});
+                                       IndexBitWidth, NullPtrValue,
+                                       HasUnstableRepr, HasExternalState});
   } else {
     I->BitWidth = BitWidth;
     I->ABIAlign = ABIAlign;
     I->PrefAlign = PrefAlign;
     I->IndexBitWidth = IndexBitWidth;
+    I->NullPtrValue = NullPtrValue;
     I->HasUnstableRepresentation = HasUnstableRepr;
     I->HasExternalState = HasExternalState;
   }

llvm/test/CodeGen/AMDGPU/lower-buffer-fat-pointers-constants.ll

@@ -193,7 +193,7 @@ define i32 @ptrtoint_very_short() {
 define <2 x i160> @ptrtoint_vec() {
 ; CHECK-LABEL: define <2 x i160> @ptrtoint_vec
 ; CHECK-SAME: () #[[ATTR0]] {
-; CHECK-NEXT:    ret <2 x i160> zeroinitializer
+; CHECK-NEXT:    ret <2 x i160> ptrtoint (<2 x ptr addrspace(7)> zeroinitializer to <2 x i160>)
 ;
   ret <2 x i160> ptrtoint (<2 x ptr addrspace(7)> zeroinitializer to <2 x i160>)
 }

llvm/test/CodeGen/AMDGPU/remove-incompatible-s-time.ll

@@ -33,11 +33,11 @@
 ]
 
 ; REALTIME:    @ConstantExpr0 = internal global i64 ptrtoint (ptr @needs_s_memrealtime to i64)
-; NOREALTIME:  @ConstantExpr0 = internal global i64 0
+; NOREALTIME:  @ConstantExpr0 = internal global i64 ptrtoint (ptr null to i64)
 @ConstantExpr0 = internal global i64 ptrtoint (ptr @needs_s_memrealtime to i64)
 
 ; MEMTIME:     @ConstantExpr1 = internal global i64 ptrtoint (ptr @needs_s_memtime to i64)
-; NOMEMTIME:   @ConstantExpr1 = internal global i64 0
+; NOMEMTIME:   @ConstantExpr1 = internal global i64 ptrtoint (ptr null to i64)
 @ConstantExpr1 = internal global i64 ptrtoint (ptr @needs_s_memtime to i64)
 
 ; REALTIME:         define i64 @needs_s_memrealtime