[WIP][IR] Add RangeMetadata on top of ExtMetadata

[nhaehnle]

Summary

This is an extremely rough draft of a potential change to replace !range
metadata by something implemented on top of ExtMetadata.

That is, replace

!range !{ i32 5, i32 20 }

by something like

!range !llvm.range{ ranges: [{ lo: i32 5, hi: i32 20 }] }

Structured data doesn't actually have arrays at the time of writing, so
the draft is limited to a single lo/hi pair. The main point is to show
a concrete example and explore how the ExtMetadata infrastructure is used.

llvm/include/llvm/IR/ExtMetadata.h

public:
   static std::unique_ptr<ExtMetadataDeserializer>
   makeDeserializer(LLVMContext &Ctx, StringRef ClassName, bool IsDistinct);
 
   StringRef getClassName() const { return ClassName; };
 
   SmallVector<std::pair<StringRef, sdata::Value>> serialize() const;
 };
 
+/// !llvm.range metadata
+///
+/// Represents a half-open range [lo, hi). Wrapping is allowed.
+class RangeMetadata : public ExtMetadata {
+  APInt Lo;
+  APInt Hi;
+
+public:
+  RangeMetadata(LLVMContext &Ctx, const APInt &Lo, const APInt &Hi);
+
+  static RangeMetadata *get(LLVMContext &Ctx, const APInt &Lo, const APInt &Hi);
+
+  static bool classof(const ExtMetadata *M) {
+    return M->getClassId() == getClass().getId();
+  }
+  static bool classof(const Metadata *MD) {
+    if (const auto *ExtMD = dyn_cast<ExtMetadata>(MD))
+      return classof(ExtMD);
+    return false;
+  }
+
+  const APInt &getLo() const { return Lo; }
+  const APInt &getHi() const { return Hi; }
+
+  static const ExtMetadataClass &getClass();
+
+private:
+  class Deserializer;
+
+  static RangeMetadata *getImpl(LLVMContext &Ctx, const APInt &Lo,
+                                const APInt &Hi);
+
+  static SmallVector<std::pair<StringRef, sdata::Value>>
+  serialize(const ExtMetadata *M, bool UseSchema);
+  static bool verifier(const ExtMetadata *M, llvm::raw_ostream &Errs);
+};
+
 } // namespace llvm
 
 #endif // LLVM_IR_EXTMETADATA_H

llvm/lib/IR/ConstantRange.cpp

 //  [T, T) = {F, T} = Full set
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/ExtMetadata.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"

 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void ConstantRange::dump() const {
   print(dbgs());
 }
 #endif
 
 ConstantRange llvm::getConstantRangeFromMetadata(const MDNode &Ranges) {
+  if (auto *RMD = dyn_cast<RangeMetadata>(&Ranges)) {
+    return {RMD->getLo(), RMD->getHi()};
+  }
+
   const unsigned NumRanges = Ranges.getNumOperands() / 2;
   assert(NumRanges >= 1 && "Must have at least one range!");
   assert(Ranges.getNumOperands() % 2 == 0 && "Must be a sequence of pairs");
 
   auto *FirstLow = mdconst::extract<ConstantInt>(Ranges.getOperand(0));
   auto *FirstHigh = mdconst::extract<ConstantInt>(Ranges.getOperand(1));
 
   ConstantRange CR(FirstLow->getValue(), FirstHigh->getValue());

llvm/lib/IR/ExtMetadata.cpp

 
 SmallVector<std::pair<StringRef, sdata::Value>>
 GenericExtMetadata::serialize() const {
   SmallVector<std::pair<StringRef, sdata::Value>> F;
   for (const auto &[K, V] : Fields)
     F.emplace_back(K, V);
   return F;
 }
+
+RangeMetadata::RangeMetadata(LLVMContext &Ctx, const APInt &Lo, const APInt &Hi)
+    : ExtMetadata(Ctx, getClass().getId(), Metadata::Uniqued), Lo(Lo), Hi(Hi) {
+  assert(Lo.getBitWidth() == Hi.getBitWidth());
+}
+
+RangeMetadata *RangeMetadata::getImpl(LLVMContext &Ctx, const APInt &Lo,
+                                      const APInt &Hi) {
+  return new (0, Uniqued) RangeMetadata(Ctx, Lo, Hi);
+}
+
+RangeMetadata *RangeMetadata::get(LLVMContext &Ctx, const APInt &Lo,
+                                  const APInt &Hi) {
+  RangeMetadata *MD = getImpl(Ctx, Lo, Hi);
+  assert(verifier(MD, llvm::dbgs()));
+  return MD;
+}
+
+class RangeMetadata::Deserializer : public ExtMetadataDeserializer {
+  LLVMContext &Ctx;
+  bool IsDistinct;
+  APInt Lo;
+  APInt Hi;
+
+public:
+  Deserializer(LLVMContext &Ctx, bool IsDistinct)
+      : Ctx(Ctx), IsDistinct(IsDistinct) {}
+
+  Error parseField(StringRef K, sdata::Value V) override {
+    if (K == "lo") {
+      if (!V.isAPInt())
+        return sdata::makeDeserializeError("'lo' must be an integer");
+      Lo = V.getAPInt();
+      return Error::success();
+    }
+
+    if (K == "hi") {
+      if (!V.isAPInt())
+        return sdata::makeDeserializeError("'hi' must be an integer");
+      Hi = V.getAPInt();
+      return Error::success();
+    }
+
+    return sdata::makeDeserializeError("expected 'lo' or 'hi'");
+  }
+
+  Expected<ExtMetadata *> finish() override {
+    if (IsDistinct)
+      return sdata::makeDeserializeError(
+          "!llvm.range metadata cannot be distinct");
+    if (!Lo.getBitWidth())
+      return sdata::makeDeserializeError("missing 'lo'");
+    if (!Hi.getBitWidth())
+      return sdata::makeDeserializeError("missing 'hi'");
+
+    auto *MD = RangeMetadata::getImpl(Ctx, Lo, Hi);
+
+    std::string Err;
+    raw_string_ostream ErrStream(Err);
+    if (!verifier(MD, ErrStream))
+      return sdata::makeDeserializeError(Err);
+
+    return MD;
+  }
+};
+
+const ExtMetadataClass &RangeMetadata::getClass() {
+  static const auto Class{[]() {
+    ExtMetadataClass C(
+        "llvm.range",
+        [](LLVMContext &Ctx, bool IsDistinct) {
+          return std::unique_ptr<ExtMetadataDeserializer>(
+              new Deserializer(Ctx, IsDistinct));
+        },
+        &RangeMetadata::serialize);
+    C.setVerifier(&RangeMetadata::verifier);
+    return C;
+  }()};
+  return Class;
+}
+
+SmallVector<std::pair<StringRef, sdata::Value>>
+RangeMetadata::serialize(const ExtMetadata *M, bool UseSchema) {
+  auto *R = cast<RangeMetadata>(M);
+  SmallVector<std::pair<StringRef, sdata::Value>> Fields;
+  Fields.emplace_back("lo", R->getLo());
+  Fields.emplace_back("hi", R->getHi());
+  return Fields;
+}
+
+bool RangeMetadata::verifier(const ExtMetadata *M, llvm::raw_ostream &Errs) {
+  auto *R = cast<RangeMetadata>(M);
+  if (R->getLo().getBitWidth() != R->getHi().getBitWidth()) {
+    Errs << "range metadata bitwidth mismatch: " << R->getLo().getBitWidth()
+         << " (lo) vs. " << R->getHi().getBitWidth() << " (hi)\n";
+    return false;
+  }
+  return true;
+}

llvm/lib/IR/LLVMContext.cpp

static const auto Aarch64SVCount =
           .setVerifier([](TargetExtType *T, raw_ostream &Errs) -> bool {
             if (T->getNumTypeParameters() || T->getNumIntParameters()) {
               Errs << "aarch64.svcount cannot have parameters\n";
               return false;
             }
             return true;
           });
   registerTargetExtTypeClass(&Aarch64SVCount);
+
+  registerExtMetadataClass(&RangeMetadata::getClass());
 }
 
 LLVMContext::~LLVMContext() { delete pImpl; }
 
 void LLVMContext::addModule(Module *M) {
   pImpl->OwnedModules.insert(M);
 }
 

llvm/lib/IR/MDBuilder.cpp

 //===---- llvm/MDBuilder.cpp - Builder for LLVM metadata ------------------===//
 //
 // 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 defines the MDBuilder class, which is used as a convenient way to
 // create LLVM metadata with a consistent and simplified interface.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/ExtMetadata.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Metadata.h"
 using namespace llvm;
 
 MDString *MDBuilder::createString(StringRef Str) {
   return MDString::get(Context, Str);
 }
 

 MDNode *MDBuilder::createFunctionSectionPrefix(StringRef Prefix) {
   return MDNode::get(Context,
                      {createString("function_section_prefix"),
                       createString(Prefix)});
 }
 
 MDNode *MDBuilder::createRange(const APInt &Lo, const APInt &Hi) {
   assert(Lo.getBitWidth() == Hi.getBitWidth() && "Mismatched bitwidths!");
-
-  Type *Ty = IntegerType::get(Context, Lo.getBitWidth());
-  return createRange(ConstantInt::get(Ty, Lo), ConstantInt::get(Ty, Hi));
+  return RangeMetadata::get(Context, Lo, Hi);
 }
 
 MDNode *MDBuilder::createRange(Constant *Lo, Constant *Hi) {
   // If the range is everything then it is useless.
   if (Hi == Lo)
     return nullptr;
 
   // Return the range [Lo, Hi).
-  return MDNode::get(Context, {createConstant(Lo), createConstant(Hi)});
+  return createRange(cast<ConstantInt>(Lo)->getValue(),
+                     cast<ConstantInt>(Hi)->getValue());
 }
 
 MDNode *MDBuilder::createCallees(ArrayRef<Function *> Callees) {
   SmallVector<Metadata *, 4> Ops;
   for (Function *F : Callees)
     Ops.push_back(createConstant(F));
   return MDNode::get(Context, Ops);
 }