[RISCV]Add support for resolving encoding conflicts among vendor specific CSRs

quic-garvgupt · quic-garvgupt · commit 40fb941e96e7 · 2024-07-09T07:23:12.000-07:00
This patch adds the framework for resolving encoding conflicts among CSRs.

Specifically, this patch adds a support for emitting a new lookup function for
the primary key which return a pair of iterators pointing to first and last
value hence giving a range of values which satisfies the query.

While printing the CSR name during objdump, iterate over the range and print the
name of only that CSR which satisifes the feature requirement of subtarget.

Below is the signature of the new function that will be emitted for primary key:

```
llvm::iterator_range&lt;const SysReg *&gt; lookupSysRegByEncoding(uint16_t Encoding) {
  struct KeyType {
    uint16_t Encoding;
  };
  KeyType Key = {Encoding};
  struct Comp {
    bool operator()(const SysReg &amp;LHS, const KeyType &amp;RHS) const {
      if (LHS.Encoding &lt; RHS.Encoding)
        return true;
      if (LHS.Encoding &gt; RHS.Encoding)
        return false;
      return false;
    }
    bool operator()(const KeyType &amp;LHS, const SysReg &amp;RHS) const {
      if (LHS.Encoding &lt; RHS.Encoding)
        return true;
      if (LHS.Encoding &gt; RHS.Encoding)
        return false;
      return false;
    }
  };
  auto Table = ArrayRef(SysRegsList);
  auto It = std::equal_range(Table.begin(), Table.end(), Key, Comp());
  return llvm::make_range(It.first, It.second);
}
```

NOTE: Emitting a different signature for returning a range of results is only
supported by primary key.
diff --git a/llvm/docs/TableGen/BackEnds.rst b/llvm/docs/TableGen/BackEnds.rst
@@ -717,6 +717,12 @@ This class provides six fields.
 
 * ``bit PrimaryKeyEarlyOut``. See the third example below.
 
+* ``bit PrimaryKeyReturnRange``. when set to 1, modifies the lookup function’s
+  definition to return a range of results rather than a single pointer to the
+  object. This feature proves useful when multiple objects meet the criteria
+  specified by the lookup function. Currently, it is supported only for primary
+  lookup functions. Refer to the fourth example below for further details.
+
 TableGen attempts to deduce the type of each of the table fields so that it
 can format the C++ initializers in the emitted table. It can deduce ``bit``,
 ``bits<n>``, ``string``, ``Intrinsic``, and ``Instruction``.  These can be
@@ -972,6 +978,79 @@ The generated tables are:
     { 0x9 }, // 4
   };
 
+.. code-block:: text
+
+  class SysReg<string name, bits<12> op> {
+    string Name = name;
+    bits<12> Encoding = op;
+    code FeaturesRequired = [{ {} }];
+  }
+
+  def List1 : GenericTable {
+    let FilterClass = "SysReg";
+    let Fields = [
+      "Name", "Encoding", "FeaturesRequired",
+    ];
+
+    let PrimaryKey = [ "Encoding" ];
+    let PrimaryKeyName = "lookupSysRegByEncoding";
+    let PrimaryKeyReturnRange = true;
+  }
+
+  let FeaturesRequired = [{ {Feature1} }] in {
+  def : SysReg<"csr1", 0x7C0>;
+  }
+
+  let FeaturesRequired = [{ {Feature2} }] in {
+  def : SysReg<"csr2", 0x7C0>;
+  }
+
+The generated table is:
+
+.. code-block:: text
+
+  constexpr SysReg List1[] = {
+    { "csr1", 0x7C0,  {Feature1}  }, // 0
+    { "csr2", 0x7C0,  {Feature2}  }, // 1
+  };
+
+In the table above, both csr1 and csr2 share the same encoding. When
+``PrimaryKeyReturnRange`` is set to false, the lookupSysRegByEncoding function
+consistently returns the first CSR (in this case, csr1). However, this approach
+may not always be suitable. To address this, if scenarios exist where multiple
+objects match the criteria sought by the lookup function, we can
+return a range of results by setting ``PrimaryKeyReturnRange`` to true.
+Below, you’ll find the C++ code emitted for the above example when
+``PrimaryKeyReturnRange`` is enabled.
+
+.. code-block:: text
+
+  llvm::iterator_range<const SysReg *> lookupSysRegByEncoding(uint16_t Encoding) {
+    struct KeyType {
+      uint16_t Encoding;
+    };
+    KeyType Key = {Encoding};
+    struct Comp {
+      bool operator()(const SysReg &LHS, const KeyType &RHS) const {
+        if (LHS.Encoding < RHS.Encoding)
+          return true;
+        if (LHS.Encoding > RHS.Encoding)
+          return false;
+        return false;
+      }
+      bool operator()(const KeyType &LHS, const SysReg &RHS) const {
+        if (LHS.Encoding < RHS.Encoding)
+          return true;
+        if (LHS.Encoding > RHS.Encoding)
+          return false;
+        return false;
+      }
+    };
+    auto Table = ArrayRef(List1);
+    auto It = std::equal_range(Table.begin(), Table.end(), Key, Comp());
+    return llvm::make_range(It.first, It.second);
+  }
+
 Search Indexes
 ~~~~~~~~~~~~~~
 
@@ -987,6 +1066,8 @@ function. This class provides three fields.
 
 * ``bit EarlyOut``. See the third example in `Generic Tables`_.
 
+* ``bit ReturnRange``. See the fourth example in `Generic Tables`_.
+
 Here is an example of a secondary key added to the ``CTable`` above. The
 generated function looks up entries based on the ``Name`` and ``Kind`` fields.
 
diff --git a/llvm/include/llvm/TableGen/SearchableTable.td b/llvm/include/llvm/TableGen/SearchableTable.td
@@ -114,6 +114,9 @@ class GenericTable {
 
   // See SearchIndex.EarlyOut
   bit PrimaryKeyEarlyOut = false;
+
+  // See SearchIndex.ReturnRange
+  bit PrimaryKeyReturnRange = false;
 }
 
 // Define a record derived from this class to generate an additional search
@@ -135,6 +138,12 @@ class SearchIndex {
   //
   // Can only be used when the first field is an integral (non-string) type.
   bit EarlyOut = false;
+
+  // If true, will generate a different function signature which will return an
+  // iterator range of pointers giving the starting and end value of the range.
+  // This feature is only supported for primary key only.
+  // e.g. lookupSysRegByEncoding returns multiple CSRs for same encoding.
+  bit ReturnRange = false;
 }
 
 // Legacy table type with integrated enum.
diff --git a/llvm/test/TableGen/ReturnRange.td b/llvm/test/TableGen/ReturnRange.td
@@ -0,0 +1,108 @@
+// RUN: llvm-tblgen -gen-searchable-tables -I %p/../../include %s | FileCheck %s
+// RUN: not llvm-tblgen -DERROR -gen-searchable-tables -I %p/../../include %s 2>&1 \
+// RUN:         | FileCheck  --check-prefix=ERROR %s
+
+include "llvm/TableGen/SearchableTable.td"
+
+class SysReg<string name, bits<12> op> {
+  string Name = name;
+  bits<12> Encoding = op;
+  code FeaturesRequired = [{ {} }];
+}
+
+def List1 : GenericTable {
+  let FilterClass = "SysReg";
+  let Fields = [
+     "Name", "Encoding", "FeaturesRequired",
+  ];
+
+  let PrimaryKey = [ "Encoding" ];
+  let PrimaryKeyName = "lookupSysRegByEncoding";
+  let PrimaryKeyReturnRange = true;
+}
+
+let FeaturesRequired = [{ {Feature1} }] in {
+def : SysReg<"csr1", 0x7C0>;
+}
+
+let FeaturesRequired = [{ {Feature2} }] in {
+def : SysReg<"csr2", 0x7C0>;
+}
+
+def lookupSysRegByName : SearchIndex {
+  let Table = List1;
+  let Key = [ "Name" ];
+#ifdef ERROR
+  // ERROR: Emitting different signature for returning a range of results is only supported for Primary Key.
+  let ReturnRange = true;
+#endif
+}
+
+// CHECK: #ifdef GET_List1_DECL
+// CHECK-NEXT: llvm::iterator_range<const SysReg *> lookupSysRegByEncoding(uint16_t Encoding);
+// CHECK-NEXT: onst SysReg *lookupSysRegByName(StringRef Name);
+// CHECK-NEXT: #endif
+
+// CHECK: #ifdef GET_List1_IMPL
+// CHECK-NEXT: constexpr SysReg List1[] = {
+// CHECK-NEXT:   { "csr1", 0x7C0,  {Feature1}  }, // 0
+// CHECK-NEXT:   { "csr2", 0x7C0,  {Feature2}  }, // 1
+// CHECK-NEXT:  };
+
+// CHECK: llvm::iterator_range<const SysReg *> lookupSysRegByEncoding(uint16_t Encoding) {
+// CHECK-NEXT: struct KeyType {
+// CHECK-NEXT:    uint16_t Encoding;
+// CHECK-NEXT:  };
+// CHECK-NEXT:  KeyType Key = {Encoding};
+// CHECK-NEXT:  struct Comp {
+// CHECK-NEXT:    bool operator()(const SysReg &LHS, const KeyType &RHS) const {
+// CHECK-NEXT:      if (LHS.Encoding < RHS.Encoding)
+// CHECK-NEXT:        return true;
+// CHECK-NEXT:      if (LHS.Encoding > RHS.Encoding)
+// CHECK-NEXT:        return false;
+// CHECK-NEXT:      return false;
+// CHECK-NEXT:    }
+// CHECK-NEXT:    bool operator()(const KeyType &LHS, const SysReg &RHS) const {
+// CHECK-NEXT:      if (LHS.Encoding < RHS.Encoding)
+// CHECK-NEXT:        return true;
+// CHECK-NEXT:      if (LHS.Encoding > RHS.Encoding)
+// CHECK-NEXT:        return false;
+// CHECK-NEXT:      return false;
+// CHECK-NEXT:    }
+// CHECK-NEXT:  };
+// CHECK-NEXT:  auto Table = ArrayRef(List1);
+// CHECK-NEXT:  auto It = std::equal_range(Table.begin(), Table.end(), Key, Comp());
+// CHECK-NEXT:  return llvm::make_range(It.first, It.second);
+// CHECK-NEXT: }
+
+// CHECK: const SysReg *lookupSysRegByName(StringRef Name) {
+// CHECK-NEXT:   struct IndexType {
+// CHECK-NEXT:     const char * Name;
+// CHECK-NEXT:     unsigned _index;
+// CHECK-NEXT:   };
+// CHECK-NEXT:   static const struct IndexType Index[] = {
+// CHECK-NEXT:     { "CSR1", 0 },
+// CHECK-NEXT:     { "CSR2", 1 },
+// CHECK-NEXT:   };
+
+// CHECK:   struct KeyType {
+// CHECK-NEXT:     std::string Name;
+// CHECK-NEXT:   };
+// CHECK-NEXT:   KeyType Key = {Name.upper()};
+// CHECK-NEXT:   struct Comp {
+// CHECK-NEXT:     bool operator()(const IndexType &LHS, const KeyType &RHS) const {
+// CHECK-NEXT:       int CmpName = StringRef(LHS.Name).compare(RHS.Name);
+// CHECK-NEXT:       if (CmpName < 0) return true;
+// CHECK-NEXT:       if (CmpName > 0) return false;
+// CHECK-NEXT:       return false;
+// CHECK-NEXT:     }
+// CHECK-NEXT:   };
+// CHECK-NEXT:   auto Table = ArrayRef(Index);
+// CHECK-NEXT:   auto Idx = std::lower_bound(Table.begin(), Table.end(), Key, Comp());
+// CHECK-NEXT:   if (Idx == Table.end() ||
+// CHECK-NEXT:       Key.Name != Idx->Name)
+// CHECK-NEXT:     return nullptr;
+
+// CHECK:  return &List1[Idx->_index];
+// CHECK-NEXT: }
+// CHECK-NEXT: #endif
diff --git a/llvm/utils/TableGen/SearchableTableEmitter.cpp b/llvm/utils/TableGen/SearchableTableEmitter.cpp
