Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 1 | #!/usr/bin/env python3 |
| 2 | |
| 3 | ## |
Taylor Simpson | e28b77a | 2023-03-06 18:58:26 -0800 | [diff] [blame] | 4 | ## Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved. |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 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 | |
| 20 | import sys |
| 21 | import re |
| 22 | import string |
| 23 | import hex_common |
| 24 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 25 | |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 26 | ## |
| 27 | ## Helpers for gen_helper_function |
| 28 | ## |
| 29 | def gen_decl_ea(f): |
| 30 | f.write(" uint32_t EA;\n") |
| 31 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 32 | |
| 33 | def gen_helper_return_type(f, regtype, regid, regno): |
| 34 | if regno > 1: |
| 35 | f.write(", ") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 36 | f.write("int32_t") |
| 37 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 38 | |
| 39 | def gen_helper_return_type_pair(f, regtype, regid, regno): |
| 40 | if regno > 1: |
| 41 | f.write(", ") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 42 | f.write("int64_t") |
| 43 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 44 | |
| 45 | def gen_helper_arg(f, regtype, regid, regno): |
| 46 | if regno > 0: |
| 47 | f.write(", ") |
Marco Liebel | cd6c4ed | 2023-03-20 02:25:32 -0700 | [diff] [blame] | 48 | f.write(f"int32_t {regtype}{regid}V") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 49 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 50 | |
| 51 | def gen_helper_arg_new(f, regtype, regid, regno): |
| 52 | if regno >= 0: |
| 53 | f.write(", ") |
Marco Liebel | cd6c4ed | 2023-03-20 02:25:32 -0700 | [diff] [blame] | 54 | f.write(f"int32_t {regtype}{regid}N") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 55 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 56 | |
| 57 | def gen_helper_arg_pair(f, regtype, regid, regno): |
| 58 | if regno >= 0: |
| 59 | f.write(", ") |
Marco Liebel | cd6c4ed | 2023-03-20 02:25:32 -0700 | [diff] [blame] | 60 | f.write(f"int64_t {regtype}{regid}V") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 61 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 62 | |
| 63 | def gen_helper_arg_ext(f, regtype, regid, regno): |
| 64 | if regno > 0: |
| 65 | f.write(", ") |
Marco Liebel | cd6c4ed | 2023-03-20 02:25:32 -0700 | [diff] [blame] | 66 | f.write(f"void *{regtype}{regid}V_void") |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 67 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 68 | |
| 69 | def gen_helper_arg_ext_pair(f, regtype, regid, regno): |
| 70 | if regno > 0: |
| 71 | f.write(", ") |
Marco Liebel | cd6c4ed | 2023-03-20 02:25:32 -0700 | [diff] [blame] | 72 | f.write(f"void *{regtype}{regid}V_void") |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 73 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 74 | |
| 75 | def gen_helper_arg_opn(f, regtype, regid, i, tag): |
| 76 | if hex_common.is_pair(regid): |
| 77 | if hex_common.is_hvx_reg(regtype): |
| 78 | gen_helper_arg_ext_pair(f, regtype, regid, i) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 79 | else: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 80 | gen_helper_arg_pair(f, regtype, regid, i) |
| 81 | elif hex_common.is_single(regid): |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 82 | if hex_common.is_old_val(regtype, regid, tag): |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 83 | if hex_common.is_hvx_reg(regtype): |
| 84 | gen_helper_arg_ext(f, regtype, regid, i) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 85 | else: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 86 | gen_helper_arg(f, regtype, regid, i) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 87 | elif hex_common.is_new_val(regtype, regid, tag): |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 88 | gen_helper_arg_new(f, regtype, regid, i) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 89 | else: |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 90 | hex_common.bad_register(regtype, regid) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 91 | else: |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 92 | hex_common.bad_register(regtype, regid) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 93 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 94 | |
| 95 | def gen_helper_arg_imm(f, immlett): |
Marco Liebel | cd6c4ed | 2023-03-20 02:25:32 -0700 | [diff] [blame] | 96 | f.write(f", int32_t {hex_common.imm_name(immlett)}") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 97 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 98 | |
| 99 | def gen_helper_dest_decl(f, regtype, regid, regno, subfield=""): |
Marco Liebel | cd6c4ed | 2023-03-20 02:25:32 -0700 | [diff] [blame] | 100 | f.write(f" int32_t {regtype}{regid}V{subfield} = 0;\n") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 101 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 102 | |
| 103 | def gen_helper_dest_decl_pair(f, regtype, regid, regno, subfield=""): |
Marco Liebel | cd6c4ed | 2023-03-20 02:25:32 -0700 | [diff] [blame] | 104 | f.write(f" int64_t {regtype}{regid}V{subfield} = 0;\n") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 105 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 106 | |
| 107 | def gen_helper_dest_decl_ext(f, regtype, regid): |
| 108 | if regtype == "Q": |
| 109 | f.write( |
| 110 | f" /* {regtype}{regid}V is *(MMQReg *)" f"({regtype}{regid}V_void) */\n" |
| 111 | ) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 112 | else: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 113 | f.write( |
| 114 | f" /* {regtype}{regid}V is *(MMVector *)" |
| 115 | f"({regtype}{regid}V_void) */\n" |
| 116 | ) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 117 | |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 118 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 119 | def gen_helper_dest_decl_ext_pair(f, regtype, regid, regno): |
| 120 | f.write( |
| 121 | f" /* {regtype}{regid}V is *(MMVectorPair *))" |
| 122 | f"{regtype}{regid}V_void) */\n" |
| 123 | ) |
| 124 | |
| 125 | |
| 126 | def gen_helper_dest_decl_opn(f, regtype, regid, i): |
| 127 | if hex_common.is_pair(regid): |
| 128 | if hex_common.is_hvx_reg(regtype): |
| 129 | gen_helper_dest_decl_ext_pair(f, regtype, regid, i) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 130 | else: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 131 | gen_helper_dest_decl_pair(f, regtype, regid, i) |
| 132 | elif hex_common.is_single(regid): |
| 133 | if hex_common.is_hvx_reg(regtype): |
| 134 | gen_helper_dest_decl_ext(f, regtype, regid) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 135 | else: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 136 | gen_helper_dest_decl(f, regtype, regid, i) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 137 | else: |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 138 | hex_common.bad_register(regtype, regid) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 139 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 140 | |
| 141 | def gen_helper_src_var_ext(f, regtype, regid): |
| 142 | if regtype == "Q": |
| 143 | f.write( |
| 144 | f" /* {regtype}{regid}V is *(MMQReg *)" f"({regtype}{regid}V_void) */\n" |
| 145 | ) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 146 | else: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 147 | f.write( |
| 148 | f" /* {regtype}{regid}V is *(MMVector *)" |
| 149 | f"({regtype}{regid}V_void) */\n" |
| 150 | ) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 151 | |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 152 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 153 | def gen_helper_src_var_ext_pair(f, regtype, regid, regno): |
| 154 | f.write( |
| 155 | f" /* {regtype}{regid}V{regno} is *(MMVectorPair *)" |
| 156 | f"({regtype}{regid}V{regno}_void) */\n" |
| 157 | ) |
| 158 | |
| 159 | |
| 160 | def gen_helper_return(f, regtype, regid, regno): |
Marco Liebel | cd6c4ed | 2023-03-20 02:25:32 -0700 | [diff] [blame] | 161 | f.write(f" return {regtype}{regid}V;\n") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 162 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 163 | |
| 164 | def gen_helper_return_pair(f, regtype, regid, regno): |
Marco Liebel | cd6c4ed | 2023-03-20 02:25:32 -0700 | [diff] [blame] | 165 | f.write(f" return {regtype}{regid}V;\n") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 166 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 167 | |
| 168 | def gen_helper_dst_write_ext(f, regtype, regid): |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 169 | return |
| 170 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 171 | |
| 172 | def gen_helper_dst_write_ext_pair(f, regtype, regid): |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 173 | return |
| 174 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 175 | |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 176 | def gen_helper_return_opn(f, regtype, regid, i): |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 177 | if hex_common.is_pair(regid): |
| 178 | if hex_common.is_hvx_reg(regtype): |
| 179 | gen_helper_dst_write_ext_pair(f, regtype, regid) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 180 | else: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 181 | gen_helper_return_pair(f, regtype, regid, i) |
| 182 | elif hex_common.is_single(regid): |
| 183 | if hex_common.is_hvx_reg(regtype): |
| 184 | gen_helper_dst_write_ext(f, regtype, regid) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 185 | else: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 186 | gen_helper_return(f, regtype, regid, i) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 187 | else: |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 188 | hex_common.bad_register(regtype, regid) |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 189 | |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 190 | |
| 191 | ## |
| 192 | ## Generate the TCG code to call the helper |
| 193 | ## For A2_add: Rd32=add(Rs32,Rt32), { RdV=RsV+RtV;} |
| 194 | ## We produce: |
| 195 | ## int32_t HELPER(A2_add)(CPUHexagonState *env, int32_t RsV, int32_t RtV) |
| 196 | ## { |
| 197 | ## uint32_t slot __attribute__(unused)) = 4; |
| 198 | ## int32_t RdV = 0; |
| 199 | ## { RdV=RsV+RtV;} |
| 200 | ## COUNT_HELPER(A2_add); |
| 201 | ## return RdV; |
| 202 | ## } |
| 203 | ## |
| 204 | def gen_helper_function(f, tag, tagregs, tagimms): |
| 205 | regs = tagregs[tag] |
| 206 | imms = tagimms[tag] |
| 207 | |
| 208 | numresults = 0 |
| 209 | numscalarresults = 0 |
| 210 | numscalarreadwrite = 0 |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 211 | for regtype, regid in regs: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 212 | if hex_common.is_written(regid): |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 213 | numresults += 1 |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 214 | if hex_common.is_scalar_reg(regtype): |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 215 | numscalarresults += 1 |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 216 | if hex_common.is_readwrite(regid): |
| 217 | if hex_common.is_scalar_reg(regtype): |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 218 | numscalarreadwrite += 1 |
| 219 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 220 | if numscalarresults > 1: |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 221 | ## The helper is bogus when there is more than one result |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 222 | f.write( |
| 223 | f"void HELPER({tag})(CPUHexagonState *env) " f"{{ BOGUS_HELPER({tag}); }}\n" |
| 224 | ) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 225 | else: |
| 226 | ## The return type of the function is the type of the destination |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 227 | ## register (if scalar) |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 228 | i = 0 |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 229 | for regtype, regid in regs: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 230 | if hex_common.is_written(regid): |
| 231 | if hex_common.is_pair(regid): |
| 232 | if hex_common.is_hvx_reg(regtype): |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 233 | continue |
| 234 | else: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 235 | gen_helper_return_type_pair(f, regtype, regid, i) |
| 236 | elif hex_common.is_single(regid): |
| 237 | if hex_common.is_hvx_reg(regtype): |
| 238 | continue |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 239 | else: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 240 | gen_helper_return_type(f, regtype, regid, i) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 241 | else: |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 242 | hex_common.bad_register(regtype, regid) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 243 | i += 1 |
| 244 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 245 | if numscalarresults == 0: |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 246 | f.write("void") |
Marco Liebel | cd6c4ed | 2023-03-20 02:25:32 -0700 | [diff] [blame] | 247 | f.write(f" HELPER({tag})(CPUHexagonState *env") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 248 | |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 249 | ## Arguments include the vector destination operands |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 250 | i = 1 |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 251 | for regtype, regid in regs: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 252 | if hex_common.is_written(regid): |
| 253 | if hex_common.is_pair(regid): |
| 254 | if hex_common.is_hvx_reg(regtype): |
| 255 | gen_helper_arg_ext_pair(f, regtype, regid, i) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 256 | else: |
| 257 | continue |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 258 | elif hex_common.is_single(regid): |
| 259 | if hex_common.is_hvx_reg(regtype): |
| 260 | gen_helper_arg_ext(f, regtype, regid, i) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 261 | else: |
| 262 | # This is the return value of the function |
| 263 | continue |
| 264 | else: |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 265 | hex_common.bad_register(regtype, regid) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 266 | i += 1 |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 267 | |
Taylor Simpson | e28b77a | 2023-03-06 18:58:26 -0800 | [diff] [blame] | 268 | ## For conditional instructions, we pass in the destination register |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 269 | if "A_CONDEXEC" in hex_common.attribdict[tag]: |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 270 | for regtype, regid in regs: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 271 | if hex_common.is_writeonly(regid) and not hex_common.is_hvx_reg( |
| 272 | regtype |
| 273 | ): |
Taylor Simpson | e28b77a | 2023-03-06 18:58:26 -0800 | [diff] [blame] | 274 | gen_helper_arg_opn(f, regtype, regid, i, tag) |
| 275 | i += 1 |
| 276 | |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 277 | ## Arguments to the helper function are the source regs and immediates |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 278 | for regtype, regid in regs: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 279 | if hex_common.is_read(regid): |
| 280 | if hex_common.is_hvx_reg(regtype) and hex_common.is_readwrite(regid): |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 281 | continue |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 282 | gen_helper_arg_opn(f, regtype, regid, i, tag) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 283 | i += 1 |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 284 | for immlett, bits, immshift in imms: |
| 285 | gen_helper_arg_imm(f, immlett) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 286 | i += 1 |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 287 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 288 | if hex_common.need_pkt_has_multi_cof(tag): |
Taylor Simpson | fb67c2b | 2022-11-08 08:28:59 -0800 | [diff] [blame] | 289 | f.write(", uint32_t pkt_has_multi_cof") |
Taylor Simpson | d54c561 | 2023-04-27 16:00:02 -0700 | [diff] [blame] | 290 | if (hex_common.need_pkt_need_commit(tag)): |
| 291 | f.write(", uint32_t pkt_need_commit") |
Taylor Simpson | fb67c2b | 2022-11-08 08:28:59 -0800 | [diff] [blame] | 292 | |
Taylor Simpson | 4008590 | 2022-11-08 08:29:00 -0800 | [diff] [blame] | 293 | if hex_common.need_PC(tag): |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 294 | if i > 0: |
| 295 | f.write(", ") |
Taylor Simpson | 4008590 | 2022-11-08 08:29:00 -0800 | [diff] [blame] | 296 | f.write("target_ulong PC") |
| 297 | i += 1 |
Taylor Simpson | 613653e | 2022-11-08 08:29:01 -0800 | [diff] [blame] | 298 | if hex_common.helper_needs_next_PC(tag): |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 299 | if i > 0: |
| 300 | f.write(", ") |
Taylor Simpson | 613653e | 2022-11-08 08:29:01 -0800 | [diff] [blame] | 301 | f.write("target_ulong next_PC") |
| 302 | i += 1 |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 303 | if hex_common.need_slot(tag): |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 304 | if i > 0: |
| 305 | f.write(", ") |
Taylor Simpson | e5d0d78 | 2023-04-27 16:00:11 -0700 | [diff] [blame] | 306 | f.write("uint32_t slotval") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 307 | i += 1 |
| 308 | if hex_common.need_part1(tag): |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 309 | if i > 0: |
| 310 | f.write(", ") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 311 | f.write("uint32_t part1") |
| 312 | f.write(")\n{\n") |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 313 | if hex_common.need_ea(tag): |
| 314 | gen_decl_ea(f) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 315 | ## Declare the return variable |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 316 | i = 0 |
| 317 | if "A_CONDEXEC" not in hex_common.attribdict[tag]: |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 318 | for regtype, regid in regs: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 319 | if hex_common.is_writeonly(regid): |
| 320 | gen_helper_dest_decl_opn(f, regtype, regid, i) |
Taylor Simpson | e28b77a | 2023-03-06 18:58:26 -0800 | [diff] [blame] | 321 | i += 1 |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 322 | |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 323 | for regtype, regid in regs: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 324 | if hex_common.is_read(regid): |
| 325 | if hex_common.is_pair(regid): |
| 326 | if hex_common.is_hvx_reg(regtype): |
| 327 | gen_helper_src_var_ext_pair(f, regtype, regid, i) |
| 328 | elif hex_common.is_single(regid): |
| 329 | if hex_common.is_hvx_reg(regtype): |
| 330 | gen_helper_src_var_ext(f, regtype, regid) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 331 | else: |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 332 | hex_common.bad_register(regtype, regid) |
Taylor Simpson | ccd9eec | 2020-12-09 18:35:22 -0600 | [diff] [blame] | 333 | |
Taylor Simpson | e5d0d78 | 2023-04-27 16:00:11 -0700 | [diff] [blame] | 334 | if hex_common.need_slot(tag): |
| 335 | if "A_LOAD" in hex_common.attribdict[tag]: |
| 336 | f.write(" bool pkt_has_store_s1 = slotval & 0x1;\n") |
| 337 | f.write(" uint32_t slot = slotval >> 1;\n") |
| 338 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 339 | if "A_FPOP" in hex_common.attribdict[tag]: |
| 340 | f.write(" arch_fpop_start(env);\n") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 341 | |
Marco Liebel | cd6c4ed | 2023-03-20 02:25:32 -0700 | [diff] [blame] | 342 | f.write(f" {hex_common.semdict[tag]}\n") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 343 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 344 | if "A_FPOP" in hex_common.attribdict[tag]: |
| 345 | f.write(" arch_fpop_end(env);\n") |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 346 | |
| 347 | ## Save/return the return variable |
Matheus Tavares Bernardino | 3608c24 | 2023-05-24 11:41:47 -0300 | [diff] [blame] | 348 | for regtype, regid in regs: |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 349 | if hex_common.is_written(regid): |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 350 | gen_helper_return_opn(f, regtype, regid, i) |
| 351 | f.write("}\n\n") |
| 352 | ## End of the helper definition |
| 353 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 354 | |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 355 | def main(): |
| 356 | hex_common.read_semantics_file(sys.argv[1]) |
| 357 | hex_common.read_attribs_file(sys.argv[2]) |
| 358 | hex_common.read_overrides_file(sys.argv[3]) |
Taylor Simpson | d51bcab | 2021-05-18 12:01:09 -0500 | [diff] [blame] | 359 | hex_common.read_overrides_file(sys.argv[4]) |
Alessandro Di Federico | e71fdc4 | 2022-09-23 19:38:30 +0200 | [diff] [blame] | 360 | ## Whether or not idef-parser is enabled is |
| 361 | ## determined by the number of arguments to |
| 362 | ## this script: |
| 363 | ## |
| 364 | ## 5 args. -> not enabled, |
| 365 | ## 6 args. -> idef-parser enabled. |
| 366 | ## |
| 367 | ## The 6:th arg. then holds a list of the successfully |
| 368 | ## parsed instructions. |
| 369 | is_idef_parser_enabled = len(sys.argv) > 6 |
| 370 | if is_idef_parser_enabled: |
| 371 | hex_common.read_idef_parser_enabled_file(sys.argv[5]) |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 372 | hex_common.calculate_attribs() |
| 373 | tagregs = hex_common.get_tagregs() |
| 374 | tagimms = hex_common.get_tagimms() |
| 375 | |
Alessandro Di Federico | e71fdc4 | 2022-09-23 19:38:30 +0200 | [diff] [blame] | 376 | output_file = sys.argv[-1] |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 377 | with open(output_file, "w") as f: |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 378 | for tag in hex_common.tags: |
| 379 | ## Skip the priv instructions |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 380 | if "A_PRIV" in hex_common.attribdict[tag]: |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 381 | continue |
| 382 | ## Skip the guest instructions |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 383 | if "A_GUEST" in hex_common.attribdict[tag]: |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 384 | continue |
| 385 | ## Skip the diag instructions |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 386 | if tag == "Y6_diag": |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 387 | continue |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 388 | if tag == "Y6_diag0": |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 389 | continue |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 390 | if tag == "Y6_diag1": |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 391 | continue |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 392 | if hex_common.skip_qemu_helper(tag): |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 393 | continue |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 394 | if hex_common.is_idef_parser_enabled(tag): |
Alessandro Di Federico | e71fdc4 | 2022-09-23 19:38:30 +0200 | [diff] [blame] | 395 | continue |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 396 | |
| 397 | gen_helper_function(f, tag, tagregs, tagimms) |
| 398 | |
Marco Liebel | 5bb322e | 2023-03-20 02:25:33 -0700 | [diff] [blame] | 399 | |
Taylor Simpson | 793958c | 2021-02-07 23:46:10 -0600 | [diff] [blame] | 400 | if __name__ == "__main__": |
| 401 | main() |