decodetree.py 40.1 KB
Newer Older
1
#!/usr/bin/env python3
Richard Henderson's avatar
Richard Henderson committed
2
3
4
5
6
# Copyright (c) 2018 Linaro Limited
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
7
# version 2.1 of the License, or (at your option) any later version.
Richard Henderson's avatar
Richard Henderson committed
8
9
10
11
12
13
14
15
16
17
18
19
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, see <http://www.gnu.org/licenses/>.
#

#
# Generate a decoding tree from a specification file.
20
# See the syntax and semantics in docs/devel/decodetree.rst.
Richard Henderson's avatar
Richard Henderson committed
21
22
23
24
25
26
27
28
29
#

import os
import re
import sys
import getopt

insnwidth = 32
insnmask = 0xffffffff
30
variablewidth = False
Richard Henderson's avatar
Richard Henderson committed
31
32
33
fields = {}
arguments = {}
formats = {}
34
allpatterns = []
35
anyextern = False
Richard Henderson's avatar
Richard Henderson committed
36
37
38
39
40
41
42

translate_prefix = 'trans'
translate_scope = 'static '
input_file = ''
output_file = None
output_fd = None
insntype = 'uint32_t'
43
decode_function = 'decode'
Richard Henderson's avatar
Richard Henderson committed
44

45
46
# An identifier for C.
re_C_ident = '[a-zA-Z][a-zA-Z0-9_]*'
Richard Henderson's avatar
Richard Henderson committed
47

48
49
50
51
52
# Identifiers for Arguments, Fields, Formats and Patterns.
re_arg_ident = '&[a-zA-Z0-9_]*'
re_fld_ident = '%[a-zA-Z0-9_]*'
re_fmt_ident = '@[a-zA-Z0-9_]*'
re_pat_ident = '[a-zA-Z0-9_]*'
Richard Henderson's avatar
Richard Henderson committed
53

54
def error_with_file(file, lineno, *args):
Richard Henderson's avatar
Richard Henderson committed
55
56
57
58
    """Print an error message from file:line and args and exit."""
    global output_file
    global output_fd

59
60
61
    prefix = ''
    if file:
        prefix += '{0}:'.format(file)
Richard Henderson's avatar
Richard Henderson committed
62
    if lineno:
63
64
65
66
67
68
        prefix += '{0}:'.format(lineno)
    if prefix:
        prefix += ' '
    print(prefix, end='error: ', file=sys.stderr)
    print(*args, file=sys.stderr)

Richard Henderson's avatar
Richard Henderson committed
69
70
71
72
    if output_file and output_fd:
        output_fd.close()
        os.remove(output_file)
    exit(1)
73
74
# end error_with_file

Richard Henderson's avatar
Richard Henderson committed
75

76
def error(lineno, *args):
77
78
79
    error_with_file(input_file, lineno, *args)
# end error

Richard Henderson's avatar
Richard Henderson committed
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

def output(*args):
    global output_fd
    for a in args:
        output_fd.write(a)


def output_autogen():
    output('/* This file is autogenerated by scripts/decodetree.py.  */\n\n')


def str_indent(c):
    """Return a string with C spaces"""
    return ' ' * c


def str_fields(fields):
97
    """Return a string uniquely identifying FIELDS"""
Richard Henderson's avatar
Richard Henderson committed
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
    r = ''
    for n in sorted(fields.keys()):
        r += '_' + n
    return r[1:]


def str_match_bits(bits, mask):
    """Return a string pretty-printing BITS/MASK"""
    global insnwidth

    i = 1 << (insnwidth - 1)
    space = 0x01010100
    r = ''
    while i != 0:
        if i & mask:
            if i & bits:
                r += '1'
            else:
                r += '0'
        else:
            r += '.'
        if i & space:
            r += ' '
        i >>= 1
    return r


def is_pow2(x):
    """Return true iff X is equal to a power of 2."""
    return (x & (x - 1)) == 0


def ctz(x):
    """Return the number of times 2 factors into X."""
132
    assert x != 0
Richard Henderson's avatar
Richard Henderson committed
133
134
135
136
137
138
139
    r = 0
    while ((x >> r) & 1) == 0:
        r += 1
    return r


def is_contiguous(bits):
140
141
    if bits == 0:
        return -1
Richard Henderson's avatar
Richard Henderson committed
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
    shift = ctz(bits)
    if is_pow2((bits >> shift) + 1):
        return shift
    else:
        return -1


def eq_fields_for_args(flds_a, flds_b):
    if len(flds_a) != len(flds_b):
        return False
    for k, a in flds_a.items():
        if k not in flds_b:
            return False
    return True


def eq_fields_for_fmts(flds_a, flds_b):
    if len(flds_a) != len(flds_b):
        return False
    for k, a in flds_a.items():
        if k not in flds_b:
            return False
        b = flds_b[k]
        if a.__class__ != b.__class__ or a != b:
            return False
    return True


class Field:
    """Class representing a simple instruction field"""
    def __init__(self, sign, pos, len):
        self.sign = sign
        self.pos = pos
        self.len = len
        self.mask = ((1 << len) - 1) << pos

    def __str__(self):
        if self.sign:
            s = 's'
        else:
            s = ''
183
        return str(self.pos) + ':' + s + str(self.len)
Richard Henderson's avatar
Richard Henderson committed
184
185
186
187
188
189
190
191
192

    def str_extract(self):
        if self.sign:
            extr = 'sextract32'
        else:
            extr = 'extract32'
        return '{0}(insn, {1}, {2})'.format(extr, self.pos, self.len)

    def __eq__(self, other):
193
        return self.sign == other.sign and self.mask == other.mask
Richard Henderson's avatar
Richard Henderson committed
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253

    def __ne__(self, other):
        return not self.__eq__(other)
# end Field


class MultiField:
    """Class representing a compound instruction field"""
    def __init__(self, subs, mask):
        self.subs = subs
        self.sign = subs[0].sign
        self.mask = mask

    def __str__(self):
        return str(self.subs)

    def str_extract(self):
        ret = '0'
        pos = 0
        for f in reversed(self.subs):
            if pos == 0:
                ret = f.str_extract()
            else:
                ret = 'deposit32({0}, {1}, {2}, {3})' \
                      .format(ret, pos, 32 - pos, f.str_extract())
            pos += f.len
        return ret

    def __ne__(self, other):
        if len(self.subs) != len(other.subs):
            return True
        for a, b in zip(self.subs, other.subs):
            if a.__class__ != b.__class__ or a != b:
                return True
        return False

    def __eq__(self, other):
        return not self.__ne__(other)
# end MultiField


class ConstField:
    """Class representing an argument field with constant value"""
    def __init__(self, value):
        self.value = value
        self.mask = 0
        self.sign = value < 0

    def __str__(self):
        return str(self.value)

    def str_extract(self):
        return str(self.value)

    def __cmp__(self, other):
        return self.value - other.value
# end ConstField


class FunctionField:
254
    """Class representing a field passed through a function"""
Richard Henderson's avatar
Richard Henderson committed
255
256
257
258
259
260
261
262
263
264
    def __init__(self, func, base):
        self.mask = base.mask
        self.sign = base.sign
        self.base = base
        self.func = func

    def __str__(self):
        return self.func + '(' + str(self.base) + ')'

    def str_extract(self):
265
        return self.func + '(ctx, ' + self.base.str_extract() + ')'
Richard Henderson's avatar
Richard Henderson committed
266
267
268
269
270
271
272
273
274

    def __eq__(self, other):
        return self.func == other.func and self.base == other.base

    def __ne__(self, other):
        return not self.__eq__(other)
# end FunctionField


275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
class ParameterField:
    """Class representing a pseudo-field read from a function"""
    def __init__(self, func):
        self.mask = 0
        self.sign = 0
        self.func = func

    def __str__(self):
        return self.func

    def str_extract(self):
        return self.func + '(ctx)'

    def __eq__(self, other):
        return self.func == other.func

    def __ne__(self, other):
        return not self.__eq__(other)
# end ParameterField


Richard Henderson's avatar
Richard Henderson committed
296
297
class Arguments:
    """Class representing the extracted fields of a format"""
298
    def __init__(self, nm, flds, extern):
Richard Henderson's avatar
Richard Henderson committed
299
        self.name = nm
300
        self.extern = extern
Richard Henderson's avatar
Richard Henderson committed
301
302
303
304
305
306
307
308
309
        self.fields = sorted(flds)

    def __str__(self):
        return self.name + ' ' + str(self.fields)

    def struct_name(self):
        return 'arg_' + self.name

    def output_def(self):
310
311
312
313
314
        if not self.extern:
            output('typedef struct {\n')
            for n in self.fields:
                output('    int ', n, ';\n')
            output('} ', self.struct_name(), ';\n\n')
Richard Henderson's avatar
Richard Henderson committed
315
316
317
318
319
# end Arguments


class General:
    """Common code between instruction formats and instruction patterns"""
320
    def __init__(self, name, lineno, base, fixb, fixm, udfm, fldm, flds, w):
Richard Henderson's avatar
Richard Henderson committed
321
        self.name = name
322
        self.file = input_file
Richard Henderson's avatar
Richard Henderson committed
323
324
325
326
327
328
329
        self.lineno = lineno
        self.base = base
        self.fixedbits = fixb
        self.fixedmask = fixm
        self.undefmask = udfm
        self.fieldmask = fldm
        self.fields = flds
330
        self.width = w
Richard Henderson's avatar
Richard Henderson committed
331
332

    def __str__(self):
333
        return self.name + ' ' + str_match_bits(self.fixedbits, self.fixedmask)
Richard Henderson's avatar
Richard Henderson committed
334
335
336
337
338
339
340
341
342
343

    def str1(self, i):
        return str_indent(i) + self.__str__()
# end General


class Format(General):
    """Class representing an instruction format"""

    def extract_name(self):
344
345
        global decode_function
        return decode_function + '_extract_' + self.name
Richard Henderson's avatar
Richard Henderson committed
346
347

    def output_extract(self):
348
        output('static void ', self.extract_name(), '(DisasContext *ctx, ',
Richard Henderson's avatar
Richard Henderson committed
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
               self.base.struct_name(), ' *a, ', insntype, ' insn)\n{\n')
        for n, f in self.fields.items():
            output('    a->', n, ' = ', f.str_extract(), ';\n')
        output('}\n\n')
# end Format


class Pattern(General):
    """Class representing an instruction pattern"""

    def output_decl(self):
        global translate_scope
        global translate_prefix
        output('typedef ', self.base.base.struct_name(),
               ' arg_', self.name, ';\n')
364
        output(translate_scope, 'bool ', translate_prefix, '_', self.name,
365
               '(DisasContext *ctx, arg_', self.name, ' *a);\n')
Richard Henderson's avatar
Richard Henderson committed
366
367
368
369
370

    def output_code(self, i, extracted, outerbits, outermask):
        global translate_prefix
        ind = str_indent(i)
        arg = self.base.base.name
371
        output(ind, '/* ', self.file, ':', str(self.lineno), ' */\n')
Richard Henderson's avatar
Richard Henderson committed
372
        if not extracted:
373
374
            output(ind, self.base.extract_name(),
                   '(ctx, &u.f_', arg, ', insn);\n')
Richard Henderson's avatar
Richard Henderson committed
375
376
        for n, f in self.fields.items():
            output(ind, 'u.f_', arg, '.', n, ' = ', f.str_extract(), ';\n')
377
378
        output(ind, 'if (', translate_prefix, '_', self.name,
               '(ctx, &u.f_', arg, ')) return true;\n')
379
380
381
382
383
384
385
386
387
388
389

    # Normal patterns do not have children.
    def build_tree(self):
        return
    def prop_masks(self):
        return
    def prop_format(self):
        return
    def prop_width(self):
        return

Richard Henderson's avatar
Richard Henderson committed
390
391
392
# end Pattern


393
394
class MultiPattern(General):
    """Class representing a set of instruction patterns"""
395

396
    def __init__(self, lineno):
397
398
        self.file = input_file
        self.lineno = lineno
399
        self.pats = []
400
        self.base = None
401
402
403
404
        self.fixedbits = 0
        self.fixedmask = 0
        self.undefmask = 0
        self.width = None
405
406

    def __str__(self):
407
408
409
410
        r = 'group'
        if self.fixedbits is not None:
            r += ' ' + str_match_bits(self.fixedbits, self.fixedmask)
        return r
411
412
413
414

    def output_decl(self):
        for p in self.pats:
            p.output_decl()
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465

    def prop_masks(self):
        global insnmask

        fixedmask = insnmask
        undefmask = insnmask

        # Collect fixedmask/undefmask for all of the children.
        for p in self.pats:
            p.prop_masks()
            fixedmask &= p.fixedmask
            undefmask &= p.undefmask

        # Widen fixedmask until all fixedbits match
        repeat = True
        fixedbits = 0
        while repeat and fixedmask != 0:
            fixedbits = None
            for p in self.pats:
                thisbits = p.fixedbits & fixedmask
                if fixedbits is None:
                    fixedbits = thisbits
                elif fixedbits != thisbits:
                    fixedmask &= ~(fixedbits ^ thisbits)
                    break
            else:
                repeat = False

        self.fixedbits = fixedbits
        self.fixedmask = fixedmask
        self.undefmask = undefmask

    def build_tree(self):
        for p in self.pats:
            p.build_tree()

    def prop_format(self):
        for p in self.pats:
            p.build_tree()

    def prop_width(self):
        width = None
        for p in self.pats:
            p.prop_width()
            if width is None:
                width = p.width
            elif width != p.width:
                error_with_file(self.file, self.lineno,
                                'width mismatch in patterns within braces')
        self.width = width

466
467
468
469
470
471
# end MultiPattern


class IncMultiPattern(MultiPattern):
    """Class representing an overlapping set of instruction patterns"""

472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
    def output_code(self, i, extracted, outerbits, outermask):
        global translate_prefix
        ind = str_indent(i)
        for p in self.pats:
            if outermask != p.fixedmask:
                innermask = p.fixedmask & ~outermask
                innerbits = p.fixedbits & ~outermask
                output(ind, 'if ((insn & ',
                       '0x{0:08x}) == 0x{1:08x}'.format(innermask, innerbits),
                       ') {\n')
                output(ind, '    /* ',
                       str_match_bits(p.fixedbits, p.fixedmask), ' */\n')
                p.output_code(i + 4, extracted, p.fixedbits, p.fixedmask)
                output(ind, '}\n')
            else:
                p.output_code(i, extracted, p.fixedbits, p.fixedmask)
488
#end IncMultiPattern
489
490


491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
class Tree:
    """Class representing a node in a decode tree"""

    def __init__(self, fm, tm):
        self.fixedmask = fm
        self.thismask = tm
        self.subs = []
        self.base = None

    def str1(self, i):
        ind = str_indent(i)
        r = '{0}{1:08x}'.format(ind, self.fixedmask)
        if self.format:
            r += ' ' + self.format.name
        r += ' [\n'
        for (b, s) in self.subs:
            r += '{0}  {1:08x}:\n'.format(ind, b)
            r += s.str1(i + 4) + '\n'
        r += ind + ']'
        return r

    def __str__(self):
        return self.str1(0)

    def output_code(self, i, extracted, outerbits, outermask):
        ind = str_indent(i)

        # If we identified all nodes below have the same format,
        # extract the fields now.
        if not extracted and self.base:
            output(ind, self.base.extract_name(),
                   '(ctx, &u.f_', self.base.base.name, ', insn);\n')
            extracted = True

        # Attempt to aid the compiler in producing compact switch statements.
        # If the bits in the mask are contiguous, extract them.
        sh = is_contiguous(self.thismask)
        if sh > 0:
            # Propagate SH down into the local functions.
            def str_switch(b, sh=sh):
                return '(insn >> {0}) & 0x{1:x}'.format(sh, b >> sh)

            def str_case(b, sh=sh):
                return '0x{0:x}'.format(b >> sh)
        else:
            def str_switch(b):
                return 'insn & 0x{0:08x}'.format(b)

            def str_case(b):
                return '0x{0:08x}'.format(b)

        output(ind, 'switch (', str_switch(self.thismask), ') {\n')
        for b, s in sorted(self.subs):
            assert (self.thismask & ~s.fixedmask) == 0
            innermask = outermask | self.thismask
            innerbits = outerbits | b
            output(ind, 'case ', str_case(b), ':\n')
            output(ind, '    /* ',
                   str_match_bits(innerbits, innermask), ' */\n')
            s.output_code(i + 4, extracted, innerbits, innermask)
551
            output(ind, '    break;\n')
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
        output(ind, '}\n')
# end Tree


class ExcMultiPattern(MultiPattern):
    """Class representing a non-overlapping set of instruction patterns"""

    def output_code(self, i, extracted, outerbits, outermask):
        # Defer everything to our decomposed Tree node
        self.tree.output_code(i, extracted, outerbits, outermask)

    @staticmethod
    def __build_tree(pats, outerbits, outermask):
        # Find the intersection of all remaining fixedmask.
        innermask = ~outermask & insnmask
        for i in pats:
            innermask &= i.fixedmask

        if innermask == 0:
            # Edge condition: One pattern covers the entire insnmask
            if len(pats) == 1:
                t = Tree(outermask, innermask)
                t.subs.append((0, pats[0]))
                return t

            text = 'overlapping patterns:'
            for p in pats:
                text += '\n' + p.file + ':' + str(p.lineno) + ': ' + str(p)
            error_with_file(pats[0].file, pats[0].lineno, text)

        fullmask = outermask | innermask

        # Sort each element of pats into the bin selected by the mask.
        bins = {}
        for i in pats:
            fb = i.fixedbits & innermask
            if fb in bins:
                bins[fb].append(i)
            else:
                bins[fb] = [i]

        # We must recurse if any bin has more than one element or if
        # the single element in the bin has not been fully matched.
        t = Tree(fullmask, innermask)

        for b, l in bins.items():
            s = l[0]
            if len(l) > 1 or s.fixedmask & ~fullmask != 0:
                s = ExcMultiPattern.__build_tree(l, b | outerbits, fullmask)
            t.subs.append((b, s))

        return t

    def build_tree(self):
        super().prop_format()
        self.tree = self.__build_tree(self.pats, self.fixedbits,
                                      self.fixedmask)

    @staticmethod
    def __prop_format(tree):
        """Propagate Format objects into the decode tree"""

        # Depth first search.
        for (b, s) in tree.subs:
            if isinstance(s, Tree):
                ExcMultiPattern.__prop_format(s)

        # If all entries in SUBS have the same format, then
        # propagate that into the tree.
        f = None
        for (b, s) in tree.subs:
            if f is None:
                f = s.base
                if f is None:
                    return
            if f is not s.base:
                return
        tree.base = f

    def prop_format(self):
        super().prop_format()
        self.__prop_format(self.tree)

# end ExcMultiPattern


Richard Henderson's avatar
Richard Henderson committed
638
639
640
641
642
643
644
645
646
647
648
def parse_field(lineno, name, toks):
    """Parse one instruction field from TOKS at LINENO"""
    global fields
    global insnwidth

    # A "simple" field will have only one entry;
    # a "multifield" will have several.
    subs = []
    width = 0
    func = None
    for t in toks:
649
        if re.match('^!function=', t):
Richard Henderson's avatar
Richard Henderson committed
650
651
652
653
654
655
            if func:
                error(lineno, 'duplicate function')
            func = t.split('=')
            func = func[1]
            continue

656
        if re.fullmatch('[0-9]+:s[0-9]+', t):
Richard Henderson's avatar
Richard Henderson committed
657
658
659
            # Signed field extract
            subtoks = t.split(':s')
            sign = True
660
        elif re.fullmatch('[0-9]+:[0-9]+', t):
Richard Henderson's avatar
Richard Henderson committed
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
            # Unsigned field extract
            subtoks = t.split(':')
            sign = False
        else:
            error(lineno, 'invalid field token "{0}"'.format(t))
        po = int(subtoks[0])
        le = int(subtoks[1])
        if po + le > insnwidth:
            error(lineno, 'field {0} too large'.format(t))
        f = Field(sign, po, le)
        subs.append(f)
        width += le

    if width > insnwidth:
        error(lineno, 'field too large')
676
677
678
679
680
    if len(subs) == 0:
        if func:
            f = ParameterField(func)
        else:
            error(lineno, 'field with no value')
Richard Henderson's avatar
Richard Henderson committed
681
    else:
682
683
684
685
686
687
688
689
690
691
692
        if len(subs) == 1:
            f = subs[0]
        else:
            mask = 0
            for s in subs:
                if mask & s.mask:
                    error(lineno, 'field components overlap')
                mask |= s.mask
            f = MultiField(subs, mask)
        if func:
            f = FunctionField(func, f)
Richard Henderson's avatar
Richard Henderson committed
693
694
695
696
697
698
699
700
701
702

    if name in fields:
        error(lineno, 'duplicate field', name)
    fields[name] = f
# end parse_field


def parse_arguments(lineno, name, toks):
    """Parse one argument set from TOKS at LINENO"""
    global arguments
703
    global re_C_ident
704
    global anyextern
Richard Henderson's avatar
Richard Henderson committed
705
706

    flds = []
707
    extern = False
Richard Henderson's avatar
Richard Henderson committed
708
    for t in toks:
709
        if re.fullmatch('!extern', t):
710
            extern = True
711
            anyextern = True
712
            continue
713
        if not re.fullmatch(re_C_ident, t):
Richard Henderson's avatar
Richard Henderson committed
714
715
716
717
718
719
720
            error(lineno, 'invalid argument set token "{0}"'.format(t))
        if t in flds:
            error(lineno, 'duplicate argument "{0}"'.format(t))
        flds.append(t)

    if name in arguments:
        error(lineno, 'duplicate argument set', name)
721
    arguments[name] = Arguments(name, flds, extern)
Richard Henderson's avatar
Richard Henderson committed
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
# end parse_arguments


def lookup_field(lineno, name):
    global fields
    if name in fields:
        return fields[name]
    error(lineno, 'undefined field', name)


def add_field(lineno, flds, new_name, f):
    if new_name in flds:
        error(lineno, 'duplicate field', new_name)
    flds[new_name] = f
    return flds


def add_field_byname(lineno, flds, new_name, old_name):
    return add_field(lineno, flds, new_name, lookup_field(lineno, old_name))


def infer_argument_set(flds):
    global arguments
745
    global decode_function
Richard Henderson's avatar
Richard Henderson committed
746
747
748
749
750

    for arg in arguments.values():
        if eq_fields_for_args(flds, arg.fields):
            return arg

751
752
    name = decode_function + str(len(arguments))
    arg = Arguments(name, flds.keys(), False)
Richard Henderson's avatar
Richard Henderson committed
753
754
755
756
    arguments[name] = arg
    return arg


757
def infer_format(arg, fieldmask, flds, width):
Richard Henderson's avatar
Richard Henderson committed
758
759
    global arguments
    global formats
760
    global decode_function
Richard Henderson's avatar
Richard Henderson committed
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775

    const_flds = {}
    var_flds = {}
    for n, c in flds.items():
        if c is ConstField:
            const_flds[n] = c
        else:
            var_flds[n] = c

    # Look for an existing format with the same argument set and fields
    for fmt in formats.values():
        if arg and fmt.base != arg:
            continue
        if fieldmask != fmt.fieldmask:
            continue
776
777
        if width != fmt.width:
            continue
Richard Henderson's avatar
Richard Henderson committed
778
779
780
781
        if not eq_fields_for_fmts(flds, fmt.fields):
            continue
        return (fmt, const_flds)

782
    name = decode_function + '_Fmt_' + str(len(formats))
Richard Henderson's avatar
Richard Henderson committed
783
784
785
    if not arg:
        arg = infer_argument_set(flds)

786
    fmt = Format(name, 0, arg, 0, 0, 0, fieldmask, var_flds, width)
Richard Henderson's avatar
Richard Henderson committed
787
788
789
790
791
792
    formats[name] = fmt

    return (fmt, const_flds)
# end infer_format


793
def parse_generic(lineno, parent_pat, name, toks):
Richard Henderson's avatar
Richard Henderson committed
794
795
796
797
    """Parse one instruction format from TOKS at LINENO"""
    global fields
    global arguments
    global formats
798
    global allpatterns
799
800
801
802
    global re_arg_ident
    global re_fld_ident
    global re_fmt_ident
    global re_C_ident
Richard Henderson's avatar
Richard Henderson committed
803
804
    global insnwidth
    global insnmask
805
    global variablewidth
Richard Henderson's avatar
Richard Henderson committed
806

807
808
    is_format = parent_pat is None

Richard Henderson's avatar
Richard Henderson committed
809
810
811
812
813
814
815
816
    fixedmask = 0
    fixedbits = 0
    undefmask = 0
    width = 0
    flds = {}
    arg = None
    fmt = None
    for t in toks:
817
        # '&Foo' gives a format an explicit argument set.
818
        if re.fullmatch(re_arg_ident, t):
Richard Henderson's avatar
Richard Henderson committed
819
820
821
822
823
824
825
826
827
828
            tt = t[1:]
            if arg:
                error(lineno, 'multiple argument sets')
            if tt in arguments:
                arg = arguments[tt]
            else:
                error(lineno, 'undefined argument set', t)
            continue

        # '@Foo' gives a pattern an explicit format.
829
        if re.fullmatch(re_fmt_ident, t):
Richard Henderson's avatar
Richard Henderson committed
830
831
832
833
834
835
836
837
838
839
            tt = t[1:]
            if fmt:
                error(lineno, 'multiple formats')
            if tt in formats:
                fmt = formats[tt]
            else:
                error(lineno, 'undefined format', t)
            continue

        # '%Foo' imports a field.
840
        if re.fullmatch(re_fld_ident, t):
Richard Henderson's avatar
Richard Henderson committed
841
842
843
844
845
            tt = t[1:]
            flds = add_field_byname(lineno, flds, tt, tt)
            continue

        # 'Foo=%Bar' imports a field with a different name.
846
        if re.fullmatch(re_C_ident + '=' + re_fld_ident, t):
Richard Henderson's avatar
Richard Henderson committed
847
848
849
850
851
            (fname, iname) = t.split('=%')
            flds = add_field_byname(lineno, flds, fname, iname)
            continue

        # 'Foo=number' sets an argument field to a constant value
852
        if re.fullmatch(re_C_ident + '=[+-]?[0-9]+', t):
Richard Henderson's avatar
Richard Henderson committed
853
854
855
856
857
858
859
            (fname, value) = t.split('=')
            value = int(value)
            flds = add_field(lineno, flds, fname, ConstField(value))
            continue

        # Pattern of 0s, 1s, dots and dashes indicate required zeros,
        # required ones, or dont-cares.
860
        if re.fullmatch('[01.-]+', t):
Richard Henderson's avatar
Richard Henderson committed
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
            shift = len(t)
            fms = t.replace('0', '1')
            fms = fms.replace('.', '0')
            fms = fms.replace('-', '0')
            fbs = t.replace('.', '0')
            fbs = fbs.replace('-', '0')
            ubm = t.replace('1', '0')
            ubm = ubm.replace('.', '0')
            ubm = ubm.replace('-', '1')
            fms = int(fms, 2)
            fbs = int(fbs, 2)
            ubm = int(ubm, 2)
            fixedbits = (fixedbits << shift) | fbs
            fixedmask = (fixedmask << shift) | fms
            undefmask = (undefmask << shift) | ubm
        # Otherwise, fieldname:fieldwidth
877
        elif re.fullmatch(re_C_ident + ':s?[0-9]+', t):
Richard Henderson's avatar
Richard Henderson committed
878
879
880
881
882
883
            (fname, flen) = t.split(':')
            sign = False
            if flen[0] == 's':
                sign = True
                flen = flen[1:]
            shift = int(flen, 10)
884
885
            if shift + width > insnwidth:
                error(lineno, 'field {0} exceeds insnwidth'.format(fname))
Richard Henderson's avatar
Richard Henderson committed
886
887
888
889
890
891
892
893
894
            f = Field(sign, insnwidth - width - shift, shift)
            flds = add_field(lineno, flds, fname, f)
            fixedbits <<= shift
            fixedmask <<= shift
            undefmask <<= shift
        else:
            error(lineno, 'invalid token "{0}"'.format(t))
        width += shift

895
896
897
898
899
900
901
    if variablewidth and width < insnwidth and width % 8 == 0:
        shift = insnwidth - width
        fixedbits <<= shift
        fixedmask <<= shift
        undefmask <<= shift
        undefmask |= (1 << shift) - 1

Richard Henderson's avatar
Richard Henderson committed
902
    # We should have filled in all of the bits of the instruction.
903
    elif not (is_format and width == 0) and width != insnwidth:
Richard Henderson's avatar
Richard Henderson committed
904
905
        error(lineno, 'definition has {0} bits'.format(width))

906
    # Do not check for fields overlapping fields; one valid usage
Richard Henderson's avatar
Richard Henderson committed
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
    # is to be able to duplicate fields via import.
    fieldmask = 0
    for f in flds.values():
        fieldmask |= f.mask

    # Fix up what we've parsed to match either a format or a pattern.
    if is_format:
        # Formats cannot reference formats.
        if fmt:
            error(lineno, 'format referencing format')
        # If an argument set is given, then there should be no fields
        # without a place to store it.
        if arg:
            for f in flds.keys():
                if f not in arg.fields:
                    error(lineno, 'field {0} not in argument set {1}'
                                  .format(f, arg.name))
        else:
            arg = infer_argument_set(flds)
        if name in formats:
            error(lineno, 'duplicate format name', name)
        fmt = Format(name, lineno, arg, fixedbits, fixedmask,
929
                     undefmask, fieldmask, flds, width)
Richard Henderson's avatar
Richard Henderson committed
930
931
932
933
934
935
936
937
938
        formats[name] = fmt
    else:
        # Patterns can reference a format ...
        if fmt:
            # ... but not an argument simultaneously
            if arg:
                error(lineno, 'pattern specifies both format and argument set')
            if fixedmask & fmt.fixedmask:
                error(lineno, 'pattern fixed bits overlap format fixed bits')
939
940
            if width != fmt.width:
                error(lineno, 'pattern uses format of different width')
Richard Henderson's avatar
Richard Henderson committed
941
942
943
944
945
            fieldmask |= fmt.fieldmask
            fixedbits |= fmt.fixedbits
            fixedmask |= fmt.fixedmask
            undefmask |= fmt.undefmask
        else:
946
            (fmt, flds) = infer_format(arg, fieldmask, flds, width)
Richard Henderson's avatar
Richard Henderson committed
947
948
949
950
951
952
953
954
955
956
957
        arg = fmt.base
        for f in flds.keys():
            if f not in arg.fields:
                error(lineno, 'field {0} not in argument set {1}'
                              .format(f, arg.name))
            if f in fmt.fields.keys():
                error(lineno, 'field {0} set by format and pattern'.format(f))
        for f in arg.fields:
            if f not in flds.keys() and f not in fmt.fields.keys():
                error(lineno, 'field {0} not initialized'.format(f))
        pat = Pattern(name, lineno, fmt, fixedbits, fixedmask,
958
                      undefmask, fieldmask, flds, width)
959
        parent_pat.pats.append(pat)
960
        allpatterns.append(pat)
Richard Henderson's avatar
Richard Henderson committed
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978

    # Validate the masks that we have assembled.
    if fieldmask & fixedmask:
        error(lineno, 'fieldmask overlaps fixedmask (0x{0:08x} & 0x{1:08x})'
                      .format(fieldmask, fixedmask))
    if fieldmask & undefmask:
        error(lineno, 'fieldmask overlaps undefmask (0x{0:08x} & 0x{1:08x})'
                      .format(fieldmask, undefmask))
    if fixedmask & undefmask:
        error(lineno, 'fixedmask overlaps undefmask (0x{0:08x} & 0x{1:08x})'
                      .format(fixedmask, undefmask))
    if not is_format:
        allbits = fieldmask | fixedmask | undefmask
        if allbits != insnmask:
            error(lineno, 'bits left unspecified (0x{0:08x})'
                          .format(allbits ^ insnmask))
# end parse_general

979

980
def parse_file(f, parent_pat):
Richard Henderson's avatar
Richard Henderson committed
981
    """Parse all of the patterns within a file"""
982
983
984
985
    global re_arg_ident
    global re_fld_ident
    global re_fmt_ident
    global re_pat_ident
Richard Henderson's avatar
Richard Henderson committed
986
987
988
989
990

    # Read all of the lines of the file.  Concatenate lines
    # ending in backslash; discard empty lines and comments.
    toks = []
    lineno = 0
991
    nesting = 0
992
    nesting_pats = []
993

Richard Henderson's avatar
Richard Henderson committed
994
995
996
    for line in f:
        lineno += 1

997
998
999
1000
        # Expand and strip spaces, to find indent.
        line = line.rstrip()
        line = line.expandtabs()
        len1 = len(line)