genxml: Add 3DSTATE_DEPTH_BOUNDS instruction.

[mesa.git] / src / intel / genxml / gen_pack_header.py

diff --git a/src/intel/genxml/gen_pack_header.py b/src/intel/genxml/gen_pack_header.py
index 8989f625d3120eab2c3ed2f9b8bc6d6ed9d63d43..118cc6330aff8277d3546a93dbade949e0298dbf 100644 (file)
--- a/src/intel/genxml/gen_pack_header.py
+++ b/src/intel/genxml/gen_pack_header.py
@@ -3,6 +3,7 @@
 from __future__ import (
     absolute_import, division, print_function, unicode_literals
 )
+import argparse
 import ast
 import xml.parsers.expat
 import re
@@ -196,7 +197,6 @@ def to_alphanum(name):
         '=': '',
         '>': '',
         '#': '',
-        'α': 'alpha',
         '&': '',
         '*': '',
         '"': '',
@@ -219,9 +219,9 @@ def safe_name(name):
 def num_from_str(num_str):
     if num_str.lower().startswith('0x'):
         return int(num_str, base=16)
-    else:
-        assert(not num_str.startswith('0') and 'octals numbers not allowed')
-        return int(num_str)
+
+    assert not num_str.startswith('0'), 'octals numbers not allowed'
+    return int(num_str)
 
 class Field(object):
     ufixed_pattern = re.compile(r"u(\d+)\.(\d+)")
@@ -235,13 +235,21 @@ class Field(object):
         self.end = int(attrs["end"])
         self.type = attrs["type"]
 
+        assert self.start <= self.end, \
+               'field {} has end ({}) < start ({})'.format(self.name, self.end,
+                                                           self.start)
+        if self.type == 'bool':
+            assert self.end == self.start, \
+                   'bool field ({}) is too wide'.format(self.name)
+
         if "prefix" in attrs:
             self.prefix = attrs["prefix"]
         else:
             self.prefix = None
 
         if "default" in attrs:
-            self.default = int(attrs["default"])
+            # Base 0 recognizes 0x, 0o, 0b prefixes in addition to decimal ints.
+            self.default = int(attrs["default"], base=0)
         else:
             self.default = None
 
@@ -298,7 +306,7 @@ class Field(object):
         print("   %-36s %s%s;" % (type, self.name, dim))
 
         prefix = ""
-        if len(self.values) > 0 and self.default == None:
+        if self.values and self.default is None:
             if self.prefix:
                 prefix = self.prefix + "_"
 
@@ -332,7 +340,7 @@ class Group(object):
 
     def collect_dwords(self, dwords, start, dim):
         for field in self.fields:
-            if type(field) is Group:
+            if isinstance(field, Group):
                 if field.count == 1:
                     field.collect_dwords(dwords, start + field.start, dim)
                 else:
@@ -416,7 +424,7 @@ class Group(object):
             # to the dword for those fields.
             field_index = 0
             for field in dw.fields:
-                if type(field) is Field and field.is_struct_type():
+                if isinstance(field, Field) and field.is_struct_type():
                     name = field.name + field.dim
                     print("")
                     print("   uint32_t v%d_%d;" % (index, field_index))
@@ -482,7 +490,7 @@ class Group(object):
                     non_address_fields.append("/* unhandled field %s, type %s */\n" % \
                                               (name, field.type))
 
-            if len(non_address_fields) > 0:
+            if non_address_fields:
                 print(" |\n".join("      " + f for f in non_address_fields) + ";")
 
             if dw.size == 32:
@@ -523,8 +531,7 @@ class Parser(object):
     def gen_prefix(self, name):
         if name[0] == "_":
             return 'GEN%s%s' % (self.gen, name)
-        else:
-            return 'GEN%s_%s' % (self.gen, name)
+        return 'GEN%s_%s' % (self.gen, name)
 
     def gen_guard(self):
         return self.gen_prefix("PACK_H")
@@ -538,6 +545,13 @@ class Parser(object):
             if name == "instruction":
                 self.instruction = safe_name(attrs["name"])
                 self.length_bias = int(attrs["bias"])
+                if "engine" in attrs:
+                    self.instruction_engines = set(attrs["engine"].split('|'))
+                else:
+                    # When an instruction doesn't have the engine specified,
+                    # it is considered to be for all engines, so 'None' is used
+                    # to signify that the instruction belongs to all engines.
+                    self.instruction_engines = None
             elif name == "struct":
                 self.struct = safe_name(attrs["name"])
                 self.structs[attrs["name"]] = 1
@@ -621,7 +635,10 @@ class Parser(object):
 
     def emit_instruction(self):
         name = self.instruction
-        if not self.length == None:
+        if self.instruction_engines and not self.instruction_engines & self.engines:
+            return
+
+        if not self.length is None:
             print('#define %-33s %6d' %
                   (self.gen_prefix(name + "_length"), self.length))
         print('#define %-33s %6d' %
@@ -629,9 +646,9 @@ class Parser(object):
 
         default_fields = []
         for field in self.group.fields:
-            if not type(field) is Field:
+            if not isinstance(field, Field):
                 continue
-            if field.default == None:
+            if field.default is None:
                 continue
             default_fields.append("   .%-35s = %6d" % (field.name, field.default))
 
@@ -646,11 +663,11 @@ class Parser(object):
 
     def emit_register(self):
         name = self.register
-        if not self.reg_num == None:
+        if not self.reg_num is None:
             print('#define %-33s 0x%04x' %
                   (self.gen_prefix(name + "_num"), self.reg_num))
 
-        if not self.length == None:
+        if not self.length is None:
             print('#define %-33s %6d' %
                   (self.gen_prefix(name + "_length"), self.length))
 
@@ -659,7 +676,7 @@ class Parser(object):
 
     def emit_struct(self):
         name = self.struct
-        if not self.length == None:
+        if not self.length is None:
             print('#define %-33s %6d' %
                   (self.gen_prefix(name + "_length"), self.length))
 
@@ -681,11 +698,36 @@ class Parser(object):
         self.parser.ParseFile(file)
         file.close()
 
-if len(sys.argv) < 2:
-    print("No input xml file specified")
-    sys.exit(1)
+def parse_args():
+    p = argparse.ArgumentParser()
+    p.add_argument('xml_source', metavar='XML_SOURCE',
+                   help="Input xml file")
+    p.add_argument('--engines', nargs='?', type=str, default='render',
+                   help="Comma-separated list of engines whose instructions should be parsed (default: %(default)s)")
+
+    pargs = p.parse_args()
+
+    if pargs.engines is None:
+        print("No engines specified")
+        sys.exit(1)
+
+    return pargs
+
+def main():
+    pargs = parse_args()
+
+    input_file = pargs.xml_source
+    engines = pargs.engines.split(',')
+    valid_engines = [ 'render', 'blitter', 'video' ]
+    if set(engines) - set(valid_engines):
+        print("Invalid engine specified, valid engines are:\n")
+        for e in valid_engines:
+            print("\t%s" % e)
+        sys.exit(1)
 
-input_file = sys.argv[1]
+    p = Parser()
+    p.engines = set(engines)
+    p.parse(input_file)
 
-p = Parser()
-p.parse(input_file)
+if __name__ == '__main__':
+    main()