| 1 |
# Copyright © 2024 Imagination Technologies Ltd. |
| 2 |
# SPDX-License-Identifier: MIT |
| 3 |
|
| 4 |
from mako.template import Template, exceptions |
| 5 |
from pco_ops import * |
| 6 |
|
| 7 |
template = """/* |
| 8 |
* Copyright © 2024 Imagination Technologies Ltd. |
| 9 |
* |
| 10 |
* SPDX-License-Identifier: MIT |
| 11 |
*/ |
| 12 |
|
| 13 |
#ifndef PCO_BUILDER_OPS_H |
| 14 |
#define PCO_BUILDER_OPS_H |
| 15 |
|
| 16 |
/** |
| 17 |
* \\file pco_builder_ops.h |
| 18 |
* |
| 19 |
* \\brief PCO op building functions. |
| 20 |
*/ |
| 21 |
|
| 22 |
#include "pco_internal.h" |
| 23 |
#include "pco_common.h" |
| 24 |
#include "pco_ops.h" |
| 25 |
#include "util/macros.h" |
| 26 |
|
| 27 |
#include <assert.h> |
| 28 |
#include <stdbool.h> |
| 29 |
|
| 30 |
/** Ref mod info. */ |
| 31 |
static inline |
| 32 |
bool pco_instr_dest_has_mod(const pco_instr *instr, unsigned dest, enum pco_ref_mod mod) |
| 33 |
{ |
| 34 |
const struct pco_op_info *info = &pco_op_info[instr->op]; |
| 35 |
if (info->num_dests == ~0) |
| 36 |
return false; |
| 37 |
|
| 38 |
assert(dest < info->num_dests); |
| 39 |
assert(mod < _PCO_REF_MOD_COUNT); |
| 40 |
return (info->dest_mods[dest] & (1ULL << mod)) != 0; |
| 41 |
} |
| 42 |
|
| 43 |
static inline |
| 44 |
bool pco_instr_src_has_mod(const pco_instr *instr, unsigned src, enum pco_ref_mod mod) |
| 45 |
{ |
| 46 |
const struct pco_op_info *info = &pco_op_info[instr->op]; |
| 47 |
if (info->num_srcs == ~0) |
| 48 |
return false; |
| 49 |
|
| 50 |
assert(src < info->num_srcs); |
| 51 |
assert(mod < _PCO_REF_MOD_COUNT); |
| 52 |
return (info->src_mods[src] & (1ULL << mod)) != 0; |
| 53 |
} |
| 54 |
|
| 55 |
% for ref_mod in ref_mods.values(): |
| 56 |
static inline |
| 57 |
bool pco_instr_dest_has_${ref_mod.t.tname}(const pco_instr *instr, unsigned dest) |
| 58 |
{ |
| 59 |
return pco_instr_dest_has_mod(instr, dest, ${ref_mod.cname}); |
| 60 |
} |
| 61 |
|
| 62 |
static inline |
| 63 |
bool pco_instr_src_has_${ref_mod.t.tname}(const pco_instr *instr, unsigned src) |
| 64 |
{ |
| 65 |
return pco_instr_src_has_mod(instr, src, ${ref_mod.cname}); |
| 66 |
} |
| 67 |
|
| 68 |
% endfor |
| 69 |
/** Op mod getting/setting. */ |
| 70 |
static inline |
| 71 |
bool pco_instr_has_mod(const pco_instr *instr, enum pco_op_mod mod) |
| 72 |
{ |
| 73 |
assert(mod < _PCO_OP_MOD_COUNT); |
| 74 |
return (pco_op_info[instr->op].mods & (1ULL << mod)) != 0; |
| 75 |
} |
| 76 |
|
| 77 |
static inline |
| 78 |
void pco_instr_set_mod(pco_instr *instr, enum pco_op_mod mod, uint32_t val) |
| 79 |
{ |
| 80 |
assert(mod < _PCO_OP_MOD_COUNT); |
| 81 |
unsigned mod_index = pco_op_info[instr->op].mod_map[mod]; |
| 82 |
assert(mod_index > 0); |
| 83 |
instr->mod[mod_index - 1] = val; |
| 84 |
} |
| 85 |
|
| 86 |
static inline |
| 87 |
uint32_t pco_instr_get_mod(const pco_instr *instr, enum pco_op_mod mod) |
| 88 |
{ |
| 89 |
assert(mod < _PCO_OP_MOD_COUNT); |
| 90 |
unsigned mod_index = pco_op_info[instr->op].mod_map[mod]; |
| 91 |
assert(mod_index > 0); |
| 92 |
return instr->mod[mod_index - 1]; |
| 93 |
} |
| 94 |
|
| 95 |
static inline |
| 96 |
bool pco_instr_mod_is_set(const pco_instr *instr, enum pco_op_mod mod) |
| 97 |
{ |
| 98 |
const struct pco_op_mod_info *info = &pco_op_mod_info[mod]; |
| 99 |
return pco_instr_get_mod(instr, mod) != (info->nzdefault ? info->nzdefault : 0); |
| 100 |
} |
| 101 |
|
| 102 |
% for op_mod in op_mods.values(): |
| 103 |
static inline |
| 104 |
bool pco_instr_has_${op_mod.t.tname}(const pco_instr *instr) |
| 105 |
{ |
| 106 |
return pco_instr_has_mod(instr, ${op_mod.cname}); |
| 107 |
} |
| 108 |
|
| 109 |
static inline |
| 110 |
void pco_instr_set_${op_mod.t.tname}(pco_instr *instr, ${op_mod.t.name} val) |
| 111 |
{ |
| 112 |
return pco_instr_set_mod(instr, ${op_mod.cname}, val); |
| 113 |
} |
| 114 |
|
| 115 |
static inline |
| 116 |
${op_mod.t.name} pco_instr_get_${op_mod.t.tname}(const pco_instr *instr) |
| 117 |
{ |
| 118 |
return pco_instr_get_mod(instr, ${op_mod.cname}); |
| 119 |
} |
| 120 |
|
| 121 |
% endfor |
| 122 |
% for op in ops.values(): |
| 123 |
% if bool(op.op_mods): |
| 124 |
struct ${op.bname}_mods { |
| 125 |
% for op_mod in op.op_mods: |
| 126 |
${op_mod.t.name} ${op_mod.t.tname}; |
| 127 |
% endfor |
| 128 |
}; |
| 129 |
|
| 130 |
% endif |
| 131 |
#define ${op.bname}_(${op.builder_params[2]}${op.builder_params[4]}) _${op.bname}_(${op.builder_params[2]}${op.builder_params[5]}) |
| 132 |
static |
| 133 |
pco_instr *_${op.bname}_(${op.builder_params[0]}) |
| 134 |
{ |
| 135 |
pco_instr *instr = pco_instr_create(func, |
| 136 |
${'num_dests' if op.num_dests == VARIABLE else op.num_dests}, |
| 137 |
${'num_srcs' if op.num_srcs == VARIABLE else op.num_srcs}); |
| 138 |
|
| 139 |
instr->op = ${op.cname.upper()}; |
| 140 |
|
| 141 |
% if op.has_target_cf_node: |
| 142 |
instr->target_cf_node = target_cf_node; |
| 143 |
% endif |
| 144 |
% if op.num_dests == VARIABLE: |
| 145 |
for (unsigned d = 0; d < num_dests; ++d) |
| 146 |
instr->dest[d] = dest[d]; |
| 147 |
% else: |
| 148 |
% for d in range(op.num_dests): |
| 149 |
instr->dest[${d}] = dest${d}; |
| 150 |
% endfor |
| 151 |
% endif |
| 152 |
% if op.num_srcs == VARIABLE: |
| 153 |
for (unsigned s = 0; s < num_srcs; ++s) |
| 154 |
instr->src[s] = src[s]; |
| 155 |
% else: |
| 156 |
% for s in range(op.num_srcs): |
| 157 |
instr->src[${s}] = src${s}; |
| 158 |
% endfor |
| 159 |
% endif |
| 160 |
|
| 161 |
% for op_mod in op.op_mods: |
| 162 |
% if op_mod.t.nzdefault is None: |
| 163 |
pco_instr_set_${op_mod.t.tname}(instr, mods.${op_mod.t.tname}); |
| 164 |
% else: |
| 165 |
pco_instr_set_${op_mod.t.tname}(instr, !mods.${op_mod.t.tname} ? ${op_mod.t.nzdefault} : mods.${op_mod.t.tname}); |
| 166 |
% endif |
| 167 |
% endfor |
| 168 |
|
| 169 |
return instr; |
| 170 |
} |
| 171 |
|
| 172 |
% if op.op_type != 'hw_direct': |
| 173 |
#define ${op.bname}(${op.builder_params[3]}${op.builder_params[4]}) _${op.bname}(${op.builder_params[3]}${op.builder_params[5]}) |
| 174 |
static inline |
| 175 |
pco_instr *_${op.bname}(${op.builder_params[1]}) |
| 176 |
{ |
| 177 |
pco_func *func = pco_cursor_func(b->cursor); |
| 178 |
pco_instr *instr = _${op.bname}_(${op.builder_params[2]}${op.builder_params[6]}); |
| 179 |
pco_builder_insert_instr(b, instr); |
| 180 |
return instr; |
| 181 |
} |
| 182 |
|
| 183 |
% endif |
| 184 |
% endfor |
| 185 |
#endif /* PCO_BUILDER_OPS_H */""" |
| 186 |
|
| 187 |
def main(): |
| 188 |
try: |
| 189 |
print(Template(template).render(ops=ops, op_mods=op_mods, ref_mods=ref_mods, VARIABLE=VARIABLE)) |
| 190 |
except: |
| 191 |
raise Exception(exceptions.text_error_template().render()) |
| 192 |
|
| 193 |
if __name__ == '__main__': |
| 194 |
main() |