Lines Matching defs:CurRec
112 /// to CurRec's name.
113 static Init *QualifyName(Record &CurRec, Init *Name) {
114 RecordKeeper &RK = CurRec.getRecords();
116 CurRec.getNameInit(),
117 StringInit::get(RK, CurRec.isMultiClass() ? "::" : ":"));
121 NewName = BinOp->Fold(&CurRec);
169 if (CurRec) {
171 if (RecordVal *RV = CurRec->getValue(Name)) {
178 if (CurRec->isClass())
179 if (auto *V = FindValueInArgs(CurRec, Name))
210 bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
211 if (!CurRec)
212 CurRec = &CurMultiClass->Rec;
214 if (RecordVal *ERV = CurRec->getValue(RV.getNameInit())) {
222 CurRec->addValue(RV);
229 bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
234 if (!CurRec) CurRec = &CurMultiClass->Rec;
236 RecordVal *RV = CurRec->getValue(ValName);
296 /// AddSubClass - Add SubClass as a subclass to CurRec, resolving its template
298 bool TGParser::AddSubClass(Record *CurRec, SubClassReference &SubClass) {
300 MapResolver R(CurRec);
306 if (AddValue(CurRec, SubClass.RefRange.Start, Field))
314 CurRec->appendAssertions(SC);
317 CurRec->appendDumps(SC);
320 if (CurRec->isClass())
321 Name = VarInit::get(QualifiedNameOfImplicitName(*CurRec),
324 Name = CurRec->getNameInit();
327 CurRec->resolveReferences(R);
333 if (CurRec->isSubClassOf(SCPair.first))
336 CurRec->addSuperClass(SCPair.first, SCPair.second);
339 if (CurRec->isSubClassOf(SC))
342 CurRec->addSuperClass(SC, SubClass.RefRange);
683 Record *CurRec = nullptr;
685 CurRec = &CurMultiClass->Rec;
687 Init *Name = ParseValue(CurRec, StringRecTy::get(Records), ParseNameMode);
756 ParseSubClassReference(Record *CurRec, bool isDefm) {
774 if (ParseTemplateArgValueList(Result.TemplateArgs, CurRec, Result.Rec)) {
831 TypedInit *TGParser::ParseSliceElement(Record *CurRec) {
833 auto *CurVal = ParseValue(CurRec);
844 CurVal = ParseValue(CurRec);
881 ->Fold(CurRec));
895 TypedInit *TGParser::ParseSliceElements(Record *CurRec, bool Single) {
909 CurVal = ParseSliceElement(CurRec);
1153 Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMRange NameLoc,
1173 if (CurRec && !CurRec->isClass() && !CurMultiClass &&
1174 CurRec->getNameInit() == Name)
1175 return UnOpInit::get(UnOpInit::CAST, Name, CurRec->getType());
1185 Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
1289 Init *LHS = ParseValue(CurRec);
1351 return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec);
1367 Init *LHS = ParseValue(CurRec);
1393 Init *Expr = ParseValue(CurRec);
1422 return (ExistsOpInit::get(Type, Expr))->Fold(CurRec);
1572 InitList.push_back(ParseValue(CurRec, ArgType));
1746 RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))->Fold(CurRec);
1753 ->Fold(CurRec);
1761 return ParseOperationForEachFilter(CurRec, ItemType);
1782 Args.push_back(ParseValue(CurRec));
1834 ->Fold(CurRec);
1860 ->Fold(CurRec);
1902 Init *LHS = ParseValue(CurRec);
1911 Init *MHS = ParseValue(CurRec, ItemType);
1921 Init *RHS = ParseValue(CurRec, ItemType);
2038 return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
2042 return ParseOperationSubstr(CurRec, ItemType);
2045 return ParseOperationFind(CurRec, ItemType);
2048 return ParseOperationCond(CurRec, ItemType);
2058 Init *StartUntyped = ParseValue(CurRec);
2074 Init *ListUntyped = ParseValue(CurRec);
2103 if (CurRec && CurRec->getValue(A)) {
2121 if (CurRec && CurRec->getValue(B)) {
2137 Record *ParseRec = CurRec;
2173 ->Fold(CurRec);
2212 Init *TGParser::ParseOperationSubstr(Record *CurRec, RecTy *ItemType) {
2223 Init *LHS = ParseValue(CurRec);
2233 Init *MHS = ParseValue(CurRec);
2241 RHS = ParseValue(CurRec);
2294 return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
2300 Init *TGParser::ParseOperationFind(Record *CurRec, RecTy *ItemType) {
2311 Init *LHS = ParseValue(CurRec);
2321 Init *MHS = ParseValue(CurRec);
2329 RHS = ParseValue(CurRec);
2382 return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
2389 Init *TGParser::ParseOperationForEachFilter(Record *CurRec, RecTy *ItemType) {
2406 if (CurRec && CurRec->getValue(LHS)) {
2418 Init *MHS = ParseValue(CurRec);
2476 Record *ParseRec = CurRec;
2510 ->Fold(CurRec);
2513 Init *TGParser::ParseOperationCond(Record *CurRec, RecTy *ItemType) {
2528 Init *V = ParseValue(CurRec);
2538 V = ParseValue(CurRec, ItemType);
2588 return CondOpInit::get(Case, Val, Type)->Fold(CurRec);
2618 Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
2625 return ParseOperation(CurRec, ItemType);
2679 return ParseIDValue(CurRec, Name, NameLoc, Mode); // Value ::= IDValue
2693 if (ParseTemplateArgValueList(Args, CurRec, Class))
2712 ParseValueList(Vals, CurRec);
2774 ParseValueList(Vals, CurRec,
2855 Init *Operator = ParseValue(CurRec);
2871 ParseDagArgList(DagArgs, CurRec);
2894 Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
2896 Init *Result = ParseSimpleValue(CurRec, ItemType, Mode);
2944 TypedInit *RHS = ParseSliceElements(CurRec, /*Single=*/true);
2950 BinOpInit::get(BinOpInit::LISTSLICE, LHS, RHS, LHSTy)->Fold(CurRec);
2954 ->Fold(CurRec);
2992 Result = FieldInit::get(Result, FieldName)->Fold(CurRec);
3018 Init *RHSResult = ParseValue(CurRec, ItemType, ParseValueMode);
3032 ->Fold(CurRec));
3057 Init *RHSResult = ParseValue(CurRec, nullptr, ParseNameMode);
3069 ->Fold(CurRec));
3095 Record *CurRec) {
3106 Init *Val = ParseValue(CurRec);
3137 void TGParser::ParseValueList(SmallVectorImpl<Init *> &Result, Record *CurRec,
3140 Result.push_back(ParseValue(CurRec, ItemType));
3150 Result.push_back(ParseValue(CurRec, ItemType));
3167 SmallVectorImpl<ArgumentInit *> &Result, Record *CurRec, Record *ArgsRec) {
3186 CurRec,
3206 Value = ParseValue(CurRec, NamedArg->getType());
3236 /// CurRec will be non-null) and within the template args for a multiclass (in
3237 /// which case CurRec will be null, but CurMultiClass will be set). This can
3239 /// CurRec and CurMultiClass.
3243 Init *TGParser::ParseDeclaration(Record *CurRec,
3273 BadField = AddValue(CurRec, IdLoc,
3277 } else if (CurRec) { // class template argument
3278 DeclName = QualifyName(*CurRec, DeclName);
3280 AddValue(CurRec, IdLoc,
3286 AddValue(CurRec, IdLoc,
3295 Init *Val = ParseValue(CurRec, Type);
3297 SetValue(CurRec, ValLoc, DeclName, std::nullopt, Val,
3391 /// sequence of template-declarations in <>'s. If CurRec is non-null, these are
3397 bool TGParser::ParseTemplateArgList(Record *CurRec) {
3401 Record *TheRecToAddTo = CurRec ? CurRec : &CurMultiClass->Rec;
3404 Init *TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
3413 TemplArg = ParseDeclaration(CurRec, true/*templateargs*/);
3437 bool TGParser::ParseBodyItem(Record *CurRec) {
3439 return ParseAssert(nullptr, CurRec);
3442 return ParseDefvar(CurRec);
3445 return ParseDump(nullptr, CurRec);
3448 if (!ParseDeclaration(CurRec, false))
3472 RecordVal *Field = CurRec->getValue(FieldName);
3483 Init *Val = ParseValue(CurRec, Type);
3489 return SetValue(CurRec, IdLoc, FieldName, BitList, Val);
3499 bool TGParser::ParseBody(Record *CurRec) {
3508 if (ParseBodyItem(CurRec))
3524 /// Apply the current let bindings to \a CurRec.
3526 bool TGParser::ApplyLetStack(Record *CurRec) {
3529 if (SetValue(CurRec, LR.Loc, LR.Name, LR.Bits, LR.Value))
3556 /// optional ClassList followed by a Body. CurRec is the current def or class
3564 bool TGParser::ParseObjectBody(Record *CurRec) {
3566 TGVarScope *ObjectScope = PushScope(CurRec);
3571 SubClassReference SubClass = ParseSubClassReference(CurRec, false);
3577 if (AddSubClass(CurRec, SubClass))
3582 SubClass = ParseSubClassReference(CurRec, false);
3586 if (ApplyLetStack(CurRec))
3589 bool Result = ParseBody(CurRec);
3610 std::unique_ptr<Record> CurRec;
3616 CurRec = std::make_unique<Record>(Records.getNewAnonymousName(), DefLoc,
3619 CurRec = std::make_unique<Record>(Name, NameLoc, Records);
3622 if (ParseObjectBody(CurRec.get()))
3625 return addEntry(std::move(CurRec));
3714 bool TGParser::ParseDefvar(Record *CurRec) {
3725 if (CurRec) {
3726 auto *V = CurRec->getValue(DeclName->getValue());
3740 Init *Value = ParseValue(CurRec);
3919 bool TGParser::ParseAssert(MultiClass *CurMultiClass, Record *CurRec) {
3924 Init *Condition = ParseValue(CurRec);
3933 Init *Message = ParseValue(CurRec);
3940 if (CurRec)
3941 CurRec->addAssertion(ConditionLoc, Condition, Message);
3960 Record *CurRec = Records.getClass(Name);
3961 if (CurRec) {
3963 if (!CurRec->getValues().empty() ||
3964 !CurRec->getSuperClasses().empty() ||
3965 !CurRec->getTemplateArgs().empty())
3966 return TokError("Class '" + CurRec->getNameInitAsString() +
3969 CurRec->updateClassLoc(Lex.getLoc());
3974 CurRec = NewRec.get();
3984 TGVarScope *ClassScope = PushScope(CurRec);
3987 if (ParseTemplateArgList(CurRec))
3990 if (ParseObjectBody(CurRec))
3994 CurRec->checkUnusedTemplateArgs();
4442 bool TGParser::ParseDump(MultiClass *CurMultiClass, Record *CurRec) {
4448 Init *Message = ParseValue(CurRec);
4456 ->Fold(CurRec);
4461 if (CurRec)
4462 CurRec->addDump(Loc, Message);