xref: /openbmc/qemu/target/hexagon/hex_common.py (revision 89aafcf2) 
1#!/usr/bin/env python3
2
3##
4##  Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
5##
6##  This program is free software; you can redistribute it and/or modify
7##  it under the terms of the GNU General Public License as published by
8##  the Free Software Foundation; either version 2 of the License, or
9##  (at your option) any later version.
10##
11##  This program is distributed in the hope that it will be useful,
12##  but WITHOUT ANY WARRANTY; without even the implied warranty of
13##  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14##  GNU General Public License for more details.
15##
16##  You should have received a copy of the GNU General Public License
17##  along with this program; if not, see <http://www.gnu.org/licenses/>.
18##
19
20import sys
21import re
22import string
23
24behdict = {}  # tag ->behavior
25semdict = {}  # tag -> semantics
26attribdict = {}  # tag -> attributes
27macros = {}  # macro -> macro information...
28attribinfo = {}  # Register information and misc
29tags = []  # list of all tags
30overrides = {}  # tags with helper overrides
31idef_parser_enabled = {}  # tags enabled for idef-parser
32
33def bad_register(regtype, regid):
34    raise Exception(f"Bad register parse: regtype '{regtype}' regid '{regid}'")
35
36# We should do this as a hash for performance,
37# but to keep order let's keep it as a list.
38def uniquify(seq):
39    seen = set()
40    seen_add = seen.add
41    return [x for x in seq if x not in seen and not seen_add(x)]
42
43
44regre = re.compile(r"((?<!DUP)[MNORCPQXSGVZA])([stuvwxyzdefg]+)([.]?[LlHh]?)(\d+S?)")
45immre = re.compile(r"[#]([rRsSuUm])(\d+)(?:[:](\d+))?")
46reg_or_immre = re.compile(
47    r"(((?<!DUP)[MNRCOPQXSGVZA])([stuvwxyzdefg]+)"
48    + "([.]?[LlHh]?)(\d+S?))|([#]([rRsSuUm])(\d+)[:]?(\d+)?)"
49)
50relimmre = re.compile(r"[#]([rR])(\d+)(?:[:](\d+))?")
51absimmre = re.compile(r"[#]([sSuUm])(\d+)(?:[:](\d+))?")
52
53finished_macros = set()
54
55
56def expand_macro_attribs(macro, allmac_re):
57    if macro.key not in finished_macros:
58        # Get a list of all things that might be macros
59        l = allmac_re.findall(macro.beh)
60        for submacro in l:
61            if not submacro:
62                continue
63            if not macros[submacro]:
64                raise Exception(f"Couldn't find macro: <{l}>")
65            macro.attribs |= expand_macro_attribs(macros[submacro], allmac_re)
66            finished_macros.add(macro.key)
67    return macro.attribs
68
69
70# When qemu needs an attribute that isn't in the imported files,
71# we'll add it here.
72def add_qemu_macro_attrib(name, attrib):
73    macros[name].attribs.add(attrib)
74
75
76immextre = re.compile(r"f(MUST_)?IMMEXT[(]([UuSsRr])")
77
78
79def is_cond_jump(tag):
80    if tag == "J2_rte":
81        return False
82    if "A_HWLOOP0_END" in attribdict[tag] or "A_HWLOOP1_END" in attribdict[tag]:
83        return False
84    return re.compile(r"(if.*fBRANCH)|(if.*fJUMPR)").search(semdict[tag]) != None
85
86
87def is_cond_call(tag):
88    return re.compile(r"(if.*fCALL)").search(semdict[tag]) != None
89
90
91def calculate_attribs():
92    add_qemu_macro_attrib("fREAD_PC", "A_IMPLICIT_READS_PC")
93    add_qemu_macro_attrib("fTRAP", "A_IMPLICIT_READS_PC")
94    add_qemu_macro_attrib("fWRITE_P0", "A_WRITES_PRED_REG")
95    add_qemu_macro_attrib("fWRITE_P1", "A_WRITES_PRED_REG")
96    add_qemu_macro_attrib("fWRITE_P2", "A_WRITES_PRED_REG")
97    add_qemu_macro_attrib("fWRITE_P3", "A_WRITES_PRED_REG")
98    add_qemu_macro_attrib("fSET_OVERFLOW", "A_IMPLICIT_WRITES_USR")
99    add_qemu_macro_attrib("fSET_LPCFG", "A_IMPLICIT_WRITES_USR")
100    add_qemu_macro_attrib("fLOAD", "A_SCALAR_LOAD")
101    add_qemu_macro_attrib("fSTORE", "A_SCALAR_STORE")
102    add_qemu_macro_attrib('fLSBNEW0', 'A_IMPLICIT_READS_P0')
103    add_qemu_macro_attrib('fLSBNEW0NOT', 'A_IMPLICIT_READS_P0')
104    add_qemu_macro_attrib('fREAD_P0', 'A_IMPLICIT_READS_P0')
105    add_qemu_macro_attrib('fLSBNEW1', 'A_IMPLICIT_READS_P1')
106    add_qemu_macro_attrib('fLSBNEW1NOT', 'A_IMPLICIT_READS_P1')
107    add_qemu_macro_attrib('fREAD_P3', 'A_IMPLICIT_READS_P3')
108
109    # Recurse down macros, find attributes from sub-macros
110    macroValues = list(macros.values())
111    allmacros_restr = "|".join(set([m.re.pattern for m in macroValues]))
112    allmacros_re = re.compile(allmacros_restr)
113    for macro in macroValues:
114        expand_macro_attribs(macro, allmacros_re)
115    # Append attributes to all instructions
116    for tag in tags:
117        for macname in allmacros_re.findall(semdict[tag]):
118            if not macname:
119                continue
120            macro = macros[macname]
121            attribdict[tag] |= set(macro.attribs)
122    # Figure out which instructions write predicate registers
123    tagregs = get_tagregs()
124    for tag in tags:
125        regs = tagregs[tag]
126        for regtype, regid in regs:
127            if regtype == "P" and is_written(regid):
128                attribdict[tag].add("A_WRITES_PRED_REG")
129    # Mark conditional jumps and calls
130    #     Not all instructions are properly marked with A_CONDEXEC
131    for tag in tags:
132        if is_cond_jump(tag) or is_cond_call(tag):
133            attribdict[tag].add("A_CONDEXEC")
134
135
136def SEMANTICS(tag, beh, sem):
137    # print tag,beh,sem
138    behdict[tag] = beh
139    semdict[tag] = sem
140    attribdict[tag] = set()
141    tags.append(tag)  # dicts have no order, this is for order
142
143
144def ATTRIBUTES(tag, attribstring):
145    attribstring = attribstring.replace("ATTRIBS", "").replace("(", "").replace(")", "")
146    if not attribstring:
147        return
148    attribs = attribstring.split(",")
149    for attrib in attribs:
150        attribdict[tag].add(attrib.strip())
151
152
153class Macro(object):
154    __slots__ = ["key", "name", "beh", "attribs", "re"]
155
156    def __init__(self, name, beh, attribs):
157        self.key = name
158        self.name = name
159        self.beh = beh
160        self.attribs = set(attribs)
161        self.re = re.compile("\\b" + name + "\\b")
162
163
164def MACROATTRIB(macname, beh, attribstring):
165    attribstring = attribstring.replace("(", "").replace(")", "")
166    if attribstring:
167        attribs = attribstring.split(",")
168    else:
169        attribs = []
170    macros[macname] = Macro(macname, beh, attribs)
171
172def compute_tag_regs(tag, full):
173    tagregs = regre.findall(behdict[tag])
174    if not full:
175        tagregs = map(lambda reg: reg[:2], tagregs)
176    return uniquify(tagregs)
177
178def compute_tag_immediates(tag):
179    return uniquify(immre.findall(behdict[tag]))
180
181
182##
183##  tagregs is the main data structure we'll use
184##  tagregs[tag] will contain the registers used by an instruction
185##  Within each entry, we'll use the regtype and regid fields
186##      regtype can be one of the following
187##          C                control register
188##          N                new register value
189##          P                predicate register
190##          R                GPR register
191##          M                modifier register
192##          Q                HVX predicate vector
193##          V                HVX vector register
194##          O                HVX new vector register
195##      regid can be one of the following
196##          d, e             destination register
197##          dd               destination register pair
198##          s, t, u, v, w    source register
199##          ss, tt, uu, vv   source register pair
200##          x, y             read-write register
201##          xx, yy           read-write register pair
202##
203def get_tagregs(full=False):
204    compute_func = lambda tag: compute_tag_regs(tag, full)
205    return dict(zip(tags, list(map(compute_func, tags))))
206
207def get_tagimms():
208    return dict(zip(tags, list(map(compute_tag_immediates, tags))))
209
210
211def is_pair(regid):
212    return len(regid) == 2
213
214
215def is_single(regid):
216    return len(regid) == 1
217
218
219def is_written(regid):
220    return regid[0] in "dexy"
221
222
223def is_writeonly(regid):
224    return regid[0] in "de"
225
226
227def is_read(regid):
228    return regid[0] in "stuvwxy"
229
230
231def is_readwrite(regid):
232    return regid[0] in "xy"
233
234
235def is_scalar_reg(regtype):
236    return regtype in "RPC"
237
238
239def is_hvx_reg(regtype):
240    return regtype in "VQ"
241
242
243def is_old_val(regtype, regid, tag):
244    return regtype + regid + "V" in semdict[tag]
245
246
247def is_new_val(regtype, regid, tag):
248    return regtype + regid + "N" in semdict[tag]
249
250
251def need_slot(tag):
252    if (
253        "A_CVI_SCATTER" not in attribdict[tag]
254        and "A_CVI_GATHER" not in attribdict[tag]
255        and ("A_STORE" in attribdict[tag]
256             or "A_LOAD" in attribdict[tag])
257    ):
258        return 1
259    else:
260        return 0
261
262
263def need_part1(tag):
264    return re.compile(r"fPART1").search(semdict[tag])
265
266
267def need_ea(tag):
268    return re.compile(r"\bEA\b").search(semdict[tag])
269
270
271def need_PC(tag):
272    return "A_IMPLICIT_READS_PC" in attribdict[tag]
273
274
275def helper_needs_next_PC(tag):
276    return "A_CALL" in attribdict[tag]
277
278
279def need_pkt_has_multi_cof(tag):
280    return "A_COF" in attribdict[tag]
281
282
283def need_pkt_need_commit(tag):
284    return 'A_IMPLICIT_WRITES_USR' in attribdict[tag]
285
286def need_condexec_reg(tag, regs):
287    if "A_CONDEXEC" in attribdict[tag]:
288        for regtype, regid in regs:
289            if is_writeonly(regid) and not is_hvx_reg(regtype):
290                return True
291    return False
292
293
294def skip_qemu_helper(tag):
295    return tag in overrides.keys()
296
297
298def is_tmp_result(tag):
299    return "A_CVI_TMP" in attribdict[tag] or "A_CVI_TMP_DST" in attribdict[tag]
300
301
302def is_new_result(tag):
303    return "A_CVI_NEW" in attribdict[tag]
304
305
306def is_idef_parser_enabled(tag):
307    return tag in idef_parser_enabled
308
309
310def imm_name(immlett):
311    return f"{immlett}iV"
312
313
314def read_semantics_file(name):
315    eval_line = ""
316    for line in open(name, "rt").readlines():
317        if not line.startswith("#"):
318            eval_line += line
319            if line.endswith("\\\n"):
320                eval_line.rstrip("\\\n")
321            else:
322                eval(eval_line.strip())
323                eval_line = ""
324
325
326def read_attribs_file(name):
327    attribre = re.compile(
328        r"DEF_ATTRIB\(([A-Za-z0-9_]+), ([^,]*), "
329        + r'"([A-Za-z0-9_\.]*)", "([A-Za-z0-9_\.]*)"\)'
330    )
331    for line in open(name, "rt").readlines():
332        if not attribre.match(line):
333            continue
334        (attrib_base, descr, rreg, wreg) = attribre.findall(line)[0]
335        attrib_base = "A_" + attrib_base
336        attribinfo[attrib_base] = {"rreg": rreg, "wreg": wreg, "descr": descr}
337
338
339def read_overrides_file(name):
340    overridere = re.compile("#define fGEN_TCG_([A-Za-z0-9_]+)\(.*")
341    for line in open(name, "rt").readlines():
342        if not overridere.match(line):
343            continue
344        tag = overridere.findall(line)[0]
345        overrides[tag] = True
346
347
348def read_idef_parser_enabled_file(name):
349    global idef_parser_enabled
350    with open(name, "r") as idef_parser_enabled_file:
351        lines = idef_parser_enabled_file.read().strip().split("\n")
352        idef_parser_enabled = set(lines)
353