Lines Matching full:record
172 /// Convert a string from a record into an std::string, return true on failure.
174 static bool convertToString(ArrayRef<uint64_t> Record, unsigned Idx,
176 if (Idx > Record.size())
179 Result.append(Record.begin() + Idx, Record.end());
200 SmallVector<uint64_t, 64> Record;
215 case BitstreamEntry::Record:
220 // Read a record.
221 Record.clear();
222 Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
229 convertToString(Record, 0, ProducerIdentification);
232 unsigned epoch = (unsigned)Record[0];
267 case BitstreamEntry::Record:
279 SmallVector<uint64_t, 64> Record;
294 case BitstreamEntry::Record:
299 // Read a record.
300 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
308 if (convertToString(Record, 0, S))
309 return error("Invalid section name record");
318 Record.clear();
346 case BitstreamEntry::Record:
358 SmallVector<uint64_t, 64> Record;
375 case BitstreamEntry::Record:
380 // Read a record.
381 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
388 if (convertToString(Record, 0, S))
389 return error("Invalid triple record");
394 Record.clear();
423 case BitstreamEntry::Record:
449 Expected<unsigned> parseVersionRecord(ArrayRef<uint64_t> Record);
452 /// and return the referenced string and the rest of the record. Otherwise
453 /// just return the record itself.
455 readNameFromStrtab(ArrayRef<uint64_t> Record);
476 BitcodeReaderBase::parseVersionRecord(ArrayRef<uint64_t> Record) {
477 if (Record.empty())
478 return error("Invalid version record");
479 unsigned ModuleVersion = Record[0];
487 BitcodeReaderBase::readNameFromStrtab(ArrayRef<uint64_t> Record) {
489 return {"", Record};
490 // Invalid reference. Let the caller complain about the record being empty.
491 if (Record[0] + Record[1] > Strtab.size())
493 return {StringRef(Strtab.data() + Record[0], Record[1]), Record.slice(2)};
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
769 bool getValueTypePair(const SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
772 if (Slot == Record.size()) return true;
773 unsigned ValNo = (unsigned)Record[Slot++];
786 if (Slot == Record.size())
789 TypeID = (unsigned)Record[Slot++];
795 bool getValueOrMetadata(const SmallVectorImpl<uint64_t> &Record,
798 if (Slot == Record.size())
800 unsigned ValID = Record[Slot++];
803 return getValueTypePair(Record, --Slot, InstNum, ResVal, TypeId,
806 if (Slot == Record.size())
808 unsigned ValNo = InstNum - (unsigned)Record[Slot++];
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
816 bool popValue(const SmallVectorImpl<uint64_t> &Record, unsigned &Slot,
819 if (getValue(Record, Slot, InstNum, Ty, TyID, ResVal, ConstExprInsertBB))
821 // All values currently take a single record slot.
827 bool getValue(const SmallVectorImpl<uint64_t> &Record, unsigned Slot,
830 ResVal = getValue(Record, Slot, InstNum, Ty, TyID, ConstExprInsertBB);
836 Value *getValue(const SmallVectorImpl<uint64_t> &Record, unsigned Slot,
839 if (Slot == Record.size()) return nullptr;
840 unsigned ValNo = (unsigned)Record[Slot];
848 Value *getValueSigned(const SmallVectorImpl<uint64_t> &Record, unsigned Slot,
851 if (Slot == Record.size()) return nullptr;
852 unsigned ValNo = (unsigned)decodeSignRotatedValue(Record[Slot]);
859 Expected<ConstantRange> readConstantRange(ArrayRef<uint64_t> Record,
862 if (Record.size() - OpNum < 2)
865 unsigned LowerActiveWords = Record[OpNum];
866 unsigned UpperActiveWords = Record[OpNum++] >> 32;
867 if (Record.size() - OpNum < LowerActiveWords + UpperActiveWords)
870 readWideAPInt(ArrayRef(&Record[OpNum], LowerActiveWords), BitWidth);
873 readWideAPInt(ArrayRef(&Record[OpNum], UpperActiveWords), BitWidth);
877 int64_t Start = BitcodeReader::decodeSignRotatedValue(Record[OpNum++]);
878 int64_t End = BitcodeReader::decodeSignRotatedValue(Record[OpNum++]);
885 readBitWidthAndConstantRange(ArrayRef<uint64_t> Record, unsigned &OpNum) {
886 if (Record.size() - OpNum < 1)
888 unsigned BitWidth = Record[OpNum++];
889 return readConstantRange(Record, OpNum, BitWidth);
905 Error parseComdatRecord(ArrayRef<uint64_t> Record);
906 Error parseGlobalVarRecord(ArrayRef<uint64_t> Record);
907 Error parseFunctionRecord(ArrayRef<uint64_t> Record);
909 ArrayRef<uint64_t> Record);
918 Expected<Value *> recordValue(SmallVectorImpl<uint64_t> &Record,
921 ArrayRef<uint64_t> Record);
954 /// Set to the offset of the VST recorded in the MODULE_CODE_VSTOFFSET record.
975 /// Original source file name recorded in a bitcode record.
986 /// Saves the stack ids from the STACK_IDS record to consult when adding stack
1009 SmallVector<ValueInfo, 0> makeRefList(ArrayRef<uint64_t> Record);
1011 makeCallList(ArrayRef<uint64_t> Record, bool IsOldProfileFormat,
1015 void parseTypeIdCompatibleVtableSummaryRecord(ArrayRef<uint64_t> Record);
1016 void parseTypeIdCompatibleVtableInfo(ArrayRef<uint64_t> Record, size_t &Slot,
1019 parseParamAccesses(ArrayRef<uint64_t> Record);
1020 SmallVector<unsigned> parseAllocInfoContext(ArrayRef<uint64_t> Record,
2005 SmallVector<uint64_t, 64> Record;
2022 case BitstreamEntry::Record:
2027 // Read a record.
2028 Record.clear();
2029 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
2037 if (Record.size() & 1)
2038 return error("Invalid parameter attribute record");
2040 for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
2042 decodeLLVMAttributesForBitcode(B, Record[i+1], Record[i]);
2043 Attrs.push_back(AttributeList::get(Context, Record[i], B));
2050 for (uint64_t Val : Record)
2311 SmallVector<uint64_t, 64> Record;
2326 case BitstreamEntry::Record:
2331 // Read a record.
2332 Record.clear();
2333 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
2340 if (Record.size() < 3)
2341 return error("Invalid grp record");
2343 uint64_t GrpID = Record[0];
2344 uint64_t Idx = Record[1]; // Index of the object this attribute refers to.
2348 for (unsigned i = 2, e = Record.size(); i != e; ++i) {
2349 if (Record[i] == 0) { // Enum attribute
2351 uint64_t EncodedKind = Record[++i];
2379 } else if (Record[i] == 1) { // Integer attribute
2381 if (Error Err = parseAttrKind(Record[++i], &Kind))
2386 B.addAlignmentAttr(Record[++i]);
2388 B.addStackAlignmentAttr(Record[++i]);
2390 B.addDereferenceableAttr(Record[++i]);
2392 B.addDereferenceableOrNullAttr(Record[++i]);
2394 B.addAllocSizeAttrFromRawRepr(Record[++i]);
2396 B.addVScaleRangeAttrFromRawRepr(Record[++i]);
2398 B.addUWTableAttr(UWTableKind(Record[++i]));
2400 B.addAllocKindAttr(static_cast<AllocFnKind>(Record[++i]));
2402 B.addMemoryAttr(MemoryEffects::createFromIntValue(Record[++i]));
2404 B.addCapturesAttr(CaptureInfo::createFromIntValue(Record[++i]));
2407 static_cast<FPClassTest>(Record[++i] & fcAllFlags));
2408 } else if (Record[i] == 3 || Record[i] == 4) { // String attribute
2409 bool HasValue = (Record[i++] == 4);
2413 while (Record[i] != 0 && i != e)
2414 KindStr += Record[i++];
2415 assert(Record[i] == 0 && "Kind string not null terminated");
2420 while (Record[i] != 0 && i != e)
2421 ValStr += Record[i++];
2422 assert(Record[i] == 0 && "Value string not null terminated");
2426 } else if (Record[i] == 5 || Record[i] == 6) {
2427 bool HasType = Record[i] == 6;
2429 if (Error Err = parseAttrKind(Record[++i], &Kind))
2434 B.addTypeAttr(Kind, HasType ? getTypeByID(Record[++i]) : nullptr);
2435 } else if (Record[i] == 7) {
2439 if (Error Err = parseAttrKind(Record[i++], &Kind))
2445 readBitWidthAndConstantRange(Record, i);
2451 } else if (Record[i] == 8) {
2455 if (Error Err = parseAttrKind(Record[i++], &Kind))
2463 unsigned RangeSize = Record[i++];
2464 unsigned BitWidth = Record[i++];
2467 readConstantRange(Record, i, BitWidth);
2504 SmallVector<uint64_t, 64> Record;
2524 case BitstreamEntry::Record:
2529 // Read a record.
2530 Record.clear();
2533 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
2542 if (Record.empty())
2543 return error("Invalid numentry record");
2544 TypeList.resize(Record[0]);
2588 if (Record.empty())
2589 return error("Invalid integer record");
2591 uint64_t NumBits = Record[0];
2600 if (Record.empty())
2601 return error("Invalid pointer record");
2603 if (Record.size() == 2)
2604 AddressSpace = Record[1];
2605 ResultTy = getTypeByID(Record[0]);
2609 ContainedIDs.push_back(Record[0]);
2614 if (Record.size() != 1)
2615 return error("Invalid opaque pointer record");
2616 unsigned AddressSpace = Record[0];
2623 if (Record.size() < 3)
2624 return error("Invalid function record");
2626 for (unsigned i = 3, e = Record.size(); i != e; ++i) {
2627 if (Type *T = getTypeByID(Record[i]))
2633 ResultTy = getTypeByID(Record[2]);
2634 if (!ResultTy || ArgTys.size() < Record.size()-3)
2637 ContainedIDs.append(Record.begin() + 2, Record.end());
2638 ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
2643 if (Record.size() < 2)
2644 return error("Invalid function record");
2646 for (unsigned i = 2, e = Record.size(); i != e; ++i) {
2647 if (Type *T = getTypeByID(Record[i])) {
2656 ResultTy = getTypeByID(Record[1]);
2657 if (!ResultTy || ArgTys.size() < Record.size()-2)
2660 ContainedIDs.append(Record.begin() + 1, Record.end());
2661 ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
2665 if (Record.empty())
2666 return error("Invalid anon struct record");
2668 for (unsigned i = 1, e = Record.size(); i != e; ++i) {
2669 if (Type *T = getTypeByID(Record[i]))
2674 if (EltTys.size() != Record.size()-1)
2676 ContainedIDs.append(Record.begin() + 1, Record.end());
2677 ResultTy = StructType::get(Context, EltTys, Record[0]);
2681 if (convertToString(Record, 0, TypeName))
2682 return error("Invalid struct name record");
2686 if (Record.empty())
2687 return error("Invalid named struct record");
2702 for (unsigned i = 1, e = Record.size(); i != e; ++i) {
2703 if (Type *T = getTypeByID(Record[i]))
2708 if (EltTys.size() != Record.size()-1)
2709 return error("Invalid named struct record");
2710 if (auto E = Res->setBodyOrError(EltTys, Record[0]))
2712 ContainedIDs.append(Record.begin() + 1, Record.end());
2717 if (Record.size() != 1)
2718 return error("Invalid opaque type record");
2735 if (Record.size() < 1)
2736 return error("Invalid target extension type record");
2741 if (Record[0] >= Record.size())
2744 unsigned NumTys = Record[0];
2748 if (Type *T = getTypeByID(Record[i + 1]))
2754 for (unsigned i = NumTys + 1, e = Record.size(); i < e; i++) {
2755 if (Record[i] > UINT_MAX)
2757 IntParams.push_back(Record[i]);
2768 if (Record.size() < 2)
2769 return error("Invalid array type record");
2770 ResultTy = getTypeByID(Record[1]);
2773 ContainedIDs.push_back(Record[1]);
2774 ResultTy = ArrayType::get(ResultTy, Record[0]);
2778 if (Record.size() < 2)
2779 return error("Invalid vector type record");
2780 if (Record[0] == 0)
2782 ResultTy = getTypeByID(Record[1]);
2785 bool Scalable = Record.size() > 2 ? Record[2] : false;
2786 ContainedIDs.push_back(Record[1]);
2787 ResultTy = VectorType::get(ResultTy, Record[0], Scalable);
2811 SmallVector<uint64_t, 64> Record;
2825 case BitstreamEntry::Record:
2832 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
2836 return error("Invalid operand bundle record");
2840 if (convertToString(Record, 0, BundleTags.back()))
2841 return error("Invalid operand bundle record");
2842 Record.clear();
2853 SmallVector<uint64_t, 64> Record;
2868 case BitstreamEntry::Record:
2876 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
2880 return error("Invalid sync scope record");
2883 if (convertToString(Record, 0, SSN))
2884 return error("Invalid sync scope record");
2887 Record.clear();
2891 /// Associate a value with its name from the given index in the provided record.
2892 Expected<Value *> BitcodeReader::recordValue(SmallVectorImpl<uint64_t> &Record,
2895 if (convertToString(Record, NameIndex, ValueName))
2896 return error("Invalid record");
2897 unsigned ValueID = Record[0];
2899 return error("Invalid record");
2932 ArrayRef<uint64_t> Record) {
2936 uint64_t FuncWordOffset = Record[1] - 1;
2954 SmallVector<uint64_t, 64> Record;
2967 case BitstreamEntry::Record:
2971 Record.clear();
2972 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
2977 unsigned ValueID = Record[0];
2981 cast<Function>(ValueList[ValueID]), Record);
3029 SmallVector<uint64_t, 64> Record;
3051 case BitstreamEntry::Record:
3056 // Read a record.
3057 Record.clear();
3058 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
3065 Expected<Value *> ValOrErr = recordValue(Record, 1, TT);
3073 Expected<Value *> ValOrErr = recordValue(Record, 2, TT);
3081 setDeferredFunctionInfo(FuncBitcodeOffsetDelta, F, Record);
3085 if (convertToString(Record, 1, ValueName))
3086 return error("Invalid bbentry record");
3087 BasicBlock *BB = getBasicBlock(Record[0]);
3089 return error("Invalid bbentry record");
3209 SmallVector<uint64_t, 64> Record;
3232 case BitstreamEntry::Record:
3237 // Read a record.
3238 Record.clear();
3241 Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
3253 if (Record.empty())
3254 return error("Invalid settype record");
3255 if (Record[0] >= TypeList.size() || !TypeList[Record[0]])
3256 return error("Invalid settype record");
3257 if (TypeList[Record[0]] == VoidType)
3259 CurTyID = Record[0];
3272 if (!CurTy->isIntOrIntVectorTy() || Record.empty())
3273 return error("Invalid integer const record");
3274 V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0]));
3277 if (!CurTy->isIntOrIntVectorTy() || Record.empty())
3278 return error("Invalid wide integer const record");
3281 APInt VInt = readWideAPInt(Record, ScalarTy->getBitWidth());
3286 if (Record.empty())
3287 return error("Invalid float const record");
3292 APInt(16, (uint16_t)Record[0])));
3295 CurTy, APFloat(APFloat::BFloat(), APInt(16, (uint32_t)Record[0])));
3298 APInt(32, (uint32_t)Record[0])));
3301 CurTy, APFloat(APFloat::IEEEdouble(), APInt(64, Record[0])));
3305 Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16);
3306 Rearrange[1] = Record[0] >> 48;
3311 APFloat(APFloat::IEEEquad(), APInt(128, Record)));
3314 CurTy, APFloat(APFloat::PPCDoubleDouble(), APInt(128, Record)));
3321 if (Record.empty())
3322 return error("Invalid aggregate record");
3324 unsigned Size = Record.size();
3327 Elts.push_back(Record[i]);
3345 if (Record.empty())
3346 return error("Invalid string record");
3348 SmallString<16> Elts(Record.begin(), Record.end());
3354 if (Record.empty())
3355 return error("Invalid data record");
3363 SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end());
3369 SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
3375 SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
3381 SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
3387 SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
3393 SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
3399 SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
3405 SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
3416 if (Record.size() < 2)
3417 return error("Invalid unary op constexpr record");
3418 int Opc = getDecodedUnaryOpcode(Record[0], CurTy);
3422 V = BitcodeConstant::create(Alloc, CurTy, Opc, (unsigned)Record[1]);
3427 if (Record.size() < 3)
3428 return error("Invalid binary op constexpr record");
3429 int Opc = getDecodedBinaryOpcode(Record[0], CurTy);
3434 if (Record.size() >= 4) {
3439 if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP))
3441 if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
3447 if (Record[3] & (1 << bitc::PEO_EXACT))
3452 {(unsigned)Record[1], (unsigned)Record[2]});
3457 if (Record.size() < 3)
3458 return error("Invalid cast constexpr record");
3459 int Opc = getDecodedCastOpcode(Record[0]);
3463 unsigned OpTyID = Record[1];
3466 return error("Invalid cast constexpr record");
3467 V = BitcodeConstant::create(Alloc, CurTy, Opc, (unsigned)Record[2]);
3478 if (Record.size() < 2)
3479 return error("Constant GEP record must have at least two elements");
3484 BitCode == bitc::CST_CODE_CE_GEP || Record.size() % 2)
3485 PointeeType = getTypeByID(Record[OpNum++]);
3490 uint64_t Op = Record[OpNum++];
3497 Flags = Record[OpNum++];
3499 readBitWidthAndConstantRange(Record, OpNum);
3504 Flags = Record[OpNum++];
3509 unsigned BaseTypeID = Record[OpNum];
3510 while (OpNum != Record.size()) {
3511 unsigned ElTyID = Record[OpNum++];
3514 return error("Invalid getelementptr constexpr record");
3515 Elts.push_back(Record[OpNum++]);
3544 if (Record.size() < 3)
3545 return error("Invalid select constexpr record");
3549 {(unsigned)Record[0], (unsigned)Record[1], (unsigned)Record[2]});
3554 if (Record.size() < 3)
3555 return error("Invalid extractelement constexpr record");
3556 unsigned OpTyID = Record[0];
3560 return error("Invalid extractelement constexpr record");
3562 if (Record.size() == 4) {
3563 unsigned IdxTyID = Record[2];
3566 return error("Invalid extractelement constexpr record");
3567 IdxRecord = Record[3];
3570 IdxRecord = Record[2];
3573 {(unsigned)Record[1], IdxRecord});
3579 if (Record.size() < 3 || !OpTy)
3580 return error("Invalid insertelement constexpr record");
3582 if (Record.size() == 4) {
3583 unsigned IdxTyID = Record[2];
3586 return error("Invalid insertelement constexpr record");
3587 IdxRecord = Record[3];
3590 IdxRecord = Record[2];
3594 {(unsigned)Record[0], (unsigned)Record[1], IdxRecord});
3599 if (Record.size() < 3 || !OpTy)
3600 return error("Invalid shufflevector constexpr record");
3603 {(unsigned)Record[0], (unsigned)Record[1], (unsigned)Record[2]});
3609 dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
3610 if (Record.size() < 4 || !RTy || !OpTy)
3611 return error("Invalid shufflevector constexpr record");
3614 {(unsigned)Record[1], (unsigned)Record[2], (unsigned)Record[3]});
3618 if (Record.size() < 4)
3619 return error("Invalid cmp constexpt record");
3620 unsigned OpTyID = Record[0];
3623 return error("Invalid cmp constexpr record");
3628 (uint8_t)Record[3]},
3629 {(unsigned)Record[1], (unsigned)Record[2]});
3635 if (Record.size() < 2)
3636 return error("Invalid inlineasm record");
3638 bool HasSideEffects = Record[0] & 1;
3639 bool IsAlignStack = Record[0] >> 1;
3640 unsigned AsmStrSize = Record[1];
3641 if (2+AsmStrSize >= Record.size())
3642 return error("Invalid inlineasm record");
3643 unsigned ConstStrSize = Record[2+AsmStrSize];
3644 if (3+AsmStrSize+ConstStrSize > Record.size())
3645 return error("Invalid inlineasm record");
3648 AsmStr += (char)Record[2+i];
3650 ConstrStr += (char)Record[3+AsmStrSize+i];
3661 if (Record.size() < 2)
3662 return error("Invalid inlineasm record");
3664 bool HasSideEffects = Record[0] & 1;
3665 bool IsAlignStack = (Record[0] >> 1) & 1;
3666 unsigned AsmDialect = Record[0] >> 2;
3667 unsigned AsmStrSize = Record[1];
3668 if (2+AsmStrSize >= Record.size())
3669 return error("Invalid inlineasm record");
3670 unsigned ConstStrSize = Record[2+AsmStrSize];
3671 if (3+AsmStrSize+ConstStrSize > Record.size())
3672 return error("Invalid inlineasm record");
3675 AsmStr += (char)Record[2+i];
3677 ConstrStr += (char)Record[3+AsmStrSize+i];
3688 if (Record.size() < 2)
3689 return error("Invalid inlineasm record");
3692 bool HasSideEffects = Record[OpNum] & 1;
3693 bool IsAlignStack = (Record[OpNum] >> 1) & 1;
3694 unsigned AsmDialect = (Record[OpNum] >> 2) & 1;
3695 bool CanThrow = (Record[OpNum] >> 3) & 1;
3697 unsigned AsmStrSize = Record[OpNum];
3699 if (OpNum + AsmStrSize >= Record.size())
3700 return error("Invalid inlineasm record");
3701 unsigned ConstStrSize = Record[OpNum + AsmStrSize];
3702 if (OpNum + 1 + AsmStrSize + ConstStrSize > Record.size())
3703 return error("Invalid inlineasm record");
3706 AsmStr += (char)Record[OpNum + i];
3709 ConstrStr += (char)Record[OpNum + AsmStrSize + i];
3720 if (Record.size() < 3)
3721 return error("Invalid inlineasm record");
3723 auto *FnTy = dyn_cast_or_null<FunctionType>(getTypeByID(Record[OpNum]));
3726 return error("Invalid inlineasm record");
3728 bool HasSideEffects = Record[OpNum] & 1;
3729 bool IsAlignStack = (Record[OpNum] >> 1) & 1;
3730 unsigned AsmDialect = (Record[OpNum] >> 2) & 1;
3731 bool CanThrow = (Record[OpNum] >> 3) & 1;
3733 unsigned AsmStrSize = Record[OpNum];
3735 if (OpNum + AsmStrSize >= Record.size())
3736 return error("Invalid inlineasm record");
3737 unsigned ConstStrSize = Record[OpNum + AsmStrSize];
3738 if (OpNum + 1 + AsmStrSize + ConstStrSize > Record.size())
3739 return error("Invalid inlineasm record");
3742 AsmStr += (char)Record[OpNum + i];
3745 ConstrStr += (char)Record[OpNum + AsmStrSize + i];
3752 if (Record.size() < 3)
3753 return error("Invalid blockaddress record");
3754 unsigned FnTyID = Record[0];
3757 return error("Invalid blockaddress record");
3760 {BitcodeConstant::BlockAddressOpcode, 0, (unsigned)Record[2]},
3761 Record[1]);
3765 if (Record.size() < 2)
3766 return error("Invalid dso_local record");
3767 unsigned GVTyID = Record[0];
3770 return error("Invalid dso_local record");
3772 Alloc, CurTy, BitcodeConstant::DSOLocalEquivalentOpcode, Record[1]);
3776 if (Record.size() < 2)
3777 return error("Invalid no_cfi record");
3778 unsigned GVTyID = Record[0];
3781 return error("Invalid no_cfi record");
3783 Record[1]);
3787 if (Record.size() < 4)
3788 return error("Invalid ptrauth record");
3792 {(unsigned)Record[0], (unsigned)Record[1],
3793 (unsigned)Record[2], (unsigned)Record[3]});
3810 SmallVector<uint64_t, 64> Record;
3824 case BitstreamEntry::Record:
3829 // Read a use list record.
3830 Record.clear();
3832 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
3842 unsigned RecordLength = Record.size();
3845 return error("Invalid record");
3846 unsigned ID = Record.pop_back_val();
3857 if (++NumUses > Record.size())
3859 Order[&U] = Record[NumUses - 1];
3861 if (Order.size() != Record.size() || NumUses > Record.size())
3978 /// either have an old bitcode file without a VST forward declaration record,
3995 SmallVector<uint64_t, 64> Record;
4033 Error BitcodeReader::parseComdatRecord(ArrayRef<uint64_t> Record) {
4037 std::tie(Name, Record) = readNameFromStrtab(Record);
4039 if (Record.empty())
4040 return error("Invalid record");
4041 Comdat::SelectionKind SK = getDecodedComdatSelectionKind(Record[0]);
4044 if (Record.size() < 2)
4045 return error("Invalid record");
4046 unsigned ComdatNameSize = Record[1];
4047 if (ComdatNameSize > Record.size() - 2)
4051 OldFormatName += (char)Record[2 + i];
4080 Error BitcodeReader::parseGlobalVarRecord(ArrayRef<uint64_t> Record) {
4088 std::tie(Name, Record) = readNameFromStrtab(Record);
4090 if (Record.size() < 6)
4091 return error("Invalid record");
4092 unsigned TyID = Record[0];
4095 return error("Invalid record");
4096 bool isConstant = Record[1] & 1;
4097 bool explicitType = Record[1] & 2;
4100 AddressSpace = Record[1] >> 2;
4111 uint64_t RawLinkage = Record[3];
4114 if (Error Err = parseAlignmentValue(Record[4], Alignment))
4117 if (Record[5]) {
4118 if (Record[5] - 1 >= SectionTable.size())
4120 Section = SectionTable[Record[5] - 1];
4125 if (Record.size() > 6 && !GlobalValue::isLocalLinkage(Linkage))
4126 Visibility = getDecodedVisibility(Record[6]);
4129 if (Record.size() > 7)
4130 TLM = getDecodedThreadLocalMode(Record[7]);
4133 if (Record.size() > 8)
4134 UnnamedAddr = getDecodedUnnamedAddrType(Record[8]);
4137 if (Record.size() > 9)
4138 ExternallyInitialized = Record[9];
4150 if (Record.size() > 10) {
4153 NewGV->setDLLStorageClass(getDecodedDLLStorageClass(Record[10]));
4162 if (unsigned InitID = Record[2])
4165 if (Record.size() > 11) {
4166 if (unsigned ComdatID = Record[11]) {
4175 if (Record.size() > 12) {
4176 auto AS = getAttributes(Record[12]).getFnAttrs();
4180 if (Record.size() > 13) {
4181 NewGV->setDSOLocal(getDecodedDSOLocal(Record[13]));
4186 if (Record.size() > 15)
4187 NewGV->setPartition(StringRef(Strtab.data() + Record[14], Record[15]));
4189 if (Record.size() > 16 && Record[16]) {
4191 deserializeSanitizerMetadata(Record[16]);
4195 if (Record.size() > 17 && Record[17]) {
4196 if (auto CM = getDecodedCodeModel(Record[17]))
4213 Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t> Record) {
4219 std::tie(Name, Record) = readNameFromStrtab(Record);
4221 if (Record.size() < 8)
4222 return error("Invalid record");
4223 unsigned FTyID = Record[0];
4226 return error("Invalid record");
4236 auto CC = static_cast<CallingConv::ID>(Record[1]);
4241 if (Record.size() > 16)
4242 AddrSpace = Record[16];
4253 bool isProto = Record[2];
4254 uint64_t RawLinkage = Record[3];
4256 Func->setAttributes(getAttributes(Record[4]));
4308 if (Error Err = parseAlignmentValue(Record[5], Alignment))
4312 if (Record[6]) {
4313 if (Record[6] - 1 >= SectionTable.size())
4315 Func->setSection(SectionTable[Record[6] - 1]);
4320 Func->setVisibility(getDecodedVisibility(Record[7]));
4321 if (Record.size() > 8 && Record[8]) {
4322 if (Record[8] - 1 >= GCTable.size())
4324 Func->setGC(GCTable[Record[8] - 1]);
4327 if (Record.size() > 9)
4328 UnnamedAddr = getDecodedUnnamedAddrType(Record[9]);
4332 if (Record.size() > 10)
4333 OperandInfo.Prologue = Record[10];
4335 if (Record.size() > 11) {
4338 Func->setDLLStorageClass(getDecodedDLLStorageClass(Record[11]));
4344 if (Record.size() > 12) {
4345 if (unsigned ComdatID = Record[12]) {
4354 if (Record.size() > 13)
4355 OperandInfo.Prefix = Record[13];
4357 if (Record.size() > 14)
4358 OperandInfo.PersonalityFn = Record[14];
4360 if (Record.size() > 15) {
4361 Func->setDSOLocal(getDecodedDSOLocal(Record[15]));
4365 // Record[16] is the address space number.
4369 if (Record.size() > 18 && Strtab.data() &&
4370 Record[17] + Record[18] <= Strtab.size()) {
4371 Func->setPartition(StringRef(Strtab.data() + Record[17], Record[18]));
4390 unsigned BitCode, ArrayRef<uint64_t> Record) {
4400 std::tie(Name, Record) = readNameFromStrtab(Record);
4403 if (Record.size() < (3 + (unsigned)NewRecord))
4404 return error("Invalid record");
4406 unsigned TypeID = Record[OpNum++];
4409 return error("Invalid record");
4422 AddrSpace = Record[OpNum++];
4425 auto Val = Record[OpNum++];
4426 auto Linkage = Record[OpNum++];
4438 if (OpNum != Record.size()) {
4441 NewGA->setVisibility(getDecodedVisibility(Record[VisInd]));
4445 if (OpNum != Record.size()) {
4446 auto S = Record[OpNum++];
4453 if (OpNum != Record.size())
4454 NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[OpNum++]));
4455 if (OpNum != Record.size())
4456 NewGA->setUnnamedAddr(getDecodedUnnamedAddrType(Record[OpNum++]));
4458 if (OpNum != Record.size())
4459 NewGA->setDSOLocal(getDecodedDSOLocal(Record[OpNum++]));
4463 if (OpNum + 1 < Record.size()) {
4465 if (Record[OpNum] + Record[OpNum + 1] > Strtab.size())
4468 StringRef(Strtab.data() + Record[OpNum], Record[OpNum + 1]));
4495 SmallVector<uint64_t, 64> Record;
4573 // associated VST forward declaration record (which would have caused
4582 // We must have had a VST forward declaration record, which caused
4623 // If we have a VST forward declaration record, make sure we
4630 // Fall through so that we record the NextUnreadBit below.
4635 // If we have a VST forward declaration record, but have already
4648 // index in the VST, nor a VST forward declaration record, as
4680 case BitstreamEntry::Record:
4685 // Read a record.
4686 Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
4692 Expected<unsigned> VersionOrErr = parseVersionRecord(Record);
4702 if (convertToString(Record, 0, S))
4703 return error("Invalid record");
4710 if (convertToString(Record, 0, TentativeDataLayoutStr))
4711 return error("Invalid record");
4716 if (convertToString(Record, 0, S))
4717 return error("Invalid record");
4724 if (convertToString(Record, 0, S))
4725 return error("Invalid record");
4731 if (convertToString(Record, 0, S))
4732 return error("Invalid record");
4738 if (convertToString(Record, 0, S))
4739 return error("Invalid record");
4744 if (Error Err = parseComdatRecord(Record))
4750 // record
4753 if (Error Err = parseGlobalVarRecord(Record))
4759 if (Error Err = parseFunctionRecord(Record))
4765 if (Error Err = parseGlobalIndirectSymbolRecord(BitCode, Record))
4770 if (Record.empty())
4771 return error("Invalid record");
4775 VSTOffset = Record[0] - 1;
4780 if (convertToString(Record, 0, ValueName))
4781 return error("Invalid record");
4785 Record.clear();
4952 SmallVector<uint64_t, 64> Record;
4998 case BitstreamEntry::Record:
5003 // Read a record.
5004 Record.clear();
5007 Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
5014 if (Record.empty() || Record[0] == 0)
5015 return error("Invalid record");
5017 FunctionBBs.resize(Record[0]);
5049 // The record should not be emitted if it's an empty list.
5050 if (Record.empty())
5051 return error("Invalid record");
5065 for (uint64_t ValID : Record)
5069 return error("Invalid record");
5074 // This record indicates that the last instruction is at the same
5079 return error("Invalid record");
5086 if (!I || Record.size() < 4)
5087 return error("Invalid record");
5089 unsigned Line = Record[0], Col = Record[1];
5090 unsigned ScopeID = Record[2], IAID = Record[3];
5091 bool isImplicitCode = Record.size() == 5 && Record[4];
5098 return error("Invalid record");
5104 return error("Invalid record");
5116 if (getValueTypePair(Record, OpNum, NextValueNo, LHS, TypeID, CurBB) ||
5117 OpNum+1 > Record.size())
5118 return error("Invalid record");
5120 int Opc = getDecodedUnaryOpcode(Record[OpNum++], LHS->getType());
5122 return error("Invalid record");
5126 if (OpNum < Record.size()) {
5128 FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
5139 if (getValueTypePair(Record, OpNum, NextValueNo, LHS, TypeID, CurBB) ||
5140 popValue(Record, OpNum, NextValueNo, LHS->getType(), TypeID, RHS,
5142 OpNum+1 > Record.size())
5143 return error("Invalid record");
5145 int Opc = getDecodedBinaryOpcode(Record[OpNum++], LHS->getType());
5147 return error("Invalid record");
5151 if (OpNum < Record.size()) {
5156 if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP))
5158 if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
5164 if (Record[OpNum] & (1 << bitc::PEO_EXACT))
5167 if (Record[OpNum] & (1 << bitc::PDI_DISJOINT))
5170 FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
5181 if (getValueTypePair(Record, OpNum, NextValueNo, Op, OpTypeID, CurBB) ||
5182 OpNum + 1 > Record.size())
5183 return error("Invalid record");
5185 ResTypeID = Record[OpNum++];
5187 int Opc = getDecodedCastOpcode(Record[OpNum++]);
5190 return error("Invalid record");
5205 if (OpNum < Record.size()) {
5207 if (Record[OpNum] & (1 << bitc::PNNI_NON_NEG))
5210 if (Record[OpNum] & (1 << bitc::TIO_NO_UNSIGNED_WRAP))
5212 if (Record[OpNum] & (1 << bitc::TIO_NO_SIGNED_WRAP))
5216 FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
5235 NW = toGEPNoWrapFlags(Record[OpNum++]);
5236 TyID = Record[OpNum++];
5247 if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr, BasePtrTypeID,
5249 return error("Invalid record");
5259 while (OpNum != Record.size()) {
5262 if (getValueTypePair(Record, OpNum, NextValueNo, Op, OpTypeID, CurBB))
5263 return error("Invalid record");
5303 if (getValueTypePair(Record, OpNum, NextValueNo, Agg, AggTypeID, CurBB))
5304 return error("Invalid record");
5307 unsigned RecSize = Record.size();
5316 uint64_t Index = Record[OpNum];
5347 if (getValueTypePair(Record, OpNum, NextValueNo, Agg, AggTypeID, CurBB))
5348 return error("Invalid record");
5351 if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))
5352 return error("Invalid record");
5354 unsigned RecSize = Record.size();
5363 uint64_t Index = Record[OpNum];
5397 if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal, TypeID,
5399 popValue(Record, OpNum, NextValueNo, TrueVal->getType(), TypeID,
5401 popValue(Record, OpNum, NextValueNo, CondType,
5403 return error("Invalid record");
5417 if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal, ValTypeID,
5419 popValue(Record, OpNum, NextValueNo, TrueVal->getType(), ValTypeID,
5421 getValueTypePair(Record, OpNum, NextValueNo, Cond, CondTypeID, CurBB))
5422 return error("Invalid record");
5439 if (OpNum < Record.size() && isa<FPMathOperator>(I)) {
5440 FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
5451 if (getValueTypePair(Record, OpNum, NextValueNo, Vec, VecTypeID, CurBB) ||
5452 getValueTypePair(Record, OpNum, NextValueNo, Idx, IdxTypeID, CurBB))
5453 return error("Invalid record");
5466 if (getValueTypePair(Record, OpNum, NextValueNo, Vec, VecTypeID, CurBB))
5467 return error("Invalid record");
5470 if (popValue(Record, OpNum, NextValueNo,
5473 getValueTypePair(Record, OpNum, NextValueNo, Idx, IdxTypeID, CurBB))
5474 return error("Invalid record");
5485 if (getValueTypePair(Record, OpNum, NextValueNo, Vec1, Vec1TypeID,
5487 popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec1TypeID,
5489 return error("Invalid record");
5492 if (getValueTypePair(Record, OpNum, NextValueNo, Mask, MaskTypeID, CurBB))
5493 return error("Invalid record");
5514 if (getValueTypePair(Record, OpNum, NextValueNo, LHS, LHSTypeID, CurBB) ||
5515 popValue(Record, OpNum, NextValueNo, LHS->getType(), LHSTypeID, RHS,
5517 return error("Invalid record");
5519 if (OpNum >= Record.size())
5521 "Invalid record: operand number exceeded available operands");
5523 CmpInst::Predicate PredVal = CmpInst::Predicate(Record[OpNum]);
5526 if (IsFP && Record.size() > OpNum+1)
5527 FMF = getDecodedFastMathFlags(Record[++OpNum]);
5537 if (Record.size() > OpNum + 1 &&
5538 (Record[++OpNum] & (1 << bitc::ICMP_SAME_SIGN)))
5542 if (OpNum + 1 != Record.size())
5543 return error("Invalid record");
5557 unsigned Size = Record.size();
5567 if (getValueTypePair(Record, OpNum, NextValueNo, Op, OpTypeID, CurBB))
5568 return error("Invalid record");
5569 if (OpNum != Record.size())
5570 return error("Invalid record");
5577 if (Record.size() != 1 && Record.size() != 3)
5578 return error("Invalid record");
5579 BasicBlock *TrueDest = getBasicBlock(Record[0]);
5581 return error("Invalid record");
5583 if (Record.size() == 1) {
5588 BasicBlock *FalseDest = getBasicBlock(Record[1]);
5590 Value *Cond = getValue(Record, 2, NextValueNo, CondType,
5593 return error("Invalid record");
5600 if (Record.size() != 1 && Record.size() != 2)
5601 return error("Invalid record");
5604 Value *CleanupPad = getValue(Record, Idx++, NextValueNo, TokenTy,
5607 return error("Invalid record");
5609 if (Record.size() == 2) {
5610 UnwindDest = getBasicBlock(Record[Idx++]);
5612 return error("Invalid record");
5620 if (Record.size() != 2)
5621 return error("Invalid record");
5624 Value *CatchPad = getValue(Record, Idx++, NextValueNo, TokenTy,
5627 return error("Invalid record");
5628 BasicBlock *BB = getBasicBlock(Record[Idx++]);
5630 return error("Invalid record");
5638 if (Record.size() < 2)
5639 return error("Invalid record");
5644 Value *ParentPad = getValue(Record, Idx++, NextValueNo, TokenTy,
5647 return error("Invalid record");
5649 unsigned NumHandlers = Record[Idx++];
5653 BasicBlock *BB = getBasicBlock(Record[Idx++]);
5655 return error("Invalid record");
5660 if (Idx + 1 == Record.size()) {
5661 UnwindDest = getBasicBlock(Record[Idx++]);
5663 return error("Invalid record");
5666 if (Record.size() != Idx)
5667 return error("Invalid record");
5681 if (Record.size() < 2)
5682 return error("Invalid record");
5687 Value *ParentPad = getValue(Record, Idx++, NextValueNo, TokenTy,
5690 return error("Invald record");
5692 unsigned NumArgOperands = Record[Idx++];
5698 if (getValueTypePair(Record, Idx, NextValueNo, Val, ValTypeID, nullptr))
5699 return error("Invalid record");
5703 if (Record.size() != Idx)
5704 return error("Invalid record");
5716 if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {
5722 unsigned OpTyID = Record[1];
5726 Value *Cond = getValue(Record, 2, NextValueNo, OpTy, OpTyID, CurBB);
5727 BasicBlock *Default = getBasicBlock(Record[3]);
5729 return error("Invalid record");
5731 unsigned NumCases = Record[4];
5739 unsigned NumItems = Record[CurIdx++];
5741 bool isSingleNumber = Record[CurIdx++];
5746 ActiveWords = Record[CurIdx++];
5747 Low = readWideAPInt(ArrayRef(&Record[CurIdx], ActiveWords),
5754 ActiveWords = Record[CurIdx++];
5755 APInt High = readWideAPInt(ArrayRef(&Record[CurIdx], ActiveWords),
5768 BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]);
5778 if (Record.size() < 3 || (Record.size() & 1) == 0)
5779 return error("Invalid record");
5780 unsigned OpTyID = Record[0];
5782 Value *Cond = getValue(Record, 1, NextValueNo, OpTy, OpTyID, CurBB);
5783 BasicBlock *Default = getBasicBlock(Record[2]);
5785 return error("Invalid record");
5786 unsigned NumCases = (Record.size()-3)/2;
5791 getFnValueByID(Record[3+i*2], OpTy, OpTyID, nullptr));
5792 BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
5795 return error("Invalid record");
5803 if (Record.size() < 2)
5804 return error("Invalid record");
5805 unsigned OpTyID = Record[0];
5807 Value *Address = getValue(Record, 1, NextValueNo, OpTy, OpTyID, CurBB);
5809 return error("Invalid record");
5810 unsigned NumDests = Record.size()-2;
5814 if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) {
5818 return error("Invalid record");
5827 if (Record.size() < 4)
5828 return error("Invalid record");
5830 AttributeList PAL = getAttributes(Record[OpNum++]);
5831 unsigned CCInfo = Record[OpNum++];
5832 BasicBlock *NormalBB = getBasicBlock(Record[OpNum++]);
5833 BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]);
5838 FTyID = Record[OpNum++];
5846 if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID,
5848 return error("Invalid record");
5859 if (Record.size() < FTy->getNumParams() + OpNum)
5866 Ops.push_back(getValue(Record, OpNum, NextValueNo, FTy->getParamType(i),
5870 return error("Invalid record");
5874 if (Record.size() != OpNum)
5875 return error("Invalid record");
5878 while (OpNum != Record.size()) {
5881 if (getValueTypePair(Record, OpNum, NextValueNo, Op, OpTypeID, CurBB))
5882 return error("Invalid record");
5911 if (getValueTypePair(Record, Idx, NextValueNo, Val, ValTypeID, CurBB))
5912 return error("Invalid record");
5920 AttributeList PAL = getAttributes(Record[OpNum++]);
5921 unsigned CCInfo = Record[OpNum++];
5923 BasicBlock *DefaultDest = getBasicBlock(Record[OpNum++]);
5924 unsigned NumIndirectDests = Record[OpNum++];
5927 IndirectDests.push_back(getBasicBlock(Record[OpNum++]));
5932 FTyID = Record[OpNum++];
5940 if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID,
5942 return error("Invalid record");
5953 if (Record.size() < FTy->getNumParams() + OpNum)
5963 Arg = getBasicBlock(Record[OpNum]);
5965 Arg = getValue(Record, OpNum, NextValueNo, FTy->getParamType(i),
5968 return error("Invalid record");
5975 if (OpNum != Record.size())
5976 return error("Invalid record");
5978 while (OpNum != Record.size()) {
5981 if (getValueTypePair(Record, OpNum, NextValueNo, Op, OpTypeID, CurBB))
5982 return error("Invalid record");
6066 if (Record.empty())
6067 return error("Invalid phi record");
6068 // The first record specifies the type.
6069 unsigned TyID = Record[0];
6072 return error("Invalid phi record");
6075 // There is an optional final record for fast-math-flags if this phi has a
6077 size_t NumArgs = (Record.size() - 1) / 2;
6079 if ((Record.size() - 1) % 2 == 1 && !isa<FPMathOperator>(PN)) {
6081 return error("Invalid phi record");
6087 BasicBlock *BB = getBasicBlock(Record[i * 2 + 2]);
6119 V = getValueSigned(Record, i * 2 + 1, NextValueNo, Ty, TyID, EdgeBB);
6121 V = getValue(Record, i * 2 + 1, NextValueNo, Ty, TyID, EdgeBB);
6125 return error("Invalid phi record");
6138 // If there are an even number of records, the final record must be FMF.
6139 if (Record.size() % 2 == 0) {
6141 FastMathFlags FMF = getDecodedFastMathFlags(Record[Record.size() - 1]);
6154 if (Record.size() < 3)
6155 return error("Invalid record");
6158 if (Record.size() < 4)
6159 return error("Invalid record");
6161 ResTypeID = Record[Idx++];
6164 return error("Invalid record");
6168 if (getValueTypePair(Record, Idx, NextValueNo, PersFn, PersFnTypeID,
6170 return error("Invalid record");
6178 bool IsCleanup = !!Record[Idx++];
6179 unsigned NumClauses = Record[Idx++];
6184 LandingPadInst::ClauseType(Record[Idx++]); (void)CT;
6188 if (getValueTypePair(Record, Idx, NextValueNo, Val, ValTypeID,
6191 return error("Invalid record");
6209 if (Record.size() != 4 && Record.size() != 5)
6210 return error("Invalid record");
6212 const uint64_t Rec = Record[3];
6215 unsigned TyID = Record[0];
6223 unsigned OpTyID = Record[1];
6225 Value *Size = getFnValueByID(Record[2], OpTy, OpTyID, CurBB);
6234 return error("Invalid record");
6237 unsigned AS = Record.size() == 5 ? Record[4] : DL.getAllocaAddrSpace();
6260 if (getValueTypePair(Record, OpNum, NextValueNo, Op, OpTypeID, CurBB) ||
6261 (OpNum + 2 != Record.size() && OpNum + 3 != Record.size()))
6262 return error("Invalid record");
6268 if (OpNum + 3 == Record.size()) {
6269 ResTypeID = Record[OpNum++];
6283 if (Error Err = parseAlignmentValue(Record[OpNum], Align))
6290 I = new LoadInst(Ty, Op, "", Record[OpNum + 1], *Align);
6299 if (getValueTypePair(Record, OpNum, NextValueNo, Op, OpTypeID, CurBB) ||
6300 (OpNum + 4 != Record.size() && OpNum + 5 != Record.size()))
6301 return error("Invalid record");
6307 if (OpNum + 5 == Record.size()) {
6308 ResTypeID = Record[OpNum++];
6321 AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
6325 return error("Invalid record");
6326 if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
6327 return error("Invalid record");
6328 SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
6331 if (Error Err = parseAlignmentValue(Record[OpNum], Align))
6335 I = new LoadInst(Ty, Op, "", Record[OpNum + 1], *Align, Ordering, SSID);
6344 if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, PtrTypeID, CurBB))
6345 return error("Invalid record");
6348 if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))
6349 return error("Invalid record");
6352 if (popValue(Record, OpNum, NextValueNo, getTypeByID(ValTypeID),
6354 return error("Invalid record");
6357 if (OpNum + 2 != Record.size())
6358 return error("Invalid record");
6363 if (Error Err = parseAlignmentValue(Record[OpNum], Align))
6370 I = new StoreInst(Val, Ptr, Record[OpNum + 1], *Align);
6380 if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, PtrTypeID, CurBB) ||
6382 return error("Invalid record");
6384 if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))
6385 return error("Invalid record");
6388 if (popValue(Record, OpNum, NextValueNo, getTypeByID(ValTypeID),
6390 return error("Invalid record");
6393 if (OpNum + 4 != Record.size())
6394 return error("Invalid record");
6398 AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
6402 return error("Invalid record");
6403 SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
6404 if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
6405 return error("Invalid record");
6408 if (Error Err = parseAlignmentValue(Record[OpNum], Align))
6412 I = new StoreInst(Val, Ptr, Record[OpNum + 1], *Align, Ordering, SSID);
6419 const size_t NumRecords = Record.size();
6423 if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, PtrTypeID, CurBB))
6424 return error("Invalid record");
6431 if (popValue(Record, OpNum, NextValueNo, getTypeByID(CmpTypeID),
6433 return error("Invalid record");
6436 if (popValue(Record, OpNum, NextValueNo, Cmp->getType(), CmpTypeID,
6439 return error("Invalid record");
6442 getDecodedOrdering(Record[OpNum + 1]);
6445 return error("Invalid record");
6447 const SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 2]);
6455 : getDecodedOrdering(Record[OpNum + 3]);
6459 return error("Invalid record");
6466 cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]);
6476 cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum + 4]);
6487 const size_t NumRecords = Record.size();
6491 if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, PtrTypeID, CurBB))
6492 return error("Invalid record");
6499 if (getValueTypePair(Record, OpNum, NextValueNo, Cmp, CmpTypeID, CurBB))
6500 return error("Invalid record");
6503 if (popValue(Record, OpNum, NextValueNo, Cmp->getType(), CmpTypeID, Val,
6505 return error("Invalid record");
6508 return error("Invalid record");
6510 const bool IsVol = Record[OpNum];
6513 getDecodedOrdering(Record[OpNum + 1]);
6517 const SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 2]);
6523 getDecodedOrdering(Record[OpNum + 3]);
6527 const bool IsWeak = Record[OpNum + 4];
6532 if (Error Err = parseAlignmentValue(Record[OpNum + 5], Alignment))
6554 const size_t NumRecords = Record.size();
6559 if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, PtrTypeID, CurBB))
6560 return error("Invalid record");
6563 return error("Invalid record");
6569 if (popValue(Record, OpNum, NextValueNo,
6571 return error("Invalid record");
6573 if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))
6574 return error("Invalid record");
6578 return error("Invalid record");
6581 getDecodedRMWOperation(Record[OpNum]);
6584 return error("Invalid record");
6586 const bool IsVol = Record[OpNum + 1];
6588 const AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
6591 return error("Invalid record");
6593 const SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
6598 if (Error Err = parseAlignmentValue(Record[OpNum + 4], Alignment))
6614 if (2 != Record.size())
6615 return error("Invalid record");
6616 AtomicOrdering Ordering = getDecodedOrdering(Record[0]);
6620 return error("Invalid record");
6621 SyncScope::ID SSID = getDecodedSyncScopeID(Record[1]);
6632 return error("Invalid dbg record: missing instruction");
6633 DILocation *DIL = cast<DILocation>(getFnMetadataByID(Record[0]));
6634 DILabel *Label = cast<DILabel>(getFnMetadataByID(Record[1]));
6648 return error("Invalid dbg record: missing instruction");
6662 DILocation *DIL = cast<DILocation>(getFnMetadataByID(Record[Slot++]));
6664 cast<DILocalVariable>(getFnMetadataByID(Record[Slot++]));
6666 cast<DIExpression>(getFnMetadataByID(Record[Slot++]));
6674 // use-before-defs are encoded with the standard non-abbrev record
6679 if (getValueTypePair(Record, Slot, NextValueNo, V, TyID, CurBB))
6680 return error("Invalid dbg record: invalid value");
6685 RawLocation = getFnMetadataByID(Record[Slot++]);
6700 DIAssignID *ID = cast<DIAssignID>(getFnMetadataByID(Record[Slot++]));
6702 cast<DIExpression>(getFnMetadataByID(Record[Slot++]));
6703 Metadata *Addr = getFnMetadataByID(Record[Slot++]);
6716 if (Record.size() < 3)
6717 return error("Invalid record");
6720 AttributeList PAL = getAttributes(Record[OpNum++]);
6721 unsigned CCInfo = Record[OpNum++];
6725 FMF = getDecodedFastMathFlags(Record[OpNum++]);
6733 FTyID = Record[OpNum++];
6741 if (getValueTypePair(Record, OpNum, NextValueNo, Callee, CalleeTypeID,
6743 return error("Invalid record");
6754 if (Record.size() < FTy->getNumParams() + OpNum)
6763 Args.push_back(getBasicBlock(Record[OpNum]));
6765 Args.push_back(getValue(Record, OpNum, NextValueNo,
6769 return error("Invalid record");
6774 if (OpNum != Record.size())
6775 return error("Invalid record");
6777 while (OpNum != Record.size()) {
6780 if (getValueTypePair(Record, OpNum, NextValueNo, Op, OpTypeID, CurBB))
6781 return error("Invalid record");
6821 if (Record.size() < 3)
6822 return error("Invalid record");
6823 unsigned OpTyID = Record[0];
6825 Value *Op = getValue(Record, 1, NextValueNo, OpTy, OpTyID, CurBB);
6826 ResTypeID = Record[2];
6829 return error("Invalid record");
6840 if (Record.empty() || Record[0] >= BundleTags.size())
6841 return error("Invalid record");
6846 while (OpNum != Record.size()) {
6848 if (getValueOrMetadata(Record, OpNum, NextValueNo, Op, CurBB))
6849 return error("Invalid record");
6853 OperandBundles.emplace_back(BundleTags[Record[0]], std::move(Inputs));
6861 if (getValueTypePair(Record, OpNum, NextValueNo, Op, OpTypeID, CurBB))
6862 return error("Invalid record");
6863 if (OpNum != Record.size())
6864 return error("Invalid record");
7237 SmallVector<uint64_t, 64> Record;
7257 case BitstreamEntry::Record:
7262 // Read a record.
7263 Record.clear();
7264 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
7271 if (convertToString(Record, 1, ValueName))
7272 return error("Invalid record");
7273 unsigned ValueID = Record[0];
7285 if (convertToString(Record, 2, ValueName))
7286 return error("Invalid record");
7287 unsigned ValueID = Record[0];
7299 unsigned ValueID = Record[0];
7300 GlobalValue::GUID RefGUID = Record[1];
7318 SmallVector<uint64_t, 64> Record;
7351 "Expected early VST parse via VSTOffset record");
7382 case BitstreamEntry::Record: {
7383 Record.clear();
7384 Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
7391 if (Error Err = parseVersionRecord(Record).takeError())
7398 if (convertToString(Record, 0, ValueName))
7399 return error("Invalid record");
7405 if (Record.size() != 5)
7406 return error("Invalid hash length " + Twine(Record.size()).str());
7409 for (auto &Val : Record) {
7417 if (Record.empty())
7418 return error("Invalid record");
7422 VSTOffset = Record[0] - 1;
7433 std::tie(Name, GVRecord) = readNameFromStrtab(Record);
7435 return error("Invalid record");
7454 ModuleSummaryIndexBitcodeReader::makeRefList(ArrayRef<uint64_t> Record) {
7456 Ret.reserve(Record.size());
7457 for (uint64_t RefValueId : Record)
7463 ModuleSummaryIndexBitcodeReader::makeCallList(ArrayRef<uint64_t> Record,
7467 // In the case of new profile formats, there are two Record entries per
7468 // Edge. Otherwise, conservatively reserve up to Record.size.
7470 Ret.reserve(Record.size() / 2);
7472 Ret.reserve(Record.size());
7474 for (unsigned I = 0, E = Record.size(); I != E; ++I) {
7478 ValueInfo Callee = std::get<0>(getValueInfoFromValueId(Record[I]));
7485 getDecodedHotnessCallEdgeInfo(Record[++I]);
7487 getDecodedRelBFCallEdgeInfo(Record[++I], RelBF, HasTailCall);
7495 parseWholeProgramDevirtResolutionByArg(ArrayRef<uint64_t> Record, size_t &Slot,
7497 uint64_t ArgNum = Record[Slot++];
7499 Wpd.ResByArg[{Record.begin() + Slot, Record.begin() + Slot + ArgNum}];
7503 static_cast<WholeProgramDevirtResolution::ByArg::Kind>(Record[Slot++]);
7504 B.Info = Record[Slot++];
7505 B.Byte = Record[Slot++];
7506 B.Bit = Record[Slot++];
7509 static void parseWholeProgramDevirtResolution(ArrayRef<uint64_t> Record,
7512 uint64_t Id = Record[Slot++];
7515 Wpd.TheKind = static_cast<WholeProgramDevirtResolution::Kind>(Record[Slot++]);
7516 Wpd.SingleImplName = {Strtab.data() + Record[Slot],
7517 static_cast<size_t>(Record[Slot + 1])};
7520 uint64_t ResByArgNum = Record[Slot++];
7522 parseWholeProgramDevirtResolutionByArg(Record, Slot, Wpd);
7525 static void parseTypeIdSummaryRecord(ArrayRef<uint64_t> Record,
7530 {Strtab.data() + Record[Slot], static_cast<size_t>(Record[Slot + 1])});
7533 TypeId.TTRes.TheKind = static_cast<TypeTestResolution::Kind>(Record[Slot++]);
7534 TypeId.TTRes.SizeM1BitWidth = Record[Slot++];
7535 TypeId.TTRes.AlignLog2 = Record[Slot++];
7536 TypeId.TTRes.SizeM1 = Record[Slot++];
7537 TypeId.TTRes.BitMask = Record[Slot++];
7538 TypeId.TTRes.InlineBits = Record[Slot++];
7540 while (Slot < Record.size())
7541 parseWholeProgramDevirtResolution(Record, Strtab, Slot, TypeId);
7545 ModuleSummaryIndexBitcodeReader::parseParamAccesses(ArrayRef<uint64_t> Record) {
7548 BitcodeReader::decodeSignRotatedValue(Record.front()));
7549 Record = Record.drop_front();
7551 BitcodeReader::decodeSignRotatedValue(Record.front()));
7552 Record = Record.drop_front();
7560 while (!Record.empty()) {
7563 ParamAccess.ParamNo = Record.front();
7564 Record = Record.drop_front();
7566 ParamAccess.Calls.resize(Record.front());
7567 Record = Record.drop_front();
7569 Call.ParamNo = Record.front();
7570 Record = Record.drop_front();
7571 Call.Callee = std::get<0>(getValueInfoFromValueId(Record.front()));
7572 Record = Record.drop_front();
7580 ArrayRef<uint64_t> Record, size_t &Slot,
7582 uint64_t Offset = Record[Slot++];
7583 ValueInfo Callee = std::get<0>(getValueInfoFromValueId(Record[Slot++]));
7588 ArrayRef<uint64_t> Record) {
7592 {Strtab.data() + Record[Slot],
7593 static_cast<size_t>(Record[Slot + 1])});
7596 while (Slot < Record.size())
7597 parseTypeIdCompatibleVtableInfo(Record, Slot, TypeId);
7601 ArrayRef<uint64_t> Record, unsigned &I) {
7604 // used, simply see if we found a radix tree array record (and thus if
7607 unsigned NumStackEntries = Record[I++];
7608 assert(Record.size() - I >= NumStackEntries);
7611 assert(Record[I] < StackIds.size());
7613 TheIndex.addOrGetStackIdIndex(StackIds[Record[I++]]));
7616 unsigned RadixIndex = Record[I++];
7659 SmallVector<uint64_t, 64> Record;
7668 if (Entry.Kind != BitstreamEntry::Record)
7669 return error("Invalid Summary Block: record for version expected");
7670 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
7676 const uint64_t Version = Record[0];
7683 Record.clear();
7716 case BitstreamEntry::Record:
7721 // Read a record. The record format depends on whether this
7728 Record.clear();
7729 Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
7736 TheIndex.setFlags(Record[0]);
7740 uint64_t ValueID = Record[0];
7743 RefGUID = Record[1] << 32 | Record[2];
7745 RefGUID = Record[1];
7763 unsigned ValueID = Record[0];
7764 uint64_t RawFlags = Record[1];
7765 unsigned InstCount = Record[2];
7767 unsigned NumRefs = Record[3];
7771 RawFunFlags = Record[3];
7772 NumRefs = Record[4];
7775 NumRORefs = Record[5];
7778 NumWORefs = Record[6];
7791 assert(Record.size() >= RefListStartIndex + NumRefs &&
7792 "Record size inconsistent with number of references");
7794 ArrayRef<uint64_t>(Record).slice(RefListStartIndex, NumRefs));
7798 ArrayRef<uint64_t>(Record).slice(CallGraphEdgeStartIndex),
7802 // In order to save memory, only record the memprof summaries if this is
7830 unsigned ValueID = Record[0];
7831 uint64_t RawFlags = Record[1];
7832 unsigned AliaseeID = Record[2];
7855 unsigned ValueID = Record[0];
7856 uint64_t RawFlags = Record[1];
7864 GVF = getDecodedGVarFlags(Record[2]);
7868 makeRefList(ArrayRef<uint64_t>(Record).slice(RefArrayStart));
7881 unsigned ValueID = Record[0];
7882 uint64_t RawFlags = Record[1];
7883 GlobalVarSummary::GVarFlags GVF = getDecodedGVarFlags(Record[2]);
7884 unsigned NumRefs = Record[3];
7889 ArrayRef<uint64_t>(Record).slice(RefListStartIndex, NumRefs));
7891 for (unsigned I = VTableListStartIndex, E = Record.size(); I != E; ++I) {
7892 ValueInfo Callee = std::get<0>(getValueInfoFromValueId(Record[I]));
7893 uint64_t Offset = Record[++I];
7913 unsigned ValueID = Record[0];
7914 uint64_t ModuleId = Record[1];
7915 uint64_t RawFlags = Record[2];
7916 unsigned InstCount = Record[3];
7918 unsigned NumRefs = Record[4];
7923 RawFunFlags = Record[4];
7934 NumWORefs = Record[8];
7938 NumRORefs = Record[RefListStartIndex - NumRORefsOffset];
7940 NumRefs = Record[NumRefsIndex];
7945 assert(Record.size() >= RefListStartIndex + NumRefs &&
7946 "Record size inconsistent with number of references");
7948 ArrayRef<uint64_t>(Record).slice(RefListStartIndex, NumRefs));
7951 ArrayRef<uint64_t>(Record).slice(CallGraphEdgeStartIndex),
7974 unsigned ValueID = Record[0];
7975 uint64_t ModuleId = Record[1];
7976 uint64_t RawFlags = Record[2];
7977 unsigned AliaseeValueId = Record[3];
7994 unsigned ValueID = Record[0];
7995 uint64_t ModuleId = Record[1];
7996 uint64_t RawFlags = Record[2];
8004 GVF = getDecodedGVarFlags(Record[3]);
8008 makeRefList(ArrayRef<uint64_t>(Record).slice(RefArrayStart));
8020 uint64_t OriginalName = Record[0];
8022 return error("Name attachment that does not follow a combined record");
8032 llvm::append_range(PendingTypeTests, Record);
8037 for (unsigned I = 0; I != Record.size(); I += 2)
8038 PendingTypeTestAssumeVCalls.push_back({Record[I], Record[I+1]});
8043 for (unsigned I = 0; I != Record.size(); I += 2)
8044 PendingTypeCheckedLoadVCalls.push_back({Record[I], Record[I+1]});
8049 {{Record[0], Record[1]}, {Record.begin() + 2, Record.end()}});
8054 {{Record[0], Record[1]}, {Record.begin() + 2, Record.end()}});
8060 for (unsigned I = 0; I != Record.size(); I += 2)
8062 {Strtab.data() + Record[I], static_cast<size_t>(Record[I + 1])});
8069 for (unsigned I = 0; I != Record.size(); I += 2)
8071 {Strtab.data() + Record[I], static_cast<size_t>(Record[I + 1])});
8076 parseTypeIdSummaryRecord(Record, Strtab, TheIndex);
8080 parseTypeIdCompatibleVtableSummaryRecord(Record);
8084 TheIndex.addBlockCount(Record[0]);
8088 PendingParamAccesses = parseParamAccesses(Record);
8096 StackIds = ArrayRef<uint64_t>(Record);
8101 assert(Record.size() % 2 == 0);
8102 StackIds.reserve(Record.size() / 2);
8103 for (auto R = Record.begin(); R != Record.end(); R += 2)
8109 RadixArray = ArrayRef<uint64_t>(Record);
8114 unsigned ValueID = Record[0];
8116 for (auto R = Record.begin() + 1; R != Record.end(); R++) {
8126 auto RecordIter = Record.begin();
8130 assert(Record.size() == 3 + NumStackIds + NumVersions);
8150 assert(Record.size() % 2 == 0);
8151 PendingContextIds.reserve(Record.size() / 2);
8152 for (auto R = Record.begin(); R != Record.end(); R += 2)
8162 NumMIBs = Record[I++];
8165 (Version < 10 && I < Record.size())) {
8166 assert(Record.size() - I >= 2);
8167 AllocationType AllocType = (AllocationType)Record[I++];
8168 auto StackIdList = parseAllocInfoContext(Record, I);
8174 assert(I == Record.size() || Record.size() - I >= NumMIBs);
8176 if (I < Record.size()) {
8187 unsigned NumContextSizeInfoEntries = Record[I++];
8188 assert(Record.size() - I >= NumContextSizeInfoEntries);
8196 {PendingContextIds[ContextIdIndex++], Record[I++]});
8213 unsigned NumMIBs = Record[I++];
8214 unsigned NumVersions = Record[I++];
8217 assert(Record.size() - I >= 2);
8218 AllocationType AllocType = (AllocationType)Record[I++];
8219 auto StackIdList = parseAllocInfoContext(Record, I);
8222 assert(Record.size() - I >= NumVersions);
8225 Versions.push_back(Record[I++]);
8226 assert(I == Record.size());
8241 SmallVector<uint64_t, 64> Record;
8258 case BitstreamEntry::Record:
8263 Record.clear();
8264 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record);
8272 uint64_t ModuleId = Record[0];
8274 if (convertToString(Record, 1, ModulePath))
8275 return error("Invalid record");
8285 if (Record.size() != 5)
8286 return error("Invalid hash length " + Twine(Record.size()).str());
8290 for (auto &Val : Record) {
8354 case BitstreamEntry::Record:
8356 SmallVector<uint64_t, 1> Record;
8358 Stream.readRecord(Entry.ID, Record, &Blob);
8481 case BitstreamEntry::Record:
8584 SmallVector<uint64_t, 64> Record;
8597 // If no flags record found, set both flags to false.
8600 case BitstreamEntry::Record:
8605 // Look for the FS_FLAGS record.
8606 Record.clear();
8607 Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
8614 uint64_t Flags = Record[0];
8680 case BitstreamEntry::Record: