aco: keep loop live-through variables spilled
[mesa.git] / src / amd / registers / makeregheader.py
1 from __future__ import absolute_import, division, print_function, unicode_literals
2
3 COPYRIGHT = '''
4 /*
5 * Copyright 2015-2019 Advanced Micro Devices, Inc.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * on the rights to use, copy, modify, merge, publish, distribute, sub
11 * license, and/or sell copies of the Software, and to permit persons to whom
12 * the Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
16 * Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
22 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24 * USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 */
27 '''
28 """
29 Create the (combined) register header from register JSON. Use --help for usage.
30 """
31
32 import argparse
33 from collections import defaultdict
34 import itertools
35 import json
36 import re
37 import sys
38
39 from regdb import Object, RegisterDatabase, deduplicate_enums, deduplicate_register_types
40
41
42 ######### BEGIN HARDCODED CONFIGURATION
43
44 # Chips are sorted chronologically
45 CHIPS = [
46 Object(name='gfx6', disambiguation='GFX6'),
47 Object(name='gfx7', disambiguation='GFX7'),
48 Object(name='gfx8', disambiguation='GFX8'),
49 Object(name='fiji', disambiguation='GFX8'),
50 Object(name='stoney', disambiguation='GFX8'),
51 Object(name='gfx9', disambiguation='GFX9'),
52 Object(name='gfx10', disambiguation='GFX10'),
53 ]
54
55 ######### END HARDCODED CONFIGURATION
56
57 def get_chip_index(chip):
58 """
59 Given a chip name, return its index in the global CHIPS list.
60 """
61 return next(idx for idx, obj in enumerate(CHIPS) if obj.name == chip)
62
63 def get_disambiguation_suffix(chips):
64 """
65 Disambiguation suffix to be used for an enum entry or field name that
66 is supported in the given set of chips.
67 """
68 oldest_chip_index = min([get_chip_index(chip) for chip in chips])
69 return CHIPS[oldest_chip_index].disambiguation
70
71 def get_chips_comment(chips, parent=None):
72 """
73 Generate a user-friendly comment describing the given set of chips.
74
75 The return value may be None, if such a comment is deemed unnecessary.
76
77 parent is an optional set of chips supporting a parent structure, e.g.
78 where chips may be the set of chips supporting a specific enum value,
79 parent would be the set of chips supporting the field containing the enum,
80 the idea being that no comment is necessary if all chips that support the
81 parent also support the child.
82 """
83 chipflags = [chip.name in chips for chip in CHIPS]
84 if all(chipflags):
85 return None
86
87 if parent is not None:
88 parentflags = [chip.name in parent for chip in CHIPS]
89 if all(childflag or not parentflag for childflag, parentflag in zip(chipflags, parentflags)):
90 return None
91
92 prefix = 0
93 for idx, chip, flag in zip(itertools.count(), CHIPS, chipflags):
94 if not flag:
95 break
96 prefix = idx + 1
97
98 suffix = len(CHIPS)
99 for idx, chip, flag in zip(itertools.count(), reversed(CHIPS), reversed(chipflags)):
100 if not flag:
101 break
102 suffix = len(CHIPS) - idx - 1
103
104 comment = []
105 if prefix > 0:
106 comment.append('<= {0}'.format(CHIPS[prefix - 1].name))
107 for chip, flag in zip(CHIPS[prefix:suffix], chipflags[prefix:suffix]):
108 if flag:
109 comment.append(chip.name)
110 if suffix < len(CHIPS):
111 comment.append('>= {0}'.format(CHIPS[suffix].name))
112
113 return ', '.join(comment)
114
115
116 class HeaderWriter(object):
117 def __init__(self, regdb, guard=None):
118 self.guard = guard
119
120 # The following contain: Object(address, chips, name, regmap/field/enumentry)
121 self.register_lines = []
122 self.field_lines = []
123 self.value_lines = []
124
125 regtype_emit = defaultdict(set)
126 enum_emit = defaultdict(set)
127
128 for regmap in regdb.register_mappings():
129 type_ref = getattr(regmap, 'type_ref', None)
130 self.register_lines.append(Object(
131 address=regmap.map.at,
132 chips=set(regmap.chips),
133 name=regmap.name,
134 regmap=regmap,
135 type_refs=set([type_ref]) if type_ref else set(),
136 ))
137
138 basename = re.sub(r'[0-9]+', '', regmap.name)
139 key = '{type_ref}::{basename}'.format(**locals())
140 if type_ref is not None and regtype_emit[key].isdisjoint(regmap.chips):
141 regtype_emit[key].update(regmap.chips)
142
143 regtype = regdb.register_type(type_ref)
144 for field in regtype.fields:
145 if field.name == 'RESERVED':
146 continue
147
148 enum_ref = getattr(field, 'enum_ref', None)
149 self.field_lines.append(Object(
150 address=regmap.map.at,
151 chips=set(regmap.chips),
152 name=field.name,
153 field=field,
154 bits=field.bits[:],
155 type_refs=set([type_ref]) if type_ref else set(),
156 enum_refs=set([enum_ref]) if enum_ref else set(),
157 ))
158
159 key = '{type_ref}::{basename}::{enum_ref}'.format(**locals())
160 if enum_ref is not None and enum_emit[key].isdisjoint(regmap.chips):
161 enum_emit[key].update(regmap.chips)
162
163 enum = regdb.enum(enum_ref)
164 for entry in enum.entries:
165 self.value_lines.append(Object(
166 address=regmap.map.at,
167 chips=set(regmap.chips),
168 name=entry.name,
169 enumentry=entry,
170 enum_refs=set([enum_ref]) if enum_ref else set(),
171 ))
172
173 # Merge register lines
174 lines = self.register_lines
175 lines.sort(key=lambda line: (line.address, line.name))
176
177 self.register_lines = []
178 for line in lines:
179 prev = self.register_lines[-1] if self.register_lines else None
180 if prev and prev.address == line.address and prev.name == line.name:
181 prev.chips.update(line.chips)
182 prev.type_refs.update(line.type_refs)
183 continue
184 self.register_lines.append(line)
185
186 # Merge field lines
187 lines = self.field_lines
188 lines.sort(key=lambda line: (line.address, line.name))
189
190 self.field_lines = []
191 for line in lines:
192 merged = False
193 for prev in reversed(self.field_lines):
194 if prev.address != line.address or prev.name != line.name:
195 break
196
197 # Can merge fields if they have the same starting bit and the
198 # range of the field as intended by the current line does not
199 # conflict with any of the regtypes covered by prev.
200 if prev.bits[0] != line.bits[0]:
201 continue
202
203 if prev.bits[1] < line.bits[1]:
204 # Current line's field extends beyond the range of prev.
205 # Need to check for conflicts
206 conflict = False
207 for type_ref in prev.type_refs:
208 for field in regdb.register_type(type_ref).fields:
209 # The only possible conflict is for a prev field
210 # that starts at a higher bit.
211 if (field.bits[0] > line.bits[0] and
212 field.bits[0] <= line.bits[1]):
213 conflict = True
214 break
215 if conflict:
216 break
217 if conflict:
218 continue
219
220 prev.bits[1] = max(prev.bits[1], line.bits[1])
221 prev.chips.update(line.chips)
222 prev.type_refs.update(line.type_refs)
223 prev.enum_refs.update(line.enum_refs)
224 merged = True
225 break
226 if not merged:
227 self.field_lines.append(line)
228
229 # Merge value lines
230 lines = self.value_lines
231 lines.sort(key=lambda line: (line.address, line.name))
232
233 self.value_lines = []
234 for line in lines:
235 for prev in reversed(self.value_lines):
236 if prev.address == line.address and prev.name == line.name and\
237 prev.enumentry.value == line.enumentry.value:
238 prev.chips.update(line.chips)
239 prev.enum_refs.update(line.enum_refs)
240 break
241 else:
242 self.value_lines.append(line)
243
244 # Disambiguate field and value lines
245 for idx, line in enumerate(self.field_lines):
246 prev = self.field_lines[idx - 1] if idx > 0 else None
247 next = self.field_lines[idx + 1] if idx + 1 < len(self.field_lines) else None
248 if (prev and prev.address == line.address and prev.field.name == line.field.name) or\
249 (next and next.address == line.address and next.field.name == line.field.name):
250 line.name += '_' + get_disambiguation_suffix(line.chips)
251
252 for idx, line in enumerate(self.value_lines):
253 prev = self.value_lines[idx - 1] if idx > 0 else None
254 next = self.value_lines[idx + 1] if idx + 1 < len(self.value_lines) else None
255 if (prev and prev.address == line.address and prev.enumentry.name == line.enumentry.name) or\
256 (next and next.address == line.address and next.enumentry.name == line.enumentry.name):
257 line.name += '_' + get_disambiguation_suffix(line.chips)
258
259 def print(self, filp, sort='address'):
260 """
261 Print out the entire register header.
262 """
263 if sort == 'address':
264 self.register_lines.sort(key=lambda line: (line.address, line.name))
265 else:
266 assert sort == 'name'
267 self.register_lines.sort(key=lambda line: (line.name, line.address))
268
269 # Collect and sort field lines by address
270 field_lines_by_address = defaultdict(list)
271 for line in self.field_lines:
272 field_lines_by_address[line.address].append(line)
273 for field_lines in field_lines_by_address.values():
274 if sort == 'address':
275 field_lines.sort(key=lambda line: (line.bits[0], line.name))
276 else:
277 field_lines.sort(key=lambda line: (line.name, line.bits[0]))
278
279 # Collect and sort value lines by address
280 value_lines_by_address = defaultdict(list)
281 for line in self.value_lines:
282 value_lines_by_address[line.address].append(line)
283 for value_lines in value_lines_by_address.values():
284 if sort == 'address':
285 value_lines.sort(key=lambda line: (line.enumentry.value, line.name))
286 else:
287 value_lines.sort(key=lambda line: (line.name, line.enumentry.value))
288
289 print('/* Automatically generated by amd/registers/makeregheader.py */\n', file=filp)
290 print(file=filp)
291 print(COPYRIGHT.strip(), file=filp)
292 print(file=filp)
293
294 if self.guard:
295 print('#ifndef {self.guard}'.format(**locals()), file=filp)
296 print('#define {self.guard}\n'.format(**locals()), file=filp)
297
298 for register_line in self.register_lines:
299 comment = get_chips_comment(register_line.chips)
300
301 address = '{0:X}'.format(register_line.address)
302 address = address.rjust(3 if register_line.regmap.map.to == 'pkt3' else 6, '0')
303
304 define_name = 'R_{address}_{register_line.name}'.format(**locals()).ljust(63)
305 comment = ' /* {0} */'.format(comment) if comment else ''
306 print('#define {define_name} 0x{address}{comment}'.format(**locals()), file=filp)
307
308 field_lines = field_lines_by_address[register_line.address]
309 field_idx = 0
310 while field_idx < len(field_lines):
311 field_line = field_lines[field_idx]
312
313 if field_line.type_refs.isdisjoint(register_line.type_refs):
314 field_idx += 1
315 continue
316 del field_lines[field_idx]
317
318 comment = get_chips_comment(field_line.chips, register_line.chips)
319
320 mask = (1 << (field_line.bits[1] - field_line.bits[0] + 1)) - 1
321 define_name = '_{address}_{field_line.name}(x)'.format(**locals()).ljust(58)
322 comment = ' /* {0} */'.format(comment) if comment else ''
323 print(
324 '#define S{define_name} (((unsigned)(x) & 0x{mask:X}) << {field_line.bits[0]}){comment}'
325 .format(**locals()), file=filp)
326 print('#define G{define_name} (((x) >> {field_line.bits[0]}) & 0x{mask:X})'
327 .format(**locals()), file=filp)
328
329 complement = ((1 << 32) - 1) ^ (mask << field_line.bits[0])
330 define_name = '_{address}_{field_line.name}'.format(**locals()).ljust(58)
331 print('#define C{define_name} 0x{complement:08X}'
332 .format(**locals()), file=filp)
333
334 value_lines = value_lines_by_address[register_line.address]
335 value_idx = 0
336 while value_idx < len(value_lines):
337 value_line = value_lines[value_idx]
338
339 if value_line.enum_refs.isdisjoint(field_line.enum_refs):
340 value_idx += 1
341 continue
342 del value_lines[value_idx]
343
344 comment = get_chips_comment(value_line.chips, field_line.chips)
345
346 define_name = 'V_{address}_{value_line.name}'.format(**locals()).ljust(55)
347 comment = ' /* {0} */'.format(comment) if comment else ''
348 print('#define {define_name} {value_line.enumentry.value}{comment}'
349 .format(**locals()), file=filp)
350
351 if self.guard:
352 print('\n#endif // {self.guard}'.format(**locals()), file=filp)
353
354
355 def main():
356 parser = argparse.ArgumentParser()
357 parser.add_argument('--chip', dest='chips', type=str, nargs='*',
358 help='Chip for which to generate the header (all chips if unspecified)')
359 parser.add_argument('--sort', choices=['name', 'address'], default='address',
360 help='Sort key for registers, fields, and enum values')
361 parser.add_argument('--guard', type=str, help='Name of the #include guard')
362 parser.add_argument('files', metavar='FILE', type=str, nargs='+',
363 help='Register database file')
364 args = parser.parse_args()
365
366 regdb = None
367 for filename in args.files:
368 with open(filename, 'r') as filp:
369 db = RegisterDatabase.from_json(json.load(filp))
370 if regdb is None:
371 regdb = db
372 else:
373 regdb.update(db)
374
375 deduplicate_enums(regdb)
376 deduplicate_register_types(regdb)
377
378 w = HeaderWriter(regdb, guard=args.guard)
379 w.print(sys.stdout, sort=args.sort)
380
381
382 if __name__ == '__main__':
383 main()
384
385 # kate: space-indent on; indent-width 4; replace-tabs on;