[UnknownProvenance] Introduce UnknownProvenance constant

[jeroen.dobbelaere]

Summary

The UnknownProvenance indicates that the provenance can be any object. This must only be used in the ptr_provenance path of a pointer.

[jeroen.dobbelaere]

• Small cleanup of useless comment
• NOTE: The LangeRef change explaining the purpose of unknown_provenance is done in D104268

[deadalnix]

llvm/include/llvm-c/Core.h

1963

Where is the implementation for these?

llvm/include/llvm/IR/Constants.h

579

Isn't inline implied by the fact this is defined directly within the class?

[jeroen.dobbelaere]

Thanks for the feedback !

llvm/include/llvm-c/Core.h

1963

Ah.. The implementation is in D111162, but I had to move the header earlier for the enum. Probably better to just add the implementation in this revision..

llvm/include/llvm/IR/Constants.h

579

Yes it is. That's what I get for copy-pasting from ConstantPointerNull..

[deadalnix]

llvm/include/llvm-c/Core.h

1963

I'm not sure what the policy is here, but I would think that we should avoid adding stuff in the header when using them will only lead to a linker error.

But in this case, it seems that you have all the pieces to add this, at least the llvm/lib/IR/Core.cpp part.

llvm/include/llvm/IR/Constants.h

579

I think it'd be better to just remove it, as to not spread erroneous patterns (inline is notoriously misunderstood by many C/C++ devs). But either way, this is certainly not worth blocking that patch for this.

[jeroen.dobbelaere]

Incorporated D111162

[jeroen.dobbelaere]

I added a llvm-c echo test in D111751, together with the ptr_provenance support.

[jeroen.dobbelaere]

Rebase to 49cb4fef02e635bf304906232214166c7531d753

[deadalnix]

Do you need help merging this?

[jeroen.dobbelaere]

In D111159#3498808, @deadalnix wrote:

Do you need help merging this?

I would like to have all patches reviewed and accepted before I start merging them into the main tree.

[jeroen.dobbelaere]

Rebased to ffe262a198a9f9030991df6d3ddd812e74fa3523

[jeroen.dobbelaere]

Rebased to ef545ef62a833152d8975ff16333b57cc41befcc (Jan 9, 2023)

[jeroen.dobbelaere]

Rebased to: 8c7cfa357280dd93d33b10bbba0fe33797e27d63 (Feb 14, 2023)

llvm/include/llvm-c/Core.h

typedef enum {
   LLVMConstantTokenNoneValueKind,
 
   LLVMMetadataAsValueValueKind,
   LLVMInlineAsmValueKind,
 
   LLVMInstructionValueKind,
   LLVMPoisonValueValueKind,
   LLVMConstantTargetNoneValueKind,
+  LLVMUnknownProvenanceValueKind
 } LLVMValueKind;
 
 typedef enum {
   LLVMIntEQ = 32, /**< equal */
   LLVMIntNE,      /**< not equal */
   LLVMIntUGT,     /**< unsigned greater than */
   LLVMIntUGE,     /**< unsigned greater or equal */
   LLVMIntULT,     /**< unsigned less than */

 
 /**
  * Obtain a constant that is a constant pointer pointing to NULL for a
  * specified type.
  */
 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
 
 /**
+ * Determine whether a value instance is unknown_provenance.
+ *
+ * @see llvm::UnknownProvenance
+ */
+LLVMBool LLVMIsUnknownProvenance(LLVMValueRef Val);
+
+/**
+ * Obtain a constant that is an constant pointer pointing to unknown_provenance
+ * for a specified type.
+ */
+LLVMValueRef LLVMGetUnknownProvenance(LLVMTypeRef Ty);
+
+/**
  * @defgroup LLVMCCoreValueConstantScalar Scalar constants
  *
  * Functions in this group model LLVMValueRef instances that correspond
  * to constants referring to scalar types.
  *
  * For integer types, the LLVMTypeRef parameter should correspond to a
  * llvm::IntegerType instance and the returned LLVMValueRef will
  * correspond to a llvm::ConstantInt.

llvm/include/llvm/IR/Constant.h

public:
   /// 'this' is deleted.  In general, you should not call this method, instead,
   /// use Value::replaceAllUsesWith, which automatically dispatches to this
   /// method as needed.
   ///
   void handleOperandChange(Value *, Value *);
 
   static Constant *getNullValue(Type* Ty);
 
+  static Constant *getUnknownProvenance(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
   static Constant *getAllOnesValue(Type* Ty);
 
   /// Return the value for an integer or pointer constant, or a vector thereof,
   /// with the given scalar value.
   static Constant *getIntegerValue(Type *Ty, const APInt &V);

llvm/include/llvm/IR/Constants.h

public:
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
     return V->getValueID() == ConstantPointerNullVal;
   }
 };
 
 //===----------------------------------------------------------------------===//
+/// A provenance pointer value indicating that the provenance can be anything.
+///
+class UnknownProvenance final : public ConstantData {
+  friend class Constant;
+
+  explicit UnknownProvenance(PointerType *T)
+      : ConstantData(T, Value::UnknownProvenanceVal) {}
+
+  void destroyConstantImpl();
+
+public:
+  UnknownProvenance(const UnknownProvenance &) = delete;
+
+  /// Static factory methods - Return objects of the specified value
+  static UnknownProvenance *get(PointerType *T);
+
+  /// Specialize the getType() method to always return an PointerType,
+  /// which reduces the amount of casting needed in parts of the compiler.
+  PointerType *getType() const { return cast<PointerType>(Value::getType()); }
+
+  /// Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const Value *V) {
+    return V->getValueID() == UnknownProvenanceVal;
+  }
+};
+
+//===----------------------------------------------------------------------===//
 /// ConstantDataSequential - A vector or array constant whose element type is a
 /// simple 1/2/4/8-byte integer or half/bfloat/float/double, and whose elements
 /// are just simple data values (i.e. ConstantInt/ConstantFP).  This Constant
 /// node has no operands because it stores all of the elements of the constant
 /// as densely packed data, instead of as Value*'s.
 ///
 /// This is the common base class of ConstantDataArray and ConstantDataVector.
 ///

llvm/include/llvm/IR/Value.def

 
 // ConstantAggregate.
 HANDLE_CONSTANT(ConstantArray)
 HANDLE_CONSTANT(ConstantStruct)
 HANDLE_CONSTANT(ConstantVector)
 
 // ConstantData.
 HANDLE_CONSTANT(UndefValue)
+HANDLE_CONSTANT(UnknownProvenance)
 HANDLE_CONSTANT(PoisonValue)
 HANDLE_CONSTANT(ConstantAggregateZero)
 HANDLE_CONSTANT(ConstantDataArray)
 HANDLE_CONSTANT(ConstantDataVector)
 HANDLE_CONSTANT(ConstantInt)
 HANDLE_CONSTANT(ConstantFP)
 HANDLE_CONSTANT(ConstantTargetNone)
 HANDLE_CONSTANT(ConstantPointerNull)

llvm/lib/IR/Constants.cpp

Constant *Constant::getNullValue(Type *Ty) {
   case Type::TargetExtTyID:
     return ConstantTargetNone::get(cast<TargetExtType>(Ty));
   default:
     // Function, Label, or Opaque type?
     llvm_unreachable("Cannot create a null constant of that type!");
   }
 }
 
+// Constructor to create a 'unknown_provenance' constant.
+Constant *Constant::getUnknownProvenance(Type *Ty) {
+  assert(Ty->isPointerTy() && "unknown_provenance must always be a pointer");
+  return UnknownProvenance::get(cast<PointerType>(Ty));
+}
+
 Constant *Constant::getIntegerValue(Type *Ty, const APInt &V) {
   Type *ScalarTy = Ty->getScalarType();
 
   // Create the base integer constant.
   Constant *C = ConstantInt::get(Ty->getContext(), V);
 
   // Convert an integer to a pointer, if necessary.
   if (PointerType *PTy = dyn_cast<PointerType>(ScalarTy))
ConstantTargetNone *ConstantTargetNone::get(TargetExtType *Ty) {
   return Entry.get();
 }
 
 /// Remove the constant from the constant table.
 void ConstantTargetNone::destroyConstantImpl() {
   getContext().pImpl->CTNConstants.erase(getType());
 }
 
+UnknownProvenance *UnknownProvenance::get(PointerType *Ty) {
+  std::unique_ptr<UnknownProvenance> &Entry =
+      Ty->getContext().pImpl->UPConstants[Ty];
+  if (!Entry)
+    Entry.reset(new UnknownProvenance(Ty));
+
+  return Entry.get();
+}
+
+/// Remove the constant from the constant table.
+void UnknownProvenance::destroyConstantImpl() {
+  getContext().pImpl->UPConstants.erase(getType());
+}
+
 UndefValue *UndefValue::get(Type *Ty) {
   std::unique_ptr<UndefValue> &Entry = Ty->getContext().pImpl->UVConstants[Ty];
   if (!Entry)
     Entry.reset(new UndefValue(Ty));
 
   return Entry.get();
 }
 

llvm/lib/IR/Core.cpp

 LLVMBool LLVMIsPoison(LLVMValueRef Val) {
   return isa<PoisonValue>(unwrap(Val));
 }
 
 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) {
   return wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty)));
 }
 
+LLVMBool LLVMIsUnknownProvenance(LLVMValueRef Val) {
+  return isa<UnknownProvenance>(unwrap(Val));
+}
+
+LLVMValueRef LLVMGetUnknownProvenance(LLVMTypeRef Ty) {
+  return wrap(UnknownProvenance::get(unwrap<PointerType>(Ty)));
+}
+
 /*--.. Operations on metadata nodes ........................................--*/
 
 LLVMMetadataRef LLVMMDStringInContext2(LLVMContextRef C, const char *Str,
                                        size_t SLen) {
   return wrap(MDString::get(*unwrap(C), StringRef(Str, SLen)));
 }
 
 LLVMMetadataRef LLVMMDNodeInContext2(LLVMContextRef C, LLVMMetadataRef *MDs,

llvm/lib/IR/LLVMContextImpl.h

#include "llvm/IR/Metadata.def"
 
   using VectorConstantsTy = ConstantUniqueMap<ConstantVector>;
   VectorConstantsTy VectorConstants;
 
   DenseMap<PointerType *, std::unique_ptr<ConstantPointerNull>> CPNConstants;
 
   DenseMap<TargetExtType *, std::unique_ptr<ConstantTargetNone>> CTNConstants;
 
+  DenseMap<PointerType *, std::unique_ptr<UnknownProvenance>> UPConstants;
+
   DenseMap<Type *, std::unique_ptr<UndefValue>> UVConstants;
 
   DenseMap<Type *, std::unique_ptr<PoisonValue>> PVConstants;
 
   StringMap<std::unique_ptr<ConstantDataSequential>> CDSConstants;
 
   DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
       BlockAddresses;

llvm/lib/IR/LLVMContextImpl.cpp

#include "llvm/IR/Metadata.def"
   ArrayConstants.freeConstants();
   StructConstants.freeConstants();
   VectorConstants.freeConstants();
   InlineAsms.freeConstants();
 
   CAZConstants.clear();
   CPNConstants.clear();
   CTNConstants.clear();
+  UPConstants.clear();
   UVConstants.clear();
   PVConstants.clear();
   IntConstants.clear();
   FPConstants.clear();
   CDSConstants.clear();
 
   // Destroy attribute node lists.
   for (FoldingSetIterator<AttributeSetNode> I = AttrsSetNodes.begin(),

llvm/tools/llvm-c-test/echo.cpp

static LLVMValueRef clone_constant_impl(LLVMValueRef Cst, LLVMModuleRef M) {
   }
 
   // Try undef
   if (LLVMIsUndef(Cst)) {
     check_value_kind(Cst, LLVMUndefValueValueKind);
     return LLVMGetUndef(TypeCloner(M).Clone(Cst));
   }
 
+  // Try unknown_provenance
+  if (LLVMIsUnknownProvenance(Cst)) {
+    check_value_kind(Cst, LLVMUnknownProvenanceValueKind);
+    return LLVMGetUnknownProvenance(TypeCloner(M).Clone(Cst));
+  }
+
   // Try poison
   if (LLVMIsPoison(Cst)) {
     check_value_kind(Cst, LLVMPoisonValueValueKind);
     return LLVMGetPoison(TypeCloner(M).Clone(Cst));
   }
 
   // Try null
   if (LLVMIsNull(Cst)) {