[UnknownProvenance] Add bitcode support.

[jeroen.dobbelaere]

Summary

Add bitcode support for UnknownProvenance.

[jeroen.dobbelaere]

Rebase to 49cb4fef02e635bf304906232214166c7531d753

[jeroen.dobbelaere]

Rebased to ffe262a198a9f9030991df6d3ddd812e74fa3523

[jeroen.dobbelaere]

Rebased to ef545ef62a833152d8975ff16333b57cc41befcc (Jan 9, 2023)

[jeroen.dobbelaere]

Rebased to: 8c7cfa357280dd93d33b10bbba0fe33797e27d63 (Feb 14, 2023)

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum ConstantsCodes {
   CST_CODE_INLINEASM_OLD3 = 28,    // INLINEASM:     [sideeffect|alignstack|
                                    //                 asmdialect|unwind,
                                    //                 asmstr,conststr]
   CST_CODE_NO_CFI_VALUE = 29, // NO_CFI [ fty, f ]
   CST_CODE_INLINEASM = 30,    // INLINEASM:     [fnty,
                               //                 sideeffect|alignstack|
                               //                 asmdialect|unwind,
                               //                 asmstr,conststr]
+  CST_CODE_UNKNOWN_PROVENANCE = 31, // UNKNOWN_PROVENANCE
 };
 
 /// CastOpcodes - These are values used in the bitcode files to encode which
 /// cast a CST_CODE_CE_CAST or a XXX refers to.  The values of these enums
 /// have no fixed relation to the LLVM IR enum values.  Changing these will
 /// break compatibility with old files.
 enum CastOpcodes {
   CAST_TRUNC = 0,

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

while (true) {
     Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
     if (!MaybeBitCode)
       return MaybeBitCode.takeError();
     switch (unsigned BitCode = MaybeBitCode.get()) {
     default:  // Default behavior: unknown constant
     case bitc::CST_CODE_UNDEF:     // UNDEF
       V = UndefValue::get(CurTy);
       break;
+    case bitc::CST_CODE_UNKNOWN_PROVENANCE: // UNKNOWN_PROVENANCE
+      if (!CurTy->isPointerTy())
+        return error("Invalid type for a unknown_provenance");
+      V = UnknownProvenance::get(cast<PointerType>(CurTy));
+      break;
     case bitc::CST_CODE_POISON:    // POISON
       V = PoisonValue::get(CurTy);
       break;
     case bitc::CST_CODE_SETTYPE:   // SETTYPE: [typeid]
       if (Record.empty())
         return error("Invalid settype record");
       if (Record[0] >= TypeList.size() || !TypeList[Record[0]])
         return error("Invalid settype record");

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

for (unsigned i = FirstVal; i != LastVal; ++i) {
     unsigned Code = -1U;
     unsigned AbbrevToUse = 0;
     if (C->isNullValue()) {
       Code = bitc::CST_CODE_NULL;
     } else if (isa<PoisonValue>(C)) {
       Code = bitc::CST_CODE_POISON;
     } else if (isa<UndefValue>(C)) {
       Code = bitc::CST_CODE_UNDEF;
+    } else if (isa<UnknownProvenance>(C)) {
+      Code = bitc::CST_CODE_UNKNOWN_PROVENANCE;
     } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {
       if (IV->getBitWidth() <= 64) {
         uint64_t V = IV->getSExtValue();
         emitSignedInt64(Record, V);
         Code = bitc::CST_CODE_INTEGER;
         AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
       } else {                             // Wide integers, > 64 bits in size.
         emitWideAPInt(Record, IV->getValue());