target/rx: Emit all disassembly in one prt()
[qemu.git] / scripts / decodetree.py
1 #!/usr/bin/env python3
2 # Copyright (c) 2018 Linaro Limited
3 #
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2 of the License, or (at your option) any later version.
8 #
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
13 #
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, see <http://www.gnu.org/licenses/>.
16 #
17
18 #
19 # Generate a decoding tree from a specification file.
20 # See the syntax and semantics in docs/devel/decodetree.rst.
21 #
22
23 import os
24 import re
25 import sys
26 import getopt
27
28 insnwidth = 32
29 insnmask = 0xffffffff
30 variablewidth = False
31 fields = {}
32 arguments = {}
33 formats = {}
34 patterns = []
35 allpatterns = []
36 anyextern = False
37
38 translate_prefix = 'trans'
39 translate_scope = 'static '
40 input_file = ''
41 output_file = None
42 output_fd = None
43 insntype = 'uint32_t'
44 decode_function = 'decode'
45
46 re_ident = '[a-zA-Z][a-zA-Z0-9_]*'
47
48
49 def error_with_file(file, lineno, *args):
50 """Print an error message from file:line and args and exit."""
51 global output_file
52 global output_fd
53
54 if lineno:
55 r = '{0}:{1}: error:'.format(file, lineno)
56 elif input_file:
57 r = '{0}: error:'.format(file)
58 else:
59 r = 'error:'
60 for a in args:
61 r += ' ' + str(a)
62 r += '\n'
63 sys.stderr.write(r)
64 if output_file and output_fd:
65 output_fd.close()
66 os.remove(output_file)
67 exit(1)
68
69 def error(lineno, *args):
70 error_with_file(input_file, lineno, args)
71
72 def output(*args):
73 global output_fd
74 for a in args:
75 output_fd.write(a)
76
77
78 if sys.version_info >= (3, 4):
79 re_fullmatch = re.fullmatch
80 else:
81 def re_fullmatch(pat, str):
82 return re.match('^' + pat + '$', str)
83
84
85 def output_autogen():
86 output('/* This file is autogenerated by scripts/decodetree.py. */\n\n')
87
88
89 def str_indent(c):
90 """Return a string with C spaces"""
91 return ' ' * c
92
93
94 def str_fields(fields):
95 """Return a string uniquely identifing FIELDS"""
96 r = ''
97 for n in sorted(fields.keys()):
98 r += '_' + n
99 return r[1:]
100
101
102 def str_match_bits(bits, mask):
103 """Return a string pretty-printing BITS/MASK"""
104 global insnwidth
105
106 i = 1 << (insnwidth - 1)
107 space = 0x01010100
108 r = ''
109 while i != 0:
110 if i & mask:
111 if i & bits:
112 r += '1'
113 else:
114 r += '0'
115 else:
116 r += '.'
117 if i & space:
118 r += ' '
119 i >>= 1
120 return r
121
122
123 def is_pow2(x):
124 """Return true iff X is equal to a power of 2."""
125 return (x & (x - 1)) == 0
126
127
128 def ctz(x):
129 """Return the number of times 2 factors into X."""
130 r = 0
131 while ((x >> r) & 1) == 0:
132 r += 1
133 return r
134
135
136 def is_contiguous(bits):
137 shift = ctz(bits)
138 if is_pow2((bits >> shift) + 1):
139 return shift
140 else:
141 return -1
142
143
144 def eq_fields_for_args(flds_a, flds_b):
145 if len(flds_a) != len(flds_b):
146 return False
147 for k, a in flds_a.items():
148 if k not in flds_b:
149 return False
150 return True
151
152
153 def eq_fields_for_fmts(flds_a, flds_b):
154 if len(flds_a) != len(flds_b):
155 return False
156 for k, a in flds_a.items():
157 if k not in flds_b:
158 return False
159 b = flds_b[k]
160 if a.__class__ != b.__class__ or a != b:
161 return False
162 return True
163
164
165 class Field:
166 """Class representing a simple instruction field"""
167 def __init__(self, sign, pos, len):
168 self.sign = sign
169 self.pos = pos
170 self.len = len
171 self.mask = ((1 << len) - 1) << pos
172
173 def __str__(self):
174 if self.sign:
175 s = 's'
176 else:
177 s = ''
178 return str(self.pos) + ':' + s + str(self.len)
179
180 def str_extract(self):
181 if self.sign:
182 extr = 'sextract32'
183 else:
184 extr = 'extract32'
185 return '{0}(insn, {1}, {2})'.format(extr, self.pos, self.len)
186
187 def __eq__(self, other):
188 return self.sign == other.sign and self.mask == other.mask
189
190 def __ne__(self, other):
191 return not self.__eq__(other)
192 # end Field
193
194
195 class MultiField:
196 """Class representing a compound instruction field"""
197 def __init__(self, subs, mask):
198 self.subs = subs
199 self.sign = subs[0].sign
200 self.mask = mask
201
202 def __str__(self):
203 return str(self.subs)
204
205 def str_extract(self):
206 ret = '0'
207 pos = 0
208 for f in reversed(self.subs):
209 if pos == 0:
210 ret = f.str_extract()
211 else:
212 ret = 'deposit32({0}, {1}, {2}, {3})' \
213 .format(ret, pos, 32 - pos, f.str_extract())
214 pos += f.len
215 return ret
216
217 def __ne__(self, other):
218 if len(self.subs) != len(other.subs):
219 return True
220 for a, b in zip(self.subs, other.subs):
221 if a.__class__ != b.__class__ or a != b:
222 return True
223 return False
224
225 def __eq__(self, other):
226 return not self.__ne__(other)
227 # end MultiField
228
229
230 class ConstField:
231 """Class representing an argument field with constant value"""
232 def __init__(self, value):
233 self.value = value
234 self.mask = 0
235 self.sign = value < 0
236
237 def __str__(self):
238 return str(self.value)
239
240 def str_extract(self):
241 return str(self.value)
242
243 def __cmp__(self, other):
244 return self.value - other.value
245 # end ConstField
246
247
248 class FunctionField:
249 """Class representing a field passed through a function"""
250 def __init__(self, func, base):
251 self.mask = base.mask
252 self.sign = base.sign
253 self.base = base
254 self.func = func
255
256 def __str__(self):
257 return self.func + '(' + str(self.base) + ')'
258
259 def str_extract(self):
260 return self.func + '(ctx, ' + self.base.str_extract() + ')'
261
262 def __eq__(self, other):
263 return self.func == other.func and self.base == other.base
264
265 def __ne__(self, other):
266 return not self.__eq__(other)
267 # end FunctionField
268
269
270 class ParameterField:
271 """Class representing a pseudo-field read from a function"""
272 def __init__(self, func):
273 self.mask = 0
274 self.sign = 0
275 self.func = func
276
277 def __str__(self):
278 return self.func
279
280 def str_extract(self):
281 return self.func + '(ctx)'
282
283 def __eq__(self, other):
284 return self.func == other.func
285
286 def __ne__(self, other):
287 return not self.__eq__(other)
288 # end ParameterField
289
290
291 class Arguments:
292 """Class representing the extracted fields of a format"""
293 def __init__(self, nm, flds, extern):
294 self.name = nm
295 self.extern = extern
296 self.fields = sorted(flds)
297
298 def __str__(self):
299 return self.name + ' ' + str(self.fields)
300
301 def struct_name(self):
302 return 'arg_' + self.name
303
304 def output_def(self):
305 if not self.extern:
306 output('typedef struct {\n')
307 for n in self.fields:
308 output(' int ', n, ';\n')
309 output('} ', self.struct_name(), ';\n\n')
310 # end Arguments
311
312
313 class General:
314 """Common code between instruction formats and instruction patterns"""
315 def __init__(self, name, lineno, base, fixb, fixm, udfm, fldm, flds, w):
316 self.name = name
317 self.file = input_file
318 self.lineno = lineno
319 self.base = base
320 self.fixedbits = fixb
321 self.fixedmask = fixm
322 self.undefmask = udfm
323 self.fieldmask = fldm
324 self.fields = flds
325 self.width = w
326
327 def __str__(self):
328 return self.name + ' ' + str_match_bits(self.fixedbits, self.fixedmask)
329
330 def str1(self, i):
331 return str_indent(i) + self.__str__()
332 # end General
333
334
335 class Format(General):
336 """Class representing an instruction format"""
337
338 def extract_name(self):
339 global decode_function
340 return decode_function + '_extract_' + self.name
341
342 def output_extract(self):
343 output('static void ', self.extract_name(), '(DisasContext *ctx, ',
344 self.base.struct_name(), ' *a, ', insntype, ' insn)\n{\n')
345 for n, f in self.fields.items():
346 output(' a->', n, ' = ', f.str_extract(), ';\n')
347 output('}\n\n')
348 # end Format
349
350
351 class Pattern(General):
352 """Class representing an instruction pattern"""
353
354 def output_decl(self):
355 global translate_scope
356 global translate_prefix
357 output('typedef ', self.base.base.struct_name(),
358 ' arg_', self.name, ';\n')
359 output(translate_scope, 'bool ', translate_prefix, '_', self.name,
360 '(DisasContext *ctx, arg_', self.name, ' *a);\n')
361
362 def output_code(self, i, extracted, outerbits, outermask):
363 global translate_prefix
364 ind = str_indent(i)
365 arg = self.base.base.name
366 output(ind, '/* ', self.file, ':', str(self.lineno), ' */\n')
367 if not extracted:
368 output(ind, self.base.extract_name(),
369 '(ctx, &u.f_', arg, ', insn);\n')
370 for n, f in self.fields.items():
371 output(ind, 'u.f_', arg, '.', n, ' = ', f.str_extract(), ';\n')
372 output(ind, 'if (', translate_prefix, '_', self.name,
373 '(ctx, &u.f_', arg, ')) return true;\n')
374 # end Pattern
375
376
377 class MultiPattern(General):
378 """Class representing an overlapping set of instruction patterns"""
379
380 def __init__(self, lineno, pats, fixb, fixm, udfm, w):
381 self.file = input_file
382 self.lineno = lineno
383 self.pats = pats
384 self.base = None
385 self.fixedbits = fixb
386 self.fixedmask = fixm
387 self.undefmask = udfm
388 self.width = w
389
390 def __str__(self):
391 r = "{"
392 for p in self.pats:
393 r = r + ' ' + str(p)
394 return r + "}"
395
396 def output_decl(self):
397 for p in self.pats:
398 p.output_decl()
399
400 def output_code(self, i, extracted, outerbits, outermask):
401 global translate_prefix
402 ind = str_indent(i)
403 for p in self.pats:
404 if outermask != p.fixedmask:
405 innermask = p.fixedmask & ~outermask
406 innerbits = p.fixedbits & ~outermask
407 output(ind, 'if ((insn & ',
408 '0x{0:08x}) == 0x{1:08x}'.format(innermask, innerbits),
409 ') {\n')
410 output(ind, ' /* ',
411 str_match_bits(p.fixedbits, p.fixedmask), ' */\n')
412 p.output_code(i + 4, extracted, p.fixedbits, p.fixedmask)
413 output(ind, '}\n')
414 else:
415 p.output_code(i, extracted, p.fixedbits, p.fixedmask)
416 #end MultiPattern
417
418
419 def parse_field(lineno, name, toks):
420 """Parse one instruction field from TOKS at LINENO"""
421 global fields
422 global re_ident
423 global insnwidth
424
425 # A "simple" field will have only one entry;
426 # a "multifield" will have several.
427 subs = []
428 width = 0
429 func = None
430 for t in toks:
431 if re_fullmatch('!function=' + re_ident, t):
432 if func:
433 error(lineno, 'duplicate function')
434 func = t.split('=')
435 func = func[1]
436 continue
437
438 if re_fullmatch('[0-9]+:s[0-9]+', t):
439 # Signed field extract
440 subtoks = t.split(':s')
441 sign = True
442 elif re_fullmatch('[0-9]+:[0-9]+', t):
443 # Unsigned field extract
444 subtoks = t.split(':')
445 sign = False
446 else:
447 error(lineno, 'invalid field token "{0}"'.format(t))
448 po = int(subtoks[0])
449 le = int(subtoks[1])
450 if po + le > insnwidth:
451 error(lineno, 'field {0} too large'.format(t))
452 f = Field(sign, po, le)
453 subs.append(f)
454 width += le
455
456 if width > insnwidth:
457 error(lineno, 'field too large')
458 if len(subs) == 0:
459 if func:
460 f = ParameterField(func)
461 else:
462 error(lineno, 'field with no value')
463 else:
464 if len(subs) == 1:
465 f = subs[0]
466 else:
467 mask = 0
468 for s in subs:
469 if mask & s.mask:
470 error(lineno, 'field components overlap')
471 mask |= s.mask
472 f = MultiField(subs, mask)
473 if func:
474 f = FunctionField(func, f)
475
476 if name in fields:
477 error(lineno, 'duplicate field', name)
478 fields[name] = f
479 # end parse_field
480
481
482 def parse_arguments(lineno, name, toks):
483 """Parse one argument set from TOKS at LINENO"""
484 global arguments
485 global re_ident
486 global anyextern
487
488 flds = []
489 extern = False
490 for t in toks:
491 if re_fullmatch('!extern', t):
492 extern = True
493 anyextern = True
494 continue
495 if not re_fullmatch(re_ident, t):
496 error(lineno, 'invalid argument set token "{0}"'.format(t))
497 if t in flds:
498 error(lineno, 'duplicate argument "{0}"'.format(t))
499 flds.append(t)
500
501 if name in arguments:
502 error(lineno, 'duplicate argument set', name)
503 arguments[name] = Arguments(name, flds, extern)
504 # end parse_arguments
505
506
507 def lookup_field(lineno, name):
508 global fields
509 if name in fields:
510 return fields[name]
511 error(lineno, 'undefined field', name)
512
513
514 def add_field(lineno, flds, new_name, f):
515 if new_name in flds:
516 error(lineno, 'duplicate field', new_name)
517 flds[new_name] = f
518 return flds
519
520
521 def add_field_byname(lineno, flds, new_name, old_name):
522 return add_field(lineno, flds, new_name, lookup_field(lineno, old_name))
523
524
525 def infer_argument_set(flds):
526 global arguments
527 global decode_function
528
529 for arg in arguments.values():
530 if eq_fields_for_args(flds, arg.fields):
531 return arg
532
533 name = decode_function + str(len(arguments))
534 arg = Arguments(name, flds.keys(), False)
535 arguments[name] = arg
536 return arg
537
538
539 def infer_format(arg, fieldmask, flds, width):
540 global arguments
541 global formats
542 global decode_function
543
544 const_flds = {}
545 var_flds = {}
546 for n, c in flds.items():
547 if c is ConstField:
548 const_flds[n] = c
549 else:
550 var_flds[n] = c
551
552 # Look for an existing format with the same argument set and fields
553 for fmt in formats.values():
554 if arg and fmt.base != arg:
555 continue
556 if fieldmask != fmt.fieldmask:
557 continue
558 if width != fmt.width:
559 continue
560 if not eq_fields_for_fmts(flds, fmt.fields):
561 continue
562 return (fmt, const_flds)
563
564 name = decode_function + '_Fmt_' + str(len(formats))
565 if not arg:
566 arg = infer_argument_set(flds)
567
568 fmt = Format(name, 0, arg, 0, 0, 0, fieldmask, var_flds, width)
569 formats[name] = fmt
570
571 return (fmt, const_flds)
572 # end infer_format
573
574
575 def parse_generic(lineno, is_format, name, toks):
576 """Parse one instruction format from TOKS at LINENO"""
577 global fields
578 global arguments
579 global formats
580 global patterns
581 global allpatterns
582 global re_ident
583 global insnwidth
584 global insnmask
585 global variablewidth
586
587 fixedmask = 0
588 fixedbits = 0
589 undefmask = 0
590 width = 0
591 flds = {}
592 arg = None
593 fmt = None
594 for t in toks:
595 # '&Foo' gives a format an explcit argument set.
596 if t[0] == '&':
597 tt = t[1:]
598 if arg:
599 error(lineno, 'multiple argument sets')
600 if tt in arguments:
601 arg = arguments[tt]
602 else:
603 error(lineno, 'undefined argument set', t)
604 continue
605
606 # '@Foo' gives a pattern an explicit format.
607 if t[0] == '@':
608 tt = t[1:]
609 if fmt:
610 error(lineno, 'multiple formats')
611 if tt in formats:
612 fmt = formats[tt]
613 else:
614 error(lineno, 'undefined format', t)
615 continue
616
617 # '%Foo' imports a field.
618 if t[0] == '%':
619 tt = t[1:]
620 flds = add_field_byname(lineno, flds, tt, tt)
621 continue
622
623 # 'Foo=%Bar' imports a field with a different name.
624 if re_fullmatch(re_ident + '=%' + re_ident, t):
625 (fname, iname) = t.split('=%')
626 flds = add_field_byname(lineno, flds, fname, iname)
627 continue
628
629 # 'Foo=number' sets an argument field to a constant value
630 if re_fullmatch(re_ident + '=[+-]?[0-9]+', t):
631 (fname, value) = t.split('=')
632 value = int(value)
633 flds = add_field(lineno, flds, fname, ConstField(value))
634 continue
635
636 # Pattern of 0s, 1s, dots and dashes indicate required zeros,
637 # required ones, or dont-cares.
638 if re_fullmatch('[01.-]+', t):
639 shift = len(t)
640 fms = t.replace('0', '1')
641 fms = fms.replace('.', '0')
642 fms = fms.replace('-', '0')
643 fbs = t.replace('.', '0')
644 fbs = fbs.replace('-', '0')
645 ubm = t.replace('1', '0')
646 ubm = ubm.replace('.', '0')
647 ubm = ubm.replace('-', '1')
648 fms = int(fms, 2)
649 fbs = int(fbs, 2)
650 ubm = int(ubm, 2)
651 fixedbits = (fixedbits << shift) | fbs
652 fixedmask = (fixedmask << shift) | fms
653 undefmask = (undefmask << shift) | ubm
654 # Otherwise, fieldname:fieldwidth
655 elif re_fullmatch(re_ident + ':s?[0-9]+', t):
656 (fname, flen) = t.split(':')
657 sign = False
658 if flen[0] == 's':
659 sign = True
660 flen = flen[1:]
661 shift = int(flen, 10)
662 if shift + width > insnwidth:
663 error(lineno, 'field {0} exceeds insnwidth'.format(fname))
664 f = Field(sign, insnwidth - width - shift, shift)
665 flds = add_field(lineno, flds, fname, f)
666 fixedbits <<= shift
667 fixedmask <<= shift
668 undefmask <<= shift
669 else:
670 error(lineno, 'invalid token "{0}"'.format(t))
671 width += shift
672
673 if variablewidth and width < insnwidth and width % 8 == 0:
674 shift = insnwidth - width
675 fixedbits <<= shift
676 fixedmask <<= shift
677 undefmask <<= shift
678 undefmask |= (1 << shift) - 1
679
680 # We should have filled in all of the bits of the instruction.
681 elif not (is_format and width == 0) and width != insnwidth:
682 error(lineno, 'definition has {0} bits'.format(width))
683
684 # Do not check for fields overlaping fields; one valid usage
685 # is to be able to duplicate fields via import.
686 fieldmask = 0
687 for f in flds.values():
688 fieldmask |= f.mask
689
690 # Fix up what we've parsed to match either a format or a pattern.
691 if is_format:
692 # Formats cannot reference formats.
693 if fmt:
694 error(lineno, 'format referencing format')
695 # If an argument set is given, then there should be no fields
696 # without a place to store it.
697 if arg:
698 for f in flds.keys():
699 if f not in arg.fields:
700 error(lineno, 'field {0} not in argument set {1}'
701 .format(f, arg.name))
702 else:
703 arg = infer_argument_set(flds)
704 if name in formats:
705 error(lineno, 'duplicate format name', name)
706 fmt = Format(name, lineno, arg, fixedbits, fixedmask,
707 undefmask, fieldmask, flds, width)
708 formats[name] = fmt
709 else:
710 # Patterns can reference a format ...
711 if fmt:
712 # ... but not an argument simultaneously
713 if arg:
714 error(lineno, 'pattern specifies both format and argument set')
715 if fixedmask & fmt.fixedmask:
716 error(lineno, 'pattern fixed bits overlap format fixed bits')
717 if width != fmt.width:
718 error(lineno, 'pattern uses format of different width')
719 fieldmask |= fmt.fieldmask
720 fixedbits |= fmt.fixedbits
721 fixedmask |= fmt.fixedmask
722 undefmask |= fmt.undefmask
723 else:
724 (fmt, flds) = infer_format(arg, fieldmask, flds, width)
725 arg = fmt.base
726 for f in flds.keys():
727 if f not in arg.fields:
728 error(lineno, 'field {0} not in argument set {1}'
729 .format(f, arg.name))
730 if f in fmt.fields.keys():
731 error(lineno, 'field {0} set by format and pattern'.format(f))
732 for f in arg.fields:
733 if f not in flds.keys() and f not in fmt.fields.keys():
734 error(lineno, 'field {0} not initialized'.format(f))
735 pat = Pattern(name, lineno, fmt, fixedbits, fixedmask,
736 undefmask, fieldmask, flds, width)
737 patterns.append(pat)
738 allpatterns.append(pat)
739
740 # Validate the masks that we have assembled.
741 if fieldmask & fixedmask:
742 error(lineno, 'fieldmask overlaps fixedmask (0x{0:08x} & 0x{1:08x})'
743 .format(fieldmask, fixedmask))
744 if fieldmask & undefmask:
745 error(lineno, 'fieldmask overlaps undefmask (0x{0:08x} & 0x{1:08x})'
746 .format(fieldmask, undefmask))
747 if fixedmask & undefmask:
748 error(lineno, 'fixedmask overlaps undefmask (0x{0:08x} & 0x{1:08x})'
749 .format(fixedmask, undefmask))
750 if not is_format:
751 allbits = fieldmask | fixedmask | undefmask
752 if allbits != insnmask:
753 error(lineno, 'bits left unspecified (0x{0:08x})'
754 .format(allbits ^ insnmask))
755 # end parse_general
756
757 def build_multi_pattern(lineno, pats):
758 """Validate the Patterns going into a MultiPattern."""
759 global patterns
760 global insnmask
761
762 if len(pats) < 2:
763 error(lineno, 'less than two patterns within braces')
764
765 fixedmask = insnmask
766 undefmask = insnmask
767
768 # Collect fixed/undefmask for all of the children.
769 # Move the defining lineno back to that of the first child.
770 for p in pats:
771 fixedmask &= p.fixedmask
772 undefmask &= p.undefmask
773 if p.lineno < lineno:
774 lineno = p.lineno
775
776 width = None
777 for p in pats:
778 if width is None:
779 width = p.width
780 elif width != p.width:
781 error(lineno, 'width mismatch in patterns within braces')
782
783 repeat = True
784 while repeat:
785 if fixedmask == 0:
786 error(lineno, 'no overlap in patterns within braces')
787 fixedbits = None
788 for p in pats:
789 thisbits = p.fixedbits & fixedmask
790 if fixedbits is None:
791 fixedbits = thisbits
792 elif fixedbits != thisbits:
793 fixedmask &= ~(fixedbits ^ thisbits)
794 break
795 else:
796 repeat = False
797
798 mp = MultiPattern(lineno, pats, fixedbits, fixedmask, undefmask, width)
799 patterns.append(mp)
800 # end build_multi_pattern
801
802 def parse_file(f):
803 """Parse all of the patterns within a file"""
804
805 global patterns
806
807 # Read all of the lines of the file. Concatenate lines
808 # ending in backslash; discard empty lines and comments.
809 toks = []
810 lineno = 0
811 nesting = 0
812 saved_pats = []
813
814 for line in f:
815 lineno += 1
816
817 # Expand and strip spaces, to find indent.
818 line = line.rstrip()
819 line = line.expandtabs()
820 len1 = len(line)
821 line = line.lstrip()
822 len2 = len(line)
823
824 # Discard comments
825 end = line.find('#')
826 if end >= 0:
827 line = line[:end]
828
829 t = line.split()
830 if len(toks) != 0:
831 # Next line after continuation
832 toks.extend(t)
833 else:
834 # Allow completely blank lines.
835 if len1 == 0:
836 continue
837 indent = len1 - len2
838 # Empty line due to comment.
839 if len(t) == 0:
840 # Indentation must be correct, even for comment lines.
841 if indent != nesting:
842 error(lineno, 'indentation ', indent, ' != ', nesting)
843 continue
844 start_lineno = lineno
845 toks = t
846
847 # Continuation?
848 if toks[-1] == '\\':
849 toks.pop()
850 continue
851
852 name = toks[0]
853 del toks[0]
854
855 # End nesting?
856 if name == '}':
857 if nesting == 0:
858 error(start_lineno, 'mismatched close brace')
859 if len(toks) != 0:
860 error(start_lineno, 'extra tokens after close brace')
861 nesting -= 2
862 if indent != nesting:
863 error(start_lineno, 'indentation ', indent, ' != ', nesting)
864 pats = patterns
865 patterns = saved_pats.pop()
866 build_multi_pattern(lineno, pats)
867 toks = []
868 continue
869
870 # Everything else should have current indentation.
871 if indent != nesting:
872 error(start_lineno, 'indentation ', indent, ' != ', nesting)
873
874 # Start nesting?
875 if name == '{':
876 if len(toks) != 0:
877 error(start_lineno, 'extra tokens after open brace')
878 saved_pats.append(patterns)
879 patterns = []
880 nesting += 2
881 toks = []
882 continue
883
884 # Determine the type of object needing to be parsed.
885 if name[0] == '%':
886 parse_field(start_lineno, name[1:], toks)
887 elif name[0] == '&':
888 parse_arguments(start_lineno, name[1:], toks)
889 elif name[0] == '@':
890 parse_generic(start_lineno, True, name[1:], toks)
891 else:
892 parse_generic(start_lineno, False, name, toks)
893 toks = []
894 # end parse_file
895
896
897 class Tree:
898 """Class representing a node in a decode tree"""
899
900 def __init__(self, fm, tm):
901 self.fixedmask = fm
902 self.thismask = tm
903 self.subs = []
904 self.base = None
905
906 def str1(self, i):
907 ind = str_indent(i)
908 r = '{0}{1:08x}'.format(ind, self.fixedmask)
909 if self.format:
910 r += ' ' + self.format.name
911 r += ' [\n'
912 for (b, s) in self.subs:
913 r += '{0} {1:08x}:\n'.format(ind, b)
914 r += s.str1(i + 4) + '\n'
915 r += ind + ']'
916 return r
917
918 def __str__(self):
919 return self.str1(0)
920
921 def output_code(self, i, extracted, outerbits, outermask):
922 ind = str_indent(i)
923
924 # If we identified all nodes below have the same format,
925 # extract the fields now.
926 if not extracted and self.base:
927 output(ind, self.base.extract_name(),
928 '(ctx, &u.f_', self.base.base.name, ', insn);\n')
929 extracted = True
930
931 # Attempt to aid the compiler in producing compact switch statements.
932 # If the bits in the mask are contiguous, extract them.
933 sh = is_contiguous(self.thismask)
934 if sh > 0:
935 # Propagate SH down into the local functions.
936 def str_switch(b, sh=sh):
937 return '(insn >> {0}) & 0x{1:x}'.format(sh, b >> sh)
938
939 def str_case(b, sh=sh):
940 return '0x{0:x}'.format(b >> sh)
941 else:
942 def str_switch(b):
943 return 'insn & 0x{0:08x}'.format(b)
944
945 def str_case(b):
946 return '0x{0:08x}'.format(b)
947
948 output(ind, 'switch (', str_switch(self.thismask), ') {\n')
949 for b, s in sorted(self.subs):
950 assert (self.thismask & ~s.fixedmask) == 0
951 innermask = outermask | self.thismask
952 innerbits = outerbits | b
953 output(ind, 'case ', str_case(b), ':\n')
954 output(ind, ' /* ',
955 str_match_bits(innerbits, innermask), ' */\n')
956 s.output_code(i + 4, extracted, innerbits, innermask)
957 output(ind, ' return false;\n')
958 output(ind, '}\n')
959 # end Tree
960
961
962 def build_tree(pats, outerbits, outermask):
963 # Find the intersection of all remaining fixedmask.
964 innermask = ~outermask & insnmask
965 for i in pats:
966 innermask &= i.fixedmask
967
968 if innermask == 0:
969 text = 'overlapping patterns:'
970 for p in pats:
971 text += '\n' + p.file + ':' + str(p.lineno) + ': ' + str(p)
972 error_with_file(pats[0].file, pats[0].lineno, text)
973
974 fullmask = outermask | innermask
975
976 # Sort each element of pats into the bin selected by the mask.
977 bins = {}
978 for i in pats:
979 fb = i.fixedbits & innermask
980 if fb in bins:
981 bins[fb].append(i)
982 else:
983 bins[fb] = [i]
984
985 # We must recurse if any bin has more than one element or if
986 # the single element in the bin has not been fully matched.
987 t = Tree(fullmask, innermask)
988
989 for b, l in bins.items():
990 s = l[0]
991 if len(l) > 1 or s.fixedmask & ~fullmask != 0:
992 s = build_tree(l, b | outerbits, fullmask)
993 t.subs.append((b, s))
994
995 return t
996 # end build_tree
997
998
999 class SizeTree:
1000 """Class representing a node in a size decode tree"""
1001
1002 def __init__(self, m, w):
1003 self.mask = m
1004 self.subs = []
1005 self.base = None
1006 self.width = w
1007
1008 def str1(self, i):
1009 ind = str_indent(i)
1010 r = '{0}{1:08x}'.format(ind, self.mask)
1011 r += ' [\n'
1012 for (b, s) in self.subs:
1013 r += '{0} {1:08x}:\n'.format(ind, b)
1014 r += s.str1(i + 4) + '\n'
1015 r += ind + ']'
1016 return r
1017
1018 def __str__(self):
1019 return self.str1(0)
1020
1021 def output_code(self, i, extracted, outerbits, outermask):
1022 ind = str_indent(i)
1023
1024 # If we need to load more bytes to test, do so now.
1025 if extracted < self.width:
1026 output(ind, 'insn = ', decode_function,
1027 '_load_bytes(ctx, insn, {0}, {1});\n'
1028 .format(extracted / 8, self.width / 8));
1029 extracted = self.width
1030
1031 # Attempt to aid the compiler in producing compact switch statements.
1032 # If the bits in the mask are contiguous, extract them.
1033 sh = is_contiguous(self.mask)
1034 if sh > 0:
1035 # Propagate SH down into the local functions.
1036 def str_switch(b, sh=sh):
1037 return '(insn >> {0}) & 0x{1:x}'.format(sh, b >> sh)
1038
1039 def str_case(b, sh=sh):
1040 return '0x{0:x}'.format(b >> sh)
1041 else:
1042 def str_switch(b):
1043 return 'insn & 0x{0:08x}'.format(b)
1044
1045 def str_case(b):
1046 return '0x{0:08x}'.format(b)
1047
1048 output(ind, 'switch (', str_switch(self.mask), ') {\n')
1049 for b, s in sorted(self.subs):
1050 innermask = outermask | self.mask
1051 innerbits = outerbits | b
1052 output(ind, 'case ', str_case(b), ':\n')
1053 output(ind, ' /* ',
1054 str_match_bits(innerbits, innermask), ' */\n')
1055 s.output_code(i + 4, extracted, innerbits, innermask)
1056 output(ind, '}\n')
1057 output(ind, 'return insn;\n')
1058 # end SizeTree
1059
1060 class SizeLeaf:
1061 """Class representing a leaf node in a size decode tree"""
1062
1063 def __init__(self, m, w):
1064 self.mask = m
1065 self.width = w
1066
1067 def str1(self, i):
1068 ind = str_indent(i)
1069 return '{0}{1:08x}'.format(ind, self.mask)
1070
1071 def __str__(self):
1072 return self.str1(0)
1073
1074 def output_code(self, i, extracted, outerbits, outermask):
1075 global decode_function
1076 ind = str_indent(i)
1077
1078 # If we need to load more bytes, do so now.
1079 if extracted < self.width:
1080 output(ind, 'insn = ', decode_function,
1081 '_load_bytes(ctx, insn, {0}, {1});\n'
1082 .format(extracted / 8, self.width / 8));
1083 extracted = self.width
1084 output(ind, 'return insn;\n')
1085 # end SizeLeaf
1086
1087
1088 def build_size_tree(pats, width, outerbits, outermask):
1089 global insnwidth
1090
1091 # Collect the mask of bits that are fixed in this width
1092 innermask = 0xff << (insnwidth - width)
1093 innermask &= ~outermask
1094 minwidth = None
1095 onewidth = True
1096 for i in pats:
1097 innermask &= i.fixedmask
1098 if minwidth is None:
1099 minwidth = i.width
1100 elif minwidth != i.width:
1101 onewidth = False;
1102 if minwidth < i.width:
1103 minwidth = i.width
1104
1105 if onewidth:
1106 return SizeLeaf(innermask, minwidth)
1107
1108 if innermask == 0:
1109 if width < minwidth:
1110 return build_size_tree(pats, width + 8, outerbits, outermask)
1111
1112 pnames = []
1113 for p in pats:
1114 pnames.append(p.name + ':' + p.file + ':' + str(p.lineno))
1115 error_with_file(pats[0].file, pats[0].lineno,
1116 'overlapping patterns size {0}:'.format(width), pnames)
1117
1118 bins = {}
1119 for i in pats:
1120 fb = i.fixedbits & innermask
1121 if fb in bins:
1122 bins[fb].append(i)
1123 else:
1124 bins[fb] = [i]
1125
1126 fullmask = outermask | innermask
1127 lens = sorted(bins.keys())
1128 if len(lens) == 1:
1129 b = lens[0]
1130 return build_size_tree(bins[b], width + 8, b | outerbits, fullmask)
1131
1132 r = SizeTree(innermask, width)
1133 for b, l in bins.items():
1134 s = build_size_tree(l, width, b | outerbits, fullmask)
1135 r.subs.append((b, s))
1136 return r
1137 # end build_size_tree
1138
1139
1140 def prop_format(tree):
1141 """Propagate Format objects into the decode tree"""
1142
1143 # Depth first search.
1144 for (b, s) in tree.subs:
1145 if isinstance(s, Tree):
1146 prop_format(s)
1147
1148 # If all entries in SUBS have the same format, then
1149 # propagate that into the tree.
1150 f = None
1151 for (b, s) in tree.subs:
1152 if f is None:
1153 f = s.base
1154 if f is None:
1155 return
1156 if f is not s.base:
1157 return
1158 tree.base = f
1159 # end prop_format
1160
1161
1162 def prop_size(tree):
1163 """Propagate minimum widths up the decode size tree"""
1164
1165 if isinstance(tree, SizeTree):
1166 min = None
1167 for (b, s) in tree.subs:
1168 width = prop_size(s)
1169 if min is None or min > width:
1170 min = width
1171 assert min >= tree.width
1172 tree.width = min
1173 else:
1174 min = tree.width
1175 return min
1176 # end prop_size
1177
1178
1179 def main():
1180 global arguments
1181 global formats
1182 global patterns
1183 global allpatterns
1184 global translate_scope
1185 global translate_prefix
1186 global output_fd
1187 global output_file
1188 global input_file
1189 global insnwidth
1190 global insntype
1191 global insnmask
1192 global decode_function
1193 global variablewidth
1194 global anyextern
1195
1196 decode_scope = 'static '
1197
1198 long_opts = ['decode=', 'translate=', 'output=', 'insnwidth=',
1199 'static-decode=', 'varinsnwidth=']
1200 try:
1201 (opts, args) = getopt.getopt(sys.argv[1:], 'o:vw:', long_opts)
1202 except getopt.GetoptError as err:
1203 error(0, err)
1204 for o, a in opts:
1205 if o in ('-o', '--output'):
1206 output_file = a
1207 elif o == '--decode':
1208 decode_function = a
1209 decode_scope = ''
1210 elif o == '--static-decode':
1211 decode_function = a
1212 elif o == '--translate':
1213 translate_prefix = a
1214 translate_scope = ''
1215 elif o in ('-w', '--insnwidth', '--varinsnwidth'):
1216 if o == '--varinsnwidth':
1217 variablewidth = True
1218 insnwidth = int(a)
1219 if insnwidth == 16:
1220 insntype = 'uint16_t'
1221 insnmask = 0xffff
1222 elif insnwidth != 32:
1223 error(0, 'cannot handle insns of width', insnwidth)
1224 else:
1225 assert False, 'unhandled option'
1226
1227 if len(args) < 1:
1228 error(0, 'missing input file')
1229 for filename in args:
1230 input_file = filename
1231 f = open(filename, 'r')
1232 parse_file(f)
1233 f.close()
1234
1235 if variablewidth:
1236 stree = build_size_tree(patterns, 8, 0, 0)
1237 prop_size(stree)
1238
1239 dtree = build_tree(patterns, 0, 0)
1240 prop_format(dtree)
1241
1242 if output_file:
1243 output_fd = open(output_file, 'w')
1244 else:
1245 output_fd = sys.stdout
1246
1247 output_autogen()
1248 for n in sorted(arguments.keys()):
1249 f = arguments[n]
1250 f.output_def()
1251
1252 # A single translate function can be invoked for different patterns.
1253 # Make sure that the argument sets are the same, and declare the
1254 # function only once.
1255 #
1256 # If we're sharing formats, we're likely also sharing trans_* functions,
1257 # but we can't tell which ones. Prevent issues from the compiler by
1258 # suppressing redundant declaration warnings.
1259 if anyextern:
1260 output("#ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE\n",
1261 "# pragma GCC diagnostic push\n",
1262 "# pragma GCC diagnostic ignored \"-Wredundant-decls\"\n",
1263 "# ifdef __clang__\n"
1264 "# pragma GCC diagnostic ignored \"-Wtypedef-redefinition\"\n",
1265 "# endif\n",
1266 "#endif\n\n")
1267
1268 out_pats = {}
1269 for i in allpatterns:
1270 if i.name in out_pats:
1271 p = out_pats[i.name]
1272 if i.base.base != p.base.base:
1273 error(0, i.name, ' has conflicting argument sets')
1274 else:
1275 i.output_decl()
1276 out_pats[i.name] = i
1277 output('\n')
1278
1279 if anyextern:
1280 output("#ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE\n",
1281 "# pragma GCC diagnostic pop\n",
1282 "#endif\n\n")
1283
1284 for n in sorted(formats.keys()):
1285 f = formats[n]
1286 f.output_extract()
1287
1288 output(decode_scope, 'bool ', decode_function,
1289 '(DisasContext *ctx, ', insntype, ' insn)\n{\n')
1290
1291 i4 = str_indent(4)
1292
1293 if len(allpatterns) != 0:
1294 output(i4, 'union {\n')
1295 for n in sorted(arguments.keys()):
1296 f = arguments[n]
1297 output(i4, i4, f.struct_name(), ' f_', f.name, ';\n')
1298 output(i4, '} u;\n\n')
1299 dtree.output_code(4, False, 0, 0)
1300
1301 output(i4, 'return false;\n')
1302 output('}\n')
1303
1304 if variablewidth:
1305 output('\n', decode_scope, insntype, ' ', decode_function,
1306 '_load(DisasContext *ctx)\n{\n',
1307 ' ', insntype, ' insn = 0;\n\n')
1308 stree.output_code(4, 0, 0, 0)
1309 output('}\n')
1310
1311 if output_file:
1312 output_fd.close()
1313 # end main
1314
1315
1316 if __name__ == '__main__':
1317 main()