4 from __future__
import (
5 absolute_import
, division
, print_function
, unicode_literals
7 import xml
.parsers
.expat
13 * Copyright (C) 2016 Intel Corporation
15 * Permission is hereby granted, free of charge, to any person obtaining a
16 * copy of this software and associated documentation files (the "Software"),
17 * to deal in the Software without restriction, including without limitation
18 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
19 * and/or sell copies of the Software, and to permit persons to whom the
20 * Software is furnished to do so, subject to the following conditions:
22 * The above copyright notice and this permission notice (including the next
23 * paragraph) shall be included in all copies or substantial portions of the
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
29 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
30 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
31 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
36 pack_header
= """%(license)s
38 /* Instructions, enums and structures for %(platform)s.
40 * This file has been generated, do not hand edit.
51 #ifndef __gen_validate_value
52 #define __gen_validate_value(x)
55 #ifndef __gen_field_functions
56 #define __gen_field_functions
63 static inline uint64_t
64 __gen_mbo(uint32_t start, uint32_t end)
66 return (~0ull >> (64 - (end - start + 1))) << start;
69 static inline uint64_t
70 __gen_uint(uint64_t v, uint32_t start, uint32_t end)
72 __gen_validate_value(v);
75 const int width = end - start + 1;
77 const uint64_t max = (1ull << width) - 1;
85 static inline uint64_t
86 __gen_sint(int64_t v, uint32_t start, uint32_t end)
88 const int width = end - start + 1;
90 __gen_validate_value(v);
94 const int64_t max = (1ll << (width - 1)) - 1;
95 const int64_t min = -(1ll << (width - 1));
96 assert(min <= v && v <= max);
100 const uint64_t mask = ~0ull >> (64 - width);
102 return (v & mask) << start;
105 static inline uint64_t
106 __gen_offset(uint64_t v, uint32_t start, uint32_t end)
108 __gen_validate_value(v);
110 uint64_t mask = (~0ull >> (64 - (end - start + 1))) << start;
112 assert((v & ~mask) == 0);
118 static inline uint32_t
121 __gen_validate_value(v);
122 return ((union __gen_value) { .f = (v) }).dw;
125 static inline uint64_t
126 __gen_sfixed(float v, uint32_t start, uint32_t end, uint32_t fract_bits)
128 __gen_validate_value(v);
130 const float factor = (1 << fract_bits);
133 const float max = ((1 << (end - start)) - 1) / factor;
134 const float min = -(1 << (end - start)) / factor;
135 assert(min <= v && v <= max);
138 const int64_t int_val = llroundf(v * factor);
139 const uint64_t mask = ~0ull >> (64 - (end - start + 1));
141 return (int_val & mask) << start;
144 static inline uint64_t
145 __gen_ufixed(float v, uint32_t start, uint32_t end, uint32_t fract_bits)
147 __gen_validate_value(v);
149 const float factor = (1 << fract_bits);
152 const float max = ((1 << (end - start + 1)) - 1) / factor;
153 const float min = 0.0f;
154 assert(min <= v && v <= max);
157 const uint64_t uint_val = llroundf(v * factor);
159 return uint_val << start;
162 #ifndef __gen_address_type
163 #error #define __gen_address_type before including this file
166 #ifndef __gen_user_data
167 #error #define __gen_combine_address before including this file
174 def to_alphanum(name
):
197 for i
, j
in substitutions
.items():
198 name
= name
.replace(i
, j
)
203 name
= to_alphanum(name
)
204 if not name
[0].isalpha():
209 def num_from_str(num_str
):
210 if num_str
.lower().startswith('0x'):
211 return int(num_str
, base
=16)
213 assert(not num_str
.startswith('0') and 'octals numbers not allowed')
217 ufixed_pattern
= re
.compile(r
"u(\d+)\.(\d+)")
218 sfixed_pattern
= re
.compile(r
"s(\d+)\.(\d+)")
220 def __init__(self
, parser
, attrs
):
223 self
.name
= safe_name(attrs
["name"])
224 self
.start
= int(attrs
["start"])
225 self
.end
= int(attrs
["end"])
226 self
.type = attrs
["type"]
228 if "prefix" in attrs
:
229 self
.prefix
= attrs
["prefix"]
233 if "default" in attrs
:
234 self
.default
= int(attrs
["default"])
238 ufixed_match
= Field
.ufixed_pattern
.match(self
.type)
241 self
.fractional_size
= int(ufixed_match
.group(2))
243 sfixed_match
= Field
.sfixed_pattern
.match(self
.type)
246 self
.fractional_size
= int(sfixed_match
.group(2))
248 def emit_template_struct(self
, dim
):
249 if self
.type == 'address':
250 type = '__gen_address_type'
251 elif self
.type == 'bool':
253 elif self
.type == 'float':
255 elif self
.type == 'ufixed':
257 elif self
.type == 'sfixed':
259 elif self
.type == 'uint' and self
.end
- self
.start
> 32:
261 elif self
.type == 'offset':
263 elif self
.type == 'int':
265 elif self
.type == 'uint':
267 elif self
.type in self
.parser
.structs
:
268 type = 'struct ' + self
.parser
.gen_prefix(safe_name(self
.type))
269 elif self
.type == 'mbo':
272 print("#error unhandled type: %s" % self
.type)
274 print(" %-36s %s%s;" % (type, self
.name
, dim
))
276 if len(self
.values
) > 0 and self
.default
== None:
278 prefix
= self
.prefix
+ "_"
282 for value
in self
.values
:
283 print("#define %-40s %d" % (prefix
+ value
.name
, value
.value
))
286 def __init__(self
, parser
, parent
, start
, count
, size
):
294 def emit_template_struct(self
, dim
):
296 print(" /* variable length fields follow */")
299 dim
= "%s[%d]" % (dim
, self
.count
)
301 for field
in self
.fields
:
302 field
.emit_template_struct(dim
)
310 def collect_dwords(self
, dwords
, start
, dim
):
311 for field
in self
.fields
:
312 if type(field
) is Group
:
314 field
.collect_dwords(dwords
, start
+ field
.start
, dim
)
316 for i
in range(field
.count
):
317 field
.collect_dwords(dwords
,
318 start
+ field
.start
+ i
* field
.size
,
322 index
= (start
+ field
.start
) // 32
323 if not index
in dwords
:
324 dwords
[index
] = self
.DWord()
326 clone
= copy
.copy(field
)
327 clone
.start
= clone
.start
+ start
328 clone
.end
= clone
.end
+ start
330 dwords
[index
].fields
.append(clone
)
332 if field
.type == "address":
333 # assert dwords[index].address == None
334 dwords
[index
].address
= field
336 # Coalesce all the dwords covered by this field. The two cases we
337 # handle are where multiple fields are in a 64 bit word (typically
338 # and address and a few bits) or where a single struct field
339 # completely covers multiple dwords.
340 while index
< (start
+ field
.end
) // 32:
341 if index
+ 1 in dwords
and not dwords
[index
] == dwords
[index
+ 1]:
342 dwords
[index
].fields
.extend(dwords
[index
+ 1].fields
)
343 dwords
[index
].size
= 64
344 dwords
[index
+ 1] = dwords
[index
]
347 def emit_pack_function(self
, start
):
349 self
.collect_dwords(dwords
, 0, "")
351 # Determine number of dwords in this group. If we have a size, use
352 # that, since that'll account for MBZ dwords at the end of a group
353 # (like dword 8 on BDW+ 3DSTATE_HS). Otherwise, use the largest dword
354 # index we've seen plus one.
356 length
= self
.size
// 32
358 length
= max(dwords
.keys()) + 1
360 for index
in range(length
):
362 if not index
in dwords
:
364 print(" dw[%d] = 0;" % index
)
367 # For 64 bit dwords, we aliased the two dword entries in the dword
368 # dict it occupies. Now that we're emitting the pack function,
369 # skip the duplicate entries.
371 if index
> 0 and index
- 1 in dwords
and dw
== dwords
[index
- 1]:
374 # Special case: only one field and it's a struct at the beginning
375 # of the dword. In this case we pack directly into the
376 # destination. This is the only way we handle embedded structs
377 # larger than 32 bits.
378 if len(dw
.fields
) == 1:
380 name
= field
.name
+ field
.dim
381 if field
.type in self
.parser
.structs
and field
.start
% 32 == 0:
383 print(" %s_pack(data, &dw[%d], &values->%s);" %
384 (self
.parser
.gen_prefix(safe_name(field
.type)), index
, name
))
387 # Pack any fields of struct type first so we have integer values
388 # to the dword for those fields.
390 for field
in dw
.fields
:
391 if type(field
) is Field
and field
.type in self
.parser
.structs
:
392 name
= field
.name
+ field
.dim
394 print(" uint32_t v%d_%d;" % (index
, field_index
))
395 print(" %s_pack(data, &v%d_%d, &values->%s);" %
396 (self
.parser
.gen_prefix(safe_name(field
.type)), index
, field_index
, name
))
397 field_index
= field_index
+ 1
400 dword_start
= index
* 32
401 if dw
.address
== None:
406 if dw
.size
== 32 and dw
.address
== None:
408 print(" dw[%d] =" % index
)
409 elif len(dw
.fields
) > address_count
:
411 print(" const uint%d_t %s =" % (dw
.size
, v
))
416 for field
in dw
.fields
:
417 if field
.type != "mbo":
418 name
= field
.name
+ field
.dim
420 if field
.type == "mbo":
421 s
= "__gen_mbo(%d, %d)" % \
422 (field
.start
- dword_start
, field
.end
- dword_start
)
423 elif field
.type == "address":
425 elif field
.type == "uint":
426 s
= "__gen_uint(values->%s, %d, %d)" % \
427 (name
, field
.start
- dword_start
, field
.end
- dword_start
)
428 elif field
.type == "int":
429 s
= "__gen_sint(values->%s, %d, %d)" % \
430 (name
, field
.start
- dword_start
, field
.end
- dword_start
)
431 elif field
.type == "bool":
432 s
= "__gen_uint(values->%s, %d, %d)" % \
433 (name
, field
.start
- dword_start
, field
.end
- dword_start
)
434 elif field
.type == "float":
435 s
= "__gen_float(values->%s)" % name
436 elif field
.type == "offset":
437 s
= "__gen_offset(values->%s, %d, %d)" % \
438 (name
, field
.start
- dword_start
, field
.end
- dword_start
)
439 elif field
.type == 'ufixed':
440 s
= "__gen_ufixed(values->%s, %d, %d, %d)" % \
441 (name
, field
.start
- dword_start
, field
.end
- dword_start
, field
.fractional_size
)
442 elif field
.type == 'sfixed':
443 s
= "__gen_sfixed(values->%s, %d, %d, %d)" % \
444 (name
, field
.start
- dword_start
, field
.end
- dword_start
, field
.fractional_size
)
445 elif field
.type in self
.parser
.structs
:
446 s
= "__gen_uint(v%d_%d, %d, %d)" % \
447 (index
, field_index
, field
.start
- dword_start
, field
.end
- dword_start
)
448 field_index
= field_index
+ 1
450 print("/* unhandled field %s, type %s */\n" % (name
, field
.type))
454 if field
== dw
.fields
[-1]:
461 print(" dw[%d] = __gen_combine_address(data, &dw[%d], values->%s, %s);" % (index
, index
, dw
.address
.name
, v
))
465 v_address
= "v%d_address" % index
466 print(" const uint64_t %s =\n __gen_combine_address(data, &dw[%d], values->%s, %s);" %
467 (v_address
, index
, dw
.address
.name
, v
))
470 print(" dw[%d] = %s;" % (index
, v
))
471 print(" dw[%d] = %s >> 32;" % (index
+ 1, v
))
474 def __init__(self
, attrs
):
475 self
.name
= safe_name(attrs
["name"])
476 self
.value
= int(attrs
["value"])
478 class Parser(object):
480 self
.parser
= xml
.parsers
.expat
.ParserCreate()
481 self
.parser
.StartElementHandler
= self
.start_element
482 self
.parser
.EndElementHandler
= self
.end_element
484 self
.instruction
= None
488 def start_element(self
, name
, attrs
):
490 self
.platform
= attrs
["name"]
491 self
.gen
= attrs
["gen"].replace('.', '')
492 print(pack_header
% {'license': license
, 'platform': self
.platform
})
493 elif name
in ("instruction", "struct", "register"):
494 if name
== "instruction":
495 self
.instruction
= safe_name(attrs
["name"])
496 self
.length_bias
= int(attrs
["bias"])
497 elif name
== "struct":
498 self
.struct
= safe_name(attrs
["name"])
499 self
.structs
[attrs
["name"]] = 1
500 elif name
== "register":
501 self
.register
= safe_name(attrs
["name"])
502 self
.reg_num
= num_from_str(attrs
["num"])
503 self
.registers
[attrs
["name"]] = 1
504 if "length" in attrs
:
505 self
.length
= int(attrs
["length"])
506 size
= self
.length
* 32
510 self
.group
= Group(self
, None, 0, 1, size
)
512 elif name
== "group":
513 group
= Group(self
, self
.group
,
514 int(attrs
["start"]), int(attrs
["count"]), int(attrs
["size"]))
515 self
.group
.fields
.append(group
)
517 elif name
== "field":
518 self
.group
.fields
.append(Field(self
, attrs
))
522 self
.enum
= safe_name(attrs
["name"])
523 if "prefix" in attrs
:
524 self
.prefix
= safe_name(attrs
["prefix"])
527 elif name
== "value":
528 self
.values
.append(Value(attrs
))
530 def end_element(self
, name
):
531 if name
== "instruction":
532 self
.emit_instruction()
533 self
.instruction
= None
535 elif name
== "struct":
539 elif name
== "register":
544 elif name
== "group":
545 self
.group
= self
.group
.parent
546 elif name
== "field":
547 self
.group
.fields
[-1].values
= self
.values
552 def gen_prefix(self
, name
):
554 return 'GEN%s%s' % (self
.gen
, name
)
556 return 'GEN%s_%s' % (self
.gen
, name
)
558 def emit_template_struct(self
, name
, group
):
559 print("struct %s {" % self
.gen_prefix(name
))
560 group
.emit_template_struct("")
563 def emit_pack_function(self
, name
, group
):
564 name
= self
.gen_prefix(name
)
565 print("static inline void\n%s_pack(__gen_user_data *data, void * restrict dst,\n%sconst struct %s * restrict values)\n{" %
566 (name
, ' ' * (len(name
) + 6), name
))
568 # Cast dst to make header C++ friendly
569 print(" uint32_t * restrict dw = (uint32_t * restrict) dst;")
571 group
.emit_pack_function(0)
575 def emit_instruction(self
):
576 name
= self
.instruction
577 if not self
.length
== None:
578 print('#define %-33s %6d' %
579 (self
.gen_prefix(name
+ "_length"), self
.length
))
580 print('#define %-33s %6d' %
581 (self
.gen_prefix(name
+ "_length_bias"), self
.length_bias
))
584 for field
in self
.group
.fields
:
585 if not type(field
) is Field
:
587 if field
.default
== None:
589 default_fields
.append(" .%-35s = %6d" % (field
.name
, field
.default
))
592 print('#define %-40s\\' % (self
.gen_prefix(name
+ '_header')))
593 print(", \\\n".join(default_fields
))
596 self
.emit_template_struct(self
.instruction
, self
.group
)
598 self
.emit_pack_function(self
.instruction
, self
.group
)
600 def emit_register(self
):
602 if not self
.reg_num
== None:
603 print('#define %-33s 0x%04x' %
604 (self
.gen_prefix(name
+ "_num"), self
.reg_num
))
606 if not self
.length
== None:
607 print('#define %-33s %6d' %
608 (self
.gen_prefix(name
+ "_length"), self
.length
))
610 self
.emit_template_struct(self
.register
, self
.group
)
611 self
.emit_pack_function(self
.register
, self
.group
)
613 def emit_struct(self
):
615 if not self
.length
== None:
616 print('#define %-33s %6d' %
617 (self
.gen_prefix(name
+ "_length"), self
.length
))
619 self
.emit_template_struct(self
.struct
, self
.group
)
620 self
.emit_pack_function(self
.struct
, self
.group
)
623 print('/* enum %s */' % self
.gen_prefix(self
.enum
))
624 for value
in self
.values
:
626 name
= self
.prefix
+ "_" + value
.name
629 print('#define %-36s %6d' % (name
.upper(), value
.value
))
632 def parse(self
, filename
):
633 file = open(filename
, "rb")
634 self
.parser
.ParseFile(file)
637 if len(sys
.argv
) < 2:
638 print("No input xml file specified")
641 input_file
= sys
.argv
[1]