[BitcodeReader] Allow reading pointer types from old IR

[sebastian-ne]

Summary

When opaque pointers are enabled and old IR with typed pointers is read,
the BitcodeReader automatically upgrades all typed pointers to opaque
pointers. This is a lossy conversion, i.e. when a function argument is a
pointer and unused, it’s impossible to reconstruct the original type
behind the pointer.

There are cases where the type information of pointers is needed. One is
reading DXIL, which is bitcode of old LLVM IR and makes a lot of use of
pointers in function signatures.
We’d like to keep using up-to-date llvm to read in and process DXIL, so
in the face of opaque pointers, we need some way to access the type
information of pointers from the read bitcode.

This patch allows extracting type information by supplying a function to
parseBitcodeFile that gets called for each function signature. This
function can access the type information via the reader’s type IDs and
the getTypeByID and getContainedTypeID functions.
The AccessBitcodeTypeInfo test exemplarily shows how type info from
pointers can be stored in metadata for use after the BitcodeReader
finished.

[nikic]

I think exposing something like this is reasonable. My high-level question would be whether function signatures are the only place where this is needed or whether we would benefit from a more generic mechanism -- for example, does a similar use-case for calls exist?

[beanz]

This approach seems reasonable to me, but I'm curious about a meta question here.

DXIL and SPIR-V (and I'm sure other targets as well), require some degree of support for typed pointers.

Might a more general annotation in the IR make sense, then the bitcode reader could annotate the module with type information which would persist after the module is created.

[aeubanks]

We have a guarantee that we can read older bitcode, but it seems weird to amend the bitcode reader to support a specific version of older LLVM IR.
What's the use case for wanting to read and preserve everything in the DXIL?

[sebastian-ne]

I think exposing something like this is reasonable.

That’s encouraging, thanks for the feedback.

My high-level question would be whether function signatures are the only place where this is needed or whether we would benefit from a more generic mechanism -- for example, does a similar use-case for calls exist?

Good point. As far as I know, dxil does not use indirect calls, so one can always do CallInst->getCalledFunction() and get types from the function signature.
I’ll try to get some opaque pointer support into our existing software to see if there’s more needed.

To allow extending the callback (potentially later), we could give the lambda a Value instead of a Function?

Might a more general annotation in the IR make sense, then the bitcode reader could annotate the module with type information which would persist after the module is created.

The elementtype(<ty>) attribute on function arguments sounded sounds quite fitting as a general annotation. It’s explicitly restricted to intrinsics though.
I think there’s more problems than preserving type information. As far as I understand, the SPIR-V backend wants to compile things like C code, which allows pointers and union casts, but I think SPIR-V and DXIL both don’t allow to re-interpret memory, so not sure how that’s handled at all.

[sebastian-ne]

I found one more place where type information from dxil needs to be extracted and that’s metadata.
The patch now adds a second callback, which allows changing metadata while it’s read in.
In the test, that’s used to replace a pointer value metadata with a tuple of the original value and metadata that stores its type information.
I wasn’t able to store type info about metadata without replacing it because the values get indistinguishable after being read (e.g. an i8* and an i32* both end up as a ptr).

The callback for function types now takes a Value, which should make it easy to extend for CallInstructions or others if that’s needed.

[sebastian-ne]

Rebased. Any concerns with the current patch?

[jsilvanus]

High-level comment regarding how to pass callbacks to parser functions: We have quite a few different parser routines, both for textual IR and bitcode, and special modes (e.g. lazy loaders).
This leads to many places where we would add essentially the same arguments, often with default values. Some functions miss these (e.g. getLazyBitcodeModule), because nobody bothered so far to add callback(s) for them.

Maybe we could instead add a ParserCallbackCollection that is passed to parser methods and contains the various callbacks available for parsing?

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

1215–1218

The assumptions here seem to be based on the existing calls from within the parser. If we expose getTypeByID and getContainedTypeID to callers, these might no longer hold.

Maybe use an additional argument that flags external callbacks, and just return nullptr in that case?

llvm/unittests/Bitcode/BitReaderTest.cpp

306

static

[sebastian-ne]

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

1215–1218

I’m not completely sure in which case this could break something, but I think the callback added in this patch is fine anyway.
It only gets called on values that are already created in the IR Module, so I assume their type is completely known at this point.

I guess a case where getTypeByID can’t return anything meaningful is for cycles is structs, i.e.

struct A { B*; }
struct B { A*; }

The callbacks added here don’t get called on (potentially incomplete) types and even if they would, I think the current behavior of getTypeByID is the most sensible thing to do.

[sebastian-ne]

Assemble callbacks in a struct, as suggested.

[jsilvanus]

Thanks for the refactoring. One more thought inline.

llvm/include/llvm/Bitcode/BitcodeReader.h

88

Now that the callback itself is optional, and the callback receives the data layout that would be used if not for the callback,
I'd like to point out that we *could* let the callback return a string instead of an optional string.

I'd find that slightly better, but I'm not sure it's worth the trouble.

[jsilvanus]

llvm/include/llvm/Bitcode/BitcodeReader.h

88

On second thought, returning an optional has the advantage of being explicit about whether the DL str was changed or not, making life easier for the parser. For example, the textual parser keeps track of the source location of the DL string for diagnostics, and discards that location if the callback replaces the DL string. That would be less convenient to do with strings returned.

[sebastian-ne]

I would have prefered a comment instead of a straight revert without giving me a chance to fix it.
Anyway, here’s a version that embeds bitcode instead of textual IR.

[sebastian-ne]

Formatting

[nikic]

LGTM, thanks

llvm/unittests/Bitcode/BitReaderTestCode.h

146 ↗

(On Diff #490085)

Add a newline before !1?

[nikic]

llvm/unittests/Bitcode/BitReaderTest.cpp

350

nit: These calls aren't necessary anymore.

llvm/include/llvm/Bitcode/BitcodeReader.h

 #include "llvm/Support/MemoryBufferRef.h"
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <system_error>
 #include <vector>
 namespace llvm {
 
+class Function;
 class LLVMContext;
 class Module;
 class MemoryBuffer;
 class ModuleSummaryIndex;
+class Type;
 
 typedef llvm::function_ref<Optional<std::string>(StringRef)>
     DataLayoutCallbackTy;
 
+typedef llvm::function_ref<Type *(unsigned)> GetTypeByIDTy;
+
+typedef llvm::function_ref<unsigned(unsigned, unsigned)> GetContainedTypeIDTy;
+
+typedef llvm::function_ref<void(Function *, unsigned, GetTypeByIDTy,
+                                GetContainedTypeIDTy)>
+    FunctionTypeCallbackTy;
+
   // These functions are for converting Expected/Error values to
   // ErrorOr/std::error_code for compatibility with legacy clients. FIXME:
   // Remove these functions once no longer needed by the C and libLTO APIs.
 
   std::error_code errorToErrorCodeAndEmitErrors(LLVMContext &Ctx, Error Err);
 
   template <typename T>
   ErrorOr<T> expectedToErrorOrAndEmitErrors(LLVMContext &Ctx, Expected<T> Val) {
class BitcodeModule {
     uint64_t IdentificationBit;
 
     // The bitstream location of this module's MODULE_BLOCK.
     uint64_t ModuleBit;
 
     BitcodeModule(ArrayRef<uint8_t> Buffer, StringRef ModuleIdentifier,
                   uint64_t IdentificationBit, uint64_t ModuleBit)
         : Buffer(Buffer), ModuleIdentifier(ModuleIdentifier),
           IdentificationBit(IdentificationBit), ModuleBit(ModuleBit) {}
 
     // Calls the ctor.
     friend Expected<BitcodeFileContents>
     getBitcodeFileContents(MemoryBufferRef Buffer);
 
     Expected<std::unique_ptr<Module>>
     getModuleImpl(LLVMContext &Context, bool MaterializeAll,
                   bool ShouldLazyLoadMetadata, bool IsImporting,
-                  DataLayoutCallbackTy DataLayoutCallback);
+                  DataLayoutCallbackTy DataLayoutCallback,
+                  FunctionTypeCallbackTy FunctionTypeCallback);
 
   public:
     StringRef getBuffer() const {
       return StringRef((const char *)Buffer.begin(), Buffer.size());
     }
 
     StringRef getStrtab() const { return Strtab; }
 
     StringRef getModuleIdentifier() const { return ModuleIdentifier; }
 
     /// Read the bitcode module and prepare for lazy deserialization of function
     /// bodies. If ShouldLazyLoadMetadata is true, lazily load metadata as well.
     /// If IsImporting is true, this module is being parsed for ThinLTO
     /// importing into another module.
     Expected<std::unique_ptr<Module>> getLazyModule(LLVMContext &Context,
                                                     bool ShouldLazyLoadMetadata,
                                                     bool IsImporting);
 
     /// Read the entire bitcode module and return it.
     Expected<std::unique_ptr<Module>> parseModule(
-        LLVMContext &Context, DataLayoutCallbackTy DataLayoutCallback =
-                                  [](StringRef) { return None; });
+        LLVMContext &Context,
+        DataLayoutCallbackTy DataLayoutCallback =
+            [](StringRef) { return None; },
+        FunctionTypeCallbackTy FunctionTypeCallback =
+            [](Function *, unsigned, GetTypeByIDTy, GetContainedTypeIDTy) {});
 
     /// Returns information about the module to be used for LTO: whether to
     /// compile with ThinLTO, and whether it has a summary.
     Expected<BitcodeLTOInfo> getLTOInfo();
 
     /// Parse the specified bitcode buffer, returning the module summary index.
     Expected<std::unique_ptr<ModuleSummaryIndex>> getSummary();
 
typedef llvm::function_ref<void(Function *, unsigned, GetTypeByIDTy,
   Expected<bool> isBitcodeContainingObjCCategory(MemoryBufferRef Buffer);
 
   /// Read the header of the specified bitcode buffer and extract just the
   /// producer string information. If successful, this returns a string. On
   /// error, this returns "".
   Expected<std::string> getBitcodeProducerString(MemoryBufferRef Buffer);
 
   /// Read the specified bitcode file, returning the module.
+  /// The FunctionTypeCallback is called for every function definition or
+  /// declaration and allows accessing the type information, also behind
+  /// pointers. This can be useful, when the opaque pointer upgrade cleans all
+  /// type information behind pointers.
+  /// The second argument to FunctionTypeCallback is the type ID of the
+  /// function, the two passed functions can be used to extract type
+  /// information.
   Expected<std::unique_ptr<Module>> parseBitcodeFile(
       MemoryBufferRef Buffer, LLVMContext &Context,
-      DataLayoutCallbackTy DataLayoutCallback = [](StringRef) {
-        return None;
-      });
+      DataLayoutCallbackTy DataLayoutCallback = [](StringRef) { return None; },
+      FunctionTypeCallbackTy FunctionTypeCallback =
+          [](Function *, unsigned, GetTypeByIDTy, GetContainedTypeIDTy) {});
 
   /// Returns LTO information for the specified bitcode file.
   Expected<BitcodeLTOInfo> getBitcodeLTOInfo(MemoryBufferRef Buffer);
 
   /// Parse the specified bitcode buffer, returning the module summary index.
   Expected<std::unique_ptr<ModuleSummaryIndex>>
   getModuleSummaryIndex(MemoryBufferRef Buffer);
 

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

class BitcodeReader : public BitcodeReaderBase, public GVMaterializer {
   bool WillMaterializeAllForwardRefs = false;
 
   bool StripDebugInfo = false;
   TBAAVerifier TBAAVerifyHelper;
 
   std::vector<std::string> BundleTags;
   SmallVector<SyncScope::ID, 8> SSIDs;
 
+  Optional<FunctionTypeCallbackTy> FunctionTypeCallback;
+
 public:
   BitcodeReader(BitstreamCursor Stream, StringRef Strtab,
                 StringRef ProducerIdentification, LLVMContext &Context);
 
   Error materializeForwardReferencedFunctions();
 
   Error materialize(GlobalValue *GV) override;
   Error materializeModule() override;
   std::vector<StructType *> getIdentifiedStructTypes() const override;
 
   /// Main interface to parsing a bitcode buffer.
   /// \returns true if an error occurred.
   Error parseBitcodeInto(
       Module *M, bool ShouldLazyLoadMetadata = false, bool IsImporting = false,
-      DataLayoutCallbackTy DataLayoutCallback = [](StringRef) { return None; });
+      DataLayoutCallbackTy DataLayoutCallback = [](StringRef) { return None; },
+      FunctionTypeCallbackTy FunctionTypeCallback =
+          [](Function *, unsigned, GetTypeByIDTy, GetContainedTypeIDTy) {});
 
   static uint64_t decodeSignRotatedValue(uint64_t V);
 
   /// Materialize any deferred Metadata block.
   Error materializeMetadata() override;
 
   void setStripDebugInfo() override;
 
 private:
   std::vector<StructType *> IdentifiedStructTypes;
   StructType *createIdentifiedStructType(LLVMContext &Context, StringRef Name);
   StructType *createIdentifiedStructType(LLVMContext &Context);
 
   static constexpr unsigned InvalidTypeID = ~0u;
 
   Type *getTypeByID(unsigned ID);
   Type *getPtrElementTypeByID(unsigned ID);
   unsigned getContainedTypeID(unsigned ID, unsigned Idx = 0);
   unsigned getVirtualTypeID(Type *Ty, ArrayRef<unsigned> ContainedTypeIDs = {});
 
+  void callFunctionTypeCallback(Function *F, unsigned TypeID);
   Value *getFnValueByID(unsigned ID, Type *Ty, unsigned TyID) {
     if (Ty && Ty->isMetadataTy())
       return MetadataAsValue::get(Ty->getContext(), getFnMetadataByID(ID));
     return ValueList.getValueFwdRef(ID, Ty, TyID);
   }
 
   Metadata *getFnMetadataByID(unsigned ID) {
     return MDLoader->getMetadataFwdRefOrLoad(ID);
private:
 
   /// Converts alignment exponent (i.e. power of two (or zero)) to the
   /// corresponding alignment to use. If alignment is too large, returns
   /// a corresponding error code.
   Error parseAlignmentValue(uint64_t Exponent, MaybeAlign &Alignment);
   Error parseAttrKind(uint64_t Code, Attribute::AttrKind *Kind);
   Error parseModule(
       uint64_t ResumeBit, bool ShouldLazyLoadMetadata = false,
-      DataLayoutCallbackTy DataLayoutCallback = [](StringRef) { return None; });
+      DataLayoutCallbackTy DataLayoutCallback = [](StringRef) { return None; },
+      FunctionTypeCallbackTy FunctionTypeCallback =
+          [](Function *, unsigned, GetTypeByIDTy, GetContainedTypeIDTy) {});
 
   Error parseComdatRecord(ArrayRef<uint64_t> Record);
   Error parseGlobalVarRecord(ArrayRef<uint64_t> Record);
   Error parseFunctionRecord(ArrayRef<uint64_t> Record);
   Error parseGlobalIndirectSymbolRecord(unsigned BitCode,
                                         ArrayRef<uint64_t> Record);
 
   Error parseAttributeBlock();

 Type *BitcodeReader::getTypeByID(unsigned ID) {
   // The type table size is always specified correctly.
   if (ID >= TypeList.size())
     return nullptr;
 
   if (Type *Ty = TypeList[ID])
     return Ty;
 
   // If we have a forward reference, the only possible case is when it is to a
   // named struct.  Just create a placeholder for now.
   return TypeList[ID] = createIdentifiedStructType(Context);
 }
 
 unsigned BitcodeReader::getContainedTypeID(unsigned ID, unsigned Idx) {
   auto It = ContainedTypeIDs.find(ID);
   if (It == ContainedTypeIDs.end())
     return InvalidTypeID;
 
   if (Idx >= It->second.size())
     return InvalidTypeID;
if (Record.size() > 16 && Record[16]) {
     llvm::GlobalValue::SanitizerMetadata Meta =
         deserializeSanitizerMetadata(Record[16]);
     NewGV->setSanitizerMetadata(Meta);
   }
 
   return Error::success();
 }
 
+void BitcodeReader::callFunctionTypeCallback(Function *F, unsigned TypeID) {
+  if (FunctionTypeCallback) {
+    (*FunctionTypeCallback)(
+        F, TypeID, [this](unsigned I) { return getTypeByID(I); },
+        [this](unsigned I, unsigned J) { return getContainedTypeID(I, J); });
+  }
+}
+
 Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t> Record) {
   // v1: [type, callingconv, isproto, linkage, paramattr, alignment, section,
   // visibility, gc, unnamed_addr, prologuedata, dllstorageclass, comdat,
   // prefixdata,  personalityfn, preemption specifier, addrspace] (name in VST)
   // v2: [strtab_offset, strtab_size, v1]
   StringRef Name;
   std::tie(Name, Record) = readNameFromStrtab(Record);
 
assert(Func->getFunctionType() == FTy &&
          "Incorrect fully specified type provided for function");
   FunctionTypeIDs[Func] = FTyID;
 
   Func->setCallingConv(CC);
   bool isProto = Record[2];
   uint64_t RawLinkage = Record[3];
   Func->setLinkage(getDecodedLinkage(RawLinkage));
   Func->setAttributes(getAttributes(Record[4]));
+  callFunctionTypeCallback(Func, FTyID);
 
   // Upgrade any old-style byval or sret without a type by propagating the
   // argument's pointee type. There should be no opaque pointers where the byval
   // type is implicit.
   for (unsigned i = 0; i != Func->arg_size(); ++i) {
     for (Attribute::AttrKind Kind : {Attribute::ByVal, Attribute::StructRet,
                                      Attribute::InAlloca}) {
       if (!Func->hasParamAttribute(i, Kind))
Error BitcodeReader::parseGlobalIndirectSymbolRecord(
 
   ValueList.push_back(NewGA, getVirtualTypeID(NewGA->getType(), TypeID));
   IndirectSymbolInits.push_back(std::make_pair(NewGA, Val));
   return Error::success();
 }
 
 Error BitcodeReader::parseModule(uint64_t ResumeBit,
                                  bool ShouldLazyLoadMetadata,
-                                 DataLayoutCallbackTy DataLayoutCallback) {
+                                 DataLayoutCallbackTy DataLayoutCallback,
+                                 FunctionTypeCallbackTy FunctionTypeCallback) {
+  this->FunctionTypeCallback = FunctionTypeCallback;
   if (ResumeBit) {
     if (Error JumpFailed = Stream.JumpToBit(ResumeBit))
       return JumpFailed;
   } else if (Error Err = Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
     return Err;
 
   SmallVector<uint64_t, 64> Record;
 
case bitc::MODULE_CODE_SOURCE_FILENAME:
       SmallString<128> ValueName;
       if (convertToString(Record, 0, ValueName))
         return error("Invalid record");
       TheModule->setSourceFileName(ValueName);
       break;
     }
     Record.clear();
   }
+  this->FunctionTypeCallback = None;
 }
 
-Error BitcodeReader::parseBitcodeInto(Module *M, bool ShouldLazyLoadMetadata,
-                                      bool IsImporting,
-                                      DataLayoutCallbackTy DataLayoutCallback) {
+Error BitcodeReader::parseBitcodeInto(
+    Module *M, bool ShouldLazyLoadMetadata, bool IsImporting,
+    DataLayoutCallbackTy DataLayoutCallback,
+    FunctionTypeCallbackTy FunctionTypeCallback) {
   TheModule = M;
   MDLoader = MetadataLoader(Stream, *M, ValueList, IsImporting,
                             [&](unsigned ID) { return getTypeByID(ID); });
-  return parseModule(0, ShouldLazyLoadMetadata, DataLayoutCallback);
+  return parseModule(0, ShouldLazyLoadMetadata, DataLayoutCallback,
+                     FunctionTypeCallback);
 }
 
 Error BitcodeReader::typeCheckLoadStoreInst(Type *ValType, Type *PtrType) {
   if (!isa<PointerType>(PtrType))
     return error("Load/Store operand is not a pointer type");
 
   if (!cast<PointerType>(PtrType)->isOpaqueOrPointeeTypeMatches(ValType))
     return error("Explicit load/store type does not match pointee "

 /// \a parseModule().  If this is truly lazy, then we need to eagerly pull
 /// in forward-referenced functions from block address references.
 ///
 /// \param[in] MaterializeAll Set to \c true if we should materialize
 /// everything.
 Expected<std::unique_ptr<Module>>
 BitcodeModule::getModuleImpl(LLVMContext &Context, bool MaterializeAll,
                              bool ShouldLazyLoadMetadata, bool IsImporting,
-                             DataLayoutCallbackTy DataLayoutCallback) {
+                             DataLayoutCallbackTy DataLayoutCallback,
+                             FunctionTypeCallbackTy FunctionTypeCallback) {
   BitstreamCursor Stream(Buffer);
 
   std::string ProducerIdentification;
   if (IdentificationBit != -1ull) {
     if (Error JumpFailed = Stream.JumpToBit(IdentificationBit))
       return std::move(JumpFailed);
     if (Error E =
             readIdentificationBlock(Stream).moveInto(ProducerIdentification))
       return std::move(E);
   }
 
   if (Error JumpFailed = Stream.JumpToBit(ModuleBit))
     return std::move(JumpFailed);
   auto *R = new BitcodeReader(std::move(Stream), Strtab, ProducerIdentification,
                               Context);
 
   std::unique_ptr<Module> M =
       std::make_unique<Module>(ModuleIdentifier, Context);
   M->setMaterializer(R);
 
   // Delay parsing Metadata if ShouldLazyLoadMetadata is true.
-  if (Error Err = R->parseBitcodeInto(M.get(), ShouldLazyLoadMetadata,
-                                      IsImporting, DataLayoutCallback))
+  if (Error Err =
+          R->parseBitcodeInto(M.get(), ShouldLazyLoadMetadata, IsImporting,
+                              DataLayoutCallback, FunctionTypeCallback))
     return std::move(Err);
 
   if (MaterializeAll) {
     // Read in the entire module, and destroy the BitcodeReader.
     if (Error Err = M->materializeAll())
       return std::move(Err);
   } else {
     // Resolve forward references from blockaddresses.
     if (Error Err = R->materializeForwardReferencedFunctions())
       return std::move(Err);
   }
   return std::move(M);
 }
 
 Expected<std::unique_ptr<Module>>
 BitcodeModule::getLazyModule(LLVMContext &Context, bool ShouldLazyLoadMetadata,
                              bool IsImporting) {
-  return getModuleImpl(Context, false, ShouldLazyLoadMetadata, IsImporting,
-                       [](StringRef) { return None; });
+  return getModuleImpl(
+      Context, false, ShouldLazyLoadMetadata, IsImporting,
+      [](StringRef) { return None; },
+      [](Function *, unsigned, GetTypeByIDTy, GetContainedTypeIDTy) {});
 }
 
 // Parse the specified bitcode buffer and merge the index into CombinedIndex.
 // We don't use ModuleIdentifier here because the client may need to control the
 // module path used in the combined summary (e.g. when reading summaries for
 // regular LTO modules).
 Error BitcodeModule::readSummary(ModuleSummaryIndex &CombinedIndex,
                                  StringRef ModulePath, uint64_t ModuleId) {
auto MOrErr = getLazyBitcodeModule(*Buffer, Context, ShouldLazyLoadMetadata,
                                      IsImporting);
   if (MOrErr)
     (*MOrErr)->setOwnedMemoryBuffer(std::move(Buffer));
   return MOrErr;
 }
 
 Expected<std::unique_ptr<Module>>
 BitcodeModule::parseModule(LLVMContext &Context,
-                           DataLayoutCallbackTy DataLayoutCallback) {
-  return getModuleImpl(Context, true, false, false, DataLayoutCallback);
+                           DataLayoutCallbackTy DataLayoutCallback,
+                           FunctionTypeCallbackTy FunctionTypeCallback) {
+  return getModuleImpl(Context, true, false, false, DataLayoutCallback,
+                       FunctionTypeCallback);
   // TODO: Restore the use-lists to the in-memory state when the bitcode was
   // written.  We must defer until the Module has been fully materialized.
 }
 
 Expected<std::unique_ptr<Module>>
 llvm::parseBitcodeFile(MemoryBufferRef Buffer, LLVMContext &Context,
-                       DataLayoutCallbackTy DataLayoutCallback) {
+                       DataLayoutCallbackTy DataLayoutCallback,
+                       FunctionTypeCallbackTy FunctionTypeCallback) {
   Expected<BitcodeModule> BM = getSingleModule(Buffer);
   if (!BM)
     return BM.takeError();
 
-  return BM->parseModule(Context, DataLayoutCallback);
+  return BM->parseModule(Context, DataLayoutCallback, FunctionTypeCallback);
 }
 
 Expected<std::string> llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer) {
   Expected<BitstreamCursor> StreamOrErr = initStream(Buffer);
   if (!StreamOrErr)
     return StreamOrErr.takeError();
 
   return readTriple(*StreamOrErr);

llvm/unittests/Bitcode/BitReaderTest.cpp

 //===- llvm/unittest/Bitcode/BitReaderTest.cpp - Tests for BitReader ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
TEST(BitReaderTest, MaterializeFunctionsForBlockAddrInFunctionAfter) {
 
   // Materialize @after, pulling in @func.
   EXPECT_FALSE(M->getFunction("after")->materialize());
   EXPECT_FALSE(M->getFunction("func")->empty());
   EXPECT_TRUE(M->getFunction("other")->empty());
   EXPECT_FALSE(verifyModule(*M, &dbgs()));
 }
 
+// Helper function to convert type metadata to a string for testing
+static std::string mdToString(Metadata *MD) {
+  std::string S;
+  if (auto *TMD = dyn_cast<MDTuple>(MD)) {
+    S += "!{";
+    for (unsigned I = 0; I < TMD->getNumOperands(); I++) {
+      if (I != 0)
+        S += ", ";
+      S += mdToString(TMD->getOperand(I).get());
+    }
+    S += "}";
+  } else if (auto *I = mdconst::dyn_extract<ConstantInt>(MD)) {
+    S += std::to_string(I->getZExtValue());
+  } else if (auto *P = mdconst::dyn_extract<PoisonValue>(MD)) {
+    auto *Ty = P->getType();
+    assert(Ty->isIntegerTy());
+    S += "i";
+    S += std::to_string(Ty->getIntegerBitWidth());
+  } else {
+    llvm_unreachable("unhandled metadata");
+  }
+  return S;
+}
+
+// Test that when reading bitcode with typed pointers and upgrading them to
+// opaque pointers, the type information of function signatures can be extracted
+// and stored e.g. in metadata.
+TEST(BitReaderTest, AccessBitcodeTypeInfo) {
+  SmallString<1024> Mem;
+  LLVMContext WriteContext;
+  writeModuleToBuffer(
+      parseAssembly(
+          WriteContext,
+          "define void @func() {\n"
+          "  unreachable\n"
+          "}\n"
+          "declare i32 @func_header()\n"
+          "declare i8* @ret_ptr()\n"
+          "declare i8* @ret_and_arg_ptr(i32 addrspace(8)*)\n"
+          "declare i8 addrspace(1)* @double_ptr(i32* addrspace(2)*, i32***)\n"),
+      Mem);
+
+  LLVMContext Context;
+  Context.setOpaquePointers(true);
+
+  Expected<std::unique_ptr<Module>> ModuleOrErr = parseBitcodeFile(
+      MemoryBufferRef(Mem.str(), "test"), Context,
+      [](StringRef) { return None; },
+      // Supply a lambda that stores the signature of a function into metadata,
+      // so that the types behind pointers can be accessed.
+      // Each function gets a !types metadata, which is a tuple with one element
+      // for a non-void return type and every argument. For primitive types it's
+      // a poison value of the type, for a pointer it's a metadata tuple with
+      // the addrspace and the referenced type.
+      [&](Function *F, unsigned TypeID, GetTypeByIDTy GetTypeByID,
+          GetContainedTypeIDTy GetContainedTypeID) {
+        // Recursively look into a (pointer) type and the the type
+        std::function<Metadata *(unsigned)> GetTypeMetadataEntry;
+        GetTypeMetadataEntry = [&](unsigned TypeID) -> Metadata * {
+          Type *Ty = GetTypeByID(TypeID);
+          if (!Ty->isPointerTy())
+            return ConstantAsMetadata::get(PoisonValue::get(Ty));
+
+          // Return !{<addrspace>, <inner>} for pointer
+          SmallVector<Metadata *, 2> MD;
+          MD.push_back(ConstantAsMetadata::get(ConstantInt::get(
+              Type::getInt32Ty(Context), Ty->getPointerAddressSpace())));
+          MD.push_back(GetTypeMetadataEntry(GetContainedTypeID(TypeID, 0)));
+          return MDTuple::get(Context, MD);
+        };
+
+        // Save the function signature as metadata
+        SmallVector<Metadata *> SignatureMD;
+        // Return type
+        if (!F->getFunctionType()->getReturnType()->isVoidTy())
+          SignatureMD.push_back(
+              GetTypeMetadataEntry(GetContainedTypeID(TypeID, 0)));
+        // Arguments
+        for (unsigned I = 0; I != F->arg_size(); ++I)
+          SignatureMD.push_back(
+              GetTypeMetadataEntry(GetContainedTypeID(TypeID, I + 1)));
+
+        MDNode *MD = MDTuple::get(Context, SignatureMD);
+        F->setMetadata("types", MD);
+      });
+
+  if (!ModuleOrErr)
+    report_fatal_error("Could not parse bitcode module");
+  std::unique_ptr<Module> M = std::move(ModuleOrErr.get());
+
+  EXPECT_EQ(mdToString(M->getFunction("func")->getMetadata("types")), "!{}");
+  EXPECT_EQ(mdToString(M->getFunction("func_header")->getMetadata("types")),
+            "!{i32}");
+  EXPECT_EQ(mdToString(M->getFunction("ret_ptr")->getMetadata("types")),
+            "!{!{0, i8}}");
+  EXPECT_EQ(mdToString(M->getFunction("ret_and_arg_ptr")->getMetadata("types")),
+            "!{!{0, i8}, !{8, i32}}");
+  EXPECT_EQ(mdToString(M->getFunction("double_ptr")->getMetadata("types")),
+            "!{!{1, i8}, !{2, !{0, i32}}, !{0, !{0, !{0, i32}}}}");
+}
+
 } // end namespace