[llvm-c] add LLVMReplaceMDNodeOperandWith

[davibe]

Summary

Hello!

I'm working on a tool that visits debug info and massages it using the llvm-c API. I noticed that LLVMGetOperand special cases MDNodes so I can get their operands, but I can't replace them. This patch adds LLVMReplaceMDNodeOperandWith which boils down to MDNode::replaceOperandWith.

The name was chosen for consistency with LLVMGetMDNodeOperands and LLVMGetMDNodeNumOperands.

[aprantl]

I can see that this is useful. Can you add a unit test for it?

[lattner]

Seems fine to me, but I don't work on the C API so I can't advise on it.

[davibe]

I added the tests as requested.

I also added LLVMIsAValueAsMetadata, since LLVMIsAMDNode is a bit of a lier and returns true for ValueAsMetadata values as well, so the way to know if something is truly a mdnode is to call LLVMIsAMDNode(v) && !LLVMIsAValueAsMetadata(v)

[davibe]

• Fixed formatting
• Added .ll files to trigger tests

[aprantl]

llvm/test/Bindings/llvm-c/replace_md_operand.ll

2

This seems to be an incredibly complicated way to invoke the function, but it's consistent with the existing tests...

[davibe]

This comment was removed by davibe.

llvm/test/Bindings/llvm-c/replace_md_operand.ll

2

Agree. I may propose another "pr"

[davibe]

I don't have commit access, could someone please commit this for me?

[aprantl]

Done. Please watch the bots ad let me know if I need to revert the patch!

llvm/include/llvm-c/Core.h

  *
  * @see llvm::dyn_cast_or_null<>
  */
 #define LLVM_DECLARE_VALUE_CAST(name) \
   LLVMValueRef LLVMIsA##name(LLVMValueRef Val);
 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DECLARE_VALUE_CAST)
 
 LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val);
+LLVMValueRef LLVMIsAValueAsMetadata(LLVMValueRef Val);
 LLVMValueRef LLVMIsAMDString(LLVMValueRef Val);
 
 /** Deprecated: Use LLVMGetValueName2 instead. */
 const char *LLVMGetValueName(LLVMValueRef Val);
 /** Deprecated: Use LLVMSetValueName2 instead. */
 void LLVMSetValueName(LLVMValueRef Val, const char *Name);
 
 /**

  * LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the
  * MDNode's operands.
  *
  * @param V MDNode to get the operands from.
  * @param Dest Destination array for operands.
  */
 void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest);
 
+/**
+ * Replace an operand at a specific index in a llvm::MDNode value.
+ *
+ * @see llvm::MDNode::replaceOperandWith()
+ */
+void LLVMReplaceMDNodeOperandWith(LLVMValueRef V, unsigned Index,
+                                  LLVMMetadataRef Replacement);
+
 /** Deprecated: Use LLVMMDStringInContext2 instead. */
 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
                                    unsigned SLen);
 /** Deprecated: Use LLVMMDStringInContext2 instead. */
 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen);
 /** Deprecated: Use LLVMMDNodeInContext2 instead. */
 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
                                  unsigned Count);

llvm/lib/IR/Core.cpp

 LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val) {
   if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
     if (isa<MDNode>(MD->getMetadata()) ||
         isa<ValueAsMetadata>(MD->getMetadata()))
       return Val;
   return nullptr;
 }
 
+LLVMValueRef LLVMIsAValueAsMetadata(LLVMValueRef Val) {
+  if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
+    if (isa<ValueAsMetadata>(MD->getMetadata()))
+      return Val;
+  return nullptr;
+}
+
 LLVMValueRef LLVMIsAMDString(LLVMValueRef Val) {
   if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
     if (isa<MDString>(MD->getMetadata()))
       return Val;
   return nullptr;
 }
 
 /*--.. Operations on Uses ..................................................--*/
void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest) {
   }
   const auto *N = cast<MDNode>(MD->getMetadata());
   const unsigned numOperands = N->getNumOperands();
   LLVMContext &Context = unwrap(V)->getContext();
   for (unsigned i = 0; i < numOperands; i++)
     Dest[i] = getMDNodeOperandImpl(Context, N, i);
 }
 
+void LLVMReplaceMDNodeOperandWith(LLVMValueRef V, unsigned Index,
+                                  LLVMMetadataRef Replacement) {
+  auto *MD = cast<MetadataAsValue>(unwrap(V));
+  auto *N = cast<MDNode>(MD->getMetadata());
+  N->replaceOperandWith(Index, unwrap<Metadata>(Replacement));
+}
+
 unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char *Name) {
   if (NamedMDNode *N = unwrap(M)->getNamedMetadata(Name)) {
     return N->getNumOperands();
   }
   return 0;
 }
 
 void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char *Name,

llvm/test/Bindings/llvm-c/is_a_value_as_metadata.ll

+; RUN: llvm-c-test --is-a-value-as-metadata < /dev/null
+; This used to trigger an assertion

llvm/test/Bindings/llvm-c/replace_md_operand.ll

+; RUN: llvm-c-test --replace-md-operand < /dev/null
+; This used to trigger an assertion

llvm/tools/llvm-c-test/llvm-c-test.h

 int llvm_disassemble(void);
 
 // debuginfo.c
 int llvm_test_dibuilder(void);
 
 // metadata.c
 int llvm_add_named_metadata_operand(void);
 int llvm_set_metadata(void);
+int llvm_replace_md_operand(void);
+int llvm_is_a_value_as_metadata(void);
 
 // object.c
 int llvm_object_list_sections(void);
 int llvm_object_list_symbols(void);
 
 // targets.c
 int llvm_targets_list(void);
 

llvm/tools/llvm-c-test/main.c

static void print_usage(void) {
   fprintf(stderr, "    Read object file from stdin - list sections\n\n");
   fprintf(stderr, "  * --object-list-symbols\n");
   fprintf(stderr,
           "    Read object file from stdin - list symbols (like nm)\n\n");
   fprintf(stderr, "  * --disassemble\n");
   fprintf(stderr, "    Read lines of triple, hex ascii machine code from stdin "
                   "- print disassembly\n\n");
   fprintf(stderr, "  * --calc\n");
+  fprintf(stderr, "  * --replace-md-operand\n");
+  fprintf(stderr, "    Run test for replacing MDNode operands\n");
+  fprintf(stderr, "  * --is-a-value-as-metadata\n");
+  fprintf(stderr,
+          "    Run test for checking if LLVMValueRef is a ValueAsMetadata\n");
   fprintf(
       stderr,
       "    Read lines of name, rpn from stdin - print generated module\n\n");
   fprintf(stderr, "  * --echo\n");
   fprintf(stderr, "    Read bitcode file from stdin - print it back out\n\n");
   fprintf(stderr, "  * --echo --opaque-pointers\n");
   fprintf(stderr, "    Read bitcode file from stdin - print it back out in "
                   "opaque pointer mode\n\n");
int main(int argc, char **argv) {
   } else if (argc == 2 && !strcmp(argv[1], "--disassemble")) {
     return llvm_disassemble();
   } else if (argc == 2 && !strcmp(argv[1], "--calc")) {
     return llvm_calc();
   } else if (argc == 2 && !strcmp(argv[1], "--add-named-metadata-operand")) {
     return llvm_add_named_metadata_operand();
   } else if (argc == 2 && !strcmp(argv[1], "--set-metadata")) {
     return llvm_set_metadata();
+  } else if (argc == 2 && !strcmp(argv[1], "--replace-md-operand")) {
+    return llvm_replace_md_operand();
+  } else if (argc == 2 && !strcmp(argv[1], "--is-a-value-as-metadata")) {
+    return llvm_is_a_value_as_metadata();
   } else if (argc == 2 && !strcmp(argv[1], "--test-function-attributes")) {
     return llvm_test_function_attributes();
   } else if (argc == 2 && !strcmp(argv[1], "--test-callsite-attributes")) {
     return llvm_test_callsite_attributes();
   } else if (argc == 2 && !strcmp(argv[1], "--echo")) {
     return llvm_echo();
   } else if (argc == 2 && !strcmp(argv[1], "--test-diagnostic-handler")) {
     return llvm_test_diagnostic_handler();
   } else if (argc == 2 && !strcmp(argv[1], "--test-dibuilder")) {
     return llvm_test_dibuilder();
   } else {
     print_usage();
   }
 
   return 1;
 }

llvm/tools/llvm-c-test/metadata.c

 /*===-- object.c - tool for testing libLLVM and llvm-c API ----------------===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* This file implements the --add-named-metadata-operand and --set-metadata   *|
 |* commands in llvm-c-test.                                                   *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include "llvm-c-test.h"
 
+#include <assert.h>
+#include <string.h>
+
 int llvm_add_named_metadata_operand(void) {
   LLVMModuleRef m = LLVMModuleCreateWithName("Mod");
   LLVMValueRef values[] = { LLVMConstInt(LLVMInt32Type(), 0, 0) };
 
   // This used to trigger an assertion
   LLVMAddNamedMetadataOperand(m, "name", LLVMMDNode(values, 1));
 
   LLVMDisposeModule(m);
int llvm_set_metadata(void) {
   LLVMValueRef ret = LLVMBuildRetVoid(b);
   LLVMSetMetadata(ret, LLVMGetMDKindID("kind", 4), LLVMMDNode(values, 1));
 
   LLVMDisposeBuilder(b);
   LLVMDeleteInstruction(ret);
 
   return 0;
 }
+
+int llvm_replace_md_operand(void) {
+  LLVMModuleRef m = LLVMModuleCreateWithName("Mod");
+  LLVMContextRef context = LLVMGetModuleContext(m);
+  unsigned int tmp = 0;
+
+  LLVMMetadataRef metas[] = {LLVMMDStringInContext2(context, "foo", 3)};
+  LLVMValueRef md =
+      LLVMMetadataAsValue(context, LLVMMDNodeInContext2(context, metas, 1));
+
+  LLVMReplaceMDNodeOperandWith(md, 0,
+                               LLVMMDStringInContext2(context, "bar", 3));
+
+  assert(!strncmp(LLVMGetMDString(LLVMGetOperand(md, 0), &tmp), "bar", 0));
+
+  LLVMDisposeModule(m);
+
+  return 0;
+}
+
+int llvm_is_a_value_as_metadata(void) {
+  LLVMModuleRef m = LLVMModuleCreateWithName("Mod");
+  LLVMContextRef context = LLVMGetModuleContext(m);
+
+  LLVMValueRef values[] = {LLVMConstInt(LLVMInt32Type(), 0, 0)};
+  LLVMValueRef md = LLVMMDNode(values, 1);
+  assert(LLVMIsAValueAsMetadata(md) == md);
+
+  LLVMMetadataRef metas[] = {LLVMMDStringInContext2(context, "foo", 3)};
+  LLVMValueRef md2 =
+      LLVMMetadataAsValue(context, LLVMMDNodeInContext2(context, metas, 1));
+  assert(LLVMIsAValueAsMetadata(md2) == NULL);
+
+  return 0;
+}