Debian Codegraph @

src/imagination/pco/pco_builder_ops.h.py

raw
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()