This is an archive of the discontinued LLVM Phabricator instance.

Differential D111161

[UnknownProvenance] Add bitcode support.
AcceptedPublic

Authored by jeroen.dobbelaere on Oct 5 2021, 8:08 AM.

Details

Reviewers
jdoerfert
nikic
asbirlea
Summary

Add bitcode support for UnknownProvenance.

Diff Detail

Event Timeline

jeroen.dobbelaere created this revision.Oct 5 2021, 8:08 AM
Herald added a subscriber: hiraditya. · View Herald TranscriptOct 5 2021, 8:08 AM
jeroen.dobbelaere requested review of this revision.Oct 5 2021, 8:08 AM
Herald added a project: Restricted Project. · View Herald TranscriptOct 5 2021, 8:08 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
jeroen.dobbelaere added a parent revision: D111160: [UnknownProvenance] Add LLVM-IR support for unknown_provenance.Oct 5 2021, 8:12 AM
jeroen.dobbelaere added a child revision: D111162: [UnknownProvenance] Add llvm-c support.
Harbormaster completed remote builds in B127087: Diff 377255.Oct 5 2021, 8:25 AM
jeroen.dobbelaere added a reviewer: asbirlea.Oct 11 2021, 8:23 AM
jeroen.dobbelaere added a child revision: D111163: [UnknownProvenance] add support in ValueMapper.Oct 13 2021, 12:03 PM
jeroen.dobbelaere removed a child revision: D111162: [UnknownProvenance] Add llvm-c support.
asbirlea accepted this revision.Nov 3 2021, 4:52 PM
This revision is now accepted and ready to land.Nov 3 2021, 4:52 PM
jeroen.dobbelaere updated this revision to Diff 423092.Apr 15 2022, 6:58 AM

Rebase to 49cb4fef02e635bf304906232214166c7531d753

Herald added a project: Restricted Project. · View Herald TranscriptApr 15 2022, 6:58 AM
Harbormaster completed remote builds in B159829: Diff 423092.Apr 15 2022, 7:49 AM
jeroen.dobbelaere updated this revision to Diff 440961.Jun 29 2022, 5:55 AM

Rebased to ffe262a198a9f9030991df6d3ddd812e74fa3523

Harbormaster completed remote builds in B172719: Diff 440961.Jun 29 2022, 7:34 AM
jeroen.dobbelaere updated this revision to Diff 488532.Jan 12 2023, 1:36 AM

Rebased to ef545ef62a833152d8975ff16333b57cc41befcc (Jan 9, 2023)

Herald added a subscriber: StephenFan. · View Herald TranscriptJan 12 2023, 1:36 AM
Harbormaster completed remote builds in B207314: Diff 488532.Jan 12 2023, 2:56 AM
jeroen.dobbelaere updated this revision to Diff 497790.Feb 15 2023, 2:06 PM

Rebased to: 8c7cfa357280dd93d33b10bbba0fe33797e27d63 (Feb 14, 2023)

Harbormaster completed remote builds in B213978: Diff 497790.Feb 15 2023, 3:23 PM

Revision Contents

PathSize
llvm/
include/
llvm/
Bitcode/
1 line
lib/
Bitcode/
Reader/
5 lines
Writer/
2 lines

Diff 377255

llvm/include/llvm/Bitcode/LLVMBitCodes.h

Show First 20 Lines • Show All 375 Lines • ▼ Show 20 Linesenum ConstantsCodes {
CST_CODE_BLOCKADDRESS = 21, // CST_CODE_BLOCKADDRESS [fnty, fnval, bb#] CST_CODE_BLOCKADDRESS = 21, // CST_CODE_BLOCKADDRESS [fnty, fnval, bb#]
CST_CODE_DATA = 22, // DATA: [n x elements] CST_CODE_DATA = 22, // DATA: [n x elements]
CST_CODE_INLINEASM_OLD2 = 23, // INLINEASM: [sideeffect|alignstack| CST_CODE_INLINEASM_OLD2 = 23, // INLINEASM: [sideeffect|alignstack|
// asmdialect,asmstr,conststr] // asmdialect,asmstr,conststr]
CST_CODE_CE_GEP_WITH_INRANGE_INDEX = 24, // [opty, flags, n x operands] CST_CODE_CE_GEP_WITH_INRANGE_INDEX = 24, // [opty, flags, n x operands]
CST_CODE_CE_UNOP = 25, // CE_UNOP: [opcode, opval] CST_CODE_CE_UNOP = 25, // CE_UNOP: [opcode, opval]
CST_CODE_POISON = 26, // POISON CST_CODE_POISON = 26, // POISON
CST_CODE_DSO_LOCAL_EQUIVALENT = 27, // DSO_LOCAL_EQUIVALENT [gvty, gv] CST_CODE_DSO_LOCAL_EQUIVALENT = 27, // DSO_LOCAL_EQUIVALENT [gvty, gv]
CST_CODE_INLINEASM = 28, // INLINEASM: [sideeffect|alignstack| CST_CODE_INLINEASM = 28, // INLINEASM: [sideeffect|alignstack|
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-  CST_CODE_INLINEASM = 28, // INLINEASM:     [sideeffect|alignstack|
-                           //                 asmdialect|unwind,
-                           //                 asmstr,conststr]
+  CST_CODE_INLINEASM = 28,          // INLINEASM:     [sideeffect|alignstack|
+                                    //                 asmdialect|unwind,
+                                    //                 asmstr,conststr]
Lint: Pre-merge checks: clang-format: please reformat the code ``` - CST_CODE_INLINEASM = 28, // INLINEASM…
// asmdialect|unwind, // asmdialect|unwind,
// asmstr,conststr] // asmstr,conststr]
CST_CODE_UNKNOWN_PROVENANCE = 29, // UNKNOWN_PROVENANCE
}; };
/// CastOpcodes - These are values used in the bitcode files to encode which /// 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 /// 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 /// have no fixed relation to the LLVM IR enum values. Changing these will
/// break compatibility with old files. /// break compatibility with old files.
enum CastOpcodes { enum CastOpcodes {
CAST_TRUNC = 0, CAST_TRUNC = 0,
▲ Show 20 Lines • Show All 302 Lines • Show Last 20 Lines

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

Show First 20 Lines • Show All 2,441 Lines • ▼ Show 20 Lines while (true) {
Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record); Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
if (!MaybeBitCode) if (!MaybeBitCode)
return MaybeBitCode.takeError(); return MaybeBitCode.takeError();
switch (unsigned BitCode = MaybeBitCode.get()) { switch (unsigned BitCode = MaybeBitCode.get()) {
default: // Default behavior: unknown constant default: // Default behavior: unknown constant
case bitc::CST_CODE_UNDEF: // UNDEF case bitc::CST_CODE_UNDEF: // UNDEF
V = UndefValue::get(CurTy); V = UndefValue::get(CurTy);
break; 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 case bitc::CST_CODE_POISON: // POISON
V = PoisonValue::get(CurTy); V = PoisonValue::get(CurTy);
break; break;
case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid]
if (Record.empty()) if (Record.empty())
return error("Invalid record"); return error("Invalid record");
if (Record[0] >= TypeList.size() || !TypeList[Record[0]]) if (Record[0] >= TypeList.size() || !TypeList[Record[0]])
return error("Invalid record"); return error("Invalid record");
▲ Show 20 Lines • Show All 4,627 Lines • Show Last 20 Lines

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

Show First 20 Lines • Show All 2,480 Lines • ▼ Show 20 Lines for (unsigned i = FirstVal; i != LastVal; ++i) {
unsigned Code = -1U; unsigned Code = -1U;
unsigned AbbrevToUse = 0; unsigned AbbrevToUse = 0;
if (C->isNullValue()) { if (C->isNullValue()) {
Code = bitc::CST_CODE_NULL; Code = bitc::CST_CODE_NULL;
} else if (isa<PoisonValue>(C)) { } else if (isa<PoisonValue>(C)) {
Code = bitc::CST_CODE_POISON; Code = bitc::CST_CODE_POISON;
} else if (isa<UndefValue>(C)) { } else if (isa<UndefValue>(C)) {
Code = bitc::CST_CODE_UNDEF; 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)) { } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {
if (IV->getBitWidth() <= 64) { if (IV->getBitWidth() <= 64) {
uint64_t V = IV->getSExtValue(); uint64_t V = IV->getSExtValue();
emitSignedInt64(Record, V); emitSignedInt64(Record, V);
Code = bitc::CST_CODE_INTEGER; Code = bitc::CST_CODE_INTEGER;
AbbrevToUse = CONSTANTS_INTEGER_ABBREV; AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
} else { // Wide integers, > 64 bits in size. } else { // Wide integers, > 64 bits in size.
emitWideAPInt(Record, IV->getValue()); emitWideAPInt(Record, IV->getValue());
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines if (C->isNullValue()) {
isCStrChar6 = BitCodeAbbrevOp::isChar6(V); isCStrChar6 = BitCodeAbbrevOp::isChar6(V);
} }
if (isCStrChar6) if (isCStrChar6)
AbbrevToUse = CString6Abbrev; AbbrevToUse = CString6Abbrev;
else if (isCStr7) else if (isCStr7)
AbbrevToUse = CString7Abbrev; AbbrevToUse = CString7Abbrev;
} else if (const ConstantDataSequential *CDS = } else if (const ConstantDataSequential *CDS =
dyn_cast<ConstantDataSequential>(C)) { dyn_cast<ConstantDataSequential>(C)) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-                  dyn_cast<ConstantDataSequential>(C)) {
+                   dyn_cast<ConstantDataSequential>(C)) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` - dyn_cast<ConstantDataSequential>…
Code = bitc::CST_CODE_DATA; Code = bitc::CST_CODE_DATA;
Type *EltTy = CDS->getElementType(); Type *EltTy = CDS->getElementType();
if (isa<IntegerType>(EltTy)) { if (isa<IntegerType>(EltTy)) {
for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)
Record.push_back(CDS->getElementAsInteger(i)); Record.push_back(CDS->getElementAsInteger(i));
} else { } else {
for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)
Record.push_back( Record.push_back(
▲ Show 20 Lines • Show All 2,415 Lines • Show Last 20 Lines