[Bitcode][Asm] Parse metadata value from operand bundles

[necipfazil]

Summary

Support parsing operand bundles with metadata value from LLVM IR.

[necipfazil]

This is needed for D105909 since it attaches type identifiers to call sites as operand bundles with metadata value. Now we can successfully compile LLVM IR with metadata operand bundles to object file while preserving the bundle value.

On the other hand, we cannot read metadata value in and out, i.e., operand bundle value is garbage when LLVM IR is compiled to bitcode, then disassembled back to LLVM IR. One of the tests [1] is a small reproducer.

[1] llvm/test/Bitcode/2021-07-22-Metadata-Operand-Bundles.ll

[necipfazil]

Abandoning this revision since it is split to two:

1. D107038: Fix parser to read metadata operand bundle values in.
2. D107039: Add tests to reproduce the bug in reading metadata operand bundle values out, and additional tests to test the fix to the issue.

This split allows the metadata-operand-bundle-value producer/consumer revisions (D105909 and D105915) to progress with the fix revision 1 above, without waiting for a fix to revision-2.

llvm/lib/AsmParser/LLParser.cpp

while (Lex.getKind() != lltok::rsquare) {
     std::vector<Value *> Inputs;
     while (Lex.getKind() != lltok::rparen) {
       // If this isn't the first input, we need a comma.
       if (!Inputs.empty() &&
           parseToken(lltok::comma, "expected ',' in input list"))
         return true;
 
       Type *Ty = nullptr;
+      if (parseType(Ty))
+        return false;
+
       Value *Input = nullptr;
-      if (parseType(Ty) || parseValue(Ty, Input, PFS))
+      if (Ty->isMetadataTy()) {
+        if (parseMetadataAsValue(Input, PFS))
           return true;
+      } else {
+        if (parseValue(Ty, Input, PFS))
+          return true;
+      }
       Inputs.push_back(Input);
     }
 
     BundleList.emplace_back(std::move(Tag), std::move(Inputs));
 
     Lex.Lex(); // Lex the ')'.
   }
 

llvm/test/Bitcode/2021-07-22-Metadata-Operand-Bundles.ll

+; This test ensures that we get a metadata operand bundle value in and out.
+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+declare void @callee()
+
+; CHECK-LABEL: call_with_operand_bundle(
+define void @call_with_operand_bundle() {
+  ; CHECK: call void @op_bundle_callee() [ "op_type"(metadata !"metadata_string") ]
+  call void @callee() [ "op_type"(metadata !"metadata_string") ]
+
+  ret void
+}

llvm/test/Bitcode/compatibility.ll

  entry:
   %l = load i32, i32* %ptr
   %x = add i32 42, 1
   call void @op_bundle_callee_1(i32 10, i32 %x) [ "foo"(i32 42, i64 100, i32 %x), "foo"(i32 42, float  0.000000e+00, i32 %l) ]
 ; CHECK: call void @op_bundle_callee_1(i32 10, i32 %x) [ "foo"(i32 42, i64 100, i32 %x), "foo"(i32 42, float  0.000000e+00, i32 %l) ]
   ret void
 }
 
+define void @call_with_operand_bundle5(i32* %ptr) {
+; CHECK-LABEL: call_with_operand_bundle5(
+ entry:
+  call void @op_bundle_callee_0() [ "foo"(metadata !"metadata_string") ]
+; CHECK: call void @op_bundle_callee_0() [ "foo"(metadata !"metadata_string") ]
+  ret void
+}
+
 ; Invoke versions of the above tests:
 
 
 define void @invoke_with_operand_bundle0(i32* %ptr) personality i8 3 {
 ; CHECK-LABEL: @invoke_with_operand_bundle0(
  entry:
   %l = load i32, i32* %ptr
   %x = add i32 42, 1

 
 exception:
   %cleanup = landingpad i8 cleanup
   br label %normal
 normal:
   ret void
 }
 
+define void @invoke_with_operand_bundle5(i32* %ptr) personality i8 3 {
+; CHECK-LABEL: @invoke_with_operand_bundle5(
+ entry:
+  invoke void @op_bundle_callee_0() [ "foo"(metadata !"metadata_string") ] to label %normal unwind label %exception
+; CHECK: invoke void @op_bundle_callee_0() [ "foo"(metadata !"metadata_string") ]
+
+exception:
+  %cleanup = landingpad i8 cleanup
+  br label %normal
+normal:
+  ret void
+}
+
 declare void @vaargs_func(...)
 define void @invoke_with_operand_bundle_vaarg(i32* %ptr) personality i8 3 {
 ; CHECK-LABEL: @invoke_with_operand_bundle_vaarg(
  entry:
   %l = load i32, i32* %ptr
   %x = add i32 42, 1
   invoke void (...) @vaargs_func(i32 10, i32 %x) [ "foo"(i32 42, i64 100, i32 %x), "foo"(i32 42, float  0.000000e+00, i32 %l) ]
         to label %normal unwind label %exception

llvm/test/Bitcode/operand-bundles.ll

  entry:
   %l = load i32, i32* %ptr
   %x = add i32 42, 1
   call void @callee1(i32 10, i32 %x) [ "foo"(i32 42, i64 100, i32 %x), "foo"(i32 42, float  0.000000e+00, i32 %l) ]
 ; CHECK: call void @callee1(i32 10, i32 %x) [ "foo"(i32 42, i64 100, i32 %x), "foo"(i32 42, float  0.000000e+00, i32 %l) ]
   ret void
 }
 
+define void @f5(i32* %ptr) {
+; CHECK-LABEL: @f5(
+ entry:
+  call void @callee0() [ "foo"(metadata !"metadata_string") ]
+; CHECK: call void @callee0() [ "foo"(metadata !"metadata_string") ]
+  ret void
+}
+
 ; Invoke versions of the above tests:
 
 
 define void @g0(i32* %ptr) personality i8 3 {
 ; CHECK-LABEL: @g0(
  entry:
   %l = load i32, i32* %ptr
   %x = add i32 42, 1

 ; CHECK: invoke void @callee1(i32 10, i32 %x) [ "foo"(i32 42, i64 100, i32 %x), "foo"(i32 42, float  0.000000e+00, i32 %l) ]
 
 exception:
   %cleanup = landingpad i8 cleanup
   br label %normal
 normal:
   ret void
 }
+
+define void @g5(i32* %ptr) personality i8 3 {
+; CHECK-LABEL: @g5(
+ entry:
+  invoke void @callee0() [ "foo"(metadata !"metadata_string") ] to label %normal unwind label %exception
+; CHECK: invoke void @callee0() [ "foo"(metadata !"metadata_string") ]
+
+exception:
+  %cleanup = landingpad i8 cleanup
+  br label %normal
+normal:
+  ret void
+}