Lines Matching defs:CurRec
112 /// to CurRec's name.
113 static const Init *QualifyName(const Record &CurRec, const Init *Name) {
114 RecordKeeper &RK = CurRec.getRecords();
116 CurRec.getNameInit(),
117 StringInit::get(RK, CurRec.isMultiClass() ? "::" : ":"));
121 NewName = BinOp->Fold(&CurRec);
171 if (CurRec) {
173 if (RecordVal *RV = CurRec->getValue(Name)) {
180 if (CurRec->isClass())
181 if (auto *V = FindValueInArgs(CurRec, Name))
212 bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
213 if (!CurRec)
214 CurRec = &CurMultiClass->Rec;
216 if (RecordVal *ERV = CurRec->getValue(RV.getNameInit())) {
224 CurRec->addValue(RV);
231 bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const Init *ValName,
236 if (!CurRec) CurRec = &CurMultiClass->Rec;
238 RecordVal *RV = CurRec->getValue(ValName);
300 /// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template
302 bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) {
304 MapResolver R(CurRec);
310 if (AddValue(CurRec, SubClass.RefRange.Start, Field))
318 CurRec->appendAssertions(SC);
321 CurRec->appendDumps(SC);
324 if (CurRec->isClass())
325 Name = VarInit::get(QualifiedNameOfImplicitName(*CurRec),
328 Name = CurRec->getNameInit();
331 CurRec->resolveReferences(R);
336 if (CurRec->isSubClassOf(SC))
339 CurRec->addSuperClass(SC, Loc);
342 if (CurRec->isSubClassOf(SC))
345 CurRec->addSuperClass(SC, SubClass.RefRange);
689 Record *CurRec = nullptr;
691 CurRec = &CurMultiClass->Rec;
694 ParseValue(CurRec, StringRecTy::get(Records), ParseNameMode);
763 ParseSubClassReference(Record *CurRec, bool isDefm) {
782 if (ParseTemplateArgValueList(Result.TemplateArgs, ArgLocs, CurRec,
840 const TypedInit *TGParser::ParseSliceElement(Record *CurRec) {
842 auto *CurVal = ParseValue(CurRec);
853 CurVal = ParseValue(CurRec);
890 ->Fold(CurRec));
904 const TypedInit *TGParser::ParseSliceElements(Record *CurRec, bool Single) {
918 CurVal = ParseSliceElement(CurRec);
1162 const Init *TGParser::ParseIDValue(Record *CurRec, const StringInit *Name,
1182 if (CurRec && !CurRec->isClass() && !CurMultiClass &&
1183 CurRec->getNameInit() == Name)
1184 return UnOpInit::get(UnOpInit::CAST, Name, CurRec->getType());
1194 const Init *TGParser::ParseOperation(Record *CurRec, const RecTy *ItemType) {
1310 const Init *LHS = ParseValue(CurRec);
1384 return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec);
1400 const Init *LHS = ParseValue(CurRec);
1426 const Init *Expr = ParseValue(CurRec);
1455 return (ExistsOpInit::get(Type, Expr))->Fold(CurRec);
1605 InitList.push_back(ParseValue(CurRec, ArgType));
1779 RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))->Fold(CurRec);
1786 ->Fold(CurRec);
1794 return ParseOperationForEachFilter(CurRec, ItemType);
1815 Args.push_back(ParseValue(CurRec));
1867 ->Fold(CurRec);
1893 ->Fold(CurRec);
1935 const Init *LHS = ParseValue(CurRec);
1944 const Init *MHS = ParseValue(CurRec, ItemType);
1954 const Init *RHS = ParseValue(CurRec, ItemType);
2071 return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
2075 return ParseOperationSubstr(CurRec, ItemType);
2078 return ParseOperationFind(CurRec, ItemType);
2081 return ParseOperationCond(CurRec, ItemType);
2091 const Init *StartUntyped = ParseValue(CurRec);
2107 const Init *ListUntyped = ParseValue(CurRec);
2136 if (CurRec && CurRec->getValue(A)) {
2154 if (CurRec && CurRec->getValue(B)) {
2170 Record *ParseRec = CurRec;
2206 ->Fold(CurRec);
2245 const Init *TGParser::ParseOperationSubstr(Record *CurRec,
2257 const Init *LHS = ParseValue(CurRec);
2267 const Init *MHS = ParseValue(CurRec);
2275 RHS = ParseValue(CurRec);
2328 return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
2334 const Init *TGParser::ParseOperationFind(Record *CurRec,
2346 const Init *LHS = ParseValue(CurRec);
2356 const Init *MHS = ParseValue(CurRec);
2364 RHS = ParseValue(CurRec);
2417 return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
2424 const Init *TGParser::ParseOperationForEachFilter(Record *CurRec,
2442 if (CurRec && CurRec->getValue(LHS)) {
2454 const Init *MHS = ParseValue(CurRec);
2512 Record *ParseRec = CurRec;
2546 ->Fold(CurRec);
2549 const Init *TGParser::ParseOperationCond(Record *CurRec,
2565 const Init *V = ParseValue(CurRec);
2575 V = ParseValue(CurRec, ItemType);
2625 return CondOpInit::get(Case, Val, Type)->Fold(CurRec);
2655 const Init *TGParser::ParseSimpleValue(Record *CurRec, const RecTy *ItemType,
2662 return ParseOperation(CurRec, ItemType);
2716 return ParseIDValue(CurRec, Name, NameLoc, Mode); // Value ::= IDValue
2731 if (ParseTemplateArgValueList(Args, ArgLocs, CurRec, Class))
2750 ParseValueList(Vals, CurRec);
2812 ParseValueList(Vals, CurRec,
2895 const Init *Operator = ParseValue(CurRec);
2911 ParseDagArgList(DagArgs, CurRec);
2934 const Init *TGParser::ParseValue(Record *CurRec, const RecTy *ItemType,
2937 const Init *Result = ParseSimpleValue(CurRec, ItemType, Mode);
2985 const TypedInit *RHS = ParseSliceElements(CurRec, /*Single=*/true);
2991 BinOpInit::get(BinOpInit::LISTSLICE, LHS, RHS, LHSTy)->Fold(CurRec);
2995 ->Fold(CurRec);
3035 Result = FieldInit::get(Result, FieldName)->Fold(CurRec);
3061 const Init *RHSResult = ParseValue(CurRec, ItemType, ParseValueMode);
3075 ->Fold(CurRec));
3100 const Init *RHSResult = ParseValue(CurRec, nullptr, ParseNameMode);
3112 ->Fold(CurRec));
3138 Record *CurRec) {
3149 const Init *Val = ParseValue(CurRec);
3181 Record *CurRec, const RecTy *ItemType) {
3182 Result.push_back(ParseValue(CurRec, ItemType));
3192 Result.push_back(ParseValue(CurRec, ItemType));
3210 SmallVectorImpl<SMLoc> &ArgLocs, Record *CurRec, const Record *ArgsRec) {
3229 CurRec,
3249 Value = ParseValue(CurRec, NamedArg->getType());
3279 /// CurRec will be non-null) and within the template args for a multiclass (in
3280 /// which case CurRec will be null, but CurMultiClass will be set). This can
3282 /// CurRec and CurMultiClass.
3286 const Init *TGParser::ParseDeclaration(Record *CurRec,
3316 BadField = AddValue(CurRec, IdLoc,
3320 } else if (CurRec) { // class template argument
3321 DeclName = QualifyName(*CurRec, DeclName);
3323 AddValue(CurRec, IdLoc,
3329 AddValue(CurRec, IdLoc,
3338 const Init *Val = ParseValue(CurRec, Type);
3340 SetValue(CurRec, ValLoc, DeclName, {}, Val,
3435 /// sequence of template-declarations in <>'s. If CurRec is non-null, these are
3441 bool TGParser::ParseTemplateArgList(Record *CurRec) {
3445 Record *TheRecToAddTo = CurRec ? CurRec : &CurMultiClass->Rec;
3448 const Init *TemplArg = ParseDeclaration(CurRec, true /*templateargs*/);
3457 TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
3481 bool TGParser::ParseBodyItem(Record *CurRec) {
3483 return ParseAssert(nullptr, CurRec);
3486 return ParseDefvar(CurRec);
3489 return ParseDump(nullptr, CurRec);
3492 if (!ParseDeclaration(CurRec, false))
3516 RecordVal *Field = CurRec->getValue(FieldName);
3527 const Init *Val = ParseValue(CurRec, Type);
3533 return SetValue(CurRec, IdLoc, FieldName, BitList, Val);
3543 bool TGParser::ParseBody(Record *CurRec) {
3552 if (ParseBodyItem(CurRec))
3568 /// Apply the current let bindings to \a CurRec.
3570 bool TGParser::ApplyLetStack(Record *CurRec) {
3573 if (SetValue(CurRec, LR.Loc, LR.Name, LR.Bits, LR.Value))
3600 /// optional ClassList followed by a Body. CurRec is the current def or class
3608 bool TGParser::ParseObjectBody(Record *CurRec) {
3610 TGVarScope *ObjectScope = PushScope(CurRec);
3615 SubClassReference SubClass = ParseSubClassReference(CurRec, false);
3621 if (AddSubClass(CurRec, SubClass))
3626 SubClass = ParseSubClassReference(CurRec, false);
3630 if (ApplyLetStack(CurRec))
3633 bool Result = ParseBody(CurRec);
3654 std::unique_ptr<Record> CurRec;
3660 CurRec = std::make_unique<Record>(Records.getNewAnonymousName(), DefLoc,
3663 CurRec = std::make_unique<Record>(Name, NameLoc, Records);
3666 if (ParseObjectBody(CurRec.get()))
3669 return addEntry(std::move(CurRec));
3758 bool TGParser::ParseDefvar(Record *CurRec) {
3769 if (CurRec) {
3770 auto *V = CurRec->getValue(DeclName->getValue());
3784 const Init *Value = ParseValue(CurRec);
3963 bool TGParser::ParseAssert(MultiClass *CurMultiClass, Record *CurRec) {
3968 const Init *Condition = ParseValue(CurRec);
3977 const Init *Message = ParseValue(CurRec);
3984 if (CurRec)
3985 CurRec->addAssertion(ConditionLoc, Condition, Message);
4004 Record *CurRec = const_cast<Record *>(Records.getClass(Name));
4005 if (CurRec) {
4007 if (!CurRec->getValues().empty() ||
4008 !CurRec->getSuperClasses().empty() ||
4009 !CurRec->getTemplateArgs().empty())
4010 return TokError("Class '" + CurRec->getNameInitAsString() +
4013 CurRec->updateClassLoc(Lex.getLoc());
4018 CurRec = NewRec.get();
4028 TGVarScope *ClassScope = PushScope(CurRec);
4031 if (ParseTemplateArgList(CurRec))
4034 if (ParseObjectBody(CurRec))
4038 CurRec->checkUnusedTemplateArgs();
4490 bool TGParser::ParseDump(MultiClass *CurMultiClass, Record *CurRec) {
4496 const Init *Message = ParseValue(CurRec);
4504 ->Fold(CurRec);
4509 if (CurRec)
4510 CurRec->addDump(Loc, Message);