Allow type-mismatching RAUW of values in metadata, and add C API.

[maleadt]

Summary

When replacing a value that's referred to by module metadata, one needs to use RAUW to update that metadata. RAUW however doesn't work when the type of the value changes, e.g., when replacing a function with one that takes an additional argument. This kind of IR happens with e.g. the nvvm.annotations metadata, which contains a reference to a LLVM::Function value. It seems to make sense to relax the type equality assertion when only replacing values in metadata (see also: https://discourse.llvm.org/t/replacing-module-metadata-uses-of-function/62431). This change does exactly that, while additionally exposing that functionality to C.

[sebastian-ne]

Since there have been no other reactions and I think this is a reasonable patch, I’ll accept it.
Please wait a day before submitting it in case others have comments.

[nikic]

I don't think this change makes sense on a couple of levels:

• I don't believe that ValueAsMetadata::handleRAUW() is intended as a public API at all.
• The original problem seems like a bug in GlobalDCE -- did anyone investigate why it happens?
• With opaque pointers the replacement doesn't use a bitcast anyway, so the issue is "fixed" as a side-effect. As this API will only go into LLVM 15, it would not be useful.

[maleadt]

In D125388#3595595, @nikic wrote:

• With opaque pointers the replacement doesn't use a bitcast anyway, so the issue is "fixed" as a side-effect. As this API will only go into LLVM 15, it would not be useful.

Ah yes, plain RAUW without bitcast just works fine on LLVM 15 with opaque pointers.

llvm/include/llvm-c/Core.h

 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
 /** Deprecated: Use LLVMMDNodeInContext2 instead. */
 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
                                  unsigned Count);
 /** Deprecated: Use LLVMMDNodeInContext2 instead. */
 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count);
 
 /**
+ * Replace all metadata uses of a value with another one.
+ *
+ * @see llvm::Value::replaceAllUsesWith()
+ */
+void LLVMReplaceAllMetadataUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
+
+/**
  * @}
  */
 
 /**
  * @defgroup LLVMCCoreValueBasicBlock Basic Block
  *
  * A basic block represents a single entry single exit section of code.
  * Basic blocks contain a list of instructions which form the body of

llvm/lib/IR/Core.cpp

char* LLVMPrintValueToString(LLVMValueRef Val) {
 
   return strdup(buf.c_str());
 }
 
 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal) {
   unwrap(OldVal)->replaceAllUsesWith(unwrap(NewVal));
 }
 
+void LLVMReplaceAllMetadataUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal) {
+  ValueAsMetadata::handleRAUW(unwrap<Value>(OldVal), unwrap<Value>(NewVal));
+}
+
 int LLVMHasMetadata(LLVMValueRef Inst) {
   return unwrap<Instruction>(Inst)->hasMetadata();
 }
 
 LLVMValueRef LLVMGetMetadata(LLVMValueRef Inst, unsigned KindID) {
   auto *I = unwrap<Instruction>(Inst);
   assert(I && "Expected instruction");
   if (auto *MD = I->getMetadata(KindID))

llvm/lib/IR/Metadata.cpp

void ValueAsMetadata::handleDeletion(Value *V) {
   MD->replaceAllUsesWith(nullptr);
   delete MD;
 }
 
 void ValueAsMetadata::handleRAUW(Value *From, Value *To) {
   assert(From && "Expected valid value");
   assert(To && "Expected valid value");
   assert(From != To && "Expected changed value");
-  assert(From->getType() == To->getType() && "Unexpected type change");
 
   LLVMContext &Context = From->getType()->getContext();
   auto &Store = Context.pImpl->ValuesAsMetadata;
   auto I = Store.find(From);
   if (I == Store.end()) {
     assert(!From->IsUsedByMD && "Expected From not to be used by metadata");
     return;
   }