NFC: exp DXIL prereq: Separate llvm insts and dxil ops, add accessors (#7977)

This change creates separate lists for llvm instructions and dxil
operations, and adds accessors for these.

Author: tex3d

utils/hct/hctdb.py

@@ -342,7 +342,8 @@ class db_dxil(object):
     "A database of DXIL instruction data"
 
     def __init__(self):
-        self.instr = []  # DXIL instructions
+        self._llvm_insts = []  # LLVM instructions
+        self._dxil_ops = []  # DXIL operations
         self.enums = []  # enumeration types
         self.val_rules = []  # validation rules
         self.metadata = []  # named metadata (db_dxil_metadata)
@@ -373,8 +374,25 @@ def __init__(self):
         self.build_semantics()
         self.populate_counters()
 
+    def get_llvm_insts(self):
+        "Get all LLVM instructions."
+        for i in self._llvm_insts:
+            yield i
+
+    def get_dxil_ops(self):
+        "Get all DXIL operations."
+        for i in self._dxil_ops:
+            yield i
+
+    def get_all_insts(self):
+        "Get all instructions, including LLVM and DXIL operations."
+        for i in self._llvm_insts:
+            yield i
+        for i in self._dxil_ops:
+            yield i
+
     def __str__(self):
-        return "\n".join(str(i) for i in self.instr)
+        return "\n".join(str(i) for i in self.get_all_insts())
 
     def next_id(self):
         "Returns the next available DXIL op ID and increments the counter"
@@ -397,11 +415,10 @@ def build_opcode_enum(self):
         # Keep track of last seen class/category pairs for OpCodeClass
         class_dict = {}
         class_dict["LlvmInst"] = "LLVM Instructions"
-        for i in self.instr:
-            if i.is_dxil_op:
-                v = OpCodeEnum.add_value(i.dxil_opid, i.dxil_op, i.doc)
-                v.category = i.category
-                class_dict[i.dxil_class] = i.category
+        for i in self.get_dxil_ops():
+            v = OpCodeEnum.add_value(i.dxil_opid, i.dxil_op, i.doc)
+            v.category = i.category
+            class_dict[i.dxil_class] = i.category
 
         # Build OpCodeClass enum
         OpCodeClass = self.add_enum_type(
@@ -574,7 +591,7 @@ def populate_categories_and_models(self):
             self.name_idx[i].category = "Other"
         for i in "LegacyF32ToF16,LegacyF16ToF32".split(","):
             self.name_idx[i].category = "Legacy floating-point"
-        for i in self.instr:
+        for i in self.get_dxil_ops():
             if i.name.startswith("Wave"):
                 i.category = "Wave"
                 i.is_wave = True
@@ -5907,20 +5924,16 @@ def UFI(name, **mappings):
 
         # TODO - some arguments are required to be immediate constants in DXIL, eg resource kinds; add this information
         # consider - report instructions that are overloaded on a single type, then turn them into non-overloaded version of that type
-        self.verify_dense(
-            self.get_dxil_insts(), lambda x: x.dxil_opid, lambda x: x.name
-        )
-        for i in self.instr:
+        self.verify_dense(self.get_dxil_ops(), lambda x: x.dxil_opid, lambda x: x.name)
+        for i in self.get_all_insts():
             self.verify_dense(i.ops, lambda x: x.pos, lambda x: i.name)
 
         # Verify that all operations in each class have the same signature.
         import itertools
 
         class_sort_func = lambda x, y: x < y
         class_key_func = lambda x: x.dxil_class
-        instr_ordered_by_class = sorted(
-            [i for i in self.instr if i.is_dxil_op], key=class_key_func
-        )
+        instr_ordered_by_class = sorted(self.get_dxil_ops(), key=class_key_func)
         instr_grouped_by_class = itertools.groupby(
             instr_ordered_by_class, key=class_key_func
         )
@@ -8492,9 +8505,9 @@ def build_valrules(self):
     def populate_counters(self):
         self.llvm_op_counters = set()
         self.dxil_op_counters = set()
-        for i in self.instr:
+        for i in self.get_all_insts():
             counters = getattr(i, "props", {}).get("counters", ())
-            if i.dxil_opid:
+            if i.is_dxil_op:
                 self.dxil_op_counters.update(counters)
             else:
                 self.llvm_op_counters.update(counters)
@@ -8518,7 +8531,10 @@ def add_inst(self, i):
             # These should not overlap, but UDiv is a known collision.
             assert i.name not in self.name_idx, f"Duplicate instruction name: {i.name}"
         self.name_idx[i.name] = i
-        self.instr.append(i)
+        if i.is_dxil_op:
+            self._dxil_ops.append(i)
+        else:
+            self._llvm_insts.append(i)
         return i
 
     def add_llvm_instr(
@@ -8581,23 +8597,18 @@ def reserve_dxil_op_range(self, group_name, count, start_reserved_id=0):
 
     def get_instr_by_llvm_name(self, llvm_name):
         "Return the instruction with the given LLVM name"
-        return next(i for i in self.instr if i.llvm_name == llvm_name)
-
-    def get_dxil_insts(self):
-        for i in self.instr:
-            if i.dxil_op != "":
-                yield i
+        return next(i for i in self.get_llvm_insts() if i.llvm_name == llvm_name)
 
     def print_stats(self):
         "Print some basic statistics on the instruction database."
-        print("Instruction count:                  %d" % len(self.instr))
+        print("Instruction count:                  %d" % len(self.get_all_insts()))
         print(
             "Max parameter count in instruction: %d"
-            % max(len(i.ops) - 1 for i in self.instr)
+            % max(len(i.ops) - 1 for i in self.get_all_insts())
         )
         print(
             "Parameter count:                    %d"
-            % sum(len(i.ops) - 1 for i in self.instr)
+            % sum(len(i.ops) - 1 for i in self.get_all_insts())
         )
 
 

utils/hct/hctdb_instrhelp.py

@@ -151,12 +151,10 @@ class db_docsref_gen:
 
     def __init__(self, db):
         self.db = db
-        instrs = [i for i in self.db.instr if i.is_dxil_op]
-        instrs = sorted(
-            instrs,
+        self.instrs = sorted(
+            self.db.get_dxil_ops(),
             key=lambda v: ("" if v.category == None else v.category) + "." + v.name,
         )
-        self.instrs = instrs
         val_rules = sorted(
             db.val_rules,
             key=lambda v: ("" if v.category == None else v.category) + "." + v.name,
@@ -328,7 +326,7 @@ def op_set_const_expr(self, o):
         )
 
     def print_body(self):
-        for i in self.db.instr:
+        for i in self.db.get_all_insts():
             if i.is_reserved:
                 continue
             if i.inst_helper_prefix:
@@ -491,8 +489,7 @@ class db_oload_gen:
 
     def __init__(self, db):
         self.db = db
-        instrs = [i for i in self.db.instr if i.is_dxil_op]
-        self.instrs = sorted(instrs, key=lambda i: i.dxil_opid)
+        self.instrs = sorted(self.db.get_dxil_ops(), key=lambda i: i.dxil_opid)
 
         # Allow these to be overridden by external scripts.
         self.OP = "OP"
@@ -907,7 +904,7 @@ def op_const_expr(self, o):
         )
 
     def print_body(self):
-        llvm_instrs = [i for i in self.db.instr if i.is_allowed and not i.is_dxil_op]
+        llvm_instrs = [i for i in self.db.get_llvm_insts() if i.is_allowed]
         print("static bool IsLLVMInstructionAllowed(llvm::Instruction &I) {")
         self.print_comment(
             "  // ",
@@ -1253,7 +1250,7 @@ def get_instrs_pred(varname, pred, attr_name="dxil_opid"):
         pred_fn = lambda i: getattr(i, pred)
     else:
         pred_fn = pred
-    llvm_instrs = [i for i in db.instr if pred_fn(i)]
+    llvm_instrs = [i for i in db.get_all_insts() if pred_fn(i)]
     result = format_comment(
         "// ",
         "Instructions: %s"
@@ -1296,7 +1293,7 @@ def get_dxil_op_counters():
 def get_instrs_rst():
     "Create an rst table of allowed LLVM instructions."
     db = get_db_dxil()
-    instrs = [i for i in db.instr if i.is_allowed and not i.is_dxil_op]
+    instrs = [i for i in db.get_llvm_insts() if i.is_allowed]
     instrs = sorted(instrs, key=lambda v: v.llvm_id)
     rows = []
     rows.append(["Instruction", "Action", "Operand overloads"])
@@ -1377,8 +1374,7 @@ def get_is_pass_option_name():
 def get_opcodes_rst():
     "Create an rst table of opcodes"
     db = get_db_dxil()
-    instrs = [i for i in db.instr if i.is_allowed and i.is_dxil_op]
-    instrs = sorted(instrs, key=lambda v: v.dxil_opid)
+    instrs = sorted(db.get_dxil_ops(), key=lambda v: v.dxil_opid)
     rows = []
     rows.append(["ID", "Name", "Description"])
     for i in instrs:
@@ -1412,8 +1408,7 @@ def get_valrules_rst():
 def get_opsigs():
     # Create a list of DXIL operation signatures, sorted by ID.
     db = get_db_dxil()
-    instrs = [i for i in db.instr if i.is_dxil_op]
-    instrs = sorted(instrs, key=lambda v: v.dxil_opid)
+    instrs = sorted(db.get_dxil_ops(), key=lambda v: v.dxil_opid)
     # db_dxil already asserts that the numbering is dense.
     # Create the code to write out.
     code = "static const char *OpCodeSignatures[] = {\n"
@@ -1455,9 +1450,8 @@ def get_opsigs():
 
 def get_min_sm_and_mask_text():
     db = get_db_dxil()
-    instrs = [i for i in db.instr if i.is_dxil_op]
     instrs = sorted(
-        instrs,
+        db.get_dxil_ops(),
         key=lambda v: (
             v.shader_model,
             v.shader_model_translated,
@@ -1546,9 +1540,8 @@ def flush_instrs(grouped_instrs, last_model, last_model_translated, last_stage):
 
 def get_valopcode_sm_text():
     db = get_db_dxil()
-    instrs = [i for i in db.instr if i.is_dxil_op]
     instrs = sorted(
-        instrs, key=lambda v: (v.shader_model, v.shader_stages, v.dxil_opid)
+        db.get_dxil_ops(), key=lambda v: (v.shader_model, v.shader_stages, v.dxil_opid)
     )
     last_model = None
     last_stage = None