reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

lib/Bitcode/Reader/BitcodeReader.cpp
 3783     Record.clear();
 3786     Expected<unsigned> MaybeBitCode = Stream.readRecord(Entry.ID, Record);
 3793       if (Record.size() < 1 || Record[0] == 0)
 3793       if (Record.size() < 1 || Record[0] == 0)
 3796       FunctionBBs.resize(Record[0]);
 3840       if (!I || Record.size() < 4)
 3843       unsigned Line = Record[0], Col = Record[1];
 3843       unsigned Line = Record[0], Col = Record[1];
 3844       unsigned ScopeID = Record[2], IAID = Record[3];
 3844       unsigned ScopeID = Record[2], IAID = Record[3];
 3845       bool isImplicitCode = Record.size() == 5 && Record[4];
 3845       bool isImplicitCode = Record.size() == 5 && Record[4];
 3868       if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
 3869           OpNum+1 > Record.size())
 3872       int Opc = getDecodedUnaryOpcode(Record[OpNum++], LHS->getType());
 3877       if (OpNum < Record.size()) {
 3879           FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
 3889       if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
 3890           popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) ||
 3891           OpNum+1 > Record.size())
 3894       int Opc = getDecodedBinaryOpcode(Record[OpNum++], LHS->getType());
 3899       if (OpNum < Record.size()) {
 3904           if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP))
 3906           if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP))
 3912           if (Record[OpNum] & (1 << bitc::PEO_EXACT))
 3915           FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
 3926       if (getValueTypePair(Record, OpNum, NextValueNo, Op) ||
 3927           OpNum+2 != Record.size())
 3930       FullTy = getFullyStructuredTypeByID(Record[OpNum]);
 3932       int Opc = getDecodedCastOpcode(Record[OpNum + 1]);
 3959         InBounds = Record[OpNum++];
 3960         FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
 3969       if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr, &FullBaseTy))
 3980       while (OpNum != Record.size()) {
 3982         if (getValueTypePair(Record, OpNum, NextValueNo, Op))
 4000       if (getValueTypePair(Record, OpNum, NextValueNo, Agg, &FullTy))
 4003       unsigned RecSize = Record.size();
 4011         uint64_t Index = Record[OpNum];
 4038       if (getValueTypePair(Record, OpNum, NextValueNo, Agg, &FullTy))
 4041       if (getValueTypePair(Record, OpNum, NextValueNo, Val))
 4044       unsigned RecSize = Record.size();
 4053         uint64_t Index = Record[OpNum];
 4084       if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal, &FullTy) ||
 4085           popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
 4086           popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond))
 4099       if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal, &FullTy) ||
 4100           popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) ||
 4101           getValueTypePair(Record, OpNum, NextValueNo, Cond))
 4118       if (OpNum < Record.size() && isa<FPMathOperator>(I)) {
 4119         FastMathFlags FMF = getDecodedFastMathFlags(Record[OpNum]);
 4129       if (getValueTypePair(Record, OpNum, NextValueNo, Vec, &FullTy) ||
 4130           getValueTypePair(Record, OpNum, NextValueNo, Idx))
 4143       if (getValueTypePair(Record, OpNum, NextValueNo, Vec, &FullTy))
 4147       if (popValue(Record, OpNum, NextValueNo,
 4149           getValueTypePair(Record, OpNum, NextValueNo, Idx))
 4159       if (getValueTypePair(Record, OpNum, NextValueNo, Vec1, &FullTy) ||
 4160           popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2))
 4163       if (getValueTypePair(Record, OpNum, NextValueNo, Mask))
 4183       if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
 4184           popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS))
 4187       if (OpNum >= Record.size())
 4191       unsigned PredVal = Record[OpNum];
 4194       if (IsFP && Record.size() > OpNum+1)
 4195         FMF = getDecodedFastMathFlags(Record[++OpNum]);
 4197       if (OpNum+1 != Record.size())
 4213         unsigned Size = Record.size();
 4222         if (getValueTypePair(Record, OpNum, NextValueNo, Op))
 4224         if (OpNum != Record.size())
 4232       if (Record.size() != 1 && Record.size() != 3)
 4232       if (Record.size() != 1 && Record.size() != 3)
 4234       BasicBlock *TrueDest = getBasicBlock(Record[0]);
 4238       if (Record.size() == 1) {
 4243         BasicBlock *FalseDest = getBasicBlock(Record[1]);
 4244         Value *Cond = getValue(Record, 2, NextValueNo,
 4254       if (Record.size() != 1 && Record.size() != 2)
 4254       if (Record.size() != 1 && Record.size() != 2)
 4258           getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
 4262       if (Record.size() == 2) {
 4263         UnwindDest = getBasicBlock(Record[Idx++]);
 4273       if (Record.size() != 2)
 4277           getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
 4280       BasicBlock *BB = getBasicBlock(Record[Idx++]);
 4290       if (Record.size() < 2)
 4296           getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
 4298       unsigned NumHandlers = Record[Idx++];
 4302         BasicBlock *BB = getBasicBlock(Record[Idx++]);
 4309       if (Idx + 1 == Record.size()) {
 4310         UnwindDest = getBasicBlock(Record[Idx++]);
 4315       if (Record.size() != Idx)
 4329       if (Record.size() < 2)
 4335           getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
 4337       unsigned NumArgOperands = Record[Idx++];
 4342         if (getValueTypePair(Record, Idx, NextValueNo, Val))
 4347       if (Record.size() != Idx)
 4359       if ((Record[0] >> 16) == SWITCH_INST_MAGIC) {
 4365         Type *OpTy = getTypeByID(Record[1]);
 4368         Value *Cond = getValue(Record, 2, NextValueNo, OpTy);
 4369         BasicBlock *Default = getBasicBlock(Record[3]);
 4373         unsigned NumCases = Record[4];
 4381           unsigned NumItems = Record[CurIdx++];
 4383             bool isSingleNumber = Record[CurIdx++];
 4388               ActiveWords = Record[CurIdx++];
 4389             Low = readWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords),
 4396                 ActiveWords = Record[CurIdx++];
 4398                   makeArrayRef(&Record[CurIdx], ActiveWords), ValueBitWidth);
 4410           BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]);
 4421       if (Record.size() < 3 || (Record.size() & 1) == 0)
 4421       if (Record.size() < 3 || (Record.size() & 1) == 0)
 4423       Type *OpTy = getTypeByID(Record[0]);
 4424       Value *Cond = getValue(Record, 1, NextValueNo, OpTy);
 4425       BasicBlock *Default = getBasicBlock(Record[2]);
 4428       unsigned NumCases = (Record.size()-3)/2;
 4433           dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
 4434         BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]);
 4445       if (Record.size() < 2)
 4447       Type *OpTy = getTypeByID(Record[0]);
 4448       Value *Address = getValue(Record, 1, NextValueNo, OpTy);
 4451       unsigned NumDests = Record.size()-2;
 4455         if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) {
 4468       if (Record.size() < 4)
 4471       AttributeList PAL = getAttributes(Record[OpNum++]);
 4472       unsigned CCInfo = Record[OpNum++];
 4473       BasicBlock *NormalBB = getBasicBlock(Record[OpNum++]);
 4474       BasicBlock *UnwindBB = getBasicBlock(Record[OpNum++]);
 4480             dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
 4487       if (getValueTypePair(Record, OpNum, NextValueNo, Callee, &FullTy))
 4502       if (Record.size() < FTy->getNumParams() + OpNum)
 4508         Ops.push_back(getValue(Record, OpNum, NextValueNo,
 4516         if (Record.size() != OpNum)
 4520         while (OpNum != Record.size()) {
 4523           if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy))
 4545       if (getValueTypePair(Record, Idx, NextValueNo, Val))
 4554       AttributeList PAL = getAttributes(Record[OpNum++]);
 4555       unsigned CCInfo = Record[OpNum++];
 4557       BasicBlock *DefaultDest = getBasicBlock(Record[OpNum++]);
 4558       unsigned NumIndirectDests = Record[OpNum++];
 4561         IndirectDests.push_back(getBasicBlock(Record[OpNum++]));
 4567             dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
 4574       if (getValueTypePair(Record, OpNum, NextValueNo, Callee, &FullTy))
 4589       if (Record.size() < FTy->getNumParams() + OpNum)
 4596           Args.push_back(getBasicBlock(Record[OpNum]));
 4598           Args.push_back(getValue(Record, OpNum, NextValueNo,
 4606         if (OpNum != Record.size())
 4609         while (OpNum != Record.size()) {
 4611           if (getValueTypePair(Record, OpNum, NextValueNo, Op))
 4632       if (Record.size() < 1)
 4635       FullTy = getFullyStructuredTypeByID(Record[0]);
 4643       size_t NumArgs = (Record.size() - 1) / 2;
 4644       if ((Record.size() - 1) % 2 == 1 && !Ty->isFPOrFPVectorTy())
 4656           V = getValueSigned(Record, i * 2 + 1, NextValueNo, Ty);
 4658           V = getValue(Record, i * 2 + 1, NextValueNo, Ty);
 4659         BasicBlock *BB = getBasicBlock(Record[i * 2 + 2]);
 4667       if (Record.size() % 2 == 0) {
 4669         FastMathFlags FMF = getDecodedFastMathFlags(Record[Record.size() - 1]);
 4669         FastMathFlags FMF = getDecodedFastMathFlags(Record[Record.size() - 1]);
 4682         if (Record.size() < 3)
 4686         if (Record.size() < 4)
 4689       FullTy = getFullyStructuredTypeByID(Record[Idx++]);
 4695         if (getValueTypePair(Record, Idx, NextValueNo, PersFn))
 4704       bool IsCleanup = !!Record[Idx++];
 4705       unsigned NumClauses = Record[Idx++];
 4710           LandingPadInst::ClauseType(Record[Idx++]); (void)CT;
 4713         if (getValueTypePair(Record, Idx, NextValueNo, Val)) {
 4733       if (Record.size() != 4)
 4735       uint64_t AlignRecord = Record[3];
 4743       FullTy = getFullyStructuredTypeByID(Record[0]);
 4751       Type *OpTy = getTypeByID(Record[1]);
 4752       Value *Size = getFnValueByID(Record[2], OpTy);
 4775       if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy) ||
 4776           (OpNum + 2 != Record.size() && OpNum + 3 != Record.size()))
 4776           (OpNum + 2 != Record.size() && OpNum + 3 != Record.size()))
 4783       if (OpNum + 3 == Record.size()) {
 4784         FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
 4793       if (Error Err = parseAlignmentValue(Record[OpNum], Align))
 4795       I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align);
 4803       if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy) ||
 4804           (OpNum + 4 != Record.size() && OpNum + 5 != Record.size()))
 4804           (OpNum + 4 != Record.size() && OpNum + 5 != Record.size()))
 4811       if (OpNum + 5 == Record.size()) {
 4812         FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
 4820       AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
 4825       if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
 4827       SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
 4830       if (Error Err = parseAlignmentValue(Record[OpNum], Align))
 4832       I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align, Ordering, SSID);
 4841       if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy) ||
 4843                ? getValueTypePair(Record, OpNum, NextValueNo, Val)
 4844                : popValue(Record, OpNum, NextValueNo,
 4846           OpNum + 2 != Record.size())
 4852       if (Error Err = parseAlignmentValue(Record[OpNum], Align))
 4854       I = new StoreInst(Val, Ptr, Record[OpNum + 1], Align);
 4864       if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy) ||
 4867                ? getValueTypePair(Record, OpNum, NextValueNo, Val)
 4868                : popValue(Record, OpNum, NextValueNo,
 4870           OpNum + 4 != Record.size())
 4875       AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
 4880       SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
 4881       if (Ordering != AtomicOrdering::NotAtomic && Record[OpNum] == 0)
 4885       if (Error Err = parseAlignmentValue(Record[OpNum], Align))
 4887       I = new StoreInst(Val, Ptr, Record[OpNum + 1], Align, Ordering, SSID);
 4897       if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy))
 4904         if (getValueTypePair(Record, OpNum, NextValueNo, Cmp, &FullTy))
 4906       } else if (popValue(Record, OpNum, NextValueNo,
 4912       if (popValue(Record, OpNum, NextValueNo, Cmp->getType(), New) ||
 4913           Record.size() < OpNum + 3 || Record.size() > OpNum + 5)
 4913           Record.size() < OpNum + 3 || Record.size() > OpNum + 5)
 4916       AtomicOrdering SuccessOrdering = getDecodedOrdering(Record[OpNum + 1]);
 4920       SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 2]);
 4925       if (Record.size() < 7)
 4929         FailureOrdering = getDecodedOrdering(Record[OpNum + 3]);
 4934       cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]);
 4936       if (Record.size() < 8) {
 4944         cast<AtomicCmpXchgInst>(I)->setWeak(Record[OpNum+4]);
 4954       if (getValueTypePair(Record, OpNum, NextValueNo, Ptr, &FullTy) ||
 4956           popValue(Record, OpNum, NextValueNo,
 4958           OpNum + 4 != Record.size())
 4960       AtomicRMWInst::BinOp Operation = getDecodedRMWOperation(Record[OpNum]);
 4964       AtomicOrdering Ordering = getDecodedOrdering(Record[OpNum + 2]);
 4968       SyncScope::ID SSID = getDecodedSyncScopeID(Record[OpNum + 3]);
 4971       cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]);
 4976       if (2 != Record.size())
 4978       AtomicOrdering Ordering = getDecodedOrdering(Record[0]);
 4983       SyncScope::ID SSID = getDecodedSyncScopeID(Record[1]);
 4990       if (Record.size() < 3)
 4994       AttributeList PAL = getAttributes(Record[OpNum++]);
 4995       unsigned CCInfo = Record[OpNum++];
 4999         FMF = getDecodedFastMathFlags(Record[OpNum++]);
 5008             dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
 5015       if (getValueTypePair(Record, OpNum, NextValueNo, Callee, &FullTy))
 5030       if (Record.size() < FTy->getNumParams() + OpNum)
 5038           Args.push_back(getBasicBlock(Record[OpNum]));
 5040           Args.push_back(getValue(Record, OpNum, NextValueNo,
 5049         if (OpNum != Record.size())
 5052         while (OpNum != Record.size()) {
 5055           if (getValueTypePair(Record, OpNum, NextValueNo, Op, &FullTy))
 5087       if (Record.size() < 3)
 5089       Type *OpTy = getTypeByID(Record[0]);
 5090       Value *Op = getValue(Record, 1, NextValueNo, OpTy);
 5091       FullTy = getFullyStructuredTypeByID(Record[2]);
 5105       if (Record.size() < 1 || Record[0] >= BundleTags.size())
 5105       if (Record.size() < 1 || Record[0] >= BundleTags.size())
 5111       while (OpNum != Record.size()) {
 5113         if (getValueTypePair(Record, OpNum, NextValueNo, Op))
 5118       OperandBundles.emplace_back(BundleTags[Record[0]], std::move(Inputs));