[llvm][TableGen] Define FieldInit::isConcrete overload

[rriddle]

Summary

There are a few field init values that are concrete but not complete/foldable (e.g. ?). This allows for using those values as initializers without erroring out.

Example:

class A {
  string value = ?;
}
class B<A impl> : A {
  let value = impl.value; // This currently emits an error.
  let value = ?;          // This doesn't emit an error.
}

[jpienaar]

Looks good thanks

[tra]

LGTM, but wait a bit before landing in case @nhaehnle has concerns.

[tra]

LGTM to unblock our build/integration.

[nhaehnle]

Do you have a concrete example where this is used? I would have expected the A1.value to be resolved... the non-resolve-behavior was only kept around for bits in instruction encodings (Resolver::keepUnsetBits).

[rriddle]

In D74360#1878327, @nhaehnle wrote:

Do you have a concrete example where this is used? I would have expected the A1.value to be resolved... the non-resolve-behavior was only kept around for bits in instruction encodings (Resolver::keepUnsetBits).

This happens in MLIR where we use tablegen quite a bit, e.g. for defining operations.

https://github.com/llvm/llvm-project/blob/272d35aef5e0d32f12b700ea12c608e0323ceb3f/mlir/include/mlir/IR/OpBase.td#L683
https://github.com/llvm/llvm-project/blob/272d35aef5e0d32f12b700ea12c608e0323ceb3f/mlir/include/mlir/IR/OpBase.td#L636

[nhaehnle]

Okay. I prefer the resolution by dsanders in D74796 though, where the field reference ends up fully resolved to a ?

llvm/include/llvm/TableGen/Record.h

public:
   Init *getRecord() const { return Rec; }
   StringInit *getFieldName() const { return FieldName; }
 
   Init *getBit(unsigned Bit) const override;
 
   Init *resolveReferences(Resolver &R) const override;
   Init *Fold(Record *CurRec) const;
 
+  bool isConcrete() const override;
   std::string getAsString() const override {
     return Rec->getAsString() + "." + FieldName->getValue().str();
   }
 };
 
 /// (v a, b) - Represent a DAG tree value.  DAG inits are required
 /// to have at least one value then a (possibly empty) list of arguments.  Each
 /// argument can have a name associated with it.

llvm/lib/TableGen/Record.cpp

if (Def == CurRec)
                       Rec->getAsString() + "' is a forbidden self-reference");
     Init *FieldVal = Def->getValue(FieldName)->getValue();
     if (FieldVal->isComplete())
       return FieldVal;
   }
   return const_cast<FieldInit *>(this);
 }
 
+bool FieldInit::isConcrete() const {
+  if (DefInit *DI = dyn_cast<DefInit>(Rec)) {
+    Init *FieldVal = DI->getDef()->getValue(FieldName)->getValue();
+    return FieldVal->isConcrete();
+  }
+  return false;
+}
+
 static void ProfileCondOpInit(FoldingSetNodeID &ID,
                              ArrayRef<Init *> CondRange,
                              ArrayRef<Init *> ValRange,
                              const RecTy *ValType) {
   assert(CondRange.size() == ValRange.size() &&
          "Number of conditions and values must match!");
   ID.AddPointer(ValType);
   ArrayRef<Init *>::iterator Case = CondRange.begin();

llvm/test/TableGen/field-access-initializers.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// XFAIL: vg_leak
+
+// CHECK: --- Defs ---
+
+// CHECK: def A1 {
+// CHECK:   string value = ?;
+// CHECK: }
+
+// CHECK: def B1 {
+// CHECK:   string value = A1.value;
+// CHECK: }
+
+class A {
+  string value = ?;
+}
+
+class B<A impl> : A {
+  let value = impl.value;
+}
+
+def A1 : A;
+def B1 : B<A1>;