libFirm
gen_TEMPLATE_new_nodes.c
1 #include "gen_TEMPLATE_new_nodes.h"
2 
3 #include "benode.h"
4 #include "TEMPLATE_bearch_t.h"
5 #include "gen_TEMPLATE_regalloc_if.h"
6 #include "TEMPLATE_new_nodes_t.h"
7 #include "fourcc.h"
8 #include "irgopt.h"
9 #include "ircons_t.h"
10 
11 ir_op *op_TEMPLATE_Add = NULL;
12 ir_op *op_TEMPLATE_And = NULL;
13 ir_op *op_TEMPLATE_Const = NULL;
14 ir_op *op_TEMPLATE_Jmp = NULL;
15 ir_op *op_TEMPLATE_Load = NULL;
16 ir_op *op_TEMPLATE_Minus = NULL;
17 ir_op *op_TEMPLATE_Mul = NULL;
18 ir_op *op_TEMPLATE_Not = NULL;
19 ir_op *op_TEMPLATE_Or = NULL;
20 ir_op *op_TEMPLATE_Return = NULL;
21 ir_op *op_TEMPLATE_Shl = NULL;
22 ir_op *op_TEMPLATE_Shr = NULL;
23 ir_op *op_TEMPLATE_Store = NULL;
24 ir_op *op_TEMPLATE_Sub = NULL;
25 ir_op *op_TEMPLATE_Xor = NULL;
26 ir_op *op_TEMPLATE_fAdd = NULL;
27 ir_op *op_TEMPLATE_fConst = NULL;
28 ir_op *op_TEMPLATE_fDiv = NULL;
29 ir_op *op_TEMPLATE_fLoad = NULL;
30 ir_op *op_TEMPLATE_fMinus = NULL;
31 ir_op *op_TEMPLATE_fMul = NULL;
32 ir_op *op_TEMPLATE_fStore = NULL;
33 ir_op *op_TEMPLATE_fSub = NULL;
34 
35 
36 static int TEMPLATE_opcode_start = -1;
37 
39 #define TEMPLATE_op_tag FOURCC('T', 'E', 'M', 'P')
40 
42 int is_TEMPLATE_op(const ir_op *op)
43 {
44  return get_op_tag(op) == TEMPLATE_op_tag;
45 }
46 
48 int is_TEMPLATE_irn(const ir_node *node)
49 {
50  return is_TEMPLATE_op(get_irn_op(node));
51 }
52 
53 int get_TEMPLATE_irn_opcode(const ir_node *node)
54 {
55  assert(is_TEMPLATE_irn(node));
56  return get_irn_opcode(node) - TEMPLATE_opcode_start;
57 }
58 
59 #undef BIT
60 #define BIT(x) (1 << (x))
61 
62 
63 
64 
65 ir_node *new_bd_TEMPLATE_Add(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1)
66 {
67  static arch_register_req_t const *in_reqs[] = {
68  &TEMPLATE_class_reg_req_gp,
69  &TEMPLATE_class_reg_req_gp,
70  };
71 
72  /* construct in array */
73  ir_node *const in[] = {
74  op0,
75  op1,
76  };
77 
78  ir_graph *const irg = get_irn_irg(block);
79  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Add, mode_Iu, 2, in);
80 
81  /* flags */
82  arch_irn_flags_t irn_flags = arch_irn_flags_none;
83  irn_flags |= arch_irn_flag_rematerializable;
84 
85  /* init node attributes */
86  int const n_res = 1;
87  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
88  (void)attr; /* avoid potential warning */
89  be_info_init_irn(res, irn_flags, in_reqs, n_res);
90  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
91  out_infos[0].req = &TEMPLATE_class_reg_req_gp;
92 
93  verify_new_node(res);
94  return optimize_node(res);
95 }
96 
97 ir_node *new_bd_TEMPLATE_And(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1)
98 {
99  static arch_register_req_t const *in_reqs[] = {
100  &TEMPLATE_class_reg_req_gp,
101  &TEMPLATE_class_reg_req_gp,
102  };
103 
104  /* construct in array */
105  ir_node *const in[] = {
106  op0,
107  op1,
108  };
109 
110  ir_graph *const irg = get_irn_irg(block);
111  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_And, mode_Iu, 2, in);
112 
113  /* flags */
114  arch_irn_flags_t irn_flags = arch_irn_flags_none;
115  irn_flags |= arch_irn_flag_rematerializable;
116 
117  /* init node attributes */
118  int const n_res = 1;
119  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
120  (void)attr; /* avoid potential warning */
121  be_info_init_irn(res, irn_flags, in_reqs, n_res);
122  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
123  out_infos[0].req = &TEMPLATE_class_reg_req_gp;
124 
125  verify_new_node(res);
126  return optimize_node(res);
127 }
128 
129 ir_node *new_bd_TEMPLATE_Const(dbg_info *dbgi, ir_node *block, ir_entity *entity, ir_tarval *value)
130 {
131  arch_register_req_t const **const in_reqs = NULL;
132 
133 
134  ir_graph *const irg = get_irn_irg(block);
135  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Const, mode_Iu, 0, NULL);
136 
137  /* flags */
138  arch_irn_flags_t irn_flags = arch_irn_flags_none;
139  irn_flags |= arch_irn_flag_rematerializable;
140 
141  /* init node attributes */
142  int const n_res = 1;
143  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
144  (void)attr; /* avoid potential warning */
145  be_info_init_irn(res, irn_flags, in_reqs, n_res);
146  set_TEMPLATE_value(res, entity, value);
147  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
148  out_infos[0].req = &TEMPLATE_class_reg_req_gp;
149 
150  verify_new_node(res);
151  return optimize_node(res);
152 }
153 
154 ir_node *new_bd_TEMPLATE_Jmp(dbg_info *dbgi, ir_node *block)
155 {
156  arch_register_req_t const **const in_reqs = NULL;
157 
158 
159  ir_graph *const irg = get_irn_irg(block);
160  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Jmp, mode_X, 0, NULL);
161 
162  /* flags */
163  arch_irn_flags_t irn_flags = arch_irn_flags_none;
164  irn_flags |= arch_irn_flag_simple_jump;
165 
166  /* init node attributes */
167  int const n_res = 1;
168  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
169  (void)attr; /* avoid potential warning */
170  be_info_init_irn(res, irn_flags, in_reqs, n_res);
171  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
172  out_infos[0].req = &arch_exec_requirement;
173 
174  verify_new_node(res);
175  return optimize_node(res);
176 }
177 
178 ir_node *new_bd_TEMPLATE_Load(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *ptr)
179 {
180  static arch_register_req_t const *in_reqs[] = {
181  &arch_memory_requirement,
182  &TEMPLATE_class_reg_req_gp,
183  };
184 
185  /* construct in array */
186  ir_node *const in[] = {
187  mem,
188  ptr,
189  };
190 
191  ir_graph *const irg = get_irn_irg(block);
192  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Load, mode_T, 2, in);
193 
194  /* flags */
195  arch_irn_flags_t irn_flags = arch_irn_flags_none;
196  irn_flags |= arch_irn_flag_rematerializable;
197 
198  /* init node attributes */
199  int const n_res = 2;
200  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
201  (void)attr; /* avoid potential warning */
202  be_info_init_irn(res, irn_flags, in_reqs, n_res);
203  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
204  out_infos[0].req = &TEMPLATE_class_reg_req_gp;
205  out_infos[1].req = &arch_memory_requirement;
206 
207  verify_new_node(res);
208  return optimize_node(res);
209 }
210 
211 ir_node *new_bd_TEMPLATE_Minus(dbg_info *dbgi, ir_node *block, ir_node *op0)
212 {
213  static arch_register_req_t const *in_reqs[] = {
214  &TEMPLATE_class_reg_req_gp,
215  };
216 
217  /* construct in array */
218  ir_node *const in[] = {
219  op0,
220  };
221 
222  ir_graph *const irg = get_irn_irg(block);
223  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Minus, mode_Iu, 1, in);
224 
225  /* flags */
226  arch_irn_flags_t irn_flags = arch_irn_flags_none;
227  irn_flags |= arch_irn_flag_rematerializable;
228 
229  /* init node attributes */
230  int const n_res = 1;
231  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
232  (void)attr; /* avoid potential warning */
233  be_info_init_irn(res, irn_flags, in_reqs, n_res);
234  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
235  out_infos[0].req = &TEMPLATE_class_reg_req_gp;
236 
237  verify_new_node(res);
238  return optimize_node(res);
239 }
240 
241 ir_node *new_bd_TEMPLATE_Mul(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1)
242 {
243  static arch_register_req_t const *in_reqs[] = {
244  &TEMPLATE_class_reg_req_gp,
245  &TEMPLATE_class_reg_req_gp,
246  };
247 
248  /* construct in array */
249  ir_node *const in[] = {
250  op0,
251  op1,
252  };
253 
254  ir_graph *const irg = get_irn_irg(block);
255  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Mul, mode_Iu, 2, in);
256 
257  /* flags */
258  arch_irn_flags_t irn_flags = arch_irn_flags_none;
259  irn_flags |= arch_irn_flag_rematerializable;
260 
261  /* init node attributes */
262  int const n_res = 1;
263  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
264  (void)attr; /* avoid potential warning */
265  be_info_init_irn(res, irn_flags, in_reqs, n_res);
266  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
267  out_infos[0].req = &TEMPLATE_class_reg_req_gp;
268 
269  verify_new_node(res);
270  return optimize_node(res);
271 }
272 
273 ir_node *new_bd_TEMPLATE_Not(dbg_info *dbgi, ir_node *block, ir_node *op0)
274 {
275  static arch_register_req_t const *in_reqs[] = {
276  &TEMPLATE_class_reg_req_gp,
277  };
278 
279  /* construct in array */
280  ir_node *const in[] = {
281  op0,
282  };
283 
284  ir_graph *const irg = get_irn_irg(block);
285  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Not, mode_Iu, 1, in);
286 
287  /* flags */
288  arch_irn_flags_t irn_flags = arch_irn_flags_none;
289  irn_flags |= arch_irn_flag_rematerializable;
290 
291  /* init node attributes */
292  int const n_res = 1;
293  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
294  (void)attr; /* avoid potential warning */
295  be_info_init_irn(res, irn_flags, in_reqs, n_res);
296  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
297  out_infos[0].req = &TEMPLATE_class_reg_req_gp;
298 
299  verify_new_node(res);
300  return optimize_node(res);
301 }
302 
303 ir_node *new_bd_TEMPLATE_Or(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1)
304 {
305  static arch_register_req_t const *in_reqs[] = {
306  &TEMPLATE_class_reg_req_gp,
307  &TEMPLATE_class_reg_req_gp,
308  };
309 
310  /* construct in array */
311  ir_node *const in[] = {
312  op0,
313  op1,
314  };
315 
316  ir_graph *const irg = get_irn_irg(block);
317  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Or, mode_Iu, 2, in);
318 
319  /* flags */
320  arch_irn_flags_t irn_flags = arch_irn_flags_none;
321  irn_flags |= arch_irn_flag_rematerializable;
322 
323  /* init node attributes */
324  int const n_res = 1;
325  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
326  (void)attr; /* avoid potential warning */
327  be_info_init_irn(res, irn_flags, in_reqs, n_res);
328  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
329  out_infos[0].req = &TEMPLATE_class_reg_req_gp;
330 
331  verify_new_node(res);
332  return optimize_node(res);
333 }
334 
335 ir_node *new_bd_TEMPLATE_Return(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs)
336 {
337 
338 
339  ir_graph *const irg = get_irn_irg(block);
340  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Return, mode_X, arity, in);
341 
342  /* flags */
343  arch_irn_flags_t irn_flags = arch_irn_flags_none;
344 
345  /* init node attributes */
346  int const n_res = 1;
347  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
348  (void)attr; /* avoid potential warning */
349  be_info_init_irn(res, irn_flags, in_reqs, n_res);
350  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
351  out_infos[0].req = &arch_exec_requirement;
352 
353  verify_new_node(res);
354  return optimize_node(res);
355 }
356 
357 ir_node *new_bd_TEMPLATE_Shl(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1)
358 {
359  static arch_register_req_t const *in_reqs[] = {
360  &TEMPLATE_class_reg_req_gp,
361  &TEMPLATE_class_reg_req_gp,
362  };
363 
364  /* construct in array */
365  ir_node *const in[] = {
366  op0,
367  op1,
368  };
369 
370  ir_graph *const irg = get_irn_irg(block);
371  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Shl, mode_Iu, 2, in);
372 
373  /* flags */
374  arch_irn_flags_t irn_flags = arch_irn_flags_none;
375  irn_flags |= arch_irn_flag_rematerializable;
376 
377  /* init node attributes */
378  int const n_res = 1;
379  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
380  (void)attr; /* avoid potential warning */
381  be_info_init_irn(res, irn_flags, in_reqs, n_res);
382  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
383  out_infos[0].req = &TEMPLATE_class_reg_req_gp;
384 
385  verify_new_node(res);
386  return optimize_node(res);
387 }
388 
389 ir_node *new_bd_TEMPLATE_Shr(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1)
390 {
391  static arch_register_req_t const *in_reqs[] = {
392  &TEMPLATE_class_reg_req_gp,
393  &TEMPLATE_class_reg_req_gp,
394  };
395 
396  /* construct in array */
397  ir_node *const in[] = {
398  op0,
399  op1,
400  };
401 
402  ir_graph *const irg = get_irn_irg(block);
403  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Shr, mode_Iu, 2, in);
404 
405  /* flags */
406  arch_irn_flags_t irn_flags = arch_irn_flags_none;
407  irn_flags |= arch_irn_flag_rematerializable;
408 
409  /* init node attributes */
410  int const n_res = 1;
411  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
412  (void)attr; /* avoid potential warning */
413  be_info_init_irn(res, irn_flags, in_reqs, n_res);
414  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
415  out_infos[0].req = &TEMPLATE_class_reg_req_gp;
416 
417  verify_new_node(res);
418  return optimize_node(res);
419 }
420 
421 ir_node *new_bd_TEMPLATE_Store(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *ptr, ir_node *val)
422 {
423  static arch_register_req_t const *in_reqs[] = {
424  &arch_memory_requirement,
425  &TEMPLATE_class_reg_req_gp,
426  &TEMPLATE_class_reg_req_gp,
427  };
428 
429  /* construct in array */
430  ir_node *const in[] = {
431  mem,
432  ptr,
433  val,
434  };
435 
436  ir_graph *const irg = get_irn_irg(block);
437  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Store, mode_M, 3, in);
438 
439  /* flags */
440  arch_irn_flags_t irn_flags = arch_irn_flags_none;
441  irn_flags |= arch_irn_flag_rematerializable;
442 
443  /* init node attributes */
444  int const n_res = 1;
445  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
446  (void)attr; /* avoid potential warning */
447  be_info_init_irn(res, irn_flags, in_reqs, n_res);
448  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
449  out_infos[0].req = &arch_memory_requirement;
450 
451  verify_new_node(res);
452  return optimize_node(res);
453 }
454 
455 ir_node *new_bd_TEMPLATE_Sub(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1)
456 {
457  static arch_register_req_t const *in_reqs[] = {
458  &TEMPLATE_class_reg_req_gp,
459  &TEMPLATE_class_reg_req_gp,
460  };
461 
462  /* construct in array */
463  ir_node *const in[] = {
464  op0,
465  op1,
466  };
467 
468  ir_graph *const irg = get_irn_irg(block);
469  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Sub, mode_Iu, 2, in);
470 
471  /* flags */
472  arch_irn_flags_t irn_flags = arch_irn_flags_none;
473  irn_flags |= arch_irn_flag_rematerializable;
474 
475  /* init node attributes */
476  int const n_res = 1;
477  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
478  (void)attr; /* avoid potential warning */
479  be_info_init_irn(res, irn_flags, in_reqs, n_res);
480  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
481  out_infos[0].req = &TEMPLATE_class_reg_req_gp;
482 
483  verify_new_node(res);
484  return optimize_node(res);
485 }
486 
487 ir_node *new_bd_TEMPLATE_Xor(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1)
488 {
489  static arch_register_req_t const *in_reqs[] = {
490  &TEMPLATE_class_reg_req_gp,
491  &TEMPLATE_class_reg_req_gp,
492  };
493 
494  /* construct in array */
495  ir_node *const in[] = {
496  op0,
497  op1,
498  };
499 
500  ir_graph *const irg = get_irn_irg(block);
501  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_Xor, mode_Iu, 2, in);
502 
503  /* flags */
504  arch_irn_flags_t irn_flags = arch_irn_flags_none;
505  irn_flags |= arch_irn_flag_rematerializable;
506 
507  /* init node attributes */
508  int const n_res = 1;
509  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
510  (void)attr; /* avoid potential warning */
511  be_info_init_irn(res, irn_flags, in_reqs, n_res);
512  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
513  out_infos[0].req = &TEMPLATE_class_reg_req_gp;
514 
515  verify_new_node(res);
516  return optimize_node(res);
517 }
518 
519 ir_node *new_bd_TEMPLATE_fAdd(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1)
520 {
521  static arch_register_req_t const *in_reqs[] = {
522  &TEMPLATE_class_reg_req_fp,
523  &TEMPLATE_class_reg_req_fp,
524  };
525 
526  /* construct in array */
527  ir_node *const in[] = {
528  op0,
529  op1,
530  };
531 
532  ir_graph *const irg = get_irn_irg(block);
533  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_fAdd, mode_F, 2, in);
534 
535  /* flags */
536  arch_irn_flags_t irn_flags = arch_irn_flags_none;
537  irn_flags |= arch_irn_flag_rematerializable;
538 
539  /* init node attributes */
540  int const n_res = 1;
541  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
542  (void)attr; /* avoid potential warning */
543  be_info_init_irn(res, irn_flags, in_reqs, n_res);
544  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
545  out_infos[0].req = &TEMPLATE_class_reg_req_fp;
546 
547  verify_new_node(res);
548  return optimize_node(res);
549 }
550 
551 ir_node *new_bd_TEMPLATE_fConst(dbg_info *dbgi, ir_node *block)
552 {
553  arch_register_req_t const **const in_reqs = NULL;
554 
555 
556  ir_graph *const irg = get_irn_irg(block);
557  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_fConst, mode_F, 0, NULL);
558 
559  /* flags */
560  arch_irn_flags_t irn_flags = arch_irn_flags_none;
561  irn_flags |= arch_irn_flag_rematerializable;
562 
563  /* init node attributes */
564  int const n_res = 1;
565  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
566  (void)attr; /* avoid potential warning */
567  be_info_init_irn(res, irn_flags, in_reqs, n_res);
568  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
569  out_infos[0].req = &TEMPLATE_class_reg_req_fp;
570 
571  verify_new_node(res);
572  return optimize_node(res);
573 }
574 
575 ir_node *new_bd_TEMPLATE_fDiv(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1)
576 {
577  static arch_register_req_t const *in_reqs[] = {
578  &TEMPLATE_class_reg_req_fp,
579  &TEMPLATE_class_reg_req_fp,
580  };
581 
582  /* construct in array */
583  ir_node *const in[] = {
584  op0,
585  op1,
586  };
587 
588  ir_graph *const irg = get_irn_irg(block);
589  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_fDiv, mode_F, 2, in);
590 
591  /* flags */
592  arch_irn_flags_t irn_flags = arch_irn_flags_none;
593 
594  /* init node attributes */
595  int const n_res = 1;
596  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
597  (void)attr; /* avoid potential warning */
598  be_info_init_irn(res, irn_flags, in_reqs, n_res);
599  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
600  out_infos[0].req = &TEMPLATE_class_reg_req_fp;
601 
602  verify_new_node(res);
603  return optimize_node(res);
604 }
605 
606 ir_node *new_bd_TEMPLATE_fLoad(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *ptr)
607 {
608  static arch_register_req_t const *in_reqs[] = {
609  &arch_memory_requirement,
610  &TEMPLATE_class_reg_req_gp,
611  };
612 
613  /* construct in array */
614  ir_node *const in[] = {
615  mem,
616  ptr,
617  };
618 
619  ir_graph *const irg = get_irn_irg(block);
620  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_fLoad, mode_T, 2, in);
621 
622  /* flags */
623  arch_irn_flags_t irn_flags = arch_irn_flags_none;
624  irn_flags |= arch_irn_flag_rematerializable;
625 
626  /* init node attributes */
627  int const n_res = 2;
628  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
629  (void)attr; /* avoid potential warning */
630  be_info_init_irn(res, irn_flags, in_reqs, n_res);
631  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
632  out_infos[0].req = &TEMPLATE_class_reg_req_fp;
633  out_infos[1].req = &arch_memory_requirement;
634 
635  verify_new_node(res);
636  return optimize_node(res);
637 }
638 
639 ir_node *new_bd_TEMPLATE_fMinus(dbg_info *dbgi, ir_node *block, ir_node *op0)
640 {
641  static arch_register_req_t const *in_reqs[] = {
642  &TEMPLATE_class_reg_req_fp,
643  };
644 
645  /* construct in array */
646  ir_node *const in[] = {
647  op0,
648  };
649 
650  ir_graph *const irg = get_irn_irg(block);
651  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_fMinus, mode_F, 1, in);
652 
653  /* flags */
654  arch_irn_flags_t irn_flags = arch_irn_flags_none;
655  irn_flags |= arch_irn_flag_rematerializable;
656 
657  /* init node attributes */
658  int const n_res = 1;
659  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
660  (void)attr; /* avoid potential warning */
661  be_info_init_irn(res, irn_flags, in_reqs, n_res);
662  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
663  out_infos[0].req = &TEMPLATE_class_reg_req_fp;
664 
665  verify_new_node(res);
666  return optimize_node(res);
667 }
668 
669 ir_node *new_bd_TEMPLATE_fMul(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1)
670 {
671  static arch_register_req_t const *in_reqs[] = {
672  &TEMPLATE_class_reg_req_fp,
673  &TEMPLATE_class_reg_req_fp,
674  };
675 
676  /* construct in array */
677  ir_node *const in[] = {
678  op0,
679  op1,
680  };
681 
682  ir_graph *const irg = get_irn_irg(block);
683  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_fMul, mode_F, 2, in);
684 
685  /* flags */
686  arch_irn_flags_t irn_flags = arch_irn_flags_none;
687 
688  /* init node attributes */
689  int const n_res = 1;
690  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
691  (void)attr; /* avoid potential warning */
692  be_info_init_irn(res, irn_flags, in_reqs, n_res);
693  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
694  out_infos[0].req = &TEMPLATE_class_reg_req_fp;
695 
696  verify_new_node(res);
697  return optimize_node(res);
698 }
699 
700 ir_node *new_bd_TEMPLATE_fStore(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *ptr, ir_node *val)
701 {
702  static arch_register_req_t const *in_reqs[] = {
703  &arch_memory_requirement,
704  &TEMPLATE_class_reg_req_gp,
705  &TEMPLATE_class_reg_req_fp,
706  };
707 
708  /* construct in array */
709  ir_node *const in[] = {
710  mem,
711  ptr,
712  val,
713  };
714 
715  ir_graph *const irg = get_irn_irg(block);
716  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_fStore, mode_M, 3, in);
717 
718  /* flags */
719  arch_irn_flags_t irn_flags = arch_irn_flags_none;
720  irn_flags |= arch_irn_flag_rematerializable;
721 
722  /* init node attributes */
723  int const n_res = 1;
724  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
725  (void)attr; /* avoid potential warning */
726  be_info_init_irn(res, irn_flags, in_reqs, n_res);
727  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
728  out_infos[0].req = &arch_memory_requirement;
729 
730  verify_new_node(res);
731  return optimize_node(res);
732 }
733 
734 ir_node *new_bd_TEMPLATE_fSub(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1)
735 {
736  static arch_register_req_t const *in_reqs[] = {
737  &TEMPLATE_class_reg_req_fp,
738  &TEMPLATE_class_reg_req_fp,
739  };
740 
741  /* construct in array */
742  ir_node *const in[] = {
743  op0,
744  op1,
745  };
746 
747  ir_graph *const irg = get_irn_irg(block);
748  ir_node *const res = new_ir_node(dbgi, irg, block, op_TEMPLATE_fSub, mode_F, 2, in);
749 
750  /* flags */
751  arch_irn_flags_t irn_flags = arch_irn_flags_none;
752  irn_flags |= arch_irn_flag_rematerializable;
753 
754  /* init node attributes */
755  int const n_res = 1;
756  TEMPLATE_attr_t *const attr = (TEMPLATE_attr_t*)get_irn_generic_attr(res);
757  (void)attr; /* avoid potential warning */
758  be_info_init_irn(res, irn_flags, in_reqs, n_res);
759  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
760  out_infos[0].req = &TEMPLATE_class_reg_req_fp;
761 
762  verify_new_node(res);
763  return optimize_node(res);
764 }
765 
766 
771 void TEMPLATE_create_opcodes(void)
772 {
773  ir_op *op;
774  int cur_opcode = get_next_ir_opcodes(iro_TEMPLATE_last);
775 
776  TEMPLATE_opcode_start = cur_opcode;
777  op = new_ir_op(cur_opcode + iro_TEMPLATE_Add, "TEMPLATE_Add", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
778  set_op_dump(op, TEMPLATE_dump_node);
779  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
780  set_op_copy_attr(op, be_copy_attr);
781  set_op_tag(op, TEMPLATE_op_tag);
782  op_TEMPLATE_Add = op;
783  op = new_ir_op(cur_opcode + iro_TEMPLATE_And, "TEMPLATE_And", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
784  set_op_dump(op, TEMPLATE_dump_node);
785  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
786  set_op_copy_attr(op, be_copy_attr);
787  set_op_tag(op, TEMPLATE_op_tag);
788  op_TEMPLATE_And = op;
789  op = new_ir_op(cur_opcode + iro_TEMPLATE_Const, "TEMPLATE_Const", op_pin_state_floats, irop_flag_constlike, oparity_any, -1, sizeof(TEMPLATE_attr_t));
790  set_op_dump(op, TEMPLATE_dump_node);
791  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
792  set_op_copy_attr(op, be_copy_attr);
793  set_op_tag(op, TEMPLATE_op_tag);
794  op_TEMPLATE_Const = op;
795  op = new_ir_op(cur_opcode + iro_TEMPLATE_Jmp, "TEMPLATE_Jmp", op_pin_state_pinned, irop_flag_cfopcode, oparity_any, -1, sizeof(TEMPLATE_attr_t));
796  set_op_dump(op, TEMPLATE_dump_node);
797  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
798  set_op_copy_attr(op, be_copy_attr);
799  set_op_tag(op, TEMPLATE_op_tag);
800  op_TEMPLATE_Jmp = op;
801  op = new_ir_op(cur_opcode + iro_TEMPLATE_Load, "TEMPLATE_Load", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(TEMPLATE_attr_t));
802  set_op_dump(op, TEMPLATE_dump_node);
803  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
804  set_op_copy_attr(op, be_copy_attr);
805  set_op_tag(op, TEMPLATE_op_tag);
806  op_TEMPLATE_Load = op;
807  op = new_ir_op(cur_opcode + iro_TEMPLATE_Minus, "TEMPLATE_Minus", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
808  set_op_dump(op, TEMPLATE_dump_node);
809  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
810  set_op_copy_attr(op, be_copy_attr);
811  set_op_tag(op, TEMPLATE_op_tag);
812  op_TEMPLATE_Minus = op;
813  op = new_ir_op(cur_opcode + iro_TEMPLATE_Mul, "TEMPLATE_Mul", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
814  set_op_dump(op, TEMPLATE_dump_node);
815  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
816  set_op_copy_attr(op, be_copy_attr);
817  set_op_tag(op, TEMPLATE_op_tag);
818  op_TEMPLATE_Mul = op;
819  op = new_ir_op(cur_opcode + iro_TEMPLATE_Not, "TEMPLATE_Not", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
820  set_op_dump(op, TEMPLATE_dump_node);
821  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
822  set_op_copy_attr(op, be_copy_attr);
823  set_op_tag(op, TEMPLATE_op_tag);
824  op_TEMPLATE_Not = op;
825  op = new_ir_op(cur_opcode + iro_TEMPLATE_Or, "TEMPLATE_Or", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
826  set_op_dump(op, TEMPLATE_dump_node);
827  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
828  set_op_copy_attr(op, be_copy_attr);
829  set_op_tag(op, TEMPLATE_op_tag);
830  op_TEMPLATE_Or = op;
831  op = new_ir_op(cur_opcode + iro_TEMPLATE_Return, "TEMPLATE_Return", op_pin_state_pinned, irop_flag_cfopcode, oparity_variable, -1, sizeof(TEMPLATE_attr_t));
832  set_op_dump(op, TEMPLATE_dump_node);
833  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
834  set_op_copy_attr(op, be_copy_attr);
835  set_op_tag(op, TEMPLATE_op_tag);
836  op_TEMPLATE_Return = op;
837  op = new_ir_op(cur_opcode + iro_TEMPLATE_Shl, "TEMPLATE_Shl", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
838  set_op_dump(op, TEMPLATE_dump_node);
839  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
840  set_op_copy_attr(op, be_copy_attr);
841  set_op_tag(op, TEMPLATE_op_tag);
842  op_TEMPLATE_Shl = op;
843  op = new_ir_op(cur_opcode + iro_TEMPLATE_Shr, "TEMPLATE_Shr", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
844  set_op_dump(op, TEMPLATE_dump_node);
845  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
846  set_op_copy_attr(op, be_copy_attr);
847  set_op_tag(op, TEMPLATE_op_tag);
848  op_TEMPLATE_Shr = op;
849  op = new_ir_op(cur_opcode + iro_TEMPLATE_Store, "TEMPLATE_Store", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(TEMPLATE_attr_t));
850  set_op_dump(op, TEMPLATE_dump_node);
851  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
852  set_op_copy_attr(op, be_copy_attr);
853  set_op_tag(op, TEMPLATE_op_tag);
854  op_TEMPLATE_Store = op;
855  op = new_ir_op(cur_opcode + iro_TEMPLATE_Sub, "TEMPLATE_Sub", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
856  set_op_dump(op, TEMPLATE_dump_node);
857  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
858  set_op_copy_attr(op, be_copy_attr);
859  set_op_tag(op, TEMPLATE_op_tag);
860  op_TEMPLATE_Sub = op;
861  op = new_ir_op(cur_opcode + iro_TEMPLATE_Xor, "TEMPLATE_Xor", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
862  set_op_dump(op, TEMPLATE_dump_node);
863  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
864  set_op_copy_attr(op, be_copy_attr);
865  set_op_tag(op, TEMPLATE_op_tag);
866  op_TEMPLATE_Xor = op;
867  op = new_ir_op(cur_opcode + iro_TEMPLATE_fAdd, "TEMPLATE_fAdd", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
868  set_op_dump(op, TEMPLATE_dump_node);
869  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
870  set_op_copy_attr(op, be_copy_attr);
871  set_op_tag(op, TEMPLATE_op_tag);
872  op_TEMPLATE_fAdd = op;
873  op = new_ir_op(cur_opcode + iro_TEMPLATE_fConst, "TEMPLATE_fConst", op_pin_state_floats, irop_flag_constlike, oparity_any, -1, sizeof(TEMPLATE_attr_t));
874  set_op_dump(op, TEMPLATE_dump_node);
875  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
876  set_op_copy_attr(op, be_copy_attr);
877  set_op_tag(op, TEMPLATE_op_tag);
878  op_TEMPLATE_fConst = op;
879  op = new_ir_op(cur_opcode + iro_TEMPLATE_fDiv, "TEMPLATE_fDiv", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
880  set_op_dump(op, TEMPLATE_dump_node);
881  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
882  set_op_copy_attr(op, be_copy_attr);
883  set_op_tag(op, TEMPLATE_op_tag);
884  op_TEMPLATE_fDiv = op;
885  op = new_ir_op(cur_opcode + iro_TEMPLATE_fLoad, "TEMPLATE_fLoad", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(TEMPLATE_attr_t));
886  set_op_dump(op, TEMPLATE_dump_node);
887  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
888  set_op_copy_attr(op, be_copy_attr);
889  set_op_tag(op, TEMPLATE_op_tag);
890  op_TEMPLATE_fLoad = op;
891  op = new_ir_op(cur_opcode + iro_TEMPLATE_fMinus, "TEMPLATE_fMinus", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
892  set_op_dump(op, TEMPLATE_dump_node);
893  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
894  set_op_copy_attr(op, be_copy_attr);
895  set_op_tag(op, TEMPLATE_op_tag);
896  op_TEMPLATE_fMinus = op;
897  op = new_ir_op(cur_opcode + iro_TEMPLATE_fMul, "TEMPLATE_fMul", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
898  set_op_dump(op, TEMPLATE_dump_node);
899  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
900  set_op_copy_attr(op, be_copy_attr);
901  set_op_tag(op, TEMPLATE_op_tag);
902  op_TEMPLATE_fMul = op;
903  op = new_ir_op(cur_opcode + iro_TEMPLATE_fStore, "TEMPLATE_fStore", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(TEMPLATE_attr_t));
904  set_op_dump(op, TEMPLATE_dump_node);
905  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
906  set_op_copy_attr(op, be_copy_attr);
907  set_op_tag(op, TEMPLATE_op_tag);
908  op_TEMPLATE_fStore = op;
909  op = new_ir_op(cur_opcode + iro_TEMPLATE_fSub, "TEMPLATE_fSub", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(TEMPLATE_attr_t));
910  set_op_dump(op, TEMPLATE_dump_node);
911  set_op_attrs_equal(op, TEMPLATE_attrs_equal);
912  set_op_copy_attr(op, be_copy_attr);
913  set_op_tag(op, TEMPLATE_op_tag);
914  op_TEMPLATE_fSub = op;
915 
916 }
917 
918 void TEMPLATE_free_opcodes(void)
919 {
920  free_ir_op(op_TEMPLATE_Add); op_TEMPLATE_Add = NULL;
921  free_ir_op(op_TEMPLATE_And); op_TEMPLATE_And = NULL;
922  free_ir_op(op_TEMPLATE_Const); op_TEMPLATE_Const = NULL;
923  free_ir_op(op_TEMPLATE_Jmp); op_TEMPLATE_Jmp = NULL;
924  free_ir_op(op_TEMPLATE_Load); op_TEMPLATE_Load = NULL;
925  free_ir_op(op_TEMPLATE_Minus); op_TEMPLATE_Minus = NULL;
926  free_ir_op(op_TEMPLATE_Mul); op_TEMPLATE_Mul = NULL;
927  free_ir_op(op_TEMPLATE_Not); op_TEMPLATE_Not = NULL;
928  free_ir_op(op_TEMPLATE_Or); op_TEMPLATE_Or = NULL;
929  free_ir_op(op_TEMPLATE_Return); op_TEMPLATE_Return = NULL;
930  free_ir_op(op_TEMPLATE_Shl); op_TEMPLATE_Shl = NULL;
931  free_ir_op(op_TEMPLATE_Shr); op_TEMPLATE_Shr = NULL;
932  free_ir_op(op_TEMPLATE_Store); op_TEMPLATE_Store = NULL;
933  free_ir_op(op_TEMPLATE_Sub); op_TEMPLATE_Sub = NULL;
934  free_ir_op(op_TEMPLATE_Xor); op_TEMPLATE_Xor = NULL;
935  free_ir_op(op_TEMPLATE_fAdd); op_TEMPLATE_fAdd = NULL;
936  free_ir_op(op_TEMPLATE_fConst); op_TEMPLATE_fConst = NULL;
937  free_ir_op(op_TEMPLATE_fDiv); op_TEMPLATE_fDiv = NULL;
938  free_ir_op(op_TEMPLATE_fLoad); op_TEMPLATE_fLoad = NULL;
939  free_ir_op(op_TEMPLATE_fMinus); op_TEMPLATE_fMinus = NULL;
940  free_ir_op(op_TEMPLATE_fMul); op_TEMPLATE_fMul = NULL;
941  free_ir_op(op_TEMPLATE_fStore); op_TEMPLATE_fStore = NULL;
942  free_ir_op(op_TEMPLATE_fSub); op_TEMPLATE_fSub = NULL;
943 
944 }
irop_flag_none
Nothing.
Definition: irop.h:43
get_irn_opcode
unsigned get_irn_opcode(const ir_node *node)
Returns the opcode-enum of the node.
get_irn_irg
ir_graph * get_irn_irg(const ir_node *node)
Returns the ir_graph this node belongs to.
ir_op
struct ir_op ir_op
Node Opcode.
Definition: firm_types.h:56
set_op_attrs_equal
void set_op_attrs_equal(ir_op *op, node_attrs_equal_func func)
Sets attrs_equal callback func for operation op.
verify_new_node
void verify_new_node(ir_node *node)
If firm is built in debug mode, verify that a newly created node is fine.
dbg_info
struct dbg_info dbg_info
Source Reference.
Definition: firm_types.h:40
get_irn_generic_attr
void * get_irn_generic_attr(ir_node *node)
Returns a pointer to the node attributes.
mode_M
ir_mode * mode_M
memory
Definition: irmode.h:190
ir_tarval
struct ir_tarval ir_tarval
Target Machine Value.
Definition: firm_types.h:68
get_irn_op
ir_op * get_irn_op(const ir_node *node)
Returns the opcode struct of the node.
optimize_node
ir_node * optimize_node(ir_node *n)
Applies local optimizations to a single node.
new_ir_node
ir_node * new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode, int arity, ir_node *const *in)
IR node constructor.
irop_flag_cfopcode
This operation is a control flow operation.
Definition: irop.h:45
mode_T
ir_mode * mode_T
tuple (none)
Definition: irmode.h:220
op_pin_state_pinned
Nodes must remain in this basic block.
Definition: firm_types.h:200
irop_flag_uses_memory
This operation has a memory input and may change the memory state.
Definition: irop.h:54
op_pin_state_exc_pinned
Node must remain in this basic block if it can throw an exception, else can float.
Definition: firm_types.h:201
set_op_copy_attr
void set_op_copy_attr(ir_op *op, copy_attr_func func)
Sets attribute copy callback func for operation op.
oparity_variable
The arity is not fixed by opcode, but statically known.
Definition: irop.h:32
new_ir_op
ir_op * new_ir_op(unsigned code, const char *name, op_pin_state p, irop_flags flags, op_arity opar, int op_index, size_t attr_size)
Creates a new IR operation.
irop_flag_constlike
This operation has no arguments and is some kind of a constant.
Definition: irop.h:50
get_next_ir_opcodes
unsigned get_next_ir_opcodes(unsigned num)
Returns the next free n IR opcode number, allows to register a bunch of user ops. ...
set_op_dump
void set_op_dump(ir_op *op, dump_node_func func)
Sets dump callback func for operation op.
ir_entity
struct ir_entity ir_entity
Entity.
Definition: firm_types.h:83
ir_node
struct ir_node ir_node
Procedure Graph Node.
Definition: firm_types.h:53
mode_Iu
ir_mode * mode_Iu
uint32
Definition: irmode.h:199
mode_F
ir_mode * mode_F
ieee754 binary32 float (single precision)
Definition: irmode.h:192
free_ir_op
void free_ir_op(ir_op *code)
Frees an ir operation.
ir_graph
struct ir_graph ir_graph
Procedure Graph.
Definition: firm_types.h:74
mode_X
ir_mode * mode_X
execution
Definition: irmode.h:217
op_pin_state_floats
Nodes of this opcode can be placed in any basic block.
Definition: firm_types.h:199
oparity_any
Any other arity.
Definition: irop.h:37