Movatterモバイル変換

Go to the documentation of this file.

1//===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===//

2//

3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

4// See https://llvm.org/LICENSE.txt for license information.

5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

6//

7//===----------------------------------------------------------------------===//

9#include "llvm/Bitcode/BitcodeReader.h"

10#include "MetadataLoader.h"

11#include "ValueList.h"

12#include "llvm/ADT/APFloat.h"

13#include "llvm/ADT/APInt.h"

14#include "llvm/ADT/ArrayRef.h"

15#include "llvm/ADT/DenseMap.h"

16#include "llvm/ADT/STLExtras.h"

17#include "llvm/ADT/SmallString.h"

18#include "llvm/ADT/SmallVector.h"

19#include "llvm/ADT/StringRef.h"

20#include "llvm/ADT/Twine.h"

21#include "llvm/Bitcode/BitcodeCommon.h"

22#include "llvm/Bitcode/LLVMBitCodes.h"

23#include "llvm/Bitstream/BitstreamReader.h"

24#include "llvm/Config/llvm-config.h"

25#include "llvm/IR/Argument.h"

26#include "llvm/IR/AttributeMask.h"

27#include "llvm/IR/Attributes.h"

28#include "llvm/IR/AutoUpgrade.h"

29#include "llvm/IR/BasicBlock.h"

30#include "llvm/IR/CallingConv.h"

31#include "llvm/IR/Comdat.h"

32#include "llvm/IR/Constant.h"

33#include "llvm/IR/ConstantRangeList.h"

34#include "llvm/IR/Constants.h"

35#include "llvm/IR/DataLayout.h"

36#include "llvm/IR/DebugInfo.h"

37#include "llvm/IR/DebugInfoMetadata.h"

38#include "llvm/IR/DebugLoc.h"

39#include "llvm/IR/DerivedTypes.h"

40#include "llvm/IR/Function.h"

41#include "llvm/IR/GVMaterializer.h"

42#include "llvm/IR/GetElementPtrTypeIterator.h"

43#include "llvm/IR/GlobalAlias.h"

44#include "llvm/IR/GlobalIFunc.h"

45#include "llvm/IR/GlobalObject.h"

46#include "llvm/IR/GlobalValue.h"

47#include "llvm/IR/GlobalVariable.h"

48#include "llvm/IR/InlineAsm.h"

49#include "llvm/IR/InstIterator.h"

50#include "llvm/IR/InstrTypes.h"

51#include "llvm/IR/Instruction.h"

52#include "llvm/IR/Instructions.h"

53#include "llvm/IR/Intrinsics.h"

54#include "llvm/IR/IntrinsicsAArch64.h"

55#include "llvm/IR/IntrinsicsARM.h"

56#include "llvm/IR/LLVMContext.h"

57#include "llvm/IR/Metadata.h"

58#include "llvm/IR/Module.h"

59#include "llvm/IR/ModuleSummaryIndex.h"

60#include "llvm/IR/Operator.h"

61#include "llvm/IR/ProfDataUtils.h"

62#include "llvm/IR/Type.h"

63#include "llvm/IR/Value.h"

64#include "llvm/IR/Verifier.h"

65#include "llvm/Support/AtomicOrdering.h"

66#include "llvm/Support/Casting.h"

67#include "llvm/Support/CommandLine.h"

68#include "llvm/Support/Compiler.h"

69#include "llvm/Support/Debug.h"

70#include "llvm/Support/Error.h"

71#include "llvm/Support/ErrorHandling.h"

72#include "llvm/Support/ErrorOr.h"

73#include "llvm/Support/MathExtras.h"

74#include "llvm/Support/MemoryBuffer.h"

75#include "llvm/Support/ModRef.h"

76#include "llvm/Support/raw_ostream.h"

77#include "llvm/TargetParser/Triple.h"

78#include <algorithm>

79#include <cassert>

80#include <cstddef>

81#include <cstdint>

82#include <deque>

83#include <map>

84#include <memory>

85#include <optional>

86#include <set>

87#include <string>

88#include <system_error>

89#include <tuple>

90#include <utility>

91#include <vector>

93using namespacellvm;

95staticcl::opt<bool>PrintSummaryGUIDs(

96"print-summary-global-ids",cl::init(false),cl::Hidden,

97cl::desc(

98"Print the global id for each value when reading the module summary"));

100staticcl::opt<bool>ExpandConstantExprs(

101"expand-constant-exprs",cl::Hidden,

102cl::desc(

103"Expand constant expressions to instructions for testing purposes"));

104

105/// Load bitcode directly into RemoveDIs format (use debug records instead

106/// of debug intrinsics). UNSET is treated as FALSE, so the default action

107/// is to do nothing. Individual tools can override this to incrementally add

108/// support for the RemoveDIs format.

109cl::opt<cl::boolOrDefault>LoadBitcodeIntoNewDbgInfoFormat(

110"load-bitcode-into-experimental-debuginfo-iterators",cl::Hidden,

111cl::desc("Load bitcode directly into the new debug info format (regardless "

112"of input format)"));

113externcl::opt<bool>UseNewDbgInfoFormat;

114externcl::opt<cl::boolOrDefault>PreserveInputDbgFormat;

115externboolWriteNewDbgInfoFormatToBitcode;

116externcl::opt<bool>WriteNewDbgInfoFormat;

117

118namespace{

119

120enum {

121 SWITCH_INST_MAGIC = 0x4B5// May 2012 => 1205 => Hex

122};

123

124}// end anonymous namespace

125

126staticError error(constTwine &Message) {

127return make_error<StringError>(

128 Message,make_error_code(BitcodeError::CorruptedBitcode));

129}

130

131staticError hasInvalidBitcodeHeader(BitstreamCursor &Stream) {

132if (!Stream.canSkipToPos(4))

133returncreateStringError(std::errc::illegal_byte_sequence,

134"file too small to contain bitcode header");

135for (unsignedC : {'B','C'})

136if (Expected<SimpleBitstreamCursor::word_t> Res = Stream.Read(8)) {

137if (Res.get() !=C)

138returncreateStringError(std::errc::illegal_byte_sequence,

139"file doesn't start with bitcode header");

140 }else

141return Res.takeError();

142for (unsignedC : {0x0, 0xC, 0xE, 0xD})

143if (Expected<SimpleBitstreamCursor::word_t> Res = Stream.Read(4)) {

144if (Res.get() !=C)

145returncreateStringError(std::errc::illegal_byte_sequence,

146"file doesn't start with bitcode header");

147 }else

148return Res.takeError();

149returnError::success();

150}

151

152staticExpected<BitstreamCursor>initStream(MemoryBufferRef Buffer) {

153constunsignedchar *BufPtr = (constunsignedchar *)Buffer.getBufferStart();

154constunsignedchar *BufEnd = BufPtr + Buffer.getBufferSize();

155

156if (Buffer.getBufferSize() & 3)

157returnerror("Invalid bitcode signature");

158

159// If we have a wrapper header, parse it and ignore the non-bc file contents.

160// The magic number is 0x0B17C0DE stored in little endian.

161if (isBitcodeWrapper(BufPtr, BufEnd))

162if (SkipBitcodeWrapperHeader(BufPtr, BufEnd,true))

163returnerror("Invalid bitcode wrapper header");

164

165BitstreamCursor Stream(ArrayRef<uint8_t>(BufPtr, BufEnd));

166if (Error Err =hasInvalidBitcodeHeader(Stream))

167return std::move(Err);

168

169return std::move(Stream);

170}

171

172/// Convert a string from a record into an std::string, return true on failure.

173template <typename StrTy>

174staticboolconvertToString(ArrayRef<uint64_t>Record,unsignedIdx,

175 StrTy &Result) {

176if (Idx >Record.size())

177returntrue;

178

179 Result.append(Record.begin() +Idx,Record.end());

180returnfalse;

181}

182

183// Strip all the TBAA attachment for the module.

184staticvoidstripTBAA(Module *M) {

185for (auto &F : *M) {

186if (F.isMaterializable())

187continue;

188for (auto &I :instructions(F))

189I.setMetadata(LLVMContext::MD_tbaa,nullptr);

190 }

191}

192

193/// Read the "IDENTIFICATION_BLOCK_ID" block, do some basic enforcement on the

194/// "epoch" encoded in the bitcode, and return the producer name if any.

195staticExpected<std::string>readIdentificationBlock(BitstreamCursor &Stream) {

196if (Error Err = Stream.EnterSubBlock(bitc::IDENTIFICATION_BLOCK_ID))

197return std::move(Err);

198

199// Read all the records.

200SmallVector<uint64_t, 64>Record;

201

202 std::string ProducerIdentification;

203

204while (true) {

205BitstreamEntry Entry;

206if (Error E = Stream.advance().moveInto(Entry))

207return std::move(E);

208

209switch (Entry.Kind) {

210default:

211caseBitstreamEntry::Error:

212returnerror("Malformed block");

213caseBitstreamEntry::EndBlock:

214return ProducerIdentification;

215caseBitstreamEntry::Record:

216// The interesting case.

217break;

218 }

219

220// Read a record.

221Record.clear();

222Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID,Record);

223if (!MaybeBitCode)

224return MaybeBitCode.takeError();

225switch (MaybeBitCode.get()) {

226default:// Default behavior: reject

227returnerror("Invalid value");

228casebitc::IDENTIFICATION_CODE_STRING:// IDENTIFICATION: [strchr x N]

229convertToString(Record, 0, ProducerIdentification);

230break;

231casebitc::IDENTIFICATION_CODE_EPOCH: {// EPOCH: [epoch#]

232unsigned epoch = (unsigned)Record[0];

233if (epoch !=bitc::BITCODE_CURRENT_EPOCH) {

234returnerror(

235Twine("Incompatible epoch: Bitcode '") +Twine(epoch) +

236"' vs current: '" +Twine(bitc::BITCODE_CURRENT_EPOCH) +"'");

237 }

238 }

239 }

240 }

241}

242

243staticExpected<std::string>readIdentificationCode(BitstreamCursor &Stream) {

244// We expect a number of well-defined blocks, though we don't necessarily

245// need to understand them all.

246while (true) {

247if (Stream.AtEndOfStream())

248return"";

249

250BitstreamEntry Entry;

251if (Error E = Stream.advance().moveInto(Entry))

252return std::move(E);

253

254switch (Entry.Kind) {

255caseBitstreamEntry::EndBlock:

256caseBitstreamEntry::Error:

257returnerror("Malformed block");

258

259caseBitstreamEntry::SubBlock:

260if (Entry.ID ==bitc::IDENTIFICATION_BLOCK_ID)

261returnreadIdentificationBlock(Stream);

262

263// Ignore other sub-blocks.

264if (Error Err = Stream.SkipBlock())

265return std::move(Err);

266continue;

267caseBitstreamEntry::Record:

268if (Error E = Stream.skipRecord(Entry.ID).takeError())

269return std::move(E);

270continue;

271 }

272 }

273}

274

275staticExpected<bool>hasObjCCategoryInModule(BitstreamCursor &Stream) {

276if (Error Err = Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))

277return std::move(Err);

278

279SmallVector<uint64_t, 64>Record;

280// Read all the records for this module.

281

282while (true) {

283Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

284if (!MaybeEntry)

285return MaybeEntry.takeError();

286BitstreamEntry Entry = MaybeEntry.get();

287

288switch (Entry.Kind) {

289caseBitstreamEntry::SubBlock:// Handled for us already.

290caseBitstreamEntry::Error:

291returnerror("Malformed block");

292caseBitstreamEntry::EndBlock:

293returnfalse;

294caseBitstreamEntry::Record:

295// The interesting case.

296break;

297 }

298

299// Read a record.

300Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

301if (!MaybeRecord)

302return MaybeRecord.takeError();

303switch (MaybeRecord.get()) {

304default:

305break;// Default behavior, ignore unknown content.

306casebitc::MODULE_CODE_SECTIONNAME: {// SECTIONNAME: [strchr x N]

307 std::string S;

308if (convertToString(Record, 0, S))

309returnerror("Invalid section name record");

310// Check for the i386 and other (x86_64, ARM) conventions

311if (S.find("__DATA,__objc_catlist") != std::string::npos ||

312 S.find("__OBJC,__category") != std::string::npos ||

313 S.find("__TEXT,__swift") != std::string::npos)

314returntrue;

315break;

316 }

317 }

318Record.clear();

319 }

320llvm_unreachable("Exit infinite loop");

321}

322

323staticExpected<bool>hasObjCCategory(BitstreamCursor &Stream) {

324// We expect a number of well-defined blocks, though we don't necessarily

325// need to understand them all.

326while (true) {

327BitstreamEntry Entry;

328if (Error E = Stream.advance().moveInto(Entry))

329return std::move(E);

330

331switch (Entry.Kind) {

332caseBitstreamEntry::Error:

333returnerror("Malformed block");

334caseBitstreamEntry::EndBlock:

335returnfalse;

336

337caseBitstreamEntry::SubBlock:

338if (Entry.ID ==bitc::MODULE_BLOCK_ID)

339returnhasObjCCategoryInModule(Stream);

340

341// Ignore other sub-blocks.

342if (Error Err = Stream.SkipBlock())

343return std::move(Err);

344continue;

345

346caseBitstreamEntry::Record:

347if (Error E = Stream.skipRecord(Entry.ID).takeError())

348return std::move(E);

349continue;

350 }

351 }

352}

353

354staticExpected<std::string>readModuleTriple(BitstreamCursor &Stream) {

355if (Error Err = Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))

356return std::move(Err);

357

358SmallVector<uint64_t, 64>Record;

359

360 std::stringTriple;

361

362// Read all the records for this module.

363while (true) {

364Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

365if (!MaybeEntry)

366return MaybeEntry.takeError();

367BitstreamEntry Entry = MaybeEntry.get();

368

369switch (Entry.Kind) {

370caseBitstreamEntry::SubBlock:// Handled for us already.

371caseBitstreamEntry::Error:

372returnerror("Malformed block");

373caseBitstreamEntry::EndBlock:

374returnTriple;

375caseBitstreamEntry::Record:

376// The interesting case.

377break;

378 }

379

380// Read a record.

381Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

382if (!MaybeRecord)

383return MaybeRecord.takeError();

384switch (MaybeRecord.get()) {

385default:break;// Default behavior, ignore unknown content.

386casebitc::MODULE_CODE_TRIPLE: {// TRIPLE: [strchr x N]

387 std::string S;

388if (convertToString(Record, 0, S))

389returnerror("Invalid triple record");

390Triple = S;

391break;

392 }

393 }

394Record.clear();

395 }

396llvm_unreachable("Exit infinite loop");

397}

398

399staticExpected<std::string>readTriple(BitstreamCursor &Stream) {

400// We expect a number of well-defined blocks, though we don't necessarily

401// need to understand them all.

402while (true) {

403Expected<BitstreamEntry> MaybeEntry = Stream.advance();

404if (!MaybeEntry)

405return MaybeEntry.takeError();

406BitstreamEntry Entry = MaybeEntry.get();

407

408switch (Entry.Kind) {

409caseBitstreamEntry::Error:

410returnerror("Malformed block");

411caseBitstreamEntry::EndBlock:

412return"";

413

414caseBitstreamEntry::SubBlock:

415if (Entry.ID ==bitc::MODULE_BLOCK_ID)

416returnreadModuleTriple(Stream);

417

418// Ignore other sub-blocks.

419if (Error Err = Stream.SkipBlock())

420return std::move(Err);

421continue;

422

423caseBitstreamEntry::Record:

424if (llvm::Expected<unsigned> Skipped = Stream.skipRecord(Entry.ID))

425continue;

426else

427return Skipped.takeError();

428 }

429 }

430}

431

432namespace{

433

434classBitcodeReaderBase {

435protected:

436 BitcodeReaderBase(BitstreamCursor Stream,StringRef Strtab)

437 : Stream(std::move(Stream)), Strtab(Strtab) {

438 this->Stream.setBlockInfo(&BlockInfo);

439 }

440

441BitstreamBlockInfo BlockInfo;

442BitstreamCursor Stream;

443StringRef Strtab;

444

445 /// In version 2 of the bitcode we store names of global values and comdats in

446 /// a string table rather than in the VST.

447bool UseStrtab =false;

448

449Expected<unsigned> parseVersionRecord(ArrayRef<uint64_t>Record);

450

451 /// If this module uses a string table, pop the reference to the string table

452 /// and return the referenced string and the rest of the record. Otherwise

453 /// just return the record itself.

454 std::pair<StringRef, ArrayRef<uint64_t>>

455 readNameFromStrtab(ArrayRef<uint64_t>Record);

456

457Error readBlockInfo();

458

459// Contains an arbitrary and optional string identifying the bitcode producer

460 std::string ProducerIdentification;

461

462Error error(constTwine &Message);

463};

464

465}// end anonymous namespace

466

467Error BitcodeReaderBase::error(constTwine &Message) {

468 std::string FullMsg = Message.str();

469if (!ProducerIdentification.empty())

470 FullMsg +=" (Producer: '" + ProducerIdentification +"' Reader: 'LLVM " +

471 LLVM_VERSION_STRING"')";

472 return ::error(FullMsg);

473}

474

475Expected<unsigned>

476BitcodeReaderBase::parseVersionRecord(ArrayRef<uint64_t>Record) {

477if (Record.empty())

478returnerror("Invalid version record");

479unsigned ModuleVersion =Record[0];

480if (ModuleVersion > 2)

481returnerror("Invalid value");

482 UseStrtab = ModuleVersion >= 2;

483return ModuleVersion;

484}

485

486std::pair<StringRef, ArrayRef<uint64_t>>

487BitcodeReaderBase::readNameFromStrtab(ArrayRef<uint64_t>Record) {

488if (!UseStrtab)

489return {"",Record};

490// Invalid reference. Let the caller complain about the record being empty.

491if (Record[0] +Record[1] > Strtab.size())

492return {"", {}};

493return {StringRef(Strtab.data() +Record[0],Record[1]),Record.slice(2)};

494}

495

496namespace{

497

498/// This represents a constant expression or constant aggregate using a custom

499/// structure internal to the bitcode reader. Later, this structure will be

500/// expanded by materializeValue() either into a constant expression/aggregate,

501/// or into an instruction sequence at the point of use. This allows us to

502/// upgrade bitcode using constant expressions even if this kind of constant

503/// expression is no longer supported.

504classBitcodeConstant final :publicValue,

505TrailingObjects<BitcodeConstant, unsigned> {

506friendTrailingObjects;

507

508// Value subclass ID: Pick largest possible value to avoid any clashes.

509staticconstexpruint8_t SubclassID = 255;

510

511public:

512// Opcodes used for non-expressions. This includes constant aggregates

513// (struct, array, vector) that might need expansion, as well as non-leaf

514// constants that don't need expansion (no_cfi, dso_local, blockaddress),

515// but still go through BitcodeConstant to avoid different uselist orders

516// between the two cases.

517staticconstexpruint8_t ConstantStructOpcode = 255;

518staticconstexpruint8_t ConstantArrayOpcode = 254;

519staticconstexpruint8_t ConstantVectorOpcode = 253;

520staticconstexpruint8_t NoCFIOpcode = 252;

521staticconstexpruint8_t DSOLocalEquivalentOpcode = 251;

522staticconstexpruint8_t BlockAddressOpcode = 250;

523staticconstexpruint8_t ConstantPtrAuthOpcode = 249;

524staticconstexpruint8_t FirstSpecialOpcode = ConstantPtrAuthOpcode;

525

526// Separate struct to make passing different number of parameters to

527// BitcodeConstant::create() more convenient.

528structExtraInfo {

529uint8_t Opcode;

530uint8_t Flags;

531unsigned BlockAddressBB = 0;

532Type *SrcElemTy =nullptr;

533 std::optional<ConstantRange> InRange;

534

535 ExtraInfo(uint8_t Opcode,uint8_t Flags = 0,Type *SrcElemTy =nullptr,

536 std::optional<ConstantRange> InRange = std::nullopt)

537 : Opcode(Opcode),Flags(Flags), SrcElemTy(SrcElemTy),

538 InRange(std::move(InRange)) {}

539

540 ExtraInfo(uint8_t Opcode,uint8_t Flags,unsigned BlockAddressBB)

541 : Opcode(Opcode),Flags(Flags), BlockAddressBB(BlockAddressBB) {}

542 };

543

544uint8_t Opcode;

545uint8_t Flags;

546unsigned NumOperands;

547unsigned BlockAddressBB;

548Type *SrcElemTy;// GEP source element type.

549 std::optional<ConstantRange>InRange;// GEP inrange attribute.

550

551private:

552 BitcodeConstant(Type *Ty,const ExtraInfo &Info,ArrayRef<unsigned> OpIDs)

553 :Value(Ty, SubclassID), Opcode(Info.Opcode),Flags(Info.Flags),

554 NumOperands(OpIDs.size()), BlockAddressBB(Info.BlockAddressBB),

555 SrcElemTy(Info.SrcElemTy), InRange(Info.InRange) {

556 std::uninitialized_copy(OpIDs.begin(), OpIDs.end(),

557 getTrailingObjects<unsigned>());

558 }

559

560 BitcodeConstant &operator=(const BitcodeConstant &) =delete;

561

562public:

563static BitcodeConstant *create(BumpPtrAllocator &A,Type *Ty,

564const ExtraInfo &Info,

565ArrayRef<unsigned> OpIDs) {

566void *Mem =A.Allocate(totalSizeToAlloc<unsigned>(OpIDs.size()),

567alignof(BitcodeConstant));

568returnnew (Mem) BitcodeConstant(Ty, Info, OpIDs);

569 }

570

571staticbool classof(constValue *V) {returnV->getValueID() == SubclassID; }

572

573ArrayRef<unsigned> getOperandIDs() const{

574returnArrayRef(getTrailingObjects<unsigned>(), NumOperands);

575 }

576

577 std::optional<ConstantRange> getInRange() const{

578assert(Opcode == Instruction::GetElementPtr);

579returnInRange;

580 }

581

582constchar *getOpcodeName() const{

583returnInstruction::getOpcodeName(Opcode);

584 }

585};

586

587classBitcodeReader :public BitcodeReaderBase,publicGVMaterializer {

588LLVMContext &Context;

589Module *TheModule =nullptr;

590// Next offset to start scanning for lazy parsing of function bodies.

591uint64_t NextUnreadBit = 0;

592// Last function offset found in the VST.

593uint64_t LastFunctionBlockBit = 0;

594bool SeenValueSymbolTable =false;

595uint64_t VSTOffset = 0;

596

597 std::vector<std::string> SectionTable;

598 std::vector<std::string> GCTable;

599

600 std::vector<Type *> TypeList;

601 /// Track type IDs of contained types. Order is the same as the contained

602 /// types of a Type*. This is used during upgrades of typed pointer IR in

603 /// opaque pointer mode.

604DenseMap<unsigned, SmallVector<unsigned, 1>> ContainedTypeIDs;

605 /// In some cases, we need to create a type ID for a type that was not

606 /// explicitly encoded in the bitcode, or we don't know about at the current

607 /// point. For example, a global may explicitly encode the value type ID, but

608 /// not have a type ID for the pointer to value type, for which we create a

609 /// virtual type ID instead. This map stores the new type ID that was created

610 /// for the given pair of Type and contained type ID.

611DenseMap<std::pair<Type *, unsigned>,unsigned> VirtualTypeIDs;

612DenseMap<Function *, unsigned> FunctionTypeIDs;

613 /// Allocator for BitcodeConstants. This should come before ValueList,

614 /// because the ValueList might hold ValueHandles to these constants, so

615 /// ValueList must be destroyed before Alloc.

616BumpPtrAllocator Alloc;

617BitcodeReaderValueList ValueList;

618 std::optional<MetadataLoader> MDLoader;

619 std::vector<Comdat *> ComdatList;

620DenseSet<GlobalObject *> ImplicitComdatObjects;

621SmallVector<Instruction *, 64> InstructionList;

622

623 std::vector<std::pair<GlobalVariable *, unsigned>> GlobalInits;

624 std::vector<std::pair<GlobalValue *, unsigned>> IndirectSymbolInits;

625

626structFunctionOperandInfo {

627Function *F;

628unsigned PersonalityFn;

629unsignedPrefix;

630unsigned Prologue;

631 };

632 std::vector<FunctionOperandInfo> FunctionOperands;

633

634 /// The set of attributes by index. Index zero in the file is for null, and

635 /// is thus not represented here. As such all indices are off by one.

636 std::vector<AttributeList> MAttributes;

637

638 /// The set of attribute groups.

639 std::map<unsigned, AttributeList> MAttributeGroups;

640

641 /// While parsing a function body, this is a list of the basic blocks for the

642 /// function.

643 std::vector<BasicBlock*> FunctionBBs;

644

645// When reading the module header, this list is populated with functions that

646// have bodies later in the file.

647 std::vector<Function*> FunctionsWithBodies;

648

649// When intrinsic functions are encountered which require upgrading they are

650// stored here with their replacement function.

651usingUpdatedIntrinsicMap =DenseMap<Function *, Function *>;

652 UpdatedIntrinsicMap UpgradedIntrinsics;

653

654// Several operations happen after the module header has been read, but

655// before function bodies are processed. This keeps track of whether

656// we've done this yet.

657bool SeenFirstFunctionBody =false;

658

659 /// When function bodies are initially scanned, this map contains info about

660 /// where to find deferred function body in the stream.

661DenseMap<Function*, uint64_t> DeferredFunctionInfo;

662

663 /// When Metadata block is initially scanned when parsing the module, we may

664 /// choose to defer parsing of the metadata. This vector contains info about

665 /// which Metadata blocks are deferred.

666 std::vector<uint64_t> DeferredMetadataInfo;

667

668 /// These are basic blocks forward-referenced by block addresses. They are

669 /// inserted lazily into functions when they're loaded. The basic block ID is

670 /// its index into the vector.

671DenseMap<Function *, std::vector<BasicBlock *>> BasicBlockFwdRefs;

672 std::deque<Function *> BasicBlockFwdRefQueue;

673

674 /// These are Functions that contain BlockAddresses which refer a different

675 /// Function. When parsing the different Function, queue Functions that refer

676 /// to the different Function. Those Functions must be materialized in order

677 /// to resolve their BlockAddress constants before the different Function

678 /// gets moved into another Module.

679 std::vector<Function *> BackwardRefFunctions;

680

681 /// Indicates that we are using a new encoding for instruction operands where

682 /// most operands in the current FUNCTION_BLOCK are encoded relative to the

683 /// instruction number, for a more compact encoding. Some instruction

684 /// operands are not relative to the instruction ID: basic block numbers, and

685 /// types. Once the old style function blocks have been phased out, we would

686 /// not need this flag.

687bool UseRelativeIDs =false;

688

689 /// True if all functions will be materialized, negating the need to process

690 /// (e.g.) blockaddress forward references.

691bool WillMaterializeAllForwardRefs =false;

692

693 /// Tracks whether we have seen debug intrinsics or records in this bitcode;

694 /// seeing both in a single module is currently a fatal error.

695bool SeenDebugIntrinsic =false;

696bool SeenDebugRecord =false;

697

698boolStripDebugInfo =false;

699TBAAVerifier TBAAVerifyHelper;

700

701 std::vector<std::string> BundleTags;

702SmallVector<SyncScope::ID, 8> SSIDs;

703

704 std::optional<ValueTypeCallbackTy> ValueTypeCallback;

705

706public:

707 BitcodeReader(BitstreamCursor Stream,StringRef Strtab,

708StringRef ProducerIdentification,LLVMContext &Context);

709

710Error materializeForwardReferencedFunctions();

711

712Error materialize(GlobalValue *GV)override;

713Error materializeModule()override;

714 std::vector<StructType *>getIdentifiedStructTypes()const override;

715

716 /// Main interface to parsing a bitcode buffer.

717 /// \returns true if an error occurred.

718Error parseBitcodeInto(Module *M,bool ShouldLazyLoadMetadata,

719bool IsImporting,ParserCallbacks Callbacks = {});

720

721staticuint64_t decodeSignRotatedValue(uint64_t V);

722

723 /// Materialize any deferred Metadata block.

724Error materializeMetadata()override;

725

726voidsetStripDebugInfo()override;

727

728private:

729 std::vector<StructType *> IdentifiedStructTypes;

730StructType *createIdentifiedStructType(LLVMContext &Context,StringRef Name);

731StructType *createIdentifiedStructType(LLVMContext &Context);

732

733staticconstexprunsigned InvalidTypeID = ~0u;

734

735Type *getTypeByID(unsignedID);

736Type *getPtrElementTypeByID(unsignedID);

737unsigned getContainedTypeID(unsignedID,unsignedIdx = 0);

738unsigned getVirtualTypeID(Type *Ty,ArrayRef<unsigned> ContainedTypeIDs = {});

739

740void callValueTypeCallback(Value *F,unsignedTypeID);

741Expected<Value *> materializeValue(unsignedValID,BasicBlock *InsertBB);

742Expected<Constant *> getValueForInitializer(unsignedID);

743

744Value *getFnValueByID(unsignedID,Type *Ty,unsigned TyID,

745BasicBlock *ConstExprInsertBB) {

746if (Ty && Ty->isMetadataTy())

747returnMetadataAsValue::get(Ty->getContext(), getFnMetadataByID(ID));

748return ValueList.getValueFwdRef(ID, Ty, TyID, ConstExprInsertBB);

749 }

750

751Metadata *getFnMetadataByID(unsignedID) {

752return MDLoader->getMetadataFwdRefOrLoad(ID);

753 }

754

755BasicBlock *getBasicBlock(unsignedID) const{

756if (ID >= FunctionBBs.size())returnnullptr;// Invalid ID

757return FunctionBBs[ID];

758 }

759

760AttributeList getAttributes(unsigned i) const{

761if (i-1 < MAttributes.size())

762return MAttributes[i-1];

763returnAttributeList();

764 }

765

766 /// Read a value/type pair out of the specified record from slot 'Slot'.

767 /// Increment Slot past the number of slots used in the record. Return true on

768 /// failure.

769bool getValueTypePair(constSmallVectorImpl<uint64_t> &Record,unsigned &Slot,

770unsigned InstNum,Value *&ResVal,unsigned &TypeID,

771BasicBlock *ConstExprInsertBB) {

772if (Slot ==Record.size())returntrue;

773unsigned ValNo = (unsigned)Record[Slot++];

774// Adjust the ValNo, if it was encoded relative to the InstNum.

775if (UseRelativeIDs)

776 ValNo = InstNum - ValNo;

777if (ValNo < InstNum) {

778// If this is not a forward reference, just return the value we already

779// have.

780TypeID = ValueList.getTypeID(ValNo);

781 ResVal = getFnValueByID(ValNo,nullptr,TypeID, ConstExprInsertBB);

782assert((!ResVal || ResVal->getType() == getTypeByID(TypeID)) &&

783"Incorrect type ID stored for value");

784return ResVal ==nullptr;

785 }

786if (Slot ==Record.size())

787returntrue;

788

789TypeID = (unsigned)Record[Slot++];

790 ResVal = getFnValueByID(ValNo, getTypeByID(TypeID),TypeID,

791 ConstExprInsertBB);

792return ResVal ==nullptr;

793 }

794

795bool getValueOrMetadata(constSmallVectorImpl<uint64_t> &Record,

796unsigned &Slot,unsigned InstNum,Value *&ResVal,

797BasicBlock *ConstExprInsertBB) {

798if (Slot ==Record.size())

799returntrue;

800unsignedValID =Record[Slot++];

801if (ValID !=static_cast<unsigned>(bitc::OB_METADATA)) {

802unsigned TypeId;

803return getValueTypePair(Record, --Slot, InstNum, ResVal, TypeId,

804 ConstExprInsertBB);

805 }

806if (Slot ==Record.size())

807returntrue;

808unsigned ValNo = InstNum - (unsigned)Record[Slot++];

809 ResVal =MetadataAsValue::get(Context, getFnMetadataByID(ValNo));

810returnfalse;

811 }

812

813 /// Read a value out of the specified record from slot 'Slot'. Increment Slot

814 /// past the number of slots used by the value in the record. Return true if

815 /// there is an error.

816bool popValue(constSmallVectorImpl<uint64_t> &Record,unsigned &Slot,

817unsigned InstNum,Type *Ty,unsigned TyID,Value *&ResVal,

818BasicBlock *ConstExprInsertBB) {

819if (getValue(Record, Slot, InstNum, Ty, TyID, ResVal, ConstExprInsertBB))

820returntrue;

821// All values currently take a single record slot.

822 ++Slot;

823returnfalse;

824 }

825

826 /// Like popValue, but does not increment the Slot number.

827bool getValue(constSmallVectorImpl<uint64_t> &Record,unsigned Slot,

828unsigned InstNum,Type *Ty,unsigned TyID,Value *&ResVal,

829BasicBlock *ConstExprInsertBB) {

830 ResVal = getValue(Record, Slot, InstNum, Ty, TyID, ConstExprInsertBB);

831return ResVal ==nullptr;

832 }

833

834 /// Version of getValue that returns ResVal directly, or 0 if there is an

835 /// error.

836Value *getValue(constSmallVectorImpl<uint64_t> &Record,unsigned Slot,

837unsigned InstNum,Type *Ty,unsigned TyID,

838BasicBlock *ConstExprInsertBB) {

839if (Slot ==Record.size())returnnullptr;

840unsigned ValNo = (unsigned)Record[Slot];

841// Adjust the ValNo, if it was encoded relative to the InstNum.

842if (UseRelativeIDs)

843 ValNo = InstNum - ValNo;

844return getFnValueByID(ValNo, Ty, TyID, ConstExprInsertBB);

845 }

846

847 /// Like getValue, but decodes signed VBRs.

848Value *getValueSigned(constSmallVectorImpl<uint64_t> &Record,unsigned Slot,

849unsigned InstNum,Type *Ty,unsigned TyID,

850BasicBlock *ConstExprInsertBB) {

851if (Slot ==Record.size())returnnullptr;

852unsigned ValNo = (unsigned)decodeSignRotatedValue(Record[Slot]);

853// Adjust the ValNo, if it was encoded relative to the InstNum.

854if (UseRelativeIDs)

855 ValNo = InstNum - ValNo;

856return getFnValueByID(ValNo, Ty, TyID, ConstExprInsertBB);

857 }

858

859Expected<ConstantRange> readConstantRange(ArrayRef<uint64_t>Record,

860unsigned &OpNum,

861unsignedBitWidth) {

862if (Record.size() - OpNum < 2)

863returnerror("Too few records for range");

864if (BitWidth > 64) {

865unsigned LowerActiveWords =Record[OpNum];

866unsigned UpperActiveWords =Record[OpNum++] >> 32;

867if (Record.size() - OpNum < LowerActiveWords + UpperActiveWords)

868returnerror("Too few records for range");

869APInt Lower =

870readWideAPInt(ArrayRef(&Record[OpNum], LowerActiveWords),BitWidth);

871 OpNum += LowerActiveWords;

872APInt Upper =

873readWideAPInt(ArrayRef(&Record[OpNum], UpperActiveWords),BitWidth);

874 OpNum += UpperActiveWords;

875returnConstantRange(Lower,Upper);

876 }else {

877 int64_t Start = BitcodeReader::decodeSignRotatedValue(Record[OpNum++]);

878 int64_tEnd = BitcodeReader::decodeSignRotatedValue(Record[OpNum++]);

879returnConstantRange(APInt(BitWidth, Start,true),

880APInt(BitWidth,End,true));

881 }

882 }

883

884Expected<ConstantRange>

885 readBitWidthAndConstantRange(ArrayRef<uint64_t>Record,unsigned &OpNum) {

886if (Record.size() - OpNum < 1)

887returnerror("Too few records for range");

888unsignedBitWidth =Record[OpNum++];

889return readConstantRange(Record, OpNum,BitWidth);

890 }

891

892 /// Upgrades old-style typeless byval/sret/inalloca attributes by adding the

893 /// corresponding argument's pointee type. Also upgrades intrinsics that now

894 /// require an elementtype attribute.

895Error propagateAttributeTypes(CallBase *CB,ArrayRef<unsigned> ArgsTys);

896

897 /// Converts alignment exponent (i.e. power of two (or zero)) to the

898 /// corresponding alignment to use. If alignment is too large, returns

899 /// a corresponding error code.

900Error parseAlignmentValue(uint64_t Exponent,MaybeAlign &Alignment);

901Error parseAttrKind(uint64_t Code,Attribute::AttrKind *Kind);

902Error parseModule(uint64_t ResumeBit,bool ShouldLazyLoadMetadata =false,

903ParserCallbacks Callbacks = {});

904

905Error parseComdatRecord(ArrayRef<uint64_t>Record);

906Error parseGlobalVarRecord(ArrayRef<uint64_t>Record);

907Error parseFunctionRecord(ArrayRef<uint64_t>Record);

908Error parseGlobalIndirectSymbolRecord(unsigned BitCode,

909ArrayRef<uint64_t>Record);

910

911Error parseAttributeBlock();

912Error parseAttributeGroupBlock();

913Error parseTypeTable();

914Error parseTypeTableBody();

915Error parseOperandBundleTags();

916Error parseSyncScopeNames();

917

918Expected<Value *> recordValue(SmallVectorImpl<uint64_t> &Record,

919unsigned NameIndex,Triple &TT);

920void setDeferredFunctionInfo(unsigned FuncBitcodeOffsetDelta,Function *F,

921ArrayRef<uint64_t>Record);

922Error parseValueSymbolTable(uint64_t Offset = 0);

923Error parseGlobalValueSymbolTable();

924Error parseConstants();

925Error rememberAndSkipFunctionBodies();

926Error rememberAndSkipFunctionBody();

927 /// Save the positions of the Metadata blocks and skip parsing the blocks.

928Error rememberAndSkipMetadata();

929Error typeCheckLoadStoreInst(Type *ValType,Type *PtrType);

930Error parseFunctionBody(Function *F);

931Error globalCleanup();

932Error resolveGlobalAndIndirectSymbolInits();

933Error parseUseLists();

934Error findFunctionInStream(

935Function *F,

936DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator);

937

938SyncScope::ID getDecodedSyncScopeID(unsigned Val);

939};

940

941/// Class to manage reading and parsing function summary index bitcode

942/// files/sections.

943classModuleSummaryIndexBitcodeReader :public BitcodeReaderBase {

944 /// The module index built during parsing.

945ModuleSummaryIndex &TheIndex;

946

947 /// Indicates whether we have encountered a global value summary section

948 /// yet during parsing.

949bool SeenGlobalValSummary =false;

950

951 /// Indicates whether we have already parsed the VST, used for error checking.

952bool SeenValueSymbolTable =false;

953

954 /// Set to the offset of the VST recorded in the MODULE_CODE_VSTOFFSET record.

955 /// Used to enable on-demand parsing of the VST.

956uint64_t VSTOffset = 0;

957

958// Map to save ValueId to ValueInfo association that was recorded in the

959// ValueSymbolTable. It is used after the VST is parsed to convert

960// call graph edges read from the function summary from referencing

961// callees by their ValueId to using the ValueInfo instead, which is how

962// they are recorded in the summary index being built.

963// We save a GUID which refers to the same global as the ValueInfo, but

964// ignoring the linkage, i.e. for values other than local linkage they are

965// identical (this is the second member). ValueInfo has the real GUID.

966DenseMap<unsigned, std::pair<ValueInfo, GlobalValue::GUID>>

967 ValueIdToValueInfoMap;

968

969 /// Map populated during module path string table parsing, from the

970 /// module ID to a string reference owned by the index's module

971 /// path string table, used to correlate with combined index

972 /// summary records.

973DenseMap<uint64_t, StringRef> ModuleIdMap;

974

975 /// Original source file name recorded in a bitcode record.

976 std::string SourceFileName;

977

978 /// The string identifier given to this module by the client, normally the

979 /// path to the bitcode file.

980StringRef ModulePath;

981

982 /// Callback to ask whether a symbol is the prevailing copy when invoked

983 /// during combined index building.

984 std::function<bool(GlobalValue::GUID)> IsPrevailing;

985

986 /// Saves the stack ids from the STACK_IDS record to consult when adding stack

987 /// ids from the lists in the callsite and alloc entries to the index.

988 std::vector<uint64_t> StackIds;

989

990 /// Linearized radix tree of allocation contexts. See the description above

991 /// the CallStackRadixTreeBuilder class in ProfileData/MemProf.h for format.

992 std::vector<uint64_t> RadixArray;

993

994public:

995 ModuleSummaryIndexBitcodeReader(

996BitstreamCursor Stream,StringRef Strtab,ModuleSummaryIndex &TheIndex,

997StringRef ModulePath,

998 std::function<bool(GlobalValue::GUID)> IsPrevailing =nullptr);

999

1000Error parseModule();

1001

1002private:

1003void setValueGUID(uint64_t ValueID,StringRef ValueName,

1004GlobalValue::LinkageTypes Linkage,

1005StringRef SourceFileName);

1006Error parseValueSymbolTable(

1007uint64_t Offset,

1008DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap);

1009SmallVector<ValueInfo, 0> makeRefList(ArrayRef<uint64_t>Record);

1010SmallVector<FunctionSummary::EdgeTy, 0>

1011 makeCallList(ArrayRef<uint64_t>Record,bool IsOldProfileFormat,

1012bool HasProfile,bool HasRelBF);

1013Error parseEntireSummary(unsignedID);

1014Error parseModuleStringTable();

1015void parseTypeIdCompatibleVtableSummaryRecord(ArrayRef<uint64_t>Record);

1016void parseTypeIdCompatibleVtableInfo(ArrayRef<uint64_t>Record,size_t &Slot,

1017TypeIdCompatibleVtableInfo &TypeId);

1018 std::vector<FunctionSummary::ParamAccess>

1019 parseParamAccesses(ArrayRef<uint64_t>Record);

1020SmallVector<unsigned> parseAllocInfoContext(ArrayRef<uint64_t>Record,

1021unsigned &I);

1022

1023template <bool AllowNullValueInfo = false>

1024 std::pair<ValueInfo, GlobalValue::GUID>

1025 getValueInfoFromValueId(unsigned ValueId);

1026

1027void addThisModule();

1028ModuleSummaryIndex::ModuleInfo *getThisModule();

1029};

1030

1031}// end anonymous namespace

1032

1033std::error_codellvm::errorToErrorCodeAndEmitErrors(LLVMContext &Ctx,

1034Error Err) {

1035if (Err) {

1036 std::error_code EC;

1037handleAllErrors(std::move(Err), [&](ErrorInfoBase &EIB) {

1038 EC = EIB.convertToErrorCode();

1039 Ctx.emitError(EIB.message());

1040 });

1041return EC;

1042 }

1043return std::error_code();

1044}

1045

1046BitcodeReader::BitcodeReader(BitstreamCursor Stream,StringRef Strtab,

1047StringRef ProducerIdentification,

1048LLVMContext &Context)

1049 : BitcodeReaderBase(std::move(Stream), Strtab), Context(Context),

1050 ValueList(this->Stream.SizeInBytes(),

1051 [this](unsigned ValID,BasicBlock *InsertBB) {

1052return materializeValue(ValID, InsertBB);

1053 }) {

1054 this->ProducerIdentification = std::string(ProducerIdentification);

1055}

1056

1057Error BitcodeReader::materializeForwardReferencedFunctions() {

1058if (WillMaterializeAllForwardRefs)

1059returnError::success();

1060

1061// Prevent recursion.

1062 WillMaterializeAllForwardRefs =true;

1063

1064while (!BasicBlockFwdRefQueue.empty()) {

1065Function *F = BasicBlockFwdRefQueue.front();

1066 BasicBlockFwdRefQueue.pop_front();

1067assert(F &&"Expected valid function");

1068if (!BasicBlockFwdRefs.count(F))

1069// Already materialized.

1070continue;

1071

1072// Check for a function that isn't materializable to prevent an infinite

1073// loop. When parsing a blockaddress stored in a global variable, there

1074// isn't a trivial way to check if a function will have a body without a

1075// linear search through FunctionsWithBodies, so just check it here.

1076if (!F->isMaterializable())

1077returnerror("Never resolved function from blockaddress");

1078

1079// Try to materialize F.

1080if (Error Err = materialize(F))

1081return Err;

1082 }

1083assert(BasicBlockFwdRefs.empty() &&"Function missing from queue");

1084

1085for (Function *F : BackwardRefFunctions)

1086if (Error Err = materialize(F))

1087return Err;

1088 BackwardRefFunctions.clear();

1089

1090// Reset state.

1091 WillMaterializeAllForwardRefs =false;

1092returnError::success();

1093}

1094

1095//===----------------------------------------------------------------------===//

1096// Helper functions to implement forward reference resolution, etc.

1097//===----------------------------------------------------------------------===//

1098

1099staticboolhasImplicitComdat(size_t Val) {

1100switch (Val) {

1101default:

1102returnfalse;

1103case 1:// Old WeakAnyLinkage

1104case 4:// Old LinkOnceAnyLinkage

1105case 10:// Old WeakODRLinkage

1106case 11:// Old LinkOnceODRLinkage

1107returntrue;

1108 }

1109}

1110

1111staticGlobalValue::LinkageTypes getDecodedLinkage(unsigned Val) {

1112switch (Val) {

1113default:// Map unknown/new linkages to external

1114case 0:

1115returnGlobalValue::ExternalLinkage;

1116case 2:

1117returnGlobalValue::AppendingLinkage;

1118case 3:

1119returnGlobalValue::InternalLinkage;

1120case 5:

1121returnGlobalValue::ExternalLinkage;// Obsolete DLLImportLinkage

1122case 6:

1123returnGlobalValue::ExternalLinkage;// Obsolete DLLExportLinkage

1124case 7:

1125returnGlobalValue::ExternalWeakLinkage;

1126case 8:

1127returnGlobalValue::CommonLinkage;

1128case 9:

1129returnGlobalValue::PrivateLinkage;

1130case 12:

1131returnGlobalValue::AvailableExternallyLinkage;

1132case 13:

1133returnGlobalValue::PrivateLinkage;// Obsolete LinkerPrivateLinkage

1134case 14:

1135returnGlobalValue::PrivateLinkage;// Obsolete LinkerPrivateWeakLinkage

1136case 15:

1137returnGlobalValue::ExternalLinkage;// Obsolete LinkOnceODRAutoHideLinkage

1138case 1:// Old value with implicit comdat.

1139case 16:

1140returnGlobalValue::WeakAnyLinkage;

1141case 10:// Old value with implicit comdat.

1142case 17:

1143returnGlobalValue::WeakODRLinkage;

1144case 4:// Old value with implicit comdat.

1145case 18:

1146returnGlobalValue::LinkOnceAnyLinkage;

1147case 11:// Old value with implicit comdat.

1148case 19:

1149returnGlobalValue::LinkOnceODRLinkage;

1150 }

1151}

1152

1153staticFunctionSummary::FFlags getDecodedFFlags(uint64_t RawFlags) {

1154FunctionSummary::FFlags Flags;

1155 Flags.ReadNone = RawFlags & 0x1;

1156 Flags.ReadOnly = (RawFlags >> 1) & 0x1;

1157 Flags.NoRecurse = (RawFlags >> 2) & 0x1;

1158 Flags.ReturnDoesNotAlias = (RawFlags >> 3) & 0x1;

1159 Flags.NoInline = (RawFlags >> 4) & 0x1;

1160 Flags.AlwaysInline = (RawFlags >> 5) & 0x1;

1161 Flags.NoUnwind = (RawFlags >> 6) & 0x1;

1162 Flags.MayThrow = (RawFlags >> 7) & 0x1;

1163 Flags.HasUnknownCall = (RawFlags >> 8) & 0x1;

1164 Flags.MustBeUnreachable = (RawFlags >> 9) & 0x1;

1165return Flags;

1166}

1167

1168// Decode the flags for GlobalValue in the summary. The bits for each attribute:

1169//

1170// linkage: [0,4), notEligibleToImport: 4, live: 5, local: 6, canAutoHide: 7,

1171// visibility: [8, 10).

1172staticGlobalValueSummary::GVFlags getDecodedGVSummaryFlags(uint64_t RawFlags,

1173uint64_t Version) {

1174// Summary were not emitted before LLVM 3.9, we don't need to upgrade Linkage

1175// like getDecodedLinkage() above. Any future change to the linkage enum and

1176// to getDecodedLinkage() will need to be taken into account here as above.

1177auto Linkage =GlobalValue::LinkageTypes(RawFlags & 0xF);// 4 bits

1178auto Visibility =GlobalValue::VisibilityTypes((RawFlags >> 8) & 3);// 2 bits

1179auto IK =GlobalValueSummary::ImportKind((RawFlags >> 10) & 1);// 1 bit

1180 RawFlags = RawFlags >> 4;

1181bool NotEligibleToImport = (RawFlags & 0x1) || Version < 3;

1182// The Live flag wasn't introduced until version 3. For dead stripping

1183// to work correctly on earlier versions, we must conservatively treat all

1184// values as live.

1185boolLive = (RawFlags & 0x2) || Version < 3;

1186boolLocal = (RawFlags & 0x4);

1187bool AutoHide = (RawFlags & 0x8);

1188

1189returnGlobalValueSummary::GVFlags(Linkage, Visibility, NotEligibleToImport,

1190Live,Local, AutoHide, IK);

1191}

1192

1193// Decode the flags for GlobalVariable in the summary

1194staticGlobalVarSummary::GVarFlags getDecodedGVarFlags(uint64_t RawFlags) {

1195returnGlobalVarSummary::GVarFlags(

1196 (RawFlags & 0x1) ?true :false, (RawFlags & 0x2) ?true :false,

1197 (RawFlags & 0x4) ?true :false,

1198 (GlobalObject::VCallVisibility)(RawFlags >> 3));

1199}

1200

1201static std::pair<CalleeInfo::HotnessType, bool>

1202getDecodedHotnessCallEdgeInfo(uint64_t RawFlags) {

1203CalleeInfo::HotnessType Hotness =

1204static_cast<CalleeInfo::HotnessType>(RawFlags & 0x7);// 3 bits

1205bool HasTailCall = (RawFlags & 0x8);// 1 bit

1206return {Hotness, HasTailCall};

1207}

1208

1209staticvoidgetDecodedRelBFCallEdgeInfo(uint64_t RawFlags,uint64_t &RelBF,

1210bool &HasTailCall) {

1211staticconstexpruint64_t RelBlockFreqMask =

1212 (1 <<CalleeInfo::RelBlockFreqBits) - 1;

1213 RelBF = RawFlags & RelBlockFreqMask;// RelBlockFreqBits bits

1214 HasTailCall = (RawFlags & (1 <<CalleeInfo::RelBlockFreqBits));// 1 bit

1215}

1216

1217staticGlobalValue::VisibilityTypes getDecodedVisibility(unsigned Val) {

1218switch (Val) {

1219default:// Map unknown visibilities to default.

1220case 0:returnGlobalValue::DefaultVisibility;

1221case 1:returnGlobalValue::HiddenVisibility;

1222case 2:returnGlobalValue::ProtectedVisibility;

1223 }

1224}

1225

1226staticGlobalValue::DLLStorageClassTypes

1227getDecodedDLLStorageClass(unsigned Val) {

1228switch (Val) {

1229default:// Map unknown values to default.

1230case 0:returnGlobalValue::DefaultStorageClass;

1231case 1:returnGlobalValue::DLLImportStorageClass;

1232case 2:returnGlobalValue::DLLExportStorageClass;

1233 }

1234}

1235

1236staticboolgetDecodedDSOLocal(unsigned Val) {

1237switch(Val) {

1238default:// Map unknown values to preemptable.

1239case 0:returnfalse;

1240case 1:returntrue;

1241 }

1242}

1243

1244static std::optional<CodeModel::Model>getDecodedCodeModel(unsigned Val) {

1245switch (Val) {

1246case 1:

1247returnCodeModel::Tiny;

1248case 2:

1249returnCodeModel::Small;

1250case 3:

1251returnCodeModel::Kernel;

1252case 4:

1253returnCodeModel::Medium;

1254case 5:

1255returnCodeModel::Large;

1256 }

1257

1258return {};

1259}

1260

1261staticGlobalVariable::ThreadLocalMode getDecodedThreadLocalMode(unsigned Val) {

1262switch (Val) {

1263case 0:return GlobalVariable::NotThreadLocal;

1264default:// Map unknown non-zero value to general dynamic.

1265case 1:return GlobalVariable::GeneralDynamicTLSModel;

1266case 2:return GlobalVariable::LocalDynamicTLSModel;

1267case 3:return GlobalVariable::InitialExecTLSModel;

1268case 4:return GlobalVariable::LocalExecTLSModel;

1269 }

1270}

1271

1272staticGlobalVariable::UnnamedAddr getDecodedUnnamedAddrType(unsigned Val) {

1273switch (Val) {

1274default:// Map unknown to UnnamedAddr::None.

1275case 0:return GlobalVariable::UnnamedAddr::None;

1276case 1:return GlobalVariable::UnnamedAddr::Global;

1277case 2:return GlobalVariable::UnnamedAddr::Local;

1278 }

1279}

1280

1281staticintgetDecodedCastOpcode(unsigned Val) {

1282switch (Val) {

1283default:return -1;

1284casebitc::CAST_TRUNC :return Instruction::Trunc;

1285casebitc::CAST_ZEXT :return Instruction::ZExt;

1286casebitc::CAST_SEXT :return Instruction::SExt;

1287casebitc::CAST_FPTOUI :return Instruction::FPToUI;

1288casebitc::CAST_FPTOSI :return Instruction::FPToSI;

1289casebitc::CAST_UITOFP :return Instruction::UIToFP;

1290casebitc::CAST_SITOFP :return Instruction::SIToFP;

1291casebitc::CAST_FPTRUNC :return Instruction::FPTrunc;

1292casebitc::CAST_FPEXT :return Instruction::FPExt;

1293casebitc::CAST_PTRTOINT:return Instruction::PtrToInt;

1294casebitc::CAST_INTTOPTR:return Instruction::IntToPtr;

1295casebitc::CAST_BITCAST :return Instruction::BitCast;

1296casebitc::CAST_ADDRSPACECAST:return Instruction::AddrSpaceCast;

1297 }

1298}

1299

1300staticintgetDecodedUnaryOpcode(unsigned Val,Type *Ty) {

1301bool IsFP = Ty->isFPOrFPVectorTy();

1302// UnOps are only valid for int/fp or vector of int/fp types

1303if (!IsFP && !Ty->isIntOrIntVectorTy())

1304return -1;

1305

1306switch (Val) {

1307default:

1308return -1;

1309casebitc::UNOP_FNEG:

1310return IsFP ? Instruction::FNeg : -1;

1311 }

1312}

1313

1314staticintgetDecodedBinaryOpcode(unsigned Val,Type *Ty) {

1315bool IsFP = Ty->isFPOrFPVectorTy();

1316// BinOps are only valid for int/fp or vector of int/fp types

1317if (!IsFP && !Ty->isIntOrIntVectorTy())

1318return -1;

1319

1320switch (Val) {

1321default:

1322return -1;

1323casebitc::BINOP_ADD:

1324return IsFP ? Instruction::FAdd : Instruction::Add;

1325casebitc::BINOP_SUB:

1326return IsFP ? Instruction::FSub : Instruction::Sub;

1327casebitc::BINOP_MUL:

1328return IsFP ? Instruction::FMul : Instruction::Mul;

1329casebitc::BINOP_UDIV:

1330return IsFP ? -1 : Instruction::UDiv;

1331casebitc::BINOP_SDIV:

1332return IsFP ? Instruction::FDiv : Instruction::SDiv;

1333casebitc::BINOP_UREM:

1334return IsFP ? -1 : Instruction::URem;

1335casebitc::BINOP_SREM:

1336return IsFP ? Instruction::FRem : Instruction::SRem;

1337casebitc::BINOP_SHL:

1338return IsFP ? -1 : Instruction::Shl;

1339casebitc::BINOP_LSHR:

1340return IsFP ? -1 : Instruction::LShr;

1341casebitc::BINOP_ASHR:

1342return IsFP ? -1 : Instruction::AShr;

1343casebitc::BINOP_AND:

1344return IsFP ? -1 : Instruction::And;

1345casebitc::BINOP_OR:

1346return IsFP ? -1 : Instruction::Or;

1347casebitc::BINOP_XOR:

1348return IsFP ? -1 : Instruction::Xor;

1349 }

1350}

1351

1352staticAtomicRMWInst::BinOp getDecodedRMWOperation(unsigned Val) {

1353switch (Val) {

1354default:returnAtomicRMWInst::BAD_BINOP;

1355casebitc::RMW_XCHG:returnAtomicRMWInst::Xchg;

1356casebitc::RMW_ADD:returnAtomicRMWInst::Add;

1357casebitc::RMW_SUB:returnAtomicRMWInst::Sub;

1358casebitc::RMW_AND:returnAtomicRMWInst::And;

1359casebitc::RMW_NAND:returnAtomicRMWInst::Nand;

1360casebitc::RMW_OR:returnAtomicRMWInst::Or;

1361casebitc::RMW_XOR:returnAtomicRMWInst::Xor;

1362casebitc::RMW_MAX:returnAtomicRMWInst::Max;

1363casebitc::RMW_MIN:returnAtomicRMWInst::Min;

1364casebitc::RMW_UMAX:returnAtomicRMWInst::UMax;

1365casebitc::RMW_UMIN:returnAtomicRMWInst::UMin;

1366casebitc::RMW_FADD:returnAtomicRMWInst::FAdd;

1367casebitc::RMW_FSUB:returnAtomicRMWInst::FSub;

1368casebitc::RMW_FMAX:returnAtomicRMWInst::FMax;

1369casebitc::RMW_FMIN:returnAtomicRMWInst::FMin;

1370casebitc::RMW_UINC_WRAP:

1371returnAtomicRMWInst::UIncWrap;

1372casebitc::RMW_UDEC_WRAP:

1373returnAtomicRMWInst::UDecWrap;

1374casebitc::RMW_USUB_COND:

1375returnAtomicRMWInst::USubCond;

1376casebitc::RMW_USUB_SAT:

1377returnAtomicRMWInst::USubSat;

1378 }

1379}

1380

1381staticAtomicOrdering getDecodedOrdering(unsigned Val) {

1382switch (Val) {

1383casebitc::ORDERING_NOTATOMIC:return AtomicOrdering::NotAtomic;

1384casebitc::ORDERING_UNORDERED:return AtomicOrdering::Unordered;

1385casebitc::ORDERING_MONOTONIC:return AtomicOrdering::Monotonic;

1386casebitc::ORDERING_ACQUIRE:return AtomicOrdering::Acquire;

1387casebitc::ORDERING_RELEASE:return AtomicOrdering::Release;

1388casebitc::ORDERING_ACQREL:return AtomicOrdering::AcquireRelease;

1389default:// Map unknown orderings to sequentially-consistent.

1390casebitc::ORDERING_SEQCST:return AtomicOrdering::SequentiallyConsistent;

1391 }

1392}

1393

1394staticComdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val) {

1395switch (Val) {

1396default:// Map unknown selection kinds to any.

1397casebitc::COMDAT_SELECTION_KIND_ANY:

1398returnComdat::Any;

1399casebitc::COMDAT_SELECTION_KIND_EXACT_MATCH:

1400returnComdat::ExactMatch;

1401casebitc::COMDAT_SELECTION_KIND_LARGEST:

1402returnComdat::Largest;

1403casebitc::COMDAT_SELECTION_KIND_NO_DUPLICATES:

1404returnComdat::NoDeduplicate;

1405casebitc::COMDAT_SELECTION_KIND_SAME_SIZE:

1406returnComdat::SameSize;

1407 }

1408}

1409

1410staticFastMathFlags getDecodedFastMathFlags(unsigned Val) {

1411FastMathFlags FMF;

1412if (0 != (Val &bitc::UnsafeAlgebra))

1413 FMF.setFast();

1414if (0 != (Val &bitc::AllowReassoc))

1415 FMF.setAllowReassoc();

1416if (0 != (Val &bitc::NoNaNs))

1417 FMF.setNoNaNs();

1418if (0 != (Val &bitc::NoInfs))

1419 FMF.setNoInfs();

1420if (0 != (Val &bitc::NoSignedZeros))

1421 FMF.setNoSignedZeros();

1422if (0 != (Val &bitc::AllowReciprocal))

1423 FMF.setAllowReciprocal();

1424if (0 != (Val &bitc::AllowContract))

1425 FMF.setAllowContract(true);

1426if (0 != (Val &bitc::ApproxFunc))

1427 FMF.setApproxFunc();

1428return FMF;

1429}

1430

1431staticvoidupgradeDLLImportExportLinkage(GlobalValue *GV,unsigned Val) {

1432// A GlobalValue with local linkage cannot have a DLL storage class.

1433if (GV->hasLocalLinkage())

1434return;

1435switch (Val) {

1436case 5: GV->setDLLStorageClass(GlobalValue::DLLImportStorageClass);break;

1437case 6: GV->setDLLStorageClass(GlobalValue::DLLExportStorageClass);break;

1438 }

1439}

1440

1441Type *BitcodeReader::getTypeByID(unsignedID) {

1442// The type table size is always specified correctly.

1443if (ID >= TypeList.size())

1444returnnullptr;

1445

1446if (Type *Ty = TypeList[ID])

1447return Ty;

1448

1449// If we have a forward reference, the only possible case is when it is to a

1450// named struct. Just create a placeholder for now.

1451return TypeList[ID] = createIdentifiedStructType(Context);

1452}

1453

1454unsigned BitcodeReader::getContainedTypeID(unsignedID,unsignedIdx) {

1455auto It = ContainedTypeIDs.find(ID);

1456if (It == ContainedTypeIDs.end())

1457return InvalidTypeID;

1458

1459if (Idx >= It->second.size())

1460return InvalidTypeID;

1461

1462return It->second[Idx];

1463}

1464

1465Type *BitcodeReader::getPtrElementTypeByID(unsignedID) {

1466if (ID >= TypeList.size())

1467returnnullptr;

1468

1469Type *Ty = TypeList[ID];

1470if (!Ty->isPointerTy())

1471returnnullptr;

1472

1473return getTypeByID(getContainedTypeID(ID, 0));

1474}

1475

1476unsigned BitcodeReader::getVirtualTypeID(Type *Ty,

1477ArrayRef<unsigned> ChildTypeIDs) {

1478unsigned ChildTypeID = ChildTypeIDs.empty() ? InvalidTypeID : ChildTypeIDs[0];

1479auto CacheKey = std::make_pair(Ty, ChildTypeID);

1480auto It = VirtualTypeIDs.find(CacheKey);

1481if (It != VirtualTypeIDs.end()) {

1482// The cmpxchg return value is the only place we need more than one

1483// contained type ID, however the second one will always be the same (i1),

1484// so we don't need to include it in the cache key. This asserts that the

1485// contained types are indeed as expected and there are no collisions.

1486assert((ChildTypeIDs.empty() ||

1487 ContainedTypeIDs[It->second] == ChildTypeIDs) &&

1488"Incorrect cached contained type IDs");

1489return It->second;

1490 }

1491

1492unsignedTypeID = TypeList.size();

1493 TypeList.push_back(Ty);

1494if (!ChildTypeIDs.empty())

1495append_range(ContainedTypeIDs[TypeID], ChildTypeIDs);

1496 VirtualTypeIDs.insert({CacheKey,TypeID});

1497returnTypeID;

1498}

1499

1500staticGEPNoWrapFlags toGEPNoWrapFlags(uint64_t Flags) {

1501GEPNoWrapFlags NW;

1502if (Flags & (1 <<bitc::GEP_INBOUNDS))

1503 NW |=GEPNoWrapFlags::inBounds();

1504if (Flags & (1 <<bitc::GEP_NUSW))

1505 NW |=GEPNoWrapFlags::noUnsignedSignedWrap();

1506if (Flags & (1 <<bitc::GEP_NUW))

1507 NW |=GEPNoWrapFlags::noUnsignedWrap();

1508return NW;

1509}

1510

1511staticboolisConstExprSupported(const BitcodeConstant *BC) {

1512uint8_t Opcode = BC->Opcode;

1513

1514// These are not real constant expressions, always consider them supported.

1515if (Opcode >= BitcodeConstant::FirstSpecialOpcode)

1516returntrue;

1517

1518// If -expand-constant-exprs is set, we want to consider all expressions

1519// as unsupported.

1520if (ExpandConstantExprs)

1521returnfalse;

1522

1523if (Instruction::isBinaryOp(Opcode))

1524returnConstantExpr::isSupportedBinOp(Opcode);

1525

1526if (Instruction::isCast(Opcode))

1527returnConstantExpr::isSupportedCastOp(Opcode);

1528

1529if (Opcode == Instruction::GetElementPtr)

1530returnConstantExpr::isSupportedGetElementPtr(BC->SrcElemTy);

1531

1532switch (Opcode) {

1533case Instruction::FNeg:

1534case Instruction::Select:

1535case Instruction::ICmp:

1536case Instruction::FCmp:

1537returnfalse;

1538default:

1539returntrue;

1540 }

1541}

1542

1543Expected<Value *> BitcodeReader::materializeValue(unsigned StartValID,

1544BasicBlock *InsertBB) {

1545// Quickly handle the case where there is no BitcodeConstant to resolve.

1546if (StartValID < ValueList.size() && ValueList[StartValID] &&

1547 !isa<BitcodeConstant>(ValueList[StartValID]))

1548return ValueList[StartValID];

1549

1550SmallDenseMap<unsigned, Value *> MaterializedValues;

1551SmallVector<unsigned> Worklist;

1552 Worklist.push_back(StartValID);

1553while (!Worklist.empty()) {

1554unsignedValID = Worklist.back();

1555if (MaterializedValues.count(ValID)) {

1556// Duplicate expression that was already handled.

1557 Worklist.pop_back();

1558continue;

1559 }

1560

1561if (ValID >= ValueList.size() || !ValueList[ValID])

1562returnerror("Invalid value ID");

1563

1564Value *V = ValueList[ValID];

1565auto *BC = dyn_cast<BitcodeConstant>(V);

1566if (!BC) {

1567 MaterializedValues.insert({ValID,V});

1568 Worklist.pop_back();

1569continue;

1570 }

1571

1572// Iterate in reverse, so values will get popped from the worklist in

1573// expected order.

1574SmallVector<Value *> Ops;

1575for (unsigned OpID :reverse(BC->getOperandIDs())) {

1576auto It = MaterializedValues.find(OpID);

1577if (It != MaterializedValues.end())

1578 Ops.push_back(It->second);

1579else

1580 Worklist.push_back(OpID);

1581 }

1582

1583// Some expressions have not been resolved yet, handle them first and then

1584// revisit this one.

1585if (Ops.size() != BC->getOperandIDs().size())

1586continue;

1587 std::reverse(Ops.begin(), Ops.end());

1588

1589SmallVector<Constant *> ConstOps;

1590for (Value *Op : Ops)

1591if (auto *C = dyn_cast<Constant>(Op))

1592 ConstOps.push_back(C);

1593

1594// Materialize as constant expression if possible.

1595if (isConstExprSupported(BC) && ConstOps.size() == Ops.size()) {

1596Constant *C;

1597if (Instruction::isCast(BC->Opcode)) {

1598C =UpgradeBitCastExpr(BC->Opcode, ConstOps[0], BC->getType());

1599if (!C)

1600C =ConstantExpr::getCast(BC->Opcode, ConstOps[0], BC->getType());

1601 }elseif (Instruction::isBinaryOp(BC->Opcode)) {

1602C =ConstantExpr::get(BC->Opcode, ConstOps[0], ConstOps[1], BC->Flags);

1603 }else {

1604switch (BC->Opcode) {

1605case BitcodeConstant::ConstantPtrAuthOpcode: {

1606auto *Key = dyn_cast<ConstantInt>(ConstOps[1]);

1607if (!Key)

1608returnerror("ptrauth key operand must be ConstantInt");

1609

1610auto *Disc = dyn_cast<ConstantInt>(ConstOps[2]);

1611if (!Disc)

1612returnerror("ptrauth disc operand must be ConstantInt");

1613

1614C =ConstantPtrAuth::get(ConstOps[0], Key, Disc, ConstOps[3]);

1615break;

1616 }

1617case BitcodeConstant::NoCFIOpcode: {

1618auto *GV = dyn_cast<GlobalValue>(ConstOps[0]);

1619if (!GV)

1620returnerror("no_cfi operand must be GlobalValue");

1621C =NoCFIValue::get(GV);

1622break;

1623 }

1624case BitcodeConstant::DSOLocalEquivalentOpcode: {

1625auto *GV = dyn_cast<GlobalValue>(ConstOps[0]);

1626if (!GV)

1627returnerror("dso_local operand must be GlobalValue");

1628C =DSOLocalEquivalent::get(GV);

1629break;

1630 }

1631case BitcodeConstant::BlockAddressOpcode: {

1632Function *Fn = dyn_cast<Function>(ConstOps[0]);

1633if (!Fn)

1634returnerror("blockaddress operand must be a function");

1635

1636// If the function is already parsed we can insert the block address

1637// right away.

1638BasicBlock *BB;

1639unsigned BBID = BC->BlockAddressBB;

1640if (!BBID)

1641// Invalid reference to entry block.

1642returnerror("Invalid ID");

1643if (!Fn->empty()) {

1644Function::iterator BBI = Fn->begin(), BBE = Fn->end();

1645for (size_tI = 0, E = BBID;I != E; ++I) {

1646if (BBI == BBE)

1647returnerror("Invalid ID");

1648 ++BBI;

1649 }

1650 BB = &*BBI;

1651 }else {

1652// Otherwise insert a placeholder and remember it so it can be

1653// inserted when the function is parsed.

1654auto &FwdBBs = BasicBlockFwdRefs[Fn];

1655if (FwdBBs.empty())

1656 BasicBlockFwdRefQueue.push_back(Fn);

1657if (FwdBBs.size() < BBID + 1)

1658 FwdBBs.resize(BBID + 1);

1659if (!FwdBBs[BBID])

1660 FwdBBs[BBID] =BasicBlock::Create(Context);

1661 BB = FwdBBs[BBID];

1662 }

1663C =BlockAddress::get(Fn, BB);

1664break;

1665 }

1666case BitcodeConstant::ConstantStructOpcode: {

1667auto *ST = cast<StructType>(BC->getType());

1668if (ST->getNumElements() != ConstOps.size())

1669returnerror("Invalid number of elements in struct initializer");

1670

1671for (constauto [Ty,Op] :zip(ST->elements(), ConstOps))

1672if (Op->getType() != Ty)

1673returnerror("Incorrect type in struct initializer");

1674

1675C =ConstantStruct::get(ST, ConstOps);

1676break;

1677 }

1678case BitcodeConstant::ConstantArrayOpcode: {

1679auto *AT = cast<ArrayType>(BC->getType());

1680if (AT->getNumElements() != ConstOps.size())

1681returnerror("Invalid number of elements in array initializer");

1682

1683for (Constant *Op : ConstOps)

1684if (Op->getType() != AT->getElementType())

1685returnerror("Incorrect type in array initializer");

1686

1687C =ConstantArray::get(AT, ConstOps);

1688break;

1689 }

1690case BitcodeConstant::ConstantVectorOpcode: {

1691auto *VT = cast<FixedVectorType>(BC->getType());

1692if (VT->getNumElements() != ConstOps.size())

1693returnerror("Invalid number of elements in vector initializer");

1694

1695for (Constant *Op : ConstOps)

1696if (Op->getType() != VT->getElementType())

1697returnerror("Incorrect type in vector initializer");

1698

1699C =ConstantVector::get(ConstOps);

1700break;

1701 }

1702case Instruction::GetElementPtr:

1703C =ConstantExpr::getGetElementPtr(

1704 BC->SrcElemTy, ConstOps[0],ArrayRef(ConstOps).drop_front(),

1705toGEPNoWrapFlags(BC->Flags), BC->getInRange());

1706break;

1707case Instruction::ExtractElement:

1708C =ConstantExpr::getExtractElement(ConstOps[0], ConstOps[1]);

1709break;

1710case Instruction::InsertElement:

1711C =ConstantExpr::getInsertElement(ConstOps[0], ConstOps[1],

1712 ConstOps[2]);

1713break;

1714case Instruction::ShuffleVector: {

1715SmallVector<int, 16>Mask;

1716ShuffleVectorInst::getShuffleMask(ConstOps[2], Mask);

1717C =ConstantExpr::getShuffleVector(ConstOps[0], ConstOps[1], Mask);

1718break;

1719 }

1720default:

1721llvm_unreachable("Unhandled bitcode constant");

1722 }

1723 }

1724

1725// Cache resolved constant.

1726 ValueList.replaceValueWithoutRAUW(ValID,C);

1727 MaterializedValues.insert({ValID,C});

1728 Worklist.pop_back();

1729continue;

1730 }

1731

1732if (!InsertBB)

1733returnerror(Twine("Value referenced by initializer is an unsupported "

1734"constant expression of type ") +

1735 BC->getOpcodeName());

1736

1737// Materialize as instructions if necessary.

1738Instruction *I;

1739if (Instruction::isCast(BC->Opcode)) {

1740I =CastInst::Create((Instruction::CastOps)BC->Opcode, Ops[0],

1741 BC->getType(),"constexpr", InsertBB);

1742 }elseif (Instruction::isUnaryOp(BC->Opcode)) {

1743I =UnaryOperator::Create((Instruction::UnaryOps)BC->Opcode, Ops[0],

1744"constexpr", InsertBB);

1745 }elseif (Instruction::isBinaryOp(BC->Opcode)) {

1746I =BinaryOperator::Create((Instruction::BinaryOps)BC->Opcode, Ops[0],

1747 Ops[1],"constexpr", InsertBB);

1748if (isa<OverflowingBinaryOperator>(I)) {

1749if (BC->Flags &OverflowingBinaryOperator::NoSignedWrap)

1750I->setHasNoSignedWrap();

1751if (BC->Flags &OverflowingBinaryOperator::NoUnsignedWrap)

1752I->setHasNoUnsignedWrap();

1753 }

1754if (isa<PossiblyExactOperator>(I) &&

1755 (BC->Flags &PossiblyExactOperator::IsExact))

1756I->setIsExact();

1757 }else {

1758switch (BC->Opcode) {

1759case BitcodeConstant::ConstantVectorOpcode: {

1760Type *IdxTy =Type::getInt32Ty(BC->getContext());

1761Value *V =PoisonValue::get(BC->getType());

1762for (auto Pair :enumerate(Ops)) {

1763Value *Idx = ConstantInt::get(IdxTy, Pair.index());

1764V =InsertElementInst::Create(V, Pair.value(),Idx,"constexpr.ins",

1765 InsertBB);

1766 }

1767I = cast<Instruction>(V);

1768break;

1769 }

1770case BitcodeConstant::ConstantStructOpcode:

1771case BitcodeConstant::ConstantArrayOpcode: {

1772Value *V =PoisonValue::get(BC->getType());

1773for (auto Pair :enumerate(Ops))

1774V =InsertValueInst::Create(V, Pair.value(), Pair.index(),

1775"constexpr.ins", InsertBB);

1776I = cast<Instruction>(V);

1777break;

1778 }

1779case Instruction::ICmp:

1780case Instruction::FCmp:

1781I =CmpInst::Create((Instruction::OtherOps)BC->Opcode,

1782 (CmpInst::Predicate)BC->Flags, Ops[0], Ops[1],

1783"constexpr", InsertBB);

1784break;

1785case Instruction::GetElementPtr:

1786I =GetElementPtrInst::Create(BC->SrcElemTy, Ops[0],

1787ArrayRef(Ops).drop_front(),"constexpr",

1788 InsertBB);

1789 cast<GetElementPtrInst>(I)->setNoWrapFlags(toGEPNoWrapFlags(BC->Flags));

1790break;

1791case Instruction::Select:

1792I =SelectInst::Create(Ops[0], Ops[1], Ops[2],"constexpr", InsertBB);

1793break;

1794case Instruction::ExtractElement:

1795I =ExtractElementInst::Create(Ops[0], Ops[1],"constexpr", InsertBB);

1796break;

1797case Instruction::InsertElement:

1798I =InsertElementInst::Create(Ops[0], Ops[1], Ops[2],"constexpr",

1799 InsertBB);

1800break;

1801case Instruction::ShuffleVector:

1802I =newShuffleVectorInst(Ops[0], Ops[1], Ops[2],"constexpr",

1803 InsertBB);

1804break;

1805default:

1806llvm_unreachable("Unhandled bitcode constant");

1807 }

1808 }

1809

1810 MaterializedValues.insert({ValID,I});

1811 Worklist.pop_back();

1812 }

1813

1814return MaterializedValues[StartValID];

1815}

1816

1817Expected<Constant *> BitcodeReader::getValueForInitializer(unsignedID) {

1818Expected<Value *> MaybeV = materializeValue(ID,/* InsertBB */nullptr);

1819if (!MaybeV)

1820return MaybeV.takeError();

1821

1822// Result must be Constant if InsertBB is nullptr.

1823return cast<Constant>(MaybeV.get());

1824}

1825

1826StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context,

1827StringRef Name) {

1828auto *Ret =StructType::create(Context,Name);

1829 IdentifiedStructTypes.push_back(Ret);

1830returnRet;

1831}

1832

1833StructType *BitcodeReader::createIdentifiedStructType(LLVMContext &Context) {

1834auto *Ret =StructType::create(Context);

1835 IdentifiedStructTypes.push_back(Ret);

1836returnRet;

1837}

1838

1839//===----------------------------------------------------------------------===//

1840// Functions for parsing blocks from the bitcode file

1841//===----------------------------------------------------------------------===//

1842

1843staticuint64_t getRawAttributeMask(Attribute::AttrKind Val) {

1844switch (Val) {

1845caseAttribute::EndAttrKinds:

1846caseAttribute::EmptyKey:

1847caseAttribute::TombstoneKey:

1848llvm_unreachable("Synthetic enumerators which should never get here");

1849

1850caseAttribute::None:return 0;

1851case Attribute::ZExt:return 1 << 0;

1852case Attribute::SExt:return 1 << 1;

1853case Attribute::NoReturn:return 1 << 2;

1854case Attribute::InReg:return 1 << 3;

1855case Attribute::StructRet:return 1 << 4;

1856case Attribute::NoUnwind:return 1 << 5;

1857case Attribute::NoAlias:return 1 << 6;

1858case Attribute::ByVal:return 1 << 7;

1859case Attribute::Nest:return 1 << 8;

1860case Attribute::ReadNone:return 1 << 9;

1861case Attribute::ReadOnly:return 1 << 10;

1862case Attribute::NoInline:return 1 << 11;

1863case Attribute::AlwaysInline:return 1 << 12;

1864case Attribute::OptimizeForSize:return 1 << 13;

1865case Attribute::StackProtect:return 1 << 14;

1866case Attribute::StackProtectReq:return 1 << 15;

1867case Attribute::Alignment:return 31 << 16;

1868case Attribute::NoCapture:return 1 << 21;

1869case Attribute::NoRedZone:return 1 << 22;

1870case Attribute::NoImplicitFloat:return 1 << 23;

1871case Attribute::Naked:return 1 << 24;

1872case Attribute::InlineHint:return 1 << 25;

1873case Attribute::StackAlignment:return 7 << 26;

1874case Attribute::ReturnsTwice:return 1 << 29;

1875case Attribute::UWTable:return 1 << 30;

1876case Attribute::NonLazyBind:return 1U << 31;

1877case Attribute::SanitizeAddress:return 1ULL << 32;

1878case Attribute::MinSize:return 1ULL << 33;

1879case Attribute::NoDuplicate:return 1ULL << 34;

1880case Attribute::StackProtectStrong:return 1ULL << 35;

1881case Attribute::SanitizeThread:return 1ULL << 36;

1882case Attribute::SanitizeMemory:return 1ULL << 37;

1883case Attribute::NoBuiltin:return 1ULL << 38;

1884case Attribute::Returned:return 1ULL << 39;

1885case Attribute::Cold:return 1ULL << 40;

1886case Attribute::Builtin:return 1ULL << 41;

1887case Attribute::OptimizeNone:return 1ULL << 42;

1888case Attribute::InAlloca:return 1ULL << 43;

1889case Attribute::NonNull:return 1ULL << 44;

1890case Attribute::JumpTable:return 1ULL << 45;

1891case Attribute::Convergent:return 1ULL << 46;

1892case Attribute::SafeStack:return 1ULL << 47;

1893case Attribute::NoRecurse:return 1ULL << 48;

1894// 1ULL << 49 is InaccessibleMemOnly, which is upgraded separately.

1895// 1ULL << 50 is InaccessibleMemOrArgMemOnly, which is upgraded separately.

1896case Attribute::SwiftSelf:return 1ULL << 51;

1897case Attribute::SwiftError:return 1ULL << 52;

1898case Attribute::WriteOnly:return 1ULL << 53;

1899case Attribute::Speculatable:return 1ULL << 54;

1900case Attribute::StrictFP:return 1ULL << 55;

1901case Attribute::SanitizeHWAddress:return 1ULL << 56;

1902case Attribute::NoCfCheck:return 1ULL << 57;

1903case Attribute::OptForFuzzing:return 1ULL << 58;

1904case Attribute::ShadowCallStack:return 1ULL << 59;

1905case Attribute::SpeculativeLoadHardening:

1906return 1ULL << 60;

1907case Attribute::ImmArg:

1908return 1ULL << 61;

1909case Attribute::WillReturn:

1910return 1ULL << 62;

1911case Attribute::NoFree:

1912return 1ULL << 63;

1913default:

1914// Other attributes are not supported in the raw format,

1915// as we ran out of space.

1916return 0;

1917 }

1918llvm_unreachable("Unsupported attribute type");

1919}

1920

1921staticvoidaddRawAttributeValue(AttrBuilder &B,uint64_t Val) {

1922if (!Val)return;

1923

1924for (Attribute::AttrKind I =Attribute::None;I !=Attribute::EndAttrKinds;

1925I =Attribute::AttrKind(I + 1)) {

1926if (uint64_t A = (Val &getRawAttributeMask(I))) {

1927if (I == Attribute::Alignment)

1928B.addAlignmentAttr(1ULL << ((A >> 16) - 1));

1929elseif (I == Attribute::StackAlignment)

1930B.addStackAlignmentAttr(1ULL << ((A >> 26)-1));

1931elseif (Attribute::isTypeAttrKind(I))

1932B.addTypeAttr(I,nullptr);// Type will be auto-upgraded.

1933else

1934B.addAttribute(I);

1935 }

1936 }

1937}

1938

1939/// This fills an AttrBuilder object with the LLVM attributes that have

1940/// been decoded from the given integer. This function must stay in sync with

1941/// 'encodeLLVMAttributesForBitcode'.

1942staticvoiddecodeLLVMAttributesForBitcode(AttrBuilder &B,

1943uint64_t EncodedAttrs,

1944uint64_t AttrIdx) {

1945// The alignment is stored as a 16-bit raw value from bits 31--16. We shift

1946// the bits above 31 down by 11 bits.

1947unsigned Alignment = (EncodedAttrs & (0xffffULL << 16)) >> 16;

1948assert((!Alignment ||isPowerOf2_32(Alignment)) &&

1949"Alignment must be a power of two.");

1950

1951if (Alignment)

1952B.addAlignmentAttr(Alignment);

1953

1954uint64_t Attrs = ((EncodedAttrs & (0xfffffULL << 32)) >> 11) |

1955 (EncodedAttrs & 0xffff);

1956

1957if (AttrIdx ==AttributeList::FunctionIndex) {

1958// Upgrade old memory attributes.

1959MemoryEffects ME =MemoryEffects::unknown();

1960if (Attrs & (1ULL << 9)) {

1961// ReadNone

1962 Attrs &= ~(1ULL << 9);

1963 ME &=MemoryEffects::none();

1964 }

1965if (Attrs & (1ULL << 10)) {

1966// ReadOnly

1967 Attrs &= ~(1ULL << 10);

1968 ME &=MemoryEffects::readOnly();

1969 }

1970if (Attrs & (1ULL << 49)) {

1971// InaccessibleMemOnly

1972 Attrs &= ~(1ULL << 49);

1973 ME &=MemoryEffects::inaccessibleMemOnly();

1974 }

1975if (Attrs & (1ULL << 50)) {

1976// InaccessibleMemOrArgMemOnly

1977 Attrs &= ~(1ULL << 50);

1978 ME &=MemoryEffects::inaccessibleOrArgMemOnly();

1979 }

1980if (Attrs & (1ULL << 53)) {

1981// WriteOnly

1982 Attrs &= ~(1ULL << 53);

1983 ME &=MemoryEffects::writeOnly();

1984 }

1985if (ME !=MemoryEffects::unknown())

1986B.addMemoryAttr(ME);

1987 }

1988

1989addRawAttributeValue(B, Attrs);

1990}

1991

1992Error BitcodeReader::parseAttributeBlock() {

1993if (Error Err = Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))

1994return Err;

1995

1996if (!MAttributes.empty())

1997returnerror("Invalid multiple blocks");

1998

1999SmallVector<uint64_t, 64>Record;

2000

2001SmallVector<AttributeList, 8>Attrs;

2002

2003// Read all the records.

2004while (true) {

2005Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

2006if (!MaybeEntry)

2007return MaybeEntry.takeError();

2008BitstreamEntry Entry = MaybeEntry.get();

2009

2010switch (Entry.Kind) {

2011caseBitstreamEntry::SubBlock:// Handled for us already.

2012caseBitstreamEntry::Error:

2013returnerror("Malformed block");

2014caseBitstreamEntry::EndBlock:

2015returnError::success();

2016caseBitstreamEntry::Record:

2017// The interesting case.

2018break;

2019 }

2020

2021// Read a record.

2022Record.clear();

2023Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

2024if (!MaybeRecord)

2025return MaybeRecord.takeError();

2026switch (MaybeRecord.get()) {

2027default:// Default behavior: ignore.

2028break;

2029casebitc::PARAMATTR_CODE_ENTRY_OLD:// ENTRY: [paramidx0, attr0, ...]

2030// Deprecated, but still needed to read old bitcode files.

2031if (Record.size() & 1)

2032returnerror("Invalid parameter attribute record");

2033

2034for (unsigned i = 0, e =Record.size(); i != e; i += 2) {

2035AttrBuilder B(Context);

2036decodeLLVMAttributesForBitcode(B,Record[i+1],Record[i]);

2037Attrs.push_back(AttributeList::get(Context,Record[i],B));

2038 }

2039

2040 MAttributes.push_back(AttributeList::get(Context, Attrs));

2041Attrs.clear();

2042break;

2043casebitc::PARAMATTR_CODE_ENTRY:// ENTRY: [attrgrp0, attrgrp1, ...]

2044for (uint64_t Val :Record)

2045Attrs.push_back(MAttributeGroups[Val]);

2046

2047 MAttributes.push_back(AttributeList::get(Context, Attrs));

2048Attrs.clear();

2049break;

2050 }

2051 }

2052}

2053

2054// Returns Attribute::None on unrecognized codes.

2055staticAttribute::AttrKind getAttrFromCode(uint64_t Code) {

2056switch (Code) {

2057default:

2058returnAttribute::None;

2059casebitc::ATTR_KIND_ALIGNMENT:

2060return Attribute::Alignment;

2061casebitc::ATTR_KIND_ALWAYS_INLINE:

2062return Attribute::AlwaysInline;

2063casebitc::ATTR_KIND_BUILTIN:

2064return Attribute::Builtin;

2065casebitc::ATTR_KIND_BY_VAL:

2066return Attribute::ByVal;

2067casebitc::ATTR_KIND_IN_ALLOCA:

2068return Attribute::InAlloca;

2069casebitc::ATTR_KIND_COLD:

2070return Attribute::Cold;

2071casebitc::ATTR_KIND_CONVERGENT:

2072return Attribute::Convergent;

2073casebitc::ATTR_KIND_DISABLE_SANITIZER_INSTRUMENTATION:

2074return Attribute::DisableSanitizerInstrumentation;

2075casebitc::ATTR_KIND_ELEMENTTYPE:

2076return Attribute::ElementType;

2077casebitc::ATTR_KIND_FNRETTHUNK_EXTERN:

2078return Attribute::FnRetThunkExtern;

2079casebitc::ATTR_KIND_INLINE_HINT:

2080return Attribute::InlineHint;

2081casebitc::ATTR_KIND_IN_REG:

2082return Attribute::InReg;

2083casebitc::ATTR_KIND_JUMP_TABLE:

2084return Attribute::JumpTable;

2085casebitc::ATTR_KIND_MEMORY:

2086return Attribute::Memory;

2087casebitc::ATTR_KIND_NOFPCLASS:

2088return Attribute::NoFPClass;

2089casebitc::ATTR_KIND_MIN_SIZE:

2090return Attribute::MinSize;

2091casebitc::ATTR_KIND_NAKED:

2092return Attribute::Naked;

2093casebitc::ATTR_KIND_NEST:

2094return Attribute::Nest;

2095casebitc::ATTR_KIND_NO_ALIAS:

2096return Attribute::NoAlias;

2097casebitc::ATTR_KIND_NO_BUILTIN:

2098return Attribute::NoBuiltin;

2099casebitc::ATTR_KIND_NO_CALLBACK:

2100return Attribute::NoCallback;

2101casebitc::ATTR_KIND_NO_CAPTURE:

2102return Attribute::NoCapture;

2103casebitc::ATTR_KIND_NO_DIVERGENCE_SOURCE:

2104return Attribute::NoDivergenceSource;

2105casebitc::ATTR_KIND_NO_DUPLICATE:

2106return Attribute::NoDuplicate;

2107casebitc::ATTR_KIND_NOFREE:

2108return Attribute::NoFree;

2109casebitc::ATTR_KIND_NO_IMPLICIT_FLOAT:

2110return Attribute::NoImplicitFloat;

2111casebitc::ATTR_KIND_NO_INLINE:

2112return Attribute::NoInline;

2113casebitc::ATTR_KIND_NO_RECURSE:

2114return Attribute::NoRecurse;

2115casebitc::ATTR_KIND_NO_MERGE:

2116return Attribute::NoMerge;

2117casebitc::ATTR_KIND_NON_LAZY_BIND:

2118return Attribute::NonLazyBind;

2119casebitc::ATTR_KIND_NON_NULL:

2120return Attribute::NonNull;

2121casebitc::ATTR_KIND_DEREFERENCEABLE:

2122return Attribute::Dereferenceable;

2123casebitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL:

2124return Attribute::DereferenceableOrNull;

2125casebitc::ATTR_KIND_ALLOC_ALIGN:

2126return Attribute::AllocAlign;

2127casebitc::ATTR_KIND_ALLOC_KIND:

2128return Attribute::AllocKind;

2129casebitc::ATTR_KIND_ALLOC_SIZE:

2130return Attribute::AllocSize;

2131casebitc::ATTR_KIND_ALLOCATED_POINTER:

2132return Attribute::AllocatedPointer;

2133casebitc::ATTR_KIND_NO_RED_ZONE:

2134return Attribute::NoRedZone;

2135casebitc::ATTR_KIND_NO_RETURN:

2136return Attribute::NoReturn;

2137casebitc::ATTR_KIND_NOSYNC:

2138return Attribute::NoSync;

2139casebitc::ATTR_KIND_NOCF_CHECK:

2140return Attribute::NoCfCheck;

2141casebitc::ATTR_KIND_NO_PROFILE:

2142return Attribute::NoProfile;

2143casebitc::ATTR_KIND_SKIP_PROFILE:

2144return Attribute::SkipProfile;

2145casebitc::ATTR_KIND_NO_UNWIND:

2146return Attribute::NoUnwind;

2147casebitc::ATTR_KIND_NO_SANITIZE_BOUNDS:

2148return Attribute::NoSanitizeBounds;

2149casebitc::ATTR_KIND_NO_SANITIZE_COVERAGE:

2150return Attribute::NoSanitizeCoverage;

2151casebitc::ATTR_KIND_NULL_POINTER_IS_VALID:

2152return Attribute::NullPointerIsValid;

2153casebitc::ATTR_KIND_OPTIMIZE_FOR_DEBUGGING:

2154return Attribute::OptimizeForDebugging;

2155casebitc::ATTR_KIND_OPT_FOR_FUZZING:

2156return Attribute::OptForFuzzing;

2157casebitc::ATTR_KIND_OPTIMIZE_FOR_SIZE:

2158return Attribute::OptimizeForSize;

2159casebitc::ATTR_KIND_OPTIMIZE_NONE:

2160return Attribute::OptimizeNone;

2161casebitc::ATTR_KIND_READ_NONE:

2162return Attribute::ReadNone;

2163casebitc::ATTR_KIND_READ_ONLY:

2164return Attribute::ReadOnly;

2165casebitc::ATTR_KIND_RETURNED:

2166return Attribute::Returned;

2167casebitc::ATTR_KIND_RETURNS_TWICE:

2168return Attribute::ReturnsTwice;

2169casebitc::ATTR_KIND_S_EXT:

2170return Attribute::SExt;

2171casebitc::ATTR_KIND_SPECULATABLE:

2172return Attribute::Speculatable;

2173casebitc::ATTR_KIND_STACK_ALIGNMENT:

2174return Attribute::StackAlignment;

2175casebitc::ATTR_KIND_STACK_PROTECT:

2176return Attribute::StackProtect;

2177casebitc::ATTR_KIND_STACK_PROTECT_REQ:

2178return Attribute::StackProtectReq;

2179casebitc::ATTR_KIND_STACK_PROTECT_STRONG:

2180return Attribute::StackProtectStrong;

2181casebitc::ATTR_KIND_SAFESTACK:

2182return Attribute::SafeStack;

2183casebitc::ATTR_KIND_SHADOWCALLSTACK:

2184return Attribute::ShadowCallStack;

2185casebitc::ATTR_KIND_STRICT_FP:

2186return Attribute::StrictFP;

2187casebitc::ATTR_KIND_STRUCT_RET:

2188return Attribute::StructRet;

2189casebitc::ATTR_KIND_SANITIZE_ADDRESS:

2190return Attribute::SanitizeAddress;

2191casebitc::ATTR_KIND_SANITIZE_HWADDRESS:

2192return Attribute::SanitizeHWAddress;

2193casebitc::ATTR_KIND_SANITIZE_THREAD:

2194return Attribute::SanitizeThread;

2195casebitc::ATTR_KIND_SANITIZE_TYPE:

2196return Attribute::SanitizeType;

2197casebitc::ATTR_KIND_SANITIZE_MEMORY:

2198return Attribute::SanitizeMemory;

2199casebitc::ATTR_KIND_SANITIZE_NUMERICAL_STABILITY:

2200return Attribute::SanitizeNumericalStability;

2201casebitc::ATTR_KIND_SANITIZE_REALTIME:

2202return Attribute::SanitizeRealtime;

2203casebitc::ATTR_KIND_SANITIZE_REALTIME_BLOCKING:

2204return Attribute::SanitizeRealtimeBlocking;

2205casebitc::ATTR_KIND_SPECULATIVE_LOAD_HARDENING:

2206return Attribute::SpeculativeLoadHardening;

2207casebitc::ATTR_KIND_SWIFT_ERROR:

2208return Attribute::SwiftError;

2209casebitc::ATTR_KIND_SWIFT_SELF:

2210return Attribute::SwiftSelf;

2211casebitc::ATTR_KIND_SWIFT_ASYNC:

2212return Attribute::SwiftAsync;

2213casebitc::ATTR_KIND_UW_TABLE:

2214return Attribute::UWTable;

2215casebitc::ATTR_KIND_VSCALE_RANGE:

2216return Attribute::VScaleRange;

2217casebitc::ATTR_KIND_WILLRETURN:

2218return Attribute::WillReturn;

2219casebitc::ATTR_KIND_WRITEONLY:

2220return Attribute::WriteOnly;

2221casebitc::ATTR_KIND_Z_EXT:

2222return Attribute::ZExt;

2223casebitc::ATTR_KIND_IMMARG:

2224return Attribute::ImmArg;

2225casebitc::ATTR_KIND_SANITIZE_MEMTAG:

2226return Attribute::SanitizeMemTag;

2227casebitc::ATTR_KIND_PREALLOCATED:

2228return Attribute::Preallocated;

2229casebitc::ATTR_KIND_NOUNDEF:

2230return Attribute::NoUndef;

2231casebitc::ATTR_KIND_BYREF:

2232return Attribute::ByRef;

2233casebitc::ATTR_KIND_MUSTPROGRESS:

2234return Attribute::MustProgress;

2235casebitc::ATTR_KIND_HOT:

2236return Attribute::Hot;

2237casebitc::ATTR_KIND_PRESPLIT_COROUTINE:

2238return Attribute::PresplitCoroutine;

2239casebitc::ATTR_KIND_WRITABLE:

2240return Attribute::Writable;

2241casebitc::ATTR_KIND_CORO_ONLY_DESTROY_WHEN_COMPLETE:

2242return Attribute::CoroDestroyOnlyWhenComplete;

2243casebitc::ATTR_KIND_DEAD_ON_UNWIND:

2244return Attribute::DeadOnUnwind;

2245casebitc::ATTR_KIND_RANGE:

2246return Attribute::Range;

2247casebitc::ATTR_KIND_INITIALIZES:

2248return Attribute::Initializes;

2249casebitc::ATTR_KIND_CORO_ELIDE_SAFE:

2250return Attribute::CoroElideSafe;

2251casebitc::ATTR_KIND_NO_EXT:

2252return Attribute::NoExt;

2253casebitc::ATTR_KIND_CAPTURES:

2254return Attribute::Captures;

2255 }

2256}

2257

2258Error BitcodeReader::parseAlignmentValue(uint64_t Exponent,

2259MaybeAlign &Alignment) {

2260// Note: Alignment in bitcode files is incremented by 1, so that zero

2261// can be used for default alignment.

2262if (Exponent >Value::MaxAlignmentExponent + 1)

2263returnerror("Invalid alignment value");

2264 Alignment =decodeMaybeAlign(Exponent);

2265returnError::success();

2266}

2267

2268Error BitcodeReader::parseAttrKind(uint64_t Code,Attribute::AttrKind *Kind) {

2269 *Kind =getAttrFromCode(Code);

2270if (*Kind ==Attribute::None)

2271returnerror("Unknown attribute kind (" +Twine(Code) +")");

2272returnError::success();

2273}

2274

2275staticboolupgradeOldMemoryAttribute(MemoryEffects &ME,uint64_t EncodedKind) {

2276switch (EncodedKind) {

2277casebitc::ATTR_KIND_READ_NONE:

2278 ME &=MemoryEffects::none();

2279returntrue;

2280casebitc::ATTR_KIND_READ_ONLY:

2281 ME &=MemoryEffects::readOnly();

2282returntrue;

2283casebitc::ATTR_KIND_WRITEONLY:

2284 ME &=MemoryEffects::writeOnly();

2285returntrue;

2286casebitc::ATTR_KIND_ARGMEMONLY:

2287 ME &=MemoryEffects::argMemOnly();

2288returntrue;

2289casebitc::ATTR_KIND_INACCESSIBLEMEM_ONLY:

2290 ME &=MemoryEffects::inaccessibleMemOnly();

2291returntrue;

2292casebitc::ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY:

2293 ME &=MemoryEffects::inaccessibleOrArgMemOnly();

2294returntrue;

2295default:

2296returnfalse;

2297 }

2298}

2299

2300Error BitcodeReader::parseAttributeGroupBlock() {

2301if (Error Err = Stream.EnterSubBlock(bitc::PARAMATTR_GROUP_BLOCK_ID))

2302return Err;

2303

2304if (!MAttributeGroups.empty())

2305returnerror("Invalid multiple blocks");

2306

2307SmallVector<uint64_t, 64>Record;

2308

2309// Read all the records.

2310while (true) {

2311Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

2312if (!MaybeEntry)

2313return MaybeEntry.takeError();

2314BitstreamEntry Entry = MaybeEntry.get();

2315

2316switch (Entry.Kind) {

2317caseBitstreamEntry::SubBlock:// Handled for us already.

2318caseBitstreamEntry::Error:

2319returnerror("Malformed block");

2320caseBitstreamEntry::EndBlock:

2321returnError::success();

2322caseBitstreamEntry::Record:

2323// The interesting case.

2324break;

2325 }

2326

2327// Read a record.

2328Record.clear();

2329Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

2330if (!MaybeRecord)

2331return MaybeRecord.takeError();

2332switch (MaybeRecord.get()) {

2333default:// Default behavior: ignore.

2334break;

2335casebitc::PARAMATTR_GRP_CODE_ENTRY: {// ENTRY: [grpid, idx, a0, a1, ...]

2336if (Record.size() < 3)

2337returnerror("Invalid grp record");

2338

2339uint64_t GrpID =Record[0];

2340uint64_t Idx =Record[1];// Index of the object this attribute refers to.

2341

2342AttrBuilder B(Context);

2343MemoryEffects ME =MemoryEffects::unknown();

2344for (unsigned i = 2, e =Record.size(); i != e; ++i) {

2345if (Record[i] == 0) {// Enum attribute

2346Attribute::AttrKind Kind;

2347uint64_t EncodedKind =Record[++i];

2348if (Idx ==AttributeList::FunctionIndex &&

2349upgradeOldMemoryAttribute(ME, EncodedKind))

2350continue;

2351

2352if (Error Err = parseAttrKind(EncodedKind, &Kind))

2353return Err;

2354

2355// Upgrade old-style byval attribute to one with a type, even if it's

2356// nullptr. We will have to insert the real type when we associate

2357// this AttributeList with a function.

2358if (Kind == Attribute::ByVal)

2359B.addByValAttr(nullptr);

2360elseif (Kind == Attribute::StructRet)

2361B.addStructRetAttr(nullptr);

2362elseif (Kind == Attribute::InAlloca)

2363B.addInAllocaAttr(nullptr);

2364elseif (Kind == Attribute::UWTable)

2365B.addUWTableAttr(UWTableKind::Default);

2366elseif (Attribute::isEnumAttrKind(Kind))

2367B.addAttribute(Kind);

2368else

2369returnerror("Not an enum attribute");

2370 }elseif (Record[i] == 1) {// Integer attribute

2371Attribute::AttrKind Kind;

2372if (Error Err = parseAttrKind(Record[++i], &Kind))

2373return Err;

2374if (!Attribute::isIntAttrKind(Kind))

2375returnerror("Not an int attribute");

2376if (Kind == Attribute::Alignment)

2377B.addAlignmentAttr(Record[++i]);

2378elseif (Kind == Attribute::StackAlignment)

2379B.addStackAlignmentAttr(Record[++i]);

2380elseif (Kind == Attribute::Dereferenceable)

2381B.addDereferenceableAttr(Record[++i]);

2382elseif (Kind == Attribute::DereferenceableOrNull)

2383B.addDereferenceableOrNullAttr(Record[++i]);

2384elseif (Kind == Attribute::AllocSize)

2385B.addAllocSizeAttrFromRawRepr(Record[++i]);

2386elseif (Kind == Attribute::VScaleRange)

2387B.addVScaleRangeAttrFromRawRepr(Record[++i]);

2388elseif (Kind == Attribute::UWTable)

2389B.addUWTableAttr(UWTableKind(Record[++i]));

2390elseif (Kind == Attribute::AllocKind)

2391B.addAllocKindAttr(static_cast<AllocFnKind>(Record[++i]));

2392elseif (Kind == Attribute::Memory)

2393B.addMemoryAttr(MemoryEffects::createFromIntValue(Record[++i]));

2394elseif (Kind == Attribute::Captures)

2395B.addCapturesAttr(CaptureInfo::createFromIntValue(Record[++i]));

2396elseif (Kind == Attribute::NoFPClass)

2397B.addNoFPClassAttr(

2398static_cast<FPClassTest>(Record[++i] &fcAllFlags));

2399 }elseif (Record[i] == 3 ||Record[i] == 4) {// String attribute

2400boolHasValue = (Record[i++] == 4);

2401SmallString<64> KindStr;

2402SmallString<64> ValStr;

2403

2404while (Record[i] != 0 && i != e)

2405 KindStr +=Record[i++];

2406assert(Record[i] == 0 &&"Kind string not null terminated");

2407

2408if (HasValue) {

2409// Has a value associated with it.

2410 ++i;// Skip the '0' that terminates the "kind" string.

2411while (Record[i] != 0 && i != e)

2412 ValStr +=Record[i++];

2413assert(Record[i] == 0 &&"Value string not null terminated");

2414 }

2415

2416B.addAttribute(KindStr.str(), ValStr.str());

2417 }elseif (Record[i] == 5 ||Record[i] == 6) {

2418bool HasType =Record[i] == 6;

2419Attribute::AttrKind Kind;

2420if (Error Err = parseAttrKind(Record[++i], &Kind))

2421return Err;

2422if (!Attribute::isTypeAttrKind(Kind))

2423returnerror("Not a type attribute");

2424

2425B.addTypeAttr(Kind, HasType ? getTypeByID(Record[++i]) :nullptr);

2426 }elseif (Record[i] == 7) {

2427Attribute::AttrKind Kind;

2428

2429 i++;

2430if (Error Err = parseAttrKind(Record[i++], &Kind))

2431return Err;

2432if (!Attribute::isConstantRangeAttrKind(Kind))

2433returnerror("Not a ConstantRange attribute");

2434

2435Expected<ConstantRange> MaybeCR =

2436 readBitWidthAndConstantRange(Record, i);

2437if (!MaybeCR)

2438return MaybeCR.takeError();

2439 i--;

2440

2441B.addConstantRangeAttr(Kind, MaybeCR.get());

2442 }elseif (Record[i] == 8) {

2443Attribute::AttrKind Kind;

2444

2445 i++;

2446if (Error Err = parseAttrKind(Record[i++], &Kind))

2447return Err;

2448if (!Attribute::isConstantRangeListAttrKind(Kind))

2449returnerror("Not a constant range list attribute");

2450

2451SmallVector<ConstantRange, 2> Val;

2452if (i + 2 > e)

2453returnerror("Too few records for constant range list");

2454unsigned RangeSize =Record[i++];

2455unsignedBitWidth =Record[i++];

2456for (unsignedIdx = 0;Idx < RangeSize; ++Idx) {

2457Expected<ConstantRange> MaybeCR =

2458 readConstantRange(Record, i,BitWidth);

2459if (!MaybeCR)

2460return MaybeCR.takeError();

2461 Val.push_back(MaybeCR.get());

2462 }

2463 i--;

2464

2465if (!ConstantRangeList::isOrderedRanges(Val))

2466returnerror("Invalid (unordered or overlapping) range list");

2467B.addConstantRangeListAttr(Kind, Val);

2468 }else {

2469returnerror("Invalid attribute group entry");

2470 }

2471 }

2472

2473if (ME !=MemoryEffects::unknown())

2474B.addMemoryAttr(ME);

2475

2476UpgradeAttributes(B);

2477 MAttributeGroups[GrpID] =AttributeList::get(Context,Idx,B);

2478break;

2479 }

2480 }

2481 }

2482}

2483

2484Error BitcodeReader::parseTypeTable() {

2485if (Error Err = Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))

2486return Err;

2487

2488return parseTypeTableBody();

2489}

2490

2491Error BitcodeReader::parseTypeTableBody() {

2492if (!TypeList.empty())

2493returnerror("Invalid multiple blocks");

2494

2495SmallVector<uint64_t, 64>Record;

2496unsigned NumRecords = 0;

2497

2498SmallString<64>TypeName;

2499

2500// Read all the records for this type table.

2501while (true) {

2502Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

2503if (!MaybeEntry)

2504return MaybeEntry.takeError();

2505BitstreamEntry Entry = MaybeEntry.get();

2506

2507switch (Entry.Kind) {

2508caseBitstreamEntry::SubBlock:// Handled for us already.

2509caseBitstreamEntry::Error:

2510returnerror("Malformed block");

2511caseBitstreamEntry::EndBlock:

2512if (NumRecords != TypeList.size())

2513returnerror("Malformed block");

2514returnError::success();

2515caseBitstreamEntry::Record:

2516// The interesting case.

2517break;

2518 }

2519

2520// Read a record.

2521Record.clear();

2522Type *ResultTy =nullptr;

2523SmallVector<unsigned> ContainedIDs;

2524Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

2525if (!MaybeRecord)

2526return MaybeRecord.takeError();

2527switch (MaybeRecord.get()) {

2528default:

2529returnerror("Invalid value");

2530casebitc::TYPE_CODE_NUMENTRY:// TYPE_CODE_NUMENTRY: [numentries]

2531// TYPE_CODE_NUMENTRY contains a count of the number of types in the

2532// type list. This allows us to reserve space.

2533if (Record.empty())

2534returnerror("Invalid numentry record");

2535 TypeList.resize(Record[0]);

2536continue;

2537casebitc::TYPE_CODE_VOID:// VOID

2538 ResultTy =Type::getVoidTy(Context);

2539break;

2540casebitc::TYPE_CODE_HALF:// HALF

2541 ResultTy =Type::getHalfTy(Context);

2542break;

2543casebitc::TYPE_CODE_BFLOAT:// BFLOAT

2544 ResultTy =Type::getBFloatTy(Context);

2545break;

2546casebitc::TYPE_CODE_FLOAT:// FLOAT

2547 ResultTy =Type::getFloatTy(Context);

2548break;

2549casebitc::TYPE_CODE_DOUBLE:// DOUBLE

2550 ResultTy =Type::getDoubleTy(Context);

2551break;

2552casebitc::TYPE_CODE_X86_FP80:// X86_FP80

2553 ResultTy =Type::getX86_FP80Ty(Context);

2554break;

2555casebitc::TYPE_CODE_FP128:// FP128

2556 ResultTy =Type::getFP128Ty(Context);

2557break;

2558casebitc::TYPE_CODE_PPC_FP128:// PPC_FP128

2559 ResultTy =Type::getPPC_FP128Ty(Context);

2560break;

2561casebitc::TYPE_CODE_LABEL:// LABEL

2562 ResultTy =Type::getLabelTy(Context);

2563break;

2564casebitc::TYPE_CODE_METADATA:// METADATA

2565 ResultTy =Type::getMetadataTy(Context);

2566break;

2567casebitc::TYPE_CODE_X86_MMX:// X86_MMX

2568// Deprecated: decodes as <1 x i64>

2569 ResultTy =

2570llvm::FixedVectorType::get(llvm::IntegerType::get(Context, 64), 1);

2571break;

2572casebitc::TYPE_CODE_X86_AMX:// X86_AMX

2573 ResultTy =Type::getX86_AMXTy(Context);

2574break;

2575casebitc::TYPE_CODE_TOKEN:// TOKEN

2576 ResultTy =Type::getTokenTy(Context);

2577break;

2578casebitc::TYPE_CODE_INTEGER: {// INTEGER: [width]

2579if (Record.empty())

2580returnerror("Invalid integer record");

2581

2582uint64_t NumBits =Record[0];

2583if (NumBits <IntegerType::MIN_INT_BITS ||

2584 NumBits >IntegerType::MAX_INT_BITS)

2585returnerror("Bitwidth for integer type out of range");

2586 ResultTy =IntegerType::get(Context, NumBits);

2587break;

2588 }

2589casebitc::TYPE_CODE_POINTER: {// POINTER: [pointee type] or

2590// [pointee type, address space]

2591if (Record.empty())

2592returnerror("Invalid pointer record");

2593unsignedAddressSpace = 0;

2594if (Record.size() == 2)

2595AddressSpace =Record[1];

2596 ResultTy = getTypeByID(Record[0]);

2597if (!ResultTy ||

2598 !PointerType::isValidElementType(ResultTy))

2599returnerror("Invalid type");

2600 ContainedIDs.push_back(Record[0]);

2601 ResultTy = PointerType::get(ResultTy->getContext(),AddressSpace);

2602break;

2603 }

2604casebitc::TYPE_CODE_OPAQUE_POINTER: {// OPAQUE_POINTER: [addrspace]

2605if (Record.size() != 1)

2606returnerror("Invalid opaque pointer record");

2607unsignedAddressSpace =Record[0];

2608 ResultTy = PointerType::get(Context,AddressSpace);

2609break;

2610 }

2611casebitc::TYPE_CODE_FUNCTION_OLD: {

2612// Deprecated, but still needed to read old bitcode files.

2613// FUNCTION: [vararg, attrid, retty, paramty x N]

2614if (Record.size() < 3)

2615returnerror("Invalid function record");

2616SmallVector<Type*, 8> ArgTys;

2617for (unsigned i = 3, e =Record.size(); i != e; ++i) {

2618if (Type *T = getTypeByID(Record[i]))

2619 ArgTys.push_back(T);

2620else

2621break;

2622 }

2623

2624 ResultTy = getTypeByID(Record[2]);

2625if (!ResultTy || ArgTys.size() <Record.size()-3)

2626returnerror("Invalid type");

2627

2628 ContainedIDs.append(Record.begin() + 2,Record.end());

2629 ResultTy = FunctionType::get(ResultTy, ArgTys,Record[0]);

2630break;

2631 }

2632casebitc::TYPE_CODE_FUNCTION: {

2633// FUNCTION: [vararg, retty, paramty x N]

2634if (Record.size() < 2)

2635returnerror("Invalid function record");

2636SmallVector<Type*, 8> ArgTys;

2637for (unsigned i = 2, e =Record.size(); i != e; ++i) {

2638if (Type *T = getTypeByID(Record[i])) {

2639if (!FunctionType::isValidArgumentType(T))

2640returnerror("Invalid function argument type");

2641 ArgTys.push_back(T);

2642 }

2643else

2644break;

2645 }

2646

2647 ResultTy = getTypeByID(Record[1]);

2648if (!ResultTy || ArgTys.size() <Record.size()-2)

2649returnerror("Invalid type");

2650

2651 ContainedIDs.append(Record.begin() + 1,Record.end());

2652 ResultTy = FunctionType::get(ResultTy, ArgTys,Record[0]);

2653break;

2654 }

2655casebitc::TYPE_CODE_STRUCT_ANON: {// STRUCT: [ispacked, eltty x N]

2656if (Record.empty())

2657returnerror("Invalid anon struct record");

2658SmallVector<Type*, 8> EltTys;

2659for (unsigned i = 1, e =Record.size(); i != e; ++i) {

2660if (Type *T = getTypeByID(Record[i]))

2661 EltTys.push_back(T);

2662else

2663break;

2664 }

2665if (EltTys.size() !=Record.size()-1)

2666returnerror("Invalid type");

2667 ContainedIDs.append(Record.begin() + 1,Record.end());

2668 ResultTy =StructType::get(Context, EltTys,Record[0]);

2669break;

2670 }

2671casebitc::TYPE_CODE_STRUCT_NAME:// STRUCT_NAME: [strchr x N]

2672if (convertToString(Record, 0, TypeName))

2673returnerror("Invalid struct name record");

2674continue;

2675

2676casebitc::TYPE_CODE_STRUCT_NAMED: {// STRUCT: [ispacked, eltty x N]

2677if (Record.empty())

2678returnerror("Invalid named struct record");

2679

2680if (NumRecords >= TypeList.size())

2681returnerror("Invalid TYPE table");

2682

2683// Check to see if this was forward referenced, if so fill in the temp.

2684StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);

2685if (Res) {

2686 Res->setName(TypeName);

2687 TypeList[NumRecords] =nullptr;

2688 }else// Otherwise, create a new struct.

2689 Res = createIdentifiedStructType(Context, TypeName);

2690TypeName.clear();

2691

2692SmallVector<Type*, 8> EltTys;

2693for (unsigned i = 1, e =Record.size(); i != e; ++i) {

2694if (Type *T = getTypeByID(Record[i]))

2695 EltTys.push_back(T);

2696else

2697break;

2698 }

2699if (EltTys.size() !=Record.size()-1)

2700returnerror("Invalid named struct record");

2701if (auto E = Res->setBodyOrError(EltTys,Record[0]))

2702return E;

2703 ContainedIDs.append(Record.begin() + 1,Record.end());

2704 ResultTy = Res;

2705break;

2706 }

2707casebitc::TYPE_CODE_OPAQUE: {// OPAQUE: []

2708if (Record.size() != 1)

2709returnerror("Invalid opaque type record");

2710

2711if (NumRecords >= TypeList.size())

2712returnerror("Invalid TYPE table");

2713

2714// Check to see if this was forward referenced, if so fill in the temp.

2715StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);

2716if (Res) {

2717 Res->setName(TypeName);

2718 TypeList[NumRecords] =nullptr;

2719 }else// Otherwise, create a new struct with no body.

2720 Res = createIdentifiedStructType(Context, TypeName);

2721TypeName.clear();

2722 ResultTy = Res;

2723break;

2724 }

2725casebitc::TYPE_CODE_TARGET_TYPE: {// TARGET_TYPE: [NumTy, Tys..., Ints...]

2726if (Record.size() < 1)

2727returnerror("Invalid target extension type record");

2728

2729if (NumRecords >= TypeList.size())

2730returnerror("Invalid TYPE table");

2731

2732if (Record[0] >=Record.size())

2733returnerror("Too many type parameters");

2734

2735unsigned NumTys =Record[0];

2736SmallVector<Type *, 4> TypeParams;

2737SmallVector<unsigned, 8> IntParams;

2738for (unsigned i = 0; i < NumTys; i++) {

2739if (Type *T = getTypeByID(Record[i + 1]))

2740 TypeParams.push_back(T);

2741else

2742returnerror("Invalid type");

2743 }

2744

2745for (unsigned i = NumTys + 1, e =Record.size(); i < e; i++) {

2746if (Record[i] > UINT_MAX)

2747returnerror("Integer parameter too large");

2748 IntParams.push_back(Record[i]);

2749 }

2750auto TTy =

2751TargetExtType::getOrError(Context, TypeName, TypeParams, IntParams);

2752if (auto E = TTy.takeError())

2753return E;

2754 ResultTy = *TTy;

2755TypeName.clear();

2756break;

2757 }

2758casebitc::TYPE_CODE_ARRAY:// ARRAY: [numelts, eltty]

2759if (Record.size() < 2)

2760returnerror("Invalid array type record");

2761 ResultTy = getTypeByID(Record[1]);

2762if (!ResultTy || !ArrayType::isValidElementType(ResultTy))

2763returnerror("Invalid type");

2764 ContainedIDs.push_back(Record[1]);

2765 ResultTy = ArrayType::get(ResultTy,Record[0]);

2766break;

2767casebitc::TYPE_CODE_VECTOR:// VECTOR: [numelts, eltty] or

2768// [numelts, eltty, scalable]

2769if (Record.size() < 2)

2770returnerror("Invalid vector type record");

2771if (Record[0] == 0)

2772returnerror("Invalid vector length");

2773 ResultTy = getTypeByID(Record[1]);

2774if (!ResultTy || !VectorType::isValidElementType(ResultTy))

2775returnerror("Invalid type");

2776bool Scalable =Record.size() > 2 ?Record[2] :false;

2777 ContainedIDs.push_back(Record[1]);

2778 ResultTy = VectorType::get(ResultTy,Record[0], Scalable);

2779break;

2780 }

2781

2782if (NumRecords >= TypeList.size())

2783returnerror("Invalid TYPE table");

2784if (TypeList[NumRecords])

2785returnerror(

2786"Invalid TYPE table: Only named structs can be forward referenced");

2787assert(ResultTy &&"Didn't read a type?");

2788 TypeList[NumRecords] = ResultTy;

2789if (!ContainedIDs.empty())

2790 ContainedTypeIDs[NumRecords] = std::move(ContainedIDs);

2791 ++NumRecords;

2792 }

2793}

2794

2795Error BitcodeReader::parseOperandBundleTags() {

2796if (Error Err = Stream.EnterSubBlock(bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID))

2797return Err;

2798

2799if (!BundleTags.empty())

2800returnerror("Invalid multiple blocks");

2801

2802SmallVector<uint64_t, 64>Record;

2803

2804while (true) {

2805Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

2806if (!MaybeEntry)

2807return MaybeEntry.takeError();

2808BitstreamEntry Entry = MaybeEntry.get();

2809

2810switch (Entry.Kind) {

2811caseBitstreamEntry::SubBlock:// Handled for us already.

2812caseBitstreamEntry::Error:

2813returnerror("Malformed block");

2814caseBitstreamEntry::EndBlock:

2815returnError::success();

2816caseBitstreamEntry::Record:

2817// The interesting case.

2818break;

2819 }

2820

2821// Tags are implicitly mapped to integers by their order.

2822

2823Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

2824if (!MaybeRecord)

2825return MaybeRecord.takeError();

2826if (MaybeRecord.get() !=bitc::OPERAND_BUNDLE_TAG)

2827returnerror("Invalid operand bundle record");

2828

2829// OPERAND_BUNDLE_TAG: [strchr x N]

2830 BundleTags.emplace_back();

2831if (convertToString(Record, 0, BundleTags.back()))

2832returnerror("Invalid operand bundle record");

2833Record.clear();

2834 }

2835}

2836

2837Error BitcodeReader::parseSyncScopeNames() {

2838if (Error Err = Stream.EnterSubBlock(bitc::SYNC_SCOPE_NAMES_BLOCK_ID))

2839return Err;

2840

2841if (!SSIDs.empty())

2842returnerror("Invalid multiple synchronization scope names blocks");

2843

2844SmallVector<uint64_t, 64>Record;

2845while (true) {

2846Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

2847if (!MaybeEntry)

2848return MaybeEntry.takeError();

2849BitstreamEntry Entry = MaybeEntry.get();

2850

2851switch (Entry.Kind) {

2852caseBitstreamEntry::SubBlock:// Handled for us already.

2853caseBitstreamEntry::Error:

2854returnerror("Malformed block");

2855caseBitstreamEntry::EndBlock:

2856if (SSIDs.empty())

2857returnerror("Invalid empty synchronization scope names block");

2858returnError::success();

2859caseBitstreamEntry::Record:

2860// The interesting case.

2861break;

2862 }

2863

2864// Synchronization scope names are implicitly mapped to synchronization

2865// scope IDs by their order.

2866

2867Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

2868if (!MaybeRecord)

2869return MaybeRecord.takeError();

2870if (MaybeRecord.get() !=bitc::SYNC_SCOPE_NAME)

2871returnerror("Invalid sync scope record");

2872

2873SmallString<16> SSN;

2874if (convertToString(Record, 0, SSN))

2875returnerror("Invalid sync scope record");

2876

2877 SSIDs.push_back(Context.getOrInsertSyncScopeID(SSN));

2878Record.clear();

2879 }

2880}

2881

2882/// Associate a value with its name from the given index in the provided record.

2883Expected<Value *> BitcodeReader::recordValue(SmallVectorImpl<uint64_t> &Record,

2884unsigned NameIndex,Triple &TT) {

2885SmallString<128>ValueName;

2886if (convertToString(Record, NameIndex,ValueName))

2887returnerror("Invalid record");

2888unsigned ValueID =Record[0];

2889if (ValueID >= ValueList.size() || !ValueList[ValueID])

2890returnerror("Invalid record");

2891Value *V = ValueList[ValueID];

2892

2893StringRef NameStr(ValueName.data(),ValueName.size());

2894if (NameStr.contains(0))

2895returnerror("Invalid value name");

2896V->setName(NameStr);

2897auto *GO = dyn_cast<GlobalObject>(V);

2898if (GO && ImplicitComdatObjects.contains(GO) &&TT.supportsCOMDAT())

2899 GO->setComdat(TheModule->getOrInsertComdat(V->getName()));

2900returnV;

2901}

2902

2903/// Helper to note and return the current location, and jump to the given

2904/// offset.

2905staticExpected<uint64_t>jumpToValueSymbolTable(uint64_t Offset,

2906BitstreamCursor &Stream) {

2907// Save the current parsing location so we can jump back at the end

2908// of the VST read.

2909uint64_t CurrentBit = Stream.GetCurrentBitNo();

2910if (Error JumpFailed = Stream.JumpToBit(Offset * 32))

2911return std::move(JumpFailed);

2912Expected<BitstreamEntry> MaybeEntry = Stream.advance();

2913if (!MaybeEntry)

2914return MaybeEntry.takeError();

2915if (MaybeEntry.get().Kind !=BitstreamEntry::SubBlock ||

2916 MaybeEntry.get().ID !=bitc::VALUE_SYMTAB_BLOCK_ID)

2917returnerror("Expected value symbol table subblock");

2918return CurrentBit;

2919}

2920

2921void BitcodeReader::setDeferredFunctionInfo(unsigned FuncBitcodeOffsetDelta,

2922Function *F,

2923ArrayRef<uint64_t>Record) {

2924// Note that we subtract 1 here because the offset is relative to one word

2925// before the start of the identification or module block, which was

2926// historically always the start of the regular bitcode header.

2927uint64_t FuncWordOffset =Record[1] - 1;

2928uint64_t FuncBitOffset = FuncWordOffset * 32;

2929 DeferredFunctionInfo[F] = FuncBitOffset + FuncBitcodeOffsetDelta;

2930// Set the LastFunctionBlockBit to point to the last function block.

2931// Later when parsing is resumed after function materialization,

2932// we can simply skip that last function block.

2933if (FuncBitOffset > LastFunctionBlockBit)

2934 LastFunctionBlockBit = FuncBitOffset;

2935}

2936

2937/// Read a new-style GlobalValue symbol table.

2938Error BitcodeReader::parseGlobalValueSymbolTable() {

2939unsigned FuncBitcodeOffsetDelta =

2940 Stream.getAbbrevIDWidth() +bitc::BlockIDWidth;

2941

2942if (Error Err = Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))

2943return Err;

2944

2945SmallVector<uint64_t, 64>Record;

2946while (true) {

2947Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

2948if (!MaybeEntry)

2949return MaybeEntry.takeError();

2950BitstreamEntry Entry = MaybeEntry.get();

2951

2952switch (Entry.Kind) {

2953caseBitstreamEntry::SubBlock:

2954caseBitstreamEntry::Error:

2955returnerror("Malformed block");

2956caseBitstreamEntry::EndBlock:

2957returnError::success();

2958caseBitstreamEntry::Record:

2959break;

2960 }

2961

2962Record.clear();

2963Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

2964if (!MaybeRecord)

2965return MaybeRecord.takeError();

2966switch (MaybeRecord.get()) {

2967casebitc::VST_CODE_FNENTRY: {// [valueid, offset]

2968unsigned ValueID =Record[0];

2969if (ValueID >= ValueList.size() || !ValueList[ValueID])

2970returnerror("Invalid value reference in symbol table");

2971 setDeferredFunctionInfo(FuncBitcodeOffsetDelta,

2972 cast<Function>(ValueList[ValueID]),Record);

2973break;

2974 }

2975 }

2976 }

2977}

2978

2979/// Parse the value symbol table at either the current parsing location or

2980/// at the given bit offset if provided.

2981Error BitcodeReader::parseValueSymbolTable(uint64_t Offset) {

2982uint64_t CurrentBit;

2983// Pass in the Offset to distinguish between calling for the module-level

2984// VST (where we want to jump to the VST offset) and the function-level

2985// VST (where we don't).

2986if (Offset > 0) {

2987Expected<uint64_t> MaybeCurrentBit =jumpToValueSymbolTable(Offset, Stream);

2988if (!MaybeCurrentBit)

2989return MaybeCurrentBit.takeError();

2990 CurrentBit = MaybeCurrentBit.get();

2991// If this module uses a string table, read this as a module-level VST.

2992if (UseStrtab) {

2993if (Error Err = parseGlobalValueSymbolTable())

2994return Err;

2995if (Error JumpFailed = Stream.JumpToBit(CurrentBit))

2996return JumpFailed;

2997returnError::success();

2998 }

2999// Otherwise, the VST will be in a similar format to a function-level VST,

3000// and will contain symbol names.

3001 }

3002

3003// Compute the delta between the bitcode indices in the VST (the word offset

3004// to the word-aligned ENTER_SUBBLOCK for the function block, and that

3005// expected by the lazy reader. The reader's EnterSubBlock expects to have

3006// already read the ENTER_SUBBLOCK code (size getAbbrevIDWidth) and BlockID

3007// (size BlockIDWidth). Note that we access the stream's AbbrevID width here

3008// just before entering the VST subblock because: 1) the EnterSubBlock

3009// changes the AbbrevID width; 2) the VST block is nested within the same

3010// outer MODULE_BLOCK as the FUNCTION_BLOCKs and therefore have the same

3011// AbbrevID width before calling EnterSubBlock; and 3) when we want to

3012// jump to the FUNCTION_BLOCK using this offset later, we don't want

3013// to rely on the stream's AbbrevID width being that of the MODULE_BLOCK.

3014unsigned FuncBitcodeOffsetDelta =

3015 Stream.getAbbrevIDWidth() +bitc::BlockIDWidth;

3016

3017if (Error Err = Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))

3018return Err;

3019

3020SmallVector<uint64_t, 64>Record;

3021

3022Triple TT(TheModule->getTargetTriple());

3023

3024// Read all the records for this value table.

3025SmallString<128>ValueName;

3026

3027while (true) {

3028Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

3029if (!MaybeEntry)

3030return MaybeEntry.takeError();

3031BitstreamEntry Entry = MaybeEntry.get();

3032

3033switch (Entry.Kind) {

3034caseBitstreamEntry::SubBlock:// Handled for us already.

3035caseBitstreamEntry::Error:

3036returnerror("Malformed block");

3037caseBitstreamEntry::EndBlock:

3038if (Offset > 0)

3039if (Error JumpFailed = Stream.JumpToBit(CurrentBit))

3040return JumpFailed;

3041returnError::success();

3042caseBitstreamEntry::Record:

3043// The interesting case.

3044break;

3045 }

3046

3047// Read a record.

3048Record.clear();

3049Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

3050if (!MaybeRecord)

3051return MaybeRecord.takeError();

3052switch (MaybeRecord.get()) {

3053default:// Default behavior: unknown type.

3054break;

3055casebitc::VST_CODE_ENTRY: {// VST_CODE_ENTRY: [valueid, namechar x N]

3056Expected<Value *> ValOrErr = recordValue(Record, 1, TT);

3057if (Error Err = ValOrErr.takeError())

3058return Err;

3059 ValOrErr.get();

3060break;

3061 }

3062casebitc::VST_CODE_FNENTRY: {

3063// VST_CODE_FNENTRY: [valueid, offset, namechar x N]

3064Expected<Value *> ValOrErr = recordValue(Record, 2, TT);

3065if (Error Err = ValOrErr.takeError())

3066return Err;

3067Value *V = ValOrErr.get();

3068

3069// Ignore function offsets emitted for aliases of functions in older

3070// versions of LLVM.

3071if (auto *F = dyn_cast<Function>(V))

3072 setDeferredFunctionInfo(FuncBitcodeOffsetDelta,F,Record);

3073break;

3074 }

3075casebitc::VST_CODE_BBENTRY: {

3076if (convertToString(Record, 1,ValueName))

3077returnerror("Invalid bbentry record");

3078BasicBlock *BB = getBasicBlock(Record[0]);

3079if (!BB)

3080returnerror("Invalid bbentry record");

3081

3082 BB->setName(ValueName.str());

3083ValueName.clear();

3084break;

3085 }

3086 }

3087 }

3088}

3089

3090/// Decode a signed value stored with the sign bit in the LSB for dense VBR

3091/// encoding.

3092uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) {

3093if ((V & 1) == 0)

3094returnV >> 1;

3095if (V != 1)

3096return -(V >> 1);

3097// There is no such thing as -0 with integers. "-0" really means MININT.

3098return 1ULL << 63;

3099}

3100

3101/// Resolve all of the initializers for global values and aliases that we can.

3102Error BitcodeReader::resolveGlobalAndIndirectSymbolInits() {

3103 std::vector<std::pair<GlobalVariable *, unsigned>> GlobalInitWorklist;

3104 std::vector<std::pair<GlobalValue *, unsigned>> IndirectSymbolInitWorklist;

3105 std::vector<FunctionOperandInfo> FunctionOperandWorklist;

3106

3107 GlobalInitWorklist.swap(GlobalInits);

3108 IndirectSymbolInitWorklist.swap(IndirectSymbolInits);

3109 FunctionOperandWorklist.swap(FunctionOperands);

3110

3111while (!GlobalInitWorklist.empty()) {

3112unsignedValID = GlobalInitWorklist.back().second;

3113if (ValID >= ValueList.size()) {

3114// Not ready to resolve this yet, it requires something later in the file.

3115 GlobalInits.push_back(GlobalInitWorklist.back());

3116 }else {

3117Expected<Constant *> MaybeC = getValueForInitializer(ValID);

3118if (!MaybeC)

3119return MaybeC.takeError();

3120 GlobalInitWorklist.back().first->setInitializer(MaybeC.get());

3121 }

3122 GlobalInitWorklist.pop_back();

3123 }

3124

3125while (!IndirectSymbolInitWorklist.empty()) {

3126unsignedValID = IndirectSymbolInitWorklist.back().second;

3127if (ValID >= ValueList.size()) {

3128 IndirectSymbolInits.push_back(IndirectSymbolInitWorklist.back());

3129 }else {

3130Expected<Constant *> MaybeC = getValueForInitializer(ValID);

3131if (!MaybeC)

3132return MaybeC.takeError();

3133Constant *C = MaybeC.get();

3134GlobalValue *GV = IndirectSymbolInitWorklist.back().first;

3135if (auto *GA = dyn_cast<GlobalAlias>(GV)) {

3136if (C->getType() != GV->getType())

3137returnerror("Alias and aliasee types don't match");

3138 GA->setAliasee(C);

3139 }elseif (auto *GI = dyn_cast<GlobalIFunc>(GV)) {

3140 GI->setResolver(C);

3141 }else {

3142returnerror("Expected an alias or an ifunc");

3143 }

3144 }

3145 IndirectSymbolInitWorklist.pop_back();

3146 }

3147

3148while (!FunctionOperandWorklist.empty()) {

3149 FunctionOperandInfo &Info = FunctionOperandWorklist.back();

3150if (Info.PersonalityFn) {

3151unsignedValID =Info.PersonalityFn - 1;

3152if (ValID < ValueList.size()) {

3153Expected<Constant *> MaybeC = getValueForInitializer(ValID);

3154if (!MaybeC)

3155return MaybeC.takeError();

3156Info.F->setPersonalityFn(MaybeC.get());

3157Info.PersonalityFn = 0;

3158 }

3159 }

3160if (Info.Prefix) {

3161unsignedValID =Info.Prefix - 1;

3162if (ValID < ValueList.size()) {

3163Expected<Constant *> MaybeC = getValueForInitializer(ValID);

3164if (!MaybeC)

3165return MaybeC.takeError();

3166Info.F->setPrefixData(MaybeC.get());

3167Info.Prefix = 0;

3168 }

3169 }

3170if (Info.Prologue) {

3171unsignedValID =Info.Prologue - 1;

3172if (ValID < ValueList.size()) {

3173Expected<Constant *> MaybeC = getValueForInitializer(ValID);

3174if (!MaybeC)

3175return MaybeC.takeError();

3176Info.F->setPrologueData(MaybeC.get());

3177Info.Prologue = 0;

3178 }

3179 }

3180if (Info.PersonalityFn ||Info.Prefix ||Info.Prologue)

3181 FunctionOperands.push_back(Info);

3182 FunctionOperandWorklist.pop_back();

3183 }

3184

3185returnError::success();

3186}

3187

3188APInt llvm::readWideAPInt(ArrayRef<uint64_t> Vals,unsigned TypeBits) {

3189SmallVector<uint64_t, 8> Words(Vals.size());

3190transform(Vals, Words.begin(),

3191 BitcodeReader::decodeSignRotatedValue);

3192

3193returnAPInt(TypeBits, Words);

3194}

3195

3196Error BitcodeReader::parseConstants() {

3197if (Error Err = Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))

3198return Err;

3199

3200SmallVector<uint64_t, 64>Record;

3201

3202// Read all the records for this value table.

3203Type *CurTy =Type::getInt32Ty(Context);

3204unsigned Int32TyID = getVirtualTypeID(CurTy);

3205unsigned CurTyID = Int32TyID;

3206Type *CurElemTy =nullptr;

3207unsigned NextCstNo = ValueList.size();

3208

3209while (true) {

3210Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

3211if (!MaybeEntry)

3212return MaybeEntry.takeError();

3213BitstreamEntry Entry = MaybeEntry.get();

3214

3215switch (Entry.Kind) {

3216caseBitstreamEntry::SubBlock:// Handled for us already.

3217caseBitstreamEntry::Error:

3218returnerror("Malformed block");

3219caseBitstreamEntry::EndBlock:

3220if (NextCstNo != ValueList.size())

3221returnerror("Invalid constant reference");

3222returnError::success();

3223caseBitstreamEntry::Record:

3224// The interesting case.

3225break;

3226 }

3227

3228// Read a record.

3229Record.clear();

3230Type *VoidType =Type::getVoidTy(Context);

3231Value *V =nullptr;

3232Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID,Record);

3233if (!MaybeBitCode)

3234return MaybeBitCode.takeError();

3235switch (unsigned BitCode = MaybeBitCode.get()) {

3236default:// Default behavior: unknown constant

3237casebitc::CST_CODE_UNDEF:// UNDEF

3238V =UndefValue::get(CurTy);

3239break;

3240casebitc::CST_CODE_POISON:// POISON

3241V =PoisonValue::get(CurTy);

3242break;

3243casebitc::CST_CODE_SETTYPE:// SETTYPE: [typeid]

3244if (Record.empty())

3245returnerror("Invalid settype record");

3246if (Record[0] >= TypeList.size() || !TypeList[Record[0]])

3247returnerror("Invalid settype record");

3248if (TypeList[Record[0]] == VoidType)

3249returnerror("Invalid constant type");

3250 CurTyID =Record[0];

3251 CurTy = TypeList[CurTyID];

3252 CurElemTy = getPtrElementTypeByID(CurTyID);

3253continue;// Skip the ValueList manipulation.

3254casebitc::CST_CODE_NULL:// NULL

3255if (CurTy->isVoidTy() || CurTy->isFunctionTy() || CurTy->isLabelTy())

3256returnerror("Invalid type for a constant null value");

3257if (auto *TETy = dyn_cast<TargetExtType>(CurTy))

3258if (!TETy->hasProperty(TargetExtType::HasZeroInit))

3259returnerror("Invalid type for a constant null value");

3260V =Constant::getNullValue(CurTy);

3261break;

3262casebitc::CST_CODE_INTEGER:// INTEGER: [intval]

3263if (!CurTy->isIntOrIntVectorTy() ||Record.empty())

3264returnerror("Invalid integer const record");

3265V = ConstantInt::get(CurTy,decodeSignRotatedValue(Record[0]));

3266break;

3267casebitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval]

3268if (!CurTy->isIntOrIntVectorTy() ||Record.empty())

3269returnerror("Invalid wide integer const record");

3270

3271auto *ScalarTy = cast<IntegerType>(CurTy->getScalarType());

3272APInt VInt =readWideAPInt(Record, ScalarTy->getBitWidth());

3273V = ConstantInt::get(CurTy, VInt);

3274break;

3275 }

3276casebitc::CST_CODE_FLOAT: {// FLOAT: [fpval]

3277if (Record.empty())

3278returnerror("Invalid float const record");

3279

3280auto *ScalarTy = CurTy->getScalarType();

3281if (ScalarTy->isHalfTy())

3282V = ConstantFP::get(CurTy,APFloat(APFloat::IEEEhalf(),

3283APInt(16, (uint16_t)Record[0])));

3284elseif (ScalarTy->isBFloatTy())

3285V = ConstantFP::get(

3286 CurTy,APFloat(APFloat::BFloat(),APInt(16, (uint32_t)Record[0])));

3287elseif (ScalarTy->isFloatTy())

3288V = ConstantFP::get(CurTy,APFloat(APFloat::IEEEsingle(),

3289APInt(32, (uint32_t)Record[0])));

3290elseif (ScalarTy->isDoubleTy())

3291V = ConstantFP::get(

3292 CurTy,APFloat(APFloat::IEEEdouble(),APInt(64,Record[0])));

3293elseif (ScalarTy->isX86_FP80Ty()) {

3294// Bits are not stored the same way as a normal i80 APInt, compensate.

3295uint64_t Rearrange[2];

3296 Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16);

3297 Rearrange[1] =Record[0] >> 48;

3298V = ConstantFP::get(

3299 CurTy,APFloat(APFloat::x87DoubleExtended(),APInt(80, Rearrange)));

3300 }elseif (ScalarTy->isFP128Ty())

3301V = ConstantFP::get(CurTy,

3302APFloat(APFloat::IEEEquad(),APInt(128,Record)));

3303elseif (ScalarTy->isPPC_FP128Ty())

3304V = ConstantFP::get(

3305 CurTy,APFloat(APFloat::PPCDoubleDouble(),APInt(128,Record)));

3306else

3307V =PoisonValue::get(CurTy);

3308break;

3309 }

3310

3311casebitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number]

3312if (Record.empty())

3313returnerror("Invalid aggregate record");

3314

3315unsignedSize =Record.size();

3316SmallVector<unsigned, 16> Elts;

3317for (unsigned i = 0; i !=Size; ++i)

3318 Elts.push_back(Record[i]);

3319

3320if (isa<StructType>(CurTy)) {

3321V = BitcodeConstant::create(

3322 Alloc, CurTy, BitcodeConstant::ConstantStructOpcode, Elts);

3323 }elseif (isa<ArrayType>(CurTy)) {

3324V = BitcodeConstant::create(Alloc, CurTy,

3325 BitcodeConstant::ConstantArrayOpcode, Elts);

3326 }elseif (isa<VectorType>(CurTy)) {

3327V = BitcodeConstant::create(

3328 Alloc, CurTy, BitcodeConstant::ConstantVectorOpcode, Elts);

3329 }else {

3330V =PoisonValue::get(CurTy);

3331 }

3332break;

3333 }

3334casebitc::CST_CODE_STRING:// STRING: [values]

3335casebitc::CST_CODE_CSTRING: {// CSTRING: [values]

3336if (Record.empty())

3337returnerror("Invalid string record");

3338

3339SmallString<16> Elts(Record.begin(),Record.end());

3340V =ConstantDataArray::getString(Context, Elts,

3341 BitCode ==bitc::CST_CODE_CSTRING);

3342break;

3343 }

3344casebitc::CST_CODE_DATA: {// DATA: [n x value]

3345if (Record.empty())

3346returnerror("Invalid data record");

3347

3348Type *EltTy;

3349if (auto *Array = dyn_cast<ArrayType>(CurTy))

3350 EltTy =Array->getElementType();

3351else

3352 EltTy = cast<VectorType>(CurTy)->getElementType();

3353if (EltTy->isIntegerTy(8)) {

3354SmallVector<uint8_t, 16> Elts(Record.begin(),Record.end());

3355if (isa<VectorType>(CurTy))

3356V =ConstantDataVector::get(Context, Elts);

3357else

3358V =ConstantDataArray::get(Context, Elts);

3359 }elseif (EltTy->isIntegerTy(16)) {

3360SmallVector<uint16_t, 16> Elts(Record.begin(),Record.end());

3361if (isa<VectorType>(CurTy))

3362V =ConstantDataVector::get(Context, Elts);

3363else

3364V =ConstantDataArray::get(Context, Elts);

3365 }elseif (EltTy->isIntegerTy(32)) {

3366SmallVector<uint32_t, 16> Elts(Record.begin(),Record.end());

3367if (isa<VectorType>(CurTy))

3368V =ConstantDataVector::get(Context, Elts);

3369else

3370V =ConstantDataArray::get(Context, Elts);

3371 }elseif (EltTy->isIntegerTy(64)) {

3372SmallVector<uint64_t, 16> Elts(Record.begin(),Record.end());

3373if (isa<VectorType>(CurTy))

3374V =ConstantDataVector::get(Context, Elts);

3375else

3376V =ConstantDataArray::get(Context, Elts);

3377 }elseif (EltTy->isHalfTy()) {

3378SmallVector<uint16_t, 16> Elts(Record.begin(),Record.end());

3379if (isa<VectorType>(CurTy))

3380V =ConstantDataVector::getFP(EltTy, Elts);

3381else

3382V =ConstantDataArray::getFP(EltTy, Elts);

3383 }elseif (EltTy->isBFloatTy()) {

3384SmallVector<uint16_t, 16> Elts(Record.begin(),Record.end());

3385if (isa<VectorType>(CurTy))

3386V =ConstantDataVector::getFP(EltTy, Elts);

3387else

3388V =ConstantDataArray::getFP(EltTy, Elts);

3389 }elseif (EltTy->isFloatTy()) {

3390SmallVector<uint32_t, 16> Elts(Record.begin(),Record.end());

3391if (isa<VectorType>(CurTy))

3392V =ConstantDataVector::getFP(EltTy, Elts);

3393else

3394V =ConstantDataArray::getFP(EltTy, Elts);

3395 }elseif (EltTy->isDoubleTy()) {

3396SmallVector<uint64_t, 16> Elts(Record.begin(),Record.end());

3397if (isa<VectorType>(CurTy))

3398V =ConstantDataVector::getFP(EltTy, Elts);

3399else

3400V =ConstantDataArray::getFP(EltTy, Elts);

3401 }else {

3402returnerror("Invalid type for value");

3403 }

3404break;

3405 }

3406casebitc::CST_CODE_CE_UNOP: {// CE_UNOP: [opcode, opval]

3407if (Record.size() < 2)

3408returnerror("Invalid unary op constexpr record");

3409int Opc =getDecodedUnaryOpcode(Record[0], CurTy);

3410if (Opc < 0) {

3411V =PoisonValue::get(CurTy);// Unknown unop.

3412 }else {

3413V = BitcodeConstant::create(Alloc, CurTy, Opc, (unsigned)Record[1]);

3414 }

3415break;

3416 }

3417casebitc::CST_CODE_CE_BINOP: {// CE_BINOP: [opcode, opval, opval]

3418if (Record.size() < 3)

3419returnerror("Invalid binary op constexpr record");

3420int Opc =getDecodedBinaryOpcode(Record[0], CurTy);

3421if (Opc < 0) {

3422V =PoisonValue::get(CurTy);// Unknown binop.

3423 }else {

3424uint8_t Flags = 0;

3425if (Record.size() >= 4) {

3426if (Opc == Instruction::Add ||

3427 Opc == Instruction::Sub ||

3428 Opc == Instruction::Mul ||

3429 Opc == Instruction::Shl) {

3430if (Record[3] & (1 <<bitc::OBO_NO_SIGNED_WRAP))

3431Flags |=OverflowingBinaryOperator::NoSignedWrap;

3432if (Record[3] & (1 <<bitc::OBO_NO_UNSIGNED_WRAP))

3433Flags |=OverflowingBinaryOperator::NoUnsignedWrap;

3434 }elseif (Opc == Instruction::SDiv ||

3435 Opc == Instruction::UDiv ||

3436 Opc == Instruction::LShr ||

3437 Opc == Instruction::AShr) {

3438if (Record[3] & (1 <<bitc::PEO_EXACT))

3439Flags |=PossiblyExactOperator::IsExact;

3440 }

3441 }

3442V = BitcodeConstant::create(Alloc, CurTy, {(uint8_t)Opc, Flags},

3443 {(unsigned)Record[1], (unsigned)Record[2]});

3444 }

3445break;

3446 }

3447casebitc::CST_CODE_CE_CAST: {// CE_CAST: [opcode, opty, opval]

3448if (Record.size() < 3)

3449returnerror("Invalid cast constexpr record");

3450int Opc =getDecodedCastOpcode(Record[0]);

3451if (Opc < 0) {

3452V =PoisonValue::get(CurTy);// Unknown cast.

3453 }else {

3454unsigned OpTyID =Record[1];

3455Type *OpTy = getTypeByID(OpTyID);

3456if (!OpTy)

3457returnerror("Invalid cast constexpr record");

3458V = BitcodeConstant::create(Alloc, CurTy, Opc, (unsigned)Record[2]);

3459 }

3460break;

3461 }

3462casebitc::CST_CODE_CE_INBOUNDS_GEP:// [ty, n x operands]

3463casebitc::CST_CODE_CE_GEP_OLD:// [ty, n x operands]

3464casebitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX_OLD:// [ty, flags, n x

3465// operands]

3466casebitc::CST_CODE_CE_GEP:// [ty, flags, n x operands]

3467casebitc::CST_CODE_CE_GEP_WITH_INRANGE: {// [ty, flags, start, end, n x

3468// operands]

3469if (Record.size() < 2)

3470returnerror("Constant GEP record must have at least two elements");

3471unsigned OpNum = 0;

3472Type *PointeeType =nullptr;

3473if (BitCode ==bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX_OLD ||

3474 BitCode ==bitc::CST_CODE_CE_GEP_WITH_INRANGE ||

3475 BitCode ==bitc::CST_CODE_CE_GEP ||Record.size() % 2)

3476 PointeeType = getTypeByID(Record[OpNum++]);

3477

3478uint64_t Flags = 0;

3479 std::optional<ConstantRange>InRange;

3480if (BitCode ==bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX_OLD) {

3481uint64_t Op =Record[OpNum++];

3482Flags =Op & 1;// inbounds

3483unsigned InRangeIndex =Op >> 1;

3484// "Upgrade" inrange by dropping it. The feature is too niche to

3485// bother.

3486 (void)InRangeIndex;

3487 }elseif (BitCode ==bitc::CST_CODE_CE_GEP_WITH_INRANGE) {

3488Flags =Record[OpNum++];

3489Expected<ConstantRange> MaybeInRange =

3490 readBitWidthAndConstantRange(Record, OpNum);

3491if (!MaybeInRange)

3492return MaybeInRange.takeError();

3493InRange = MaybeInRange.get();

3494 }elseif (BitCode ==bitc::CST_CODE_CE_GEP) {

3495Flags =Record[OpNum++];

3496 }elseif (BitCode ==bitc::CST_CODE_CE_INBOUNDS_GEP)

3497Flags = (1 <<bitc::GEP_INBOUNDS);

3498

3499SmallVector<unsigned, 16> Elts;

3500unsigned BaseTypeID =Record[OpNum];

3501while (OpNum !=Record.size()) {

3502unsigned ElTyID =Record[OpNum++];

3503Type *ElTy = getTypeByID(ElTyID);

3504if (!ElTy)

3505returnerror("Invalid getelementptr constexpr record");

3506 Elts.push_back(Record[OpNum++]);

3507 }

3508

3509if (Elts.size() < 1)

3510returnerror("Invalid gep with no operands");

3511

3512Type *BaseType = getTypeByID(BaseTypeID);

3513if (isa<VectorType>(BaseType)) {

3514 BaseTypeID = getContainedTypeID(BaseTypeID, 0);

3515BaseType = getTypeByID(BaseTypeID);

3516 }

3517

3518PointerType *OrigPtrTy = dyn_cast_or_null<PointerType>(BaseType);

3519if (!OrigPtrTy)

3520returnerror("GEP base operand must be pointer or vector of pointer");

3521

3522if (!PointeeType) {

3523 PointeeType = getPtrElementTypeByID(BaseTypeID);

3524if (!PointeeType)

3525returnerror("Missing element type for old-style constant GEP");

3526 }

3527

3528V = BitcodeConstant::create(

3529 Alloc, CurTy,

3530 {Instruction::GetElementPtr,uint8_t(Flags), PointeeType,InRange},

3531 Elts);

3532break;

3533 }

3534casebitc::CST_CODE_CE_SELECT: {// CE_SELECT: [opval#, opval#, opval#]

3535if (Record.size() < 3)

3536returnerror("Invalid select constexpr record");

3537

3538V = BitcodeConstant::create(

3539 Alloc, CurTy, Instruction::Select,

3540 {(unsigned)Record[0], (unsigned)Record[1], (unsigned)Record[2]});

3541break;

3542 }

3543casebitc::CST_CODE_CE_EXTRACTELT

3544 : {// CE_EXTRACTELT: [opty, opval, opty, opval]

3545if (Record.size() < 3)

3546returnerror("Invalid extractelement constexpr record");

3547unsigned OpTyID =Record[0];

3548VectorType *OpTy =

3549 dyn_cast_or_null<VectorType>(getTypeByID(OpTyID));

3550if (!OpTy)

3551returnerror("Invalid extractelement constexpr record");

3552unsigned IdxRecord;

3553if (Record.size() == 4) {

3554unsigned IdxTyID =Record[2];

3555Type *IdxTy = getTypeByID(IdxTyID);

3556if (!IdxTy)

3557returnerror("Invalid extractelement constexpr record");

3558 IdxRecord =Record[3];

3559 }else {

3560// Deprecated, but still needed to read old bitcode files.

3561 IdxRecord =Record[2];

3562 }

3563V = BitcodeConstant::create(Alloc, CurTy, Instruction::ExtractElement,

3564 {(unsigned)Record[1], IdxRecord});

3565break;

3566 }

3567casebitc::CST_CODE_CE_INSERTELT

3568 : {// CE_INSERTELT: [opval, opval, opty, opval]

3569VectorType *OpTy = dyn_cast<VectorType>(CurTy);

3570if (Record.size() < 3 || !OpTy)

3571returnerror("Invalid insertelement constexpr record");

3572unsigned IdxRecord;

3573if (Record.size() == 4) {

3574unsigned IdxTyID =Record[2];

3575Type *IdxTy = getTypeByID(IdxTyID);

3576if (!IdxTy)

3577returnerror("Invalid insertelement constexpr record");

3578 IdxRecord =Record[3];

3579 }else {

3580// Deprecated, but still needed to read old bitcode files.

3581 IdxRecord =Record[2];

3582 }

3583V = BitcodeConstant::create(

3584 Alloc, CurTy, Instruction::InsertElement,

3585 {(unsigned)Record[0], (unsigned)Record[1], IdxRecord});

3586break;

3587 }

3588casebitc::CST_CODE_CE_SHUFFLEVEC: {// CE_SHUFFLEVEC: [opval, opval, opval]

3589VectorType *OpTy = dyn_cast<VectorType>(CurTy);

3590if (Record.size() < 3 || !OpTy)

3591returnerror("Invalid shufflevector constexpr record");

3592V = BitcodeConstant::create(

3593 Alloc, CurTy, Instruction::ShuffleVector,

3594 {(unsigned)Record[0], (unsigned)Record[1], (unsigned)Record[2]});

3595break;

3596 }

3597casebitc::CST_CODE_CE_SHUFVEC_EX: {// [opty, opval, opval, opval]

3598VectorType *RTy = dyn_cast<VectorType>(CurTy);

3599VectorType *OpTy =

3600 dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));

3601if (Record.size() < 4 || !RTy || !OpTy)

3602returnerror("Invalid shufflevector constexpr record");

3603V = BitcodeConstant::create(

3604 Alloc, CurTy, Instruction::ShuffleVector,

3605 {(unsigned)Record[1], (unsigned)Record[2], (unsigned)Record[3]});

3606break;

3607 }

3608casebitc::CST_CODE_CE_CMP: {// CE_CMP: [opty, opval, opval, pred]

3609if (Record.size() < 4)

3610returnerror("Invalid cmp constexpt record");

3611unsigned OpTyID =Record[0];

3612Type *OpTy = getTypeByID(OpTyID);

3613if (!OpTy)

3614returnerror("Invalid cmp constexpr record");

3615V = BitcodeConstant::create(

3616 Alloc, CurTy,

3617 {(uint8_t)(OpTy->isFPOrFPVectorTy() ? Instruction::FCmp

3618 : Instruction::ICmp),

3619 (uint8_t)Record[3]},

3620 {(unsigned)Record[1], (unsigned)Record[2]});

3621break;

3622 }

3623// This maintains backward compatibility, pre-asm dialect keywords.

3624// Deprecated, but still needed to read old bitcode files.

3625casebitc::CST_CODE_INLINEASM_OLD: {

3626if (Record.size() < 2)

3627returnerror("Invalid inlineasm record");

3628 std::string AsmStr, ConstrStr;

3629bool HasSideEffects =Record[0] & 1;

3630bool IsAlignStack =Record[0] >> 1;

3631unsigned AsmStrSize =Record[1];

3632if (2+AsmStrSize >=Record.size())

3633returnerror("Invalid inlineasm record");

3634unsigned ConstStrSize =Record[2+AsmStrSize];

3635if (3+AsmStrSize+ConstStrSize >Record.size())

3636returnerror("Invalid inlineasm record");

3637

3638for (unsigned i = 0; i != AsmStrSize; ++i)

3639 AsmStr += (char)Record[2+i];

3640for (unsigned i = 0; i != ConstStrSize; ++i)

3641 ConstrStr += (char)Record[3+AsmStrSize+i];

3642UpgradeInlineAsmString(&AsmStr);

3643if (!CurElemTy)

3644returnerror("Missing element type for old-style inlineasm");

3645V =InlineAsm::get(cast<FunctionType>(CurElemTy), AsmStr, ConstrStr,

3646 HasSideEffects, IsAlignStack);

3647break;

3648 }

3649// This version adds support for the asm dialect keywords (e.g.,

3650// inteldialect).

3651casebitc::CST_CODE_INLINEASM_OLD2: {

3652if (Record.size() < 2)

3653returnerror("Invalid inlineasm record");

3654 std::string AsmStr, ConstrStr;

3655bool HasSideEffects =Record[0] & 1;

3656bool IsAlignStack = (Record[0] >> 1) & 1;

3657unsigned AsmDialect =Record[0] >> 2;

3658unsigned AsmStrSize =Record[1];

3659if (2+AsmStrSize >=Record.size())

3660returnerror("Invalid inlineasm record");

3661unsigned ConstStrSize =Record[2+AsmStrSize];

3662if (3+AsmStrSize+ConstStrSize >Record.size())

3663returnerror("Invalid inlineasm record");

3664

3665for (unsigned i = 0; i != AsmStrSize; ++i)

3666 AsmStr += (char)Record[2+i];

3667for (unsigned i = 0; i != ConstStrSize; ++i)

3668 ConstrStr += (char)Record[3+AsmStrSize+i];

3669UpgradeInlineAsmString(&AsmStr);

3670if (!CurElemTy)

3671returnerror("Missing element type for old-style inlineasm");

3672V =InlineAsm::get(cast<FunctionType>(CurElemTy), AsmStr, ConstrStr,

3673 HasSideEffects, IsAlignStack,

3674InlineAsm::AsmDialect(AsmDialect));

3675break;

3676 }

3677// This version adds support for the unwind keyword.

3678casebitc::CST_CODE_INLINEASM_OLD3: {

3679if (Record.size() < 2)

3680returnerror("Invalid inlineasm record");

3681unsigned OpNum = 0;

3682 std::string AsmStr, ConstrStr;

3683bool HasSideEffects =Record[OpNum] & 1;

3684bool IsAlignStack = (Record[OpNum] >> 1) & 1;

3685unsigned AsmDialect = (Record[OpNum] >> 2) & 1;

3686bool CanThrow = (Record[OpNum] >> 3) & 1;

3687 ++OpNum;

3688unsigned AsmStrSize =Record[OpNum];

3689 ++OpNum;

3690if (OpNum + AsmStrSize >=Record.size())

3691returnerror("Invalid inlineasm record");

3692unsigned ConstStrSize =Record[OpNum + AsmStrSize];

3693if (OpNum + 1 + AsmStrSize + ConstStrSize >Record.size())

3694returnerror("Invalid inlineasm record");

3695

3696for (unsigned i = 0; i != AsmStrSize; ++i)

3697 AsmStr += (char)Record[OpNum + i];

3698 ++OpNum;

3699for (unsigned i = 0; i != ConstStrSize; ++i)

3700 ConstrStr += (char)Record[OpNum + AsmStrSize + i];

3701UpgradeInlineAsmString(&AsmStr);

3702if (!CurElemTy)

3703returnerror("Missing element type for old-style inlineasm");

3704V =InlineAsm::get(cast<FunctionType>(CurElemTy), AsmStr, ConstrStr,

3705 HasSideEffects, IsAlignStack,

3706InlineAsm::AsmDialect(AsmDialect), CanThrow);

3707break;

3708 }

3709// This version adds explicit function type.

3710casebitc::CST_CODE_INLINEASM: {

3711if (Record.size() < 3)

3712returnerror("Invalid inlineasm record");

3713unsigned OpNum = 0;

3714auto *FnTy = dyn_cast_or_null<FunctionType>(getTypeByID(Record[OpNum]));

3715 ++OpNum;

3716if (!FnTy)

3717returnerror("Invalid inlineasm record");

3718 std::string AsmStr, ConstrStr;

3719bool HasSideEffects =Record[OpNum] & 1;

3720bool IsAlignStack = (Record[OpNum] >> 1) & 1;

3721unsigned AsmDialect = (Record[OpNum] >> 2) & 1;

3722bool CanThrow = (Record[OpNum] >> 3) & 1;

3723 ++OpNum;

3724unsigned AsmStrSize =Record[OpNum];

3725 ++OpNum;

3726if (OpNum + AsmStrSize >=Record.size())

3727returnerror("Invalid inlineasm record");

3728unsigned ConstStrSize =Record[OpNum + AsmStrSize];

3729if (OpNum + 1 + AsmStrSize + ConstStrSize >Record.size())

3730returnerror("Invalid inlineasm record");

3731

3732for (unsigned i = 0; i != AsmStrSize; ++i)

3733 AsmStr += (char)Record[OpNum + i];

3734 ++OpNum;

3735for (unsigned i = 0; i != ConstStrSize; ++i)

3736 ConstrStr += (char)Record[OpNum + AsmStrSize + i];

3737UpgradeInlineAsmString(&AsmStr);

3738V =InlineAsm::get(FnTy, AsmStr, ConstrStr, HasSideEffects, IsAlignStack,

3739InlineAsm::AsmDialect(AsmDialect), CanThrow);

3740break;

3741 }

3742casebitc::CST_CODE_BLOCKADDRESS:{

3743if (Record.size() < 3)

3744returnerror("Invalid blockaddress record");

3745unsigned FnTyID =Record[0];

3746Type *FnTy = getTypeByID(FnTyID);

3747if (!FnTy)

3748returnerror("Invalid blockaddress record");

3749V = BitcodeConstant::create(

3750 Alloc, CurTy,

3751 {BitcodeConstant::BlockAddressOpcode, 0, (unsigned)Record[2]},

3752Record[1]);

3753break;

3754 }

3755casebitc::CST_CODE_DSO_LOCAL_EQUIVALENT: {

3756if (Record.size() < 2)

3757returnerror("Invalid dso_local record");

3758unsigned GVTyID =Record[0];

3759Type *GVTy = getTypeByID(GVTyID);

3760if (!GVTy)

3761returnerror("Invalid dso_local record");

3762V = BitcodeConstant::create(

3763 Alloc, CurTy, BitcodeConstant::DSOLocalEquivalentOpcode,Record[1]);

3764break;

3765 }

3766casebitc::CST_CODE_NO_CFI_VALUE: {

3767if (Record.size() < 2)

3768returnerror("Invalid no_cfi record");

3769unsigned GVTyID =Record[0];

3770Type *GVTy = getTypeByID(GVTyID);

3771if (!GVTy)

3772returnerror("Invalid no_cfi record");

3773V = BitcodeConstant::create(Alloc, CurTy, BitcodeConstant::NoCFIOpcode,

3774Record[1]);

3775break;

3776 }

3777casebitc::CST_CODE_PTRAUTH: {

3778if (Record.size() < 4)

3779returnerror("Invalid ptrauth record");

3780// Ptr, Key, Disc, AddrDisc

3781V = BitcodeConstant::create(Alloc, CurTy,

3782 BitcodeConstant::ConstantPtrAuthOpcode,

3783 {(unsigned)Record[0], (unsigned)Record[1],

3784 (unsigned)Record[2], (unsigned)Record[3]});

3785break;

3786 }

3787 }

3788

3789assert(V->getType() == getTypeByID(CurTyID) &&"Incorrect result type ID");

3790if (Error Err = ValueList.assignValue(NextCstNo, V, CurTyID))

3791return Err;

3792 ++NextCstNo;

3793 }

3794}

3795

3796Error BitcodeReader::parseUseLists() {

3797if (Error Err = Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID))

3798return Err;

3799

3800// Read all the records.

3801SmallVector<uint64_t, 64>Record;

3802

3803while (true) {

3804Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

3805if (!MaybeEntry)

3806return MaybeEntry.takeError();

3807BitstreamEntry Entry = MaybeEntry.get();

3808

3809switch (Entry.Kind) {

3810caseBitstreamEntry::SubBlock:// Handled for us already.

3811caseBitstreamEntry::Error:

3812returnerror("Malformed block");

3813caseBitstreamEntry::EndBlock:

3814returnError::success();

3815caseBitstreamEntry::Record:

3816// The interesting case.

3817break;

3818 }

3819

3820// Read a use list record.

3821Record.clear();

3822bool IsBB =false;

3823Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

3824if (!MaybeRecord)

3825return MaybeRecord.takeError();

3826switch (MaybeRecord.get()) {

3827default:// Default behavior: unknown type.

3828break;

3829casebitc::USELIST_CODE_BB:

3830 IsBB =true;

3831 [[fallthrough]];

3832casebitc::USELIST_CODE_DEFAULT: {

3833unsignedRecordLength =Record.size();

3834if (RecordLength < 3)

3835// Records should have at least an ID and two indexes.

3836returnerror("Invalid record");

3837unsignedID =Record.pop_back_val();

3838

3839Value *V;

3840if (IsBB) {

3841assert(ID < FunctionBBs.size() &&"Basic block not found");

3842V = FunctionBBs[ID];

3843 }else

3844V = ValueList[ID];

3845unsigned NumUses = 0;

3846SmallDenseMap<const Use *, unsigned, 16> Order;

3847for (constUse &U :V->materialized_uses()) {

3848if (++NumUses >Record.size())

3849break;

3850 Order[&U] =Record[NumUses - 1];

3851 }

3852if (Order.size() !=Record.size() || NumUses >Record.size())

3853// Mismatches can happen if the functions are being materialized lazily

3854// (out-of-order), or a value has been upgraded.

3855break;

3856

3857V->sortUseList([&](constUse &L,constUse &R) {

3858return Order.lookup(&L) < Order.lookup(&R);

3859 });

3860break;

3861 }

3862 }

3863 }

3864}

3865

3866/// When we see the block for metadata, remember where it is and then skip it.

3867/// This lets us lazily deserialize the metadata.

3868Error BitcodeReader::rememberAndSkipMetadata() {

3869// Save the current stream state.

3870uint64_t CurBit = Stream.GetCurrentBitNo();

3871 DeferredMetadataInfo.push_back(CurBit);

3872

3873// Skip over the block for now.

3874if (Error Err = Stream.SkipBlock())

3875return Err;

3876returnError::success();

3877}

3878

3879Error BitcodeReader::materializeMetadata() {

3880for (uint64_t BitPos : DeferredMetadataInfo) {

3881// Move the bit stream to the saved position.

3882if (Error JumpFailed = Stream.JumpToBit(BitPos))

3883return JumpFailed;

3884if (Error Err = MDLoader->parseModuleMetadata())

3885return Err;

3886 }

3887

3888// Upgrade "Linker Options" module flag to "llvm.linker.options" module-level

3889// metadata. Only upgrade if the new option doesn't exist to avoid upgrade

3890// multiple times.

3891if (!TheModule->getNamedMetadata("llvm.linker.options")) {

3892if (Metadata *Val = TheModule->getModuleFlag("Linker Options")) {

3893NamedMDNode *LinkerOpts =

3894 TheModule->getOrInsertNamedMetadata("llvm.linker.options");

3895for (constMDOperand &MDOptions : cast<MDNode>(Val)->operands())

3896 LinkerOpts->addOperand(cast<MDNode>(MDOptions));

3897 }

3898 }

3899

3900 DeferredMetadataInfo.clear();

3901returnError::success();

3902}

3903

3904void BitcodeReader::setStripDebugInfo() {StripDebugInfo =true; }

3905

3906/// When we see the block for a function body, remember where it is and then

3907/// skip it. This lets us lazily deserialize the functions.

3908Error BitcodeReader::rememberAndSkipFunctionBody() {

3909// Get the function we are talking about.

3910if (FunctionsWithBodies.empty())

3911returnerror("Insufficient function protos");

3912

3913Function *Fn = FunctionsWithBodies.back();

3914 FunctionsWithBodies.pop_back();

3915

3916// Save the current stream state.

3917uint64_t CurBit = Stream.GetCurrentBitNo();

3918assert(

3919 (DeferredFunctionInfo[Fn] == 0 || DeferredFunctionInfo[Fn] == CurBit) &&

3920"Mismatch between VST and scanned function offsets");

3921 DeferredFunctionInfo[Fn] = CurBit;

3922

3923// Skip over the function block for now.

3924if (Error Err = Stream.SkipBlock())

3925return Err;

3926returnError::success();

3927}

3928

3929Error BitcodeReader::globalCleanup() {

3930// Patch the initializers for globals and aliases up.

3931if (Error Err = resolveGlobalAndIndirectSymbolInits())

3932return Err;

3933if (!GlobalInits.empty() || !IndirectSymbolInits.empty())

3934returnerror("Malformed global initializer set");

3935

3936// Look for intrinsic functions which need to be upgraded at some point

3937// and functions that need to have their function attributes upgraded.

3938for (Function &F : *TheModule) {

3939 MDLoader->upgradeDebugIntrinsics(F);

3940Function *NewFn;

3941// If PreserveInputDbgFormat=true, then we don't know whether we want

3942// intrinsics or records, and we won't perform any conversions in either

3943// case, so don't upgrade intrinsics to records.

3944if (UpgradeIntrinsicFunction(

3945 &F, NewFn,PreserveInputDbgFormat != cl::boolOrDefault::BOU_TRUE))

3946 UpgradedIntrinsics[&F] = NewFn;

3947// Look for functions that rely on old function attribute behavior.

3948UpgradeFunctionAttributes(F);

3949 }

3950

3951// Look for global variables which need to be renamed.

3952 std::vector<std::pair<GlobalVariable *, GlobalVariable *>> UpgradedVariables;

3953for (GlobalVariable &GV : TheModule->globals())

3954if (GlobalVariable *Upgraded =UpgradeGlobalVariable(&GV))

3955 UpgradedVariables.emplace_back(&GV, Upgraded);

3956for (auto &Pair : UpgradedVariables) {

3957 Pair.first->eraseFromParent();

3958 TheModule->insertGlobalVariable(Pair.second);

3959 }

3960

3961// Force deallocation of memory for these vectors to favor the client that

3962// want lazy deserialization.

3963 std::vector<std::pair<GlobalVariable *, unsigned>>().swap(GlobalInits);

3964 std::vector<std::pair<GlobalValue *, unsigned>>().swap(IndirectSymbolInits);

3965returnError::success();

3966}

3967

3968/// Support for lazy parsing of function bodies. This is required if we

3969/// either have an old bitcode file without a VST forward declaration record,

3970/// or if we have an anonymous function being materialized, since anonymous

3971/// functions do not have a name and are therefore not in the VST.

3972Error BitcodeReader::rememberAndSkipFunctionBodies() {

3973if (Error JumpFailed = Stream.JumpToBit(NextUnreadBit))

3974return JumpFailed;

3975

3976if (Stream.AtEndOfStream())

3977returnerror("Could not find function in stream");

3978

3979if (!SeenFirstFunctionBody)

3980returnerror("Trying to materialize functions before seeing function blocks");

3981

3982// An old bitcode file with the symbol table at the end would have

3983// finished the parse greedily.

3984assert(SeenValueSymbolTable);

3985

3986SmallVector<uint64_t, 64>Record;

3987

3988while (true) {

3989Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();

3990if (!MaybeEntry)

3991return MaybeEntry.takeError();

3992llvm::BitstreamEntry Entry = MaybeEntry.get();

3993

3994switch (Entry.Kind) {

3995default:

3996returnerror("Expect SubBlock");

3997caseBitstreamEntry::SubBlock:

3998switch (Entry.ID) {

3999default:

4000returnerror("Expect function block");

4001casebitc::FUNCTION_BLOCK_ID:

4002if (Error Err = rememberAndSkipFunctionBody())

4003return Err;

4004 NextUnreadBit = Stream.GetCurrentBitNo();

4005returnError::success();

4006 }

4007 }

4008 }

4009}

4010

4011Error BitcodeReaderBase::readBlockInfo() {

4012Expected<std::optional<BitstreamBlockInfo>> MaybeNewBlockInfo =

4013 Stream.ReadBlockInfoBlock();

4014if (!MaybeNewBlockInfo)

4015return MaybeNewBlockInfo.takeError();

4016 std::optional<BitstreamBlockInfo> NewBlockInfo =

4017 std::move(MaybeNewBlockInfo.get());

4018if (!NewBlockInfo)

4019returnerror("Malformed block");

4020 BlockInfo = std::move(*NewBlockInfo);

4021returnError::success();

4022}

4023

4024Error BitcodeReader::parseComdatRecord(ArrayRef<uint64_t>Record) {

4025// v1: [selection_kind, name]

4026// v2: [strtab_offset, strtab_size, selection_kind]

4027StringRef Name;

4028 std::tie(Name,Record) = readNameFromStrtab(Record);

4029

4030if (Record.empty())

4031returnerror("Invalid record");

4032Comdat::SelectionKind SK =getDecodedComdatSelectionKind(Record[0]);

4033 std::string OldFormatName;

4034if (!UseStrtab) {

4035if (Record.size() < 2)

4036returnerror("Invalid record");

4037unsigned ComdatNameSize =Record[1];

4038if (ComdatNameSize >Record.size() - 2)

4039returnerror("Comdat name size too large");

4040 OldFormatName.reserve(ComdatNameSize);

4041for (unsigned i = 0; i != ComdatNameSize; ++i)

4042 OldFormatName += (char)Record[2 + i];

4043Name = OldFormatName;

4044 }

4045Comdat *C = TheModule->getOrInsertComdat(Name);

4046C->setSelectionKind(SK);

4047 ComdatList.push_back(C);

4048returnError::success();

4049}

4050

4051staticvoidinferDSOLocal(GlobalValue *GV) {

4052// infer dso_local from linkage and visibility if it is not encoded.

4053if (GV->hasLocalLinkage() ||

4054 (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage()))

4055 GV->setDSOLocal(true);

4056}

4057

4058GlobalValue::SanitizerMetadata deserializeSanitizerMetadata(unsigned V) {

4059GlobalValue::SanitizerMetadata Meta;

4060if (V & (1 << 0))

4061 Meta.NoAddress =true;

4062if (V & (1 << 1))

4063 Meta.NoHWAddress =true;

4064if (V & (1 << 2))

4065 Meta.Memtag =true;

4066if (V & (1 << 3))

4067 Meta.IsDynInit =true;

4068return Meta;

4069}

4070

4071Error BitcodeReader::parseGlobalVarRecord(ArrayRef<uint64_t>Record) {

4072// v1: [pointer type, isconst, initid, linkage, alignment, section,

4073// visibility, threadlocal, unnamed_addr, externally_initialized,

4074// dllstorageclass, comdat, attributes, preemption specifier,

4075// partition strtab offset, partition strtab size] (name in VST)

4076// v2: [strtab_offset, strtab_size, v1]

4077// v3: [v2, code_model]

4078StringRef Name;

4079 std::tie(Name,Record) = readNameFromStrtab(Record);

4080

4081if (Record.size() < 6)

4082returnerror("Invalid record");

4083unsigned TyID =Record[0];

4084Type *Ty = getTypeByID(TyID);

4085if (!Ty)

4086returnerror("Invalid record");

4087boolisConstant =Record[1] & 1;

4088bool explicitType =Record[1] & 2;

4089unsignedAddressSpace;

4090if (explicitType) {

4091AddressSpace =Record[1] >> 2;

4092 }else {

4093if (!Ty->isPointerTy())

4094returnerror("Invalid type for value");

4095AddressSpace = cast<PointerType>(Ty)->getAddressSpace();

4096 TyID = getContainedTypeID(TyID);

4097 Ty = getTypeByID(TyID);

4098if (!Ty)

4099returnerror("Missing element type for old-style global");

4100 }

4101

4102uint64_t RawLinkage =Record[3];

4103GlobalValue::LinkageTypes Linkage =getDecodedLinkage(RawLinkage);

4104MaybeAlign Alignment;

4105if (Error Err = parseAlignmentValue(Record[4], Alignment))

4106return Err;

4107 std::stringSection;

4108if (Record[5]) {

4109if (Record[5] - 1 >= SectionTable.size())

4110returnerror("Invalid ID");

4111Section = SectionTable[Record[5] - 1];

4112 }

4113GlobalValue::VisibilityTypes Visibility =GlobalValue::DefaultVisibility;

4114// Local linkage must have default visibility.

4115// auto-upgrade `hidden` and `protected` for old bitcode.

4116if (Record.size() > 6 && !GlobalValue::isLocalLinkage(Linkage))

4117 Visibility =getDecodedVisibility(Record[6]);

4118

4119GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal;

4120if (Record.size() > 7)

4121 TLM =getDecodedThreadLocalMode(Record[7]);

4122

4123GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;

4124if (Record.size() > 8)

4125 UnnamedAddr =getDecodedUnnamedAddrType(Record[8]);

4126

4127bool ExternallyInitialized =false;

4128if (Record.size() > 9)

4129 ExternallyInitialized =Record[9];

4130

4131GlobalVariable *NewGV =

4132newGlobalVariable(*TheModule, Ty,isConstant, Linkage,nullptr,Name,

4133nullptr, TLM,AddressSpace, ExternallyInitialized);

4134if (Alignment)

4135 NewGV->setAlignment(*Alignment);

4136if (!Section.empty())

4137 NewGV->setSection(Section);

4138 NewGV->setVisibility(Visibility);

4139 NewGV->setUnnamedAddr(UnnamedAddr);

4140

4141if (Record.size() > 10) {

4142// A GlobalValue with local linkage cannot have a DLL storage class.

4143if (!NewGV->hasLocalLinkage()) {

4144 NewGV->setDLLStorageClass(getDecodedDLLStorageClass(Record[10]));

4145 }

4146 }else {

4147upgradeDLLImportExportLinkage(NewGV, RawLinkage);

4148 }

4149

4150 ValueList.push_back(NewGV, getVirtualTypeID(NewGV->getType(), TyID));

4151

4152// Remember which value to use for the global initializer.

4153if (unsigned InitID =Record[2])

4154 GlobalInits.push_back(std::make_pair(NewGV, InitID - 1));

4155

4156if (Record.size() > 11) {

4157if (unsigned ComdatID =Record[11]) {

4158if (ComdatID > ComdatList.size())

4159returnerror("Invalid global variable comdat ID");

4160 NewGV->setComdat(ComdatList[ComdatID - 1]);

4161 }

4162 }elseif (hasImplicitComdat(RawLinkage)) {

4163 ImplicitComdatObjects.insert(NewGV);

4164 }

4165

4166if (Record.size() > 12) {

4167auto AS =getAttributes(Record[12]).getFnAttrs();

4168 NewGV->setAttributes(AS);

4169 }

4170

4171if (Record.size() > 13) {

4172 NewGV->setDSOLocal(getDecodedDSOLocal(Record[13]));

4173 }

4174inferDSOLocal(NewGV);

4175

4176// Check whether we have enough values to read a partition name.

4177if (Record.size() > 15)

4178 NewGV->setPartition(StringRef(Strtab.data() +Record[14],Record[15]));

4179

4180if (Record.size() > 16 &&Record[16]) {

4181llvm::GlobalValue::SanitizerMetadata Meta =

4182deserializeSanitizerMetadata(Record[16]);

4183 NewGV->setSanitizerMetadata(Meta);

4184 }

4185

4186if (Record.size() > 17 &&Record[17]) {

4187if (auto CM =getDecodedCodeModel(Record[17]))

4188 NewGV->setCodeModel(*CM);

4189else

4190returnerror("Invalid global variable code model");

4191 }

4192

4193returnError::success();

4194}

4195

4196void BitcodeReader::callValueTypeCallback(Value *F,unsignedTypeID) {

4197if (ValueTypeCallback) {

4198 (*ValueTypeCallback)(

4199F,TypeID, [this](unsignedI) {return getTypeByID(I); },

4200 [this](unsignedI,unsigned J) {return getContainedTypeID(I, J); });

4201 }

4202}

4203

4204Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t>Record) {

4205// v1: [type, callingconv, isproto, linkage, paramattr, alignment, section,

4206// visibility, gc, unnamed_addr, prologuedata, dllstorageclass, comdat,

4207// prefixdata, personalityfn, preemption specifier, addrspace] (name in VST)

4208// v2: [strtab_offset, strtab_size, v1]

4209StringRef Name;

4210 std::tie(Name,Record) = readNameFromStrtab(Record);

4211

4212if (Record.size() < 8)

4213returnerror("Invalid record");

4214unsigned FTyID =Record[0];

4215Type *FTy = getTypeByID(FTyID);

4216if (!FTy)

4217returnerror("Invalid record");

4218if (isa<PointerType>(FTy)) {

4219 FTyID = getContainedTypeID(FTyID, 0);

4220 FTy = getTypeByID(FTyID);

4221if (!FTy)

4222returnerror("Missing element type for old-style function");

4223 }

4224

4225if (!isa<FunctionType>(FTy))

4226returnerror("Invalid type for value");

4227autoCC =static_cast<CallingConv::ID>(Record[1]);

4228if (CC & ~CallingConv::MaxID)

4229returnerror("Invalid calling convention ID");

4230

4231unsigned AddrSpace = TheModule->getDataLayout().getProgramAddressSpace();

4232if (Record.size() > 16)

4233 AddrSpace =Record[16];

4234

4235Function *Func =

4236Function::Create(cast<FunctionType>(FTy),GlobalValue::ExternalLinkage,

4237 AddrSpace,Name, TheModule);

4238

4239assert(Func->getFunctionType() == FTy &&

4240"Incorrect fully specified type provided for function");

4241 FunctionTypeIDs[Func] = FTyID;

4242

4243Func->setCallingConv(CC);

4244bool isProto =Record[2];

4245uint64_t RawLinkage =Record[3];

4246Func->setLinkage(getDecodedLinkage(RawLinkage));

4247Func->setAttributes(getAttributes(Record[4]));

4248 callValueTypeCallback(Func, FTyID);

4249

4250// Upgrade any old-style byval or sret without a type by propagating the

4251// argument's pointee type. There should be no opaque pointers where the byval

4252// type is implicit.

4253for (unsigned i = 0; i !=Func->arg_size(); ++i) {

4254for (Attribute::AttrKind Kind : {Attribute::ByVal, Attribute::StructRet,

4255 Attribute::InAlloca}) {

4256if (!Func->hasParamAttribute(i, Kind))

4257continue;

4258

4259if (Func->getParamAttribute(i, Kind).getValueAsType())

4260continue;

4261

4262Func->removeParamAttr(i, Kind);

4263

4264unsigned ParamTypeID = getContainedTypeID(FTyID, i + 1);

4265Type *PtrEltTy = getPtrElementTypeByID(ParamTypeID);

4266if (!PtrEltTy)

4267returnerror("Missing param element type for attribute upgrade");

4268

4269Attribute NewAttr;

4270switch (Kind) {

4271case Attribute::ByVal:

4272 NewAttr =Attribute::getWithByValType(Context, PtrEltTy);

4273break;

4274case Attribute::StructRet:

4275 NewAttr =Attribute::getWithStructRetType(Context, PtrEltTy);

4276break;

4277case Attribute::InAlloca:

4278 NewAttr =Attribute::getWithInAllocaType(Context, PtrEltTy);

4279break;

4280default:

4281llvm_unreachable("not an upgraded type attribute");

4282 }

4283

4284Func->addParamAttr(i, NewAttr);

4285 }

4286 }

4287

4288if (Func->getCallingConv() ==CallingConv::X86_INTR &&

4289 !Func->arg_empty() && !Func->hasParamAttribute(0, Attribute::ByVal)) {

4290unsigned ParamTypeID = getContainedTypeID(FTyID, 1);

4291Type *ByValTy = getPtrElementTypeByID(ParamTypeID);

4292if (!ByValTy)

4293returnerror("Missing param element type for x86_intrcc upgrade");

4294Attribute NewAttr =Attribute::getWithByValType(Context, ByValTy);

4295Func->addParamAttr(0, NewAttr);

4296 }

4297

4298MaybeAlign Alignment;

4299if (Error Err = parseAlignmentValue(Record[5], Alignment))

4300return Err;

4301if (Alignment)

4302Func->setAlignment(*Alignment);

4303if (Record[6]) {

4304if (Record[6] - 1 >= SectionTable.size())

4305returnerror("Invalid ID");

4306Func->setSection(SectionTable[Record[6] - 1]);

4307 }

4308// Local linkage must have default visibility.

4309// auto-upgrade `hidden` and `protected` for old bitcode.

4310if (!Func->hasLocalLinkage())

4311Func->setVisibility(getDecodedVisibility(Record[7]));

4312if (Record.size() > 8 &&Record[8]) {

4313if (Record[8] - 1 >= GCTable.size())

4314returnerror("Invalid ID");

4315Func->setGC(GCTable[Record[8] - 1]);

4316 }

4317GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;

4318if (Record.size() > 9)

4319 UnnamedAddr =getDecodedUnnamedAddrType(Record[9]);

4320Func->setUnnamedAddr(UnnamedAddr);

4321

4322 FunctionOperandInfoOperandInfo = {Func, 0, 0, 0};

4323if (Record.size() > 10)

4324OperandInfo.Prologue =Record[10];

4325

4326if (Record.size() > 11) {

4327// A GlobalValue with local linkage cannot have a DLL storage class.

4328if (!Func->hasLocalLinkage()) {

4329Func->setDLLStorageClass(getDecodedDLLStorageClass(Record[11]));

4330 }

4331 }else {

4332upgradeDLLImportExportLinkage(Func, RawLinkage);

4333 }

4334

4335if (Record.size() > 12) {

4336if (unsigned ComdatID =Record[12]) {

4337if (ComdatID > ComdatList.size())

4338returnerror("Invalid function comdat ID");

4339Func->setComdat(ComdatList[ComdatID - 1]);

4340 }

4341 }elseif (hasImplicitComdat(RawLinkage)) {

4342 ImplicitComdatObjects.insert(Func);

4343 }

4344

4345if (Record.size() > 13)

4346OperandInfo.Prefix =Record[13];

4347

4348if (Record.size() > 14)

4349OperandInfo.PersonalityFn =Record[14];

4350

4351if (Record.size() > 15) {

4352Func->setDSOLocal(getDecodedDSOLocal(Record[15]));

4353 }

4354inferDSOLocal(Func);

4355

4356// Record[16] is the address space number.

4357

4358// Check whether we have enough values to read a partition name. Also make

4359// sure Strtab has enough values.

4360if (Record.size() > 18 && Strtab.data() &&

4361Record[17] +Record[18] <= Strtab.size()) {

4362Func->setPartition(StringRef(Strtab.data() +Record[17],Record[18]));

4363 }

4364

4365 ValueList.push_back(Func, getVirtualTypeID(Func->getType(), FTyID));

4366

4367if (OperandInfo.PersonalityFn ||OperandInfo.Prefix ||OperandInfo.Prologue)

4368 FunctionOperands.push_back(OperandInfo);

4369

4370// If this is a function with a body, remember the prototype we are

4371// creating now, so that we can match up the body with them later.

4372if (!isProto) {

4373Func->setIsMaterializable(true);

4374 FunctionsWithBodies.push_back(Func);

4375 DeferredFunctionInfo[Func] = 0;

4376 }

4377returnError::success();

4378}

4379

4380Error BitcodeReader::parseGlobalIndirectSymbolRecord(

4381unsigned BitCode,ArrayRef<uint64_t>Record) {

4382// v1 ALIAS_OLD: [alias type, aliasee val#, linkage] (name in VST)

4383// v1 ALIAS: [alias type, addrspace, aliasee val#, linkage, visibility,

4384// dllstorageclass, threadlocal, unnamed_addr,

4385// preemption specifier] (name in VST)

4386// v1 IFUNC: [alias type, addrspace, aliasee val#, linkage,

4387// visibility, dllstorageclass, threadlocal, unnamed_addr,

4388// preemption specifier] (name in VST)

4389// v2: [strtab_offset, strtab_size, v1]

4390StringRef Name;

4391 std::tie(Name,Record) = readNameFromStrtab(Record);

4392

4393bool NewRecord = BitCode !=bitc::MODULE_CODE_ALIAS_OLD;

4394if (Record.size() < (3 + (unsigned)NewRecord))

4395returnerror("Invalid record");

4396unsigned OpNum = 0;

4397unsignedTypeID =Record[OpNum++];

4398Type *Ty = getTypeByID(TypeID);

4399if (!Ty)

4400returnerror("Invalid record");

4401

4402unsigned AddrSpace;

4403if (!NewRecord) {

4404auto *PTy = dyn_cast<PointerType>(Ty);

4405if (!PTy)

4406returnerror("Invalid type for value");

4407 AddrSpace = PTy->getAddressSpace();

4408TypeID = getContainedTypeID(TypeID);

4409 Ty = getTypeByID(TypeID);

4410if (!Ty)

4411returnerror("Missing element type for old-style indirect symbol");

4412 }else {

4413 AddrSpace =Record[OpNum++];

4414 }

4415

4416auto Val =Record[OpNum++];

4417autoLinkage =Record[OpNum++];

4418GlobalValue *NewGA;

4419if (BitCode ==bitc::MODULE_CODE_ALIAS ||

4420 BitCode ==bitc::MODULE_CODE_ALIAS_OLD)

4421 NewGA =GlobalAlias::create(Ty, AddrSpace,getDecodedLinkage(Linkage),Name,

4422 TheModule);

4423else

4424 NewGA =GlobalIFunc::create(Ty, AddrSpace,getDecodedLinkage(Linkage),Name,

4425nullptr, TheModule);

4426

4427// Local linkage must have default visibility.

4428// auto-upgrade `hidden` and `protected` for old bitcode.

4429if (OpNum !=Record.size()) {

4430auto VisInd = OpNum++;

4431if (!NewGA->hasLocalLinkage())

4432 NewGA->setVisibility(getDecodedVisibility(Record[VisInd]));

4433 }

4434if (BitCode ==bitc::MODULE_CODE_ALIAS ||

4435 BitCode ==bitc::MODULE_CODE_ALIAS_OLD) {

4436if (OpNum !=Record.size()) {

4437auto S =Record[OpNum++];

4438// A GlobalValue with local linkage cannot have a DLL storage class.

4439if (!NewGA->hasLocalLinkage())

4440 NewGA->setDLLStorageClass(getDecodedDLLStorageClass(S));

4441 }

4442else

4443upgradeDLLImportExportLinkage(NewGA, Linkage);

4444if (OpNum !=Record.size())

4445 NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[OpNum++]));

4446if (OpNum !=Record.size())

4447 NewGA->setUnnamedAddr(getDecodedUnnamedAddrType(Record[OpNum++]));

4448 }

4449if (OpNum !=Record.size())

4450 NewGA->setDSOLocal(getDecodedDSOLocal(Record[OpNum++]));

4451inferDSOLocal(NewGA);

4452

4453// Check whether we have enough values to read a partition name.

4454if (OpNum + 1 <Record.size()) {

4455// Check Strtab has enough values for the partition.

4456if (Record[OpNum] +Record[OpNum + 1] > Strtab.size())

4457returnerror("Malformed partition, too large.");

4458 NewGA->setPartition(

4459StringRef(Strtab.data() +Record[OpNum],Record[OpNum + 1]));

4460 }

4461

4462 ValueList.push_back(NewGA, getVirtualTypeID(NewGA->getType(),TypeID));

4463 IndirectSymbolInits.push_back(std::make_pair(NewGA, Val));

4464returnError::success();

4465}

4466

4467Error BitcodeReader::parseModule(uint64_t ResumeBit,

4468bool ShouldLazyLoadMetadata,

4469ParserCallbacks Callbacks) {

4470// Load directly into RemoveDIs format if LoadBitcodeIntoNewDbgInfoFormat

4471// has been set to true and we aren't attempting to preserve the existing

4472// format in the bitcode (default action: load into the old debug format).

4473if (PreserveInputDbgFormat != cl::boolOrDefault::BOU_TRUE) {

4474 TheModule->IsNewDbgInfoFormat =

4475UseNewDbgInfoFormat &&

4476LoadBitcodeIntoNewDbgInfoFormat != cl::boolOrDefault::BOU_FALSE;

4477 }

4478

4479 this->ValueTypeCallback = std::move(Callbacks.ValueType);

4480if (ResumeBit) {

4481if (Error JumpFailed = Stream.JumpToBit(ResumeBit))

4482return JumpFailed;

4483 }elseif (Error Err = Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))

4484return Err;

4485

4486SmallVector<uint64_t, 64>Record;

4487

4488// Parts of bitcode parsing depend on the datalayout. Make sure we

4489// finalize the datalayout before we run any of that code.

4490bool ResolvedDataLayout =false;

4491// In order to support importing modules with illegal data layout strings,

4492// delay parsing the data layout string until after upgrades and overrides

4493// have been applied, allowing to fix illegal data layout strings.

4494// Initialize to the current module's layout string in case none is specified.

4495 std::string TentativeDataLayoutStr = TheModule->getDataLayoutStr();

4496

4497auto ResolveDataLayout = [&]() ->Error {

4498if (ResolvedDataLayout)

4499returnError::success();

4500

4501// Datalayout and triple can't be parsed after this point.

4502 ResolvedDataLayout =true;

4503

4504// Auto-upgrade the layout string

4505 TentativeDataLayoutStr =llvm::UpgradeDataLayoutString(

4506 TentativeDataLayoutStr, TheModule->getTargetTriple());

4507

4508// Apply override

4509if (Callbacks.DataLayout) {

4510if (auto LayoutOverride = (*Callbacks.DataLayout)(

4511 TheModule->getTargetTriple(), TentativeDataLayoutStr))

4512 TentativeDataLayoutStr = *LayoutOverride;

4513 }

4514

4515// Now the layout string is finalized in TentativeDataLayoutStr. Parse it.

4516Expected<DataLayout> MaybeDL =DataLayout::parse(TentativeDataLayoutStr);

4517if (!MaybeDL)

4518return MaybeDL.takeError();

4519

4520 TheModule->setDataLayout(MaybeDL.get());

4521returnError::success();

4522 };

4523

4524// Read all the records for this module.

4525while (true) {

4526Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();

4527if (!MaybeEntry)

4528return MaybeEntry.takeError();

4529llvm::BitstreamEntry Entry = MaybeEntry.get();

4530

4531switch (Entry.Kind) {

4532caseBitstreamEntry::Error:

4533returnerror("Malformed block");

4534caseBitstreamEntry::EndBlock:

4535if (Error Err = ResolveDataLayout())

4536return Err;

4537return globalCleanup();

4538

4539caseBitstreamEntry::SubBlock:

4540switch (Entry.ID) {

4541default:// Skip unknown content.

4542if (Error Err = Stream.SkipBlock())

4543return Err;

4544break;

4545casebitc::BLOCKINFO_BLOCK_ID:

4546if (Error Err = readBlockInfo())

4547return Err;

4548break;

4549casebitc::PARAMATTR_BLOCK_ID:

4550if (Error Err = parseAttributeBlock())

4551return Err;

4552break;

4553casebitc::PARAMATTR_GROUP_BLOCK_ID:

4554if (Error Err = parseAttributeGroupBlock())

4555return Err;

4556break;

4557casebitc::TYPE_BLOCK_ID_NEW:

4558if (Error Err = parseTypeTable())

4559return Err;

4560break;

4561casebitc::VALUE_SYMTAB_BLOCK_ID:

4562if (!SeenValueSymbolTable) {

4563// Either this is an old form VST without function index and an

4564// associated VST forward declaration record (which would have caused

4565// the VST to be jumped to and parsed before it was encountered

4566// normally in the stream), or there were no function blocks to

4567// trigger an earlier parsing of the VST.

4568assert(VSTOffset == 0 || FunctionsWithBodies.empty());

4569if (Error Err = parseValueSymbolTable())

4570return Err;

4571 SeenValueSymbolTable =true;

4572 }else {

4573// We must have had a VST forward declaration record, which caused

4574// the parser to jump to and parse the VST earlier.

4575assert(VSTOffset > 0);

4576if (Error Err = Stream.SkipBlock())

4577return Err;

4578 }

4579break;

4580casebitc::CONSTANTS_BLOCK_ID:

4581if (Error Err = parseConstants())

4582return Err;

4583if (Error Err = resolveGlobalAndIndirectSymbolInits())

4584return Err;

4585break;

4586casebitc::METADATA_BLOCK_ID:

4587if (ShouldLazyLoadMetadata) {

4588if (Error Err = rememberAndSkipMetadata())

4589return Err;

4590break;

4591 }

4592assert(DeferredMetadataInfo.empty() &&"Unexpected deferred metadata");

4593if (Error Err = MDLoader->parseModuleMetadata())

4594return Err;

4595break;

4596casebitc::METADATA_KIND_BLOCK_ID:

4597if (Error Err = MDLoader->parseMetadataKinds())

4598return Err;

4599break;

4600casebitc::FUNCTION_BLOCK_ID:

4601if (Error Err = ResolveDataLayout())

4602return Err;

4603

4604// If this is the first function body we've seen, reverse the

4605// FunctionsWithBodies list.

4606if (!SeenFirstFunctionBody) {

4607 std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end());

4608if (Error Err = globalCleanup())

4609return Err;

4610 SeenFirstFunctionBody =true;

4611 }

4612

4613if (VSTOffset > 0) {

4614// If we have a VST forward declaration record, make sure we

4615// parse the VST now if we haven't already. It is needed to

4616// set up the DeferredFunctionInfo vector for lazy reading.

4617if (!SeenValueSymbolTable) {

4618if (Error Err = BitcodeReader::parseValueSymbolTable(VSTOffset))

4619return Err;

4620 SeenValueSymbolTable =true;

4621// Fall through so that we record the NextUnreadBit below.

4622// This is necessary in case we have an anonymous function that

4623// is later materialized. Since it will not have a VST entry we

4624// need to fall back to the lazy parse to find its offset.

4625 }else {

4626// If we have a VST forward declaration record, but have already

4627// parsed the VST (just above, when the first function body was

4628// encountered here), then we are resuming the parse after

4629// materializing functions. The ResumeBit points to the

4630// start of the last function block recorded in the

4631// DeferredFunctionInfo map. Skip it.

4632if (Error Err = Stream.SkipBlock())

4633return Err;

4634continue;

4635 }

4636 }

4637

4638// Support older bitcode files that did not have the function

4639// index in the VST, nor a VST forward declaration record, as

4640// well as anonymous functions that do not have VST entries.

4641// Build the DeferredFunctionInfo vector on the fly.

4642if (Error Err = rememberAndSkipFunctionBody())

4643return Err;

4644

4645// Suspend parsing when we reach the function bodies. Subsequent

4646// materialization calls will resume it when necessary. If the bitcode

4647// file is old, the symbol table will be at the end instead and will not

4648// have been seen yet. In this case, just finish the parse now.

4649if (SeenValueSymbolTable) {

4650 NextUnreadBit = Stream.GetCurrentBitNo();

4651// After the VST has been parsed, we need to make sure intrinsic name

4652// are auto-upgraded.

4653return globalCleanup();

4654 }

4655break;

4656casebitc::USELIST_BLOCK_ID:

4657if (Error Err = parseUseLists())

4658return Err;

4659break;

4660casebitc::OPERAND_BUNDLE_TAGS_BLOCK_ID:

4661if (Error Err = parseOperandBundleTags())

4662return Err;

4663break;

4664casebitc::SYNC_SCOPE_NAMES_BLOCK_ID:

4665if (Error Err = parseSyncScopeNames())

4666return Err;

4667break;

4668 }

4669continue;

4670

4671caseBitstreamEntry::Record:

4672// The interesting case.

4673break;

4674 }

4675

4676// Read a record.

4677Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID,Record);

4678if (!MaybeBitCode)

4679return MaybeBitCode.takeError();

4680switch (unsigned BitCode = MaybeBitCode.get()) {

4681default:break;// Default behavior, ignore unknown content.

4682casebitc::MODULE_CODE_VERSION: {

4683Expected<unsigned> VersionOrErr = parseVersionRecord(Record);

4684if (!VersionOrErr)

4685return VersionOrErr.takeError();

4686 UseRelativeIDs = *VersionOrErr >= 1;

4687break;

4688 }

4689casebitc::MODULE_CODE_TRIPLE: {// TRIPLE: [strchr x N]

4690if (ResolvedDataLayout)

4691returnerror("target triple too late in module");

4692 std::string S;

4693if (convertToString(Record, 0, S))

4694returnerror("Invalid record");

4695 TheModule->setTargetTriple(S);

4696break;

4697 }

4698casebitc::MODULE_CODE_DATALAYOUT: {// DATALAYOUT: [strchr x N]

4699if (ResolvedDataLayout)

4700returnerror("datalayout too late in module");

4701if (convertToString(Record, 0, TentativeDataLayoutStr))

4702returnerror("Invalid record");

4703break;

4704 }

4705casebitc::MODULE_CODE_ASM: {// ASM: [strchr x N]

4706 std::string S;

4707if (convertToString(Record, 0, S))

4708returnerror("Invalid record");

4709 TheModule->setModuleInlineAsm(S);

4710break;

4711 }

4712casebitc::MODULE_CODE_DEPLIB: {// DEPLIB: [strchr x N]

4713// Deprecated, but still needed to read old bitcode files.

4714 std::string S;

4715if (convertToString(Record, 0, S))

4716returnerror("Invalid record");

4717// Ignore value.

4718break;

4719 }

4720casebitc::MODULE_CODE_SECTIONNAME: {// SECTIONNAME: [strchr x N]

4721 std::string S;

4722if (convertToString(Record, 0, S))

4723returnerror("Invalid record");

4724 SectionTable.push_back(S);

4725break;

4726 }

4727casebitc::MODULE_CODE_GCNAME: {// SECTIONNAME: [strchr x N]

4728 std::string S;

4729if (convertToString(Record, 0, S))

4730returnerror("Invalid record");

4731 GCTable.push_back(S);

4732break;

4733 }

4734casebitc::MODULE_CODE_COMDAT:

4735if (Error Err = parseComdatRecord(Record))

4736return Err;

4737break;

4738// FIXME: BitcodeReader should handle {GLOBALVAR, FUNCTION, ALIAS, IFUNC}

4739// written by ThinLinkBitcodeWriter. See

4740// `ThinLinkBitcodeWriter::writeSimplifiedModuleInfo` for the format of each

4741// record

4742// (https://github.com/llvm/llvm-project/blob/b6a93967d9c11e79802b5e75cec1584d6c8aa472/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp#L4714)

4743casebitc::MODULE_CODE_GLOBALVAR:

4744if (Error Err = parseGlobalVarRecord(Record))

4745return Err;

4746break;

4747casebitc::MODULE_CODE_FUNCTION:

4748if (Error Err = ResolveDataLayout())

4749return Err;

4750if (Error Err = parseFunctionRecord(Record))

4751return Err;

4752break;

4753casebitc::MODULE_CODE_IFUNC:

4754casebitc::MODULE_CODE_ALIAS:

4755casebitc::MODULE_CODE_ALIAS_OLD:

4756if (Error Err = parseGlobalIndirectSymbolRecord(BitCode,Record))

4757return Err;

4758break;

4759 /// MODULE_CODE_VSTOFFSET: [offset]

4760casebitc::MODULE_CODE_VSTOFFSET:

4761if (Record.empty())

4762returnerror("Invalid record");

4763// Note that we subtract 1 here because the offset is relative to one word

4764// before the start of the identification or module block, which was

4765// historically always the start of the regular bitcode header.

4766 VSTOffset =Record[0] - 1;

4767break;

4768 /// MODULE_CODE_SOURCE_FILENAME: [namechar x N]

4769casebitc::MODULE_CODE_SOURCE_FILENAME:

4770SmallString<128>ValueName;

4771if (convertToString(Record, 0,ValueName))

4772returnerror("Invalid record");

4773 TheModule->setSourceFileName(ValueName);

4774break;

4775 }

4776Record.clear();

4777 }

4778 this->ValueTypeCallback = std::nullopt;

4779returnError::success();

4780}

4781

4782Error BitcodeReader::parseBitcodeInto(Module *M,bool ShouldLazyLoadMetadata,

4783bool IsImporting,

4784ParserCallbacks Callbacks) {

4785 TheModule =M;

4786MetadataLoaderCallbacks MDCallbacks;

4787 MDCallbacks.GetTypeByID = [&](unsignedID) {return getTypeByID(ID); };

4788 MDCallbacks.GetContainedTypeID = [&](unsignedI,unsigned J) {

4789return getContainedTypeID(I, J);

4790 };

4791 MDCallbacks.MDType = Callbacks.MDType;

4792 MDLoader =MetadataLoader(Stream, *M, ValueList, IsImporting, MDCallbacks);

4793returnparseModule(0, ShouldLazyLoadMetadata, Callbacks);

4794}

4795

4796Error BitcodeReader::typeCheckLoadStoreInst(Type *ValType,Type *PtrType) {

4797if (!isa<PointerType>(PtrType))

4798returnerror("Load/Store operand is not a pointer type");

4799if (!PointerType::isLoadableOrStorableType(ValType))

4800returnerror("Cannot load/store from pointer");

4801returnError::success();

4802}

4803

4804Error BitcodeReader::propagateAttributeTypes(CallBase *CB,

4805ArrayRef<unsigned> ArgTyIDs) {

4806AttributeList Attrs = CB->getAttributes();

4807for (unsigned i = 0; i != CB->arg_size(); ++i) {

4808for (Attribute::AttrKind Kind : {Attribute::ByVal, Attribute::StructRet,

4809 Attribute::InAlloca}) {

4810if (!Attrs.hasParamAttr(i, Kind) ||

4811Attrs.getParamAttr(i, Kind).getValueAsType())

4812continue;

4813

4814Type *PtrEltTy = getPtrElementTypeByID(ArgTyIDs[i]);

4815if (!PtrEltTy)

4816returnerror("Missing element type for typed attribute upgrade");

4817

4818Attribute NewAttr;

4819switch (Kind) {

4820case Attribute::ByVal:

4821 NewAttr =Attribute::getWithByValType(Context, PtrEltTy);

4822break;

4823case Attribute::StructRet:

4824 NewAttr =Attribute::getWithStructRetType(Context, PtrEltTy);

4825break;

4826case Attribute::InAlloca:

4827 NewAttr =Attribute::getWithInAllocaType(Context, PtrEltTy);

4828break;

4829default:

4830llvm_unreachable("not an upgraded type attribute");

4831 }

4832

4833Attrs =Attrs.addParamAttribute(Context, i, NewAttr);

4834 }

4835 }

4836

4837if (CB->isInlineAsm()) {

4838constInlineAsm *IA = cast<InlineAsm>(CB->getCalledOperand());

4839unsigned ArgNo = 0;

4840for (constInlineAsm::ConstraintInfo &CI :IA->ParseConstraints()) {

4841if (!CI.hasArg())

4842continue;

4843

4844if (CI.isIndirect && !Attrs.getParamElementType(ArgNo)) {

4845Type *ElemTy = getPtrElementTypeByID(ArgTyIDs[ArgNo]);

4846if (!ElemTy)

4847returnerror("Missing element type for inline asm upgrade");

4848Attrs =Attrs.addParamAttribute(

4849 Context, ArgNo,

4850Attribute::get(Context, Attribute::ElementType, ElemTy));

4851 }

4852

4853 ArgNo++;

4854 }

4855 }

4856

4857switch (CB->getIntrinsicID()) {

4858case Intrinsic::preserve_array_access_index:

4859case Intrinsic::preserve_struct_access_index:

4860case Intrinsic::aarch64_ldaxr:

4861case Intrinsic::aarch64_ldxr:

4862case Intrinsic::aarch64_stlxr:

4863case Intrinsic::aarch64_stxr:

4864case Intrinsic::arm_ldaex:

4865case Intrinsic::arm_ldrex:

4866case Intrinsic::arm_stlex:

4867case Intrinsic::arm_strex: {

4868unsigned ArgNo;

4869switch (CB->getIntrinsicID()) {

4870case Intrinsic::aarch64_stlxr:

4871case Intrinsic::aarch64_stxr:

4872case Intrinsic::arm_stlex:

4873case Intrinsic::arm_strex:

4874 ArgNo = 1;

4875break;

4876default:

4877 ArgNo = 0;

4878break;

4879 }

4880if (!Attrs.getParamElementType(ArgNo)) {

4881Type *ElTy = getPtrElementTypeByID(ArgTyIDs[ArgNo]);

4882if (!ElTy)

4883returnerror("Missing element type for elementtype upgrade");

4884Attribute NewAttr =Attribute::get(Context, Attribute::ElementType, ElTy);

4885Attrs =Attrs.addParamAttribute(Context, ArgNo, NewAttr);

4886 }

4887break;

4888 }

4889default:

4890break;

4891 }

4892

4893 CB->setAttributes(Attrs);

4894returnError::success();

4895}

4896

4897/// Lazily parse the specified function body block.

4898Error BitcodeReader::parseFunctionBody(Function *F) {

4899if (Error Err = Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))

4900return Err;

4901

4902// Unexpected unresolved metadata when parsing function.

4903if (MDLoader->hasFwdRefs())

4904returnerror("Invalid function metadata: incoming forward references");

4905

4906 InstructionList.clear();

4907unsigned ModuleValueListSize = ValueList.size();

4908unsigned ModuleMDLoaderSize = MDLoader->size();

4909

4910// Add all the function arguments to the value table.

4911unsigned ArgNo = 0;

4912unsigned FTyID = FunctionTypeIDs[F];

4913for (Argument &I :F->args()) {

4914unsigned ArgTyID = getContainedTypeID(FTyID, ArgNo + 1);

4915assert(I.getType() == getTypeByID(ArgTyID) &&

4916"Incorrect fully specified type for Function Argument");

4917 ValueList.push_back(&I, ArgTyID);

4918 ++ArgNo;

4919 }

4920unsigned NextValueNo = ValueList.size();

4921BasicBlock *CurBB =nullptr;

4922unsigned CurBBNo = 0;

4923// Block into which constant expressions from phi nodes are materialized.

4924BasicBlock *PhiConstExprBB =nullptr;

4925// Edge blocks for phi nodes into which constant expressions have been

4926// expanded.

4927SmallMapVector<std::pair<BasicBlock *, BasicBlock *>,BasicBlock *, 4>

4928 ConstExprEdgeBBs;

4929

4930DebugLoc LastLoc;

4931auto getLastInstruction = [&]() ->Instruction * {

4932if (CurBB && !CurBB->empty())

4933return &CurBB->back();

4934elseif (CurBBNo && FunctionBBs[CurBBNo - 1] &&

4935 !FunctionBBs[CurBBNo - 1]->empty())

4936return &FunctionBBs[CurBBNo - 1]->back();

4937returnnullptr;

4938 };

4939

4940 std::vector<OperandBundleDef> OperandBundles;

4941

4942// Read all the records.

4943SmallVector<uint64_t, 64>Record;

4944

4945while (true) {

4946Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();

4947if (!MaybeEntry)

4948return MaybeEntry.takeError();

4949llvm::BitstreamEntry Entry = MaybeEntry.get();

4950

4951switch (Entry.Kind) {

4952caseBitstreamEntry::Error:

4953returnerror("Malformed block");

4954caseBitstreamEntry::EndBlock:

4955goto OutOfRecordLoop;

4956

4957caseBitstreamEntry::SubBlock:

4958switch (Entry.ID) {

4959default:// Skip unknown content.

4960if (Error Err = Stream.SkipBlock())

4961return Err;

4962break;

4963casebitc::CONSTANTS_BLOCK_ID:

4964if (Error Err = parseConstants())

4965return Err;

4966 NextValueNo = ValueList.size();

4967break;

4968casebitc::VALUE_SYMTAB_BLOCK_ID:

4969if (Error Err = parseValueSymbolTable())

4970return Err;

4971break;

4972casebitc::METADATA_ATTACHMENT_ID:

4973if (Error Err = MDLoader->parseMetadataAttachment(*F, InstructionList))

4974return Err;

4975break;

4976casebitc::METADATA_BLOCK_ID:

4977assert(DeferredMetadataInfo.empty() &&

4978"Must read all module-level metadata before function-level");

4979if (Error Err = MDLoader->parseFunctionMetadata())

4980return Err;

4981break;

4982casebitc::USELIST_BLOCK_ID:

4983if (Error Err = parseUseLists())

4984return Err;

4985break;

4986 }

4987continue;

4988

4989caseBitstreamEntry::Record:

4990// The interesting case.

4991break;

4992 }

4993

4994// Read a record.

4995Record.clear();

4996Instruction *I =nullptr;

4997unsigned ResTypeID = InvalidTypeID;

4998Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID,Record);

4999if (!MaybeBitCode)

5000return MaybeBitCode.takeError();

5001switch (unsigned BitCode = MaybeBitCode.get()) {

5002default:// Default behavior: reject

5003returnerror("Invalid value");

5004casebitc::FUNC_CODE_DECLAREBLOCKS: {// DECLAREBLOCKS: [nblocks]

5005if (Record.empty() ||Record[0] == 0)

5006returnerror("Invalid record");

5007// Create all the basic blocks for the function.

5008 FunctionBBs.resize(Record[0]);

5009

5010// See if anything took the address of blocks in this function.

5011auto BBFRI = BasicBlockFwdRefs.find(F);

5012if (BBFRI == BasicBlockFwdRefs.end()) {

5013for (BasicBlock *&BB : FunctionBBs)

5014 BB =BasicBlock::Create(Context,"",F);

5015 }else {

5016auto &BBRefs = BBFRI->second;

5017// Check for invalid basic block references.

5018if (BBRefs.size() > FunctionBBs.size())

5019returnerror("Invalid ID");

5020assert(!BBRefs.empty() &&"Unexpected empty array");

5021assert(!BBRefs.front() &&"Invalid reference to entry block");

5022for (unsignedI = 0, E = FunctionBBs.size(), RE = BBRefs.size();I != E;

5023 ++I)

5024if (I < RE && BBRefs[I]) {

5025 BBRefs[I]->insertInto(F);

5026 FunctionBBs[I] = BBRefs[I];

5027 }else {

5028 FunctionBBs[I] =BasicBlock::Create(Context,"",F);

5029 }

5030

5031// Erase from the table.

5032 BasicBlockFwdRefs.erase(BBFRI);

5033 }

5034

5035 CurBB = FunctionBBs[0];

5036continue;

5037 }

5038

5039casebitc::FUNC_CODE_BLOCKADDR_USERS:// BLOCKADDR_USERS: [vals...]

5040// The record should not be emitted if it's an empty list.

5041if (Record.empty())

5042returnerror("Invalid record");

5043// When we have the RARE case of a BlockAddress Constant that is not

5044// scoped to the Function it refers to, we need to conservatively

5045// materialize the referred to Function, regardless of whether or not

5046// that Function will ultimately be linked, otherwise users of

5047// BitcodeReader might start splicing out Function bodies such that we

5048// might no longer be able to materialize the BlockAddress since the

5049// BasicBlock (and entire body of the Function) the BlockAddress refers

5050// to may have been moved. In the case that the user of BitcodeReader

5051// decides ultimately not to link the Function body, materializing here

5052// could be considered wasteful, but it's better than a deserialization

5053// failure as described. This keeps BitcodeReader unaware of complex

5054// linkage policy decisions such as those use by LTO, leaving those

5055// decisions "one layer up."

5056for (uint64_t ValID :Record)

5057if (auto *F = dyn_cast<Function>(ValueList[ValID]))

5058 BackwardRefFunctions.push_back(F);

5059else

5060returnerror("Invalid record");

5061

5062continue;

5063

5064casebitc::FUNC_CODE_DEBUG_LOC_AGAIN:// DEBUG_LOC_AGAIN

5065// This record indicates that the last instruction is at the same

5066// location as the previous instruction with a location.

5067I = getLastInstruction();

5068

5069if (!I)

5070returnerror("Invalid record");

5071I->setDebugLoc(LastLoc);

5072I =nullptr;

5073continue;

5074

5075casebitc::FUNC_CODE_DEBUG_LOC: {// DEBUG_LOC: [line, col, scope, ia]

5076I = getLastInstruction();

5077if (!I ||Record.size() < 4)

5078returnerror("Invalid record");

5079

5080unsignedLine =Record[0], Col =Record[1];

5081unsigned ScopeID =Record[2], IAID =Record[3];

5082bool isImplicitCode =Record.size() == 5 &&Record[4];

5083

5084MDNode *Scope =nullptr, *IA =nullptr;

5085if (ScopeID) {

5086Scope = dyn_cast_or_null<MDNode>(

5087 MDLoader->getMetadataFwdRefOrLoad(ScopeID - 1));

5088if (!Scope)

5089returnerror("Invalid record");

5090 }

5091if (IAID) {

5092IA = dyn_cast_or_null<MDNode>(

5093 MDLoader->getMetadataFwdRefOrLoad(IAID - 1));

5094if (!IA)

5095returnerror("Invalid record");

5096 }

5097 LastLoc = DILocation::get(Scope->getContext(), Line, Col, Scope, IA,

5098 isImplicitCode);

5099I->setDebugLoc(LastLoc);

5100I =nullptr;

5101continue;

5102 }

5103casebitc::FUNC_CODE_INST_UNOP: {// UNOP: [opval, ty, opcode]

5104unsigned OpNum = 0;

5105Value *LHS;

5106unsignedTypeID;

5107if (getValueTypePair(Record, OpNum, NextValueNo, LHS,TypeID, CurBB) ||

5108 OpNum+1 >Record.size())

5109returnerror("Invalid record");

5110

5111int Opc =getDecodedUnaryOpcode(Record[OpNum++],LHS->getType());

5112if (Opc == -1)

5113returnerror("Invalid record");

5114I =UnaryOperator::Create((Instruction::UnaryOps)Opc, LHS);

5115 ResTypeID =TypeID;

5116 InstructionList.push_back(I);

5117if (OpNum <Record.size()) {

5118if (isa<FPMathOperator>(I)) {

5119FastMathFlags FMF =getDecodedFastMathFlags(Record[OpNum]);

5120if (FMF.any())

5121I->setFastMathFlags(FMF);

5122 }

5123 }

5124break;

5125 }

5126casebitc::FUNC_CODE_INST_BINOP: {// BINOP: [opval, ty, opval, opcode]

5127unsigned OpNum = 0;

5128Value *LHS, *RHS;

5129unsignedTypeID;

5130if (getValueTypePair(Record, OpNum, NextValueNo, LHS,TypeID, CurBB) ||

5131 popValue(Record, OpNum, NextValueNo,LHS->getType(),TypeID, RHS,

5132 CurBB) ||

5133 OpNum+1 >Record.size())

5134returnerror("Invalid record");

5135

5136int Opc =getDecodedBinaryOpcode(Record[OpNum++],LHS->getType());

5137if (Opc == -1)

5138returnerror("Invalid record");

5139I =BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);

5140 ResTypeID =TypeID;

5141 InstructionList.push_back(I);

5142if (OpNum <Record.size()) {

5143if (Opc == Instruction::Add ||

5144 Opc == Instruction::Sub ||

5145 Opc == Instruction::Mul ||

5146 Opc == Instruction::Shl) {

5147if (Record[OpNum] & (1 <<bitc::OBO_NO_SIGNED_WRAP))

5148 cast<BinaryOperator>(I)->setHasNoSignedWrap(true);

5149if (Record[OpNum] & (1 <<bitc::OBO_NO_UNSIGNED_WRAP))

5150 cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true);

5151 }elseif (Opc == Instruction::SDiv ||

5152 Opc == Instruction::UDiv ||

5153 Opc == Instruction::LShr ||

5154 Opc == Instruction::AShr) {

5155if (Record[OpNum] & (1 <<bitc::PEO_EXACT))

5156 cast<BinaryOperator>(I)->setIsExact(true);

5157 }elseif (Opc == Instruction::Or) {

5158if (Record[OpNum] & (1 <<bitc::PDI_DISJOINT))

5159 cast<PossiblyDisjointInst>(I)->setIsDisjoint(true);

5160 }elseif (isa<FPMathOperator>(I)) {

5161FastMathFlags FMF =getDecodedFastMathFlags(Record[OpNum]);

5162if (FMF.any())

5163I->setFastMathFlags(FMF);

5164 }

5165 }

5166break;

5167 }

5168casebitc::FUNC_CODE_INST_CAST: {// CAST: [opval, opty, destty, castopc]

5169unsigned OpNum = 0;

5170Value *Op;

5171unsigned OpTypeID;

5172if (getValueTypePair(Record, OpNum, NextValueNo,Op, OpTypeID, CurBB) ||

5173 OpNum + 1 >Record.size())

5174returnerror("Invalid record");

5175

5176 ResTypeID =Record[OpNum++];

5177Type *ResTy = getTypeByID(ResTypeID);

5178int Opc =getDecodedCastOpcode(Record[OpNum++]);

5179

5180if (Opc == -1 || !ResTy)

5181returnerror("Invalid record");

5182Instruction *Temp =nullptr;

5183if ((I =UpgradeBitCastInst(Opc,Op, ResTy, Temp))) {

5184if (Temp) {

5185 InstructionList.push_back(Temp);

5186assert(CurBB &&"No current BB?");

5187 Temp->insertInto(CurBB, CurBB->end());

5188 }

5189 }else {

5190auto CastOp = (Instruction::CastOps)Opc;

5191if (!CastInst::castIsValid(CastOp,Op, ResTy))

5192returnerror("Invalid cast");

5193I =CastInst::Create(CastOp,Op, ResTy);

5194 }

5195

5196if (OpNum <Record.size()) {

5197if (Opc == Instruction::ZExt || Opc == Instruction::UIToFP) {

5198if (Record[OpNum] & (1 <<bitc::PNNI_NON_NEG))

5199 cast<PossiblyNonNegInst>(I)->setNonNeg(true);

5200 }elseif (Opc == Instruction::Trunc) {

5201if (Record[OpNum] & (1 <<bitc::TIO_NO_UNSIGNED_WRAP))

5202 cast<TruncInst>(I)->setHasNoUnsignedWrap(true);

5203if (Record[OpNum] & (1 <<bitc::TIO_NO_SIGNED_WRAP))

5204 cast<TruncInst>(I)->setHasNoSignedWrap(true);

5205 }

5206if (isa<FPMathOperator>(I)) {

5207FastMathFlags FMF =getDecodedFastMathFlags(Record[OpNum]);

5208if (FMF.any())

5209I->setFastMathFlags(FMF);

5210 }

5211 }

5212

5213 InstructionList.push_back(I);

5214break;

5215 }

5216casebitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD:

5217casebitc::FUNC_CODE_INST_GEP_OLD:

5218casebitc::FUNC_CODE_INST_GEP: {// GEP: type, [n x operands]

5219unsigned OpNum = 0;

5220

5221unsigned TyID;

5222Type *Ty;

5223GEPNoWrapFlags NW;

5224

5225if (BitCode ==bitc::FUNC_CODE_INST_GEP) {

5226 NW =toGEPNoWrapFlags(Record[OpNum++]);

5227 TyID =Record[OpNum++];

5228 Ty = getTypeByID(TyID);

5229 }else {

5230if (BitCode ==bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD)

5231 NW =GEPNoWrapFlags::inBounds();

5232 TyID = InvalidTypeID;

5233 Ty =nullptr;

5234 }

5235

5236Value *BasePtr;

5237unsigned BasePtrTypeID;

5238if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr, BasePtrTypeID,

5239 CurBB))

5240returnerror("Invalid record");

5241

5242if (!Ty) {

5243 TyID = getContainedTypeID(BasePtrTypeID);

5244if (BasePtr->getType()->isVectorTy())

5245 TyID = getContainedTypeID(TyID);

5246 Ty = getTypeByID(TyID);

5247 }

5248

5249SmallVector<Value*, 16> GEPIdx;

5250while (OpNum !=Record.size()) {

5251Value *Op;

5252unsigned OpTypeID;

5253if (getValueTypePair(Record, OpNum, NextValueNo,Op, OpTypeID, CurBB))

5254returnerror("Invalid record");

5255 GEPIdx.push_back(Op);

5256 }

5257

5258auto *GEP =GetElementPtrInst::Create(Ty, BasePtr, GEPIdx);

5259I =GEP;

5260

5261 ResTypeID = TyID;

5262if (cast<GEPOperator>(I)->getNumIndices() != 0) {

5263auto GTI = std::next(gep_type_begin(I));

5264for (Value *Idx :drop_begin(cast<GEPOperator>(I)->indices())) {

5265unsigned SubType = 0;

5266if (GTI.isStruct()) {

5267ConstantInt *IdxC =

5268Idx->getType()->isVectorTy()

5269 ? cast<ConstantInt>(cast<Constant>(Idx)->getSplatValue())

5270 :cast<ConstantInt>(Idx);

5271 SubType = IdxC->getZExtValue();

5272 }

5273 ResTypeID = getContainedTypeID(ResTypeID, SubType);

5274 ++GTI;

5275 }

5276 }

5277

5278// At this point ResTypeID is the result element type. We need a pointer

5279// or vector of pointer to it.

5280 ResTypeID = getVirtualTypeID(I->getType()->getScalarType(), ResTypeID);

5281if (I->getType()->isVectorTy())

5282 ResTypeID = getVirtualTypeID(I->getType(), ResTypeID);

5283

5284 InstructionList.push_back(I);

5285GEP->setNoWrapFlags(NW);

5286break;

5287 }

5288

5289casebitc::FUNC_CODE_INST_EXTRACTVAL: {

5290// EXTRACTVAL: [opty, opval, n x indices]

5291unsigned OpNum = 0;

5292Value *Agg;

5293unsigned AggTypeID;

5294if (getValueTypePair(Record, OpNum, NextValueNo, Agg, AggTypeID, CurBB))

5295returnerror("Invalid record");

5296Type *Ty = Agg->getType();

5297

5298unsigned RecSize =Record.size();

5299if (OpNum == RecSize)

5300returnerror("EXTRACTVAL: Invalid instruction with 0 indices");

5301

5302SmallVector<unsigned, 4> EXTRACTVALIdx;

5303 ResTypeID = AggTypeID;

5304for (; OpNum != RecSize; ++OpNum) {

5305boolIsArray = Ty->isArrayTy();

5306bool IsStruct = Ty->isStructTy();

5307uint64_t Index =Record[OpNum];

5308

5309if (!IsStruct && !IsArray)

5310returnerror("EXTRACTVAL: Invalid type");

5311if ((unsigned)Index != Index)

5312returnerror("Invalid value");

5313if (IsStruct && Index >= Ty->getStructNumElements())

5314returnerror("EXTRACTVAL: Invalid struct index");

5315if (IsArray && Index >= Ty->getArrayNumElements())

5316returnerror("EXTRACTVAL: Invalid array index");

5317 EXTRACTVALIdx.push_back((unsigned)Index);

5318

5319if (IsStruct) {

5320 Ty = Ty->getStructElementType(Index);

5321 ResTypeID = getContainedTypeID(ResTypeID, Index);

5322 }else {

5323 Ty = Ty->getArrayElementType();

5324 ResTypeID = getContainedTypeID(ResTypeID);

5325 }

5326 }

5327

5328I =ExtractValueInst::Create(Agg, EXTRACTVALIdx);

5329 InstructionList.push_back(I);

5330break;

5331 }

5332

5333casebitc::FUNC_CODE_INST_INSERTVAL: {

5334// INSERTVAL: [opty, opval, opty, opval, n x indices]

5335unsigned OpNum = 0;

5336Value *Agg;

5337unsigned AggTypeID;

5338if (getValueTypePair(Record, OpNum, NextValueNo, Agg, AggTypeID, CurBB))

5339returnerror("Invalid record");

5340Value *Val;

5341unsigned ValTypeID;

5342if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))

5343returnerror("Invalid record");

5344

5345unsigned RecSize =Record.size();

5346if (OpNum == RecSize)

5347returnerror("INSERTVAL: Invalid instruction with 0 indices");

5348

5349SmallVector<unsigned, 4> INSERTVALIdx;

5350Type *CurTy = Agg->getType();

5351for (; OpNum != RecSize; ++OpNum) {

5352boolIsArray = CurTy->isArrayTy();

5353bool IsStruct = CurTy->isStructTy();

5354uint64_t Index =Record[OpNum];

5355

5356if (!IsStruct && !IsArray)

5357returnerror("INSERTVAL: Invalid type");

5358if ((unsigned)Index != Index)

5359returnerror("Invalid value");

5360if (IsStruct && Index >= CurTy->getStructNumElements())

5361returnerror("INSERTVAL: Invalid struct index");

5362if (IsArray && Index >= CurTy->getArrayNumElements())

5363returnerror("INSERTVAL: Invalid array index");

5364

5365 INSERTVALIdx.push_back((unsigned)Index);

5366if (IsStruct)

5367 CurTy = CurTy->getStructElementType(Index);

5368else

5369 CurTy = CurTy->getArrayElementType();

5370 }

5371

5372if (CurTy != Val->getType())

5373returnerror("Inserted value type doesn't match aggregate type");

5374

5375I =InsertValueInst::Create(Agg, Val, INSERTVALIdx);

5376 ResTypeID = AggTypeID;

5377 InstructionList.push_back(I);

5378break;

5379 }

5380

5381casebitc::FUNC_CODE_INST_SELECT: {// SELECT: [opval, ty, opval, opval]

5382// obsolete form of select

5383// handles select i1 ... in old bitcode

5384unsigned OpNum = 0;

5385Value *TrueVal, *FalseVal, *Cond;

5386unsignedTypeID;

5387Type *CondType =Type::getInt1Ty(Context);

5388if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal,TypeID,

5389 CurBB) ||

5390 popValue(Record, OpNum, NextValueNo,TrueVal->getType(),TypeID,

5391 FalseVal, CurBB) ||

5392 popValue(Record, OpNum, NextValueNo, CondType,

5393 getVirtualTypeID(CondType),Cond, CurBB))

5394returnerror("Invalid record");

5395

5396I =SelectInst::Create(Cond, TrueVal, FalseVal);

5397 ResTypeID =TypeID;

5398 InstructionList.push_back(I);

5399break;

5400 }

5401

5402casebitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred]

5403// new form of select

5404// handles select i1 or select [N x i1]

5405unsigned OpNum = 0;

5406Value *TrueVal, *FalseVal, *Cond;

5407unsigned ValTypeID, CondTypeID;

5408if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal, ValTypeID,

5409 CurBB) ||

5410 popValue(Record, OpNum, NextValueNo,TrueVal->getType(), ValTypeID,

5411 FalseVal, CurBB) ||

5412 getValueTypePair(Record, OpNum, NextValueNo,Cond, CondTypeID, CurBB))

5413returnerror("Invalid record");

5414

5415// select condition can be either i1 or [N x i1]

5416if (VectorType* vector_type =

5417 dyn_cast<VectorType>(Cond->getType())) {

5418// expect <n x i1>

5419if (vector_type->getElementType() !=Type::getInt1Ty(Context))

5420returnerror("Invalid type for value");

5421 }else {

5422// expect i1

5423if (Cond->getType() !=Type::getInt1Ty(Context))

5424returnerror("Invalid type for value");

5425 }

5426

5427I =SelectInst::Create(Cond, TrueVal, FalseVal);

5428 ResTypeID = ValTypeID;

5429 InstructionList.push_back(I);

5430if (OpNum <Record.size() && isa<FPMathOperator>(I)) {

5431FastMathFlags FMF =getDecodedFastMathFlags(Record[OpNum]);

5432if (FMF.any())

5433I->setFastMathFlags(FMF);

5434 }

5435break;

5436 }

5437

5438casebitc::FUNC_CODE_INST_EXTRACTELT: {// EXTRACTELT: [opty, opval, opval]

5439unsigned OpNum = 0;

5440Value *Vec, *Idx;

5441unsigned VecTypeID, IdxTypeID;

5442if (getValueTypePair(Record, OpNum, NextValueNo, Vec, VecTypeID, CurBB) ||

5443 getValueTypePair(Record, OpNum, NextValueNo,Idx, IdxTypeID, CurBB))

5444returnerror("Invalid record");

5445if (!Vec->getType()->isVectorTy())

5446returnerror("Invalid type for value");

5447I =ExtractElementInst::Create(Vec,Idx);

5448 ResTypeID = getContainedTypeID(VecTypeID);

5449 InstructionList.push_back(I);

5450break;

5451 }

5452

5453casebitc::FUNC_CODE_INST_INSERTELT: {// INSERTELT: [ty, opval,opval,opval]

5454unsigned OpNum = 0;

5455Value *Vec, *Elt, *Idx;

5456unsigned VecTypeID, IdxTypeID;

5457if (getValueTypePair(Record, OpNum, NextValueNo, Vec, VecTypeID, CurBB))

5458returnerror("Invalid record");

5459if (!Vec->getType()->isVectorTy())

5460returnerror("Invalid type for value");

5461if (popValue(Record, OpNum, NextValueNo,

5462 cast<VectorType>(Vec->getType())->getElementType(),

5463 getContainedTypeID(VecTypeID), Elt, CurBB) ||

5464 getValueTypePair(Record, OpNum, NextValueNo,Idx, IdxTypeID, CurBB))

5465returnerror("Invalid record");

5466I =InsertElementInst::Create(Vec, Elt,Idx);

5467 ResTypeID = VecTypeID;

5468 InstructionList.push_back(I);

5469break;

5470 }

5471

5472casebitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval]

5473unsigned OpNum = 0;

5474Value *Vec1, *Vec2, *Mask;

5475unsigned Vec1TypeID;

5476if (getValueTypePair(Record, OpNum, NextValueNo, Vec1, Vec1TypeID,

5477 CurBB) ||

5478 popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec1TypeID,

5479 Vec2, CurBB))

5480returnerror("Invalid record");

5481

5482unsigned MaskTypeID;

5483if (getValueTypePair(Record, OpNum, NextValueNo, Mask, MaskTypeID, CurBB))

5484returnerror("Invalid record");

5485if (!Vec1->getType()->isVectorTy() || !Vec2->getType()->isVectorTy())

5486returnerror("Invalid type for value");

5487

5488I =newShuffleVectorInst(Vec1, Vec2, Mask);

5489 ResTypeID =

5490 getVirtualTypeID(I->getType(), getContainedTypeID(Vec1TypeID));

5491 InstructionList.push_back(I);

5492break;

5493 }

5494

5495casebitc::FUNC_CODE_INST_CMP:// CMP: [opty, opval, opval, pred]

5496// Old form of ICmp/FCmp returning bool

5497// Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were

5498// both legal on vectors but had different behaviour.

5499casebitc::FUNC_CODE_INST_CMP2: {// CMP2: [opty, opval, opval, pred]

5500// FCmp/ICmp returning bool or vector of bool

5501

5502unsigned OpNum = 0;

5503Value *LHS, *RHS;

5504unsigned LHSTypeID;

5505if (getValueTypePair(Record, OpNum, NextValueNo, LHS, LHSTypeID, CurBB) ||

5506 popValue(Record, OpNum, NextValueNo,LHS->getType(), LHSTypeID, RHS,

5507 CurBB))

5508returnerror("Invalid record");

5509

5510if (OpNum >=Record.size())

5511returnerror(

5512"Invalid record: operand number exceeded available operands");

5513

5514CmpInst::Predicate PredVal =CmpInst::Predicate(Record[OpNum]);

5515bool IsFP =LHS->getType()->isFPOrFPVectorTy();

5516FastMathFlags FMF;

5517if (IsFP &&Record.size() > OpNum+1)

5518 FMF =getDecodedFastMathFlags(Record[++OpNum]);

5519

5520if (IsFP) {

5521if (!CmpInst::isFPPredicate(PredVal))

5522returnerror("Invalid fcmp predicate");

5523I =newFCmpInst(PredVal, LHS, RHS);

5524 }else {

5525if (!CmpInst::isIntPredicate(PredVal))

5526returnerror("Invalid icmp predicate");

5527I =newICmpInst(PredVal, LHS, RHS);

5528if (Record.size() > OpNum + 1 &&

5529 (Record[++OpNum] & (1 <<bitc::ICMP_SAME_SIGN)))

5530 cast<ICmpInst>(I)->setSameSign();

5531 }

5532

5533if (OpNum + 1 !=Record.size())

5534returnerror("Invalid record");

5535

5536 ResTypeID = getVirtualTypeID(I->getType()->getScalarType());

5537if (LHS->getType()->isVectorTy())

5538 ResTypeID = getVirtualTypeID(I->getType(), ResTypeID);

5539

5540if (FMF.any())

5541I->setFastMathFlags(FMF);

5542 InstructionList.push_back(I);

5543break;

5544 }

5545

5546casebitc::FUNC_CODE_INST_RET:// RET: [opty,opval<optional>]

5547 {

5548unsignedSize =Record.size();

5549if (Size == 0) {

5550I =ReturnInst::Create(Context);

5551 InstructionList.push_back(I);

5552break;

5553 }

5554

5555unsigned OpNum = 0;

5556Value *Op =nullptr;

5557unsigned OpTypeID;

5558if (getValueTypePair(Record, OpNum, NextValueNo,Op, OpTypeID, CurBB))

5559returnerror("Invalid record");

5560if (OpNum !=Record.size())

5561returnerror("Invalid record");

5562

5563I =ReturnInst::Create(Context,Op);

5564 InstructionList.push_back(I);

5565break;

5566 }

5567casebitc::FUNC_CODE_INST_BR: {// BR: [bb#, bb#, opval] or [bb#]

5568if (Record.size() != 1 &&Record.size() != 3)

5569returnerror("Invalid record");

5570BasicBlock *TrueDest = getBasicBlock(Record[0]);

5571if (!TrueDest)

5572returnerror("Invalid record");

5573

5574if (Record.size() == 1) {

5575I =BranchInst::Create(TrueDest);

5576 InstructionList.push_back(I);

5577 }

5578else {

5579BasicBlock *FalseDest = getBasicBlock(Record[1]);

5580Type *CondType =Type::getInt1Ty(Context);

5581Value *Cond = getValue(Record, 2, NextValueNo, CondType,

5582 getVirtualTypeID(CondType), CurBB);

5583if (!FalseDest || !Cond)

5584returnerror("Invalid record");

5585I =BranchInst::Create(TrueDest, FalseDest,Cond);

5586 InstructionList.push_back(I);

5587 }

5588break;

5589 }

5590casebitc::FUNC_CODE_INST_CLEANUPRET: {// CLEANUPRET: [val] or [val,bb#]

5591if (Record.size() != 1 &&Record.size() != 2)

5592returnerror("Invalid record");

5593unsignedIdx = 0;

5594Type *TokenTy =Type::getTokenTy(Context);

5595Value *CleanupPad = getValue(Record,Idx++, NextValueNo, TokenTy,

5596 getVirtualTypeID(TokenTy), CurBB);

5597if (!CleanupPad)

5598returnerror("Invalid record");

5599BasicBlock *UnwindDest =nullptr;

5600if (Record.size() == 2) {

5601 UnwindDest = getBasicBlock(Record[Idx++]);

5602if (!UnwindDest)

5603returnerror("Invalid record");

5604 }

5605

5606I =CleanupReturnInst::Create(CleanupPad, UnwindDest);

5607 InstructionList.push_back(I);

5608break;

5609 }

5610casebitc::FUNC_CODE_INST_CATCHRET: {// CATCHRET: [val,bb#]

5611if (Record.size() != 2)

5612returnerror("Invalid record");

5613unsignedIdx = 0;

5614Type *TokenTy =Type::getTokenTy(Context);

5615Value *CatchPad = getValue(Record,Idx++, NextValueNo, TokenTy,

5616 getVirtualTypeID(TokenTy), CurBB);

5617if (!CatchPad)

5618returnerror("Invalid record");

5619BasicBlock *BB = getBasicBlock(Record[Idx++]);

5620if (!BB)

5621returnerror("Invalid record");

5622

5623I =CatchReturnInst::Create(CatchPad, BB);

5624 InstructionList.push_back(I);

5625break;

5626 }

5627casebitc::FUNC_CODE_INST_CATCHSWITCH: {// CATCHSWITCH: [tok,num,(bb)*,bb?]

5628// We must have, at minimum, the outer scope and the number of arguments.

5629if (Record.size() < 2)

5630returnerror("Invalid record");

5631

5632unsignedIdx = 0;

5633

5634Type *TokenTy =Type::getTokenTy(Context);

5635Value *ParentPad = getValue(Record,Idx++, NextValueNo, TokenTy,

5636 getVirtualTypeID(TokenTy), CurBB);

5637if (!ParentPad)

5638returnerror("Invalid record");

5639

5640unsigned NumHandlers =Record[Idx++];

5641

5642SmallVector<BasicBlock *, 2> Handlers;

5643for (unsignedOp = 0;Op != NumHandlers; ++Op) {

5644BasicBlock *BB = getBasicBlock(Record[Idx++]);

5645if (!BB)

5646returnerror("Invalid record");

5647 Handlers.push_back(BB);

5648 }

5649

5650BasicBlock *UnwindDest =nullptr;

5651if (Idx + 1 ==Record.size()) {

5652 UnwindDest = getBasicBlock(Record[Idx++]);

5653if (!UnwindDest)

5654returnerror("Invalid record");

5655 }

5656

5657if (Record.size() !=Idx)

5658returnerror("Invalid record");

5659

5660auto *CatchSwitch =

5661CatchSwitchInst::Create(ParentPad, UnwindDest, NumHandlers);

5662for (BasicBlock *Handler : Handlers)

5663 CatchSwitch->addHandler(Handler);

5664I = CatchSwitch;

5665 ResTypeID = getVirtualTypeID(I->getType());

5666 InstructionList.push_back(I);

5667break;

5668 }

5669casebitc::FUNC_CODE_INST_CATCHPAD:

5670casebitc::FUNC_CODE_INST_CLEANUPPAD: {// [tok,num,(ty,val)*]

5671// We must have, at minimum, the outer scope and the number of arguments.

5672if (Record.size() < 2)

5673returnerror("Invalid record");

5674

5675unsignedIdx = 0;

5676

5677Type *TokenTy =Type::getTokenTy(Context);

5678Value *ParentPad = getValue(Record,Idx++, NextValueNo, TokenTy,

5679 getVirtualTypeID(TokenTy), CurBB);

5680if (!ParentPad)

5681returnerror("Invald record");

5682

5683unsigned NumArgOperands =Record[Idx++];

5684

5685SmallVector<Value *, 2>Args;

5686for (unsignedOp = 0;Op != NumArgOperands; ++Op) {

5687Value *Val;

5688unsigned ValTypeID;

5689if (getValueTypePair(Record,Idx, NextValueNo, Val, ValTypeID,nullptr))

5690returnerror("Invalid record");

5691Args.push_back(Val);

5692 }

5693

5694if (Record.size() !=Idx)

5695returnerror("Invalid record");

5696

5697if (BitCode ==bitc::FUNC_CODE_INST_CLEANUPPAD)

5698I =CleanupPadInst::Create(ParentPad, Args);

5699else

5700I =CatchPadInst::Create(ParentPad, Args);

5701 ResTypeID = getVirtualTypeID(I->getType());

5702 InstructionList.push_back(I);

5703break;

5704 }

5705casebitc::FUNC_CODE_INST_SWITCH: {// SWITCH: [opty, op0, op1, ...]

5706// Check magic

5707if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {

5708// "New" SwitchInst format with case ranges. The changes to write this

5709// format were reverted but we still recognize bitcode that uses it.

5710// Hopefully someday we will have support for case ranges and can use

5711// this format again.

5712

5713unsigned OpTyID =Record[1];

5714Type *OpTy = getTypeByID(OpTyID);

5715unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth();

5716

5717Value *Cond = getValue(Record, 2, NextValueNo, OpTy, OpTyID, CurBB);

5718BasicBlock *Default = getBasicBlock(Record[3]);

5719if (!OpTy || !Cond || !Default)

5720returnerror("Invalid record");

5721

5722unsigned NumCases =Record[4];

5723

5724SwitchInst *SI =SwitchInst::Create(Cond,Default, NumCases);

5725 InstructionList.push_back(SI);

5726

5727unsigned CurIdx = 5;

5728for (unsigned i = 0; i != NumCases; ++i) {

5729SmallVector<ConstantInt*, 1> CaseVals;

5730unsigned NumItems =Record[CurIdx++];

5731for (unsigned ci = 0; ci != NumItems; ++ci) {

5732bool isSingleNumber =Record[CurIdx++];

5733

5734APInt Low;

5735unsigned ActiveWords = 1;

5736if (ValueBitWidth > 64)

5737 ActiveWords =Record[CurIdx++];

5738Low =readWideAPInt(ArrayRef(&Record[CurIdx], ActiveWords),

5739 ValueBitWidth);

5740 CurIdx += ActiveWords;

5741

5742if (!isSingleNumber) {

5743 ActiveWords = 1;

5744if (ValueBitWidth > 64)

5745 ActiveWords =Record[CurIdx++];

5746APInt High =readWideAPInt(ArrayRef(&Record[CurIdx], ActiveWords),

5747 ValueBitWidth);

5748 CurIdx += ActiveWords;

5749

5750// FIXME: It is not clear whether values in the range should be

5751// compared as signed or unsigned values. The partially

5752// implemented changes that used this format in the past used

5753// unsigned comparisons.

5754for ( ;Low.ule(High); ++Low)

5755 CaseVals.push_back(ConstantInt::get(Context,Low));

5756 }else

5757 CaseVals.push_back(ConstantInt::get(Context,Low));

5758 }

5759BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]);

5760for (ConstantInt *Cst : CaseVals)

5761SI->addCase(Cst, DestBB);

5762 }

5763I =SI;

5764break;

5765 }

5766

5767// Old SwitchInst format without case ranges.

5768

5769if (Record.size() < 3 || (Record.size() & 1) == 0)

5770returnerror("Invalid record");

5771unsigned OpTyID =Record[0];

5772Type *OpTy = getTypeByID(OpTyID);

5773Value *Cond = getValue(Record, 1, NextValueNo, OpTy, OpTyID, CurBB);

5774BasicBlock *Default = getBasicBlock(Record[2]);

5775if (!OpTy || !Cond || !Default)

5776returnerror("Invalid record");

5777unsigned NumCases = (Record.size()-3)/2;

5778SwitchInst *SI =SwitchInst::Create(Cond,Default, NumCases);

5779 InstructionList.push_back(SI);

5780for (unsigned i = 0, e = NumCases; i !=e; ++i) {

5781ConstantInt *CaseVal = dyn_cast_or_null<ConstantInt>(

5782 getFnValueByID(Record[3+i*2], OpTy, OpTyID,nullptr));

5783BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);

5784if (!CaseVal || !DestBB) {

5785deleteSI;

5786returnerror("Invalid record");

5787 }

5788SI->addCase(CaseVal, DestBB);

5789 }

5790I =SI;

5791break;

5792 }

5793casebitc::FUNC_CODE_INST_INDIRECTBR: {// INDIRECTBR: [opty, op0, op1, ...]

5794if (Record.size() < 2)

5795returnerror("Invalid record");

5796unsigned OpTyID =Record[0];

5797Type *OpTy = getTypeByID(OpTyID);

5798Value *Address = getValue(Record, 1, NextValueNo, OpTy, OpTyID, CurBB);

5799if (!OpTy || !Address)

5800returnerror("Invalid record");

5801unsigned NumDests =Record.size()-2;

5802IndirectBrInst *IBI =IndirectBrInst::Create(Address, NumDests);

5803 InstructionList.push_back(IBI);

5804for (unsigned i = 0, e = NumDests; i !=e; ++i) {

5805if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) {

5806 IBI->addDestination(DestBB);

5807 }else {

5808delete IBI;

5809returnerror("Invalid record");

5810 }

5811 }

5812I = IBI;

5813break;

5814 }

5815

5816casebitc::FUNC_CODE_INST_INVOKE: {

5817// INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...]

5818if (Record.size() < 4)

5819returnerror("Invalid record");

5820unsigned OpNum = 0;

5821AttributeList PAL =getAttributes(Record[OpNum++]);

5822unsigned CCInfo =Record[OpNum++];

5823BasicBlock *NormalBB = getBasicBlock(Record[OpNum++]);

5824BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]);

5825

5826unsigned FTyID = InvalidTypeID;

5827FunctionType *FTy =nullptr;

5828if ((CCInfo >> 13) & 1) {

5829 FTyID =Record[OpNum++];

5830 FTy = dyn_cast<FunctionType>(getTypeByID(FTyID));

5831if (!FTy)

5832returnerror("Explicit invoke type is not a function type");

5833 }

5834

5835Value *Callee;

5836unsigned CalleeTypeID;

5837if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID,

5838 CurBB))

5839returnerror("Invalid record");

5840

5841PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType());

5842if (!CalleeTy)

5843returnerror("Callee is not a pointer");

5844if (!FTy) {

5845 FTyID = getContainedTypeID(CalleeTypeID);

5846 FTy = dyn_cast_or_null<FunctionType>(getTypeByID(FTyID));

5847if (!FTy)

5848returnerror("Callee is not of pointer to function type");

5849 }

5850if (Record.size() < FTy->getNumParams() + OpNum)

5851returnerror("Insufficient operands to call");

5852

5853SmallVector<Value*, 16> Ops;

5854SmallVector<unsigned, 16> ArgTyIDs;

5855for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {

5856unsigned ArgTyID = getContainedTypeID(FTyID, i + 1);

5857 Ops.push_back(getValue(Record, OpNum, NextValueNo, FTy->getParamType(i),

5858 ArgTyID, CurBB));

5859 ArgTyIDs.push_back(ArgTyID);

5860if (!Ops.back())

5861returnerror("Invalid record");

5862 }

5863

5864if (!FTy->isVarArg()) {

5865if (Record.size() != OpNum)

5866returnerror("Invalid record");

5867 }else {

5868// Read type/value pairs for varargs params.

5869while (OpNum !=Record.size()) {

5870Value *Op;

5871unsigned OpTypeID;

5872if (getValueTypePair(Record, OpNum, NextValueNo,Op, OpTypeID, CurBB))

5873returnerror("Invalid record");

5874 Ops.push_back(Op);

5875 ArgTyIDs.push_back(OpTypeID);

5876 }

5877 }

5878

5879// Upgrade the bundles if needed.

5880if (!OperandBundles.empty())

5881UpgradeOperandBundles(OperandBundles);

5882

5883I =InvokeInst::Create(FTy, Callee, NormalBB, UnwindBB, Ops,

5884 OperandBundles);

5885 ResTypeID = getContainedTypeID(FTyID);

5886 OperandBundles.clear();

5887 InstructionList.push_back(I);

5888 cast<InvokeInst>(I)->setCallingConv(

5889static_cast<CallingConv::ID>(CallingConv::MaxID & CCInfo));

5890 cast<InvokeInst>(I)->setAttributes(PAL);

5891if (Error Err = propagateAttributeTypes(cast<CallBase>(I), ArgTyIDs)) {

5892I->deleteValue();

5893return Err;

5894 }

5895

5896break;

5897 }

5898casebitc::FUNC_CODE_INST_RESUME: {// RESUME: [opval]

5899unsignedIdx = 0;

5900Value *Val =nullptr;

5901unsigned ValTypeID;

5902if (getValueTypePair(Record,Idx, NextValueNo, Val, ValTypeID, CurBB))

5903returnerror("Invalid record");

5904I =ResumeInst::Create(Val);

5905 InstructionList.push_back(I);

5906break;

5907 }

5908casebitc::FUNC_CODE_INST_CALLBR: {

5909// CALLBR: [attr, cc, norm, transfs, fty, fnid, args]

5910unsigned OpNum = 0;

5911AttributeList PAL =getAttributes(Record[OpNum++]);

5912unsigned CCInfo =Record[OpNum++];

5913

5914BasicBlock *DefaultDest = getBasicBlock(Record[OpNum++]);

5915unsigned NumIndirectDests =Record[OpNum++];

5916SmallVector<BasicBlock *, 16> IndirectDests;

5917for (unsigned i = 0, e = NumIndirectDests; i !=e; ++i)

5918 IndirectDests.push_back(getBasicBlock(Record[OpNum++]));

5919

5920unsigned FTyID = InvalidTypeID;

5921FunctionType *FTy =nullptr;

5922if ((CCInfo >>bitc::CALL_EXPLICIT_TYPE) & 1) {

5923 FTyID =Record[OpNum++];

5924 FTy = dyn_cast_or_null<FunctionType>(getTypeByID(FTyID));

5925if (!FTy)

5926returnerror("Explicit call type is not a function type");

5927 }

5928

5929Value *Callee;

5930unsigned CalleeTypeID;

5931if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID,

5932 CurBB))

5933returnerror("Invalid record");

5934

5935PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());

5936if (!OpTy)

5937returnerror("Callee is not a pointer type");

5938if (!FTy) {

5939 FTyID = getContainedTypeID(CalleeTypeID);

5940 FTy = dyn_cast_or_null<FunctionType>(getTypeByID(FTyID));

5941if (!FTy)

5942returnerror("Callee is not of pointer to function type");

5943 }

5944if (Record.size() < FTy->getNumParams() + OpNum)

5945returnerror("Insufficient operands to call");

5946

5947SmallVector<Value*, 16>Args;

5948SmallVector<unsigned, 16> ArgTyIDs;

5949// Read the fixed params.

5950for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {

5951Value *Arg;

5952unsigned ArgTyID = getContainedTypeID(FTyID, i + 1);

5953if (FTy->getParamType(i)->isLabelTy())

5954 Arg = getBasicBlock(Record[OpNum]);

5955else

5956 Arg = getValue(Record, OpNum, NextValueNo, FTy->getParamType(i),

5957 ArgTyID, CurBB);

5958if (!Arg)

5959returnerror("Invalid record");

5960Args.push_back(Arg);

5961 ArgTyIDs.push_back(ArgTyID);

5962 }

5963

5964// Read type/value pairs for varargs params.

5965if (!FTy->isVarArg()) {

5966if (OpNum !=Record.size())

5967returnerror("Invalid record");

5968 }else {

5969while (OpNum !=Record.size()) {

5970Value *Op;

5971unsigned OpTypeID;

5972if (getValueTypePair(Record, OpNum, NextValueNo,Op, OpTypeID, CurBB))

5973returnerror("Invalid record");

5974Args.push_back(Op);

5975 ArgTyIDs.push_back(OpTypeID);

5976 }

5977 }

5978

5979// Upgrade the bundles if needed.

5980if (!OperandBundles.empty())

5981UpgradeOperandBundles(OperandBundles);

5982

5983if (auto *IA = dyn_cast<InlineAsm>(Callee)) {

5984InlineAsm::ConstraintInfoVector ConstraintInfo =IA->ParseConstraints();

5985auto IsLabelConstraint = [](constInlineAsm::ConstraintInfo &CI) {

5986return CI.Type ==InlineAsm::isLabel;

5987 };

5988if (none_of(ConstraintInfo, IsLabelConstraint)) {

5989// Upgrade explicit blockaddress arguments to label constraints.

5990// Verify that the last arguments are blockaddress arguments that

5991// match the indirect destinations. Clang always generates callbr

5992// in this form. We could support reordering with more effort.

5993unsigned FirstBlockArg =Args.size() - IndirectDests.size();

5994for (unsigned ArgNo = FirstBlockArg; ArgNo <Args.size(); ++ArgNo) {

5995unsigned LabelNo = ArgNo - FirstBlockArg;

5996auto *BA = dyn_cast<BlockAddress>(Args[ArgNo]);

5997if (!BA || BA->getFunction() !=F ||

5998 LabelNo > IndirectDests.size() ||

5999 BA->getBasicBlock() != IndirectDests[LabelNo])

6000returnerror("callbr argument does not match indirect dest");

6001 }

6002

6003// Remove blockaddress arguments.

6004Args.erase(Args.begin() + FirstBlockArg,Args.end());

6005 ArgTyIDs.erase(ArgTyIDs.begin() + FirstBlockArg, ArgTyIDs.end());

6006

6007// Recreate the function type with less arguments.

6008SmallVector<Type *> ArgTys;

6009for (Value *Arg : Args)

6010 ArgTys.push_back(Arg->getType());

6011 FTy =

6012 FunctionType::get(FTy->getReturnType(), ArgTys, FTy->isVarArg());

6013

6014// Update constraint string to use label constraints.

6015 std::string Constraints =IA->getConstraintString();

6016unsigned ArgNo = 0;

6017size_t Pos = 0;

6018for (constauto &CI : ConstraintInfo) {

6019if (CI.hasArg()) {

6020if (ArgNo >= FirstBlockArg)

6021 Constraints.insert(Pos,"!");

6022 ++ArgNo;

6023 }

6024

6025// Go to next constraint in string.

6026 Pos = Constraints.find(',', Pos);

6027if (Pos == std::string::npos)

6028break;

6029 ++Pos;

6030 }

6031

6032Callee =InlineAsm::get(FTy,IA->getAsmString(), Constraints,

6033IA->hasSideEffects(),IA->isAlignStack(),

6034IA->getDialect(),IA->canThrow());

6035 }

6036 }

6037

6038I =CallBrInst::Create(FTy, Callee, DefaultDest, IndirectDests, Args,

6039 OperandBundles);

6040 ResTypeID = getContainedTypeID(FTyID);

6041 OperandBundles.clear();

6042 InstructionList.push_back(I);

6043 cast<CallBrInst>(I)->setCallingConv(

6044static_cast<CallingConv::ID>((0x7ff & CCInfo) >>bitc::CALL_CCONV));

6045 cast<CallBrInst>(I)->setAttributes(PAL);

6046if (Error Err = propagateAttributeTypes(cast<CallBase>(I), ArgTyIDs)) {

6047I->deleteValue();

6048return Err;

6049 }

6050break;

6051 }

6052casebitc::FUNC_CODE_INST_UNREACHABLE:// UNREACHABLE

6053I =newUnreachableInst(Context);

6054 InstructionList.push_back(I);

6055break;

6056casebitc::FUNC_CODE_INST_PHI: {// PHI: [ty, val0,bb0, ...]

6057if (Record.empty())

6058returnerror("Invalid phi record");

6059// The first record specifies the type.

6060unsigned TyID =Record[0];

6061Type *Ty = getTypeByID(TyID);

6062if (!Ty)

6063returnerror("Invalid phi record");

6064

6065// Phi arguments are pairs of records of [value, basic block].

6066// There is an optional final record for fast-math-flags if this phi has a

6067// floating-point type.

6068size_t NumArgs = (Record.size() - 1) / 2;

6069PHINode *PN =PHINode::Create(Ty, NumArgs);

6070if ((Record.size() - 1) % 2 == 1 && !isa<FPMathOperator>(PN)) {

6071 PN->deleteValue();

6072returnerror("Invalid phi record");

6073 }

6074 InstructionList.push_back(PN);

6075

6076SmallDenseMap<BasicBlock *, Value *>Args;

6077for (unsigned i = 0; i != NumArgs; i++) {

6078BasicBlock *BB = getBasicBlock(Record[i * 2 + 2]);

6079if (!BB) {

6080 PN->deleteValue();

6081returnerror("Invalid phi BB");

6082 }

6083

6084// Phi nodes may contain the same predecessor multiple times, in which

6085// case the incoming value must be identical. Directly reuse the already

6086// seen value here, to avoid expanding a constant expression multiple

6087// times.

6088auto It =Args.find(BB);

6089if (It !=Args.end()) {

6090 PN->addIncoming(It->second, BB);

6091continue;

6092 }

6093

6094// If there already is a block for this edge (from a different phi),

6095// use it.

6096BasicBlock *EdgeBB = ConstExprEdgeBBs.lookup({BB, CurBB});

6097if (!EdgeBB) {

6098// Otherwise, use a temporary block (that we will discard if it

6099// turns out to be unnecessary).

6100if (!PhiConstExprBB)

6101 PhiConstExprBB =BasicBlock::Create(Context,"phi.constexpr",F);

6102 EdgeBB = PhiConstExprBB;

6103 }

6104

6105// With the new function encoding, it is possible that operands have

6106// negative IDs (for forward references). Use a signed VBR

6107// representation to keep the encoding small.

6108Value *V;

6109if (UseRelativeIDs)

6110V = getValueSigned(Record, i * 2 + 1, NextValueNo, Ty, TyID, EdgeBB);

6111else

6112V = getValue(Record, i * 2 + 1, NextValueNo, Ty, TyID, EdgeBB);

6113if (!V) {

6114 PN->deleteValue();

6115 PhiConstExprBB->eraseFromParent();

6116returnerror("Invalid phi record");

6117 }

6118

6119if (EdgeBB == PhiConstExprBB && !EdgeBB->empty()) {

6120 ConstExprEdgeBBs.insert({{BB, CurBB}, EdgeBB});

6121 PhiConstExprBB =nullptr;

6122 }

6123 PN->addIncoming(V, BB);

6124Args.insert({BB,V});

6125 }

6126I = PN;

6127 ResTypeID = TyID;

6128

6129// If there are an even number of records, the final record must be FMF.

6130if (Record.size() % 2 == 0) {

6131assert(isa<FPMathOperator>(I) &&"Unexpected phi type");

6132FastMathFlags FMF =getDecodedFastMathFlags(Record[Record.size() - 1]);

6133if (FMF.any())

6134I->setFastMathFlags(FMF);

6135 }

6136

6137break;

6138 }

6139

6140casebitc::FUNC_CODE_INST_LANDINGPAD:

6141casebitc::FUNC_CODE_INST_LANDINGPAD_OLD: {

6142// LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?]

6143unsignedIdx = 0;

6144if (BitCode ==bitc::FUNC_CODE_INST_LANDINGPAD) {

6145if (Record.size() < 3)

6146returnerror("Invalid record");

6147 }else {

6148assert(BitCode ==bitc::FUNC_CODE_INST_LANDINGPAD_OLD);

6149if (Record.size() < 4)

6150returnerror("Invalid record");

6151 }

6152 ResTypeID =Record[Idx++];

6153Type *Ty = getTypeByID(ResTypeID);

6154if (!Ty)

6155returnerror("Invalid record");

6156if (BitCode ==bitc::FUNC_CODE_INST_LANDINGPAD_OLD) {

6157Value *PersFn =nullptr;

6158unsigned PersFnTypeID;

6159if (getValueTypePair(Record,Idx, NextValueNo, PersFn, PersFnTypeID,

6160nullptr))

6161returnerror("Invalid record");

6162

6163if (!F->hasPersonalityFn())

6164F->setPersonalityFn(cast<Constant>(PersFn));

6165elseif (F->getPersonalityFn() != cast<Constant>(PersFn))

6166returnerror("Personality function mismatch");

6167 }

6168

6169bool IsCleanup = !!Record[Idx++];

6170unsigned NumClauses =Record[Idx++];

6171LandingPadInst *LP =LandingPadInst::Create(Ty, NumClauses);

6172 LP->setCleanup(IsCleanup);

6173for (unsigned J = 0; J != NumClauses; ++J) {

6174LandingPadInst::ClauseType CT =

6175LandingPadInst::ClauseType(Record[Idx++]); (void)CT;

6176Value *Val;

6177unsigned ValTypeID;

6178

6179if (getValueTypePair(Record,Idx, NextValueNo, Val, ValTypeID,

6180nullptr)) {

6181delete LP;

6182returnerror("Invalid record");

6183 }

6184

6185assert((CT !=LandingPadInst::Catch ||

6186 !isa<ArrayType>(Val->getType())) &&

6187"Catch clause has a invalid type!");

6188assert((CT !=LandingPadInst::Filter ||

6189 isa<ArrayType>(Val->getType())) &&

6190"Filter clause has invalid type!");

6191 LP->addClause(cast<Constant>(Val));

6192 }

6193

6194I = LP;

6195 InstructionList.push_back(I);

6196break;

6197 }

6198

6199casebitc::FUNC_CODE_INST_ALLOCA: {// ALLOCA: [instty, opty, op, align]

6200if (Record.size() != 4 &&Record.size() != 5)

6201returnerror("Invalid record");

6202usingAPV =AllocaPackedValues;

6203constuint64_t Rec =Record[3];

6204constbool InAlloca = Bitfield::get<APV::UsedWithInAlloca>(Rec);

6205constbool SwiftError = Bitfield::get<APV::SwiftError>(Rec);

6206unsigned TyID =Record[0];

6207Type *Ty = getTypeByID(TyID);

6208if (!Bitfield::get<APV::ExplicitType>(Rec)) {

6209 TyID = getContainedTypeID(TyID);

6210 Ty = getTypeByID(TyID);

6211if (!Ty)

6212returnerror("Missing element type for old-style alloca");

6213 }

6214unsigned OpTyID =Record[1];

6215Type *OpTy = getTypeByID(OpTyID);

6216Value *Size = getFnValueByID(Record[2], OpTy, OpTyID, CurBB);

6217MaybeAlign Align;

6218uint64_t AlignExp =

6219 Bitfield::get<APV::AlignLower>(Rec) |

6220 (Bitfield::get<APV::AlignUpper>(Rec) << APV::AlignLower::Bits);

6221if (Error Err = parseAlignmentValue(AlignExp,Align)) {

6222return Err;

6223 }

6224if (!Ty || !Size)

6225returnerror("Invalid record");

6226

6227constDataLayout &DL = TheModule->getDataLayout();

6228unsigned AS =Record.size() == 5 ?Record[4] :DL.getAllocaAddrSpace();

6229

6230SmallPtrSet<Type *, 4> Visited;

6231if (!Align && !Ty->isSized(&Visited))

6232returnerror("alloca of unsized type");

6233if (!Align)

6234Align =DL.getPrefTypeAlign(Ty);

6235

6236if (!Size->getType()->isIntegerTy())

6237returnerror("alloca element count must have integer type");

6238

6239AllocaInst *AI =newAllocaInst(Ty, AS,Size, *Align);

6240 AI->setUsedWithInAlloca(InAlloca);

6241 AI->setSwiftError(SwiftError);

6242I = AI;

6243 ResTypeID = getVirtualTypeID(AI->getType(), TyID);

6244 InstructionList.push_back(I);

6245break;

6246 }

6247casebitc::FUNC_CODE_INST_LOAD: {// LOAD: [opty, op, align, vol]

6248unsigned OpNum = 0;

6249Value *Op;

6250unsigned OpTypeID;

6251if (getValueTypePair(Record, OpNum, NextValueNo,Op, OpTypeID, CurBB) ||

6252 (OpNum + 2 !=Record.size() && OpNum + 3 !=Record.size()))

6253returnerror("Invalid record");

6254

6255if (!isa<PointerType>(Op->getType()))

6256returnerror("Load operand is not a pointer type");

6257

6258Type *Ty =nullptr;

6259if (OpNum + 3 ==Record.size()) {

6260 ResTypeID =Record[OpNum++];

6261 Ty = getTypeByID(ResTypeID);

6262 }else {

6263 ResTypeID = getContainedTypeID(OpTypeID);

6264 Ty = getTypeByID(ResTypeID);

6265 }

6266

6267if (!Ty)

6268returnerror("Missing load type");

6269

6270if (Error Err = typeCheckLoadStoreInst(Ty,Op->getType()))

6271return Err;

6272

6273MaybeAlign Align;

6274if (Error Err = parseAlignmentValue(Record[OpNum],Align))

6275return Err;

6276SmallPtrSet<Type *, 4> Visited;

6277if (!Align && !Ty->isSized(&Visited))

6278returnerror("load of unsized type");

6279if (!Align)

6280Align = TheModule->getDataLayout().getABITypeAlign(Ty);

6281I =newLoadInst(Ty,Op,"",Record[OpNum + 1], *Align);

6282 InstructionList.push_back(I);

6283break;

6284 }

6285casebitc::FUNC_CODE_INST_LOADATOMIC: {

6286// LOADATOMIC: [opty, op, align, vol, ordering, ssid]

6287unsigned OpNum = 0;

6288Value *Op;

6289unsigned OpTypeID;

6290if (getValueTypePair(Record, OpNum, NextValueNo,Op, OpTypeID, CurBB) ||

6291 (OpNum + 4 !=Record.size() && OpNum + 5 !=Record.size()))

6292returnerror("Invalid record");

6293

6294if (!isa<PointerType>(Op->getType()))

6295returnerror("Load operand is not a pointer type");

6296

6297Type *Ty =nullptr;

6298if (OpNum + 5 ==Record.size()) {

6299 ResTypeID =Record[OpNum++];

6300 Ty = getTypeByID(ResTypeID);

6301 }else {

6302 ResTypeID = getContainedTypeID(OpTypeID);

6303 Ty = getTypeByID(ResTypeID);

6304 }

6305

6306if (!Ty)

6307returnerror("Missing atomic load type");

6308

6309if (Error Err = typeCheckLoadStoreInst(Ty,Op->getType()))

6310return Err;

6311

6312AtomicOrdering Ordering =getDecodedOrdering(Record[OpNum + 2]);

6313if (Ordering == AtomicOrdering::NotAtomic ||

6314 Ordering == AtomicOrdering::Release ||

6315 Ordering == AtomicOrdering::AcquireRelease)

6316returnerror("Invalid record");

6317if (Ordering != AtomicOrdering::NotAtomic &&Record[OpNum] == 0)

6318returnerror("Invalid record");

6319SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);

6320

6321MaybeAlign Align;

6322if (Error Err = parseAlignmentValue(Record[OpNum],Align))

6323return Err;

6324if (!Align)

6325returnerror("Alignment missing from atomic load");

6326I =newLoadInst(Ty,Op,"",Record[OpNum + 1], *Align, Ordering, SSID);

6327 InstructionList.push_back(I);

6328break;

6329 }

6330casebitc::FUNC_CODE_INST_STORE:

6331casebitc::FUNC_CODE_INST_STORE_OLD: {// STORE2:[ptrty, ptr, val, align, vol]

6332unsigned OpNum = 0;

6333Value *Val, *Ptr;

6334unsigned PtrTypeID, ValTypeID;

6335if (getValueTypePair(Record, OpNum, NextValueNo,Ptr, PtrTypeID, CurBB))

6336returnerror("Invalid record");

6337

6338if (BitCode ==bitc::FUNC_CODE_INST_STORE) {

6339if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))

6340returnerror("Invalid record");

6341 }else {

6342 ValTypeID = getContainedTypeID(PtrTypeID);

6343if (popValue(Record, OpNum, NextValueNo, getTypeByID(ValTypeID),

6344 ValTypeID, Val, CurBB))

6345returnerror("Invalid record");

6346 }

6347

6348if (OpNum + 2 !=Record.size())

6349returnerror("Invalid record");

6350

6351if (Error Err = typeCheckLoadStoreInst(Val->getType(),Ptr->getType()))

6352return Err;

6353MaybeAlign Align;

6354if (Error Err = parseAlignmentValue(Record[OpNum],Align))

6355return Err;

6356SmallPtrSet<Type *, 4> Visited;

6357if (!Align && !Val->getType()->isSized(&Visited))

6358returnerror("store of unsized type");

6359if (!Align)

6360Align = TheModule->getDataLayout().getABITypeAlign(Val->getType());

6361I =newStoreInst(Val,Ptr,Record[OpNum + 1], *Align);

6362 InstructionList.push_back(I);

6363break;

6364 }

6365casebitc::FUNC_CODE_INST_STOREATOMIC:

6366casebitc::FUNC_CODE_INST_STOREATOMIC_OLD: {

6367// STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, ssid]

6368unsigned OpNum = 0;

6369Value *Val, *Ptr;

6370unsigned PtrTypeID, ValTypeID;

6371if (getValueTypePair(Record, OpNum, NextValueNo,Ptr, PtrTypeID, CurBB) ||

6372 !isa<PointerType>(Ptr->getType()))

6373returnerror("Invalid record");

6374if (BitCode ==bitc::FUNC_CODE_INST_STOREATOMIC) {

6375if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))

6376returnerror("Invalid record");

6377 }else {

6378 ValTypeID = getContainedTypeID(PtrTypeID);

6379if (popValue(Record, OpNum, NextValueNo, getTypeByID(ValTypeID),

6380 ValTypeID, Val, CurBB))

6381returnerror("Invalid record");

6382 }

6383

6384if (OpNum + 4 !=Record.size())

6385returnerror("Invalid record");

6386

6387if (Error Err = typeCheckLoadStoreInst(Val->getType(),Ptr->getType()))

6388return Err;

6389AtomicOrdering Ordering =getDecodedOrdering(Record[OpNum + 2]);

6390if (Ordering == AtomicOrdering::NotAtomic ||

6391 Ordering == AtomicOrdering::Acquire ||

6392 Ordering == AtomicOrdering::AcquireRelease)

6393returnerror("Invalid record");

6394SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);

6395if (Ordering != AtomicOrdering::NotAtomic &&Record[OpNum] == 0)

6396returnerror("Invalid record");

6397

6398MaybeAlign Align;

6399if (Error Err = parseAlignmentValue(Record[OpNum],Align))

6400return Err;

6401if (!Align)

6402returnerror("Alignment missing from atomic store");

6403I =newStoreInst(Val,Ptr,Record[OpNum + 1], *Align, Ordering, SSID);

6404 InstructionList.push_back(I);

6405break;

6406 }

6407casebitc::FUNC_CODE_INST_CMPXCHG_OLD: {

6408// CMPXCHG_OLD: [ptrty, ptr, cmp, val, vol, ordering, synchscope,

6409// failure_ordering?, weak?]

6410constsize_t NumRecords =Record.size();

6411unsigned OpNum = 0;

6412Value *Ptr =nullptr;

6413unsigned PtrTypeID;

6414if (getValueTypePair(Record, OpNum, NextValueNo,Ptr, PtrTypeID, CurBB))

6415returnerror("Invalid record");

6416

6417if (!isa<PointerType>(Ptr->getType()))

6418returnerror("Cmpxchg operand is not a pointer type");

6419

6420Value *Cmp =nullptr;

6421unsigned CmpTypeID = getContainedTypeID(PtrTypeID);

6422if (popValue(Record, OpNum, NextValueNo, getTypeByID(CmpTypeID),

6423 CmpTypeID, Cmp, CurBB))

6424returnerror("Invalid record");

6425

6426Value *New =nullptr;

6427if (popValue(Record, OpNum, NextValueNo,Cmp->getType(), CmpTypeID,

6428 New, CurBB) ||

6429 NumRecords < OpNum + 3 || NumRecords > OpNum + 5)

6430returnerror("Invalid record");

6431

6432constAtomicOrdering SuccessOrdering =

6433getDecodedOrdering(Record[OpNum + 1]);

6434if (SuccessOrdering == AtomicOrdering::NotAtomic ||

6435 SuccessOrdering == AtomicOrdering::Unordered)

6436returnerror("Invalid record");

6437

6438constSyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 2]);

6439

6440if (Error Err = typeCheckLoadStoreInst(Cmp->getType(),Ptr->getType()))

6441return Err;

6442

6443constAtomicOrdering FailureOrdering =

6444 NumRecords < 7

6445 ?AtomicCmpXchgInst::getStrongestFailureOrdering(SuccessOrdering)

6446 :getDecodedOrdering(Record[OpNum + 3]);

6447

6448if (FailureOrdering == AtomicOrdering::NotAtomic ||

6449 FailureOrdering == AtomicOrdering::Unordered)

6450returnerror("Invalid record");

6451

6452constAlign Alignment(

6453 TheModule->getDataLayout().getTypeStoreSize(Cmp->getType()));

6454

6455I =newAtomicCmpXchgInst(Ptr, Cmp, New, Alignment, SuccessOrdering,

6456 FailureOrdering, SSID);

6457 cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]);

6458

6459if (NumRecords < 8) {

6460// Before weak cmpxchgs existed, the instruction simply returned the

6461// value loaded from memory, so bitcode files from that era will be

6462// expecting the first component of a modern cmpxchg.

6463I->insertInto(CurBB, CurBB->end());

6464I =ExtractValueInst::Create(I, 0);

6465 ResTypeID = CmpTypeID;

6466 }else {

6467 cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum + 4]);

6468unsigned I1TypeID = getVirtualTypeID(Type::getInt1Ty(Context));

6469 ResTypeID = getVirtualTypeID(I->getType(), {CmpTypeID, I1TypeID});

6470 }

6471

6472 InstructionList.push_back(I);

6473break;

6474 }

6475casebitc::FUNC_CODE_INST_CMPXCHG: {

6476// CMPXCHG: [ptrty, ptr, cmp, val, vol, success_ordering, synchscope,

6477// failure_ordering, weak, align?]

6478constsize_t NumRecords =Record.size();

6479unsigned OpNum = 0;

6480Value *Ptr =nullptr;

6481unsigned PtrTypeID;

6482if (getValueTypePair(Record, OpNum, NextValueNo,Ptr, PtrTypeID, CurBB))

6483returnerror("Invalid record");

6484

6485if (!isa<PointerType>(Ptr->getType()))

6486returnerror("Cmpxchg operand is not a pointer type");

6487

6488Value *Cmp =nullptr;

6489unsigned CmpTypeID;

6490if (getValueTypePair(Record, OpNum, NextValueNo, Cmp, CmpTypeID, CurBB))

6491returnerror("Invalid record");

6492

6493Value *Val =nullptr;

6494if (popValue(Record, OpNum, NextValueNo,Cmp->getType(), CmpTypeID, Val,

6495 CurBB))

6496returnerror("Invalid record");

6497

6498if (NumRecords < OpNum + 3 || NumRecords > OpNum + 6)

6499returnerror("Invalid record");

6500

6501constbool IsVol =Record[OpNum];

6502

6503constAtomicOrdering SuccessOrdering =

6504getDecodedOrdering(Record[OpNum + 1]);

6505if (!AtomicCmpXchgInst::isValidSuccessOrdering(SuccessOrdering))

6506returnerror("Invalid cmpxchg success ordering");

6507

6508constSyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 2]);

6509

6510if (Error Err = typeCheckLoadStoreInst(Cmp->getType(),Ptr->getType()))

6511return Err;

6512

6513constAtomicOrdering FailureOrdering =

6514getDecodedOrdering(Record[OpNum + 3]);

6515if (!AtomicCmpXchgInst::isValidFailureOrdering(FailureOrdering))

6516returnerror("Invalid cmpxchg failure ordering");

6517

6518constbool IsWeak =Record[OpNum + 4];

6519

6520MaybeAlign Alignment;

6521

6522if (NumRecords == (OpNum + 6)) {

6523if (Error Err = parseAlignmentValue(Record[OpNum + 5], Alignment))

6524return Err;

6525 }

6526if (!Alignment)

6527 Alignment =

6528Align(TheModule->getDataLayout().getTypeStoreSize(Cmp->getType()));

6529

6530I =newAtomicCmpXchgInst(Ptr, Cmp, Val, *Alignment, SuccessOrdering,

6531 FailureOrdering, SSID);

6532 cast<AtomicCmpXchgInst>(I)->setVolatile(IsVol);

6533 cast<AtomicCmpXchgInst>(I)->setWeak(IsWeak);

6534

6535unsigned I1TypeID = getVirtualTypeID(Type::getInt1Ty(Context));

6536 ResTypeID = getVirtualTypeID(I->getType(), {CmpTypeID, I1TypeID});

6537

6538 InstructionList.push_back(I);

6539break;

6540 }

6541casebitc::FUNC_CODE_INST_ATOMICRMW_OLD:

6542casebitc::FUNC_CODE_INST_ATOMICRMW: {

6543// ATOMICRMW_OLD: [ptrty, ptr, val, op, vol, ordering, ssid, align?]

6544// ATOMICRMW: [ptrty, ptr, valty, val, op, vol, ordering, ssid, align?]

6545constsize_t NumRecords =Record.size();

6546unsigned OpNum = 0;

6547

6548Value *Ptr =nullptr;

6549unsigned PtrTypeID;

6550if (getValueTypePair(Record, OpNum, NextValueNo,Ptr, PtrTypeID, CurBB))

6551returnerror("Invalid record");

6552

6553if (!isa<PointerType>(Ptr->getType()))

6554returnerror("Invalid record");

6555

6556Value *Val =nullptr;

6557unsigned ValTypeID = InvalidTypeID;

6558if (BitCode ==bitc::FUNC_CODE_INST_ATOMICRMW_OLD) {

6559 ValTypeID = getContainedTypeID(PtrTypeID);

6560if (popValue(Record, OpNum, NextValueNo,

6561 getTypeByID(ValTypeID), ValTypeID, Val, CurBB))

6562returnerror("Invalid record");

6563 }else {

6564if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))

6565returnerror("Invalid record");

6566 }

6567

6568if (!(NumRecords == (OpNum + 4) || NumRecords == (OpNum + 5)))

6569returnerror("Invalid record");

6570

6571constAtomicRMWInst::BinOp Operation =

6572getDecodedRMWOperation(Record[OpNum]);

6573if (Operation <AtomicRMWInst::FIRST_BINOP ||

6574Operation >AtomicRMWInst::LAST_BINOP)

6575returnerror("Invalid record");

6576

6577constbool IsVol =Record[OpNum + 1];

6578

6579constAtomicOrdering Ordering =getDecodedOrdering(Record[OpNum + 2]);

6580if (Ordering == AtomicOrdering::NotAtomic ||

6581 Ordering == AtomicOrdering::Unordered)

6582returnerror("Invalid record");

6583

6584constSyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);

6585

6586MaybeAlign Alignment;

6587

6588if (NumRecords == (OpNum + 5)) {

6589if (Error Err = parseAlignmentValue(Record[OpNum + 4], Alignment))

6590return Err;

6591 }

6592

6593if (!Alignment)

6594 Alignment =

6595Align(TheModule->getDataLayout().getTypeStoreSize(Val->getType()));

6596

6597I =newAtomicRMWInst(Operation,Ptr, Val, *Alignment, Ordering, SSID);

6598 ResTypeID = ValTypeID;

6599 cast<AtomicRMWInst>(I)->setVolatile(IsVol);

6600

6601 InstructionList.push_back(I);

6602break;

6603 }

6604casebitc::FUNC_CODE_INST_FENCE: {// FENCE:[ordering, ssid]

6605if (2 !=Record.size())

6606returnerror("Invalid record");

6607AtomicOrdering Ordering =getDecodedOrdering(Record[0]);

6608if (Ordering == AtomicOrdering::NotAtomic ||

6609 Ordering == AtomicOrdering::Unordered ||

6610 Ordering == AtomicOrdering::Monotonic)

6611returnerror("Invalid record");

6612SyncScope::ID SSID = getDecodedSyncScopeID(Record[1]);

6613I =newFenceInst(Context, Ordering, SSID);

6614 InstructionList.push_back(I);

6615break;

6616 }

6617casebitc::FUNC_CODE_DEBUG_RECORD_LABEL: {

6618// DbgLabelRecords are placed after the Instructions that they are

6619// attached to.

6620 SeenDebugRecord =true;

6621Instruction *Inst = getLastInstruction();

6622if (!Inst)

6623returnerror("Invalid dbg record: missing instruction");

6624DILocation *DIL = cast<DILocation>(getFnMetadataByID(Record[0]));

6625DILabel *Label = cast<DILabel>(getFnMetadataByID(Record[1]));

6626 Inst->getParent()->insertDbgRecordBefore(

6627newDbgLabelRecord(Label,DebugLoc(DIL)), Inst->getIterator());

6628continue;// This isn't an instruction.

6629 }

6630casebitc::FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE:

6631casebitc::FUNC_CODE_DEBUG_RECORD_VALUE:

6632casebitc::FUNC_CODE_DEBUG_RECORD_DECLARE:

6633casebitc::FUNC_CODE_DEBUG_RECORD_ASSIGN: {

6634// DbgVariableRecords are placed after the Instructions that they are

6635// attached to.

6636 SeenDebugRecord =true;

6637Instruction *Inst = getLastInstruction();

6638if (!Inst)

6639returnerror("Invalid dbg record: missing instruction");

6640

6641// First 3 fields are common to all kinds:

6642// DILocation, DILocalVariable, DIExpression

6643// dbg_value (FUNC_CODE_DEBUG_RECORD_VALUE)

6644// ..., LocationMetadata

6645// dbg_value (FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE - abbrev'd)

6646// ..., Value

6647// dbg_declare (FUNC_CODE_DEBUG_RECORD_DECLARE)

6648// ..., LocationMetadata

6649// dbg_assign (FUNC_CODE_DEBUG_RECORD_ASSIGN)

6650// ..., LocationMetadata, DIAssignID, DIExpression, LocationMetadata

6651unsignedSlot = 0;

6652// Common fields (0-2).

6653DILocation *DIL = cast<DILocation>(getFnMetadataByID(Record[Slot++]));

6654DILocalVariable *Var =

6655 cast<DILocalVariable>(getFnMetadataByID(Record[Slot++]));

6656DIExpression *Expr =

6657 cast<DIExpression>(getFnMetadataByID(Record[Slot++]));

6658

6659// Union field (3: LocationMetadata | Value).

6660Metadata *RawLocation =nullptr;

6661if (BitCode ==bitc::FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE) {

6662Value *V =nullptr;

6663unsigned TyID = 0;

6664// We never expect to see a fwd reference value here because

6665// use-before-defs are encoded with the standard non-abbrev record

6666// type (they'd require encoding the type too, and they're rare). As a

6667// result, getValueTypePair only ever increments Slot by one here (once

6668// for the value, never twice for value and type).

6669unsigned SlotBefore =Slot;

6670if (getValueTypePair(Record, Slot, NextValueNo, V, TyID, CurBB))

6671returnerror("Invalid dbg record: invalid value");

6672 (void)SlotBefore;

6673assert((SlotBefore == Slot - 1) &&"unexpected fwd ref");

6674 RawLocation =ValueAsMetadata::get(V);

6675 }else {

6676 RawLocation = getFnMetadataByID(Record[Slot++]);

6677 }

6678

6679DbgVariableRecord *DVR =nullptr;

6680switch (BitCode) {

6681casebitc::FUNC_CODE_DEBUG_RECORD_VALUE:

6682casebitc::FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE:

6683 DVR =newDbgVariableRecord(RawLocation, Var, Expr, DIL,

6684 DbgVariableRecord::LocationType::Value);

6685break;

6686casebitc::FUNC_CODE_DEBUG_RECORD_DECLARE:

6687 DVR =newDbgVariableRecord(RawLocation, Var, Expr, DIL,

6688 DbgVariableRecord::LocationType::Declare);

6689break;

6690casebitc::FUNC_CODE_DEBUG_RECORD_ASSIGN: {

6691DIAssignID *ID = cast<DIAssignID>(getFnMetadataByID(Record[Slot++]));

6692DIExpression *AddrExpr =

6693 cast<DIExpression>(getFnMetadataByID(Record[Slot++]));

6694Metadata *Addr = getFnMetadataByID(Record[Slot++]);

6695 DVR =newDbgVariableRecord(RawLocation, Var, Expr,ID,Addr, AddrExpr,

6696 DIL);

6697break;

6698 }

6699default:

6700llvm_unreachable("Unknown DbgVariableRecord bitcode");

6701 }

6702 Inst->getParent()->insertDbgRecordBefore(DVR, Inst->getIterator());

6703continue;// This isn't an instruction.

6704 }

6705casebitc::FUNC_CODE_INST_CALL: {

6706// CALL: [paramattrs, cc, fmf, fnty, fnid, arg0, arg1...]

6707if (Record.size() < 3)

6708returnerror("Invalid record");

6709

6710unsigned OpNum = 0;

6711AttributeList PAL =getAttributes(Record[OpNum++]);

6712unsigned CCInfo =Record[OpNum++];

6713

6714FastMathFlags FMF;

6715if ((CCInfo >>bitc::CALL_FMF) & 1) {

6716 FMF =getDecodedFastMathFlags(Record[OpNum++]);

6717if (!FMF.any())

6718returnerror("Fast math flags indicator set for call with no FMF");

6719 }

6720

6721unsigned FTyID = InvalidTypeID;

6722FunctionType *FTy =nullptr;

6723if ((CCInfo >>bitc::CALL_EXPLICIT_TYPE) & 1) {

6724 FTyID =Record[OpNum++];

6725 FTy = dyn_cast_or_null<FunctionType>(getTypeByID(FTyID));

6726if (!FTy)

6727returnerror("Explicit call type is not a function type");

6728 }

6729

6730Value *Callee;

6731unsigned CalleeTypeID;

6732if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID,

6733 CurBB))

6734returnerror("Invalid record");

6735

6736PointerType *OpTy = dyn_cast<PointerType>(Callee->getType());

6737if (!OpTy)

6738returnerror("Callee is not a pointer type");

6739if (!FTy) {

6740 FTyID = getContainedTypeID(CalleeTypeID);

6741 FTy = dyn_cast_or_null<FunctionType>(getTypeByID(FTyID));

6742if (!FTy)

6743returnerror("Callee is not of pointer to function type");

6744 }

6745if (Record.size() < FTy->getNumParams() + OpNum)

6746returnerror("Insufficient operands to call");

6747

6748SmallVector<Value*, 16>Args;

6749SmallVector<unsigned, 16> ArgTyIDs;

6750// Read the fixed params.

6751for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) {

6752unsigned ArgTyID = getContainedTypeID(FTyID, i + 1);

6753if (FTy->getParamType(i)->isLabelTy())

6754Args.push_back(getBasicBlock(Record[OpNum]));

6755else

6756Args.push_back(getValue(Record, OpNum, NextValueNo,

6757 FTy->getParamType(i), ArgTyID, CurBB));

6758 ArgTyIDs.push_back(ArgTyID);

6759if (!Args.back())

6760returnerror("Invalid record");

6761 }

6762

6763// Read type/value pairs for varargs params.

6764if (!FTy->isVarArg()) {

6765if (OpNum !=Record.size())

6766returnerror("Invalid record");

6767 }else {

6768while (OpNum !=Record.size()) {

6769Value *Op;

6770unsigned OpTypeID;

6771if (getValueTypePair(Record, OpNum, NextValueNo,Op, OpTypeID, CurBB))

6772returnerror("Invalid record");

6773Args.push_back(Op);

6774 ArgTyIDs.push_back(OpTypeID);

6775 }

6776 }

6777

6778// Upgrade the bundles if needed.

6779if (!OperandBundles.empty())

6780UpgradeOperandBundles(OperandBundles);

6781

6782I =CallInst::Create(FTy, Callee, Args, OperandBundles);

6783 ResTypeID = getContainedTypeID(FTyID);

6784 OperandBundles.clear();

6785 InstructionList.push_back(I);

6786 cast<CallInst>(I)->setCallingConv(

6787static_cast<CallingConv::ID>((0x7ff & CCInfo) >>bitc::CALL_CCONV));

6788CallInst::TailCallKind TCK =CallInst::TCK_None;

6789if (CCInfo & (1 <<bitc::CALL_TAIL))

6790 TCK =CallInst::TCK_Tail;

6791if (CCInfo & (1 <<bitc::CALL_MUSTTAIL))

6792 TCK =CallInst::TCK_MustTail;

6793if (CCInfo & (1 <<bitc::CALL_NOTAIL))

6794 TCK =CallInst::TCK_NoTail;

6795 cast<CallInst>(I)->setTailCallKind(TCK);

6796 cast<CallInst>(I)->setAttributes(PAL);

6797if (isa<DbgInfoIntrinsic>(I))

6798 SeenDebugIntrinsic =true;

6799if (Error Err = propagateAttributeTypes(cast<CallBase>(I), ArgTyIDs)) {

6800I->deleteValue();

6801return Err;

6802 }

6803if (FMF.any()) {

6804if (!isa<FPMathOperator>(I))

6805returnerror("Fast-math-flags specified for call without "

6806"floating-point scalar or vector return type");

6807I->setFastMathFlags(FMF);

6808 }

6809break;

6810 }

6811casebitc::FUNC_CODE_INST_VAARG: {// VAARG: [valistty, valist, instty]

6812if (Record.size() < 3)

6813returnerror("Invalid record");

6814unsigned OpTyID =Record[0];

6815Type *OpTy = getTypeByID(OpTyID);

6816Value *Op = getValue(Record, 1, NextValueNo, OpTy, OpTyID, CurBB);

6817 ResTypeID =Record[2];

6818Type *ResTy = getTypeByID(ResTypeID);

6819if (!OpTy || !Op || !ResTy)

6820returnerror("Invalid record");

6821I =newVAArgInst(Op, ResTy);

6822 InstructionList.push_back(I);

6823break;

6824 }

6825

6826casebitc::FUNC_CODE_OPERAND_BUNDLE: {

6827// A call or an invoke can be optionally prefixed with some variable

6828// number of operand bundle blocks. These blocks are read into

6829// OperandBundles and consumed at the next call or invoke instruction.

6830

6831if (Record.empty() ||Record[0] >= BundleTags.size())

6832returnerror("Invalid record");

6833

6834 std::vector<Value *> Inputs;

6835

6836unsigned OpNum = 1;

6837while (OpNum !=Record.size()) {

6838Value *Op;

6839if (getValueOrMetadata(Record, OpNum, NextValueNo,Op, CurBB))

6840returnerror("Invalid record");

6841 Inputs.push_back(Op);

6842 }

6843

6844 OperandBundles.emplace_back(BundleTags[Record[0]], std::move(Inputs));

6845continue;

6846 }

6847

6848casebitc::FUNC_CODE_INST_FREEZE: {// FREEZE: [opty,opval]

6849unsigned OpNum = 0;

6850Value *Op =nullptr;

6851unsigned OpTypeID;

6852if (getValueTypePair(Record, OpNum, NextValueNo,Op, OpTypeID, CurBB))

6853returnerror("Invalid record");

6854if (OpNum !=Record.size())

6855returnerror("Invalid record");

6856

6857I =newFreezeInst(Op);

6858 ResTypeID = OpTypeID;

6859 InstructionList.push_back(I);

6860break;

6861 }

6862 }

6863

6864// Add instruction to end of current BB. If there is no current BB, reject

6865// this file.

6866if (!CurBB) {

6867I->deleteValue();

6868returnerror("Invalid instruction with no BB");

6869 }

6870if (!OperandBundles.empty()) {

6871I->deleteValue();

6872returnerror("Operand bundles found with no consumer");

6873 }

6874I->insertInto(CurBB, CurBB->end());

6875

6876// If this was a terminator instruction, move to the next block.

6877if (I->isTerminator()) {

6878 ++CurBBNo;

6879 CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] :nullptr;

6880 }

6881

6882// Non-void values get registered in the value table for future use.

6883if (!I->getType()->isVoidTy()) {

6884assert(I->getType() == getTypeByID(ResTypeID) &&

6885"Incorrect result type ID");

6886if (Error Err = ValueList.assignValue(NextValueNo++,I, ResTypeID))

6887return Err;

6888 }

6889 }

6890

6891OutOfRecordLoop:

6892

6893if (!OperandBundles.empty())

6894returnerror("Operand bundles found with no consumer");

6895

6896// Check the function list for unresolved values.

6897if (Argument *A = dyn_cast<Argument>(ValueList.back())) {

6898if (!A->getParent()) {

6899// We found at least one unresolved value. Nuke them all to avoid leaks.

6900for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){

6901if ((A = dyn_cast_or_null<Argument>(ValueList[i])) && !A->getParent()) {

6902A->replaceAllUsesWith(PoisonValue::get(A->getType()));

6903deleteA;

6904 }

6905 }

6906returnerror("Never resolved value found in function");

6907 }

6908 }

6909

6910// Unexpected unresolved metadata about to be dropped.

6911if (MDLoader->hasFwdRefs())

6912returnerror("Invalid function metadata: outgoing forward refs");

6913

6914if (PhiConstExprBB)

6915 PhiConstExprBB->eraseFromParent();

6916

6917for (constauto &Pair : ConstExprEdgeBBs) {

6918BasicBlock *From = Pair.first.first;

6919BasicBlock *To = Pair.first.second;

6920BasicBlock *EdgeBB = Pair.second;

6921BranchInst::Create(To, EdgeBB);

6922From->getTerminator()->replaceSuccessorWith(To, EdgeBB);

6923 To->replacePhiUsesWith(From, EdgeBB);

6924 EdgeBB->moveBefore(To);

6925 }

6926

6927// Trim the value list down to the size it was before we parsed this function.

6928 ValueList.shrinkTo(ModuleValueListSize);

6929 MDLoader->shrinkTo(ModuleMDLoaderSize);

6930 std::vector<BasicBlock*>().swap(FunctionBBs);

6931returnError::success();

6932}

6933

6934/// Find the function body in the bitcode stream

6935Error BitcodeReader::findFunctionInStream(

6936Function *F,

6937DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) {

6938while (DeferredFunctionInfoIterator->second == 0) {

6939// This is the fallback handling for the old format bitcode that

6940// didn't contain the function index in the VST, or when we have

6941// an anonymous function which would not have a VST entry.

6942// Assert that we have one of those two cases.

6943assert(VSTOffset == 0 || !F->hasName());

6944// Parse the next body in the stream and set its position in the

6945// DeferredFunctionInfo map.

6946if (Error Err = rememberAndSkipFunctionBodies())

6947return Err;

6948 }

6949returnError::success();

6950}

6951

6952SyncScope::ID BitcodeReader::getDecodedSyncScopeID(unsigned Val) {

6953if (Val ==SyncScope::SingleThread || Val ==SyncScope::System)

6954returnSyncScope::ID(Val);

6955if (Val >= SSIDs.size())

6956returnSyncScope::System;// Map unknown synchronization scopes to system.

6957return SSIDs[Val];

6958}

6959

6960//===----------------------------------------------------------------------===//

6961// GVMaterializer implementation

6962//===----------------------------------------------------------------------===//

6963

6964Error BitcodeReader::materialize(GlobalValue *GV) {

6965Function *F = dyn_cast<Function>(GV);

6966// If it's not a function or is already material, ignore the request.

6967if (!F || !F->isMaterializable())

6968returnError::success();

6969

6970DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F);

6971assert(DFII != DeferredFunctionInfo.end() &&"Deferred function not found!");

6972// If its position is recorded as 0, its body is somewhere in the stream

6973// but we haven't seen it yet.

6974if (DFII->second == 0)

6975if (Error Err = findFunctionInStream(F, DFII))

6976return Err;

6977

6978// Materialize metadata before parsing any function bodies.

6979if (Error Err = materializeMetadata())

6980return Err;

6981

6982// Move the bit stream to the saved position of the deferred function body.

6983if (Error JumpFailed = Stream.JumpToBit(DFII->second))

6984return JumpFailed;

6985

6986// Regardless of the debug info format we want to end up in, we need

6987// IsNewDbgInfoFormat=true to construct any debug records seen in the bitcode.

6988F->IsNewDbgInfoFormat =true;

6989

6990if (Error Err = parseFunctionBody(F))

6991return Err;

6992F->setIsMaterializable(false);

6993

6994// All parsed Functions should load into the debug info format dictated by the

6995// Module, unless we're attempting to preserve the input debug info format.

6996if (SeenDebugIntrinsic && SeenDebugRecord)

6997returnerror("Mixed debug intrinsics and debug records in bitcode module!");

6998if (PreserveInputDbgFormat == cl::boolOrDefault::BOU_TRUE) {

6999bool SeenAnyDebugInfo = SeenDebugIntrinsic || SeenDebugRecord;

7000bool NewDbgInfoFormatDesired =

7001 SeenAnyDebugInfo ? SeenDebugRecord :F->getParent()->IsNewDbgInfoFormat;

7002if (SeenAnyDebugInfo) {

7003UseNewDbgInfoFormat = SeenDebugRecord;

7004WriteNewDbgInfoFormatToBitcode = SeenDebugRecord;

7005WriteNewDbgInfoFormat = SeenDebugRecord;

7006 }

7007// If the module's debug info format doesn't match the observed input

7008// format, then set its format now; we don't need to call the conversion

7009// function because there must be no existing intrinsics to convert.

7010// Otherwise, just set the format on this function now.

7011if (NewDbgInfoFormatDesired !=F->getParent()->IsNewDbgInfoFormat)

7012F->getParent()->setNewDbgInfoFormatFlag(NewDbgInfoFormatDesired);

7013else

7014F->setNewDbgInfoFormatFlag(NewDbgInfoFormatDesired);

7015 }else {

7016// If we aren't preserving formats, we use the Module flag to get our

7017// desired format instead of reading flags, in case we are lazy-loading and

7018// the format of the module has been changed since it was set by the flags.

7019// We only need to convert debug info here if we have debug records but

7020// desire the intrinsic format; everything else is a no-op or handled by the

7021// autoupgrader.

7022bool ModuleIsNewDbgInfoFormat =F->getParent()->IsNewDbgInfoFormat;

7023if (ModuleIsNewDbgInfoFormat || !SeenDebugRecord)

7024F->setNewDbgInfoFormatFlag(ModuleIsNewDbgInfoFormat);

7025else

7026F->setIsNewDbgInfoFormat(ModuleIsNewDbgInfoFormat);

7027 }

7028

7029if (StripDebugInfo)

7030stripDebugInfo(*F);

7031

7032// Upgrade any old intrinsic calls in the function.

7033for (auto &I : UpgradedIntrinsics) {

7034for (User *U :llvm::make_early_inc_range(I.first->materialized_users()))

7035if (CallInst *CI = dyn_cast<CallInst>(U))

7036UpgradeIntrinsicCall(CI,I.second);

7037 }

7038

7039// Finish fn->subprogram upgrade for materialized functions.

7040if (DISubprogram *SP = MDLoader->lookupSubprogramForFunction(F))

7041F->setSubprogram(SP);

7042

7043// Check if the TBAA Metadata are valid, otherwise we will need to strip them.

7044if (!MDLoader->isStrippingTBAA()) {

7045for (auto &I :instructions(F)) {

7046MDNode *TBAA =I.getMetadata(LLVMContext::MD_tbaa);

7047if (!TBAA || TBAAVerifyHelper.visitTBAAMetadata(I, TBAA))

7048continue;

7049 MDLoader->setStripTBAA(true);

7050stripTBAA(F->getParent());

7051 }

7052 }

7053

7054for (auto &I :instructions(F)) {

7055// "Upgrade" older incorrect branch weights by dropping them.

7056if (auto *MD =I.getMetadata(LLVMContext::MD_prof)) {

7057if (MD->getOperand(0) !=nullptr && isa<MDString>(MD->getOperand(0))) {

7058MDString *MDS = cast<MDString>(MD->getOperand(0));

7059StringRef ProfName = MDS->getString();

7060// Check consistency of !prof branch_weights metadata.

7061if (ProfName !="branch_weights")

7062continue;

7063unsigned ExpectedNumOperands = 0;

7064if (BranchInst *BI = dyn_cast<BranchInst>(&I))

7065 ExpectedNumOperands = BI->getNumSuccessors();

7066elseif (SwitchInst *SI = dyn_cast<SwitchInst>(&I))

7067 ExpectedNumOperands =SI->getNumSuccessors();

7068elseif (isa<CallInst>(&I))

7069 ExpectedNumOperands = 1;

7070elseif (IndirectBrInst *IBI = dyn_cast<IndirectBrInst>(&I))

7071 ExpectedNumOperands = IBI->getNumDestinations();

7072elseif (isa<SelectInst>(&I))

7073 ExpectedNumOperands = 2;

7074else

7075continue;// ignore and continue.

7076

7077unsignedOffset =getBranchWeightOffset(MD);

7078

7079// If branch weight doesn't match, just strip branch weight.

7080if (MD->getNumOperands() !=Offset + ExpectedNumOperands)

7081I.setMetadata(LLVMContext::MD_prof,nullptr);

7082 }

7083 }

7084

7085// Remove incompatible attributes on function calls.

7086if (auto *CI = dyn_cast<CallBase>(&I)) {

7087 CI->removeRetAttrs(AttributeFuncs::typeIncompatible(

7088 CI->getFunctionType()->getReturnType(), CI->getRetAttributes()));

7089

7090for (unsigned ArgNo = 0; ArgNo < CI->arg_size(); ++ArgNo)

7091 CI->removeParamAttrs(ArgNo,AttributeFuncs::typeIncompatible(

7092 CI->getArgOperand(ArgNo)->getType(),

7093 CI->getParamAttributes(ArgNo)));

7094 }

7095 }

7096

7097// Look for functions that rely on old function attribute behavior.

7098UpgradeFunctionAttributes(*F);

7099

7100// Bring in any functions that this function forward-referenced via

7101// blockaddresses.

7102return materializeForwardReferencedFunctions();

7103}

7104

7105Error BitcodeReader::materializeModule() {

7106if (Error Err = materializeMetadata())

7107return Err;

7108

7109// Promise to materialize all forward references.

7110 WillMaterializeAllForwardRefs =true;

7111

7112// Iterate over the module, deserializing any functions that are still on

7113// disk.

7114for (Function &F : *TheModule) {

7115if (Error Err = materialize(&F))

7116return Err;

7117 }

7118// At this point, if there are any function bodies, parse the rest of

7119// the bits in the module past the last function block we have recorded

7120// through either lazy scanning or the VST.

7121if (LastFunctionBlockBit || NextUnreadBit)

7122if (Error Err =parseModule(LastFunctionBlockBit > NextUnreadBit

7123 ? LastFunctionBlockBit

7124 : NextUnreadBit))

7125return Err;

7126

7127// Check that all block address forward references got resolved (as we

7128// promised above).

7129if (!BasicBlockFwdRefs.empty())

7130returnerror("Never resolved function from blockaddress");

7131

7132// Upgrade any intrinsic calls that slipped through (should not happen!) and

7133// delete the old functions to clean up. We can't do this unless the entire

7134// module is materialized because there could always be another function body

7135// with calls to the old function.

7136for (auto &I : UpgradedIntrinsics) {

7137for (auto *U :I.first->users()) {

7138if (CallInst *CI = dyn_cast<CallInst>(U))

7139UpgradeIntrinsicCall(CI,I.second);

7140 }

7141if (!I.first->use_empty())

7142I.first->replaceAllUsesWith(I.second);

7143I.first->eraseFromParent();

7144 }

7145 UpgradedIntrinsics.clear();

7146

7147UpgradeDebugInfo(*TheModule);

7148

7149UpgradeModuleFlags(*TheModule);

7150

7151UpgradeARCRuntime(*TheModule);

7152

7153returnError::success();

7154}

7155

7156std::vector<StructType *> BitcodeReader::getIdentifiedStructTypes() const{

7157return IdentifiedStructTypes;

7158}

7159

7160ModuleSummaryIndexBitcodeReader::ModuleSummaryIndexBitcodeReader(

7161BitstreamCursor Cursor,StringRef Strtab,ModuleSummaryIndex &TheIndex,

7162StringRef ModulePath, std::function<bool(GlobalValue::GUID)> IsPrevailing)

7163 : BitcodeReaderBase(std::move(Cursor), Strtab), TheIndex(TheIndex),

7164 ModulePath(ModulePath), IsPrevailing(IsPrevailing) {}

7165

7166void ModuleSummaryIndexBitcodeReader::addThisModule() {

7167 TheIndex.addModule(ModulePath);

7168}

7169

7170ModuleSummaryIndex::ModuleInfo *

7171ModuleSummaryIndexBitcodeReader::getThisModule() {

7172return TheIndex.getModule(ModulePath);

7173}

7174

7175template <bool AllowNullValueInfo>

7176std::pair<ValueInfo, GlobalValue::GUID>

7177ModuleSummaryIndexBitcodeReader::getValueInfoFromValueId(unsigned ValueId) {

7178auto VGI = ValueIdToValueInfoMap[ValueId];

7179// We can have a null value info for memprof callsite info records in

7180// distributed ThinLTO index files when the callee function summary is not

7181// included in the index. The bitcode writer records 0 in that case,

7182// and the caller of this helper will set AllowNullValueInfo to true.

7183assert(AllowNullValueInfo || std::get<0>(VGI));

7184return VGI;

7185}

7186

7187void ModuleSummaryIndexBitcodeReader::setValueGUID(

7188uint64_t ValueID,StringRef ValueName,GlobalValue::LinkageTypes Linkage,

7189StringRef SourceFileName) {

7190 std::string GlobalId =

7191GlobalValue::getGlobalIdentifier(ValueName, Linkage, SourceFileName);

7192auto ValueGUID =GlobalValue::getGUID(GlobalId);

7193auto OriginalNameID = ValueGUID;

7194if (GlobalValue::isLocalLinkage(Linkage))

7195 OriginalNameID =GlobalValue::getGUID(ValueName);

7196if (PrintSummaryGUIDs)

7197dbgs() <<"GUID " << ValueGUID <<"(" << OriginalNameID <<") is "

7198 <<ValueName <<"\n";

7199

7200// UseStrtab is false for legacy summary formats and value names are

7201// created on stack. In that case we save the name in a string saver in

7202// the index so that the value name can be recorded.

7203 ValueIdToValueInfoMap[ValueID] = std::make_pair(

7204 TheIndex.getOrInsertValueInfo(

7205 ValueGUID, UseStrtab ?ValueName : TheIndex.saveString(ValueName)),

7206 OriginalNameID);

7207}

7208

7209// Specialized value symbol table parser used when reading module index

7210// blocks where we don't actually create global values. The parsed information

7211// is saved in the bitcode reader for use when later parsing summaries.

7212Error ModuleSummaryIndexBitcodeReader::parseValueSymbolTable(

7213uint64_t Offset,

7214DenseMap<unsigned, GlobalValue::LinkageTypes> &ValueIdToLinkageMap) {

7215// With a strtab the VST is not required to parse the summary.

7216if (UseStrtab)

7217returnError::success();

7218

7219assert(Offset > 0 &&"Expected non-zero VST offset");

7220Expected<uint64_t> MaybeCurrentBit =jumpToValueSymbolTable(Offset, Stream);

7221if (!MaybeCurrentBit)

7222return MaybeCurrentBit.takeError();

7223uint64_t CurrentBit = MaybeCurrentBit.get();

7224

7225if (Error Err = Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))

7226return Err;

7227

7228SmallVector<uint64_t, 64>Record;

7229

7230// Read all the records for this value table.

7231SmallString<128>ValueName;

7232

7233while (true) {

7234Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

7235if (!MaybeEntry)

7236return MaybeEntry.takeError();

7237BitstreamEntry Entry = MaybeEntry.get();

7238

7239switch (Entry.Kind) {

7240caseBitstreamEntry::SubBlock:// Handled for us already.

7241caseBitstreamEntry::Error:

7242returnerror("Malformed block");

7243caseBitstreamEntry::EndBlock:

7244// Done parsing VST, jump back to wherever we came from.

7245if (Error JumpFailed = Stream.JumpToBit(CurrentBit))

7246return JumpFailed;

7247returnError::success();

7248caseBitstreamEntry::Record:

7249// The interesting case.

7250break;

7251 }

7252

7253// Read a record.

7254Record.clear();

7255Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

7256if (!MaybeRecord)

7257return MaybeRecord.takeError();

7258switch (MaybeRecord.get()) {

7259default:// Default behavior: ignore (e.g. VST_CODE_BBENTRY records).

7260break;

7261casebitc::VST_CODE_ENTRY: {// VST_CODE_ENTRY: [valueid, namechar x N]

7262if (convertToString(Record, 1,ValueName))

7263returnerror("Invalid record");

7264unsigned ValueID =Record[0];

7265assert(!SourceFileName.empty());

7266auto VLI = ValueIdToLinkageMap.find(ValueID);

7267assert(VLI != ValueIdToLinkageMap.end() &&

7268"No linkage found for VST entry?");

7269autoLinkage = VLI->second;

7270 setValueGUID(ValueID,ValueName, Linkage, SourceFileName);

7271ValueName.clear();

7272break;

7273 }

7274casebitc::VST_CODE_FNENTRY: {

7275// VST_CODE_FNENTRY: [valueid, offset, namechar x N]

7276if (convertToString(Record, 2,ValueName))

7277returnerror("Invalid record");

7278unsigned ValueID =Record[0];

7279assert(!SourceFileName.empty());

7280auto VLI = ValueIdToLinkageMap.find(ValueID);

7281assert(VLI != ValueIdToLinkageMap.end() &&

7282"No linkage found for VST entry?");

7283autoLinkage = VLI->second;

7284 setValueGUID(ValueID,ValueName, Linkage, SourceFileName);

7285ValueName.clear();

7286break;

7287 }

7288casebitc::VST_CODE_COMBINED_ENTRY: {

7289// VST_CODE_COMBINED_ENTRY: [valueid, refguid]

7290unsigned ValueID =Record[0];

7291GlobalValue::GUID RefGUID =Record[1];

7292// The "original name", which is the second value of the pair will be

7293// overriden later by a FS_COMBINED_ORIGINAL_NAME in the combined index.

7294 ValueIdToValueInfoMap[ValueID] =

7295 std::make_pair(TheIndex.getOrInsertValueInfo(RefGUID), RefGUID);

7296break;

7297 }

7298 }

7299 }

7300}

7301

7302// Parse just the blocks needed for building the index out of the module.

7303// At the end of this routine the module Index is populated with a map

7304// from global value id to GlobalValueSummary objects.

7305Error ModuleSummaryIndexBitcodeReader::parseModule() {

7306if (Error Err = Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))

7307return Err;

7308

7309SmallVector<uint64_t, 64>Record;

7310DenseMap<unsigned, GlobalValue::LinkageTypes> ValueIdToLinkageMap;

7311unsigned ValueId = 0;

7312

7313// Read the index for this module.

7314while (true) {

7315Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();

7316if (!MaybeEntry)

7317return MaybeEntry.takeError();

7318llvm::BitstreamEntry Entry = MaybeEntry.get();

7319

7320switch (Entry.Kind) {

7321caseBitstreamEntry::Error:

7322returnerror("Malformed block");

7323caseBitstreamEntry::EndBlock:

7324returnError::success();

7325

7326caseBitstreamEntry::SubBlock:

7327switch (Entry.ID) {

7328default:// Skip unknown content.

7329if (Error Err = Stream.SkipBlock())

7330return Err;

7331break;

7332casebitc::BLOCKINFO_BLOCK_ID:

7333// Need to parse these to get abbrev ids (e.g. for VST)

7334if (Error Err = readBlockInfo())

7335return Err;

7336break;

7337casebitc::VALUE_SYMTAB_BLOCK_ID:

7338// Should have been parsed earlier via VSTOffset, unless there

7339// is no summary section.

7340assert(((SeenValueSymbolTable && VSTOffset > 0) ||

7341 !SeenGlobalValSummary) &&

7342"Expected early VST parse via VSTOffset record");

7343if (Error Err = Stream.SkipBlock())

7344return Err;

7345break;

7346casebitc::GLOBALVAL_SUMMARY_BLOCK_ID:

7347casebitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID:

7348// Add the module if it is a per-module index (has a source file name).

7349if (!SourceFileName.empty())

7350 addThisModule();

7351assert(!SeenValueSymbolTable &&

7352"Already read VST when parsing summary block?");

7353// We might not have a VST if there were no values in the

7354// summary. An empty summary block generated when we are

7355// performing ThinLTO compiles so we don't later invoke

7356// the regular LTO process on them.

7357if (VSTOffset > 0) {

7358if (Error Err = parseValueSymbolTable(VSTOffset, ValueIdToLinkageMap))

7359return Err;

7360 SeenValueSymbolTable =true;

7361 }

7362 SeenGlobalValSummary =true;

7363if (Error Err = parseEntireSummary(Entry.ID))

7364return Err;

7365break;

7366casebitc::MODULE_STRTAB_BLOCK_ID:

7367if (Error Err = parseModuleStringTable())

7368return Err;

7369break;

7370 }

7371continue;

7372

7373caseBitstreamEntry::Record: {

7374Record.clear();

7375Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID,Record);

7376if (!MaybeBitCode)

7377return MaybeBitCode.takeError();

7378switch (MaybeBitCode.get()) {

7379default:

7380break;// Default behavior, ignore unknown content.

7381casebitc::MODULE_CODE_VERSION: {

7382if (Error Err = parseVersionRecord(Record).takeError())

7383return Err;

7384break;

7385 }

7386 /// MODULE_CODE_SOURCE_FILENAME: [namechar x N]

7387casebitc::MODULE_CODE_SOURCE_FILENAME: {

7388SmallString<128>ValueName;

7389if (convertToString(Record, 0,ValueName))

7390returnerror("Invalid record");

7391 SourceFileName =ValueName.c_str();

7392break;

7393 }

7394 /// MODULE_CODE_HASH: [5*i32]

7395casebitc::MODULE_CODE_HASH: {

7396if (Record.size() != 5)

7397returnerror("Invalid hash length " +Twine(Record.size()).str());

7398auto &Hash = getThisModule()->second;

7399int Pos = 0;

7400for (auto &Val :Record) {

7401assert(!(Val >> 32) &&"Unexpected high bits set");

7402 Hash[Pos++] = Val;

7403 }

7404break;

7405 }

7406 /// MODULE_CODE_VSTOFFSET: [offset]

7407casebitc::MODULE_CODE_VSTOFFSET:

7408if (Record.empty())

7409returnerror("Invalid record");

7410// Note that we subtract 1 here because the offset is relative to one

7411// word before the start of the identification or module block, which

7412// was historically always the start of the regular bitcode header.

7413 VSTOffset =Record[0] - 1;

7414break;

7415// v1 GLOBALVAR: [pointer type, isconst, initid, linkage, ...]

7416// v1 FUNCTION: [type, callingconv, isproto, linkage, ...]

7417// v1 ALIAS: [alias type, addrspace, aliasee val#, linkage, ...]

7418// v2: [strtab offset, strtab size, v1]

7419casebitc::MODULE_CODE_GLOBALVAR:

7420casebitc::MODULE_CODE_FUNCTION:

7421casebitc::MODULE_CODE_ALIAS: {

7422StringRef Name;

7423ArrayRef<uint64_t> GVRecord;

7424 std::tie(Name, GVRecord) = readNameFromStrtab(Record);

7425if (GVRecord.size() <= 3)

7426returnerror("Invalid record");

7427uint64_t RawLinkage = GVRecord[3];

7428GlobalValue::LinkageTypes Linkage =getDecodedLinkage(RawLinkage);

7429if (!UseStrtab) {

7430 ValueIdToLinkageMap[ValueId++] =Linkage;

7431break;

7432 }

7433

7434 setValueGUID(ValueId++,Name, Linkage, SourceFileName);

7435break;

7436 }

7437 }

7438 }

7439continue;

7440 }

7441 }

7442}

7443

7444SmallVector<ValueInfo, 0>

7445ModuleSummaryIndexBitcodeReader::makeRefList(ArrayRef<uint64_t>Record) {

7446SmallVector<ValueInfo, 0>Ret;

7447Ret.reserve(Record.size());

7448for (uint64_t RefValueId :Record)

7449Ret.push_back(std::get<0>(getValueInfoFromValueId(RefValueId)));

7450returnRet;

7451}

7452

7453SmallVector<FunctionSummary::EdgeTy, 0>

7454ModuleSummaryIndexBitcodeReader::makeCallList(ArrayRef<uint64_t>Record,

7455bool IsOldProfileFormat,

7456bool HasProfile,bool HasRelBF) {

7457SmallVector<FunctionSummary::EdgeTy, 0>Ret;

7458// In the case of new profile formats, there are two Record entries per

7459// Edge. Otherwise, conservatively reserve up to Record.size.

7460if (!IsOldProfileFormat && (HasProfile || HasRelBF))

7461Ret.reserve(Record.size() / 2);

7462else

7463Ret.reserve(Record.size());

7464

7465for (unsignedI = 0, E =Record.size();I != E; ++I) {

7466CalleeInfo::HotnessType Hotness = CalleeInfo::HotnessType::Unknown;

7467bool HasTailCall =false;

7468uint64_t RelBF = 0;

7469ValueInfo Callee = std::get<0>(getValueInfoFromValueId(Record[I]));

7470if (IsOldProfileFormat) {

7471I += 1;// Skip old callsitecount field

7472if (HasProfile)

7473I += 1;// Skip old profilecount field

7474 }elseif (HasProfile)

7475 std::tie(Hotness, HasTailCall) =

7476getDecodedHotnessCallEdgeInfo(Record[++I]);

7477elseif (HasRelBF)

7478getDecodedRelBFCallEdgeInfo(Record[++I], RelBF, HasTailCall);

7479Ret.push_back(FunctionSummary::EdgeTy{

7480Callee,CalleeInfo(Hotness, HasTailCall, RelBF)});

7481 }

7482returnRet;

7483}

7484

7485staticvoid

7486parseWholeProgramDevirtResolutionByArg(ArrayRef<uint64_t>Record,size_t &Slot,

7487WholeProgramDevirtResolution &Wpd) {

7488uint64_t ArgNum =Record[Slot++];

7489WholeProgramDevirtResolution::ByArg &B =

7490 Wpd.ResByArg[{Record.begin() + Slot,Record.begin() + Slot + ArgNum}];

7491 Slot += ArgNum;

7492

7493B.TheKind =

7494static_cast<WholeProgramDevirtResolution::ByArg::Kind>(Record[Slot++]);

7495B.Info =Record[Slot++];

7496B.Byte =Record[Slot++];

7497B.Bit =Record[Slot++];

7498}

7499

7500staticvoidparseWholeProgramDevirtResolution(ArrayRef<uint64_t>Record,

7501StringRef Strtab,size_t &Slot,

7502TypeIdSummary &TypeId) {

7503uint64_t Id =Record[Slot++];

7504WholeProgramDevirtResolution &Wpd = TypeId.WPDRes[Id];

7505

7506 Wpd.TheKind =static_cast<WholeProgramDevirtResolution::Kind>(Record[Slot++]);

7507 Wpd.SingleImplName = {Strtab.data() +Record[Slot],

7508static_cast<size_t>(Record[Slot + 1])};

7509 Slot += 2;

7510

7511uint64_t ResByArgNum =Record[Slot++];

7512for (uint64_t I = 0;I != ResByArgNum; ++I)

7513parseWholeProgramDevirtResolutionByArg(Record, Slot, Wpd);

7514}

7515

7516staticvoidparseTypeIdSummaryRecord(ArrayRef<uint64_t>Record,

7517StringRef Strtab,

7518ModuleSummaryIndex &TheIndex) {

7519size_t Slot = 0;

7520TypeIdSummary &TypeId = TheIndex.getOrInsertTypeIdSummary(

7521 {Strtab.data() +Record[Slot],static_cast<size_t>(Record[Slot + 1])});

7522 Slot += 2;

7523

7524 TypeId.TTRes.TheKind =static_cast<TypeTestResolution::Kind>(Record[Slot++]);

7525 TypeId.TTRes.SizeM1BitWidth =Record[Slot++];

7526 TypeId.TTRes.AlignLog2 =Record[Slot++];

7527 TypeId.TTRes.SizeM1 =Record[Slot++];

7528 TypeId.TTRes.BitMask =Record[Slot++];

7529 TypeId.TTRes.InlineBits =Record[Slot++];

7530

7531while (Slot <Record.size())

7532parseWholeProgramDevirtResolution(Record, Strtab, Slot, TypeId);

7533}

7534

7535std::vector<FunctionSummary::ParamAccess>

7536ModuleSummaryIndexBitcodeReader::parseParamAccesses(ArrayRef<uint64_t>Record) {

7537auto ReadRange = [&]() {

7538APInt Lower(FunctionSummary::ParamAccess::RangeWidth,

7539 BitcodeReader::decodeSignRotatedValue(Record.front()));

7540Record =Record.drop_front();

7541APInt Upper(FunctionSummary::ParamAccess::RangeWidth,

7542 BitcodeReader::decodeSignRotatedValue(Record.front()));

7543Record =Record.drop_front();

7544ConstantRange Range{Lower,Upper};

7545assert(!Range.isFullSet());

7546assert(!Range.isUpperSignWrapped());

7547returnRange;

7548 };

7549

7550 std::vector<FunctionSummary::ParamAccess> PendingParamAccesses;

7551while (!Record.empty()) {

7552 PendingParamAccesses.emplace_back();

7553FunctionSummary::ParamAccess &ParamAccess = PendingParamAccesses.back();

7554 ParamAccess.ParamNo =Record.front();

7555Record =Record.drop_front();

7556 ParamAccess.Use = ReadRange();

7557 ParamAccess.Calls.resize(Record.front());

7558Record =Record.drop_front();

7559for (auto &Call : ParamAccess.Calls) {

7560Call.ParamNo =Record.front();

7561Record =Record.drop_front();

7562Call.Callee = std::get<0>(getValueInfoFromValueId(Record.front()));

7563Record =Record.drop_front();

7564Call.Offsets = ReadRange();

7565 }

7566 }

7567return PendingParamAccesses;

7568}

7569

7570void ModuleSummaryIndexBitcodeReader::parseTypeIdCompatibleVtableInfo(

7571ArrayRef<uint64_t>Record,size_t &Slot,

7572TypeIdCompatibleVtableInfo &TypeId) {

7573uint64_t Offset =Record[Slot++];

7574ValueInfo Callee = std::get<0>(getValueInfoFromValueId(Record[Slot++]));

7575 TypeId.push_back({Offset,Callee});

7576}

7577

7578void ModuleSummaryIndexBitcodeReader::parseTypeIdCompatibleVtableSummaryRecord(

7579ArrayRef<uint64_t>Record) {

7580size_tSlot = 0;

7581TypeIdCompatibleVtableInfo &TypeId =

7582 TheIndex.getOrInsertTypeIdCompatibleVtableSummary(

7583 {Strtab.data() +Record[Slot],

7584static_cast<size_t>(Record[Slot + 1])});

7585Slot += 2;

7586

7587while (Slot <Record.size())

7588 parseTypeIdCompatibleVtableInfo(Record, Slot, TypeId);

7589}

7590

7591SmallVector<unsigned> ModuleSummaryIndexBitcodeReader::parseAllocInfoContext(

7592ArrayRef<uint64_t>Record,unsigned &I) {

7593SmallVector<unsigned> StackIdList;

7594// For backwards compatibility with old format before radix tree was

7595// used, simply see if we found a radix tree array record (and thus if

7596// the RadixArray is non-empty).

7597if (RadixArray.empty()) {

7598unsigned NumStackEntries =Record[I++];

7599assert(Record.size() -I >= NumStackEntries);

7600 StackIdList.reserve(NumStackEntries);

7601for (unsigned J = 0; J < NumStackEntries; J++) {

7602assert(Record[I] < StackIds.size());

7603 StackIdList.push_back(

7604 TheIndex.addOrGetStackIdIndex(StackIds[Record[I++]]));

7605 }

7606 }else {

7607unsigned RadixIndex =Record[I++];

7608// See the comments above CallStackRadixTreeBuilder in ProfileData/MemProf.h

7609// for a detailed description of the radix tree array format. Briefly, the

7610// first entry will be the number of frames, any negative values are the

7611// negative of the offset of the next frame, and otherwise the frames are in

7612// increasing linear order.

7613assert(RadixIndex < RadixArray.size());

7614unsigned NumStackIds = RadixArray[RadixIndex++];

7615 StackIdList.reserve(NumStackIds);

7616while (NumStackIds--) {

7617assert(RadixIndex < RadixArray.size());

7618unsigned Elem = RadixArray[RadixIndex];

7619if (static_cast<std::make_signed_t<unsigned>>(Elem) < 0) {

7620 RadixIndex = RadixIndex - Elem;

7621assert(RadixIndex < RadixArray.size());

7622 Elem = RadixArray[RadixIndex];

7623// We shouldn't encounter a second offset in a row.

7624assert(static_cast<std::make_signed_t<unsigned>>(Elem) >= 0);

7625 }

7626 RadixIndex++;

7627 StackIdList.push_back(TheIndex.addOrGetStackIdIndex(StackIds[Elem]));

7628 }

7629 }

7630return StackIdList;

7631}

7632

7633staticvoidsetSpecialRefs(SmallVectorImpl<ValueInfo> &Refs,unsigned ROCnt,

7634unsigned WOCnt) {

7635// Readonly and writeonly refs are in the end of the refs list.

7636assert(ROCnt + WOCnt <= Refs.size());

7637unsigned FirstWORef = Refs.size() - WOCnt;

7638unsigned RefNo = FirstWORef - ROCnt;

7639for (; RefNo < FirstWORef; ++RefNo)

7640 Refs[RefNo].setReadOnly();

7641for (; RefNo < Refs.size(); ++RefNo)

7642 Refs[RefNo].setWriteOnly();

7643}

7644

7645// Eagerly parse the entire summary block. This populates the GlobalValueSummary

7646// objects in the index.

7647Error ModuleSummaryIndexBitcodeReader::parseEntireSummary(unsignedID) {

7648if (Error Err = Stream.EnterSubBlock(ID))

7649return Err;

7650SmallVector<uint64_t, 64>Record;

7651

7652// Parse version

7653 {

7654Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

7655if (!MaybeEntry)

7656return MaybeEntry.takeError();

7657BitstreamEntry Entry = MaybeEntry.get();

7658

7659if (Entry.Kind !=BitstreamEntry::Record)

7660returnerror("Invalid Summary Block: record for version expected");

7661Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

7662if (!MaybeRecord)

7663return MaybeRecord.takeError();

7664if (MaybeRecord.get() !=bitc::FS_VERSION)

7665returnerror("Invalid Summary Block: version expected");

7666 }

7667constuint64_t Version =Record[0];

7668constbool IsOldProfileFormat =Version == 1;

7669if (Version < 1 || Version >ModuleSummaryIndex::BitcodeSummaryVersion)

7670returnerror("Invalid summary version " +Twine(Version) +

7671". Version should be in the range [1-" +

7672Twine(ModuleSummaryIndex::BitcodeSummaryVersion) +

7673"].");

7674Record.clear();

7675

7676// Keep around the last seen summary to be used when we see an optional

7677// "OriginalName" attachement.

7678GlobalValueSummary *LastSeenSummary =nullptr;

7679GlobalValue::GUID LastSeenGUID = 0;

7680

7681// We can expect to see any number of type ID information records before

7682// each function summary records; these variables store the information

7683// collected so far so that it can be used to create the summary object.

7684 std::vector<GlobalValue::GUID> PendingTypeTests;

7685 std::vector<FunctionSummary::VFuncId> PendingTypeTestAssumeVCalls,

7686 PendingTypeCheckedLoadVCalls;

7687 std::vector<FunctionSummary::ConstVCall> PendingTypeTestAssumeConstVCalls,

7688 PendingTypeCheckedLoadConstVCalls;

7689 std::vector<FunctionSummary::ParamAccess> PendingParamAccesses;

7690

7691 std::vector<CallsiteInfo> PendingCallsites;

7692 std::vector<AllocInfo> PendingAllocs;

7693 std::vector<uint64_t> PendingContextIds;

7694

7695while (true) {

7696Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

7697if (!MaybeEntry)

7698return MaybeEntry.takeError();

7699BitstreamEntry Entry = MaybeEntry.get();

7700

7701switch (Entry.Kind) {

7702caseBitstreamEntry::SubBlock:// Handled for us already.

7703caseBitstreamEntry::Error:

7704returnerror("Malformed block");

7705caseBitstreamEntry::EndBlock:

7706returnError::success();

7707caseBitstreamEntry::Record:

7708// The interesting case.

7709break;

7710 }

7711

7712// Read a record. The record format depends on whether this

7713// is a per-module index or a combined index file. In the per-module

7714// case the records contain the associated value's ID for correlation

7715// with VST entries. In the combined index the correlation is done

7716// via the bitcode offset of the summary records (which were saved

7717// in the combined index VST entries). The records also contain

7718// information used for ThinLTO renaming and importing.

7719Record.clear();

7720Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID,Record);

7721if (!MaybeBitCode)

7722return MaybeBitCode.takeError();

7723switch (unsigned BitCode = MaybeBitCode.get()) {

7724default:// Default behavior: ignore.

7725break;

7726casebitc::FS_FLAGS: {// [flags]

7727 TheIndex.setFlags(Record[0]);

7728break;

7729 }

7730casebitc::FS_VALUE_GUID: {// [valueid, refguid_upper32, refguid_lower32]

7731uint64_t ValueID =Record[0];

7732GlobalValue::GUID RefGUID;

7733if (Version >= 11) {

7734 RefGUID =Record[1] << 32 |Record[2];

7735 }else {

7736 RefGUID =Record[1];

7737 }

7738 ValueIdToValueInfoMap[ValueID] =

7739 std::make_pair(TheIndex.getOrInsertValueInfo(RefGUID), RefGUID);

7740break;

7741 }

7742// FS_PERMODULE is legacy and does not have support for the tail call flag.

7743// FS_PERMODULE: [valueid, flags, instcount, fflags, numrefs,

7744// numrefs x valueid, n x (valueid)]

7745// FS_PERMODULE_PROFILE: [valueid, flags, instcount, fflags, numrefs,

7746// numrefs x valueid,

7747// n x (valueid, hotness+tailcall flags)]

7748// FS_PERMODULE_RELBF: [valueid, flags, instcount, fflags, numrefs,

7749// numrefs x valueid,

7750// n x (valueid, relblockfreq+tailcall)]

7751casebitc::FS_PERMODULE:

7752casebitc::FS_PERMODULE_RELBF:

7753casebitc::FS_PERMODULE_PROFILE: {

7754unsigned ValueID =Record[0];

7755uint64_t RawFlags =Record[1];

7756unsigned InstCount =Record[2];

7757uint64_t RawFunFlags = 0;

7758unsigned NumRefs =Record[3];

7759unsigned NumRORefs = 0, NumWORefs = 0;

7760int RefListStartIndex = 4;

7761if (Version >= 4) {

7762 RawFunFlags =Record[3];

7763 NumRefs =Record[4];

7764 RefListStartIndex = 5;

7765if (Version >= 5) {

7766 NumRORefs =Record[5];

7767 RefListStartIndex = 6;

7768if (Version >= 7) {

7769 NumWORefs =Record[6];

7770 RefListStartIndex = 7;

7771 }

7772 }

7773 }

7774

7775autoFlags =getDecodedGVSummaryFlags(RawFlags, Version);

7776// The module path string ref set in the summary must be owned by the

7777// index's module string table. Since we don't have a module path

7778// string table section in the per-module index, we create a single

7779// module path string table entry with an empty (0) ID to take

7780// ownership.

7781int CallGraphEdgeStartIndex = RefListStartIndex + NumRefs;

7782assert(Record.size() >= RefListStartIndex + NumRefs &&

7783"Record size inconsistent with number of references");

7784SmallVector<ValueInfo, 0> Refs = makeRefList(

7785ArrayRef<uint64_t>(Record).slice(RefListStartIndex, NumRefs));

7786bool HasProfile = (BitCode ==bitc::FS_PERMODULE_PROFILE);

7787bool HasRelBF = (BitCode ==bitc::FS_PERMODULE_RELBF);

7788SmallVector<FunctionSummary::EdgeTy, 0> Calls = makeCallList(

7789ArrayRef<uint64_t>(Record).slice(CallGraphEdgeStartIndex),

7790 IsOldProfileFormat, HasProfile, HasRelBF);

7791setSpecialRefs(Refs, NumRORefs, NumWORefs);

7792auto VIAndOriginalGUID = getValueInfoFromValueId(ValueID);

7793// In order to save memory, only record the memprof summaries if this is

7794// the prevailing copy of a symbol. The linker doesn't resolve local

7795// linkage values so don't check whether those are prevailing.

7796autoLT = (GlobalValue::LinkageTypes)Flags.Linkage;

7797if (IsPrevailing && !GlobalValue::isLocalLinkage(LT) &&

7798 !IsPrevailing(VIAndOriginalGUID.first.getGUID())) {

7799 PendingCallsites.clear();

7800 PendingAllocs.clear();

7801 }

7802autoFS = std::make_unique<FunctionSummary>(

7803 Flags, InstCount,getDecodedFFlags(RawFunFlags), std::move(Refs),

7804 std::move(Calls), std::move(PendingTypeTests),

7805 std::move(PendingTypeTestAssumeVCalls),

7806 std::move(PendingTypeCheckedLoadVCalls),

7807 std::move(PendingTypeTestAssumeConstVCalls),

7808 std::move(PendingTypeCheckedLoadConstVCalls),

7809 std::move(PendingParamAccesses), std::move(PendingCallsites),

7810 std::move(PendingAllocs));

7811FS->setModulePath(getThisModule()->first());

7812FS->setOriginalName(std::get<1>(VIAndOriginalGUID));

7813 TheIndex.addGlobalValueSummary(std::get<0>(VIAndOriginalGUID),

7814 std::move(FS));

7815break;

7816 }

7817// FS_ALIAS: [valueid, flags, valueid]

7818// Aliases must be emitted (and parsed) after all FS_PERMODULE entries, as

7819// they expect all aliasee summaries to be available.

7820casebitc::FS_ALIAS: {

7821unsigned ValueID =Record[0];

7822uint64_t RawFlags =Record[1];

7823unsigned AliaseeID =Record[2];

7824autoFlags =getDecodedGVSummaryFlags(RawFlags, Version);

7825auto AS = std::make_unique<AliasSummary>(Flags);

7826// The module path string ref set in the summary must be owned by the

7827// index's module string table. Since we don't have a module path

7828// string table section in the per-module index, we create a single

7829// module path string table entry with an empty (0) ID to take

7830// ownership.

7831 AS->setModulePath(getThisModule()->first());

7832

7833auto AliaseeVI = std::get<0>(getValueInfoFromValueId(AliaseeID));

7834auto AliaseeInModule = TheIndex.findSummaryInModule(AliaseeVI, ModulePath);

7835if (!AliaseeInModule)

7836returnerror("Alias expects aliasee summary to be parsed");

7837 AS->setAliasee(AliaseeVI, AliaseeInModule);

7838

7839autoGUID = getValueInfoFromValueId(ValueID);

7840 AS->setOriginalName(std::get<1>(GUID));

7841 TheIndex.addGlobalValueSummary(std::get<0>(GUID), std::move(AS));

7842break;

7843 }

7844// FS_PERMODULE_GLOBALVAR_INIT_REFS: [valueid, flags, varflags, n x valueid]

7845casebitc::FS_PERMODULE_GLOBALVAR_INIT_REFS: {

7846unsigned ValueID =Record[0];

7847uint64_t RawFlags =Record[1];

7848unsigned RefArrayStart = 2;

7849GlobalVarSummary::GVarFlags GVF(/* ReadOnly */false,

7850/* WriteOnly */false,

7851/* Constant */false,

7852GlobalObject::VCallVisibilityPublic);

7853autoFlags =getDecodedGVSummaryFlags(RawFlags, Version);

7854if (Version >= 5) {

7855 GVF =getDecodedGVarFlags(Record[2]);

7856 RefArrayStart = 3;

7857 }

7858SmallVector<ValueInfo, 0> Refs =

7859 makeRefList(ArrayRef<uint64_t>(Record).slice(RefArrayStart));

7860autoFS =

7861 std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));

7862FS->setModulePath(getThisModule()->first());

7863autoGUID = getValueInfoFromValueId(ValueID);

7864FS->setOriginalName(std::get<1>(GUID));

7865 TheIndex.addGlobalValueSummary(std::get<0>(GUID), std::move(FS));

7866break;

7867 }

7868// FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS: [valueid, flags, varflags,

7869// numrefs, numrefs x valueid,

7870// n x (valueid, offset)]

7871casebitc::FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS: {

7872unsigned ValueID =Record[0];

7873uint64_t RawFlags =Record[1];

7874GlobalVarSummary::GVarFlags GVF =getDecodedGVarFlags(Record[2]);

7875unsigned NumRefs =Record[3];

7876unsigned RefListStartIndex = 4;

7877unsigned VTableListStartIndex = RefListStartIndex + NumRefs;

7878autoFlags =getDecodedGVSummaryFlags(RawFlags, Version);

7879SmallVector<ValueInfo, 0> Refs = makeRefList(

7880ArrayRef<uint64_t>(Record).slice(RefListStartIndex, NumRefs));

7881VTableFuncList VTableFuncs;

7882for (unsignedI = VTableListStartIndex, E =Record.size();I != E; ++I) {

7883ValueInfo Callee = std::get<0>(getValueInfoFromValueId(Record[I]));

7884uint64_t Offset =Record[++I];

7885 VTableFuncs.push_back({Callee,Offset});

7886 }

7887autoVS =

7888 std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));

7889VS->setModulePath(getThisModule()->first());

7890VS->setVTableFuncs(VTableFuncs);

7891autoGUID = getValueInfoFromValueId(ValueID);

7892VS->setOriginalName(std::get<1>(GUID));

7893 TheIndex.addGlobalValueSummary(std::get<0>(GUID), std::move(VS));

7894break;

7895 }

7896// FS_COMBINED is legacy and does not have support for the tail call flag.

7897// FS_COMBINED: [valueid, modid, flags, instcount, fflags, numrefs,

7898// numrefs x valueid, n x (valueid)]

7899// FS_COMBINED_PROFILE: [valueid, modid, flags, instcount, fflags, numrefs,

7900// numrefs x valueid,

7901// n x (valueid, hotness+tailcall flags)]

7902casebitc::FS_COMBINED:

7903casebitc::FS_COMBINED_PROFILE: {

7904unsigned ValueID =Record[0];

7905uint64_t ModuleId =Record[1];

7906uint64_t RawFlags =Record[2];

7907unsigned InstCount =Record[3];

7908uint64_t RawFunFlags = 0;

7909unsigned NumRefs =Record[4];

7910unsigned NumRORefs = 0, NumWORefs = 0;

7911int RefListStartIndex = 5;

7912

7913if (Version >= 4) {

7914 RawFunFlags =Record[4];

7915 RefListStartIndex = 6;

7916size_t NumRefsIndex = 5;

7917if (Version >= 5) {

7918unsigned NumRORefsOffset = 1;

7919 RefListStartIndex = 7;

7920if (Version >= 6) {

7921 NumRefsIndex = 6;

7922 RefListStartIndex = 8;

7923if (Version >= 7) {

7924 RefListStartIndex = 9;

7925 NumWORefs =Record[8];

7926 NumRORefsOffset = 2;

7927 }

7928 }

7929 NumRORefs =Record[RefListStartIndex - NumRORefsOffset];

7930 }

7931 NumRefs =Record[NumRefsIndex];

7932 }

7933

7934autoFlags =getDecodedGVSummaryFlags(RawFlags, Version);

7935int CallGraphEdgeStartIndex = RefListStartIndex + NumRefs;

7936assert(Record.size() >= RefListStartIndex + NumRefs &&

7937"Record size inconsistent with number of references");

7938SmallVector<ValueInfo, 0> Refs = makeRefList(

7939ArrayRef<uint64_t>(Record).slice(RefListStartIndex, NumRefs));

7940bool HasProfile = (BitCode ==bitc::FS_COMBINED_PROFILE);

7941SmallVector<FunctionSummary::EdgeTy, 0> Edges = makeCallList(

7942ArrayRef<uint64_t>(Record).slice(CallGraphEdgeStartIndex),

7943 IsOldProfileFormat, HasProfile,false);

7944ValueInfo VI = std::get<0>(getValueInfoFromValueId(ValueID));

7945setSpecialRefs(Refs, NumRORefs, NumWORefs);

7946autoFS = std::make_unique<FunctionSummary>(

7947 Flags, InstCount,getDecodedFFlags(RawFunFlags), std::move(Refs),

7948 std::move(Edges), std::move(PendingTypeTests),

7949 std::move(PendingTypeTestAssumeVCalls),

7950 std::move(PendingTypeCheckedLoadVCalls),

7951 std::move(PendingTypeTestAssumeConstVCalls),

7952 std::move(PendingTypeCheckedLoadConstVCalls),

7953 std::move(PendingParamAccesses), std::move(PendingCallsites),

7954 std::move(PendingAllocs));

7955 LastSeenSummary =FS.get();

7956 LastSeenGUID =VI.getGUID();

7957FS->setModulePath(ModuleIdMap[ModuleId]);

7958 TheIndex.addGlobalValueSummary(VI, std::move(FS));

7959break;

7960 }

7961// FS_COMBINED_ALIAS: [valueid, modid, flags, valueid]

7962// Aliases must be emitted (and parsed) after all FS_COMBINED entries, as

7963// they expect all aliasee summaries to be available.

7964casebitc::FS_COMBINED_ALIAS: {

7965unsigned ValueID =Record[0];

7966uint64_t ModuleId =Record[1];

7967uint64_t RawFlags =Record[2];

7968unsigned AliaseeValueId =Record[3];

7969autoFlags =getDecodedGVSummaryFlags(RawFlags, Version);

7970auto AS = std::make_unique<AliasSummary>(Flags);

7971 LastSeenSummary = AS.get();

7972 AS->setModulePath(ModuleIdMap[ModuleId]);

7973

7974auto AliaseeVI = std::get<0>(getValueInfoFromValueId(AliaseeValueId));

7975auto AliaseeInModule = TheIndex.findSummaryInModule(AliaseeVI, AS->modulePath());

7976 AS->setAliasee(AliaseeVI, AliaseeInModule);

7977

7978ValueInfo VI = std::get<0>(getValueInfoFromValueId(ValueID));

7979 LastSeenGUID =VI.getGUID();

7980 TheIndex.addGlobalValueSummary(VI, std::move(AS));

7981break;

7982 }

7983// FS_COMBINED_GLOBALVAR_INIT_REFS: [valueid, modid, flags, n x valueid]

7984casebitc::FS_COMBINED_GLOBALVAR_INIT_REFS: {

7985unsigned ValueID =Record[0];

7986uint64_t ModuleId =Record[1];

7987uint64_t RawFlags =Record[2];

7988unsigned RefArrayStart = 3;

7989GlobalVarSummary::GVarFlags GVF(/* ReadOnly */false,

7990/* WriteOnly */false,

7991/* Constant */false,

7992GlobalObject::VCallVisibilityPublic);

7993autoFlags =getDecodedGVSummaryFlags(RawFlags, Version);

7994if (Version >= 5) {

7995 GVF =getDecodedGVarFlags(Record[3]);

7996 RefArrayStart = 4;

7997 }

7998SmallVector<ValueInfo, 0> Refs =

7999 makeRefList(ArrayRef<uint64_t>(Record).slice(RefArrayStart));

8000autoFS =

8001 std::make_unique<GlobalVarSummary>(Flags, GVF, std::move(Refs));

8002 LastSeenSummary =FS.get();

8003FS->setModulePath(ModuleIdMap[ModuleId]);

8004ValueInfo VI = std::get<0>(getValueInfoFromValueId(ValueID));

8005 LastSeenGUID =VI.getGUID();

8006 TheIndex.addGlobalValueSummary(VI, std::move(FS));

8007break;

8008 }

8009// FS_COMBINED_ORIGINAL_NAME: [original_name]

8010casebitc::FS_COMBINED_ORIGINAL_NAME: {

8011uint64_t OriginalName =Record[0];

8012if (!LastSeenSummary)

8013returnerror("Name attachment that does not follow a combined record");

8014 LastSeenSummary->setOriginalName(OriginalName);

8015 TheIndex.addOriginalName(LastSeenGUID, OriginalName);

8016// Reset the LastSeenSummary

8017 LastSeenSummary =nullptr;

8018 LastSeenGUID = 0;

8019break;

8020 }

8021casebitc::FS_TYPE_TESTS:

8022assert(PendingTypeTests.empty());

8023llvm::append_range(PendingTypeTests,Record);

8024break;

8025

8026casebitc::FS_TYPE_TEST_ASSUME_VCALLS:

8027assert(PendingTypeTestAssumeVCalls.empty());

8028for (unsignedI = 0;I !=Record.size();I += 2)

8029 PendingTypeTestAssumeVCalls.push_back({Record[I], Record[I+1]});

8030break;

8031

8032casebitc::FS_TYPE_CHECKED_LOAD_VCALLS:

8033assert(PendingTypeCheckedLoadVCalls.empty());

8034for (unsignedI = 0;I !=Record.size();I += 2)

8035 PendingTypeCheckedLoadVCalls.push_back({Record[I], Record[I+1]});

8036break;

8037

8038casebitc::FS_TYPE_TEST_ASSUME_CONST_VCALL:

8039 PendingTypeTestAssumeConstVCalls.push_back(

8040 {{Record[0],Record[1]}, {Record.begin() + 2,Record.end()}});

8041break;

8042

8043casebitc::FS_TYPE_CHECKED_LOAD_CONST_VCALL:

8044 PendingTypeCheckedLoadConstVCalls.push_back(

8045 {{Record[0],Record[1]}, {Record.begin() + 2,Record.end()}});

8046break;

8047

8048casebitc::FS_CFI_FUNCTION_DEFS: {

8049 std::set<std::string, std::less<>> &CfiFunctionDefs =

8050 TheIndex.cfiFunctionDefs();

8051for (unsignedI = 0;I !=Record.size();I += 2)

8052 CfiFunctionDefs.insert(

8053 {Strtab.data() + Record[I], static_cast<size_t>(Record[I + 1])});

8054break;

8055 }

8056

8057casebitc::FS_CFI_FUNCTION_DECLS: {

8058 std::set<std::string, std::less<>> &CfiFunctionDecls =

8059 TheIndex.cfiFunctionDecls();

8060for (unsignedI = 0;I !=Record.size();I += 2)

8061 CfiFunctionDecls.insert(

8062 {Strtab.data() + Record[I], static_cast<size_t>(Record[I + 1])});

8063break;

8064 }

8065

8066casebitc::FS_TYPE_ID:

8067parseTypeIdSummaryRecord(Record, Strtab, TheIndex);

8068break;

8069

8070casebitc::FS_TYPE_ID_METADATA:

8071 parseTypeIdCompatibleVtableSummaryRecord(Record);

8072break;

8073

8074casebitc::FS_BLOCK_COUNT:

8075 TheIndex.addBlockCount(Record[0]);

8076break;

8077

8078casebitc::FS_PARAM_ACCESS: {

8079 PendingParamAccesses = parseParamAccesses(Record);

8080break;

8081 }

8082

8083casebitc::FS_STACK_IDS: {// [n x stackid]

8084// Save stack ids in the reader to consult when adding stack ids from the

8085// lists in the stack node and alloc node entries.

8086if (Version <= 11) {

8087 StackIds =ArrayRef<uint64_t>(Record);

8088break;

8089 }

8090// This is an array of 32-bit fixed-width values, holding each 64-bit

8091// context id as a pair of adjacent (most significant first) 32-bit words.

8092assert(Record.size() % 2 == 0);

8093 StackIds.reserve(Record.size() / 2);

8094for (auto R =Record.begin(); R !=Record.end(); R += 2)

8095 StackIds.push_back(*R << 32 | *(R + 1));

8096break;

8097 }

8098

8099casebitc::FS_CONTEXT_RADIX_TREE_ARRAY: {// [n x entry]

8100 RadixArray =ArrayRef<uint64_t>(Record);

8101break;

8102 }

8103

8104casebitc::FS_PERMODULE_CALLSITE_INFO: {

8105unsigned ValueID =Record[0];

8106SmallVector<unsigned> StackIdList;

8107for (auto R =Record.begin() + 1; R !=Record.end(); R++) {

8108assert(*R < StackIds.size());

8109 StackIdList.push_back(TheIndex.addOrGetStackIdIndex(StackIds[*R]));

8110 }

8111ValueInfo VI = std::get<0>(getValueInfoFromValueId(ValueID));

8112 PendingCallsites.push_back(CallsiteInfo({VI, std::move(StackIdList)}));

8113break;

8114 }

8115

8116casebitc::FS_COMBINED_CALLSITE_INFO: {

8117auto RecordIter =Record.begin();

8118unsigned ValueID = *RecordIter++;

8119unsigned NumStackIds = *RecordIter++;

8120unsigned NumVersions = *RecordIter++;

8121assert(Record.size() == 3 + NumStackIds + NumVersions);

8122SmallVector<unsigned> StackIdList;

8123for (unsigned J = 0; J < NumStackIds; J++) {

8124assert(*RecordIter < StackIds.size());

8125 StackIdList.push_back(

8126 TheIndex.addOrGetStackIdIndex(StackIds[*RecordIter++]));

8127 }

8128SmallVector<unsigned> Versions;

8129for (unsigned J = 0; J < NumVersions; J++)

8130 Versions.push_back(*RecordIter++);

8131ValueInfo VI = std::get<0>(

8132 getValueInfoFromValueId</*AllowNullValueInfo*/ true>(ValueID));

8133 PendingCallsites.push_back(

8134CallsiteInfo({VI, std::move(Versions), std::move(StackIdList)}));

8135break;

8136 }

8137

8138casebitc::FS_ALLOC_CONTEXT_IDS: {

8139// This is an array of 32-bit fixed-width values, holding each 64-bit

8140// context id as a pair of adjacent (most significant first) 32-bit words.

8141assert(Record.size() % 2 == 0);

8142 PendingContextIds.reserve(Record.size() / 2);

8143for (auto R =Record.begin(); R !=Record.end(); R += 2)

8144 PendingContextIds.push_back(*R << 32 | *(R + 1));

8145break;

8146 }

8147

8148casebitc::FS_PERMODULE_ALLOC_INFO: {

8149unsignedI = 0;

8150 std::vector<MIBInfo> MIBs;

8151unsigned NumMIBs = 0;

8152if (Version >= 10)

8153 NumMIBs =Record[I++];

8154unsigned MIBsRead = 0;

8155while ((Version >= 10 && MIBsRead++ < NumMIBs) ||

8156 (Version < 10 &&I <Record.size())) {

8157assert(Record.size() -I >= 2);

8158AllocationType AllocType = (AllocationType)Record[I++];

8159auto StackIdList = parseAllocInfoContext(Record,I);

8160 MIBs.push_back(MIBInfo(AllocType, std::move(StackIdList)));

8161 }

8162// We either have nothing left or at least NumMIBs context size info

8163// indices left (for the total sizes included when reporting of hinted

8164// bytes is enabled).

8165assert(I ==Record.size() ||Record.size() -I >= NumMIBs);

8166 std::vector<std::vector<ContextTotalSize>> AllContextSizes;

8167if (I <Record.size()) {

8168assert(!PendingContextIds.empty() &&

8169"Missing context ids for alloc sizes");

8170unsigned ContextIdIndex = 0;

8171 MIBsRead = 0;

8172// The sizes are a linearized array of sizes, where for each MIB there

8173// is 1 or more sizes (due to context trimming, each MIB in the metadata

8174// and summarized here can correspond to more than one original context

8175// from the profile).

8176while (MIBsRead++ < NumMIBs) {

8177// First read the number of contexts recorded for this MIB.

8178unsigned NumContextSizeInfoEntries =Record[I++];

8179assert(Record.size() -I >= NumContextSizeInfoEntries);

8180 std::vector<ContextTotalSize> ContextSizes;

8181 ContextSizes.reserve(NumContextSizeInfoEntries);

8182for (unsigned J = 0; J < NumContextSizeInfoEntries; J++) {

8183assert(ContextIdIndex < PendingContextIds.size());

8184// PendingContextIds read from the preceding FS_ALLOC_CONTEXT_IDS

8185// should be in the same order as the total sizes.

8186 ContextSizes.push_back(

8187 {PendingContextIds[ContextIdIndex++],Record[I++]});

8188 }

8189 AllContextSizes.push_back(std::move(ContextSizes));

8190 }

8191 PendingContextIds.clear();

8192 }

8193 PendingAllocs.push_back(AllocInfo(std::move(MIBs)));

8194if (!AllContextSizes.empty()) {

8195assert(PendingAllocs.back().MIBs.size() == AllContextSizes.size());

8196 PendingAllocs.back().ContextSizeInfos = std::move(AllContextSizes);

8197 }

8198break;

8199 }

8200

8201casebitc::FS_COMBINED_ALLOC_INFO: {

8202unsignedI = 0;

8203 std::vector<MIBInfo> MIBs;

8204unsigned NumMIBs =Record[I++];

8205unsigned NumVersions =Record[I++];

8206unsigned MIBsRead = 0;

8207while (MIBsRead++ < NumMIBs) {

8208assert(Record.size() -I >= 2);

8209AllocationType AllocType = (AllocationType)Record[I++];

8210auto StackIdList = parseAllocInfoContext(Record,I);

8211 MIBs.push_back(MIBInfo(AllocType, std::move(StackIdList)));

8212 }

8213assert(Record.size() -I >= NumVersions);

8214SmallVector<uint8_t> Versions;

8215for (unsigned J = 0; J < NumVersions; J++)

8216 Versions.push_back(Record[I++]);

8217assert(I ==Record.size());

8218 PendingAllocs.push_back(AllocInfo(std::move(Versions), std::move(MIBs)));

8219break;

8220 }

8221 }

8222 }

8223llvm_unreachable("Exit infinite loop");

8224}

8225

8226// Parse the module string table block into the Index.

8227// This populates the ModulePathStringTable map in the index.

8228Error ModuleSummaryIndexBitcodeReader::parseModuleStringTable() {

8229if (Error Err = Stream.EnterSubBlock(bitc::MODULE_STRTAB_BLOCK_ID))

8230return Err;

8231

8232SmallVector<uint64_t, 64>Record;

8233

8234SmallString<128> ModulePath;

8235ModuleSummaryIndex::ModuleInfo *LastSeenModule =nullptr;

8236

8237while (true) {

8238Expected<BitstreamEntry> MaybeEntry = Stream.advanceSkippingSubblocks();

8239if (!MaybeEntry)

8240return MaybeEntry.takeError();

8241BitstreamEntry Entry = MaybeEntry.get();

8242

8243switch (Entry.Kind) {

8244caseBitstreamEntry::SubBlock:// Handled for us already.

8245caseBitstreamEntry::Error:

8246returnerror("Malformed block");

8247caseBitstreamEntry::EndBlock:

8248returnError::success();

8249caseBitstreamEntry::Record:

8250// The interesting case.

8251break;

8252 }

8253

8254Record.clear();

8255Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID,Record);

8256if (!MaybeRecord)

8257return MaybeRecord.takeError();

8258switch (MaybeRecord.get()) {

8259default:// Default behavior: ignore.

8260break;

8261casebitc::MST_CODE_ENTRY: {

8262// MST_ENTRY: [modid, namechar x N]

8263uint64_t ModuleId =Record[0];

8264

8265if (convertToString(Record, 1, ModulePath))

8266returnerror("Invalid record");

8267

8268 LastSeenModule = TheIndex.addModule(ModulePath);

8269 ModuleIdMap[ModuleId] = LastSeenModule->first();

8270

8271 ModulePath.clear();

8272break;

8273 }

8274 /// MST_CODE_HASH: [5*i32]

8275casebitc::MST_CODE_HASH: {

8276if (Record.size() != 5)

8277returnerror("Invalid hash length " +Twine(Record.size()).str());

8278if (!LastSeenModule)

8279returnerror("Invalid hash that does not follow a module path");

8280int Pos = 0;

8281for (auto &Val :Record) {

8282assert(!(Val >> 32) &&"Unexpected high bits set");

8283 LastSeenModule->second[Pos++] = Val;

8284 }

8285// Reset LastSeenModule to avoid overriding the hash unexpectedly.

8286 LastSeenModule =nullptr;

8287break;

8288 }

8289 }

8290 }

8291llvm_unreachable("Exit infinite loop");

8292}

8293

8294namespace{

8295

8296// FIXME: This class is only here to support the transition to llvm::Error. It

8297// will be removed once this transition is complete. Clients should prefer to

8298// deal with the Error value directly, rather than converting to error_code.

8299classBitcodeErrorCategoryType :public std::error_category {

8300constchar *name()const noexcept override{

8301return"llvm.bitcode";

8302 }

8303

8304 std::string message(int IE) const override{

8305BitcodeError E =static_cast<BitcodeError>(IE);

8306switch (E) {

8307case BitcodeError::CorruptedBitcode:

8308return"Corrupted bitcode";

8309 }

8310llvm_unreachable("Unknown error type!");

8311 }

8312};

8313

8314}// end anonymous namespace

8315

8316const std::error_category &llvm::BitcodeErrorCategory() {

8317static BitcodeErrorCategoryType ErrorCategory;

8318return ErrorCategory;

8319}

8320

8321staticExpected<StringRef>readBlobInRecord(BitstreamCursor &Stream,

8322unsignedBlock,unsigned RecordID) {

8323if (Error Err = Stream.EnterSubBlock(Block))

8324return std::move(Err);

8325

8326StringRef Strtab;

8327while (true) {

8328Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();

8329if (!MaybeEntry)

8330return MaybeEntry.takeError();

8331llvm::BitstreamEntry Entry = MaybeEntry.get();

8332

8333switch (Entry.Kind) {

8334caseBitstreamEntry::EndBlock:

8335return Strtab;

8336

8337caseBitstreamEntry::Error:

8338returnerror("Malformed block");

8339

8340caseBitstreamEntry::SubBlock:

8341if (Error Err = Stream.SkipBlock())

8342return std::move(Err);

8343break;

8344

8345caseBitstreamEntry::Record:

8346StringRef Blob;

8347SmallVector<uint64_t, 1>Record;

8348Expected<unsigned> MaybeRecord =

8349 Stream.readRecord(Entry.ID,Record, &Blob);

8350if (!MaybeRecord)

8351return MaybeRecord.takeError();

8352if (MaybeRecord.get() == RecordID)

8353 Strtab = Blob;

8354break;

8355 }

8356 }

8357}

8358

8359//===----------------------------------------------------------------------===//

8360// External interface

8361//===----------------------------------------------------------------------===//

8362

8363Expected<std::vector<BitcodeModule>>

8364llvm::getBitcodeModuleList(MemoryBufferRef Buffer) {

8365auto FOrErr =getBitcodeFileContents(Buffer);

8366if (!FOrErr)

8367return FOrErr.takeError();

8368return std::move(FOrErr->Mods);

8369}

8370

8371Expected<BitcodeFileContents>

8372llvm::getBitcodeFileContents(MemoryBufferRef Buffer) {

8373Expected<BitstreamCursor> StreamOrErr =initStream(Buffer);

8374if (!StreamOrErr)

8375return StreamOrErr.takeError();

8376BitstreamCursor &Stream = *StreamOrErr;

8377

8378BitcodeFileContents F;

8379while (true) {

8380uint64_t BCBegin = Stream.getCurrentByteNo();

8381

8382// We may be consuming bitcode from a client that leaves garbage at the end

8383// of the bitcode stream (e.g. Apple's ar tool). If we are close enough to

8384// the end that there cannot possibly be another module, stop looking.

8385if (BCBegin + 8 >= Stream.getBitcodeBytes().size())

8386returnF;

8387

8388Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();

8389if (!MaybeEntry)

8390return MaybeEntry.takeError();

8391llvm::BitstreamEntry Entry = MaybeEntry.get();

8392

8393switch (Entry.Kind) {

8394caseBitstreamEntry::EndBlock:

8395caseBitstreamEntry::Error:

8396returnerror("Malformed block");

8397

8398caseBitstreamEntry::SubBlock: {

8399uint64_t IdentificationBit = -1ull;

8400if (Entry.ID ==bitc::IDENTIFICATION_BLOCK_ID) {

8401 IdentificationBit = Stream.GetCurrentBitNo() - BCBegin * 8;

8402if (Error Err = Stream.SkipBlock())

8403return std::move(Err);

8404

8405 {

8406Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();

8407if (!MaybeEntry)

8408return MaybeEntry.takeError();

8409 Entry = MaybeEntry.get();

8410 }

8411

8412if (Entry.Kind !=BitstreamEntry::SubBlock ||

8413 Entry.ID !=bitc::MODULE_BLOCK_ID)

8414returnerror("Malformed block");

8415 }

8416

8417if (Entry.ID ==bitc::MODULE_BLOCK_ID) {

8418uint64_t ModuleBit = Stream.GetCurrentBitNo() - BCBegin * 8;

8419if (Error Err = Stream.SkipBlock())

8420return std::move(Err);

8421

8422F.Mods.push_back({Stream.getBitcodeBytes().slice(

8423 BCBegin, Stream.getCurrentByteNo() - BCBegin),

8424 Buffer.getBufferIdentifier(), IdentificationBit,

8425 ModuleBit});

8426continue;

8427 }

8428

8429if (Entry.ID ==bitc::STRTAB_BLOCK_ID) {

8430Expected<StringRef> Strtab =

8431readBlobInRecord(Stream,bitc::STRTAB_BLOCK_ID,bitc::STRTAB_BLOB);

8432if (!Strtab)

8433return Strtab.takeError();

8434// This string table is used by every preceding bitcode module that does

8435// not have its own string table. A bitcode file may have multiple

8436// string tables if it was created by binary concatenation, for example

8437// with "llvm-cat -b".

8438for (BitcodeModule &I :llvm::reverse(F.Mods)) {

8439if (!I.Strtab.empty())

8440break;

8441I.Strtab = *Strtab;

8442 }

8443// Similarly, the string table is used by every preceding symbol table;

8444// normally there will be just one unless the bitcode file was created

8445// by binary concatenation.

8446if (!F.Symtab.empty() &&F.StrtabForSymtab.empty())

8447F.StrtabForSymtab = *Strtab;

8448continue;

8449 }

8450

8451if (Entry.ID ==bitc::SYMTAB_BLOCK_ID) {

8452Expected<StringRef> SymtabOrErr =

8453readBlobInRecord(Stream,bitc::SYMTAB_BLOCK_ID,bitc::SYMTAB_BLOB);

8454if (!SymtabOrErr)

8455return SymtabOrErr.takeError();

8456

8457// We can expect the bitcode file to have multiple symbol tables if it

8458// was created by binary concatenation. In that case we silently

8459// ignore any subsequent symbol tables, which is fine because this is a

8460// low level function. The client is expected to notice that the number

8461// of modules in the symbol table does not match the number of modules

8462// in the input file and regenerate the symbol table.

8463if (F.Symtab.empty())

8464F.Symtab = *SymtabOrErr;

8465continue;

8466 }

8467

8468if (Error Err = Stream.SkipBlock())

8469return std::move(Err);

8470continue;

8471 }

8472caseBitstreamEntry::Record:

8473if (Error E = Stream.skipRecord(Entry.ID).takeError())

8474return std::move(E);

8475continue;

8476 }

8477 }

8478}

8479

8480/// Get a lazy one-at-time loading module from bitcode.

8481///

8482/// This isn't always used in a lazy context. In particular, it's also used by

8483/// \a parseModule(). If this is truly lazy, then we need to eagerly pull

8484/// in forward-referenced functions from block address references.

8485///

8486/// \param[in] MaterializeAll Set to \c true if we should materialize

8487/// everything.

8488Expected<std::unique_ptr<Module>>

8489BitcodeModule::getModuleImpl(LLVMContext &Context,bool MaterializeAll,

8490bool ShouldLazyLoadMetadata,bool IsImporting,

8491ParserCallbacks Callbacks) {

8492BitstreamCursor Stream(Buffer);

8493

8494 std::string ProducerIdentification;

8495if (IdentificationBit != -1ull) {

8496if (Error JumpFailed = Stream.JumpToBit(IdentificationBit))

8497return std::move(JumpFailed);

8498if (Error E =

8499readIdentificationBlock(Stream).moveInto(ProducerIdentification))

8500return std::move(E);

8501 }

8502

8503if (Error JumpFailed = Stream.JumpToBit(ModuleBit))

8504return std::move(JumpFailed);

8505auto *R =new BitcodeReader(std::move(Stream), Strtab, ProducerIdentification,

8506 Context);

8507

8508 std::unique_ptr<Module>M =

8509 std::make_unique<Module>(ModuleIdentifier, Context);

8510M->setMaterializer(R);

8511

8512// Delay parsing Metadata if ShouldLazyLoadMetadata is true.

8513if (Error Err =R->parseBitcodeInto(M.get(), ShouldLazyLoadMetadata,

8514 IsImporting, Callbacks))

8515return std::move(Err);

8516

8517if (MaterializeAll) {

8518// Read in the entire module, and destroy the BitcodeReader.

8519if (Error Err =M->materializeAll())

8520return std::move(Err);

8521 }else {

8522// Resolve forward references from blockaddresses.

8523if (Error Err =R->materializeForwardReferencedFunctions())

8524return std::move(Err);

8525 }

8526

8527return std::move(M);

8528}

8529

8530Expected<std::unique_ptr<Module>>

8531BitcodeModule::getLazyModule(LLVMContext &Context,bool ShouldLazyLoadMetadata,

8532bool IsImporting,ParserCallbacks Callbacks) {

8533return getModuleImpl(Context,false, ShouldLazyLoadMetadata, IsImporting,

8534 Callbacks);

8535}

8536

8537// Parse the specified bitcode buffer and merge the index into CombinedIndex.

8538// We don't use ModuleIdentifier here because the client may need to control the

8539// module path used in the combined summary (e.g. when reading summaries for

8540// regular LTO modules).

8541Error BitcodeModule::readSummary(

8542ModuleSummaryIndex &CombinedIndex,StringRef ModulePath,

8543 std::function<bool(GlobalValue::GUID)> IsPrevailing) {

8544BitstreamCursor Stream(Buffer);

8545if (Error JumpFailed = Stream.JumpToBit(ModuleBit))

8546return JumpFailed;

8547

8548 ModuleSummaryIndexBitcodeReader R(std::move(Stream), Strtab, CombinedIndex,

8549 ModulePath, IsPrevailing);

8550return R.parseModule();

8551}

8552

8553// Parse the specified bitcode buffer, returning the function info index.

8554Expected<std::unique_ptr<ModuleSummaryIndex>>BitcodeModule::getSummary() {

8555BitstreamCursor Stream(Buffer);

8556if (Error JumpFailed = Stream.JumpToBit(ModuleBit))

8557return std::move(JumpFailed);

8558

8559auto Index = std::make_unique<ModuleSummaryIndex>(/*HaveGVs=*/false);

8560 ModuleSummaryIndexBitcodeReader R(std::move(Stream), Strtab, *Index,

8561 ModuleIdentifier, 0);

8562

8563if (Error Err = R.parseModule())

8564return std::move(Err);

8565

8566return std::move(Index);

8567}

8568

8569staticExpected<std::pair<bool, bool>>

8570getEnableSplitLTOUnitAndUnifiedFlag(BitstreamCursor &Stream,

8571unsignedID,

8572BitcodeLTOInfo &LTOInfo) {

8573if (Error Err = Stream.EnterSubBlock(ID))

8574return std::move(Err);

8575SmallVector<uint64_t, 64>Record;

8576

8577while (true) {

8578BitstreamEntry Entry;

8579 std::pair<bool, bool> Result = {false,false};

8580if (Error E = Stream.advanceSkippingSubblocks().moveInto(Entry))

8581return std::move(E);

8582

8583switch (Entry.Kind) {

8584caseBitstreamEntry::SubBlock:// Handled for us already.

8585caseBitstreamEntry::Error:

8586returnerror("Malformed block");

8587caseBitstreamEntry::EndBlock: {

8588// If no flags record found, set both flags to false.

8589return Result;

8590 }

8591caseBitstreamEntry::Record:

8592// The interesting case.

8593break;

8594 }

8595

8596// Look for the FS_FLAGS record.

8597Record.clear();

8598Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID,Record);

8599if (!MaybeBitCode)

8600return MaybeBitCode.takeError();

8601switch (MaybeBitCode.get()) {

8602default:// Default behavior: ignore.

8603break;

8604casebitc::FS_FLAGS: {// [flags]

8605uint64_t Flags =Record[0];

8606// Scan flags.

8607assert(Flags <= 0x2ff &&"Unexpected bits in flag");

8608

8609bool EnableSplitLTOUnit = Flags & 0x8;

8610bool UnifiedLTO = Flags & 0x200;

8611 Result = {EnableSplitLTOUnit, UnifiedLTO};

8612

8613return Result;

8614 }

8615 }

8616 }

8617llvm_unreachable("Exit infinite loop");

8618}

8619

8620// Check if the given bitcode buffer contains a global value summary block.

8621Expected<BitcodeLTOInfo>BitcodeModule::getLTOInfo() {

8622BitstreamCursor Stream(Buffer);

8623if (Error JumpFailed = Stream.JumpToBit(ModuleBit))

8624return std::move(JumpFailed);

8625

8626if (Error Err = Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))

8627return std::move(Err);

8628

8629while (true) {

8630llvm::BitstreamEntry Entry;

8631if (Error E = Stream.advance().moveInto(Entry))

8632return std::move(E);

8633

8634switch (Entry.Kind) {

8635caseBitstreamEntry::Error:

8636returnerror("Malformed block");

8637caseBitstreamEntry::EndBlock:

8638returnBitcodeLTOInfo{/*IsThinLTO=*/false,/*HasSummary=*/false,

8639/*EnableSplitLTOUnit=*/false,/*UnifiedLTO=*/false};

8640

8641caseBitstreamEntry::SubBlock:

8642if (Entry.ID ==bitc::GLOBALVAL_SUMMARY_BLOCK_ID) {

8643BitcodeLTOInfo LTOInfo;

8644Expected<std::pair<bool, bool>> Flags =

8645getEnableSplitLTOUnitAndUnifiedFlag(Stream, Entry.ID, LTOInfo);

8646if (!Flags)

8647return Flags.takeError();

8648 std::tie(LTOInfo.EnableSplitLTOUnit, LTOInfo.UnifiedLTO) = Flags.get();

8649 LTOInfo.IsThinLTO =true;

8650 LTOInfo.HasSummary =true;

8651return LTOInfo;

8652 }

8653

8654if (Entry.ID ==bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID) {

8655BitcodeLTOInfo LTOInfo;

8656Expected<std::pair<bool, bool>> Flags =

8657getEnableSplitLTOUnitAndUnifiedFlag(Stream, Entry.ID, LTOInfo);

8658if (!Flags)

8659return Flags.takeError();

8660 std::tie(LTOInfo.EnableSplitLTOUnit, LTOInfo.UnifiedLTO) = Flags.get();

8661 LTOInfo.IsThinLTO =false;

8662 LTOInfo.HasSummary =true;

8663return LTOInfo;

8664 }

8665

8666// Ignore other sub-blocks.

8667if (Error Err = Stream.SkipBlock())

8668return std::move(Err);

8669continue;

8670

8671caseBitstreamEntry::Record:

8672if (Expected<unsigned> StreamFailed = Stream.skipRecord(Entry.ID))

8673continue;

8674else

8675return StreamFailed.takeError();

8676 }

8677 }

8678}

8679

8680staticExpected<BitcodeModule>getSingleModule(MemoryBufferRef Buffer) {

8681Expected<std::vector<BitcodeModule>> MsOrErr =getBitcodeModuleList(Buffer);

8682if (!MsOrErr)

8683return MsOrErr.takeError();

8684

8685if (MsOrErr->size() != 1)

8686returnerror("Expected a single module");

8687

8688return (*MsOrErr)[0];

8689}

8690

8691Expected<std::unique_ptr<Module>>

8692llvm::getLazyBitcodeModule(MemoryBufferRef Buffer,LLVMContext &Context,

8693bool ShouldLazyLoadMetadata,bool IsImporting,

8694ParserCallbacks Callbacks) {

8695Expected<BitcodeModule> BM =getSingleModule(Buffer);

8696if (!BM)

8697return BM.takeError();

8698

8699return BM->getLazyModule(Context, ShouldLazyLoadMetadata, IsImporting,

8700 Callbacks);

8701}

8702

8703Expected<std::unique_ptr<Module>>llvm::getOwningLazyBitcodeModule(

8704 std::unique_ptr<MemoryBuffer> &&Buffer,LLVMContext &Context,

8705bool ShouldLazyLoadMetadata,bool IsImporting,ParserCallbacks Callbacks) {

8706auto MOrErr =getLazyBitcodeModule(*Buffer, Context, ShouldLazyLoadMetadata,

8707 IsImporting, Callbacks);

8708if (MOrErr)

8709 (*MOrErr)->setOwnedMemoryBuffer(std::move(Buffer));

8710return MOrErr;

8711}

8712

8713Expected<std::unique_ptr<Module>>

8714BitcodeModule::parseModule(LLVMContext &Context,ParserCallbacks Callbacks) {

8715return getModuleImpl(Context,true,false,false, Callbacks);

8716// TODO: Restore the use-lists to the in-memory state when the bitcode was

8717// written. We must defer until the Module has been fully materialized.

8718}

8719

8720Expected<std::unique_ptr<Module>>

8721llvm::parseBitcodeFile(MemoryBufferRef Buffer,LLVMContext &Context,

8722ParserCallbacks Callbacks) {

8723Expected<BitcodeModule> BM =getSingleModule(Buffer);

8724if (!BM)

8725return BM.takeError();

8726

8727return BM->parseModule(Context, Callbacks);

8728}

8729

8730Expected<std::string>llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer) {

8731Expected<BitstreamCursor> StreamOrErr =initStream(Buffer);

8732if (!StreamOrErr)

8733return StreamOrErr.takeError();

8734

8735returnreadTriple(*StreamOrErr);

8736}

8737

8738Expected<bool>llvm::isBitcodeContainingObjCCategory(MemoryBufferRef Buffer) {

8739Expected<BitstreamCursor> StreamOrErr =initStream(Buffer);

8740if (!StreamOrErr)

8741return StreamOrErr.takeError();

8742

8743returnhasObjCCategory(*StreamOrErr);

8744}

8745

8746Expected<std::string>llvm::getBitcodeProducerString(MemoryBufferRef Buffer) {

8747Expected<BitstreamCursor> StreamOrErr =initStream(Buffer);

8748if (!StreamOrErr)

8749return StreamOrErr.takeError();

8750

8751returnreadIdentificationCode(*StreamOrErr);

8752}

8753

8754Error llvm::readModuleSummaryIndex(MemoryBufferRef Buffer,

8755ModuleSummaryIndex &CombinedIndex) {

8756Expected<BitcodeModule> BM =getSingleModule(Buffer);

8757if (!BM)

8758return BM.takeError();

8759

8760return BM->readSummary(CombinedIndex, BM->getModuleIdentifier());

8761}

8762

8763Expected<std::unique_ptr<ModuleSummaryIndex>>

8764llvm::getModuleSummaryIndex(MemoryBufferRef Buffer) {

8765Expected<BitcodeModule> BM =getSingleModule(Buffer);

8766if (!BM)

8767return BM.takeError();

8768

8769return BM->getSummary();

8770}

8771

8772Expected<BitcodeLTOInfo>llvm::getBitcodeLTOInfo(MemoryBufferRef Buffer) {

8773Expected<BitcodeModule> BM =getSingleModule(Buffer);

8774if (!BM)

8775return BM.takeError();

8776

8777return BM->getLTOInfo();

8778}

8779

8780Expected<std::unique_ptr<ModuleSummaryIndex>>

8781llvm::getModuleSummaryIndexForFile(StringRef Path,

8782bool IgnoreEmptyThinLTOIndexFile) {

8783ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =

8784MemoryBuffer::getFileOrSTDIN(Path);

8785if (!FileOrErr)

8786returnerrorCodeToError(FileOrErr.getError());

8787if (IgnoreEmptyThinLTOIndexFile && !(*FileOrErr)->getBufferSize())

8788returnnullptr;

8789returngetModuleSummaryIndex(**FileOrErr);

8790}

const

aarch64 promote const

Definition:AArch64PromoteConstant.cpp:230

isConstant

static bool isConstant(const MachineInstr &MI)

Definition:AMDGPUInstructionSelector.cpp:2862

APFloat.h

This file declares a class to represent arbitrary precision floating point values and provide a varie...

APInt.h

This file implements a class to represent arbitrary precision integral constant values and operations...

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

Definition:ARMSLSHardening.cpp:73

ArrayRef.h

instructions

Expand Atomic instructions

Definition:AtomicExpandPass.cpp:172

AtomicOrdering.h

Atomic ordering constants.

AttributeMask.h

Attributes.h

This file contains the simple types necessary to represent the attributes associated with functions a...

AutoUpgrade.h

BitcodeCommon.h

getDecodedRelBFCallEdgeInfo

static void getDecodedRelBFCallEdgeInfo(uint64_t RawFlags, uint64_t &RelBF, bool &HasTailCall)

Definition:BitcodeReader.cpp:1209

upgradeDLLImportExportLinkage

static void upgradeDLLImportExportLinkage(GlobalValue *GV, unsigned Val)

Definition:BitcodeReader.cpp:1431

PrintSummaryGUIDs

static cl::opt< bool > PrintSummaryGUIDs("print-summary-global-ids", cl::init(false), cl::Hidden, cl::desc("Print the global id for each value when reading the module summary"))

getDecodedOrdering

static AtomicOrdering getDecodedOrdering(unsigned Val)

Definition:BitcodeReader.cpp:1381

getDecodedHotnessCallEdgeInfo

static std::pair< CalleeInfo::HotnessType, bool > getDecodedHotnessCallEdgeInfo(uint64_t RawFlags)

Definition:BitcodeReader.cpp:1202

getDecodedFFlags

static FunctionSummary::FFlags getDecodedFFlags(uint64_t RawFlags)

Definition:BitcodeReader.cpp:1153

getDecodedCodeModel

static std::optional< CodeModel::Model > getDecodedCodeModel(unsigned Val)

Definition:BitcodeReader.cpp:1244

setSpecialRefs

static void setSpecialRefs(SmallVectorImpl< ValueInfo > &Refs, unsigned ROCnt, unsigned WOCnt)

Definition:BitcodeReader.cpp:7633

PreserveInputDbgFormat

cl::opt< cl::boolOrDefault > PreserveInputDbgFormat

getDecodedDSOLocal

static bool getDecodedDSOLocal(unsigned Val)

Definition:BitcodeReader.cpp:1236

convertToString

static bool convertToString(ArrayRef< uint64_t > Record, unsigned Idx, StrTy &Result)

Convert a string from a record into an std::string, return true on failure.

Definition:BitcodeReader.cpp:174

getDecodedUnnamedAddrType

static GlobalVariable::UnnamedAddr getDecodedUnnamedAddrType(unsigned Val)

Definition:BitcodeReader.cpp:1272

stripTBAA

static void stripTBAA(Module *M)

Definition:BitcodeReader.cpp:184

getEnableSplitLTOUnitAndUnifiedFlag

static Expected< std::pair< bool, bool > > getEnableSplitLTOUnitAndUnifiedFlag(BitstreamCursor &Stream, unsigned ID, BitcodeLTOInfo &LTOInfo)

Definition:BitcodeReader.cpp:8570

getDecodedUnaryOpcode

static int getDecodedUnaryOpcode(unsigned Val, Type *Ty)

Definition:BitcodeReader.cpp:1300

readTriple

static Expected< std::string > readTriple(BitstreamCursor &Stream)

Definition:BitcodeReader.cpp:399

parseWholeProgramDevirtResolutionByArg

static void parseWholeProgramDevirtResolutionByArg(ArrayRef< uint64_t > Record, size_t &Slot, WholeProgramDevirtResolution &Wpd)

Definition:BitcodeReader.cpp:7486

getRawAttributeMask

static uint64_t getRawAttributeMask(Attribute::AttrKind Val)

Definition:BitcodeReader.cpp:1843

getDecodedGVSummaryFlags

static GlobalValueSummary::GVFlags getDecodedGVSummaryFlags(uint64_t RawFlags, uint64_t Version)

Definition:BitcodeReader.cpp:1172

getDecodedGVarFlags

static GlobalVarSummary::GVarFlags getDecodedGVarFlags(uint64_t RawFlags)

Definition:BitcodeReader.cpp:1194

getAttrFromCode

static Attribute::AttrKind getAttrFromCode(uint64_t Code)

Definition:BitcodeReader.cpp:2055

jumpToValueSymbolTable

static Expected< uint64_t > jumpToValueSymbolTable(uint64_t Offset, BitstreamCursor &Stream)

Helper to note and return the current location, and jump to the given offset.

Definition:BitcodeReader.cpp:2905

hasObjCCategoryInModule

static Expected< bool > hasObjCCategoryInModule(BitstreamCursor &Stream)

Definition:BitcodeReader.cpp:275

getDecodedDLLStorageClass

static GlobalValue::DLLStorageClassTypes getDecodedDLLStorageClass(unsigned Val)

Definition:BitcodeReader.cpp:1227

toGEPNoWrapFlags

static GEPNoWrapFlags toGEPNoWrapFlags(uint64_t Flags)

Definition:BitcodeReader.cpp:1500

decodeLLVMAttributesForBitcode

static void decodeLLVMAttributesForBitcode(AttrBuilder &B, uint64_t EncodedAttrs, uint64_t AttrIdx)

This fills an AttrBuilder object with the LLVM attributes that have been decoded from the given integ...

Definition:BitcodeReader.cpp:1942

WriteNewDbgInfoFormat

cl::opt< bool > WriteNewDbgInfoFormat

parseTypeIdSummaryRecord

static void parseTypeIdSummaryRecord(ArrayRef< uint64_t > Record, StringRef Strtab, ModuleSummaryIndex &TheIndex)

Definition:BitcodeReader.cpp:7516

LoadBitcodeIntoNewDbgInfoFormat

cl::opt< cl::boolOrDefault > LoadBitcodeIntoNewDbgInfoFormat("load-bitcode-into-experimental-debuginfo-iterators", cl::Hidden, cl::desc("Load bitcode directly into the new debug info format (regardless " "of input format)"))

Load bitcode directly into RemoveDIs format (use debug records instead of debug intrinsics).

addRawAttributeValue

static void addRawAttributeValue(AttrBuilder &B, uint64_t Val)

Definition:BitcodeReader.cpp:1921

WriteNewDbgInfoFormatToBitcode

bool WriteNewDbgInfoFormatToBitcode

Definition:BasicBlock.cpp:47

getDecodedComdatSelectionKind

static Comdat::SelectionKind getDecodedComdatSelectionKind(unsigned Val)

Definition:BitcodeReader.cpp:1394

hasImplicitComdat

static bool hasImplicitComdat(size_t Val)

Definition:BitcodeReader.cpp:1099

getDecodedLinkage

static GlobalValue::LinkageTypes getDecodedLinkage(unsigned Val)

Definition:BitcodeReader.cpp:1111

hasInvalidBitcodeHeader

static Error hasInvalidBitcodeHeader(BitstreamCursor &Stream)

Definition:BitcodeReader.cpp:131

readIdentificationCode

static Expected< std::string > readIdentificationCode(BitstreamCursor &Stream)

Definition:BitcodeReader.cpp:243

getDecodedBinaryOpcode

static int getDecodedBinaryOpcode(unsigned Val, Type *Ty)

Definition:BitcodeReader.cpp:1314

getDecodedRMWOperation

static AtomicRMWInst::BinOp getDecodedRMWOperation(unsigned Val)

Definition:BitcodeReader.cpp:1352

getSingleModule

static Expected< BitcodeModule > getSingleModule(MemoryBufferRef Buffer)

Definition:BitcodeReader.cpp:8680

hasObjCCategory

static Expected< bool > hasObjCCategory(BitstreamCursor &Stream)

Definition:BitcodeReader.cpp:323

getDecodedThreadLocalMode

static GlobalVariable::ThreadLocalMode getDecodedThreadLocalMode(unsigned Val)

Definition:BitcodeReader.cpp:1261

parseWholeProgramDevirtResolution

static void parseWholeProgramDevirtResolution(ArrayRef< uint64_t > Record, StringRef Strtab, size_t &Slot, TypeIdSummary &TypeId)

Definition:BitcodeReader.cpp:7500

inferDSOLocal

static void inferDSOLocal(GlobalValue *GV)

Definition:BitcodeReader.cpp:4051

getDecodedFastMathFlags

static FastMathFlags getDecodedFastMathFlags(unsigned Val)

Definition:BitcodeReader.cpp:1410

deserializeSanitizerMetadata

GlobalValue::SanitizerMetadata deserializeSanitizerMetadata(unsigned V)

Definition:BitcodeReader.cpp:4058

initStream

static Expected< BitstreamCursor > initStream(MemoryBufferRef Buffer)

Definition:BitcodeReader.cpp:152

ExpandConstantExprs

static cl::opt< bool > ExpandConstantExprs("expand-constant-exprs", cl::Hidden, cl::desc("Expand constant expressions to instructions for testing purposes"))

upgradeOldMemoryAttribute

static bool upgradeOldMemoryAttribute(MemoryEffects &ME, uint64_t EncodedKind)

Definition:BitcodeReader.cpp:2275

readBlobInRecord

static Expected< StringRef > readBlobInRecord(BitstreamCursor &Stream, unsigned Block, unsigned RecordID)

Definition:BitcodeReader.cpp:8321

readIdentificationBlock

static Expected< std::string > readIdentificationBlock(BitstreamCursor &Stream)

Read the "IDENTIFICATION_BLOCK_ID" block, do some basic enforcement on the "epoch" encoded in the bit...

Definition:BitcodeReader.cpp:195

isConstExprSupported

static bool isConstExprSupported(const BitcodeConstant *BC)

Definition:BitcodeReader.cpp:1511

getDecodedCastOpcode

static int getDecodedCastOpcode(unsigned Val)

Definition:BitcodeReader.cpp:1281

UseNewDbgInfoFormat

cl::opt< bool > UseNewDbgInfoFormat

readModuleTriple

static Expected< std::string > readModuleTriple(BitstreamCursor &Stream)

Definition:BitcodeReader.cpp:354

getDecodedVisibility

static GlobalValue::VisibilityTypes getDecodedVisibility(unsigned Val)

Definition:BitcodeReader.cpp:1217

BitcodeReader.h

BitstreamReader.h

From

BlockVerifier::State From

Definition:BlockVerifier.cpp:57

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

Info

Analysis containing CSE Info

Definition:CSEInfo.cpp:27

This file contains the declarations for the subclasses of Constant, which represent the different fla...

getOpcodeName

static StringRef getOpcodeName(uint8_t Opcode, uint8_t OpcodeBase)

Definition:DWARFDebugLine.cpp:627

DataLayout.h

Idx

Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx

Definition:DeadArgumentElimination.cpp:353

Live

Looks at all the uses of the given value Returns the Liveness deduced from the uses of this value Adds all uses that cause the result to be MaybeLive to MaybeLiveRetUses If the result is Live

Definition:DeadArgumentElimination.cpp:472

This file defines the DenseMap class.

DerivedTypes.h

Default

@ Default

Definition:DwarfDebug.cpp:87

Addr

uint64_t Addr

Definition:ELFObjHandler.cpp:79

Name

std::string Name

Definition:ELFObjHandler.cpp:77

Size

uint64_t Size

Definition:ELFObjHandler.cpp:81

End

bool End

Definition:ELF_riscv.cpp:480

ErrorOr.h

Provides ErrorOr<T> smart pointer.

GVMaterializer.h

GetElementPtrTypeIterator.h

GlobalAlias.h

GlobalIFunc.h

This file contains the declaration of the GlobalIFunc class, which represents a single indirect funct...

HashFunctionMode::Local

@ Local

Hexagon Common GEP

Definition:HexagonCommonGEP.cpp:170

Module.h This file contains the declarations for the Module class.

#define F(x, y, z)

Definition:MD5.cpp:55

#define I(x, y, z)

Definition:MD5.cpp:58

MathExtras.h

MemoryBuffer.h

AllocType

Definition:MemoryBuiltins.cpp:59

MetadataLoader.h

Metadata.h

This file contains the declarations for metadata subclasses.

InRange

static bool InRange(int64_t Value, unsigned short Shift, int LBound, int HBound)

Definition:MicroMipsSizeReduction.cpp:327

ModRef.h

ModuleSummaryIndex.h

ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...

Range

ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))

High

uint64_t High

Definition:NVVMIntrRange.cpp:51

Operation

PowerPC Reduce CR logical Operation

Definition:PPCReduceCRLogicals.cpp:735

if(PassOpts->AAPipeline)

Definition:PassBuilderBindings.cpp:64

ProfDataUtils.h

This file contains the declarations for profiling metadata utility functions.

Cond

const SmallVectorImpl< MachineOperand > & Cond

Definition:RISCVRedundantCopyElimination.cpp:75

auto CC

Definition:RISCVRedundantCopyElimination.cpp:79

assert

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

name

static const char * name

Definition:SMEABIPass.cpp:46

Address

@ Address

Definition:SPIRVEmitNonSemanticDI.cpp:68

STLExtras.h

This file contains some templates that are useful if you are working with the STL at all.

decodeSignRotatedValue

static uint64_t decodeSignRotatedValue(uint64_t V)

Decode a signed value stored with the sign bit in the LSB for dense VBR encoding.

Definition:SelectionDAGISel.cpp:2960

SmallString.h

This file defines the SmallString class.

SmallVector.h

This file defines the SmallVector class.

StringRef.h

error

#define error(X)

Definition:SymbolRecordMapping.cpp:14

Ptr

@ Ptr

Definition:TargetLibraryInfo.cpp:77

Value * RHS

Definition:X86PartialReduction.cpp:74

LHS

Value * LHS

Definition:X86PartialReduction.cpp:73

BaseType

FunctionType

Definition:ItaniumDemangle.h:823

PointerType

Definition:ItaniumDemangle.h:627

VectorType

Definition:ItaniumDemangle.h:1173

bool

llvm::APFloat

Definition:APFloat.h:904

llvm::APInt

Class for arbitrary precision integers.

Definition:APInt.h:78

llvm::AllocaInst

an instruction to allocate memory on the stack

Definition:Instructions.h:63

llvm::AllocaInst::setSwiftError

void setSwiftError(bool V)

Specify whether this alloca is used to represent a swifterror.

Definition:Instructions.h:151

llvm::AllocaInst::getType

PointerType * getType() const

Overload to return most specific pointer type.

Definition:Instructions.h:99

llvm::AllocaInst::setUsedWithInAlloca

void setUsedWithInAlloca(bool V)

Specify whether this alloca is used to represent the arguments to a call.

Definition:Instructions.h:144

llvm::Argument

This class represents an incoming formal argument to a Function.

Definition:Argument.h:31

llvm::ArrayRef

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

Definition:ArrayRef.h:41

llvm::ArrayRef::end

iterator end() const

Definition:ArrayRef.h:157

llvm::ArrayRef::size

size_t size() const

size - Get the array size.

Definition:ArrayRef.h:168

llvm::ArrayRef::begin

iterator begin() const

Definition:ArrayRef.h:156

llvm::ArrayRef::empty

bool empty() const

empty - Check if the array is empty.

Definition:ArrayRef.h:163

llvm::AtomicCmpXchgInst

An instruction that atomically checks whether a specified value is in a memory location,...

Definition:Instructions.h:501

llvm::AtomicCmpXchgInst::isValidFailureOrdering

static bool isValidFailureOrdering(AtomicOrdering Ordering)

Definition:Instructions.h:574

llvm::AtomicCmpXchgInst::getStrongestFailureOrdering

static AtomicOrdering getStrongestFailureOrdering(AtomicOrdering SuccessOrdering)

Returns the strongest permitted ordering on failure, given the desired ordering on success.

Definition:Instructions.h:652

llvm::AtomicCmpXchgInst::isValidSuccessOrdering

static bool isValidSuccessOrdering(AtomicOrdering Ordering)

Definition:Instructions.h:569

llvm::AtomicRMWInst

an instruction that atomically reads a memory location, combines it with another value,...

Definition:Instructions.h:704

llvm::AtomicRMWInst::BinOp

BinOp

This enumeration lists the possible modifications atomicrmw can make.

Definition:Instructions.h:716

llvm::AtomicRMWInst::Add

@ Add

*p = old + v

Definition:Instructions.h:720

llvm::AtomicRMWInst::FAdd

@ FAdd

*p = old + v

Definition:Instructions.h:741

llvm::AtomicRMWInst::USubCond

@ USubCond

Subtract only if no unsigned overflow.

Definition:Instructions.h:764

llvm::AtomicRMWInst::Min

@ Min

*p = old <signed v ? old : v

Definition:Instructions.h:734

llvm::AtomicRMWInst::BAD_BINOP

@ BAD_BINOP

Definition:Instructions.h:772

llvm::AtomicRMWInst::LAST_BINOP

@ LAST_BINOP

Definition:Instructions.h:771

llvm::AtomicRMWInst::Or

@ Or

*p = old | v

Definition:Instructions.h:728

llvm::AtomicRMWInst::Sub

@ Sub

*p = old - v

Definition:Instructions.h:722

llvm::AtomicRMWInst::And

@ And

*p = old & v

Definition:Instructions.h:724

llvm::AtomicRMWInst::Xor

@ Xor

*p = old ^ v

Definition:Instructions.h:730

llvm::AtomicRMWInst::USubSat

@ USubSat

*p = usub.sat(old, v) usub.sat matches the behavior of llvm.usub.sat.

Definition:Instructions.h:768

llvm::AtomicRMWInst::FSub

@ FSub

*p = old - v

Definition:Instructions.h:744

llvm::AtomicRMWInst::UIncWrap

@ UIncWrap

Increment one up to a maximum value.

Definition:Instructions.h:756

llvm::AtomicRMWInst::Max

@ Max

*p = old >signed v ? old : v

Definition:Instructions.h:732

llvm::AtomicRMWInst::UMin

@ UMin

*p = old <unsigned v ? old : v

Definition:Instructions.h:738

llvm::AtomicRMWInst::FMin

@ FMin

*p = minnum(old, v) minnum matches the behavior of llvm.minnum.

Definition:Instructions.h:752

llvm::AtomicRMWInst::UMax

@ UMax

*p = old >unsigned v ? old : v

Definition:Instructions.h:736

llvm::AtomicRMWInst::FMax

@ FMax

*p = maxnum(old, v) maxnum matches the behavior of llvm.maxnum.

Definition:Instructions.h:748

llvm::AtomicRMWInst::UDecWrap

@ UDecWrap

Decrement one until a minimum value or zero.

Definition:Instructions.h:760

llvm::AtomicRMWInst::FIRST_BINOP

@ FIRST_BINOP

Definition:Instructions.h:770

llvm::AtomicRMWInst::Xchg

@ Xchg

*p = v

Definition:Instructions.h:718

llvm::AtomicRMWInst::Nand

@ Nand

*p = ~(old & v)

Definition:Instructions.h:726

llvm::AttrBuilder

Definition:Attributes.h:1064

llvm::AttributeList

Definition:Attributes.h:490

llvm::AttributeList::getFnAttrs

AttributeSet getFnAttrs() const

The function attributes are returned.

Definition:Attributes.cpp:1860

llvm::AttributeList::get

static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute > > Attrs)

Create an AttributeList with the specified parameters in it.

Definition:Attributes.cpp:1499

llvm::AttributeList::FunctionIndex

@ FunctionIndex

Definition:Attributes.h:494

llvm::Attribute

Definition:Attributes.h:67

llvm::Attribute::getWithStructRetType

static Attribute getWithStructRetType(LLVMContext &Context, Type *Ty)

Definition:Attributes.cpp:260

llvm::Attribute::get

static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)

Return a uniquified Attribute object.

Definition:Attributes.cpp:95

llvm::Attribute::isTypeAttrKind

static bool isTypeAttrKind(AttrKind Kind)

Definition:Attributes.h:105

llvm::Attribute::AttrKind

AttrKind

This enumeration lists the attributes that can be associated with parameters, function results,...

Definition:Attributes.h:86

llvm::Attribute::TombstoneKey

@ TombstoneKey

Use as Tombstone key for DenseMap of AttrKind.

Definition:Attributes.h:93

llvm::Attribute::None

@ None

No attributes have been set.

Definition:Attributes.h:88

llvm::Attribute::EmptyKey

@ EmptyKey

Use as Empty key for DenseMap of AttrKind.

Definition:Attributes.h:92

llvm::Attribute::EndAttrKinds

@ EndAttrKinds

Sentinel value useful for loops.

Definition:Attributes.h:91

llvm::Attribute::isConstantRangeAttrKind

static bool isConstantRangeAttrKind(AttrKind Kind)

Definition:Attributes.h:108

llvm::Attribute::getWithInAllocaType

static Attribute getWithInAllocaType(LLVMContext &Context, Type *Ty)

Definition:Attributes.cpp:272

llvm::Attribute::isIntAttrKind

static bool isIntAttrKind(AttrKind Kind)

Definition:Attributes.h:102

llvm::Attribute::isConstantRangeListAttrKind

static bool isConstantRangeListAttrKind(AttrKind Kind)

Definition:Attributes.h:111

llvm::Attribute::getWithByValType

static Attribute getWithByValType(LLVMContext &Context, Type *Ty)

Definition:Attributes.cpp:256

llvm::Attribute::isEnumAttrKind

static bool isEnumAttrKind(AttrKind Kind)

Definition:Attributes.h:99

llvm::BasicBlock

LLVM Basic Block Representation.

Definition:BasicBlock.h:61

llvm::BasicBlock::end

iterator end()

Definition:BasicBlock.h:474

llvm::BasicBlock::empty

bool empty() const

Definition:BasicBlock.h:483

llvm::BasicBlock::Create

static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)

Creates a new BasicBlock.

Definition:BasicBlock.h:213

llvm::BasicBlock::replacePhiUsesWith

void replacePhiUsesWith(BasicBlock *Old, BasicBlock *New)

Update all phi nodes in this basic block to refer to basic block New instead of basic block Old.

Definition:BasicBlock.cpp:673

llvm::BasicBlock::eraseFromParent

SymbolTableList< BasicBlock >::iterator eraseFromParent()

Unlink 'this' from the containing function and delete it.

Definition:BasicBlock.cpp:279

llvm::BasicBlock::moveBefore

void moveBefore(BasicBlock *MovePos)

Unlink this basic block from its current function and insert it into the function that MovePos lives ...

Definition:BasicBlock.h:389

llvm::BasicBlock::back

const Instruction & back() const

Definition:BasicBlock.h:486

llvm::BinaryOperator::Create

static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), InsertPosition InsertBefore=nullptr)

Construct a binary instruction, given the opcode and the two operands.

Definition:Instructions.cpp:2639

llvm::BitcodeModule

Represents a module in a bitcode file.

Definition:BitcodeReader.h:101

llvm::BitcodeModule::getSummary

Expected< std::unique_ptr< ModuleSummaryIndex > > getSummary()

Parse the specified bitcode buffer, returning the module summary index.

Definition:BitcodeReader.cpp:8554

llvm::BitcodeModule::getLTOInfo

Expected< BitcodeLTOInfo > getLTOInfo()

Returns information about the module to be used for LTO: whether to compile with ThinLTO,...

Definition:BitcodeReader.cpp:8621

llvm::BitcodeModule::readSummary

Error readSummary(ModuleSummaryIndex &CombinedIndex, StringRef ModulePath, std::function< bool(GlobalValue::GUID)> IsPrevailing=nullptr)

Parse the specified bitcode buffer and merge its module summary index into CombinedIndex.

Definition:BitcodeReader.cpp:8541

llvm::BitcodeModule::parseModule

Expected< std::unique_ptr< Module > > parseModule(LLVMContext &Context, ParserCallbacks Callbacks={})

Read the entire bitcode module and return it.

Definition:BitcodeReader.cpp:8714

llvm::BitcodeModule::getLazyModule

Expected< std::unique_ptr< Module > > getLazyModule(LLVMContext &Context, bool ShouldLazyLoadMetadata, bool IsImporting, ParserCallbacks Callbacks={})

Read the bitcode module and prepare for lazy deserialization of function bodies.

Definition:BitcodeReader.cpp:8531

llvm::BitcodeReaderValueList

Definition:ValueList.h:28

llvm::BitcodeReaderValueList::getValueFwdRef

Value * getValueFwdRef(unsigned Idx, Type *Ty, unsigned TyID, BasicBlock *ConstExprInsertBB)

Definition:ValueList.cpp:54

llvm::BitcodeReaderValueList::push_back

void push_back(Value *V, unsigned TypeID)

Definition:ValueList.h:52

llvm::BitcodeReaderValueList::back

Value * back() const

Definition:ValueList.h:70

llvm::BitcodeReaderValueList::replaceValueWithoutRAUW

void replaceValueWithoutRAUW(unsigned ValNo, Value *NewV)

Definition:ValueList.h:81

llvm::BitcodeReaderValueList::assignValue

Error assignValue(unsigned Idx, Value *V, unsigned TypeID)

Definition:ValueList.cpp:25

llvm::BitcodeReaderValueList::shrinkTo

void shrinkTo(unsigned N)

Definition:ValueList.h:76

llvm::BitcodeReaderValueList::getTypeID

unsigned getTypeID(unsigned ValNo) const

Definition:ValueList.h:65

llvm::BitcodeReaderValueList::size

unsigned size() const

Definition:ValueList.h:48

llvm::BitstreamBlockInfo

This class maintains the abbreviations read from a block info block.

Definition:BitstreamReader.h:37

llvm::BitstreamCursor

This represents a position within a bitcode file, implemented on top of a SimpleBitstreamCursor.

Definition:BitstreamReader.h:357

llvm::BitstreamCursor::JumpToBit

Error JumpToBit(uint64_t BitNo)

Reset the stream to the specified bit number.

Definition:BitstreamReader.h:127

llvm::BitstreamCursor::AtEndOfStream

bool AtEndOfStream()

Definition:BitstreamReader.h:112

llvm::BitstreamCursor::GetCurrentBitNo

uint64_t GetCurrentBitNo() const

Return the bit # of the bit we are reading.

Definition:BitstreamReader.h:117

llvm::BitstreamCursor::getBitcodeBytes

ArrayRef< uint8_t > getBitcodeBytes() const

Definition:BitstreamReader.h:124

llvm::BitstreamCursor::Read

Expected< word_t > Read(unsigned NumBits)

Definition:BitstreamReader.h:185

llvm::BitstreamCursor::advance

Expected< BitstreamEntry > advance(unsigned Flags=0)

Advance the current bitstream, returning the next entry in the stream.

Definition:BitstreamReader.h:417

llvm::BitstreamCursor::advanceSkippingSubblocks

Expected< BitstreamEntry > advanceSkippingSubblocks(unsigned Flags=0)

This is a convenience function for clients that don't expect any subblocks.

Definition:BitstreamReader.h:456

llvm::BitstreamCursor::setBlockInfo

void setBlockInfo(BitstreamBlockInfo *BI)

Set the block info to be used by this BitstreamCursor to interpret abbreviated records.

Definition:BitstreamReader.h:572

llvm::BitstreamCursor::readRecord

Expected< unsigned > readRecord(unsigned AbbrevID, SmallVectorImpl< uint64_t > &Vals, StringRef *Blob=nullptr)

Definition:BitstreamReader.cpp:214

llvm::BitstreamCursor::EnterSubBlock

Error EnterSubBlock(unsigned BlockID, unsigned *NumWordsP=nullptr)

Having read the ENTER_SUBBLOCK abbrevid, and enter the block.

Definition:BitstreamReader.cpp:26

llvm::BitstreamCursor::SkipBlock

Error SkipBlock()

Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip over the body of this block.

Definition:BitstreamReader.h:483

llvm::BitstreamCursor::skipRecord

Expected< unsigned > skipRecord(unsigned AbbrevID)

Read the current record and discard it, returning the code for the record.

Definition:BitstreamReader.cpp:96

llvm::BitstreamCursor::getCurrentByteNo

uint64_t getCurrentByteNo() const

Definition:BitstreamReader.h:122

llvm::BitstreamCursor::canSkipToPos

bool canSkipToPos(size_t pos) const

Definition:BitstreamReader.h:107

llvm::BlockAddress::get

static BlockAddress * get(Function *F, BasicBlock *BB)

Return a BlockAddress for the specified function and basic block.

Definition:Constants.cpp:1897

llvm::BranchInst

Conditional or Unconditional Branch instruction.

Definition:Instructions.h:3016

llvm::BranchInst::Create

static BranchInst * Create(BasicBlock *IfTrue, InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:3072

llvm::BumpPtrAllocatorImpl

Allocate memory in an ever growing pool, as if by bump-pointer.

Definition:Allocator.h:66

llvm::CallBase

Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...

Definition:InstrTypes.h:1112

llvm::CallBase::isInlineAsm

bool isInlineAsm() const

Check if this call is an inline asm statement.

Definition:InstrTypes.h:1408

llvm::CallBase::getCalledOperand

Value * getCalledOperand() const

Definition:InstrTypes.h:1334

llvm::CallBase::setAttributes

void setAttributes(AttributeList A)

Set the attributes for this call.

Definition:InstrTypes.h:1420

llvm::CallBase::getIntrinsicID

Intrinsic::ID getIntrinsicID() const

Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...

Definition:Instructions.cpp:356

llvm::CallBase::arg_size

unsigned arg_size() const

Definition:InstrTypes.h:1284

llvm::CallBase::getAttributes

AttributeList getAttributes() const

Return the attributes for this call.

Definition:InstrTypes.h:1417

llvm::CallBrInst::Create

static CallBrInst * Create(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest, ArrayRef< BasicBlock * > IndirectDests, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:3864

llvm::CallInst

This class represents a function call, abstracting a target machine's calling convention.

Definition:Instructions.h:1479

llvm::CallInst::Create

static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:1514

llvm::CallInst::TailCallKind

TailCallKind

Definition:Instructions.h:1572

llvm::CallInst::TCK_None

@ TCK_None

Definition:Instructions.h:1573

llvm::CallInst::TCK_MustTail

@ TCK_MustTail

Definition:Instructions.h:1575

llvm::CallInst::TCK_Tail

@ TCK_Tail

Definition:Instructions.h:1574

llvm::CallInst::TCK_NoTail

@ TCK_NoTail

Definition:Instructions.h:1576

llvm::CaptureInfo::createFromIntValue

static CaptureInfo createFromIntValue(uint32_t Data)

Definition:ModRef.h:363

llvm::CastInst::Create

static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", InsertPosition InsertBefore=nullptr)

Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...

Definition:Instructions.cpp:2972

llvm::CastInst::castIsValid

static bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy)

This method can be used to determine if a cast from SrcTy to DstTy using Opcode op is valid or not.

Definition:Instructions.cpp:3241

llvm::CatchPadInst::Create

static CatchPadInst * Create(Value *CatchSwitch, ArrayRef< Value * > Args, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:4259

llvm::CatchReturnInst::Create

static CatchReturnInst * Create(Value *CatchPad, BasicBlock *BB, InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:4304

llvm::CatchSwitchInst::Create

static CatchSwitchInst * Create(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumHandlers, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:4093

llvm::CleanupPadInst::Create

static CleanupPadInst * Create(Value *ParentPad, ArrayRef< Value * > Args={}, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:4230

llvm::CleanupReturnInst::Create

static CleanupReturnInst * Create(Value *CleanupPad, BasicBlock *UnwindBB=nullptr, InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:4381

llvm::CmpInst::Predicate

Predicate

This enumeration lists the possible predicates for CmpInst subclasses.

Definition:InstrTypes.h:673

llvm::CmpInst::Create

static CmpInst * Create(OtherOps Op, Predicate Pred, Value *S1, Value *S2, const Twine &Name="", InsertPosition InsertBefore=nullptr)

Construct a compare instruction, given the opcode, the predicate and the two operands.

Definition:Instructions.cpp:3434

llvm::CmpInst::isFPPredicate

bool isFPPredicate() const

Definition:InstrTypes.h:780

llvm::CmpInst::isIntPredicate

bool isIntPredicate() const

Definition:InstrTypes.h:781

llvm::Comdat

Definition:Comdat.h:33

llvm::Comdat::SelectionKind

SelectionKind

Definition:Comdat.h:35

llvm::Comdat::Largest

@ Largest

The linker will choose the largest COMDAT.

Definition:Comdat.h:38

llvm::Comdat::SameSize

@ SameSize

The data referenced by the COMDAT must be the same size.

Definition:Comdat.h:40

llvm::Comdat::Any

@ Any

The linker may choose any COMDAT.

Definition:Comdat.h:36

llvm::Comdat::NoDeduplicate

@ NoDeduplicate

No deduplication is performed.

Definition:Comdat.h:39

llvm::Comdat::ExactMatch

@ ExactMatch

The data referenced by the COMDAT must be the same.

Definition:Comdat.h:37

llvm::ConstantArray::get

static Constant * get(ArrayType *T, ArrayRef< Constant * > V)

Definition:Constants.cpp:1312

llvm::ConstantDataArray::getString

static Constant * getString(LLVMContext &Context, StringRef Initializer, bool AddNull=true)

This method constructs a CDS and initializes it with a text string.

Definition:Constants.cpp:2991

llvm::ConstantDataArray::get

static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)

get() constructor - Return a constant with array type with an element count and element type matching...

Definition:Constants.h:709

llvm::ConstantDataArray::getFP

static Constant * getFP(Type *ElementType, ArrayRef< uint16_t > Elts)

getFP() constructors - Return a constant of array type with a float element type taken from argument ...

Definition:Constants.cpp:2970

llvm::ConstantDataVector::get

static Constant * get(LLVMContext &Context, ArrayRef< uint8_t > Elts)

get() constructors - Return a constant with vector type with an element count and element type matchi...

Definition:Constants.cpp:3007

llvm::ConstantDataVector::getFP

static Constant * getFP(Type *ElementType, ArrayRef< uint16_t > Elts)

getFP() constructors - Return a constant of vector type with a float element type taken from argument...

Definition:Constants.cpp:3044

llvm::ConstantExpr::getExtractElement

static Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)

Definition:Constants.cpp:2555

llvm::ConstantExpr::getCast

static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)

Convenience function for getting a Cast operation.

Definition:Constants.cpp:2222

llvm::ConstantExpr::getInsertElement

static Constant * getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx, Type *OnlyIfReducedTy=nullptr)

Definition:Constants.cpp:2577

llvm::ConstantExpr::getShuffleVector

static Constant * getShuffleVector(Constant *V1, Constant *V2, ArrayRef< int > Mask, Type *OnlyIfReducedTy=nullptr)

Definition:Constants.cpp:2600

llvm::ConstantExpr::isSupportedGetElementPtr

static bool isSupportedGetElementPtr(const Type *SrcElemTy)

Whether creating a constant expression for this getelementptr type is supported.

Definition:Constants.h:1379

llvm::ConstantExpr::get

static Constant * get(unsigned Opcode, Constant *C1, Constant *C2, unsigned Flags=0, Type *OnlyIfReducedTy=nullptr)

get - Return a binary or shift operator constant expression, folding if possible.

Definition:Constants.cpp:2340

llvm::ConstantExpr::isSupportedBinOp

static bool isSupportedBinOp(unsigned Opcode)

Whether creating a constant expression for this binary operator is supported.

Definition:Constants.cpp:2409

llvm::ConstantExpr::getGetElementPtr

static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, GEPNoWrapFlags NW=GEPNoWrapFlags::none(), std::optional< ConstantRange > InRange=std::nullopt, Type *OnlyIfReducedTy=nullptr)

Getelementptr form.

Definition:Constants.h:1267

llvm::ConstantExpr::isSupportedCastOp

static bool isSupportedCastOp(unsigned Opcode)

Whether creating a constant expression for this cast is supported.

Definition:Constants.cpp:2458

llvm::ConstantInt

This is the shared class of boolean and integer constants.

Definition:Constants.h:83

llvm::ConstantInt::getZExtValue

uint64_t getZExtValue() const

Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...

Definition:Constants.h:157

llvm::ConstantPtrAuth::get

static ConstantPtrAuth * get(Constant *Ptr, ConstantInt *Key, ConstantInt *Disc, Constant *AddrDisc)

Return a pointer signed with the specified parameters.

Definition:Constants.cpp:2072

llvm::ConstantRangeList::isOrderedRanges

static bool isOrderedRanges(ArrayRef< ConstantRange > RangesRef)

Definition:ConstantRangeList.cpp:14

llvm::ConstantRange

This class represents a range of values.

Definition:ConstantRange.h:47

llvm::ConstantRange::isUpperSignWrapped

bool isUpperSignWrapped() const

Return true if the (exclusive) upper bound wraps around the signed domain.

Definition:ConstantRange.cpp:434

llvm::ConstantRange::isFullSet

bool isFullSet() const

Return true if this set contains all of the elements possible for this data-type.

Definition:ConstantRange.cpp:414

llvm::ConstantStruct::get

static Constant * get(StructType *T, ArrayRef< Constant * > V)

Definition:Constants.cpp:1378

llvm::ConstantVector::get

static Constant * get(ArrayRef< Constant * > V)

Definition:Constants.cpp:1421

llvm::Constant

This is an important base class in LLVM.

Definition:Constant.h:42

llvm::Constant::getNullValue

static Constant * getNullValue(Type *Ty)

Constructor to create a '0' constant of arbitrary type.

Definition:Constants.cpp:373

llvm::DIAssignID

Assignment ID.

Definition:DebugInfoMetadata.h:309

llvm::DIExpression

DWARF expression.

Definition:DebugInfoMetadata.h:2763

llvm::DILabel

Label.

Definition:DebugInfoMetadata.h:3551

llvm::DILocalVariable

Local variable.

Definition:DebugInfoMetadata.h:3460

llvm::DILocation

Debug location.

Definition:DebugInfoMetadata.h:1988

llvm::DISubprogram

Subprogram description.

Definition:DebugInfoMetadata.h:1710

llvm::DSOLocalEquivalent::get

static DSOLocalEquivalent * get(GlobalValue *GV)

Return a DSOLocalEquivalent for the specified global value.

Definition:Constants.cpp:1970

llvm::DWARFExpression::Operation

This class represents an Operation in the Expression.

Definition:DWARFExpression.h:32

llvm::DataLayout

A parsed version of the target data layout string in and methods for querying it.

Definition:DataLayout.h:63

llvm::DataLayout::parse

static Expected< DataLayout > parse(StringRef LayoutString)

Parse a data layout string and return the layout.

Definition:DataLayout.cpp:264

llvm::DbgLabelRecord

Records a position in IR for a source label (DILabel).

Definition:DebugProgramInstruction.h:231

llvm::DbgVariableRecord

Record of a variable value-assignment, aka a non instruction representation of the dbg....

Definition:DebugProgramInstruction.h:270

llvm::DebugLoc

A debug info location.

Definition:DebugLoc.h:33

llvm::DenseMapBase::lookup

ValueT lookup(const_arg_type_t< KeyT > Val) const

lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...

Definition:DenseMap.h:194

llvm::DenseMapBase::find

iterator find(const_arg_type_t< KeyT > Val)

Definition:DenseMap.h:156

llvm::DenseMapBase::erase

bool erase(const KeyT &Val)

Definition:DenseMap.h:321

llvm::DenseMapBase::size

unsigned size() const

Definition:DenseMap.h:99

llvm::DenseMapBase::empty

bool empty() const

Definition:DenseMap.h:98

llvm::DenseMapBase::count

size_type count(const_arg_type_t< KeyT > Val) const

Return 1 if the specified key is in the map, 0 otherwise.

Definition:DenseMap.h:152

llvm::DenseMapBase::end

iterator end()

Definition:DenseMap.h:84

llvm::DenseMapBase::insert

std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)

Definition:DenseMap.h:211

llvm::DenseMap

Definition:DenseMap.h:727

llvm::DenseSet

Implements a dense probed hash-table based set.

Definition:DenseSet.h:278

llvm::ErrorInfoBase

Base class for error info classes.

Definition:Error.h:45

llvm::ErrorInfoBase::message

virtual std::string message() const

Return the error message as a string.

Definition:Error.h:53

llvm::ErrorInfoBase::convertToErrorCode

virtual std::error_code convertToErrorCode() const =0

Convert this error to a std::error_code.

llvm::ErrorOr

Represents either an error or a value T.

Definition:ErrorOr.h:56

llvm::ErrorOr::getError

std::error_code getError() const

Definition:ErrorOr.h:152

llvm::Error

Lightweight error class with error context and mandatory checking.

Definition:Error.h:160

llvm::Error::success

static ErrorSuccess success()

Create a success value.

Definition:Error.h:337

llvm::Expected

Tagged union holding either a T or a Error.

Definition:Error.h:481

llvm::Expected::takeError

Error takeError()

Take ownership of the stored error.

Definition:Error.h:608

llvm::Expected::get

reference get()

Returns a reference to the stored T value.

Definition:Error.h:578

llvm::ExtractElementInst::Create

static ExtractElementInst * Create(Value *Vec, Value *Idx, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:1788

llvm::ExtractValueInst::Create

static ExtractValueInst * Create(Value *Agg, ArrayRef< unsigned > Idxs, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:2418

llvm::FCmpInst

This instruction compares its operands according to the predicate given to the constructor.

Definition:Instructions.h:1379

llvm::FastMathFlags

Convenience struct for specifying and reasoning about fast-math flags.

Definition:FMF.h:20

llvm::FastMathFlags::setFast

void setFast(bool B=true)

Definition:FMF.h:97

llvm::FastMathFlags::any

bool any() const

Definition:FMF.h:57

llvm::FastMathFlags::setAllowContract

void setAllowContract(bool B=true)

Definition:FMF.h:91

llvm::FastMathFlags::setAllowReciprocal

void setAllowReciprocal(bool B=true)

Definition:FMF.h:88

llvm::FastMathFlags::setNoSignedZeros

void setNoSignedZeros(bool B=true)

Definition:FMF.h:85

llvm::FastMathFlags::setNoNaNs

void setNoNaNs(bool B=true)

Definition:FMF.h:79

llvm::FastMathFlags::setAllowReassoc

void setAllowReassoc(bool B=true)

Flag setters.

Definition:FMF.h:76

llvm::FastMathFlags::setApproxFunc

void setApproxFunc(bool B=true)

Definition:FMF.h:94

llvm::FastMathFlags::setNoInfs

void setNoInfs(bool B=true)

Definition:FMF.h:82

llvm::FenceInst

An instruction for ordering other memory operations.

Definition:Instructions.h:424

llvm::FixedVectorType::get

static FixedVectorType * get(Type *ElementType, unsigned NumElts)

Definition:Type.cpp:791

llvm::FreezeInst

This class represents a freeze function that returns random concrete value if an operand is either a ...

Definition:Instructions.h:5088

llvm::FunctionSummary::EdgeTy

std::pair< ValueInfo, CalleeInfo > EdgeTy

<CalleeValueInfo, CalleeInfo> call edge pair.

Definition:ModuleSummaryIndex.h:723

llvm::Function

Definition:Function.h:63

llvm::Function::Create

static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)

Definition:Function.h:173

llvm::Function::iterator

BasicBlockListType::iterator iterator

Definition:Function.h:68

llvm::Function::empty

bool empty() const

Definition:Function.h:859

llvm::Function::back

const BasicBlock & back() const

Definition:Function.h:862

llvm::Function::begin

iterator begin()

Definition:Function.h:853

llvm::Function::end

iterator end()

Definition:Function.h:855

llvm::GEPNoWrapFlags

Represents flags for the getelementptr instruction/expression.

Definition:GEPNoWrapFlags.h:26

llvm::GEPNoWrapFlags::inBounds

static GEPNoWrapFlags inBounds()

Definition:GEPNoWrapFlags.h:50

llvm::GEPNoWrapFlags::noUnsignedWrap

static GEPNoWrapFlags noUnsignedWrap()

Definition:GEPNoWrapFlags.h:56

llvm::GEPNoWrapFlags::noUnsignedSignedWrap

static GEPNoWrapFlags noUnsignedSignedWrap()

Definition:GEPNoWrapFlags.h:53

llvm::GVMaterializer

Definition:GVMaterializer.h:28

llvm::GVMaterializer::setStripDebugInfo

virtual void setStripDebugInfo()=0

llvm::GVMaterializer::materializeModule

virtual Error materializeModule()=0

Make sure the entire Module has been completely read.

llvm::GVMaterializer::materializeMetadata

virtual Error materializeMetadata()=0

llvm::GVMaterializer::materialize

virtual Error materialize(GlobalValue *GV)=0

Make sure the given GlobalValue is fully read.

llvm::GVMaterializer::getIdentifiedStructTypes

virtual std::vector< StructType * > getIdentifiedStructTypes() const =0

llvm::GetElementPtrInst::Create

static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:956

llvm::GlobalAlias::create

static GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)

If a parent module is specified, the alias is automatically inserted into the end of the specified mo...

Definition:Globals.cpp:557

llvm::GlobalIFunc::create

static GlobalIFunc * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Resolver, Module *Parent)

If a parent module is specified, the ifunc is automatically inserted into the end of the specified mo...

Definition:Globals.cpp:614

llvm::GlobalObject::setAlignment

void setAlignment(Align Align)

Sets the alignment attribute of the GlobalObject.

Definition:Globals.cpp:143

llvm::GlobalObject::setComdat

void setComdat(Comdat *C)

Definition:Globals.cpp:212

llvm::GlobalObject::setSection

void setSection(StringRef S)

Change the section for this global.

Definition:Globals.cpp:273

llvm::GlobalObject::VCallVisibility

VCallVisibility

Definition:GlobalObject.h:32

llvm::GlobalObject::VCallVisibilityPublic

@ VCallVisibilityPublic

Definition:GlobalObject.h:34

llvm::GlobalValueSummary

Function and variable summary information to aid decisions and implementation of importing.

Definition:ModuleSummaryIndex.h:466

llvm::GlobalValueSummary::ImportKind

ImportKind

Definition:ModuleSummaryIndex.h:471

llvm::GlobalValueSummary::setOriginalName

void setOriginalName(GlobalValue::GUID Name)

Initialize the original name hash in this summary.

Definition:ModuleSummaryIndex.h:582

llvm::GlobalValue

Definition:GlobalValue.h:48

llvm::GlobalValue::ThreadLocalMode

ThreadLocalMode

Definition:GlobalValue.h:196

llvm::GlobalValue::isLocalLinkage

static bool isLocalLinkage(LinkageTypes Linkage)

Definition:GlobalValue.h:410

llvm::GlobalValue::setUnnamedAddr

void setUnnamedAddr(UnnamedAddr Val)

Definition:GlobalValue.h:232

llvm::GlobalValue::hasLocalLinkage

bool hasLocalLinkage() const

Definition:GlobalValue.h:529

llvm::GlobalValue::hasDefaultVisibility

bool hasDefaultVisibility() const

Definition:GlobalValue.h:250

llvm::GlobalValue::setDLLStorageClass

void setDLLStorageClass(DLLStorageClassTypes C)

Definition:GlobalValue.h:285

llvm::GlobalValue::setThreadLocalMode

void setThreadLocalMode(ThreadLocalMode Val)

Definition:GlobalValue.h:268

llvm::GlobalValue::hasExternalWeakLinkage

bool hasExternalWeakLinkage() const

Definition:GlobalValue.h:530

llvm::GlobalValue::DLLStorageClassTypes

DLLStorageClassTypes

Storage classes of global values for PE targets.

Definition:GlobalValue.h:73

llvm::GlobalValue::DefaultStorageClass

@ DefaultStorageClass

Definition:GlobalValue.h:74

llvm::GlobalValue::DLLExportStorageClass

@ DLLExportStorageClass

Function to be accessible from DLL.

Definition:GlobalValue.h:76

llvm::GlobalValue::DLLImportStorageClass

@ DLLImportStorageClass

Function to be imported from DLL.

Definition:GlobalValue.h:75

llvm::GlobalValue::getGUID

GUID getGUID() const

Return a 64-bit global unique ID constructed from global value name (i.e.

Definition:GlobalValue.h:596

llvm::GlobalValue::setDSOLocal

void setDSOLocal(bool Local)

Definition:GlobalValue.h:304

llvm::GlobalValue::getType

PointerType * getType() const

Global values are always pointers.

Definition:GlobalValue.h:295

llvm::GlobalValue::VisibilityTypes

VisibilityTypes

An enumeration for the kinds of visibility of global values.

Definition:GlobalValue.h:66

llvm::GlobalValue::DefaultVisibility

@ DefaultVisibility

The GV is visible.

Definition:GlobalValue.h:67

llvm::GlobalValue::HiddenVisibility

@ HiddenVisibility

The GV is hidden.

Definition:GlobalValue.h:68

llvm::GlobalValue::ProtectedVisibility

@ ProtectedVisibility

The GV is protected.

Definition:GlobalValue.h:69

llvm::GlobalValue::setVisibility

void setVisibility(VisibilityTypes V)

Definition:GlobalValue.h:255

llvm::GlobalValue::setSanitizerMetadata

void setSanitizerMetadata(SanitizerMetadata Meta)

Definition:Globals.cpp:249

llvm::GlobalValue::UnnamedAddr

UnnamedAddr

Definition:GlobalValue.h:210

llvm::GlobalValue::getGlobalIdentifier

std::string getGlobalIdentifier() const

Return the modified name for this global value suitable to be used as the key for a global lookup (e....

Definition:Globals.cpp:184

llvm::GlobalValue::LinkageTypes

LinkageTypes

An enumeration for the kinds of linkage for global values.

Definition:GlobalValue.h:51

llvm::GlobalValue::PrivateLinkage

@ PrivateLinkage

Like Internal, but omit from symbol table.

Definition:GlobalValue.h:60

llvm::GlobalValue::CommonLinkage

@ CommonLinkage

Tentative definitions.

Definition:GlobalValue.h:62

llvm::GlobalValue::InternalLinkage

@ InternalLinkage

Rename collisions when linking (static functions).

Definition:GlobalValue.h:59

llvm::GlobalValue::LinkOnceAnyLinkage

@ LinkOnceAnyLinkage

Keep one copy of function when linking (inline)

Definition:GlobalValue.h:54

llvm::GlobalValue::WeakODRLinkage

@ WeakODRLinkage

Same, but only replaced by something equivalent.

Definition:GlobalValue.h:57

llvm::GlobalValue::ExternalLinkage

@ ExternalLinkage

Externally visible function.

Definition:GlobalValue.h:52

llvm::GlobalValue::WeakAnyLinkage

@ WeakAnyLinkage

Keep one copy of named function when linking (weak)

Definition:GlobalValue.h:56

llvm::GlobalValue::AppendingLinkage

@ AppendingLinkage

Special purpose, only applies to global arrays.

Definition:GlobalValue.h:58

llvm::GlobalValue::AvailableExternallyLinkage

@ AvailableExternallyLinkage

Available for inspection, not emission.

Definition:GlobalValue.h:53

llvm::GlobalValue::ExternalWeakLinkage

@ ExternalWeakLinkage

ExternalWeak linkage description.

Definition:GlobalValue.h:61

llvm::GlobalValue::LinkOnceODRLinkage

@ LinkOnceODRLinkage

Same, but only replaced by something equivalent.

Definition:GlobalValue.h:55

llvm::GlobalValue::setPartition

void setPartition(StringRef Part)

Definition:Globals.cpp:226

llvm::GlobalVariable

Definition:GlobalVariable.h:39

llvm::GlobalVariable::setAttributes

void setAttributes(AttributeSet A)

Set attribute list for this global.

Definition:GlobalVariable.h:258

llvm::GlobalVariable::setCodeModel

void setCodeModel(CodeModel::Model CM)

Change the code model for this global.

Definition:Globals.cpp:534

llvm::ICmpInst

This instruction compares its operands according to the predicate given to the constructor.

Definition:Instructions.h:1158

llvm::IndirectBrInst

Indirect Branch Instruction.

Definition:Instructions.h:3544

llvm::IndirectBrInst::addDestination

void addDestination(BasicBlock *Dest)

Add a destination.

Definition:Instructions.cpp:4217

llvm::IndirectBrInst::Create

static IndirectBrInst * Create(Value *Address, unsigned NumDests, InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:3602

llvm::IndirectBrInst::getNumDestinations

unsigned getNumDestinations() const

return the number of possible destinations in this indirectbr instruction.

Definition:Instructions.h:3617

llvm::InlineAsm

Definition:InlineAsm.h:34

llvm::InlineAsm::AsmDialect

AsmDialect

Definition:InlineAsm.h:36

llvm::InlineAsm::get

static InlineAsm * get(FunctionType *Ty, StringRef AsmString, StringRef Constraints, bool hasSideEffects, bool isAlignStack=false, AsmDialect asmDialect=AD_ATT, bool canThrow=false)

InlineAsm::get - Return the specified uniqued inline asm string.

Definition:InlineAsm.cpp:43

llvm::InlineAsm::isLabel

@ isLabel

Definition:InlineAsm.h:99

llvm::InlineAsm::ConstraintInfoVector

std::vector< ConstraintInfo > ConstraintInfoVector

Definition:InlineAsm.h:121

llvm::InsertElementInst::Create

static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:1848

llvm::InsertValueInst::Create

static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:2519

llvm::Instruction

Definition:Instruction.h:68

llvm::Instruction::isCast

bool isCast() const

Definition:Instruction.h:319

llvm::Instruction::isBinaryOp

bool isBinaryOp() const

Definition:Instruction.h:315

llvm::Instruction::OtherOps

OtherOps

Definition:Instruction.h:1036

llvm::Instruction::getOpcodeName

const char * getOpcodeName() const

Definition:Instruction.h:312

llvm::Instruction::BinaryOps

BinaryOps

Definition:Instruction.h:1008

llvm::Instruction::isUnaryOp

bool isUnaryOp() const

Definition:Instruction.h:314

llvm::Instruction::UnaryOps

UnaryOps

Definition:Instruction.h:1001

llvm::Instruction::CastOps

CastOps

Definition:Instruction.h:1022

llvm::Instruction::insertInto

InstListType::iterator insertInto(BasicBlock *ParentBB, InstListType::iterator It)

Inserts an unlinked instruction into ParentBB at position It and returns the iterator of the inserted...

Definition:Instruction.cpp:123

llvm::IntegerType::get

static IntegerType * get(LLVMContext &C, unsigned NumBits)

This static method is the primary way of constructing an IntegerType.

Definition:Type.cpp:311

llvm::IntegerType::MIN_INT_BITS

@ MIN_INT_BITS

Minimum number of bits that can be specified.

Definition:DerivedTypes.h:53

llvm::IntegerType::MAX_INT_BITS

@ MAX_INT_BITS

Maximum number of bits that can be specified.

Definition:DerivedTypes.h:54

llvm::InvokeInst::Create

static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:3710

llvm::LLVMContext

This is an important class for using LLVM in a threaded context.

Definition:LLVMContext.h:67

llvm::LLVMContext::emitError

void emitError(const Instruction *I, const Twine &ErrorStr)

emitError - Emit an error message to the currently installed error handler with optional location inf...

Definition:LLVMContext.cpp:210

llvm::LLVMContext::getOrInsertSyncScopeID

SyncScope::ID getOrInsertSyncScopeID(StringRef SSN)

getOrInsertSyncScopeID - Maps synchronization scope name to synchronization scope ID.

Definition:LLVMContext.cpp:306

llvm::LandingPadInst

The landingpad instruction holds all of the information necessary to generate correct exception handl...

Definition:Instructions.h:2840

llvm::LandingPadInst::Create

static LandingPadInst * Create(Type *RetTy, unsigned NumReservedClauses, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

Constructors - NumReservedClauses is a hint for the number of incoming clauses that this landingpad w...

Definition:Instructions.cpp:266

llvm::LandingPadInst::addClause

void addClause(Constant *ClauseVal)

Add a catch or filter clause to the landing pad.

Definition:Instructions.cpp:289

llvm::LandingPadInst::ClauseType

ClauseType

Definition:Instructions.h:2852

llvm::LandingPadInst::Catch

@ Catch

Definition:Instructions.h:2852

llvm::LandingPadInst::Filter

@ Filter

Definition:Instructions.h:2852

llvm::LandingPadInst::setCleanup

void setCleanup(bool V)

Indicate that this landingpad instruction is a cleanup.

Definition:Instructions.h:2888

llvm::LoadInst

An instruction for reading from memory.

Definition:Instructions.h:176

llvm::MDNode

Metadata node.

Definition:Metadata.h:1073

llvm::MDOperand

Tracking metadata reference owned by Metadata.

Definition:Metadata.h:895

llvm::MDString

A single uniqued string.

Definition:Metadata.h:724

llvm::MDString::getString

StringRef getString() const

Definition:Metadata.cpp:616

llvm::MapVector::insert

std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)

Definition:MapVector.h:141

llvm::MapVector::lookup

ValueT lookup(const KeyT &Key) const

Definition:MapVector.h:110

llvm::MemoryBufferRef

Definition:MemoryBufferRef.h:22

llvm::MemoryBufferRef::getBufferSize

size_t getBufferSize() const

Definition:MemoryBufferRef.h:37

llvm::MemoryBufferRef::getBufferIdentifier

StringRef getBufferIdentifier() const

Definition:MemoryBufferRef.h:33

llvm::MemoryBufferRef::getBufferStart

const char * getBufferStart() const

Definition:MemoryBufferRef.h:35

llvm::MemoryBuffer::getFileOrSTDIN

static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, std::optional< Align > Alignment=std::nullopt)

Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".

Definition:MemoryBuffer.cpp:163

llvm::MemoryEffectsBase

Definition:ModRef.h:72

llvm::MemoryEffectsBase::readOnly

static MemoryEffectsBase readOnly()

Create MemoryEffectsBase that can read any memory.

Definition:ModRef.h:122

llvm::MemoryEffectsBase::argMemOnly

static MemoryEffectsBase argMemOnly(ModRefInfo MR=ModRefInfo::ModRef)

Create MemoryEffectsBase that can only access argument memory.

Definition:ModRef.h:132

llvm::MemoryEffectsBase::inaccessibleMemOnly

static MemoryEffectsBase inaccessibleMemOnly(ModRefInfo MR=ModRefInfo::ModRef)

Create MemoryEffectsBase that can only access inaccessible memory.

Definition:ModRef.h:138

llvm::MemoryEffectsBase::createFromIntValue

static MemoryEffectsBase createFromIntValue(uint32_t Data)

Create MemoryEffectsBase from an encoded integer value (used by memory attribute).

Definition:ModRef.h:154

llvm::MemoryEffectsBase::writeOnly

static MemoryEffectsBase writeOnly()

Create MemoryEffectsBase that can write any memory.

Definition:ModRef.h:127

llvm::MemoryEffectsBase::inaccessibleOrArgMemOnly

static MemoryEffectsBase inaccessibleOrArgMemOnly(ModRefInfo MR=ModRefInfo::ModRef)

Create MemoryEffectsBase that can only access inaccessible or argument memory.

Definition:ModRef.h:145

llvm::MemoryEffectsBase::none

static MemoryEffectsBase none()

Create MemoryEffectsBase that cannot read or write any memory.

Definition:ModRef.h:117

llvm::MemoryEffectsBase::unknown

static MemoryEffectsBase unknown()

Create MemoryEffectsBase that can read and write any memory.

Definition:ModRef.h:112

llvm::MetadataAsValue::get

static MetadataAsValue * get(LLVMContext &Context, Metadata *MD)

Definition:Metadata.cpp:103

llvm::MetadataLoader

Helper class that handles loading Metadatas and keeping them available.

Definition:MetadataLoader.h:48

llvm::Metadata

Root of the metadata hierarchy.

Definition:Metadata.h:62

llvm::ModuleSummaryIndex

Class to hold module path string table and global value map, and encapsulate methods for operating on...

Definition:ModuleSummaryIndex.h:1345

llvm::ModuleSummaryIndex::getOrInsertTypeIdSummary

TypeIdSummary & getOrInsertTypeIdSummary(StringRef TypeId)

Return an existing or new TypeIdSummary entry for TypeId.

Definition:ModuleSummaryIndex.h:1830

llvm::ModuleSummaryIndex::getOrInsertValueInfo

ValueInfo getOrInsertValueInfo(GlobalValue::GUID GUID)

Return a ValueInfo for GUID.

Definition:ModuleSummaryIndex.h:1639

llvm::ModuleSummaryIndex::saveString

StringRef saveString(StringRef String)

Definition:ModuleSummaryIndex.h:1646

llvm::ModuleSummaryIndex::setFlags

void setFlags(uint64_t Flags)

Definition:ModuleSummaryIndex.cpp:117

llvm::ModuleSummaryIndex::addBlockCount

void addBlockCount(uint64_t C)

Definition:ModuleSummaryIndex.h:1483

llvm::ModuleSummaryIndex::addModule

ModuleInfo * addModule(StringRef ModPath, ModuleHash Hash=ModuleHash{{0}})

Add a new module with the given Hash, mapped to the given ModID, and return a reference to the module...

Definition:ModuleSummaryIndex.h:1800

llvm::ModuleSummaryIndex::addGlobalValueSummary

void addGlobalValueSummary(const GlobalValue &GV, std::unique_ptr< GlobalValueSummary > Summary)

Add a global value summary for a value.

Definition:ModuleSummaryIndex.h:1685

llvm::ModuleSummaryIndex::cfiFunctionDefs

std::set< std::string, std::less<> > & cfiFunctionDefs()

Definition:ModuleSummaryIndex.h:1670

llvm::ModuleSummaryIndex::BitcodeSummaryVersion

static constexpr uint64_t BitcodeSummaryVersion

Definition:ModuleSummaryIndex.h:1470

llvm::ModuleSummaryIndex::cfiFunctionDecls

std::set< std::string, std::less<> > & cfiFunctionDecls()

Definition:ModuleSummaryIndex.h:1677

llvm::ModuleSummaryIndex::findSummaryInModule

GlobalValueSummary * findSummaryInModule(ValueInfo VI, StringRef ModuleId) const

Find the summary for ValueInfo VI in module ModuleId, or nullptr if not found.

Definition:ModuleSummaryIndex.h:1721

llvm::ModuleSummaryIndex::addOrGetStackIdIndex

unsigned addOrGetStackIdIndex(uint64_t StackId)

Definition:ModuleSummaryIndex.h:1494

llvm::ModuleSummaryIndex::getModule

ModuleInfo * getModule(StringRef ModPath)

Return module entry for module with the given ModPath.

Definition:ModuleSummaryIndex.h:1805

llvm::ModuleSummaryIndex::addOriginalName

void addOriginalName(GlobalValue::GUID ValueGUID, GlobalValue::GUID OrigGUID)

Add an original name for the value of the given GUID.

Definition:ModuleSummaryIndex.h:1710

llvm::ModuleSummaryIndex::getOrInsertTypeIdCompatibleVtableSummary

TypeIdCompatibleVtableInfo & getOrInsertTypeIdCompatibleVtableSummary(StringRef TypeId)

Return an existing or new TypeIdCompatibleVtableMap entry for TypeId.

Definition:ModuleSummaryIndex.h:1864

llvm::Module

A Module instance is used to store all the information related to an LLVM module.

Definition:Module.h:65

llvm::Module::getNamedMetadata

NamedMDNode * getNamedMetadata(StringRef Name) const

Return the first NamedMDNode in the module with the specified name.

Definition:Module.cpp:297

llvm::Module::getTargetTriple

const std::string & getTargetTriple() const

Get the target triple which is a string describing the target host.

Definition:Module.h:298

llvm::Module::getOrInsertNamedMetadata

NamedMDNode * getOrInsertNamedMetadata(StringRef Name)

Return the named MDNode in the module with the specified name.

Definition:Module.cpp:304

llvm::Module::getOrInsertComdat

Comdat * getOrInsertComdat(StringRef Name)

Return the Comdat in the module with the specified name.

Definition:Module.cpp:611

llvm::Module::getModuleFlag

Metadata * getModuleFlag(StringRef Key) const

Return the corresponding value if Key appears in module flags, otherwise return null.

Definition:Module.cpp:354

llvm::NamedMDNode

A tuple of MDNodes.

Definition:Metadata.h:1737

llvm::NamedMDNode::addOperand

void addOperand(MDNode *M)

Definition:Metadata.cpp:1431

llvm::NoCFIValue::get

static NoCFIValue * get(GlobalValue *GV)

Return a NoCFIValue for the specified function.

Definition:Constants.cpp:2028

llvm::OverflowingBinaryOperator::NoUnsignedWrap

@ NoUnsignedWrap

Definition:Operator.h:81

llvm::OverflowingBinaryOperator::NoSignedWrap

@ NoSignedWrap

Definition:Operator.h:82

llvm::PHINode

Definition:Instructions.h:2600

llvm::PHINode::addIncoming

void addIncoming(Value *V, BasicBlock *BB)

Add an incoming value to the end of the PHI list.

Definition:Instructions.h:2735

llvm::PHINode::Create

static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...

Definition:Instructions.h:2635

llvm::PoisonValue::get

static PoisonValue * get(Type *T)

Static factory methods - Return an 'poison' object of the specified type.

Definition:Constants.cpp:1878

llvm::PossiblyExactOperator::IsExact

@ IsExact

Definition:Operator.h:158

llvm::Record

Definition:Record.h:1596

llvm::ResumeInst::Create

static ResumeInst * Create(Value *Exn, InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:4016

llvm::ReturnInst::Create

static ReturnInst * Create(LLVMContext &C, Value *retVal=nullptr, InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:2965

llvm::SelectInst::Create

static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", InsertPosition InsertBefore=nullptr, Instruction *MDFrom=nullptr)

Definition:Instructions.h:1682

llvm::ShuffleVectorInst

This instruction constructs a fixed permutation of two input vectors.

Definition:Instructions.h:1901

llvm::ShuffleVectorInst::getShuffleMask

ArrayRef< int > getShuffleMask() const

Definition:Instructions.h:1974

llvm::SmallDenseMap

Definition:DenseMap.h:883

llvm::SmallPtrSet

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

Definition:SmallPtrSet.h:519

llvm::SmallString

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

Definition:SmallString.h:26

llvm::SmallString::str

StringRef str() const

Explicit conversion to StringRef.

Definition:SmallString.h:254

llvm::SmallVectorBase::empty

bool empty() const

Definition:SmallVector.h:81

llvm::SmallVectorBase::size

size_t size() const

Definition:SmallVector.h:78

llvm::SmallVectorImpl

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

Definition:SmallVector.h:573

llvm::SmallVectorImpl::reserve

void reserve(size_type N)

Definition:SmallVector.h:663

llvm::SmallVectorImpl::erase

iterator erase(const_iterator CI)

Definition:SmallVector.h:737

llvm::SmallVectorImpl::append

void append(ItTy in_start, ItTy in_end)

Add the specified range to the end of the SmallVector.

Definition:SmallVector.h:683

llvm::SmallVectorImpl::clear

void clear()

Definition:SmallVector.h:610

llvm::SmallVectorTemplateBase::pop_back

void pop_back()

Definition:SmallVector.h:425

llvm::SmallVectorTemplateBase::push_back

void push_back(const T &Elt)

Definition:SmallVector.h:413

llvm::SmallVectorTemplateCommon::end

iterator end()

Definition:SmallVector.h:269

llvm::SmallVectorTemplateCommon::begin

iterator begin()

Definition:SmallVector.h:267

llvm::SmallVectorTemplateCommon::back

reference back()

Definition:SmallVector.h:308

llvm::SmallVector

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Definition:SmallVector.h:1196

llvm::StoreInst

An instruction for storing to memory.

Definition:Instructions.h:292

llvm::StringMapEntryStorage::second

ValueTy second

Definition:StringMapEntry.h:71

llvm::StringMapEntry

StringMapEntry - This is used to represent one value that is inserted into a StringMap.

Definition:StringMapEntry.h:102

llvm::StringMapEntry::first

StringRef first() const

Definition:StringMapEntry.h:119

llvm::StringRef

StringRef - Represent a constant reference to a string, i.e.

Definition:StringRef.h:51

llvm::StringRef::empty

constexpr bool empty() const

empty - Check if the string is empty.

Definition:StringRef.h:147

llvm::StringRef::data

constexpr const char * data() const

data - Get a pointer to the start of the string (which may not be null terminated).

Definition:StringRef.h:144

llvm::StructType

Class to represent struct types.

Definition:DerivedTypes.h:218

llvm::StructType::get

static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)

This static method is the primary way to create a literal StructType.

Definition:Type.cpp:406

llvm::StructType::create

static StructType * create(LLVMContext &Context, StringRef Name)

This creates an identified struct.

Definition:Type.cpp:612

llvm::StructType::setName

void setName(StringRef Name)

Change the name of this type to the specified name, or to a name with a suffix if there is a collisio...

Definition:Type.cpp:561

llvm::StructType::setBodyOrError

Error setBodyOrError(ArrayRef< Type * > Elements, bool isPacked=false)

Specify a body for an opaque identified type or return an error if it would make the type recursive.

Definition:Type.cpp:531

llvm::SwitchInst

Multiway switch.

Definition:Instructions.h:3154

llvm::SwitchInst::Create

static SwitchInst * Create(Value *Value, BasicBlock *Default, unsigned NumCases, InsertPosition InsertBefore=nullptr)

Definition:Instructions.h:3338

llvm::TBAAVerifier

Verify that the TBAA Metadatas are valid.

Definition:Verifier.h:39

llvm::TBAAVerifier::visitTBAAMetadata

bool visitTBAAMetadata(Instruction &I, const MDNode *MD)

Visit an instruction and return true if it is valid, return false if an invalid TBAA is attached.

Definition:Verifier.cpp:7616

llvm::TargetExtType::HasZeroInit

@ HasZeroInit

zeroinitializer is valid for this target extension type.

Definition:DerivedTypes.h:806

llvm::TargetExtType::getOrError

static Expected< TargetExtType * > getOrError(LLVMContext &Context, StringRef Name, ArrayRef< Type * > Types={}, ArrayRef< unsigned > Ints={})

Return a target extension type having the specified name and optional type and integer parameters,...

Definition:Type.cpp:901

llvm::TrailingObjects

See the file comment for details on the usage of the TrailingObjects type.

Definition:TrailingObjects.h:216

llvm::TrailingObjects::TrailingObjects

TrailingObjects()=default

llvm::Triple

Triple - Helper class for working with autoconf configuration names.

Definition:Triple.h:44

llvm::Twine

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

Definition:Twine.h:81

llvm::Twine::str

std::string str() const

Return the twine contents as a std::string.

Definition:Twine.cpp:17

llvm::Type

The instances of the Type class are immutable: once they are created, they are never changed.

Definition:Type.h:45

llvm::Type::getHalfTy

static Type * getHalfTy(LLVMContext &C)

llvm::Type::getStructElementType

Type * getStructElementType(unsigned N) const

llvm::Type::getDoubleTy

static Type * getDoubleTy(LLVMContext &C)

llvm::Type::isVectorTy

bool isVectorTy() const

True if this is an instance of VectorType.

Definition:Type.h:270

llvm::Type::isArrayTy

bool isArrayTy() const

True if this is an instance of ArrayType.

Definition:Type.h:261

llvm::Type::getX86_FP80Ty

static Type * getX86_FP80Ty(LLVMContext &C)

llvm::Type::isLabelTy

bool isLabelTy() const

Return true if this is 'label'.

Definition:Type.h:228

llvm::Type::getBFloatTy

static Type * getBFloatTy(LLVMContext &C)

llvm::Type::isIntOrIntVectorTy

bool isIntOrIntVectorTy() const

Return true if this is an integer type or a vector of integer types.

Definition:Type.h:243

llvm::Type::isPointerTy

bool isPointerTy() const

True if this is an instance of PointerType.

Definition:Type.h:264

llvm::Type::getInt1Ty

static IntegerType * getInt1Ty(LLVMContext &C)

llvm::Type::getArrayElementType

Type * getArrayElementType() const

Definition:Type.h:411

llvm::Type::isFloatTy

bool isFloatTy() const

Return true if this is 'float', a 32-bit IEEE fp type.

Definition:Type.h:153

llvm::Type::getX86_AMXTy

static Type * getX86_AMXTy(LLVMContext &C)

llvm::Type::isBFloatTy

bool isBFloatTy() const

Return true if this is 'bfloat', a 16-bit bfloat type.

Definition:Type.h:145

llvm::Type::getMetadataTy

static Type * getMetadataTy(LLVMContext &C)

llvm::Type::getStructNumElements

unsigned getStructNumElements() const

llvm::Type::getArrayNumElements

uint64_t getArrayNumElements() const

llvm::Type::TypeID

TypeID

Definitions of all of the base types for the Type system.

Definition:Type.h:54

llvm::Type::getVoidTy

static Type * getVoidTy(LLVMContext &C)

llvm::Type::getLabelTy

static Type * getLabelTy(LLVMContext &C)

llvm::Type::isStructTy

bool isStructTy() const

True if this is an instance of StructType.

Definition:Type.h:258

llvm::Type::getFP128Ty

static Type * getFP128Ty(LLVMContext &C)

llvm::Type::isSized

bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const

Return true if it makes sense to take the size of this type.

Definition:Type.h:310

llvm::Type::isHalfTy

bool isHalfTy() const

Return true if this is 'half', a 16-bit IEEE fp type.

Definition:Type.h:142

llvm::Type::getContext

LLVMContext & getContext() const

Return the LLVMContext in which this type was uniqued.

Definition:Type.h:128

llvm::Type::isDoubleTy

bool isDoubleTy() const

Return true if this is 'double', a 64-bit IEEE fp type.

Definition:Type.h:156

llvm::Type::getTokenTy

static Type * getTokenTy(LLVMContext &C)

llvm::Type::isFunctionTy

bool isFunctionTy() const

True if this is an instance of FunctionType.

Definition:Type.h:255

llvm::Type::getInt32Ty

static IntegerType * getInt32Ty(LLVMContext &C)

llvm::Type::getFloatTy

static Type * getFloatTy(LLVMContext &C)

llvm::Type::isIntegerTy

bool isIntegerTy() const

True if this is an instance of IntegerType.

Definition:Type.h:237

llvm::Type::isFPOrFPVectorTy

bool isFPOrFPVectorTy() const

Return true if this is a FP type or a vector of FP.

Definition:Type.h:225

llvm::Type::getPPC_FP128Ty

static Type * getPPC_FP128Ty(LLVMContext &C)

llvm::Type::isVoidTy

bool isVoidTy() const

Return true if this is 'void'.

Definition:Type.h:139

llvm::Type::getScalarType

Type * getScalarType() const

If this is a vector type, return the element type, otherwise return 'this'.

Definition:Type.h:355

llvm::Type::isMetadataTy

bool isMetadataTy() const

Return true if this is 'metadata'.

Definition:Type.h:231

llvm::UnaryOperator::Create

static UnaryOperator * Create(UnaryOps Op, Value *S, const Twine &Name=Twine(), InsertPosition InsertBefore=nullptr)

Construct a unary instruction, given the opcode and an operand.

Definition:Instructions.cpp:2536

llvm::UndefValue::get

static UndefValue * get(Type *T)

Static factory methods - Return an 'undef' object of the specified type.

Definition:Constants.cpp:1859

llvm::UnreachableInst

This function has undefined behavior.

Definition:Instructions.h:4461

llvm::Use

A Use represents the edge between a Value definition and its users.

Definition:Use.h:43

llvm::User

Definition:User.h:44

llvm::VAArgInst

This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...

Definition:Instructions.h:1741

llvm::ValueAsMetadata::get

static ValueAsMetadata * get(Value *V)

Definition:Metadata.cpp:501

llvm::Value

LLVM Value Representation.

Definition:Value.h:74

llvm::Value::getType

Type * getType() const

All values are typed, get the type of this value.

Definition:Value.h:255

llvm::Value::setName

void setName(const Twine &Name)

Change the name of the value.

Definition:Value.cpp:377

llvm::Value::deleteValue

void deleteValue()

Delete a pointer to a generic Value.

Definition:Value.cpp:110

llvm::Value::MaxAlignmentExponent

static constexpr unsigned MaxAlignmentExponent

The maximum alignment for instructions.

Definition:Value.h:810

llvm::Value::operator=

Value & operator=(const Value &)=delete

llvm::cl::opt

Definition:CommandLine.h:1423

llvm::detail::DenseSetImpl::insert

std::pair< iterator, bool > insert(const ValueT &V)

Definition:DenseSet.h:213

llvm::detail::DenseSetImpl::contains

bool contains(const_arg_type_t< ValueT > V) const

Check if the set contains the given element.

Definition:DenseSet.h:193

llvm::ilist_detail::node_parent_access::getParent

const ParentTy * getParent() const

Definition:ilist_node.h:32

llvm::ilist_node_impl::getIterator

self_iterator getIterator()

Definition:ilist_node.h:132

This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM.

DebugInfo.h

ErrorHandling.h

llvm_unreachable

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

Definition:ErrorHandling.h:143

Error.h

llvm::AArch64CC::LT

@ LT

Definition:AArch64BaseInfo.h:266

llvm::AArch64CC::VS

@ VS

Definition:AArch64BaseInfo.h:261

llvm::AArch64PACKey::IA

@ IA

Definition:AArch64BaseInfo.h:875

llvm::AMDGPU::HSAMD::Kernel::Arg::Key::TypeName

constexpr char TypeName[]

Key for Kernel::Arg::Metadata::mTypeName.

Definition:AMDGPUMetadata.h:176

llvm::AMDGPU::HSAMD::Kernel::Key::Args

constexpr char Args[]

Key for Kernel::Metadata::mArgs.

Definition:AMDGPUMetadata.h:395

llvm::AMDGPU::HSAMD::Kernel::Key::Attrs

constexpr char Attrs[]

Key for Kernel::Metadata::mAttrs.

Definition:AMDGPUMetadata.h:393

llvm::AMDGPU::PALMD::Key

Key

PAL metadata keys.

Definition:AMDGPUMetadata.h:487

llvm::ARMBuildAttrs::Section

@ Section

Legacy Tags.

Definition:ARMBuildAttributes.h:82

llvm::ARM_MB::ST

@ ST

Definition:ARMBaseInfo.h:73

llvm::ARM_PROC::IE

@ IE

Definition:ARMBaseInfo.h:27

llvm::ARM::PredBlockMask::TT

@ TT

llvm::ARM::ProfileKind::M

@ M

llvm::AttributeFuncs::typeIncompatible

AttributeMask typeIncompatible(Type *Ty, AttributeSet AS, AttributeSafetyKind ASK=ASK_ALL)

Which attributes cannot be applied to a type.

Definition:Attributes.cpp:2349

llvm::BitmaskEnumDetail::Mask

constexpr std::underlying_type_t< E > Mask()

Get a bitmask with 1s in all places up to the high-order bit of E's largest value.

Definition:BitmaskEnum.h:125

llvm::COFF::Entry

@ Entry

Definition:COFF.h:844

llvm::CallingConv::MaxID

@ MaxID

The highest possible ID. Must be some 2^k - 1.

Definition:CallingConv.h:274

llvm::CallingConv::X86_INTR

@ X86_INTR

x86 hardware interrupt context.

Definition:CallingConv.h:173

llvm::CallingConv::C

@ C

The default llvm calling convention, compatible with C.

Definition:CallingConv.h:34

llvm::CallingConv::ID

unsigned ID

LLVM IR allows to use arbitrary numbers as calling convention identifiers.

Definition:CallingConv.h:24

llvm::CodeModel::Medium

@ Medium

Definition:CodeGen.h:31

llvm::CodeModel::Large

@ Large

Definition:CodeGen.h:31

llvm::CodeModel::Tiny

@ Tiny

Definition:CodeGen.h:31

llvm::CodeModel::Small

@ Small

Definition:CodeGen.h:31

llvm::CodeModel::Kernel

@ Kernel

Definition:CodeGen.h:31

llvm::GOFF::RecordLength

constexpr uint8_t RecordLength

Length of the parts of a physical GOFF record.

Definition:GOFF.h:28

llvm::IndexedCGData::Version

const uint64_t Version

Definition:CodeGenData.h:286

llvm::Intrinsic::getAttributes

AttributeList getAttributes(LLVMContext &C, ID id)

Return the attributes for an intrinsic.

llvm::M68k::MemAddrModeKind::U

@ U

llvm::M68k::MemAddrModeKind::V

@ V

llvm::M68k::MemAddrModeKind::u

@ u

llvm::MCID::Call

@ Call

Definition:MCInstrDesc.h:156

llvm::MipsISD::Ret

@ Ret

Definition:MipsISelLowering.h:117

llvm::NVPTXAS::AddressSpace

AddressSpace

Definition:NVPTXAddrSpace.h:20

llvm::NVPTX::Ordering

Ordering

Definition:NVPTX.h:116

llvm::RISCVFenceField::R

@ R

Definition:RISCVBaseInfo.h:373

llvm::SIEncodingFamily::VI

@ VI

Definition:SIDefines.h:37

llvm::SIEncodingFamily::SI

@ SI

Definition:SIDefines.h:36

llvm::SyncScope::ID

uint8_t ID

Definition:LLVMContext.h:46

llvm::SyncScope::SingleThread

@ SingleThread

Synchronized with respect to signal handlers executing in the same thread.

Definition:LLVMContext.h:54

llvm::SyncScope::System

@ System

Synchronized with respect to all concurrently executing threads.

Definition:LLVMContext.h:57

llvm::X86AS::FS

@ FS

Definition:X86.h:211

llvm::X86::FirstMacroFusionInstKind::Cmp

@ Cmp

llvm::bitc::BITCODE_CURRENT_EPOCH

@ BITCODE_CURRENT_EPOCH

Definition:LLVMBitCodes.h:81

llvm::bitc::TYPE_CODE_BFLOAT

@ TYPE_CODE_BFLOAT

Definition:LLVMBitCodes.h:174

llvm::bitc::TYPE_CODE_OPAQUE

@ TYPE_CODE_OPAQUE

Definition:LLVMBitCodes.h:143

llvm::bitc::TYPE_CODE_LABEL

@ TYPE_CODE_LABEL

Definition:LLVMBitCodes.h:142

llvm::bitc::TYPE_CODE_VOID

@ TYPE_CODE_VOID

Definition:LLVMBitCodes.h:139

llvm::bitc::TYPE_CODE_METADATA

@ TYPE_CODE_METADATA

Definition:LLVMBitCodes.h:162

llvm::bitc::TYPE_CODE_HALF

@ TYPE_CODE_HALF

Definition:LLVMBitCodes.h:150

llvm::bitc::TYPE_CODE_VECTOR

@ TYPE_CODE_VECTOR

Definition:LLVMBitCodes.h:153

llvm::bitc::TYPE_CODE_PPC_FP128

@ TYPE_CODE_PPC_FP128

Definition:LLVMBitCodes.h:160

llvm::bitc::TYPE_CODE_TARGET_TYPE

@ TYPE_CODE_TARGET_TYPE

Definition:LLVMBitCodes.h:179

llvm::bitc::TYPE_CODE_STRUCT_ANON

@ TYPE_CODE_STRUCT_ANON

Definition:LLVMBitCodes.h:166

llvm::bitc::TYPE_CODE_STRUCT_NAME

@ TYPE_CODE_STRUCT_NAME

Definition:LLVMBitCodes.h:167

llvm::bitc::TYPE_CODE_X86_FP80

@ TYPE_CODE_X86_FP80

Definition:LLVMBitCodes.h:158

llvm::bitc::TYPE_CODE_X86_MMX

@ TYPE_CODE_X86_MMX

Definition:LLVMBitCodes.h:164

llvm::bitc::TYPE_CODE_OPAQUE_POINTER

@ TYPE_CODE_OPAQUE_POINTER

Definition:LLVMBitCodes.h:177

llvm::bitc::TYPE_CODE_FLOAT

@ TYPE_CODE_FLOAT

Definition:LLVMBitCodes.h:140

llvm::bitc::TYPE_CODE_FUNCTION

@ TYPE_CODE_FUNCTION

Definition:LLVMBitCodes.h:170

llvm::bitc::TYPE_CODE_INTEGER

@ TYPE_CODE_INTEGER

Definition:LLVMBitCodes.h:144

llvm::bitc::TYPE_CODE_TOKEN

@ TYPE_CODE_TOKEN

Definition:LLVMBitCodes.h:172

llvm::bitc::TYPE_CODE_POINTER

@ TYPE_CODE_POINTER

Definition:LLVMBitCodes.h:145

llvm::bitc::TYPE_CODE_X86_AMX

@ TYPE_CODE_X86_AMX

Definition:LLVMBitCodes.h:175

llvm::bitc::TYPE_CODE_ARRAY

@ TYPE_CODE_ARRAY

Definition:LLVMBitCodes.h:152

llvm::bitc::TYPE_CODE_DOUBLE

@ TYPE_CODE_DOUBLE

Definition:LLVMBitCodes.h:141

llvm::bitc::TYPE_CODE_FP128

@ TYPE_CODE_FP128

Definition:LLVMBitCodes.h:159

llvm::bitc::TYPE_CODE_NUMENTRY

@ TYPE_CODE_NUMENTRY

Definition:LLVMBitCodes.h:136

llvm::bitc::TYPE_CODE_FUNCTION_OLD

@ TYPE_CODE_FUNCTION_OLD

Definition:LLVMBitCodes.h:147

llvm::bitc::TYPE_CODE_STRUCT_NAMED

@ TYPE_CODE_STRUCT_NAMED

Definition:LLVMBitCodes.h:168

llvm::bitc::RMW_USUB_COND

@ RMW_USUB_COND

Definition:LLVMBitCodes.h:504

llvm::bitc::RMW_MAX

@ RMW_MAX

Definition:LLVMBitCodes.h:494

llvm::bitc::RMW_FMIN

@ RMW_FMIN

Definition:LLVMBitCodes.h:501

llvm::bitc::RMW_XCHG

@ RMW_XCHG

Definition:LLVMBitCodes.h:487

llvm::bitc::RMW_AND

@ RMW_AND

Definition:LLVMBitCodes.h:490

llvm::bitc::RMW_UMIN

@ RMW_UMIN

Definition:LLVMBitCodes.h:497

llvm::bitc::RMW_USUB_SAT

@ RMW_USUB_SAT

Definition:LLVMBitCodes.h:505

llvm::bitc::RMW_FADD

@ RMW_FADD

Definition:LLVMBitCodes.h:498

llvm::bitc::RMW_OR

@ RMW_OR

Definition:LLVMBitCodes.h:492

llvm::bitc::RMW_XOR

@ RMW_XOR

Definition:LLVMBitCodes.h:493

llvm::bitc::RMW_SUB

@ RMW_SUB

Definition:LLVMBitCodes.h:489

llvm::bitc::RMW_UDEC_WRAP

@ RMW_UDEC_WRAP

Definition:LLVMBitCodes.h:503

llvm::bitc::RMW_UMAX

@ RMW_UMAX

Definition:LLVMBitCodes.h:496

llvm::bitc::RMW_FSUB

@ RMW_FSUB

Definition:LLVMBitCodes.h:499

llvm::bitc::RMW_UINC_WRAP

@ RMW_UINC_WRAP

Definition:LLVMBitCodes.h:502

llvm::bitc::RMW_NAND

@ RMW_NAND

Definition:LLVMBitCodes.h:491

llvm::bitc::RMW_ADD

@ RMW_ADD

Definition:LLVMBitCodes.h:488

llvm::bitc::RMW_FMAX

@ RMW_FMAX

Definition:LLVMBitCodes.h:500

llvm::bitc::RMW_MIN

@ RMW_MIN

Definition:LLVMBitCodes.h:495

llvm::bitc::FS_CONTEXT_RADIX_TREE_ARRAY

@ FS_CONTEXT_RADIX_TREE_ARRAY

Definition:LLVMBitCodes.h:337

llvm::bitc::FS_BLOCK_COUNT

@ FS_BLOCK_COUNT

Definition:LLVMBitCodes.h:302

llvm::bitc::FS_PERMODULE

@ FS_PERMODULE

Definition:LLVMBitCodes.h:210

llvm::bitc::FS_CFI_FUNCTION_DEFS

@ FS_CFI_FUNCTION_DEFS

Definition:LLVMBitCodes.h:263

llvm::bitc::FS_VALUE_GUID

@ FS_VALUE_GUID

Definition:LLVMBitCodes.h:259

llvm::bitc::FS_PERMODULE_RELBF

@ FS_PERMODULE_RELBF

Definition:LLVMBitCodes.h:272

llvm::bitc::FS_COMBINED_GLOBALVAR_INIT_REFS

@ FS_COMBINED_GLOBALVAR_INIT_REFS

Definition:LLVMBitCodes.h:225

llvm::bitc::FS_COMBINED

@ FS_COMBINED

Definition:LLVMBitCodes.h:219

llvm::bitc::FS_TYPE_CHECKED_LOAD_VCALLS

@ FS_TYPE_CHECKED_LOAD_VCALLS

Definition:LLVMBitCodes.h:247

llvm::bitc::FS_COMBINED_PROFILE

@ FS_COMBINED_PROFILE

Definition:LLVMBitCodes.h:223

llvm::bitc::FS_ALLOC_CONTEXT_IDS

@ FS_ALLOC_CONTEXT_IDS

Definition:LLVMBitCodes.h:333

llvm::bitc::FS_PARAM_ACCESS

@ FS_PARAM_ACCESS

Definition:LLVMBitCodes.h:305

llvm::bitc::FS_COMBINED_ORIGINAL_NAME

@ FS_COMBINED_ORIGINAL_NAME

Definition:LLVMBitCodes.h:231

llvm::bitc::FS_TYPE_ID_METADATA

@ FS_TYPE_ID_METADATA

Definition:LLVMBitCodes.h:294

llvm::bitc::FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS

@ FS_PERMODULE_VTABLE_GLOBALVAR_INIT_REFS

Definition:LLVMBitCodes.h:300

llvm::bitc::FS_TYPE_TEST_ASSUME_CONST_VCALL

@ FS_TYPE_TEST_ASSUME_CONST_VCALL

Definition:LLVMBitCodes.h:251

llvm::bitc::FS_ALIAS

@ FS_ALIAS

Definition:LLVMBitCodes.h:227

llvm::bitc::FS_TYPE_ID

@ FS_TYPE_ID

Definition:LLVMBitCodes.h:280

llvm::bitc::FS_PERMODULE_GLOBALVAR_INIT_REFS

@ FS_PERMODULE_GLOBALVAR_INIT_REFS

Definition:LLVMBitCodes.h:216

llvm::bitc::FS_COMBINED_ALIAS

@ FS_COMBINED_ALIAS

Definition:LLVMBitCodes.h:229

llvm::bitc::FS_TYPE_TEST_ASSUME_VCALLS

@ FS_TYPE_TEST_ASSUME_VCALLS

Definition:LLVMBitCodes.h:242

llvm::bitc::FS_CFI_FUNCTION_DECLS

@ FS_CFI_FUNCTION_DECLS

Definition:LLVMBitCodes.h:267

llvm::bitc::FS_TYPE_TESTS

@ FS_TYPE_TESTS

Definition:LLVMBitCodes.h:237

llvm::bitc::FS_COMBINED_CALLSITE_INFO

@ FS_COMBINED_CALLSITE_INFO

Definition:LLVMBitCodes.h:316

llvm::bitc::FS_FLAGS

@ FS_FLAGS

Definition:LLVMBitCodes.h:274

llvm::bitc::FS_COMBINED_ALLOC_INFO

@ FS_COMBINED_ALLOC_INFO

Definition:LLVMBitCodes.h:321

llvm::bitc::FS_STACK_IDS

@ FS_STACK_IDS

Definition:LLVMBitCodes.h:324

llvm::bitc::FS_PERMODULE_PROFILE

@ FS_PERMODULE_PROFILE

Definition:LLVMBitCodes.h:214

llvm::bitc::FS_PERMODULE_CALLSITE_INFO

@ FS_PERMODULE_CALLSITE_INFO

Definition:LLVMBitCodes.h:308

llvm::bitc::FS_PERMODULE_ALLOC_INFO

@ FS_PERMODULE_ALLOC_INFO

Definition:LLVMBitCodes.h:312

llvm::bitc::FS_VERSION

@ FS_VERSION

Definition:LLVMBitCodes.h:233

llvm::bitc::FS_TYPE_CHECKED_LOAD_CONST_VCALL

@ FS_TYPE_CHECKED_LOAD_CONST_VCALL

Definition:LLVMBitCodes.h:255

llvm::bitc::PNNI_NON_NEG

@ PNNI_NON_NEG

Definition:LLVMBitCodes.h:537

llvm::bitc::IDENTIFICATION_CODE_EPOCH

@ IDENTIFICATION_CODE_EPOCH

Definition:LLVMBitCodes.h:72

llvm::bitc::IDENTIFICATION_CODE_STRING

@ IDENTIFICATION_CODE_STRING

Definition:LLVMBitCodes.h:71

llvm::bitc::CST_CODE_CE_INBOUNDS_GEP

@ CST_CODE_CE_INBOUNDS_GEP

Definition:LLVMBitCodes.h:413

llvm::bitc::CST_CODE_INLINEASM_OLD3

@ CST_CODE_INLINEASM_OLD3

Definition:LLVMBitCodes.h:422

llvm::bitc::CST_CODE_BLOCKADDRESS

@ CST_CODE_BLOCKADDRESS

Definition:LLVMBitCodes.h:414

llvm::bitc::CST_CODE_NO_CFI_VALUE

@ CST_CODE_NO_CFI_VALUE

Definition:LLVMBitCodes.h:425

llvm::bitc::CST_CODE_DATA

@ CST_CODE_DATA

Definition:LLVMBitCodes.h:415

llvm::bitc::CST_CODE_CE_SHUFVEC_EX

@ CST_CODE_CE_SHUFVEC_EX

Definition:LLVMBitCodes.h:412

llvm::bitc::CST_CODE_CE_EXTRACTELT

@ CST_CODE_CE_EXTRACTELT

Definition:LLVMBitCodes.h:406

llvm::bitc::CST_CODE_CE_GEP_OLD

@ CST_CODE_CE_GEP_OLD

Definition:LLVMBitCodes.h:404

llvm::bitc::CST_CODE_CE_BINOP

@ CST_CODE_CE_BINOP

Definition:LLVMBitCodes.h:402

llvm::bitc::CST_CODE_INLINEASM_OLD

@ CST_CODE_INLINEASM_OLD

Definition:LLVMBitCodes.h:410

llvm::bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX_OLD

@ CST_CODE_CE_GEP_WITH_INRANGE_INDEX_OLD

Definition:LLVMBitCodes.h:418

llvm::bitc::CST_CODE_CE_SHUFFLEVEC

@ CST_CODE_CE_SHUFFLEVEC

Definition:LLVMBitCodes.h:408

llvm::bitc::CST_CODE_STRING

@ CST_CODE_STRING

Definition:LLVMBitCodes.h:400

llvm::bitc::CST_CODE_SETTYPE

@ CST_CODE_SETTYPE

Definition:LLVMBitCodes.h:393

llvm::bitc::CST_CODE_UNDEF

@ CST_CODE_UNDEF

Definition:LLVMBitCodes.h:395

llvm::bitc::CST_CODE_NULL

@ CST_CODE_NULL

Definition:LLVMBitCodes.h:394

llvm::bitc::CST_CODE_WIDE_INTEGER

@ CST_CODE_WIDE_INTEGER

Definition:LLVMBitCodes.h:397

llvm::bitc::CST_CODE_CE_GEP

@ CST_CODE_CE_GEP

Definition:LLVMBitCodes.h:431

llvm::bitc::CST_CODE_DSO_LOCAL_EQUIVALENT

@ CST_CODE_DSO_LOCAL_EQUIVALENT

Definition:LLVMBitCodes.h:421

llvm::bitc::CST_CODE_PTRAUTH

@ CST_CODE_PTRAUTH

Definition:LLVMBitCodes.h:432

llvm::bitc::CST_CODE_CE_CMP

@ CST_CODE_CE_CMP

Definition:LLVMBitCodes.h:409

llvm::bitc::CST_CODE_AGGREGATE

@ CST_CODE_AGGREGATE

Definition:LLVMBitCodes.h:399

llvm::bitc::CST_CODE_CE_SELECT

@ CST_CODE_CE_SELECT

Definition:LLVMBitCodes.h:405

llvm::bitc::CST_CODE_CE_INSERTELT

@ CST_CODE_CE_INSERTELT

Definition:LLVMBitCodes.h:407

llvm::bitc::CST_CODE_INLINEASM_OLD2

@ CST_CODE_INLINEASM_OLD2

Definition:LLVMBitCodes.h:416

llvm::bitc::CST_CODE_CE_UNOP

@ CST_CODE_CE_UNOP

Definition:LLVMBitCodes.h:419

llvm::bitc::CST_CODE_CSTRING

@ CST_CODE_CSTRING

Definition:LLVMBitCodes.h:401

llvm::bitc::CST_CODE_FLOAT

@ CST_CODE_FLOAT

Definition:LLVMBitCodes.h:398

llvm::bitc::CST_CODE_CE_GEP_WITH_INRANGE

@ CST_CODE_CE_GEP_WITH_INRANGE

Definition:LLVMBitCodes.h:430

llvm::bitc::CST_CODE_INTEGER

@ CST_CODE_INTEGER

Definition:LLVMBitCodes.h:396

llvm::bitc::CST_CODE_POISON

@ CST_CODE_POISON

Definition:LLVMBitCodes.h:420

llvm::bitc::CST_CODE_CE_CAST

@ CST_CODE_CE_CAST

Definition:LLVMBitCodes.h:403

llvm::bitc::CST_CODE_INLINEASM

@ CST_CODE_INLINEASM

Definition:LLVMBitCodes.h:426

llvm::bitc::GEP_INBOUNDS

@ GEP_INBOUNDS

Definition:LLVMBitCodes.h:553

llvm::bitc::GEP_NUW

@ GEP_NUW

Definition:LLVMBitCodes.h:555

llvm::bitc::GEP_NUSW

@ GEP_NUSW

Definition:LLVMBitCodes.h:554

llvm::bitc::CALL_EXPLICIT_TYPE

@ CALL_EXPLICIT_TYPE

Definition:LLVMBitCodes.h:578

llvm::bitc::CALL_MUSTTAIL

@ CALL_MUSTTAIL

Definition:LLVMBitCodes.h:577

llvm::bitc::CALL_TAIL

@ CALL_TAIL

Definition:LLVMBitCodes.h:575

llvm::bitc::CALL_CCONV

@ CALL_CCONV

Definition:LLVMBitCodes.h:576

llvm::bitc::CALL_FMF

@ CALL_FMF

Definition:LLVMBitCodes.h:580

llvm::bitc::CALL_NOTAIL

@ CALL_NOTAIL

Definition:LLVMBitCodes.h:579

llvm::bitc::VST_CODE_BBENTRY

@ VST_CODE_BBENTRY

Definition:LLVMBitCodes.h:193

llvm::bitc::VST_CODE_ENTRY

@ VST_CODE_ENTRY

Definition:LLVMBitCodes.h:192

llvm::bitc::VST_CODE_FNENTRY

@ VST_CODE_FNENTRY

Definition:LLVMBitCodes.h:194

llvm::bitc::VST_CODE_COMBINED_ENTRY

@ VST_CODE_COMBINED_ENTRY

Definition:LLVMBitCodes.h:196

llvm::bitc::PEO_EXACT

@ PEO_EXACT

Definition:LLVMBitCodes.h:541

llvm::bitc::COMDAT_SELECTION_KIND_LARGEST

@ COMDAT_SELECTION_KIND_LARGEST

Definition:LLVMBitCodes.h:797

llvm::bitc::COMDAT_SELECTION_KIND_ANY

@ COMDAT_SELECTION_KIND_ANY

Definition:LLVMBitCodes.h:795

llvm::bitc::COMDAT_SELECTION_KIND_SAME_SIZE

@ COMDAT_SELECTION_KIND_SAME_SIZE

Definition:LLVMBitCodes.h:799

llvm::bitc::COMDAT_SELECTION_KIND_EXACT_MATCH

@ COMDAT_SELECTION_KIND_EXACT_MATCH

Definition:LLVMBitCodes.h:796

llvm::bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES

@ COMDAT_SELECTION_KIND_NO_DUPLICATES

Definition:LLVMBitCodes.h:798

llvm::bitc::ATTR_KIND_STACK_PROTECT

@ ATTR_KIND_STACK_PROTECT

Definition:LLVMBitCodes.h:715

llvm::bitc::ATTR_KIND_NO_UNWIND

@ ATTR_KIND_NO_UNWIND

Definition:LLVMBitCodes.h:707

llvm::bitc::ATTR_KIND_STACK_PROTECT_STRONG

@ ATTR_KIND_STACK_PROTECT_STRONG

Definition:LLVMBitCodes.h:717

llvm::bitc::ATTR_KIND_SANITIZE_MEMORY

@ ATTR_KIND_SANITIZE_MEMORY

Definition:LLVMBitCodes.h:721

llvm::bitc::ATTR_KIND_SAFESTACK

@ ATTR_KIND_SAFESTACK

Definition:LLVMBitCodes.h:733

llvm::bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE

@ ATTR_KIND_OPTIMIZE_FOR_SIZE

Definition:LLVMBitCodes.h:708

llvm::bitc::ATTR_KIND_SWIFT_ERROR

@ ATTR_KIND_SWIFT_ERROR

Definition:LLVMBitCodes.h:736

llvm::bitc::ATTR_KIND_BYREF

@ ATTR_KIND_BYREF

Definition:LLVMBitCodes.h:758

llvm::bitc::ATTR_KIND_INACCESSIBLEMEM_ONLY

@ ATTR_KIND_INACCESSIBLEMEM_ONLY

Definition:LLVMBitCodes.h:738

llvm::bitc::ATTR_KIND_STRUCT_RET

@ ATTR_KIND_STRUCT_RET

Definition:LLVMBitCodes.h:718

llvm::bitc::ATTR_KIND_MIN_SIZE

@ ATTR_KIND_MIN_SIZE

Definition:LLVMBitCodes.h:695

llvm::bitc::ATTR_KIND_NO_CALLBACK

@ ATTR_KIND_NO_CALLBACK

Definition:LLVMBitCodes.h:760

llvm::bitc::ATTR_KIND_NO_CAPTURE

@ ATTR_KIND_NO_CAPTURE

Definition:LLVMBitCodes.h:700

llvm::bitc::ATTR_KIND_FNRETTHUNK_EXTERN

@ ATTR_KIND_FNRETTHUNK_EXTERN

Definition:LLVMBitCodes.h:773

llvm::bitc::ATTR_KIND_NOFREE

@ ATTR_KIND_NOFREE

Definition:LLVMBitCodes.h:751

llvm::bitc::ATTR_KIND_NO_DIVERGENCE_SOURCE

@ ATTR_KIND_NO_DIVERGENCE_SOURCE

Definition:LLVMBitCodes.h:789

llvm::bitc::ATTR_KIND_SANITIZE_ADDRESS

@ ATTR_KIND_SANITIZE_ADDRESS

Definition:LLVMBitCodes.h:719

llvm::bitc::ATTR_KIND_NO_IMPLICIT_FLOAT

@ ATTR_KIND_NO_IMPLICIT_FLOAT

Definition:LLVMBitCodes.h:702

llvm::bitc::ATTR_KIND_NO_BUILTIN

@ ATTR_KIND_NO_BUILTIN

Definition:LLVMBitCodes.h:699

llvm::bitc::ATTR_KIND_MEMORY

@ ATTR_KIND_MEMORY

Definition:LLVMBitCodes.h:775

llvm::bitc::ATTR_KIND_NO_RECURSE

@ ATTR_KIND_NO_RECURSE

Definition:LLVMBitCodes.h:737

llvm::bitc::ATTR_KIND_DEAD_ON_UNWIND

@ ATTR_KIND_DEAD_ON_UNWIND

Definition:LLVMBitCodes.h:780

llvm::bitc::ATTR_KIND_CONVERGENT

@ ATTR_KIND_CONVERGENT

Definition:LLVMBitCodes.h:732

llvm::bitc::ATTR_KIND_NAKED

@ ATTR_KIND_NAKED

Definition:LLVMBitCodes.h:696

llvm::bitc::ATTR_KIND_RETURNED

@ ATTR_KIND_RETURNED

Definition:LLVMBitCodes.h:711

llvm::bitc::ATTR_KIND_STACK_ALIGNMENT

@ ATTR_KIND_STACK_ALIGNMENT

Definition:LLVMBitCodes.h:714

llvm::bitc::ATTR_KIND_SWIFT_SELF

@ ATTR_KIND_SWIFT_SELF

Definition:LLVMBitCodes.h:735

llvm::bitc::ATTR_KIND_NEST

@ ATTR_KIND_NEST

Definition:LLVMBitCodes.h:697

llvm::bitc::ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY

@ ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY

Definition:LLVMBitCodes.h:739

llvm::bitc::ATTR_KIND_ALLOC_SIZE

@ ATTR_KIND_ALLOC_SIZE

Definition:LLVMBitCodes.h:740

llvm::bitc::ATTR_KIND_STACK_PROTECT_REQ

@ ATTR_KIND_STACK_PROTECT_REQ

Definition:LLVMBitCodes.h:716

llvm::bitc::ATTR_KIND_INLINE_HINT

@ ATTR_KIND_INLINE_HINT

Definition:LLVMBitCodes.h:693

llvm::bitc::ATTR_KIND_NON_NULL

@ ATTR_KIND_NON_NULL

Definition:LLVMBitCodes.h:728

llvm::bitc::ATTR_KIND_NULL_POINTER_IS_VALID

@ ATTR_KIND_NULL_POINTER_IS_VALID

Definition:LLVMBitCodes.h:756

llvm::bitc::ATTR_KIND_SANITIZE_HWADDRESS

@ ATTR_KIND_SANITIZE_HWADDRESS

Definition:LLVMBitCodes.h:744

llvm::bitc::ATTR_KIND_NO_RETURN

@ ATTR_KIND_NO_RETURN

Definition:LLVMBitCodes.h:706

llvm::bitc::ATTR_KIND_MUSTPROGRESS

@ ATTR_KIND_MUSTPROGRESS

Definition:LLVMBitCodes.h:759

llvm::bitc::ATTR_KIND_RETURNS_TWICE

@ ATTR_KIND_RETURNS_TWICE

Definition:LLVMBitCodes.h:712

llvm::bitc::ATTR_KIND_Z_EXT

@ ATTR_KIND_Z_EXT

Definition:LLVMBitCodes.h:723

llvm::bitc::ATTR_KIND_SHADOWCALLSTACK

@ ATTR_KIND_SHADOWCALLSTACK

Definition:LLVMBitCodes.h:747

llvm::bitc::ATTR_KIND_OPT_FOR_FUZZING

@ ATTR_KIND_OPT_FOR_FUZZING

Definition:LLVMBitCodes.h:746

llvm::bitc::ATTR_KIND_COLD

@ ATTR_KIND_COLD

Definition:LLVMBitCodes.h:725

llvm::bitc::ATTR_KIND_WRITABLE

@ ATTR_KIND_WRITABLE

Definition:LLVMBitCodes.h:778

llvm::bitc::ATTR_KIND_SANITIZE_NUMERICAL_STABILITY

@ ATTR_KIND_SANITIZE_NUMERICAL_STABILITY

Definition:LLVMBitCodes.h:782

llvm::bitc::ATTR_KIND_INITIALIZES

@ ATTR_KIND_INITIALIZES

Definition:LLVMBitCodes.h:783

llvm::bitc::ATTR_KIND_ARGMEMONLY

@ ATTR_KIND_ARGMEMONLY

Definition:LLVMBitCodes.h:734

llvm::bitc::ATTR_KIND_ALLOCATED_POINTER

@ ATTR_KIND_ALLOCATED_POINTER

Definition:LLVMBitCodes.h:770

llvm::bitc::ATTR_KIND_DISABLE_SANITIZER_INSTRUMENTATION

@ ATTR_KIND_DISABLE_SANITIZER_INSTRUMENTATION

Definition:LLVMBitCodes.h:767

llvm::bitc::ATTR_KIND_NOUNDEF

@ ATTR_KIND_NOUNDEF

Definition:LLVMBitCodes.h:757

llvm::bitc::ATTR_KIND_SKIP_PROFILE

@ ATTR_KIND_SKIP_PROFILE

Definition:LLVMBitCodes.h:774

llvm::bitc::ATTR_KIND_IMMARG

@ ATTR_KIND_IMMARG

Definition:LLVMBitCodes.h:749

llvm::bitc::ATTR_KIND_ELEMENTTYPE

@ ATTR_KIND_ELEMENTTYPE

Definition:LLVMBitCodes.h:766

llvm::bitc::ATTR_KIND_CORO_ELIDE_SAFE

@ ATTR_KIND_CORO_ELIDE_SAFE

Definition:LLVMBitCodes.h:787

llvm::bitc::ATTR_KIND_ALLOC_KIND

@ ATTR_KIND_ALLOC_KIND

Definition:LLVMBitCodes.h:771

llvm::bitc::ATTR_KIND_BUILTIN

@ ATTR_KIND_BUILTIN

Definition:LLVMBitCodes.h:724

llvm::bitc::ATTR_KIND_NO_MERGE

@ ATTR_KIND_NO_MERGE

Definition:LLVMBitCodes.h:755

llvm::bitc::ATTR_KIND_STRICT_FP

@ ATTR_KIND_STRICT_FP

Definition:LLVMBitCodes.h:743

llvm::bitc::ATTR_KIND_NO_DUPLICATE

@ ATTR_KIND_NO_DUPLICATE

Definition:LLVMBitCodes.h:701

llvm::bitc::ATTR_KIND_ALLOC_ALIGN

@ ATTR_KIND_ALLOC_ALIGN

Definition:LLVMBitCodes.h:769

llvm::bitc::ATTR_KIND_NON_LAZY_BIND

@ ATTR_KIND_NON_LAZY_BIND

Definition:LLVMBitCodes.h:704

llvm::bitc::ATTR_KIND_DEREFERENCEABLE

@ ATTR_KIND_DEREFERENCEABLE

Definition:LLVMBitCodes.h:730

llvm::bitc::ATTR_KIND_READ_NONE

@ ATTR_KIND_READ_NONE

Definition:LLVMBitCodes.h:709

llvm::bitc::ATTR_KIND_S_EXT

@ ATTR_KIND_S_EXT

Definition:LLVMBitCodes.h:713

llvm::bitc::ATTR_KIND_UW_TABLE

@ ATTR_KIND_UW_TABLE

Definition:LLVMBitCodes.h:722

llvm::bitc::ATTR_KIND_BY_VAL

@ ATTR_KIND_BY_VAL

Definition:LLVMBitCodes.h:692

llvm::bitc::ATTR_KIND_OPTIMIZE_NONE

@ ATTR_KIND_OPTIMIZE_NONE

Definition:LLVMBitCodes.h:726

llvm::bitc::ATTR_KIND_NO_EXT

@ ATTR_KIND_NO_EXT

Definition:LLVMBitCodes.h:788

llvm::bitc::ATTR_KIND_WRITEONLY

@ ATTR_KIND_WRITEONLY

Definition:LLVMBitCodes.h:741

llvm::bitc::ATTR_KIND_NO_RED_ZONE

@ ATTR_KIND_NO_RED_ZONE

Definition:LLVMBitCodes.h:705

llvm::bitc::ATTR_KIND_NOCF_CHECK

@ ATTR_KIND_NOCF_CHECK

Definition:LLVMBitCodes.h:745

llvm::bitc::ATTR_KIND_NO_PROFILE

@ ATTR_KIND_NO_PROFILE

Definition:LLVMBitCodes.h:762

llvm::bitc::ATTR_KIND_DEREFERENCEABLE_OR_NULL

@ ATTR_KIND_DEREFERENCEABLE_OR_NULL

Definition:LLVMBitCodes.h:731

llvm::bitc::ATTR_KIND_SANITIZE_REALTIME

@ ATTR_KIND_SANITIZE_REALTIME

Definition:LLVMBitCodes.h:785

llvm::bitc::ATTR_KIND_IN_REG

@ ATTR_KIND_IN_REG

Definition:LLVMBitCodes.h:694

llvm::bitc::ATTR_KIND_IN_ALLOCA

@ ATTR_KIND_IN_ALLOCA

Definition:LLVMBitCodes.h:727

llvm::bitc::ATTR_KIND_READ_ONLY

@ ATTR_KIND_READ_ONLY

Definition:LLVMBitCodes.h:710

llvm::bitc::ATTR_KIND_ALIGNMENT

@ ATTR_KIND_ALIGNMENT

Definition:LLVMBitCodes.h:690

llvm::bitc::ATTR_KIND_SPECULATIVE_LOAD_HARDENING

@ ATTR_KIND_SPECULATIVE_LOAD_HARDENING

Definition:LLVMBitCodes.h:748

llvm::bitc::ATTR_KIND_ALWAYS_INLINE

@ ATTR_KIND_ALWAYS_INLINE

Definition:LLVMBitCodes.h:691

llvm::bitc::ATTR_KIND_NOFPCLASS

@ ATTR_KIND_NOFPCLASS

Definition:LLVMBitCodes.h:776

llvm::bitc::ATTR_KIND_WILLRETURN

@ ATTR_KIND_WILLRETURN

Definition:LLVMBitCodes.h:750

llvm::bitc::ATTR_KIND_RANGE

@ ATTR_KIND_RANGE

Definition:LLVMBitCodes.h:781

llvm::bitc::ATTR_KIND_SANITIZE_TYPE

@ ATTR_KIND_SANITIZE_TYPE

Definition:LLVMBitCodes.h:790

llvm::bitc::ATTR_KIND_PRESPLIT_COROUTINE

@ ATTR_KIND_PRESPLIT_COROUTINE

Definition:LLVMBitCodes.h:772

llvm::bitc::ATTR_KIND_NOSYNC

@ ATTR_KIND_NOSYNC

Definition:LLVMBitCodes.h:752

llvm::bitc::ATTR_KIND_NO_ALIAS

@ ATTR_KIND_NO_ALIAS

Definition:LLVMBitCodes.h:698

llvm::bitc::ATTR_KIND_VSCALE_RANGE

@ ATTR_KIND_VSCALE_RANGE

Definition:LLVMBitCodes.h:763

llvm::bitc::ATTR_KIND_NO_SANITIZE_COVERAGE

@ ATTR_KIND_NO_SANITIZE_COVERAGE

Definition:LLVMBitCodes.h:765

llvm::bitc::ATTR_KIND_JUMP_TABLE

@ ATTR_KIND_JUMP_TABLE

Definition:LLVMBitCodes.h:729

llvm::bitc::ATTR_KIND_SPECULATABLE

@ ATTR_KIND_SPECULATABLE

Definition:LLVMBitCodes.h:742

llvm::bitc::ATTR_KIND_NO_INLINE

@ ATTR_KIND_NO_INLINE

Definition:LLVMBitCodes.h:703

llvm::bitc::ATTR_KIND_HOT

@ ATTR_KIND_HOT

Definition:LLVMBitCodes.h:761

llvm::bitc::ATTR_KIND_SANITIZE_REALTIME_BLOCKING

@ ATTR_KIND_SANITIZE_REALTIME_BLOCKING

Definition:LLVMBitCodes.h:786

llvm::bitc::ATTR_KIND_NO_SANITIZE_BOUNDS

@ ATTR_KIND_NO_SANITIZE_BOUNDS

Definition:LLVMBitCodes.h:768

llvm::bitc::ATTR_KIND_SANITIZE_MEMTAG

@ ATTR_KIND_SANITIZE_MEMTAG

Definition:LLVMBitCodes.h:753

llvm::bitc::ATTR_KIND_CORO_ONLY_DESTROY_WHEN_COMPLETE

@ ATTR_KIND_CORO_ONLY_DESTROY_WHEN_COMPLETE

Definition:LLVMBitCodes.h:779

llvm::bitc::ATTR_KIND_CAPTURES

@ ATTR_KIND_CAPTURES

Definition:LLVMBitCodes.h:791

llvm::bitc::ATTR_KIND_SANITIZE_THREAD

@ ATTR_KIND_SANITIZE_THREAD

Definition:LLVMBitCodes.h:720

llvm::bitc::ATTR_KIND_OPTIMIZE_FOR_DEBUGGING

@ ATTR_KIND_OPTIMIZE_FOR_DEBUGGING

Definition:LLVMBitCodes.h:777

llvm::bitc::ATTR_KIND_PREALLOCATED

@ ATTR_KIND_PREALLOCATED

Definition:LLVMBitCodes.h:754

llvm::bitc::ATTR_KIND_SWIFT_ASYNC

@ ATTR_KIND_SWIFT_ASYNC

Definition:LLVMBitCodes.h:764

llvm::bitc::OBO_NO_SIGNED_WRAP

@ OBO_NO_SIGNED_WRAP

Definition:LLVMBitCodes.h:512

llvm::bitc::OBO_NO_UNSIGNED_WRAP

@ OBO_NO_UNSIGNED_WRAP

Definition:LLVMBitCodes.h:511

llvm::bitc::TIO_NO_UNSIGNED_WRAP

@ TIO_NO_UNSIGNED_WRAP

Definition:LLVMBitCodes.h:518

llvm::bitc::TIO_NO_SIGNED_WRAP

@ TIO_NO_SIGNED_WRAP

Definition:LLVMBitCodes.h:519

llvm::bitc::UNOP_FNEG

@ UNOP_FNEG

Definition:LLVMBitCodes.h:460

llvm::bitc::USELIST_CODE_BB

@ USELIST_CODE_BB

Definition:LLVMBitCodes.h:685

llvm::bitc::USELIST_CODE_DEFAULT

@ USELIST_CODE_DEFAULT

Definition:LLVMBitCodes.h:684

llvm::bitc::SYNC_SCOPE_NAMES_BLOCK_ID

@ SYNC_SCOPE_NAMES_BLOCK_ID

Definition:LLVMBitCodes.h:65

llvm::bitc::PARAMATTR_BLOCK_ID

@ PARAMATTR_BLOCK_ID

Definition:LLVMBitCodes.h:33

llvm::bitc::TYPE_BLOCK_ID_NEW

@ TYPE_BLOCK_ID_NEW

Definition:LLVMBitCodes.h:48

llvm::bitc::MODULE_BLOCK_ID

@ MODULE_BLOCK_ID

Definition:LLVMBitCodes.h:30

llvm::bitc::STRTAB_BLOCK_ID

@ STRTAB_BLOCK_ID

Definition:LLVMBitCodes.h:59

llvm::bitc::SYMTAB_BLOCK_ID

@ SYMTAB_BLOCK_ID

Definition:LLVMBitCodes.h:63

llvm::bitc::CONSTANTS_BLOCK_ID

@ CONSTANTS_BLOCK_ID

Definition:LLVMBitCodes.h:36

llvm::bitc::PARAMATTR_GROUP_BLOCK_ID

@ PARAMATTR_GROUP_BLOCK_ID

Definition:LLVMBitCodes.h:34

llvm::bitc::METADATA_KIND_BLOCK_ID

@ METADATA_KIND_BLOCK_ID

Definition:LLVMBitCodes.h:57

llvm::bitc::IDENTIFICATION_BLOCK_ID

@ IDENTIFICATION_BLOCK_ID

Definition:LLVMBitCodes.h:42

llvm::bitc::GLOBALVAL_SUMMARY_BLOCK_ID

@ GLOBALVAL_SUMMARY_BLOCK_ID

Definition:LLVMBitCodes.h:53

llvm::bitc::METADATA_ATTACHMENT_ID

@ METADATA_ATTACHMENT_ID

Definition:LLVMBitCodes.h:46

llvm::bitc::METADATA_BLOCK_ID

@ METADATA_BLOCK_ID

Definition:LLVMBitCodes.h:45

llvm::bitc::FUNCTION_BLOCK_ID

@ FUNCTION_BLOCK_ID

Definition:LLVMBitCodes.h:37

llvm::bitc::FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID

@ FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID

Definition:LLVMBitCodes.h:61

llvm::bitc::MODULE_STRTAB_BLOCK_ID

@ MODULE_STRTAB_BLOCK_ID

Definition:LLVMBitCodes.h:52

llvm::bitc::VALUE_SYMTAB_BLOCK_ID

@ VALUE_SYMTAB_BLOCK_ID

Definition:LLVMBitCodes.h:44

llvm::bitc::OPERAND_BUNDLE_TAGS_BLOCK_ID

@ OPERAND_BUNDLE_TAGS_BLOCK_ID

Definition:LLVMBitCodes.h:55

llvm::bitc::USELIST_BLOCK_ID

@ USELIST_BLOCK_ID

Definition:LLVMBitCodes.h:50

llvm::bitc::OB_METADATA

@ OB_METADATA

Definition:LLVMBitCodes.h:548

llvm::bitc::CAST_BITCAST

@ CAST_BITCAST

Definition:LLVMBitCodes.h:451

llvm::bitc::CAST_UITOFP

@ CAST_UITOFP

Definition:LLVMBitCodes.h:445

llvm::bitc::CAST_FPTOSI

@ CAST_FPTOSI

Definition:LLVMBitCodes.h:444

llvm::bitc::CAST_FPTOUI

@ CAST_FPTOUI

Definition:LLVMBitCodes.h:443

llvm::bitc::CAST_SITOFP

@ CAST_SITOFP

Definition:LLVMBitCodes.h:446

llvm::bitc::CAST_TRUNC

@ CAST_TRUNC

Definition:LLVMBitCodes.h:440

llvm::bitc::CAST_INTTOPTR

@ CAST_INTTOPTR

Definition:LLVMBitCodes.h:450

llvm::bitc::CAST_SEXT

@ CAST_SEXT

Definition:LLVMBitCodes.h:442

llvm::bitc::CAST_ZEXT

@ CAST_ZEXT

Definition:LLVMBitCodes.h:441

llvm::bitc::CAST_FPEXT

@ CAST_FPEXT

Definition:LLVMBitCodes.h:448

llvm::bitc::CAST_ADDRSPACECAST

@ CAST_ADDRSPACECAST

Definition:LLVMBitCodes.h:452

llvm::bitc::CAST_FPTRUNC

@ CAST_FPTRUNC

Definition:LLVMBitCodes.h:447

llvm::bitc::CAST_PTRTOINT

@ CAST_PTRTOINT

Definition:LLVMBitCodes.h:449

llvm::bitc::BLOCKINFO_BLOCK_ID

@ BLOCKINFO_BLOCK_ID

BLOCKINFO_BLOCK is used to define metadata about blocks, for example, standard abbrevs that should be...

Definition:BitCodeEnums.h:69

llvm::bitc::BlockIDWidth

@ BlockIDWidth

Definition:BitCodeEnums.h:37

llvm::bitc::MODULE_CODE_FUNCTION

@ MODULE_CODE_FUNCTION

Definition:LLVMBitCodes.h:100

llvm::bitc::MODULE_CODE_VERSION

@ MODULE_CODE_VERSION

Definition:LLVMBitCodes.h:85

llvm::bitc::MODULE_CODE_SOURCE_FILENAME

@ MODULE_CODE_SOURCE_FILENAME

Definition:LLVMBitCodes.h:116

llvm::bitc::MODULE_CODE_SECTIONNAME

@ MODULE_CODE_SECTIONNAME

Definition:LLVMBitCodes.h:89

llvm::bitc::MODULE_CODE_TRIPLE

@ MODULE_CODE_TRIPLE

Definition:LLVMBitCodes.h:86

llvm::bitc::MODULE_CODE_DATALAYOUT

@ MODULE_CODE_DATALAYOUT

Definition:LLVMBitCodes.h:87

llvm::bitc::MODULE_CODE_GLOBALVAR

@ MODULE_CODE_GLOBALVAR

Definition:LLVMBitCodes.h:96

llvm::bitc::MODULE_CODE_ALIAS_OLD

@ MODULE_CODE_ALIAS_OLD

Definition:LLVMBitCodes.h:103

llvm::bitc::MODULE_CODE_VSTOFFSET

@ MODULE_CODE_VSTOFFSET

Definition:LLVMBitCodes.h:108

llvm::bitc::MODULE_CODE_IFUNC

@ MODULE_CODE_IFUNC

Definition:LLVMBitCodes.h:122

llvm::bitc::MODULE_CODE_ALIAS

@ MODULE_CODE_ALIAS

Definition:LLVMBitCodes.h:111

llvm::bitc::MODULE_CODE_GCNAME

@ MODULE_CODE_GCNAME

Definition:LLVMBitCodes.h:105

llvm::bitc::MODULE_CODE_DEPLIB

@ MODULE_CODE_DEPLIB

Definition:LLVMBitCodes.h:92

llvm::bitc::MODULE_CODE_ASM

@ MODULE_CODE_ASM

Definition:LLVMBitCodes.h:88

llvm::bitc::MODULE_CODE_HASH

@ MODULE_CODE_HASH

Definition:LLVMBitCodes.h:119

llvm::bitc::MODULE_CODE_COMDAT

@ MODULE_CODE_COMDAT

Definition:LLVMBitCodes.h:106

llvm::bitc::FUNC_CODE_INST_ATOMICRMW_OLD

@ FUNC_CODE_INST_ATOMICRMW_OLD

Definition:LLVMBitCodes.h:636

llvm::bitc::FUNC_CODE_INST_CATCHRET

@ FUNC_CODE_INST_CATCHRET

Definition:LLVMBitCodes.h:654

llvm::bitc::FUNC_CODE_INST_LANDINGPAD

@ FUNC_CODE_INST_LANDINGPAD

Definition:LLVMBitCodes.h:652

llvm::bitc::FUNC_CODE_INST_EXTRACTVAL

@ FUNC_CODE_INST_EXTRACTVAL

Definition:LLVMBitCodes.h:617

llvm::bitc::FUNC_CODE_INST_CATCHPAD

@ FUNC_CODE_INST_CATCHPAD

Definition:LLVMBitCodes.h:655

llvm::bitc::FUNC_CODE_INST_RESUME

@ FUNC_CODE_INST_RESUME

Definition:LLVMBitCodes.h:639

llvm::bitc::FUNC_CODE_INST_CMP2

@ FUNC_CODE_INST_CMP2

Definition:LLVMBitCodes.h:621

llvm::bitc::FUNC_CODE_INST_FENCE

@ FUNC_CODE_INST_FENCE

Definition:LLVMBitCodes.h:632

llvm::bitc::FUNC_CODE_INST_CALLBR

@ FUNC_CODE_INST_CALLBR

Definition:LLVMBitCodes.h:663

llvm::bitc::FUNC_CODE_INST_CATCHSWITCH

@ FUNC_CODE_INST_CATCHSWITCH

Definition:LLVMBitCodes.h:657

llvm::bitc::FUNC_CODE_INST_BR

@ FUNC_CODE_INST_BR

Definition:LLVMBitCodes.h:598

llvm::bitc::FUNC_CODE_INST_INBOUNDS_GEP_OLD

@ FUNC_CODE_INST_INBOUNDS_GEP_OLD

Definition:LLVMBitCodes.h:624

llvm::bitc::FUNC_CODE_INST_VSELECT

@ FUNC_CODE_INST_VSELECT

Definition:LLVMBitCodes.h:623

llvm::bitc::FUNC_CODE_INST_GEP_OLD

@ FUNC_CODE_INST_GEP_OLD

Definition:LLVMBitCodes.h:590

llvm::bitc::FUNC_CODE_INST_GEP

@ FUNC_CODE_INST_GEP

Definition:LLVMBitCodes.h:646

llvm::bitc::FUNC_CODE_INST_STOREATOMIC_OLD

@ FUNC_CODE_INST_STOREATOMIC_OLD

Definition:LLVMBitCodes.h:644

llvm::bitc::FUNC_CODE_INST_CLEANUPRET

@ FUNC_CODE_INST_CLEANUPRET

Definition:LLVMBitCodes.h:653

llvm::bitc::FUNC_CODE_INST_LANDINGPAD_OLD

@ FUNC_CODE_INST_LANDINGPAD_OLD

Definition:LLVMBitCodes.h:640

llvm::bitc::FUNC_CODE_DEBUG_RECORD_VALUE

@ FUNC_CODE_DEBUG_RECORD_VALUE

Definition:LLVMBitCodes.h:671

llvm::bitc::FUNC_CODE_INST_LOADATOMIC

@ FUNC_CODE_INST_LOADATOMIC

Definition:LLVMBitCodes.h:642

llvm::bitc::FUNC_CODE_DEBUG_RECORD_ASSIGN

@ FUNC_CODE_DEBUG_RECORD_ASSIGN

Definition:LLVMBitCodes.h:675

llvm::bitc::FUNC_CODE_INST_LOAD

@ FUNC_CODE_INST_LOAD

Definition:LLVMBitCodes.h:608

llvm::bitc::FUNC_CODE_INST_STOREATOMIC

@ FUNC_CODE_INST_STOREATOMIC

Definition:LLVMBitCodes.h:648

llvm::bitc::FUNC_CODE_INST_ATOMICRMW

@ FUNC_CODE_INST_ATOMICRMW

Definition:LLVMBitCodes.h:666

llvm::bitc::FUNC_CODE_INST_BINOP

@ FUNC_CODE_INST_BINOP

Definition:LLVMBitCodes.h:588

llvm::bitc::FUNC_CODE_INST_STORE

@ FUNC_CODE_INST_STORE

Definition:LLVMBitCodes.h:647

llvm::bitc::FUNC_CODE_DEBUG_LOC_AGAIN

@ FUNC_CODE_DEBUG_LOC_AGAIN

Definition:LLVMBitCodes.h:627

llvm::bitc::FUNC_CODE_INST_EXTRACTELT

@ FUNC_CODE_INST_EXTRACTELT

Definition:LLVMBitCodes.h:592

llvm::bitc::FUNC_CODE_INST_INDIRECTBR

@ FUNC_CODE_INST_INDIRECTBR

Definition:LLVMBitCodes.h:625

llvm::bitc::FUNC_CODE_INST_INVOKE

@ FUNC_CODE_INST_INVOKE

Definition:LLVMBitCodes.h:600

llvm::bitc::FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE

@ FUNC_CODE_DEBUG_RECORD_VALUE_SIMPLE

Definition:LLVMBitCodes.h:678

llvm::bitc::FUNC_CODE_INST_INSERTVAL

@ FUNC_CODE_INST_INSERTVAL

Definition:LLVMBitCodes.h:618

llvm::bitc::FUNC_CODE_DECLAREBLOCKS

@ FUNC_CODE_DECLAREBLOCKS

Definition:LLVMBitCodes.h:586

llvm::bitc::FUNC_CODE_DEBUG_RECORD_LABEL

@ FUNC_CODE_DEBUG_RECORD_LABEL

Definition:LLVMBitCodes.h:680

llvm::bitc::FUNC_CODE_INST_SWITCH

@ FUNC_CODE_INST_SWITCH

Definition:LLVMBitCodes.h:599

llvm::bitc::FUNC_CODE_INST_PHI

@ FUNC_CODE_INST_PHI

Definition:LLVMBitCodes.h:604

llvm::bitc::FUNC_CODE_INST_RET

@ FUNC_CODE_INST_RET

Definition:LLVMBitCodes.h:597

llvm::bitc::FUNC_CODE_INST_CALL

@ FUNC_CODE_INST_CALL

Definition:LLVMBitCodes.h:629

llvm::bitc::FUNC_CODE_INST_ALLOCA

@ FUNC_CODE_INST_ALLOCA

Definition:LLVMBitCodes.h:607

llvm::bitc::FUNC_CODE_INST_INSERTELT

@ FUNC_CODE_INST_INSERTELT

Definition:LLVMBitCodes.h:593

llvm::bitc::FUNC_CODE_INST_SELECT

@ FUNC_CODE_INST_SELECT

Definition:LLVMBitCodes.h:591

llvm::bitc::FUNC_CODE_BLOCKADDR_USERS

@ FUNC_CODE_BLOCKADDR_USERS

Definition:LLVMBitCodes.h:669

llvm::bitc::FUNC_CODE_INST_CLEANUPPAD

@ FUNC_CODE_INST_CLEANUPPAD

Definition:LLVMBitCodes.h:656

llvm::bitc::FUNC_CODE_INST_SHUFFLEVEC

@ FUNC_CODE_INST_SHUFFLEVEC

Definition:LLVMBitCodes.h:594

llvm::bitc::FUNC_CODE_INST_UNOP

@ FUNC_CODE_INST_UNOP

Definition:LLVMBitCodes.h:662

llvm::bitc::FUNC_CODE_INST_STORE_OLD

@ FUNC_CODE_INST_STORE_OLD

Definition:LLVMBitCodes.h:615

llvm::bitc::FUNC_CODE_INST_VAARG

@ FUNC_CODE_INST_VAARG

Definition:LLVMBitCodes.h:611

llvm::bitc::FUNC_CODE_INST_FREEZE

@ FUNC_CODE_INST_FREEZE

Definition:LLVMBitCodes.h:665

llvm::bitc::FUNC_CODE_INST_CMPXCHG

@ FUNC_CODE_INST_CMPXCHG

Definition:LLVMBitCodes.h:649

llvm::bitc::FUNC_CODE_INST_UNREACHABLE

@ FUNC_CODE_INST_UNREACHABLE

Definition:LLVMBitCodes.h:602

llvm::bitc::FUNC_CODE_INST_CAST

@ FUNC_CODE_INST_CAST

Definition:LLVMBitCodes.h:589

llvm::bitc::FUNC_CODE_INST_CMPXCHG_OLD

@ FUNC_CODE_INST_CMPXCHG_OLD

Definition:LLVMBitCodes.h:633

llvm::bitc::FUNC_CODE_DEBUG_LOC

@ FUNC_CODE_DEBUG_LOC

Definition:LLVMBitCodes.h:631

llvm::bitc::FUNC_CODE_DEBUG_RECORD_DECLARE

@ FUNC_CODE_DEBUG_RECORD_DECLARE

Definition:LLVMBitCodes.h:673

llvm::bitc::FUNC_CODE_OPERAND_BUNDLE

@ FUNC_CODE_OPERAND_BUNDLE

Definition:LLVMBitCodes.h:661

llvm::bitc::FUNC_CODE_INST_CMP

@ FUNC_CODE_INST_CMP

Definition:LLVMBitCodes.h:595

llvm::bitc::STRTAB_BLOB

@ STRTAB_BLOB

Definition:LLVMBitCodes.h:803

llvm::bitc::ICMP_SAME_SIGN

@ ICMP_SAME_SIGN

Definition:LLVMBitCodes.h:560

llvm::bitc::PDI_DISJOINT

@ PDI_DISJOINT

Definition:LLVMBitCodes.h:545

llvm::bitc::NoNaNs

@ NoNaNs

Definition:LLVMBitCodes.h:527

llvm::bitc::ApproxFunc

@ ApproxFunc

Definition:LLVMBitCodes.h:532

llvm::bitc::AllowContract

@ AllowContract

Definition:LLVMBitCodes.h:531

llvm::bitc::NoSignedZeros

@ NoSignedZeros

Definition:LLVMBitCodes.h:529

llvm::bitc::NoInfs

@ NoInfs

Definition:LLVMBitCodes.h:528

llvm::bitc::UnsafeAlgebra

@ UnsafeAlgebra

Definition:LLVMBitCodes.h:526

llvm::bitc::AllowReassoc

@ AllowReassoc

Definition:LLVMBitCodes.h:533

llvm::bitc::AllowReciprocal

@ AllowReciprocal

Definition:LLVMBitCodes.h:530

llvm::bitc::OPERAND_BUNDLE_TAG

@ OPERAND_BUNDLE_TAG

Definition:LLVMBitCodes.h:183

llvm::bitc::PARAMATTR_CODE_ENTRY_OLD

@ PARAMATTR_CODE_ENTRY_OLD

Definition:LLVMBitCodes.h:128

llvm::bitc::PARAMATTR_GRP_CODE_ENTRY

@ PARAMATTR_GRP_CODE_ENTRY

Definition:LLVMBitCodes.h:131

llvm::bitc::PARAMATTR_CODE_ENTRY

@ PARAMATTR_CODE_ENTRY

Definition:LLVMBitCodes.h:130

llvm::bitc::SYNC_SCOPE_NAME

@ SYNC_SCOPE_NAME

Definition:LLVMBitCodes.h:187

llvm::bitc::SYMTAB_BLOB

@ SYMTAB_BLOB

Definition:LLVMBitCodes.h:807

llvm::bitc::MST_CODE_HASH

@ MST_CODE_HASH

Definition:LLVMBitCodes.h:202

llvm::bitc::MST_CODE_ENTRY

@ MST_CODE_ENTRY

Definition:LLVMBitCodes.h:201

llvm::bitc::BINOP_SHL

@ BINOP_SHL

Definition:LLVMBitCodes.h:475

llvm::bitc::BINOP_UREM

@ BINOP_UREM

Definition:LLVMBitCodes.h:473

llvm::bitc::BINOP_ADD

@ BINOP_ADD

Definition:LLVMBitCodes.h:468

llvm::bitc::BINOP_UDIV

@ BINOP_UDIV

Definition:LLVMBitCodes.h:471

llvm::bitc::BINOP_ASHR

@ BINOP_ASHR

Definition:LLVMBitCodes.h:477

llvm::bitc::BINOP_OR

@ BINOP_OR

Definition:LLVMBitCodes.h:479

llvm::bitc::BINOP_LSHR

@ BINOP_LSHR

Definition:LLVMBitCodes.h:476

llvm::bitc::BINOP_MUL

@ BINOP_MUL

Definition:LLVMBitCodes.h:470

llvm::bitc::BINOP_SDIV

@ BINOP_SDIV

Definition:LLVMBitCodes.h:472

llvm::bitc::BINOP_XOR

@ BINOP_XOR

Definition:LLVMBitCodes.h:480

llvm::bitc::BINOP_SREM

@ BINOP_SREM

Definition:LLVMBitCodes.h:474

llvm::bitc::BINOP_AND

@ BINOP_AND

Definition:LLVMBitCodes.h:478

llvm::bitc::BINOP_SUB

@ BINOP_SUB

Definition:LLVMBitCodes.h:469

llvm::bitc::ORDERING_ACQUIRE

@ ORDERING_ACQUIRE

Definition:LLVMBitCodes.h:567

llvm::bitc::ORDERING_ACQREL

@ ORDERING_ACQREL

Definition:LLVMBitCodes.h:569

llvm::bitc::ORDERING_RELEASE

@ ORDERING_RELEASE

Definition:LLVMBitCodes.h:568

llvm::bitc::ORDERING_NOTATOMIC

@ ORDERING_NOTATOMIC

Definition:LLVMBitCodes.h:564

llvm::bitc::ORDERING_UNORDERED

@ ORDERING_UNORDERED

Definition:LLVMBitCodes.h:565

llvm::bitc::ORDERING_SEQCST

@ ORDERING_SEQCST

Definition:LLVMBitCodes.h:570

llvm::bitc::ORDERING_MONOTONIC

@ ORDERING_MONOTONIC

Definition:LLVMBitCodes.h:566

llvm::cl::Hidden

@ Hidden

Definition:CommandLine.h:137

llvm::cl::init

initializer< Ty > init(const Ty &Val)

Definition:CommandLine.h:443

llvm::cl::Prefix

@ Prefix

Definition:CommandLine.h:158

llvm::codeview::EncodedFramePtrReg::BasePtr

@ BasePtr

llvm::ctx_profile::GUID

uint64_t GUID

Definition:CtxInstrContextNode.h:66

llvm::dwarf::Index

Index

Definition:Dwarf.h:882

llvm::jitlink::Linkage

Linkage

Describes symbol linkage. This can be used to resolve definition clashes.

Definition:JITLink.h:395

llvm::jitlink::Scope

Scope

Defines the scope in which this symbol should be visible: Default – Visible in the public interface o...

Definition:JITLink.h:412

llvm::lltok::Kind

Kind

Definition:LLToken.h:18

llvm::logicalview::LVScopeKind::IsArray

@ IsArray

llvm::logicalview::LVSortMode::Line

@ Line

llvm::memprof::Meta