1#!/usr/bin/env python3 2 3## 4## Copyright(c) 2019-2021 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 31 32# We should do this as a hash for performance, 33# but to keep order let's keep it as a list. 34def uniquify(seq): 35 seen = set() 36 seen_add = seen.add 37 return [x for x in seq if x not in seen and not seen_add(x)] 38 39regre = re.compile( 40 r"((?<!DUP)[MNORCPQXSGVZA])([stuvwxyzdefg]+)([.]?[LlHh]?)(\d+S?)") 41immre = re.compile(r"[#]([rRsSuUm])(\d+)(?:[:](\d+))?") 42reg_or_immre = \ 43 re.compile(r"(((?<!DUP)[MNRCOPQXSGVZA])([stuvwxyzdefg]+)" + \ 44 "([.]?[LlHh]?)(\d+S?))|([#]([rRsSuUm])(\d+)[:]?(\d+)?)") 45relimmre = re.compile(r"[#]([rR])(\d+)(?:[:](\d+))?") 46absimmre = re.compile(r"[#]([sSuUm])(\d+)(?:[:](\d+))?") 47 48finished_macros = set() 49 50def expand_macro_attribs(macro,allmac_re): 51 if macro.key not in finished_macros: 52 # Get a list of all things that might be macros 53 l = allmac_re.findall(macro.beh) 54 for submacro in l: 55 if not submacro: continue 56 if not macros[submacro]: 57 raise Exception("Couldn't find macro: <%s>" % l) 58 macro.attribs |= expand_macro_attribs( 59 macros[submacro], allmac_re) 60 finished_macros.add(macro.key) 61 return macro.attribs 62 63# When qemu needs an attribute that isn't in the imported files, 64# we'll add it here. 65def add_qemu_macro_attrib(name, attrib): 66 macros[name].attribs.add(attrib) 67 68immextre = re.compile(r'f(MUST_)?IMMEXT[(]([UuSsRr])') 69def calculate_attribs(): 70 add_qemu_macro_attrib('fREAD_PC', 'A_IMPLICIT_READS_PC') 71 add_qemu_macro_attrib('fTRAP', 'A_IMPLICIT_READS_PC') 72 add_qemu_macro_attrib('fWRITE_P0', 'A_WRITES_PRED_REG') 73 add_qemu_macro_attrib('fWRITE_P1', 'A_WRITES_PRED_REG') 74 add_qemu_macro_attrib('fWRITE_P2', 'A_WRITES_PRED_REG') 75 add_qemu_macro_attrib('fWRITE_P3', 'A_WRITES_PRED_REG') 76 add_qemu_macro_attrib('fSET_OVERFLOW', 'A_IMPLICIT_WRITES_USR') 77 add_qemu_macro_attrib('fSET_LPCFG', 'A_IMPLICIT_WRITES_USR') 78 79 # Recurse down macros, find attributes from sub-macros 80 macroValues = list(macros.values()) 81 allmacros_restr = "|".join(set([ m.re.pattern for m in macroValues ])) 82 allmacros_re = re.compile(allmacros_restr) 83 for macro in macroValues: 84 expand_macro_attribs(macro,allmacros_re) 85 # Append attributes to all instructions 86 for tag in tags: 87 for macname in allmacros_re.findall(semdict[tag]): 88 if not macname: continue 89 macro = macros[macname] 90 attribdict[tag] |= set(macro.attribs) 91 # Figure out which instructions write predicate registers 92 tagregs = get_tagregs() 93 for tag in tags: 94 regs = tagregs[tag] 95 for regtype, regid, toss, numregs in regs: 96 if regtype == "P" and is_written(regid): 97 attribdict[tag].add('A_WRITES_PRED_REG') 98 99def SEMANTICS(tag, beh, sem): 100 #print tag,beh,sem 101 behdict[tag] = beh 102 semdict[tag] = sem 103 attribdict[tag] = set() 104 tags.append(tag) # dicts have no order, this is for order 105 106def ATTRIBUTES(tag, attribstring): 107 attribstring = \ 108 attribstring.replace("ATTRIBS","").replace("(","").replace(")","") 109 if not attribstring: 110 return 111 attribs = attribstring.split(",") 112 for attrib in attribs: 113 attribdict[tag].add(attrib.strip()) 114 115class Macro(object): 116 __slots__ = ['key','name', 'beh', 'attribs', 're'] 117 def __init__(self, name, beh, attribs): 118 self.key = name 119 self.name = name 120 self.beh = beh 121 self.attribs = set(attribs) 122 self.re = re.compile("\\b" + name + "\\b") 123 124def MACROATTRIB(macname,beh,attribstring): 125 attribstring = attribstring.replace("(","").replace(")","") 126 if attribstring: 127 attribs = attribstring.split(",") 128 else: 129 attribs = [] 130 macros[macname] = Macro(macname,beh,attribs) 131 132def compute_tag_regs(tag): 133 return uniquify(regre.findall(behdict[tag])) 134 135def compute_tag_immediates(tag): 136 return uniquify(immre.findall(behdict[tag])) 137 138## 139## tagregs is the main data structure we'll use 140## tagregs[tag] will contain the registers used by an instruction 141## Within each entry, we'll use the regtype and regid fields 142## regtype can be one of the following 143## C control register 144## N new register value 145## P predicate register 146## R GPR register 147## M modifier register 148## regid can be one of the following 149## d, e destination register 150## dd destination register pair 151## s, t, u, v, w source register 152## ss, tt, uu, vv source register pair 153## x, y read-write register 154## xx, yy read-write register pair 155## 156def get_tagregs(): 157 return dict(zip(tags, list(map(compute_tag_regs, tags)))) 158 159def get_tagimms(): 160 return dict(zip(tags, list(map(compute_tag_immediates, tags)))) 161 162def is_pair(regid): 163 return len(regid) == 2 164 165def is_single(regid): 166 return len(regid) == 1 167 168def is_written(regid): 169 return regid[0] in "dexy" 170 171def is_writeonly(regid): 172 return regid[0] in "de" 173 174def is_read(regid): 175 return regid[0] in "stuvwxy" 176 177def is_readwrite(regid): 178 return regid[0] in "xy" 179 180def is_scalar_reg(regtype): 181 return regtype in "RPC" 182 183def is_old_val(regtype, regid, tag): 184 return regtype+regid+'V' in semdict[tag] 185 186def is_new_val(regtype, regid, tag): 187 return regtype+regid+'N' in semdict[tag] 188 189def need_slot(tag): 190 if ('A_CONDEXEC' in attribdict[tag] or 191 'A_STORE' in attribdict[tag] or 192 'A_LOAD' in attribdict[tag]): 193 return 1 194 else: 195 return 0 196 197def need_part1(tag): 198 return re.compile(r"fPART1").search(semdict[tag]) 199 200def need_ea(tag): 201 return re.compile(r"\bEA\b").search(semdict[tag]) 202 203def skip_qemu_helper(tag): 204 return tag in overrides.keys() 205 206def imm_name(immlett): 207 return "%siV" % immlett 208 209def read_semantics_file(name): 210 eval_line = "" 211 for line in open(name, 'rt').readlines(): 212 if not line.startswith("#"): 213 eval_line += line 214 if line.endswith("\\\n"): 215 eval_line.rstrip("\\\n") 216 else: 217 eval(eval_line.strip()) 218 eval_line = "" 219 220def read_attribs_file(name): 221 attribre = re.compile(r'DEF_ATTRIB\(([A-Za-z0-9_]+), ([^,]*), ' + 222 r'"([A-Za-z0-9_\.]*)", "([A-Za-z0-9_\.]*)"\)') 223 for line in open(name, 'rt').readlines(): 224 if not attribre.match(line): 225 continue 226 (attrib_base,descr,rreg,wreg) = attribre.findall(line)[0] 227 attrib_base = 'A_' + attrib_base 228 attribinfo[attrib_base] = {'rreg':rreg, 'wreg':wreg, 'descr':descr} 229 230def read_overrides_file(name): 231 overridere = re.compile("#define fGEN_TCG_([A-Za-z0-9_]+)\(.*") 232 for line in open(name, 'rt').readlines(): 233 if not overridere.match(line): 234 continue 235 tag = overridere.findall(line)[0] 236 overrides[tag] = True 237