TableGen: Get rid of Init::getFieldInit

[nhaehnle]

Summary

FieldInit will just rely on the standardized resolving mechanism to give
us DefInits for folding, thus simplifying the code.

Unlike the removal of resolveListElementReference, this shouldn't have
performance implications, because DefInits do not recurse inside their
record.

Change-Id: Id4544c774c9d9ee92f293615af6ecff706453f21

[tra]

lib/TableGen/Record.cpp

1377 ↗

(On Diff #135224)

assert(RV) as we no longer allow it to be nullptr.

[nhaehnle]

lib/TableGen/Record.cpp

1377 ↗

(On Diff #135224)

Actually no, this is on purpose. resolveReferences works fine with RV == nullptr, it just has subtly different semantics (resolving via R.getValue() instead of resolving only RV). All the other recursive resolving calls look like this as well, e.g. when resolving the list in a VarListElementInit or operands of OpInit subclasses. The whole point of this change is to streamline the resolving process in FieldInit as well.

I haven't looked into the full history of this, but I suspect somebody mistakenly decided to skip the recursive resolveReferences call in the !RV call, and then somebody else added the special code in VarInit::getFieldInit to fix one particular case that ended up being broken by the lack of resolve calls.

Whatever the history, the Right Thing to do is for all composite Inits to recursively resolve their components in a standardized way. I have an upcoming change that does a similar thing with BitsInit.

[nhaehnle]

lib/TableGen/Record.cpp

1377 ↗

(On Diff #135224)

That should have read: ... mistakenly decided to skip the recursive resolveReferences call in the !RV case.

Point is, VarInit::getFieldInit papers over this mistake in some specific cases but not all.

llvm/trunk/include/llvm/TableGen/Record.h

public:
 
   /// This method is used to implement the FieldInit class.
   /// Implementors of this method should return the type of the named field if
   /// they are of record type.
   virtual RecTy *getFieldType(StringInit *FieldName) const {
     return nullptr;
   }
 
-  /// This method complements getFieldType to return the
-  /// initializer for the specified field.  If getFieldType returns non-null
-  /// this method should return non-null, otherwise it returns null.
-  virtual Init *getFieldInit(Record &R, const RecordVal *RV,
-                             StringInit *FieldName) const {
-    return nullptr;
-  }
-
   /// This method is used by classes that refer to other
   /// variables which may not be defined at the time the expression is formed.
   /// If a value is set for the variable later, this method will be called on
   /// users of the value to allow the value to propagate out.
   virtual Init *resolveReferences(Record &R, const RecordVal *RV) const {
     return const_cast<Init *>(this);
   }
 
public:
   StringRef getName() const;
   Init *getNameInit() const { return VarName; }
 
   std::string getNameInitAsString() const {
     return getNameInit()->getAsUnquotedString();
   }
 
   RecTy *getFieldType(StringInit *FieldName) const override;
-  Init *getFieldInit(Record &R, const RecordVal *RV,
-                     StringInit *FieldName) const override;
 
   /// This method is used by classes that refer to other
   /// variables which may not be defined at the time they expression is formed.
   /// If a value is set for the variable later, this method will be called on
   /// users of the value to allow the value to propagate out.
   ///
   Init *resolveReferences(Record &R, const RecordVal *RV) const override;
 
public:
 
   Init *convertInitializerTo(RecTy *Ty) const override;
 
   Record *getDef() const { return Def; }
 
   //virtual Init *convertInitializerBitRange(ArrayRef<unsigned> Bits);
 
   RecTy *getFieldType(StringInit *FieldName) const override;
-  Init *getFieldInit(Record &R, const RecordVal *RV,
-                     StringInit *FieldName) const override;
 
   std::string getAsString() const override;
 
   Init *getBit(unsigned Bit) const override {
     llvm_unreachable("Illegal bit reference off def");
   }
 };
 

llvm/trunk/lib/TableGen/Record.cpp

 
 RecTy *VarInit::getFieldType(StringInit *FieldName) const {
   if (RecordRecTy *RTy = dyn_cast<RecordRecTy>(getType()))
     if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName))
       return RV->getType();
   return nullptr;
 }
 
-Init *VarInit::getFieldInit(Record &R, const RecordVal *RV,
-                            StringInit *FieldName) const {
-  if (isa<RecordRecTy>(getType()))
-    if (const RecordVal *Val = R.getValue(VarName)) {
-      if (RV != Val && (RV || isa<UnsetInit>(Val->getValue())))
-        return nullptr;
-      Init *TheInit = Val->getValue();
-      assert(TheInit != this && "Infinite loop detected!");
-      if (Init *I = TheInit->getFieldInit(R, RV, FieldName))
-        return I;
-      return nullptr;
-    }
-  return nullptr;
-}
-
 Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) const {
   if (RecordVal *Val = R.getValue(VarName))
     if (RV == Val || (!RV && !isa<UnsetInit>(Val->getValue())))
       return Val->getValue();
   return const_cast<VarInit *>(this);
 }
 
 VarBitInit *VarBitInit::get(TypedInit *T, unsigned B) {

 }
 
 RecTy *DefInit::getFieldType(StringInit *FieldName) const {
   if (const RecordVal *RV = Def->getValue(FieldName))
     return RV->getType();
   return nullptr;
 }
 
-Init *DefInit::getFieldInit(Record &R, const RecordVal *RV,
-                            StringInit *FieldName) const {
-  return Def->getValue(FieldName)->getValue();
-}
-
 std::string DefInit::getAsString() const {
   return Def->getName();
 }
 
 FieldInit *FieldInit::get(Init *R, StringInit *FN) {
   using Key = std::pair<Init *, StringInit *>;
   static DenseMap<Key, FieldInit*> ThePool;
 
   Key TheKey(std::make_pair(R, FN));
 
   FieldInit *&I = ThePool[TheKey];
   if (!I) I = new(Allocator) FieldInit(R, FN);
   return I;
 }
 
 Init *FieldInit::getBit(unsigned Bit) const {
   if (getType() == BitRecTy::get())
     return const_cast<FieldInit*>(this);
   return VarBitInit::get(const_cast<FieldInit*>(this), Bit);
 }
 
 Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const {
-  Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
+  Init *NewRec = Rec->resolveReferences(R, RV);
 
-  if (Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName)) {
-    Init *BVR = BitsVal->resolveReferences(R, RV);
-    return BVR->isComplete() ? BVR : const_cast<FieldInit *>(this);
+  if (DefInit *DI = dyn_cast<DefInit>(NewRec)) {
+    Init *FieldVal = DI->getDef()->getValue(FieldName)->getValue();
+    Init *BVR = FieldVal->resolveReferences(R, RV);
+    if (BVR->isComplete())
+      return BVR;
   }
 
   if (NewRec != Rec)
     return FieldInit::get(NewRec, FieldName);
   return const_cast<FieldInit *>(this);
 }
 
 static void ProfileDagInit(FoldingSetNodeID &ID, Init *V, StringInit *VN,