TargetExtType: Use a schema-based abbreviation in bitcode

[nhaehnle]

Summary

The encoding of the structured data used in target types is quite
verbose, and most of its contents are redundant as they encode the
symbols that act as keys of the structured data fields (e.g., "layout")
as well as the self-description of the value types.

By defining an abbreviation that contains all this information as
literals, the overhead is amortized over multiple target types.

The main challenge of this change is the fact that the Array encoding
can only appear once in an abbreviation, at the end, but target types
need two arrays. Define a new ExtArray encoding that avoids this
limitation. Since the encoding space for the encoding itself is rather
tight (3 bits), this extended array encoding allows tuples inside of
arrays as a precautionary extension. This feature is not used at this
time, but it seems rather likely that it will become useful in the
future.

[Flakebi]

llvm/lib/Bitstream/Reader/BitstreamReader.cpp

380–385

The code in BitstreamCursor::skipRecord and in BitstreamCursor::readRecord is almost identical. Maybe it makes sense to move that into a function that takes an optional Vals vector?

[nhaehnle]

llvm/lib/Bitstream/Reader/BitstreamReader.cpp

380–385

Yeah, I was wondering the same thing. I suspect that the initial theory was that skipRecord can be faster. It's unclear how valid that theory is with modern branch predictors. And if it genuinely is an issue, we could still have a single implementation that we force to be specialized by writing it as a template. In any case, I'd rather do that in a separate change.

[nhaehnle]

Rebase, mostly changes related to APInt bitwidth being preserved.

[Flakebi]

Looks good to me

[nhaehnle]

Drop symbols-as-values for now

[nhaehnle]

Move SchemaField into this patch

[nhaehnle]

Rebase

llvm/docs/BitCodeFormat.rst

 * Blob (code 5): This field is emitted as a vbr6, followed by padding to a
   32-bit boundary (for alignment) and an array of 8-bit objects.  The array of
   bytes is further followed by tail padding to ensure that its total length is a
   multiple of 4 bytes.  This makes it very efficient for the reader to decode
   the data without having to make a copy of it: it can use a pointer to the data
   in the mapped in file and poke directly at it.  A blob may only occur as the
   last operand of an abbreviation.
 
+* Extended Array (code 6): This field is an array of tuples. The operand's extra
+  data specifies is the number of tuple fields minus 1. The operand is followed
+  by operands describing each field of the tuple. Extended arrays can appear
+  anywhere in an abbreviation.
+
+  Nested extended arrays are currently not supported, but are a possible
+  extension.
+
+  When reading an extended array in an abbreviated record, the first integer is
+  a vbr6 that indicates the array length, followed by the encoded elements of
+  the array. Each element is a tightly packed encoding of the tuple fields.
+
 For example, target triples in LLVM modules are encoded as a record of the form
 ``[TRIPLE, 'a', 'b', 'c', 'd']``.  Consider if the bitstream emitted the
 following abbrev entry:
 
 ::
 
   [0, Fixed, 4]
   [0, Array]

llvm/include/llvm/Bitstream/BitCodes.h

 ///   2. It could be an encoding specification ("this operand encoded like so").
 ///
 class BitCodeAbbrevOp {
   uint64_t Val;           // A literal value or data for an encoding.
   bool IsLiteral : 1;     // Indicate whether this is a literal value or not.
   unsigned Enc   : 3;     // The encoding to use.
 public:
   enum Encoding {
-    Fixed = 1,  // A fixed width field, Val specifies number of bits.
-    VBR   = 2,  // A VBR field where Val specifies the width of each chunk.
-    Array = 3,  // A sequence of fields, next field species elt encoding.
-    Char6 = 4,  // A 6-bit fixed field which maps to [a-zA-Z0-9._].
-    Blob  = 5   // 32-bit aligned array of 8-bit characters.
+    Fixed = 1,    // A fixed width field, Val specifies number of bits.
+    VBR = 2,      // A VBR field where Val specifies the width of each chunk.
+    Array = 3,    // A sequence of fields, next field species elt encoding.
+    Char6 = 4,    // A 6-bit fixed field which maps to [a-zA-Z0-9._].
+    Blob = 5,     // 32-bit aligned array of 8-bit characters.
+    ExtArray = 6, // A VBR6-encoded element count followed by Val+1 fields
+                  // describing the element encoding
   };
 
-  static bool isValidEncoding(uint64_t E) {
-    return E >= 1 && E <= 5;
-  }
+  static bool isValidEncoding(uint64_t E) { return E >= 1 && E <= 6; }
 
   explicit BitCodeAbbrevOp(uint64_t V) :  Val(V), IsLiteral(true) {}
   explicit BitCodeAbbrevOp(Encoding E, uint64_t Data = 0)
     : Val(Data), IsLiteral(false), Enc(E) {}
 
   bool isLiteral() const  { return IsLiteral; }
   bool isEncoding() const { return !IsLiteral; }
 
   // Accessors for literals.
   uint64_t getLiteralValue() const { assert(isLiteral()); return Val; }
 
   // Accessors for encoding info.
   Encoding getEncoding() const { assert(isEncoding()); return (Encoding)Enc; }
   uint64_t getEncodingData() const {
     assert(isEncoding() && hasEncodingData());
     return Val;
   }
 
   bool hasEncodingData() const { return hasEncodingData(getEncoding()); }
   static bool hasEncodingData(Encoding E) {
     switch (E) {
     case Fixed:
     case VBR:
+    case ExtArray:
       return true;
     case Array:
     case Char6:
     case Blob:
       return false;
     }
     report_fatal_error("Invalid encoding");
   }

llvm/include/llvm/Bitstream/BitstreamWriter.h

for (; i != e; ++i) {
         } else {
           // Emit a vbr6 to indicate the number of elements present.
           EmitVBR(static_cast<uint32_t>(Vals.size()-RecordIdx), 6);
 
           // Emit each field.
           for (unsigned e = Vals.size(); RecordIdx != e; ++RecordIdx)
             EmitAbbreviatedField(EltEnc, Vals[RecordIdx]);
         }
+      } else if (Op.getEncoding() == BitCodeAbbrevOp::ExtArray) {
+        // Extended array case.
+        unsigned NumFields = Op.getEncodingData() + 1;
+        assert(i + NumFields < e && "missing array field specifiers");
+
+        unsigned NumElements = Vals[RecordIdx++];
+        EmitVBR(NumElements, 6);
+
+        for (; NumElements; --NumElements) {
+          for (unsigned field = 0; field != NumFields; ++field, ++RecordIdx) {
+            assert(RecordIdx < Vals.size());
+            const BitCodeAbbrevOp &Enc = Abbv->getOperandInfo(i + field + 1);
+            EmitAbbreviatedField(Enc, Vals[RecordIdx]);
+          }
+        }
+
+        i += NumFields;
       } else if (Op.getEncoding() == BitCodeAbbrevOp::Blob) {
         // If this record has blob data, emit it, otherwise we must have record
         // entries to encode this way.
 
         if (BlobData) {
           assert(RecordIdx == Vals.size() &&
                  "Blob data and record entries specified for blob operand!");
 
           assert(Blob.data() == BlobData && "BlobData got moved");
           assert(Blob.size() == BlobLen && "BlobLen got changed");
           emitBlob(Blob);
           BlobData = nullptr;
         } else {
           emitBlob(Vals.slice(RecordIdx));
         }
-      } else {  // Single scalar field.
+      } else { // Single scalar field.
         assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
         EmitAbbreviatedField(Op, Vals[RecordIdx]);
         ++RecordIdx;
       }
     }
     assert(RecordIdx == Vals.size() && "Not all record operands emitted!");
     assert(BlobData == nullptr &&
            "Blob data specified for record that doesn't use it!");

llvm/include/llvm/IR/StructuredData.h

bool getBool() const {
     return std::get<APInt>(S).getZExtValue();
   }
   Type *getType() const {
     assert(isType());
     return std::get<Type *>(S);
   }
 };
 
+/// Describes the "schema" of a field of structured data.
+///
+/// This is used to describe structures for bitcode abbreviation.
+class SchemaField {
+public:
+  enum class Type {
+    /// Fixed-width APInt (possibly a boolean). TypeData is the number of bits.
+    Int,
+
+    /// LLVM type
+    Type,
+  };
+
+private:
+  StringRef TheKey;
+  Type TheType;
+  unsigned TypeData;
+
+public:
+  SchemaField(StringRef K, Type T, unsigned TD = 0)
+      : TheKey(K), TheType(T), TypeData(TD) {
+    assert((T != Type::Int || TD != 0) &&
+           "integer schema types must have a bit width");
+  }
+
+  StringRef getKey() const { return TheKey; }
+  Type getType() const { return TheType; }
+  unsigned getTypeBitWidth() const {
+    assert(TheType == Type::Int);
+    return TypeData;
+  }
+};
+
 // Convenience function to create an Error object when an error is encountered
 // while deserializing structured data.
 Error makeDeserializeError(const Twine &Msg);
 
 } // end namespace sdata
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/IR/TargetExtType.h

public:
   TargetTypeInfoDeserialize(LLVMContext &Ctx, StringRef Name,
                             ArrayRef<Type *> Types, ArrayRef<unsigned> Ints);
 
   Error parseField(StringRef K, sdata::Value V);
 
   Expected<TargetExtType *> finish();
 };
 
+/// Return the schema for target type info.
+ArrayRef<sdata::SchemaField> getTargetTypeInfoSchema();
+
 /// Serialize the target type info into structured data.
 ///
-/// If UseSchema is true, fields are generated according to a fixed schema.
+/// If UseSchema is true, fields are generated according to the schema returned
+/// by @ref getTargetTypeInfoSchema.
 SmallVector<std::pair<StringRef, sdata::Value>>
 serializeTargetTypeInfo(TargetExtType *Ty, bool UseSchema);
 
 } // namespace llvm
 
 #endif // LLVM_IR_TARGETEXTTYPE_H

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

for (const auto &GUIDSummaryLists : *Index)
           for (auto &CallEdge : FS->calls())
             if (!CallEdge.first.haveGVs() || !CallEdge.first.getValue())
               assignValueId(CallEdge.first.getGUID());
   }
 
 protected:
   void writePerModuleGlobalValueSummary();
 
+  void encodeSchemaAbbrev(BitCodeAbbrev &Abbrev,
+                          ArrayRef<sdata::SchemaField> Fields);
   void
   encodeStructuredData(SmallVectorImpl<uint64_t> &Vals,
                        ArrayRef<std::pair<StringRef, sdata::Value>> Fields);
 
 private:
   void writePerModuleFunctionSummaryRecord(
       SmallVector<uint64_t, 64> &NameVals, GlobalValueSummary *Summary,
       unsigned ValueID, unsigned FSCallsAbbrev, unsigned FSCallsProfileAbbrev,
void ModuleBitcodeWriter::writeTypeTable() {
 
   // Abbrev for TYPE_CODE_ARRAY.
   Abbv = std::make_shared<BitCodeAbbrev>();
   Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_ARRAY));
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));   // size
   Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
   unsigned ArrayAbbrev = Stream.EmitAbbrev(std::move(Abbv));
 
+  // Abbrev for TYPE_CODE_TARGET_TYPE -- only emitted when used.
+  unsigned TargetAbbrev = 0;
+
   // Emit an entry count so the reader can reserve space.
   TypeVals.push_back(TypeList.size());
   Stream.EmitRecord(bitc::TYPE_CODE_NUMENTRY, TypeVals);
   TypeVals.clear();
 
   // Loop over all of the types, emitting each in turn.
   for (Type *T : TypeList) {
     int AbbrevToUse = 0;
case Type::TargetExtTyID: {
                         StructNameAbbrev);
       TypeVals.push_back(TET->getNumTypeParameters());
       for (Type *InnerTy : TET->type_params())
         TypeVals.push_back(VE.getTypeID(InnerTy));
       TypeVals.push_back(TET->getNumIntParameters());
       for (unsigned IntParam : TET->int_params())
         TypeVals.push_back(IntParam);
 
-      auto Fields = serializeTargetTypeInfo(TET, /*UseSchema=*/false);
+      auto Fields = serializeTargetTypeInfo(TET, /*UseSchema=*/true);
       encodeStructuredData(TypeVals, Fields);
+
+      if (!TargetAbbrev) {
+        Abbv = std::make_shared<BitCodeAbbrev>();
+        Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_TARGET_TYPE));
+        Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::ExtArray, 0)); // types
+        Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
+        Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::ExtArray, 0)); // ints
+        Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
+        encodeSchemaAbbrev(*Abbv, getTargetTypeInfoSchema());
+        TargetAbbrev = Stream.EmitAbbrev(std::move(Abbv));
+      }
+      AbbrevToUse = TargetAbbrev;
       break;
     }
     case Type::TypedPointerTyID:
       llvm_unreachable("Typed pointers cannot be added to IR modules");
     }
 
     // Emit the finished record.
     Stream.EmitRecord(Code, TypeVals, AbbrevToUse);
if (!PerModule) {
         Record.push_back(V);
     }
     Stream.EmitRecord(PerModule ? bitc::FS_PERMODULE_ALLOC_INFO
                                 : bitc::FS_COMBINED_ALLOC_INFO,
                       Record, AllocAbbrev);
   }
 }
 
+void ModuleBitcodeWriterBase::encodeSchemaAbbrev(
+    BitCodeAbbrev &Abbrev, ArrayRef<sdata::SchemaField> Fields) {
+  Abbrev.Add(BitCodeAbbrevOp(Fields.size()));
+  for (const auto &Field : Fields) {
+    Abbrev.Add(BitCodeAbbrevOp(StrtabBuilder.add(Field.getKey())));
+    Abbrev.Add(BitCodeAbbrevOp(Field.getKey().size()));
+
+    if (Field.getType() == sdata::SchemaField::Type::Int) {
+      unsigned NumBits = Field.getTypeBitWidth();
+      Abbrev.Add(BitCodeAbbrevOp(bitc::SDATA_INT_BASE + NumBits));
+      while (NumBits > 64) {
+        Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 64));
+        NumBits -= 64;
+      }
+      Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
+    } else if (Field.getType() == sdata::SchemaField::Type::Type) {
+      Abbrev.Add(BitCodeAbbrevOp(bitc::SDATA_TYPE));
+      Abbrev.Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
+                                 VE.computeBitsRequiredForTypeIndicies()));
+    } else {
+      llvm_unreachable("unimplemented schema field type");
+    }
+  }
+}
+
 void ModuleBitcodeWriterBase::encodeStructuredData(
     SmallVectorImpl<uint64_t> &Vals,
     ArrayRef<std::pair<StringRef, sdata::Value>> Fields) {
   Vals.push_back(Fields.size());
   for (const auto &[Key, Value] : Fields) {
     Vals.push_back(StrtabBuilder.add(Key));
     Vals.push_back(Key.size());
 

llvm/lib/Bitstream/Reader/BitstreamReader.cpp

 
 static Expected<uint64_t> readAbbreviatedField(BitstreamCursor &Cursor,
                                                const BitCodeAbbrevOp &Op) {
   assert(!Op.isLiteral() && "Not to be used with literals!");
 
   // Decode the value as we are commanded.
   switch (Op.getEncoding()) {
   case BitCodeAbbrevOp::Array:
+  case BitCodeAbbrevOp::ExtArray:
   case BitCodeAbbrevOp::Blob:
     llvm_unreachable("Should not reach here");
   case BitCodeAbbrevOp::Fixed:
     assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize);
     return Cursor.Read((unsigned)Op.getEncodingData());
   case BitCodeAbbrevOp::VBR:
     assert((unsigned)Op.getEncodingData() <= Cursor.MaxChunkSize);
     return Cursor.ReadVBR64((unsigned)Op.getEncodingData());
Expected<unsigned> BitstreamCursor::skipRecord(unsigned AbbrevID) {
 
   const BitCodeAbbrev *Abbv = MaybeAbbv.get();
   const BitCodeAbbrevOp &CodeOp = Abbv->getOperandInfo(0);
   unsigned Code;
   if (CodeOp.isLiteral())
     Code = CodeOp.getLiteralValue();
   else {
     if (CodeOp.getEncoding() == BitCodeAbbrevOp::Array ||
+        CodeOp.getEncoding() == BitCodeAbbrevOp::ExtArray ||
         CodeOp.getEncoding() == BitCodeAbbrevOp::Blob)
       return llvm::createStringError(
           std::errc::illegal_byte_sequence,
           "Abbreviation starts with an Array or a Blob");
     Expected<uint64_t> MaybeCode = readAbbreviatedField(*this, CodeOp);
     if (!MaybeCode)
       return MaybeCode.takeError();
     Code = MaybeCode.get();
   }
 
   for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i < e; ++i) {
     const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
     if (Op.isLiteral())
       continue;
 
     if (Op.getEncoding() != BitCodeAbbrevOp::Array &&
+        Op.getEncoding() != BitCodeAbbrevOp::ExtArray &&
         Op.getEncoding() != BitCodeAbbrevOp::Blob) {
       if (Expected<uint64_t> MaybeField = readAbbreviatedField(*this, Op))
         continue;
       else
         return MaybeField.takeError();
     }
 
     if (Op.getEncoding() == BitCodeAbbrevOp::Array) {
if (Op.getEncoding() == BitCodeAbbrevOp::Array) {
       case BitCodeAbbrevOp::Char6:
         if (Error Err = JumpToBit(GetCurrentBitNo() + NumElts * 6))
           return std::move(Err);
         break;
       }
       continue;
     }
 
+    if (Op.getEncoding() == BitCodeAbbrevOp::ExtArray) {
+      // Extended array case.
+      unsigned NumFields = Op.getEncodingData() + 1;
+      if (i + NumFields >= e)
+        return error("Missing array element specifiers");
+
+      Expected<uint32_t> MaybeNumElts = ReadVBR(6);
+      if (!MaybeNumElts) {
+        return error(
+            ("Failed to read size: " + toString(MaybeNumElts.takeError()))
+                .c_str());
+      }
+      uint32_t NumElts = MaybeNumElts.get();
+      if (NumElts > std::numeric_limits<size_t>::max() / NumFields)
+        return error("Size overflow");
+
+      size_t NumVals = (size_t)NumElts * NumFields;
+      if (!isSizePlausible(NumVals))
+        return error("Size is not plausible");
+
+      for (; NumElts; --NumElts) {
+        for (unsigned field = 0; field != NumFields; ++field) {
+          const BitCodeAbbrevOp &Enc = Abbv->getOperandInfo(i + field + 1);
+          if (Error Err = readAbbreviatedField(*this, Enc).takeError())
+            return std::move(Err);
+        }
+      }
+
+      i += NumFields;
+      continue;
+    }
+
     assert(Op.getEncoding() == BitCodeAbbrevOp::Blob);
     // Blob case.  Read the number of bytes as a vbr6.
     Expected<uint32_t> MaybeNum = ReadVBR(6);
     if (!MaybeNum)
       return MaybeNum.takeError();
     unsigned NumElts = MaybeNum.get();
     SkipToFourByteBoundary();  // 32-bit alignment
 
Expected<unsigned> BitstreamCursor::readRecord(unsigned AbbrevID,
   // Read the record code first.
   assert(Abbv->getNumOperandInfos() != 0 && "no record code in abbreviation?");
   const BitCodeAbbrevOp &CodeOp = Abbv->getOperandInfo(0);
   unsigned Code;
   if (CodeOp.isLiteral())
     Code = CodeOp.getLiteralValue();
   else {
     if (CodeOp.getEncoding() == BitCodeAbbrevOp::Array ||
+        CodeOp.getEncoding() == BitCodeAbbrevOp::ExtArray ||
         CodeOp.getEncoding() == BitCodeAbbrevOp::Blob)
       return error("Abbreviation starts with an Array or a Blob");
     if (Expected<uint64_t> MaybeCode = readAbbreviatedField(*this, CodeOp))
       Code = MaybeCode.get();
     else
       return MaybeCode.takeError();
   }
 
   for (unsigned i = 1, e = Abbv->getNumOperandInfos(); i != e; ++i) {
     const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
     if (Op.isLiteral()) {
       Vals.push_back(Op.getLiteralValue());
       continue;
     }
 
     if (Op.getEncoding() != BitCodeAbbrevOp::Array &&
+        Op.getEncoding() != BitCodeAbbrevOp::ExtArray &&
         Op.getEncoding() != BitCodeAbbrevOp::Blob) {
       if (Expected<uint64_t> MaybeVal = readAbbreviatedField(*this, Op))
         Vals.push_back(MaybeVal.get());
       else
         return MaybeVal.takeError();
       continue;
     }
 
if (Op.getEncoding() == BitCodeAbbrevOp::Array) {
           if (Expected<SimpleBitstreamCursor::word_t> MaybeVal = Read(6))
             Vals.push_back(BitCodeAbbrevOp::DecodeChar6(MaybeVal.get()));
           else
             return MaybeVal.takeError();
       }
       continue;
     }
 
+    if (Op.getEncoding() == BitCodeAbbrevOp::ExtArray) {
+      // Extended array case.
+      unsigned NumFields = Op.getEncodingData() + 1;
+      if (i + NumFields >= e)
+        return error("Missing array element specifiers");
+
+      Expected<uint32_t> MaybeNumElts = ReadVBR(6);
+      if (!MaybeNumElts) {
+        return error(
+            ("Failed to read size: " + toString(MaybeNumElts.takeError()))
+                .c_str());
+      }
+      uint32_t NumElts = MaybeNumElts.get();
+      if (NumElts > std::numeric_limits<size_t>::max() / NumFields)
+        return error("Size overflow");
+
+      size_t NumVals = (size_t)NumElts * NumFields;
+      if (!isSizePlausible(NumVals))
+        return error("Size is not plausible");
+      Vals.reserve(Vals.size() + NumVals);
+
+      Vals.push_back(NumElts);
+
+      for (; NumElts; --NumElts) {
+        for (unsigned field = 0; field != NumFields; ++field) {
+          const BitCodeAbbrevOp &Enc = Abbv->getOperandInfo(i + field + 1);
+          if (Expected<uint64_t> MaybeVal = readAbbreviatedField(*this, Enc))
+            Vals.push_back(MaybeVal.get());
+          else
+            return MaybeVal.takeError();
+        }
+      }
+
+      i += NumFields;
+      continue;
+    }
+
     assert(Op.getEncoding() == BitCodeAbbrevOp::Blob);
     // Blob case.  Read the number of bytes as a vbr6.
     Expected<uint32_t> MaybeNumElts = ReadVBR(6);
     if (!MaybeNumElts)
       return MaybeNumElts.takeError();
     uint32_t NumElts = MaybeNumElts.get();
     SkipToFourByteBoundary();  // 32-bit alignment
 

llvm/lib/IR/Type.cpp

 bool PointerType::isLoadableOrStorableType(Type *ElemTy) {
   return isValidElementType(ElemTy) && !ElemTy->isFunctionTy();
 }
 
 //===----------------------------------------------------------------------===//
 //                       TargetExtType Implementation
 //===----------------------------------------------------------------------===//
 
+namespace {
+
+struct TargetTypeInfoSchema {
+  sdata::SchemaField Schema[3] = {
+      {"layout", sdata::SchemaField::Type::Type},
+      {"canBeGlobal", sdata::SchemaField::Type::Int, 1},
+      {"hasZeroInit", sdata::SchemaField::Type::Int, 1},
+  };
+
+  static const TargetTypeInfoSchema &get() {
+    static const TargetTypeInfoSchema TTIS;
+    return TTIS;
+  }
+};
+
+} // anonymous namespace
+
 TargetTypeInfoDeserialize::TargetTypeInfoDeserialize(LLVMContext &Ctx,
                                                      StringRef Name,
                                                      ArrayRef<Type *> Types,
                                                      ArrayRef<unsigned> Ints)
     : Ctx(Ctx), Name(Name), Types(Types), Ints(Ints) {
   LayoutType = Type::getVoidTy(Ctx);
 }
 
Expected<TargetExtType *> TargetTypeInfoDeserialize::finish() {
   if (T->LayoutType != LayoutType)
     return sdata::makeDeserializeError("target type has wrong layout type");
   if (T->Properties != Properties)
     return sdata::makeDeserializeError("target type has wrong properties");
 
   return T;
 }
 
+ArrayRef<sdata::SchemaField> llvm::getTargetTypeInfoSchema() {
+  const auto &TTIS = TargetTypeInfoSchema::get();
+  return TTIS.Schema;
+}
+
 SmallVector<std::pair<StringRef, sdata::Value>>
 llvm::serializeTargetTypeInfo(TargetExtType *Ty, bool UseSchema) {
   SmallVector<std::pair<StringRef, sdata::Value>> Fields;
 
   if (UseSchema || !Ty->getLayoutType()->isVoidTy())
     Fields.emplace_back("layout", Ty->getLayoutType());
 
   struct {