libFirm
 All Data Structures Functions Variables Typedefs Enumerations Enumerator Groups Pages
gen_riscv_new_nodes.c
1 #include "gen_riscv_new_nodes.h"
2 
3 #include "benode.h"
4 #include "riscv_bearch_t.h"
5 #include "gen_riscv_regalloc_if.h"
6 #include "riscv_new_nodes_t.h"
7 #include "fourcc.h"
8 #include "irgopt.h"
9 #include "ircons_t.h"
10 
11 ir_op *op_riscv_add = NULL;
12 ir_op *op_riscv_addi = NULL;
13 ir_op *op_riscv_and = NULL;
14 ir_op *op_riscv_andi = NULL;
15 ir_op *op_riscv_bcc = NULL;
16 ir_op *op_riscv_div = NULL;
17 ir_op *op_riscv_divu = NULL;
18 ir_op *op_riscv_ijmp = NULL;
19 ir_op *op_riscv_j = NULL;
20 ir_op *op_riscv_jal = NULL;
21 ir_op *op_riscv_jalr = NULL;
22 ir_op *op_riscv_lb = NULL;
23 ir_op *op_riscv_lbu = NULL;
24 ir_op *op_riscv_lh = NULL;
25 ir_op *op_riscv_lhu = NULL;
26 ir_op *op_riscv_lui = NULL;
27 ir_op *op_riscv_lw = NULL;
28 ir_op *op_riscv_mul = NULL;
29 ir_op *op_riscv_mulh = NULL;
30 ir_op *op_riscv_mulhu = NULL;
31 ir_op *op_riscv_or = NULL;
32 ir_op *op_riscv_ori = NULL;
33 ir_op *op_riscv_rem = NULL;
34 ir_op *op_riscv_remu = NULL;
35 ir_op *op_riscv_ret = NULL;
36 ir_op *op_riscv_sb = NULL;
37 ir_op *op_riscv_sh = NULL;
38 ir_op *op_riscv_sll = NULL;
39 ir_op *op_riscv_slli = NULL;
40 ir_op *op_riscv_slt = NULL;
41 ir_op *op_riscv_sltiu = NULL;
42 ir_op *op_riscv_sltu = NULL;
43 ir_op *op_riscv_sra = NULL;
44 ir_op *op_riscv_srai = NULL;
45 ir_op *op_riscv_srl = NULL;
46 ir_op *op_riscv_srli = NULL;
47 ir_op *op_riscv_sub = NULL;
48 ir_op *op_riscv_sw = NULL;
49 ir_op *op_riscv_switch = NULL;
50 ir_op *op_riscv_xor = NULL;
51 ir_op *op_riscv_xori = NULL;
52 
53 
54 static int riscv_opcode_start = -1;
55 
57 #define riscv_op_tag FOURCC('r', 'i', 's', 'c')
58 
60 int is_riscv_op(const ir_op *op)
61 {
62  return get_op_tag(op) == riscv_op_tag;
63 }
64 
66 int is_riscv_irn(const ir_node *node)
67 {
68  return is_riscv_op(get_irn_op(node));
69 }
70 
71 int get_riscv_irn_opcode(const ir_node *node)
72 {
73  assert(is_riscv_irn(node));
74  return get_irn_opcode(node) - riscv_opcode_start;
75 }
76 
77 #undef BIT
78 #define BIT(x) (1 << (x))
79 
80 
81 
82 
83 ir_node *new_bd_riscv_add(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
84 {
85  static arch_register_req_t const *in_reqs[] = {
86  &riscv_class_reg_req_gp,
87  &riscv_class_reg_req_gp,
88  };
89 
90  /* construct in array */
91  ir_node *const in[] = {
92  left,
93  right,
94  };
95 
96  ir_graph *const irg = get_irn_irg(block);
97  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_add, mode_Iu, 2, in);
98 
99  /* init node attributes */
100 
101  /* flags */
102  arch_irn_flags_t irn_flags = arch_irn_flags_none;
103  irn_flags |= arch_irn_flag_rematerializable;
104  int const n_res = 1;
105  be_info_init_irn(res, irn_flags, in_reqs, n_res);
106  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
107  (void)attr; /* avoid potential warning */
108  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
109  out_infos[0].req = &riscv_class_reg_req_gp;
110 
111  verify_new_node(res);
112  return optimize_node(res);
113 }
114 
115 ir_node *new_bd_riscv_addi(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
116 {
117  static arch_register_req_t const *in_reqs[] = {
118  &riscv_class_reg_req_gp,
119  };
120 
121  /* construct in array */
122  ir_node *const in[] = {
123  left,
124  };
125 
126  ir_graph *const irg = get_irn_irg(block);
127  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_addi, mode_Iu, 1, in);
128 
129  /* init node attributes */
130 
131  /* flags */
132  arch_irn_flags_t irn_flags = arch_irn_flags_none;
133  irn_flags |= arch_irn_flag_rematerializable;
134  int const n_res = 1;
135  be_info_init_irn(res, irn_flags, in_reqs, n_res);
136  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
137  (void)attr; /* avoid potential warning */
138  attr->ent = ent;
139  attr->val = val;
140  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
141  out_infos[0].req = &riscv_class_reg_req_gp;
142 
143  verify_new_node(res);
144  return optimize_node(res);
145 }
146 
147 ir_node *new_bd_riscv_and(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
148 {
149  static arch_register_req_t const *in_reqs[] = {
150  &riscv_class_reg_req_gp,
151  &riscv_class_reg_req_gp,
152  };
153 
154  /* construct in array */
155  ir_node *const in[] = {
156  left,
157  right,
158  };
159 
160  ir_graph *const irg = get_irn_irg(block);
161  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_and, mode_Iu, 2, in);
162 
163  /* init node attributes */
164 
165  /* flags */
166  arch_irn_flags_t irn_flags = arch_irn_flags_none;
167  irn_flags |= arch_irn_flag_rematerializable;
168  int const n_res = 1;
169  be_info_init_irn(res, irn_flags, in_reqs, n_res);
170  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
171  (void)attr; /* avoid potential warning */
172  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
173  out_infos[0].req = &riscv_class_reg_req_gp;
174 
175  verify_new_node(res);
176  return optimize_node(res);
177 }
178 
179 ir_node *new_bd_riscv_andi(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
180 {
181  static arch_register_req_t const *in_reqs[] = {
182  &riscv_class_reg_req_gp,
183  };
184 
185  /* construct in array */
186  ir_node *const in[] = {
187  left,
188  };
189 
190  ir_graph *const irg = get_irn_irg(block);
191  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_andi, mode_Iu, 1, in);
192 
193  /* init node attributes */
194 
195  /* flags */
196  arch_irn_flags_t irn_flags = arch_irn_flags_none;
197  irn_flags |= arch_irn_flag_rematerializable;
198  int const n_res = 1;
199  be_info_init_irn(res, irn_flags, in_reqs, n_res);
200  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
201  (void)attr; /* avoid potential warning */
202  attr->ent = ent;
203  attr->val = val;
204  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
205  out_infos[0].req = &riscv_class_reg_req_gp;
206 
207  verify_new_node(res);
208  return optimize_node(res);
209 }
210 
211 ir_node *new_bd_riscv_bcc(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, riscv_cond_t const cond)
212 {
213  static arch_register_req_t const *in_reqs[] = {
214  &riscv_class_reg_req_gp,
215  &riscv_class_reg_req_gp,
216  };
217 
218  /* construct in array */
219  ir_node *const in[] = {
220  left,
221  right,
222  };
223 
224  ir_graph *const irg = get_irn_irg(block);
225  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_bcc, mode_T, 2, in);
226 
227  /* init node attributes */
228 
229  /* flags */
230  arch_irn_flags_t irn_flags = arch_irn_flags_none;
231  int const n_res = 2;
232  be_info_init_irn(res, irn_flags, in_reqs, n_res);
233  riscv_cond_attr_t *const attr = (riscv_cond_attr_t*)get_irn_generic_attr(res);
234  (void)attr; /* avoid potential warning */
235  attr->cond = cond;
236  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
237  out_infos[0].req = &arch_exec_requirement;
238  out_infos[1].req = &arch_exec_requirement;
239 
240  verify_new_node(res);
241  return optimize_node(res);
242 }
243 
244 ir_node *new_bd_riscv_div(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
245 {
246  static arch_register_req_t const *in_reqs[] = {
247  &riscv_class_reg_req_gp,
248  &riscv_class_reg_req_gp,
249  };
250 
251  /* construct in array */
252  ir_node *const in[] = {
253  left,
254  right,
255  };
256 
257  ir_graph *const irg = get_irn_irg(block);
258  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_div, mode_Iu, 2, in);
259 
260  /* init node attributes */
261 
262  /* flags */
263  arch_irn_flags_t irn_flags = arch_irn_flags_none;
264  irn_flags |= arch_irn_flag_rematerializable;
265  int const n_res = 1;
266  be_info_init_irn(res, irn_flags, in_reqs, n_res);
267  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
268  (void)attr; /* avoid potential warning */
269  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
270  out_infos[0].req = &riscv_class_reg_req_gp;
271 
272  verify_new_node(res);
273  return optimize_node(res);
274 }
275 
276 ir_node *new_bd_riscv_divu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
277 {
278  static arch_register_req_t const *in_reqs[] = {
279  &riscv_class_reg_req_gp,
280  &riscv_class_reg_req_gp,
281  };
282 
283  /* construct in array */
284  ir_node *const in[] = {
285  left,
286  right,
287  };
288 
289  ir_graph *const irg = get_irn_irg(block);
290  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_divu, mode_Iu, 2, in);
291 
292  /* init node attributes */
293 
294  /* flags */
295  arch_irn_flags_t irn_flags = arch_irn_flags_none;
296  irn_flags |= arch_irn_flag_rematerializable;
297  int const n_res = 1;
298  be_info_init_irn(res, irn_flags, in_reqs, n_res);
299  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
300  (void)attr; /* avoid potential warning */
301  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
302  out_infos[0].req = &riscv_class_reg_req_gp;
303 
304  verify_new_node(res);
305  return optimize_node(res);
306 }
307 
308 ir_node *new_bd_riscv_ijmp(dbg_info *dbgi, ir_node *block, ir_node *op0)
309 {
310  static arch_register_req_t const *in_reqs[] = {
311  &riscv_class_reg_req_gp,
312  };
313 
314  /* construct in array */
315  ir_node *const in[] = {
316  op0,
317  };
318 
319  ir_graph *const irg = get_irn_irg(block);
320  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_ijmp, mode_X, 1, in);
321 
322  /* init node attributes */
323 
324  /* flags */
325  arch_irn_flags_t irn_flags = arch_irn_flags_none;
326  int const n_res = 1;
327  be_info_init_irn(res, irn_flags, in_reqs, n_res);
328  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
329  (void)attr; /* avoid potential warning */
330  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
331  out_infos[0].req = &arch_exec_requirement;
332 
333  verify_new_node(res);
334  return optimize_node(res);
335 }
336 
337 ir_node *new_bd_riscv_j(dbg_info *dbgi, ir_node *block)
338 {
339  arch_register_req_t const **const in_reqs = NULL;
340 
341 
342  ir_graph *const irg = get_irn_irg(block);
343  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_j, mode_X, 0, NULL);
344 
345  /* init node attributes */
346 
347  /* flags */
348  arch_irn_flags_t irn_flags = arch_irn_flags_none;
349  irn_flags |= arch_irn_flag_simple_jump;
350  irn_flags |= arch_irn_flag_fallthrough;
351  int const n_res = 1;
352  be_info_init_irn(res, irn_flags, in_reqs, n_res);
353  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
354  (void)attr; /* avoid potential warning */
355  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
356  out_infos[0].req = &arch_exec_requirement;
357 
358  verify_new_node(res);
359  return optimize_node(res);
360 }
361 
362 ir_node *new_bd_riscv_jal(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs, int n_res, ir_entity *const ent, int32_t const val)
363 {
364 
365 
366  ir_graph *const irg = get_irn_irg(block);
367  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_jal, mode_T, arity, in);
368 
369  /* init node attributes */
370 
371  /* flags */
372  arch_irn_flags_t irn_flags = arch_irn_flags_none;
373  be_info_init_irn(res, irn_flags, in_reqs, n_res);
374  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
375  (void)attr; /* avoid potential warning */
376  attr->ent = ent;
377  attr->val = val;
378 
379  verify_new_node(res);
380  return optimize_node(res);
381 }
382 
383 ir_node *new_bd_riscv_jalr(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs, int n_res)
384 {
385 
386 
387  ir_graph *const irg = get_irn_irg(block);
388  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_jalr, mode_T, arity, in);
389 
390  /* init node attributes */
391 
392  /* flags */
393  arch_irn_flags_t irn_flags = arch_irn_flags_none;
394  be_info_init_irn(res, irn_flags, in_reqs, n_res);
395  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
396  (void)attr; /* avoid potential warning */
397 
398  verify_new_node(res);
399  return optimize_node(res);
400 }
401 
402 ir_node *new_bd_riscv_lb(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val)
403 {
404  static arch_register_req_t const *in_reqs[] = {
405  &arch_memory_requirement,
406  &riscv_class_reg_req_gp,
407  };
408 
409  /* construct in array */
410  ir_node *const in[] = {
411  mem,
412  base,
413  };
414 
415  ir_graph *const irg = get_irn_irg(block);
416  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_lb, mode_T, 2, in);
417 
418  /* init node attributes */
419 
420  /* flags */
421  arch_irn_flags_t irn_flags = arch_irn_flags_none;
422  int const n_res = 2;
423  be_info_init_irn(res, irn_flags, in_reqs, n_res);
424  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
425  (void)attr; /* avoid potential warning */
426  attr->ent = ent;
427  attr->val = val;
428  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
429  out_infos[0].req = &arch_memory_requirement;
430  out_infos[1].req = &riscv_class_reg_req_gp;
431 
432  verify_new_node(res);
433  return optimize_node(res);
434 }
435 
436 ir_node *new_bd_riscv_lbu(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val)
437 {
438  static arch_register_req_t const *in_reqs[] = {
439  &arch_memory_requirement,
440  &riscv_class_reg_req_gp,
441  };
442 
443  /* construct in array */
444  ir_node *const in[] = {
445  mem,
446  base,
447  };
448 
449  ir_graph *const irg = get_irn_irg(block);
450  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_lbu, mode_T, 2, in);
451 
452  /* init node attributes */
453 
454  /* flags */
455  arch_irn_flags_t irn_flags = arch_irn_flags_none;
456  int const n_res = 2;
457  be_info_init_irn(res, irn_flags, in_reqs, n_res);
458  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
459  (void)attr; /* avoid potential warning */
460  attr->ent = ent;
461  attr->val = val;
462  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
463  out_infos[0].req = &arch_memory_requirement;
464  out_infos[1].req = &riscv_class_reg_req_gp;
465 
466  verify_new_node(res);
467  return optimize_node(res);
468 }
469 
470 ir_node *new_bd_riscv_lh(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val)
471 {
472  static arch_register_req_t const *in_reqs[] = {
473  &arch_memory_requirement,
474  &riscv_class_reg_req_gp,
475  };
476 
477  /* construct in array */
478  ir_node *const in[] = {
479  mem,
480  base,
481  };
482 
483  ir_graph *const irg = get_irn_irg(block);
484  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_lh, mode_T, 2, in);
485 
486  /* init node attributes */
487 
488  /* flags */
489  arch_irn_flags_t irn_flags = arch_irn_flags_none;
490  int const n_res = 2;
491  be_info_init_irn(res, irn_flags, in_reqs, n_res);
492  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
493  (void)attr; /* avoid potential warning */
494  attr->ent = ent;
495  attr->val = val;
496  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
497  out_infos[0].req = &arch_memory_requirement;
498  out_infos[1].req = &riscv_class_reg_req_gp;
499 
500  verify_new_node(res);
501  return optimize_node(res);
502 }
503 
504 ir_node *new_bd_riscv_lhu(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val)
505 {
506  static arch_register_req_t const *in_reqs[] = {
507  &arch_memory_requirement,
508  &riscv_class_reg_req_gp,
509  };
510 
511  /* construct in array */
512  ir_node *const in[] = {
513  mem,
514  base,
515  };
516 
517  ir_graph *const irg = get_irn_irg(block);
518  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_lhu, mode_T, 2, in);
519 
520  /* init node attributes */
521 
522  /* flags */
523  arch_irn_flags_t irn_flags = arch_irn_flags_none;
524  int const n_res = 2;
525  be_info_init_irn(res, irn_flags, in_reqs, n_res);
526  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
527  (void)attr; /* avoid potential warning */
528  attr->ent = ent;
529  attr->val = val;
530  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
531  out_infos[0].req = &arch_memory_requirement;
532  out_infos[1].req = &riscv_class_reg_req_gp;
533 
534  verify_new_node(res);
535  return optimize_node(res);
536 }
537 
538 ir_node *new_bd_riscv_lui(dbg_info *dbgi, ir_node *block, ir_entity *const ent, int32_t const val)
539 {
540  static arch_register_req_t const *in_reqs[] = {
541  };
542 
543 
544  ir_graph *const irg = get_irn_irg(block);
545  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_lui, mode_Iu, 0, NULL);
546 
547  /* init node attributes */
548 
549  /* flags */
550  arch_irn_flags_t irn_flags = arch_irn_flags_none;
551  irn_flags |= arch_irn_flag_rematerializable;
552  int const n_res = 1;
553  be_info_init_irn(res, irn_flags, in_reqs, n_res);
554  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
555  (void)attr; /* avoid potential warning */
556  attr->ent = ent;
557  attr->val = val;
558  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
559  out_infos[0].req = &riscv_class_reg_req_gp;
560 
561  verify_new_node(res);
562  return optimize_node(res);
563 }
564 
565 ir_node *new_bd_riscv_lw(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val)
566 {
567  static arch_register_req_t const *in_reqs[] = {
568  &arch_memory_requirement,
569  &riscv_class_reg_req_gp,
570  };
571 
572  /* construct in array */
573  ir_node *const in[] = {
574  mem,
575  base,
576  };
577 
578  ir_graph *const irg = get_irn_irg(block);
579  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_lw, mode_T, 2, in);
580 
581  /* init node attributes */
582 
583  /* flags */
584  arch_irn_flags_t irn_flags = arch_irn_flags_none;
585  int const n_res = 2;
586  be_info_init_irn(res, irn_flags, in_reqs, n_res);
587  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
588  (void)attr; /* avoid potential warning */
589  attr->ent = ent;
590  attr->val = val;
591  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
592  out_infos[0].req = &arch_memory_requirement;
593  out_infos[1].req = &riscv_class_reg_req_gp;
594 
595  verify_new_node(res);
596  return optimize_node(res);
597 }
598 
599 ir_node *new_bd_riscv_mul(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
600 {
601  static arch_register_req_t const *in_reqs[] = {
602  &riscv_class_reg_req_gp,
603  &riscv_class_reg_req_gp,
604  };
605 
606  /* construct in array */
607  ir_node *const in[] = {
608  left,
609  right,
610  };
611 
612  ir_graph *const irg = get_irn_irg(block);
613  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_mul, mode_Iu, 2, in);
614 
615  /* init node attributes */
616 
617  /* flags */
618  arch_irn_flags_t irn_flags = arch_irn_flags_none;
619  irn_flags |= arch_irn_flag_rematerializable;
620  int const n_res = 1;
621  be_info_init_irn(res, irn_flags, in_reqs, n_res);
622  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
623  (void)attr; /* avoid potential warning */
624  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
625  out_infos[0].req = &riscv_class_reg_req_gp;
626 
627  verify_new_node(res);
628  return optimize_node(res);
629 }
630 
631 ir_node *new_bd_riscv_mulh(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
632 {
633  static arch_register_req_t const *in_reqs[] = {
634  &riscv_class_reg_req_gp,
635  &riscv_class_reg_req_gp,
636  };
637 
638  /* construct in array */
639  ir_node *const in[] = {
640  left,
641  right,
642  };
643 
644  ir_graph *const irg = get_irn_irg(block);
645  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_mulh, mode_Iu, 2, in);
646 
647  /* init node attributes */
648 
649  /* flags */
650  arch_irn_flags_t irn_flags = arch_irn_flags_none;
651  irn_flags |= arch_irn_flag_rematerializable;
652  int const n_res = 1;
653  be_info_init_irn(res, irn_flags, in_reqs, n_res);
654  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
655  (void)attr; /* avoid potential warning */
656  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
657  out_infos[0].req = &riscv_class_reg_req_gp;
658 
659  verify_new_node(res);
660  return optimize_node(res);
661 }
662 
663 ir_node *new_bd_riscv_mulhu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
664 {
665  static arch_register_req_t const *in_reqs[] = {
666  &riscv_class_reg_req_gp,
667  &riscv_class_reg_req_gp,
668  };
669 
670  /* construct in array */
671  ir_node *const in[] = {
672  left,
673  right,
674  };
675 
676  ir_graph *const irg = get_irn_irg(block);
677  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_mulhu, mode_Iu, 2, in);
678 
679  /* init node attributes */
680 
681  /* flags */
682  arch_irn_flags_t irn_flags = arch_irn_flags_none;
683  irn_flags |= arch_irn_flag_rematerializable;
684  int const n_res = 1;
685  be_info_init_irn(res, irn_flags, in_reqs, n_res);
686  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
687  (void)attr; /* avoid potential warning */
688  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
689  out_infos[0].req = &riscv_class_reg_req_gp;
690 
691  verify_new_node(res);
692  return optimize_node(res);
693 }
694 
695 ir_node *new_bd_riscv_or(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
696 {
697  static arch_register_req_t const *in_reqs[] = {
698  &riscv_class_reg_req_gp,
699  &riscv_class_reg_req_gp,
700  };
701 
702  /* construct in array */
703  ir_node *const in[] = {
704  left,
705  right,
706  };
707 
708  ir_graph *const irg = get_irn_irg(block);
709  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_or, mode_Iu, 2, in);
710 
711  /* init node attributes */
712 
713  /* flags */
714  arch_irn_flags_t irn_flags = arch_irn_flags_none;
715  irn_flags |= arch_irn_flag_rematerializable;
716  int const n_res = 1;
717  be_info_init_irn(res, irn_flags, in_reqs, n_res);
718  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
719  (void)attr; /* avoid potential warning */
720  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
721  out_infos[0].req = &riscv_class_reg_req_gp;
722 
723  verify_new_node(res);
724  return optimize_node(res);
725 }
726 
727 ir_node *new_bd_riscv_ori(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
728 {
729  static arch_register_req_t const *in_reqs[] = {
730  &riscv_class_reg_req_gp,
731  };
732 
733  /* construct in array */
734  ir_node *const in[] = {
735  left,
736  };
737 
738  ir_graph *const irg = get_irn_irg(block);
739  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_ori, mode_Iu, 1, in);
740 
741  /* init node attributes */
742 
743  /* flags */
744  arch_irn_flags_t irn_flags = arch_irn_flags_none;
745  irn_flags |= arch_irn_flag_rematerializable;
746  int const n_res = 1;
747  be_info_init_irn(res, irn_flags, in_reqs, n_res);
748  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
749  (void)attr; /* avoid potential warning */
750  attr->ent = ent;
751  attr->val = val;
752  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
753  out_infos[0].req = &riscv_class_reg_req_gp;
754 
755  verify_new_node(res);
756  return optimize_node(res);
757 }
758 
759 ir_node *new_bd_riscv_rem(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
760 {
761  static arch_register_req_t const *in_reqs[] = {
762  &riscv_class_reg_req_gp,
763  &riscv_class_reg_req_gp,
764  };
765 
766  /* construct in array */
767  ir_node *const in[] = {
768  left,
769  right,
770  };
771 
772  ir_graph *const irg = get_irn_irg(block);
773  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_rem, mode_Iu, 2, in);
774 
775  /* init node attributes */
776 
777  /* flags */
778  arch_irn_flags_t irn_flags = arch_irn_flags_none;
779  irn_flags |= arch_irn_flag_rematerializable;
780  int const n_res = 1;
781  be_info_init_irn(res, irn_flags, in_reqs, n_res);
782  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
783  (void)attr; /* avoid potential warning */
784  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
785  out_infos[0].req = &riscv_class_reg_req_gp;
786 
787  verify_new_node(res);
788  return optimize_node(res);
789 }
790 
791 ir_node *new_bd_riscv_remu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
792 {
793  static arch_register_req_t const *in_reqs[] = {
794  &riscv_class_reg_req_gp,
795  &riscv_class_reg_req_gp,
796  };
797 
798  /* construct in array */
799  ir_node *const in[] = {
800  left,
801  right,
802  };
803 
804  ir_graph *const irg = get_irn_irg(block);
805  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_remu, mode_Iu, 2, in);
806 
807  /* init node attributes */
808 
809  /* flags */
810  arch_irn_flags_t irn_flags = arch_irn_flags_none;
811  irn_flags |= arch_irn_flag_rematerializable;
812  int const n_res = 1;
813  be_info_init_irn(res, irn_flags, in_reqs, n_res);
814  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
815  (void)attr; /* avoid potential warning */
816  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
817  out_infos[0].req = &riscv_class_reg_req_gp;
818 
819  verify_new_node(res);
820  return optimize_node(res);
821 }
822 
823 ir_node *new_bd_riscv_ret(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs)
824 {
825 
826 
827  ir_graph *const irg = get_irn_irg(block);
828  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_ret, mode_X, arity, in);
829 
830  /* init node attributes */
831 
832  /* flags */
833  arch_irn_flags_t irn_flags = arch_irn_flags_none;
834  int const n_res = 1;
835  be_info_init_irn(res, irn_flags, in_reqs, n_res);
836  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
837  (void)attr; /* avoid potential warning */
838  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
839  out_infos[0].req = &arch_exec_requirement;
840 
841  verify_new_node(res);
842  return optimize_node(res);
843 }
844 
845 ir_node *new_bd_riscv_sb(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_node *value, ir_entity *const ent, int32_t const val)
846 {
847  static arch_register_req_t const *in_reqs[] = {
848  &arch_memory_requirement,
849  &riscv_class_reg_req_gp,
850  &riscv_class_reg_req_gp,
851  };
852 
853  /* construct in array */
854  ir_node *const in[] = {
855  mem,
856  base,
857  value,
858  };
859 
860  ir_graph *const irg = get_irn_irg(block);
861  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_sb, mode_M, 3, in);
862 
863  /* init node attributes */
864 
865  /* flags */
866  arch_irn_flags_t irn_flags = arch_irn_flags_none;
867  int const n_res = 1;
868  be_info_init_irn(res, irn_flags, in_reqs, n_res);
869  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
870  (void)attr; /* avoid potential warning */
871  attr->ent = ent;
872  attr->val = val;
873  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
874  out_infos[0].req = &arch_memory_requirement;
875 
876  verify_new_node(res);
877  return optimize_node(res);
878 }
879 
880 ir_node *new_bd_riscv_sh(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_node *value, ir_entity *const ent, int32_t const val)
881 {
882  static arch_register_req_t const *in_reqs[] = {
883  &arch_memory_requirement,
884  &riscv_class_reg_req_gp,
885  &riscv_class_reg_req_gp,
886  };
887 
888  /* construct in array */
889  ir_node *const in[] = {
890  mem,
891  base,
892  value,
893  };
894 
895  ir_graph *const irg = get_irn_irg(block);
896  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_sh, mode_M, 3, in);
897 
898  /* init node attributes */
899 
900  /* flags */
901  arch_irn_flags_t irn_flags = arch_irn_flags_none;
902  int const n_res = 1;
903  be_info_init_irn(res, irn_flags, in_reqs, n_res);
904  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
905  (void)attr; /* avoid potential warning */
906  attr->ent = ent;
907  attr->val = val;
908  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
909  out_infos[0].req = &arch_memory_requirement;
910 
911  verify_new_node(res);
912  return optimize_node(res);
913 }
914 
915 ir_node *new_bd_riscv_sll(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
916 {
917  static arch_register_req_t const *in_reqs[] = {
918  &riscv_class_reg_req_gp,
919  &riscv_class_reg_req_gp,
920  };
921 
922  /* construct in array */
923  ir_node *const in[] = {
924  left,
925  right,
926  };
927 
928  ir_graph *const irg = get_irn_irg(block);
929  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_sll, mode_Iu, 2, in);
930 
931  /* init node attributes */
932 
933  /* flags */
934  arch_irn_flags_t irn_flags = arch_irn_flags_none;
935  irn_flags |= arch_irn_flag_rematerializable;
936  int const n_res = 1;
937  be_info_init_irn(res, irn_flags, in_reqs, n_res);
938  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
939  (void)attr; /* avoid potential warning */
940  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
941  out_infos[0].req = &riscv_class_reg_req_gp;
942 
943  verify_new_node(res);
944  return optimize_node(res);
945 }
946 
947 ir_node *new_bd_riscv_slli(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
948 {
949  static arch_register_req_t const *in_reqs[] = {
950  &riscv_class_reg_req_gp,
951  };
952 
953  /* construct in array */
954  ir_node *const in[] = {
955  left,
956  };
957 
958  ir_graph *const irg = get_irn_irg(block);
959  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_slli, mode_Iu, 1, in);
960 
961  /* init node attributes */
962 
963  /* flags */
964  arch_irn_flags_t irn_flags = arch_irn_flags_none;
965  irn_flags |= arch_irn_flag_rematerializable;
966  int const n_res = 1;
967  be_info_init_irn(res, irn_flags, in_reqs, n_res);
968  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
969  (void)attr; /* avoid potential warning */
970  attr->ent = ent;
971  attr->val = val;
972  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
973  out_infos[0].req = &riscv_class_reg_req_gp;
974 
975  verify_new_node(res);
976  return optimize_node(res);
977 }
978 
979 ir_node *new_bd_riscv_slt(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
980 {
981  static arch_register_req_t const *in_reqs[] = {
982  &riscv_class_reg_req_gp,
983  &riscv_class_reg_req_gp,
984  };
985 
986  /* construct in array */
987  ir_node *const in[] = {
988  left,
989  right,
990  };
991 
992  ir_graph *const irg = get_irn_irg(block);
993  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_slt, mode_Iu, 2, in);
994 
995  /* init node attributes */
996 
997  /* flags */
998  arch_irn_flags_t irn_flags = arch_irn_flags_none;
999  irn_flags |= arch_irn_flag_rematerializable;
1000  int const n_res = 1;
1001  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1002  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
1003  (void)attr; /* avoid potential warning */
1004  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1005  out_infos[0].req = &riscv_class_reg_req_gp;
1006 
1007  verify_new_node(res);
1008  return optimize_node(res);
1009 }
1010 
1011 ir_node *new_bd_riscv_sltiu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
1012 {
1013  static arch_register_req_t const *in_reqs[] = {
1014  &riscv_class_reg_req_gp,
1015  };
1016 
1017  /* construct in array */
1018  ir_node *const in[] = {
1019  left,
1020  };
1021 
1022  ir_graph *const irg = get_irn_irg(block);
1023  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_sltiu, mode_Iu, 1, in);
1024 
1025  /* init node attributes */
1026 
1027  /* flags */
1028  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1029  irn_flags |= arch_irn_flag_rematerializable;
1030  int const n_res = 1;
1031  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1032  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
1033  (void)attr; /* avoid potential warning */
1034  attr->ent = ent;
1035  attr->val = val;
1036  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1037  out_infos[0].req = &riscv_class_reg_req_gp;
1038 
1039  verify_new_node(res);
1040  return optimize_node(res);
1041 }
1042 
1043 ir_node *new_bd_riscv_sltu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1044 {
1045  static arch_register_req_t const *in_reqs[] = {
1046  &riscv_class_reg_req_gp,
1047  &riscv_class_reg_req_gp,
1048  };
1049 
1050  /* construct in array */
1051  ir_node *const in[] = {
1052  left,
1053  right,
1054  };
1055 
1056  ir_graph *const irg = get_irn_irg(block);
1057  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_sltu, mode_Iu, 2, in);
1058 
1059  /* init node attributes */
1060 
1061  /* flags */
1062  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1063  irn_flags |= arch_irn_flag_rematerializable;
1064  int const n_res = 1;
1065  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1066  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
1067  (void)attr; /* avoid potential warning */
1068  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1069  out_infos[0].req = &riscv_class_reg_req_gp;
1070 
1071  verify_new_node(res);
1072  return optimize_node(res);
1073 }
1074 
1075 ir_node *new_bd_riscv_sra(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1076 {
1077  static arch_register_req_t const *in_reqs[] = {
1078  &riscv_class_reg_req_gp,
1079  &riscv_class_reg_req_gp,
1080  };
1081 
1082  /* construct in array */
1083  ir_node *const in[] = {
1084  left,
1085  right,
1086  };
1087 
1088  ir_graph *const irg = get_irn_irg(block);
1089  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_sra, mode_Iu, 2, in);
1090 
1091  /* init node attributes */
1092 
1093  /* flags */
1094  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1095  irn_flags |= arch_irn_flag_rematerializable;
1096  int const n_res = 1;
1097  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1098  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
1099  (void)attr; /* avoid potential warning */
1100  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1101  out_infos[0].req = &riscv_class_reg_req_gp;
1102 
1103  verify_new_node(res);
1104  return optimize_node(res);
1105 }
1106 
1107 ir_node *new_bd_riscv_srai(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
1108 {
1109  static arch_register_req_t const *in_reqs[] = {
1110  &riscv_class_reg_req_gp,
1111  };
1112 
1113  /* construct in array */
1114  ir_node *const in[] = {
1115  left,
1116  };
1117 
1118  ir_graph *const irg = get_irn_irg(block);
1119  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_srai, mode_Iu, 1, in);
1120 
1121  /* init node attributes */
1122 
1123  /* flags */
1124  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1125  irn_flags |= arch_irn_flag_rematerializable;
1126  int const n_res = 1;
1127  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1128  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
1129  (void)attr; /* avoid potential warning */
1130  attr->ent = ent;
1131  attr->val = val;
1132  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1133  out_infos[0].req = &riscv_class_reg_req_gp;
1134 
1135  verify_new_node(res);
1136  return optimize_node(res);
1137 }
1138 
1139 ir_node *new_bd_riscv_srl(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1140 {
1141  static arch_register_req_t const *in_reqs[] = {
1142  &riscv_class_reg_req_gp,
1143  &riscv_class_reg_req_gp,
1144  };
1145 
1146  /* construct in array */
1147  ir_node *const in[] = {
1148  left,
1149  right,
1150  };
1151 
1152  ir_graph *const irg = get_irn_irg(block);
1153  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_srl, mode_Iu, 2, in);
1154 
1155  /* init node attributes */
1156 
1157  /* flags */
1158  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1159  irn_flags |= arch_irn_flag_rematerializable;
1160  int const n_res = 1;
1161  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1162  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
1163  (void)attr; /* avoid potential warning */
1164  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1165  out_infos[0].req = &riscv_class_reg_req_gp;
1166 
1167  verify_new_node(res);
1168  return optimize_node(res);
1169 }
1170 
1171 ir_node *new_bd_riscv_srli(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
1172 {
1173  static arch_register_req_t const *in_reqs[] = {
1174  &riscv_class_reg_req_gp,
1175  };
1176 
1177  /* construct in array */
1178  ir_node *const in[] = {
1179  left,
1180  };
1181 
1182  ir_graph *const irg = get_irn_irg(block);
1183  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_srli, mode_Iu, 1, in);
1184 
1185  /* init node attributes */
1186 
1187  /* flags */
1188  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1189  irn_flags |= arch_irn_flag_rematerializable;
1190  int const n_res = 1;
1191  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1192  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
1193  (void)attr; /* avoid potential warning */
1194  attr->ent = ent;
1195  attr->val = val;
1196  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1197  out_infos[0].req = &riscv_class_reg_req_gp;
1198 
1199  verify_new_node(res);
1200  return optimize_node(res);
1201 }
1202 
1203 ir_node *new_bd_riscv_sub(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1204 {
1205  static arch_register_req_t const *in_reqs[] = {
1206  &riscv_class_reg_req_gp,
1207  &riscv_class_reg_req_gp,
1208  };
1209 
1210  /* construct in array */
1211  ir_node *const in[] = {
1212  left,
1213  right,
1214  };
1215 
1216  ir_graph *const irg = get_irn_irg(block);
1217  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_sub, mode_Iu, 2, in);
1218 
1219  /* init node attributes */
1220 
1221  /* flags */
1222  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1223  irn_flags |= arch_irn_flag_rematerializable;
1224  int const n_res = 1;
1225  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1226  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
1227  (void)attr; /* avoid potential warning */
1228  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1229  out_infos[0].req = &riscv_class_reg_req_gp;
1230 
1231  verify_new_node(res);
1232  return optimize_node(res);
1233 }
1234 
1235 ir_node *new_bd_riscv_sw(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_node *value, ir_entity *const ent, int32_t const val)
1236 {
1237  static arch_register_req_t const *in_reqs[] = {
1238  &arch_memory_requirement,
1239  &riscv_class_reg_req_gp,
1240  &riscv_class_reg_req_gp,
1241  };
1242 
1243  /* construct in array */
1244  ir_node *const in[] = {
1245  mem,
1246  base,
1247  value,
1248  };
1249 
1250  ir_graph *const irg = get_irn_irg(block);
1251  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_sw, mode_M, 3, in);
1252 
1253  /* init node attributes */
1254 
1255  /* flags */
1256  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1257  int const n_res = 1;
1258  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1259  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
1260  (void)attr; /* avoid potential warning */
1261  attr->ent = ent;
1262  attr->val = val;
1263  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1264  out_infos[0].req = &arch_memory_requirement;
1265 
1266  verify_new_node(res);
1267  return optimize_node(res);
1268 }
1269 
1270 ir_node *new_bd_riscv_switch(dbg_info *dbgi, ir_node *block, ir_node *op0, int n_res, const ir_switch_table *table, ir_entity *table_entity)
1271 {
1272  static arch_register_req_t const *in_reqs[] = {
1273  &riscv_class_reg_req_gp,
1274  };
1275 
1276  /* construct in array */
1277  ir_node *const in[] = {
1278  op0,
1279  };
1280 
1281  ir_graph *const irg = get_irn_irg(block);
1282  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_switch, mode_T, 1, in);
1283 
1284  /* init node attributes */
1285 
1286  /* flags */
1287  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1288  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1289  riscv_switch_attr_t *const attr = (riscv_switch_attr_t*)get_irn_generic_attr(res);
1290  (void)attr; /* avoid potential warning */
1291  be_switch_attr_init(res, &attr->swtch, table, table_entity);
1292 
1293  verify_new_node(res);
1294  return optimize_node(res);
1295 }
1296 
1297 ir_node *new_bd_riscv_xor(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1298 {
1299  static arch_register_req_t const *in_reqs[] = {
1300  &riscv_class_reg_req_gp,
1301  &riscv_class_reg_req_gp,
1302  };
1303 
1304  /* construct in array */
1305  ir_node *const in[] = {
1306  left,
1307  right,
1308  };
1309 
1310  ir_graph *const irg = get_irn_irg(block);
1311  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_xor, mode_Iu, 2, in);
1312 
1313  /* init node attributes */
1314 
1315  /* flags */
1316  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1317  irn_flags |= arch_irn_flag_rematerializable;
1318  int const n_res = 1;
1319  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1320  riscv_attr_t *const attr = (riscv_attr_t*)get_irn_generic_attr(res);
1321  (void)attr; /* avoid potential warning */
1322  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1323  out_infos[0].req = &riscv_class_reg_req_gp;
1324 
1325  verify_new_node(res);
1326  return optimize_node(res);
1327 }
1328 
1329 ir_node *new_bd_riscv_xori(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
1330 {
1331  static arch_register_req_t const *in_reqs[] = {
1332  &riscv_class_reg_req_gp,
1333  };
1334 
1335  /* construct in array */
1336  ir_node *const in[] = {
1337  left,
1338  };
1339 
1340  ir_graph *const irg = get_irn_irg(block);
1341  ir_node *const res = new_ir_node(dbgi, irg, block, op_riscv_xori, mode_Iu, 1, in);
1342 
1343  /* init node attributes */
1344 
1345  /* flags */
1346  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1347  irn_flags |= arch_irn_flag_rematerializable;
1348  int const n_res = 1;
1349  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1350  riscv_immediate_attr_t *const attr = (riscv_immediate_attr_t*)get_irn_generic_attr(res);
1351  (void)attr; /* avoid potential warning */
1352  attr->ent = ent;
1353  attr->val = val;
1354  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1355  out_infos[0].req = &riscv_class_reg_req_gp;
1356 
1357  verify_new_node(res);
1358  return optimize_node(res);
1359 }
1360 
1361 
1366 void riscv_create_opcodes(void)
1367 {
1368  ir_op *op;
1369  int cur_opcode = get_next_ir_opcodes(iro_riscv_last);
1370 
1371  riscv_opcode_start = cur_opcode;
1372  op = new_ir_op(cur_opcode + iro_riscv_add, "riscv_add", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1373  set_op_dump(op, riscv_dump_node);
1374  set_op_attrs_equal(op, riscv_attrs_equal);
1375  set_op_copy_attr(op, be_copy_attr);
1376  set_op_tag(op, riscv_op_tag);
1377  op_riscv_add = op;
1378  op = new_ir_op(cur_opcode + iro_riscv_addi, "riscv_addi", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1379  set_op_dump(op, riscv_dump_node);
1380  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1381  set_op_copy_attr(op, be_copy_attr);
1382  set_op_tag(op, riscv_op_tag);
1383  op_riscv_addi = op;
1384  op = new_ir_op(cur_opcode + iro_riscv_and, "riscv_and", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1385  set_op_dump(op, riscv_dump_node);
1386  set_op_attrs_equal(op, riscv_attrs_equal);
1387  set_op_copy_attr(op, be_copy_attr);
1388  set_op_tag(op, riscv_op_tag);
1389  op_riscv_and = op;
1390  op = new_ir_op(cur_opcode + iro_riscv_andi, "riscv_andi", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1391  set_op_dump(op, riscv_dump_node);
1392  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1393  set_op_copy_attr(op, be_copy_attr);
1394  set_op_tag(op, riscv_op_tag);
1395  op_riscv_andi = op;
1396  op = new_ir_op(cur_opcode + iro_riscv_bcc, "riscv_bcc", op_pin_state_pinned, irop_flag_cfopcode|irop_flag_forking, oparity_any, -1, sizeof(riscv_cond_attr_t));
1397  set_op_dump(op, riscv_dump_node);
1398  set_op_attrs_equal(op, riscv_cond_attrs_equal);
1399  set_op_copy_attr(op, be_copy_attr);
1400  set_op_tag(op, riscv_op_tag);
1401  op_riscv_bcc = op;
1402  op = new_ir_op(cur_opcode + iro_riscv_div, "riscv_div", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1403  set_op_dump(op, riscv_dump_node);
1404  set_op_attrs_equal(op, riscv_attrs_equal);
1405  set_op_copy_attr(op, be_copy_attr);
1406  set_op_tag(op, riscv_op_tag);
1407  op_riscv_div = op;
1408  op = new_ir_op(cur_opcode + iro_riscv_divu, "riscv_divu", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1409  set_op_dump(op, riscv_dump_node);
1410  set_op_attrs_equal(op, riscv_attrs_equal);
1411  set_op_copy_attr(op, be_copy_attr);
1412  set_op_tag(op, riscv_op_tag);
1413  op_riscv_divu = op;
1414  op = new_ir_op(cur_opcode + iro_riscv_ijmp, "riscv_ijmp", op_pin_state_pinned, irop_flag_cfopcode|irop_flag_unknown_jump, oparity_any, -1, sizeof(riscv_attr_t));
1415  set_op_dump(op, riscv_dump_node);
1416  set_op_attrs_equal(op, riscv_attrs_equal);
1417  set_op_copy_attr(op, be_copy_attr);
1418  set_op_tag(op, riscv_op_tag);
1419  op_riscv_ijmp = op;
1420  op = new_ir_op(cur_opcode + iro_riscv_j, "riscv_j", op_pin_state_pinned, irop_flag_cfopcode, oparity_any, -1, sizeof(riscv_attr_t));
1421  set_op_dump(op, riscv_dump_node);
1422  set_op_attrs_equal(op, riscv_attrs_equal);
1423  set_op_copy_attr(op, be_copy_attr);
1424  set_op_tag(op, riscv_op_tag);
1425  op_riscv_j = op;
1426  op = new_ir_op(cur_opcode + iro_riscv_jal, "riscv_jal", op_pin_state_exc_pinned, irop_flag_none, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1427  set_op_dump(op, riscv_dump_node);
1428  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1429  set_op_copy_attr(op, be_copy_attr);
1430  set_op_tag(op, riscv_op_tag);
1431  op_riscv_jal = op;
1432  op = new_ir_op(cur_opcode + iro_riscv_jalr, "riscv_jalr", op_pin_state_exc_pinned, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1433  set_op_dump(op, riscv_dump_node);
1434  set_op_attrs_equal(op, riscv_attrs_equal);
1435  set_op_copy_attr(op, be_copy_attr);
1436  set_op_tag(op, riscv_op_tag);
1437  op_riscv_jalr = op;
1438  op = new_ir_op(cur_opcode + iro_riscv_lb, "riscv_lb", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1439  ir_op_set_memory_index(op, 0); set_op_dump(op, riscv_dump_node);
1440  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1441  set_op_copy_attr(op, be_copy_attr);
1442  set_op_tag(op, riscv_op_tag);
1443  op_riscv_lb = op;
1444  op = new_ir_op(cur_opcode + iro_riscv_lbu, "riscv_lbu", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1445  ir_op_set_memory_index(op, 0); set_op_dump(op, riscv_dump_node);
1446  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1447  set_op_copy_attr(op, be_copy_attr);
1448  set_op_tag(op, riscv_op_tag);
1449  op_riscv_lbu = op;
1450  op = new_ir_op(cur_opcode + iro_riscv_lh, "riscv_lh", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1451  ir_op_set_memory_index(op, 0); set_op_dump(op, riscv_dump_node);
1452  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1453  set_op_copy_attr(op, be_copy_attr);
1454  set_op_tag(op, riscv_op_tag);
1455  op_riscv_lh = op;
1456  op = new_ir_op(cur_opcode + iro_riscv_lhu, "riscv_lhu", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1457  ir_op_set_memory_index(op, 0); set_op_dump(op, riscv_dump_node);
1458  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1459  set_op_copy_attr(op, be_copy_attr);
1460  set_op_tag(op, riscv_op_tag);
1461  op_riscv_lhu = op;
1462  op = new_ir_op(cur_opcode + iro_riscv_lui, "riscv_lui", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1463  set_op_dump(op, riscv_dump_node);
1464  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1465  set_op_copy_attr(op, be_copy_attr);
1466  set_op_tag(op, riscv_op_tag);
1467  op_riscv_lui = op;
1468  op = new_ir_op(cur_opcode + iro_riscv_lw, "riscv_lw", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1469  ir_op_set_memory_index(op, 0); set_op_dump(op, riscv_dump_node);
1470  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1471  set_op_copy_attr(op, be_copy_attr);
1472  set_op_tag(op, riscv_op_tag);
1473  op_riscv_lw = op;
1474  op = new_ir_op(cur_opcode + iro_riscv_mul, "riscv_mul", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1475  set_op_dump(op, riscv_dump_node);
1476  set_op_attrs_equal(op, riscv_attrs_equal);
1477  set_op_copy_attr(op, be_copy_attr);
1478  set_op_tag(op, riscv_op_tag);
1479  op_riscv_mul = op;
1480  op = new_ir_op(cur_opcode + iro_riscv_mulh, "riscv_mulh", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1481  set_op_dump(op, riscv_dump_node);
1482  set_op_attrs_equal(op, riscv_attrs_equal);
1483  set_op_copy_attr(op, be_copy_attr);
1484  set_op_tag(op, riscv_op_tag);
1485  op_riscv_mulh = op;
1486  op = new_ir_op(cur_opcode + iro_riscv_mulhu, "riscv_mulhu", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1487  set_op_dump(op, riscv_dump_node);
1488  set_op_attrs_equal(op, riscv_attrs_equal);
1489  set_op_copy_attr(op, be_copy_attr);
1490  set_op_tag(op, riscv_op_tag);
1491  op_riscv_mulhu = op;
1492  op = new_ir_op(cur_opcode + iro_riscv_or, "riscv_or", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1493  set_op_dump(op, riscv_dump_node);
1494  set_op_attrs_equal(op, riscv_attrs_equal);
1495  set_op_copy_attr(op, be_copy_attr);
1496  set_op_tag(op, riscv_op_tag);
1497  op_riscv_or = op;
1498  op = new_ir_op(cur_opcode + iro_riscv_ori, "riscv_ori", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1499  set_op_dump(op, riscv_dump_node);
1500  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1501  set_op_copy_attr(op, be_copy_attr);
1502  set_op_tag(op, riscv_op_tag);
1503  op_riscv_ori = op;
1504  op = new_ir_op(cur_opcode + iro_riscv_rem, "riscv_rem", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1505  set_op_dump(op, riscv_dump_node);
1506  set_op_attrs_equal(op, riscv_attrs_equal);
1507  set_op_copy_attr(op, be_copy_attr);
1508  set_op_tag(op, riscv_op_tag);
1509  op_riscv_rem = op;
1510  op = new_ir_op(cur_opcode + iro_riscv_remu, "riscv_remu", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1511  set_op_dump(op, riscv_dump_node);
1512  set_op_attrs_equal(op, riscv_attrs_equal);
1513  set_op_copy_attr(op, be_copy_attr);
1514  set_op_tag(op, riscv_op_tag);
1515  op_riscv_remu = op;
1516  op = new_ir_op(cur_opcode + iro_riscv_ret, "riscv_ret", op_pin_state_pinned, irop_flag_cfopcode, oparity_any, -1, sizeof(riscv_attr_t));
1517  set_op_dump(op, riscv_dump_node);
1518  set_op_attrs_equal(op, riscv_attrs_equal);
1519  set_op_copy_attr(op, be_copy_attr);
1520  set_op_tag(op, riscv_op_tag);
1521  op_riscv_ret = op;
1522  op = new_ir_op(cur_opcode + iro_riscv_sb, "riscv_sb", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1523  ir_op_set_memory_index(op, 0); set_op_dump(op, riscv_dump_node);
1524  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1525  set_op_copy_attr(op, be_copy_attr);
1526  set_op_tag(op, riscv_op_tag);
1527  op_riscv_sb = op;
1528  op = new_ir_op(cur_opcode + iro_riscv_sh, "riscv_sh", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1529  ir_op_set_memory_index(op, 0); set_op_dump(op, riscv_dump_node);
1530  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1531  set_op_copy_attr(op, be_copy_attr);
1532  set_op_tag(op, riscv_op_tag);
1533  op_riscv_sh = op;
1534  op = new_ir_op(cur_opcode + iro_riscv_sll, "riscv_sll", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1535  set_op_dump(op, riscv_dump_node);
1536  set_op_attrs_equal(op, riscv_attrs_equal);
1537  set_op_copy_attr(op, be_copy_attr);
1538  set_op_tag(op, riscv_op_tag);
1539  op_riscv_sll = op;
1540  op = new_ir_op(cur_opcode + iro_riscv_slli, "riscv_slli", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1541  set_op_dump(op, riscv_dump_node);
1542  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1543  set_op_copy_attr(op, be_copy_attr);
1544  set_op_tag(op, riscv_op_tag);
1545  op_riscv_slli = op;
1546  op = new_ir_op(cur_opcode + iro_riscv_slt, "riscv_slt", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1547  set_op_dump(op, riscv_dump_node);
1548  set_op_attrs_equal(op, riscv_attrs_equal);
1549  set_op_copy_attr(op, be_copy_attr);
1550  set_op_tag(op, riscv_op_tag);
1551  op_riscv_slt = op;
1552  op = new_ir_op(cur_opcode + iro_riscv_sltiu, "riscv_sltiu", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1553  set_op_dump(op, riscv_dump_node);
1554  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1555  set_op_copy_attr(op, be_copy_attr);
1556  set_op_tag(op, riscv_op_tag);
1557  op_riscv_sltiu = op;
1558  op = new_ir_op(cur_opcode + iro_riscv_sltu, "riscv_sltu", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1559  set_op_dump(op, riscv_dump_node);
1560  set_op_attrs_equal(op, riscv_attrs_equal);
1561  set_op_copy_attr(op, be_copy_attr);
1562  set_op_tag(op, riscv_op_tag);
1563  op_riscv_sltu = op;
1564  op = new_ir_op(cur_opcode + iro_riscv_sra, "riscv_sra", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1565  set_op_dump(op, riscv_dump_node);
1566  set_op_attrs_equal(op, riscv_attrs_equal);
1567  set_op_copy_attr(op, be_copy_attr);
1568  set_op_tag(op, riscv_op_tag);
1569  op_riscv_sra = op;
1570  op = new_ir_op(cur_opcode + iro_riscv_srai, "riscv_srai", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1571  set_op_dump(op, riscv_dump_node);
1572  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1573  set_op_copy_attr(op, be_copy_attr);
1574  set_op_tag(op, riscv_op_tag);
1575  op_riscv_srai = op;
1576  op = new_ir_op(cur_opcode + iro_riscv_srl, "riscv_srl", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1577  set_op_dump(op, riscv_dump_node);
1578  set_op_attrs_equal(op, riscv_attrs_equal);
1579  set_op_copy_attr(op, be_copy_attr);
1580  set_op_tag(op, riscv_op_tag);
1581  op_riscv_srl = op;
1582  op = new_ir_op(cur_opcode + iro_riscv_srli, "riscv_srli", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1583  set_op_dump(op, riscv_dump_node);
1584  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1585  set_op_copy_attr(op, be_copy_attr);
1586  set_op_tag(op, riscv_op_tag);
1587  op_riscv_srli = op;
1588  op = new_ir_op(cur_opcode + iro_riscv_sub, "riscv_sub", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1589  set_op_dump(op, riscv_dump_node);
1590  set_op_attrs_equal(op, riscv_attrs_equal);
1591  set_op_copy_attr(op, be_copy_attr);
1592  set_op_tag(op, riscv_op_tag);
1593  op_riscv_sub = op;
1594  op = new_ir_op(cur_opcode + iro_riscv_sw, "riscv_sw", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1595  ir_op_set_memory_index(op, 0); set_op_dump(op, riscv_dump_node);
1596  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1597  set_op_copy_attr(op, be_copy_attr);
1598  set_op_tag(op, riscv_op_tag);
1599  op_riscv_sw = op;
1600  op = new_ir_op(cur_opcode + iro_riscv_switch, "riscv_switch", op_pin_state_pinned, irop_flag_cfopcode|irop_flag_forking, oparity_any, -1, sizeof(riscv_switch_attr_t));
1601  set_op_dump(op, riscv_dump_node);
1602  set_op_attrs_equal(op, riscv_switch_attrs_equal);
1603  set_op_copy_attr(op, be_copy_attr);
1604  set_op_tag(op, riscv_op_tag);
1605  op_riscv_switch = op;
1606  op = new_ir_op(cur_opcode + iro_riscv_xor, "riscv_xor", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_attr_t));
1607  set_op_dump(op, riscv_dump_node);
1608  set_op_attrs_equal(op, riscv_attrs_equal);
1609  set_op_copy_attr(op, be_copy_attr);
1610  set_op_tag(op, riscv_op_tag);
1611  op_riscv_xor = op;
1612  op = new_ir_op(cur_opcode + iro_riscv_xori, "riscv_xori", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(riscv_immediate_attr_t));
1613  set_op_dump(op, riscv_dump_node);
1614  set_op_attrs_equal(op, riscv_immediate_attrs_equal);
1615  set_op_copy_attr(op, be_copy_attr);
1616  set_op_tag(op, riscv_op_tag);
1617  op_riscv_xori = op;
1618 
1619 }
1620 
1621 void riscv_free_opcodes(void)
1622 {
1623  free_ir_op(op_riscv_add); op_riscv_add = NULL;
1624  free_ir_op(op_riscv_addi); op_riscv_addi = NULL;
1625  free_ir_op(op_riscv_and); op_riscv_and = NULL;
1626  free_ir_op(op_riscv_andi); op_riscv_andi = NULL;
1627  free_ir_op(op_riscv_bcc); op_riscv_bcc = NULL;
1628  free_ir_op(op_riscv_div); op_riscv_div = NULL;
1629  free_ir_op(op_riscv_divu); op_riscv_divu = NULL;
1630  free_ir_op(op_riscv_ijmp); op_riscv_ijmp = NULL;
1631  free_ir_op(op_riscv_j); op_riscv_j = NULL;
1632  free_ir_op(op_riscv_jal); op_riscv_jal = NULL;
1633  free_ir_op(op_riscv_jalr); op_riscv_jalr = NULL;
1634  free_ir_op(op_riscv_lb); op_riscv_lb = NULL;
1635  free_ir_op(op_riscv_lbu); op_riscv_lbu = NULL;
1636  free_ir_op(op_riscv_lh); op_riscv_lh = NULL;
1637  free_ir_op(op_riscv_lhu); op_riscv_lhu = NULL;
1638  free_ir_op(op_riscv_lui); op_riscv_lui = NULL;
1639  free_ir_op(op_riscv_lw); op_riscv_lw = NULL;
1640  free_ir_op(op_riscv_mul); op_riscv_mul = NULL;
1641  free_ir_op(op_riscv_mulh); op_riscv_mulh = NULL;
1642  free_ir_op(op_riscv_mulhu); op_riscv_mulhu = NULL;
1643  free_ir_op(op_riscv_or); op_riscv_or = NULL;
1644  free_ir_op(op_riscv_ori); op_riscv_ori = NULL;
1645  free_ir_op(op_riscv_rem); op_riscv_rem = NULL;
1646  free_ir_op(op_riscv_remu); op_riscv_remu = NULL;
1647  free_ir_op(op_riscv_ret); op_riscv_ret = NULL;
1648  free_ir_op(op_riscv_sb); op_riscv_sb = NULL;
1649  free_ir_op(op_riscv_sh); op_riscv_sh = NULL;
1650  free_ir_op(op_riscv_sll); op_riscv_sll = NULL;
1651  free_ir_op(op_riscv_slli); op_riscv_slli = NULL;
1652  free_ir_op(op_riscv_slt); op_riscv_slt = NULL;
1653  free_ir_op(op_riscv_sltiu); op_riscv_sltiu = NULL;
1654  free_ir_op(op_riscv_sltu); op_riscv_sltu = NULL;
1655  free_ir_op(op_riscv_sra); op_riscv_sra = NULL;
1656  free_ir_op(op_riscv_srai); op_riscv_srai = NULL;
1657  free_ir_op(op_riscv_srl); op_riscv_srl = NULL;
1658  free_ir_op(op_riscv_srli); op_riscv_srli = NULL;
1659  free_ir_op(op_riscv_sub); op_riscv_sub = NULL;
1660  free_ir_op(op_riscv_sw); op_riscv_sw = NULL;
1661  free_ir_op(op_riscv_switch); op_riscv_switch = NULL;
1662  free_ir_op(op_riscv_xor); op_riscv_xor = NULL;
1663  free_ir_op(op_riscv_xori); op_riscv_xori = NULL;
1664 
1665 }
set_op_dump
void set_op_dump(ir_op *op, dump_node_func func)
Sets dump callback func for operation op.
get_irn_generic_attr
void * get_irn_generic_attr(ir_node *node)
Returns a pointer to the node attributes.
mode_X
ir_mode * mode_X
execution
Definition: irmode.h:205
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_attrs_equal
void set_op_attrs_equal(ir_op *op, node_attrs_equal_func func)
Sets attrs_equal callback func for operation op.
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.
op_pin_state_floats
Nodes of this opcode can be placed in any basic block.
Definition: firm_types.h:202
ir_graph
struct ir_graph ir_graph
Procedure Graph.
Definition: firm_types.h:74
dbg_info
struct dbg_info dbg_info
Source Reference.
Definition: firm_types.h:40
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:187
irop_flag_forking
Forking control flow at this operation.
Definition: irop.h:48
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:44
get_irn_opcode
unsigned get_irn_opcode(const ir_node *node)
Returns the opcode-enum of the node.
ir_switch_table
struct ir_switch_table ir_switch_table
A switch table mapping integer numbers to proj-numbers of a Switch-node.
Definition: firm_types.h:105
ir_entity
struct ir_entity ir_entity
Entity.
Definition: firm_types.h:83
get_irn_irg
ir_graph * get_irn_irg(const ir_node *node)
Returns the ir_graph this node belongs to.
mode_M
ir_mode * mode_M
memory
Definition: irmode.h:178
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:204
get_irn_op
ir_op * get_irn_op(const ir_node *node)
Returns the opcode struct of the node.
ir_op_set_memory_index
void ir_op_set_memory_index(ir_op *op, int memory_index)
Sets memory input of operation using memory.
ir_op
struct ir_op ir_op
Node Opcode.
Definition: firm_types.h:56
optimize_node
ir_node * optimize_node(ir_node *n)
Applies local optimizations to a single node.
free_ir_op
void free_ir_op(ir_op *code)
Frees an ir operation.
op_pin_state_pinned
Nodes must remain in this basic block.
Definition: firm_types.h:203
irop_flag_unknown_jump
This operation jumps to an unknown destination.
Definition: irop.h:58
mode_T
ir_mode * mode_T
tuple (none)
Definition: irmode.h:208
irop_flag_none
Nothing.
Definition: irop.h:42
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.
set_op_copy_attr
void set_op_copy_attr(ir_op *op, copy_attr_func func)
Sets attribute copy callback func for operation op.
irop_flag_uses_memory
This operation has a memory input and may change the memory state.
Definition: irop.h:53
oparity_any
Any other arity, either fixed for the opcode or known when creating the node.
Definition: irop.h:36