Lines Matching defs:ID
605 return TokError("Metadata id is already used");
653 ValID ID;
654 if (ParseValID(ID))
656 if (ID.Kind != ValID::t_Constant)
658 Aliasee = ID.ConstantVal;
839 return TokError("expected attribute group id");
1001 /// GetGlobalVal - Get a value with the specified name or ID, creating a
1047 GlobalValue *LLParser::GetGlobalVal(unsigned ID, Type *Ty, LocTy Loc) {
1054 GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
1060 I = ForwardRefValIDs.find(ID);
1068 Error(Loc, "'@" + Twine(ID) + "' defined with type '" +
1081 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
2146 /// GetVal - Get a value with the specified name or ID, creating a
2191 Value *LLParser::PerFunctionState::GetVal(unsigned ID, Type *Ty,
2194 Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
2200 I = ForwardRefValIDs.find(ID);
2209 P.Error(Loc, "'%" + Twine(ID) + "' is not a basic block");
2211 P.Error(Loc, "'%" + Twine(ID) + "' defined with type '" +
2228 ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
2237 // If this instruction has void type, it cannot have a name or ID specified.
2247 // If neither a name nor an ID was specified, just use the next ID.
2291 /// GetBB - Get a basic block with the specified name or ID, creating a
2299 BasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) {
2300 return dyn_cast_or_null<BasicBlock>(GetVal(ID,
2342 bool LLParser::ParseValID(ValID &ID, PerFunctionState *PFS) {
2343 ID.Loc = Lex.getLoc();
2347 ID.UIntVal = Lex.getUIntVal();
2348 ID.Kind = ValID::t_GlobalID;
2351 ID.StrVal = Lex.getStrVal();
2352 ID.Kind = ValID::t_GlobalName;
2355 ID.UIntVal = Lex.getUIntVal();
2356 ID.Kind = ValID::t_LocalID;
2359 ID.StrVal = Lex.getStrVal();
2360 ID.Kind = ValID::t_LocalName;
2363 ID.APSIntVal = Lex.getAPSIntVal();
2364 ID.Kind = ValID::t_APSInt;
2367 ID.APFloatVal = Lex.getAPFloatVal();
2368 ID.Kind = ValID::t_APFloat;
2371 ID.ConstantVal = ConstantInt::getTrue(Context);
2372 ID.Kind = ValID::t_Constant;
2375 ID.ConstantVal = ConstantInt::getFalse(Context);
2376 ID.Kind = ValID::t_Constant;
2378 case lltok::kw_null: ID.Kind = ValID::t_Null; break;
2379 case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
2380 case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
2390 ID.ConstantStructElts = new Constant*[Elts.size()];
2391 ID
2392 memcpy(ID.ConstantStructElts, Elts.data(), Elts.size()*sizeof(Elts[0]));
2393 ID.Kind = ValID::t_ConstantStruct;
2411 ID.ConstantStructElts = new Constant*[Elts.size()];
2412 memcpy(ID.ConstantStructElts, Elts.data(), Elts.size()*sizeof(Elts[0]));
2413 ID.UIntVal = Elts.size();
2414 ID.Kind = ValID::t_PackedConstantStruct;
2419 return Error(ID.Loc, "constant vector must not be empty");
2434 ID.ConstantVal = ConstantVector::get(Elts);
2435 ID.Kind = ValID::t_Constant;
2450 ID.Kind = ValID::t_EmptyArray;
2468 ID.ConstantVal = ConstantArray::get(ATy, Elts);
2469 ID.Kind = ValID::t_Constant;
2474 ID.ConstantVal = ConstantDataArray::getString(Context, Lex.getStrVal(),
2477 ID.Kind = ValID::t_Constant;
2488 ParseStringConstant(ID.StrVal) ||
2492 ID.StrVal2 = Lex.getStrVal();
2493 ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1) |
2495 ID.Kind = ValID::t_InlineAsm;
2546 ID.ConstantVal = FwdRef;
2547 ID.Kind = ValID::t_Constant;
2571 ID.ConstantVal = BlockAddress::get(F, BB);
2572 ID.Kind = ValID::t_Constant;
2600 return Error(ID.Loc, "invalid cast opcode for cast from '" +
2603 ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc,
2605 ID.Kind = ValID::t_Constant;
2619 return Error(ID.Loc, "extractvalue operand must be aggregate type");
2621 return Error(ID.Loc, "invalid indices for extractvalue");
2622 ID.ConstantVal = ConstantExpr::getExtractValue(Val, Indices);
2623 ID.Kind = ValID::t_Constant;
2638 return Error(ID.Loc, "insertvalue operand must be aggregate type");
2642 return Error(ID.Loc, "invalid indices for insertvalue");
2644 return Error(ID.Loc, "insertvalue operand and field disagree in type: '" +
2648 ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1, Indices);
2649 ID.Kind = ValID::t_Constant;
2666 return Error(ID.Loc, "compare operands must have the same type");
2672 return Error(ID.Loc, "fcmp requires floating point operands");
2673 ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
2678 return Error(ID.Loc, "icmp requires pointer or integer operands");
2679 ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
2681 ID.Kind = ValID::t_Constant;
2729 return Error(ID.Loc, "operands of constexpr must have same type");
2749 return Error(ID.Loc, "constexpr requires integer operands");
2757 return Error(ID.Loc, "constexpr requires fp operands");
2766 ID.ConstantVal = C;
2767 ID.Kind = ValID::t_Constant;
2785 return Error(ID.Loc, "operands of constexpr must have same type");
2787 return Error(ID.Loc,
2789 ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
2790 ID.Kind = ValID::t_Constant;
2825 return Error(ID
2838 return Error(ID.Loc, "getelementptr index must be an integer");
2840 return Error(ID.Loc, "getelementptr index type missmatch");
2846 ID.Loc,
2854 return Error(ID.Loc, "base element of getelementptr must be sized");
2857 return Error(ID.Loc, "invalid getelementptr indices");
2858 ID.ConstantVal =
2862 return Error(ID.Loc, "expected three operands to select");
2865 return Error(ID.Loc, Reason);
2866 ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]);
2869 return Error(ID.Loc, "expected three operands to shufflevector");
2871 return Error(ID.Loc, "invalid operands to shufflevector");
2872 ID.ConstantVal =
2876 return Error(ID.Loc, "expected two operands to extractelement");
2878 return Error(ID.Loc, "invalid extractelement operands");
2879 ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]);
2883 return Error(ID.Loc, "expected three operands to insertelement");
2885 return Error(ID.Loc, "invalid insertelement operands");
2886 ID.ConstantVal =
2890 ID.Kind = ValID::t_Constant;
2902 ValID ID;
2904 bool Parsed = ParseValID(ID) ||
2905 ConvertValIDToValue(Ty, ID, V, nullptr);
2907 return Error(ID.Loc, "global values must be constants");
3896 bool LLParser::ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
3899 return Error(ID.Loc, "functions are not values, refer to them as pointers");
3901 switch (ID.Kind) {
3903 if (!PFS) return Error(ID.Loc, "invalid use of function-local name");
3904 V = PFS->GetVal(ID.UIntVal, Ty, ID.Loc);
3907 if (!PFS) return Error(ID.Loc, "invalid use of function-local name");
3908 V = PFS->GetVal(ID.StrVal, Ty, ID.Loc);
3914 if (!FTy || !InlineAsm::Verify(FTy, ID.StrVal2))
3915 return Error(ID.Loc, "invalid type for inline asm constraint string");
3916 V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal&1,
3917 (ID.UIntVal>>1)&1, (InlineAsm::AsmDialect(ID.UIntVal>>2)));
3921 V = GetGlobalVal(ID.StrVal, Ty, ID.Loc);
3924 V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc);
3928 return Error(ID.Loc, "integer constant must have integer type");
3929 ID.APSIntVal = ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits());
3930 V = ConstantInt::get(Context, ID.APSIntVal);
3934 !ConstantFP::isValueValidForType(Ty, ID.APFloatVal))
3935 return Error(ID.Loc, "floating point constant invalid for type");
3939 if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble) {
3942 ID.APFloatVal.convert(APFloat::IEEEhalf, APFloat::rmNearestTiesToEven,
3945 ID.APFloatVal.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven,
3948 V = ConstantFP::get(Context, ID.APFloatVal);
3951 return Error(ID.Loc, "floating point constant does not have type '" +
3957 return Error(ID.Loc, "null must be a pointer type");
3963 return Error(ID.Loc, "invalid type for undef constant");
3968 return Error(ID.Loc, "invalid empty array initializer");
3974 return Error(ID.Loc, "invalid type for null constant");
3978 if (ID.ConstantVal->getType() != Ty)
3979 return Error(ID.Loc, "constant expression type mismatch");
3981 V = ID.ConstantVal;
3986 if (ST->getNumElements() != ID.UIntVal)
3987 return Error(ID.Loc,
3989 if (ST->isPacked() != (ID.Kind == ValID::t_PackedConstantStruct))
3990 return Error(ID.Loc, "packed'ness of initializer and type don't match");
3993 for (unsigned i = 0, e = ID.UIntVal; i != e; ++i)
3994 if (ID.ConstantStructElts[i]->getType() != ST->getElementType(i))
3995 return Error(ID.Loc, "element " + Twine(i) +
3998 V = ConstantStruct::get(ST, makeArrayRef(ID.ConstantStructElts,
3999 ID.UIntVal));
4001 return Error(ID.Loc, "constant expression type mismatch");
4009 ValID ID;
4010 return ParseValID(ID, PFS) ||
4011 ConvertValIDToValue(Ty, ID, V, PFS);
4255 ValID ID;
4257 ID.Kind = ValID::t_GlobalID;
4258 ID.UIntVal = NumberedVals.size() - 1;
4260 ID.Kind = ValID::t_GlobalName;
4261 ID.StrVal = FunctionName;
4263 auto Blocks = ForwardRefBlockAddresses.find(ID);
4271 ValID ID;
4273 ID.Kind = ValID::t_GlobalName;
4274 ID.StrVal = F.getName();
4276 ID.Kind = ValID::t_GlobalID;
4277 ID.UIntVal = FunctionNumber;
4280 auto Blocks = P.ForwardRefBlockAddresses.find(ID);
4289 "Expected local id or name");
4373 if (ParseToken(lltok::equal, "expected '=' after instruction id"))
