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