libFirm
 All Data Structures Functions Variables Typedefs Enumerations Enumerator Groups Pages
gen_mips_new_nodes.c
1 #include "gen_mips_new_nodes.h"
2 
3 #include "benode.h"
4 #include "mips_bearch_t.h"
5 #include "gen_mips_regalloc_if.h"
6 #include "mips_new_nodes_t.h"
7 #include "fourcc.h"
8 #include "irgopt.h"
9 #include "ircons_t.h"
10 
11 ir_op *op_mips_addiu = NULL;
12 ir_op *op_mips_addu = NULL;
13 ir_op *op_mips_and = NULL;
14 ir_op *op_mips_andi = NULL;
15 ir_op *op_mips_b = NULL;
16 ir_op *op_mips_bcc = NULL;
17 ir_op *op_mips_div_hi = NULL;
18 ir_op *op_mips_div_lo = NULL;
19 ir_op *op_mips_divu_hi = NULL;
20 ir_op *op_mips_divu_lo = NULL;
21 ir_op *op_mips_ijmp = NULL;
22 ir_op *op_mips_jal = NULL;
23 ir_op *op_mips_jalr = NULL;
24 ir_op *op_mips_lb = NULL;
25 ir_op *op_mips_lbu = NULL;
26 ir_op *op_mips_lh = NULL;
27 ir_op *op_mips_lhu = NULL;
28 ir_op *op_mips_lui = NULL;
29 ir_op *op_mips_lw = NULL;
30 ir_op *op_mips_mult_hi = NULL;
31 ir_op *op_mips_mult_lo = NULL;
32 ir_op *op_mips_multu_hi = NULL;
33 ir_op *op_mips_nor = NULL;
34 ir_op *op_mips_or = NULL;
35 ir_op *op_mips_ori = NULL;
36 ir_op *op_mips_ret = NULL;
37 ir_op *op_mips_sb = NULL;
38 ir_op *op_mips_sh = NULL;
39 ir_op *op_mips_sll = NULL;
40 ir_op *op_mips_sllv = NULL;
41 ir_op *op_mips_slt = NULL;
42 ir_op *op_mips_sltiu = NULL;
43 ir_op *op_mips_sltu = NULL;
44 ir_op *op_mips_sra = NULL;
45 ir_op *op_mips_srav = NULL;
46 ir_op *op_mips_srl = NULL;
47 ir_op *op_mips_srlv = NULL;
48 ir_op *op_mips_subu = NULL;
49 ir_op *op_mips_sw = NULL;
50 ir_op *op_mips_switch = NULL;
51 ir_op *op_mips_xor = NULL;
52 ir_op *op_mips_xori = NULL;
53 
54 
55 static int mips_opcode_start = -1;
56 
58 #define mips_op_tag FOURCC('m', 'i', 'p', 's')
59 
61 int is_mips_op(const ir_op *op)
62 {
63  return get_op_tag(op) == mips_op_tag;
64 }
65 
67 int is_mips_irn(const ir_node *node)
68 {
69  return is_mips_op(get_irn_op(node));
70 }
71 
72 int get_mips_irn_opcode(const ir_node *node)
73 {
74  assert(is_mips_irn(node));
75  return get_irn_opcode(node) - mips_opcode_start;
76 }
77 
78 #undef BIT
79 #define BIT(x) (1 << (x))
80 
81 
82 
83 
84 ir_node *new_bd_mips_addiu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
85 {
86  static arch_register_req_t const *in_reqs[] = {
87  &mips_class_reg_req_gp,
88  };
89 
90  /* construct in array */
91  ir_node *const in[] = {
92  left,
93  };
94 
95  ir_graph *const irg = get_irn_irg(block);
96  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_addiu, mode_Iu, 1, in);
97 
98  /* init node attributes */
99 
100  /* flags */
101  arch_irn_flags_t irn_flags = arch_irn_flags_none;
102  irn_flags |= arch_irn_flag_rematerializable;
103  int const n_res = 1;
104  be_info_init_irn(res, irn_flags, in_reqs, n_res);
105  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
106  (void)attr; /* avoid potential warning */
107  attr->ent = ent;
108  attr->val = val;
109  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
110  out_infos[0].req = &mips_class_reg_req_gp;
111 
112  verify_new_node(res);
113  return optimize_node(res);
114 }
115 
116 ir_node *new_bd_mips_addu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
117 {
118  static arch_register_req_t const *in_reqs[] = {
119  &mips_class_reg_req_gp,
120  &mips_class_reg_req_gp,
121  };
122 
123  /* construct in array */
124  ir_node *const in[] = {
125  left,
126  right,
127  };
128 
129  ir_graph *const irg = get_irn_irg(block);
130  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_addu, mode_Iu, 2, in);
131 
132  /* init node attributes */
133 
134  /* flags */
135  arch_irn_flags_t irn_flags = arch_irn_flags_none;
136  irn_flags |= arch_irn_flag_rematerializable;
137  int const n_res = 1;
138  be_info_init_irn(res, irn_flags, in_reqs, n_res);
139  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
140  (void)attr; /* avoid potential warning */
141  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
142  out_infos[0].req = &mips_class_reg_req_gp;
143 
144  verify_new_node(res);
145  return optimize_node(res);
146 }
147 
148 ir_node *new_bd_mips_and(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
149 {
150  static arch_register_req_t const *in_reqs[] = {
151  &mips_class_reg_req_gp,
152  &mips_class_reg_req_gp,
153  };
154 
155  /* construct in array */
156  ir_node *const in[] = {
157  left,
158  right,
159  };
160 
161  ir_graph *const irg = get_irn_irg(block);
162  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_and, mode_Iu, 2, in);
163 
164  /* init node attributes */
165 
166  /* flags */
167  arch_irn_flags_t irn_flags = arch_irn_flags_none;
168  irn_flags |= arch_irn_flag_rematerializable;
169  int const n_res = 1;
170  be_info_init_irn(res, irn_flags, in_reqs, n_res);
171  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
172  (void)attr; /* avoid potential warning */
173  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
174  out_infos[0].req = &mips_class_reg_req_gp;
175 
176  verify_new_node(res);
177  return optimize_node(res);
178 }
179 
180 ir_node *new_bd_mips_andi(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
181 {
182  static arch_register_req_t const *in_reqs[] = {
183  &mips_class_reg_req_gp,
184  };
185 
186  /* construct in array */
187  ir_node *const in[] = {
188  left,
189  };
190 
191  ir_graph *const irg = get_irn_irg(block);
192  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_andi, mode_Iu, 1, in);
193 
194  /* init node attributes */
195 
196  /* flags */
197  arch_irn_flags_t irn_flags = arch_irn_flags_none;
198  irn_flags |= arch_irn_flag_rematerializable;
199  int const n_res = 1;
200  be_info_init_irn(res, irn_flags, in_reqs, n_res);
201  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
202  (void)attr; /* avoid potential warning */
203  attr->ent = ent;
204  attr->val = val;
205  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
206  out_infos[0].req = &mips_class_reg_req_gp;
207 
208  verify_new_node(res);
209  return optimize_node(res);
210 }
211 
212 ir_node *new_bd_mips_b(dbg_info *dbgi, ir_node *block)
213 {
214  arch_register_req_t const **const in_reqs = NULL;
215 
216 
217  ir_graph *const irg = get_irn_irg(block);
218  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_b, mode_X, 0, NULL);
219 
220  /* init node attributes */
221 
222  /* flags */
223  arch_irn_flags_t irn_flags = arch_irn_flags_none;
224  irn_flags |= arch_irn_flag_simple_jump;
225  irn_flags |= arch_irn_flag_fallthrough;
226  int const n_res = 1;
227  be_info_init_irn(res, irn_flags, in_reqs, n_res);
228  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
229  (void)attr; /* avoid potential warning */
230  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
231  out_infos[0].req = &arch_exec_requirement;
232 
233  verify_new_node(res);
234  return optimize_node(res);
235 }
236 
237 ir_node *new_bd_mips_bcc(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, mips_cond_t const cond)
238 {
239  static arch_register_req_t const *in_reqs[] = {
240  &mips_class_reg_req_gp,
241  &mips_class_reg_req_gp,
242  };
243 
244  /* construct in array */
245  ir_node *const in[] = {
246  left,
247  right,
248  };
249 
250  ir_graph *const irg = get_irn_irg(block);
251  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_bcc, mode_T, 2, in);
252 
253  /* init node attributes */
254 
255  /* flags */
256  arch_irn_flags_t irn_flags = arch_irn_flags_none;
257  irn_flags |= arch_irn_flag_fallthrough;
258  int const n_res = 2;
259  be_info_init_irn(res, irn_flags, in_reqs, n_res);
260  mips_cond_attr_t *const attr = (mips_cond_attr_t*)get_irn_generic_attr(res);
261  (void)attr; /* avoid potential warning */
262  attr->cond = cond;
263  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
264  out_infos[0].req = &arch_exec_requirement;
265  out_infos[1].req = &arch_exec_requirement;
266 
267  verify_new_node(res);
268  return optimize_node(res);
269 }
270 
271 ir_node *new_bd_mips_bcc_z(dbg_info *dbgi, ir_node *block, ir_node *left, mips_cond_t const cond)
272 {
273  static arch_register_req_t const *in_reqs[] = {
274  &mips_class_reg_req_gp,
275  };
276 
277  /* construct in array */
278  ir_node *const in[] = {
279  left,
280  };
281 
282  ir_graph *const irg = get_irn_irg(block);
283  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_bcc, mode_T, 1, in);
284 
285  /* init node attributes */
286 
287  /* flags */
288  arch_irn_flags_t irn_flags = arch_irn_flags_none;
289  irn_flags |= arch_irn_flag_fallthrough;
290  int const n_res = 2;
291  be_info_init_irn(res, irn_flags, in_reqs, n_res);
292  mips_cond_attr_t *const attr = (mips_cond_attr_t*)get_irn_generic_attr(res);
293  (void)attr; /* avoid potential warning */
294  attr->cond = cond;
295  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
296  out_infos[0].req = &arch_exec_requirement;
297  out_infos[1].req = &arch_exec_requirement;
298 
299  verify_new_node(res);
300  return optimize_node(res);
301 }
302 
303 ir_node *new_bd_mips_div_hi(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
304 {
305  static arch_register_req_t const *in_reqs[] = {
306  &mips_class_reg_req_gp,
307  &mips_class_reg_req_gp,
308  };
309 
310  /* construct in array */
311  ir_node *const in[] = {
312  left,
313  right,
314  };
315 
316  ir_graph *const irg = get_irn_irg(block);
317  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_div_hi, mode_Iu, 2, in);
318 
319  /* init node attributes */
320 
321  /* flags */
322  arch_irn_flags_t irn_flags = arch_irn_flags_none;
323  int const n_res = 1;
324  be_info_init_irn(res, irn_flags, in_reqs, n_res);
325  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
326  (void)attr; /* avoid potential warning */
327  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
328  out_infos[0].req = &mips_class_reg_req_gp;
329 
330  verify_new_node(res);
331  return optimize_node(res);
332 }
333 
334 ir_node *new_bd_mips_div_lo(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
335 {
336  static arch_register_req_t const *in_reqs[] = {
337  &mips_class_reg_req_gp,
338  &mips_class_reg_req_gp,
339  };
340 
341  /* construct in array */
342  ir_node *const in[] = {
343  left,
344  right,
345  };
346 
347  ir_graph *const irg = get_irn_irg(block);
348  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_div_lo, mode_Iu, 2, in);
349 
350  /* init node attributes */
351 
352  /* flags */
353  arch_irn_flags_t irn_flags = arch_irn_flags_none;
354  int const n_res = 1;
355  be_info_init_irn(res, irn_flags, in_reqs, n_res);
356  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
357  (void)attr; /* avoid potential warning */
358  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
359  out_infos[0].req = &mips_class_reg_req_gp;
360 
361  verify_new_node(res);
362  return optimize_node(res);
363 }
364 
365 ir_node *new_bd_mips_divu_hi(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
366 {
367  static arch_register_req_t const *in_reqs[] = {
368  &mips_class_reg_req_gp,
369  &mips_class_reg_req_gp,
370  };
371 
372  /* construct in array */
373  ir_node *const in[] = {
374  left,
375  right,
376  };
377 
378  ir_graph *const irg = get_irn_irg(block);
379  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_divu_hi, mode_Iu, 2, in);
380 
381  /* init node attributes */
382 
383  /* flags */
384  arch_irn_flags_t irn_flags = arch_irn_flags_none;
385  int const n_res = 1;
386  be_info_init_irn(res, irn_flags, in_reqs, n_res);
387  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
388  (void)attr; /* avoid potential warning */
389  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
390  out_infos[0].req = &mips_class_reg_req_gp;
391 
392  verify_new_node(res);
393  return optimize_node(res);
394 }
395 
396 ir_node *new_bd_mips_divu_lo(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
397 {
398  static arch_register_req_t const *in_reqs[] = {
399  &mips_class_reg_req_gp,
400  &mips_class_reg_req_gp,
401  };
402 
403  /* construct in array */
404  ir_node *const in[] = {
405  left,
406  right,
407  };
408 
409  ir_graph *const irg = get_irn_irg(block);
410  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_divu_lo, mode_Iu, 2, in);
411 
412  /* init node attributes */
413 
414  /* flags */
415  arch_irn_flags_t irn_flags = arch_irn_flags_none;
416  int const n_res = 1;
417  be_info_init_irn(res, irn_flags, in_reqs, n_res);
418  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
419  (void)attr; /* avoid potential warning */
420  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
421  out_infos[0].req = &mips_class_reg_req_gp;
422 
423  verify_new_node(res);
424  return optimize_node(res);
425 }
426 
427 ir_node *new_bd_mips_ijmp(dbg_info *dbgi, ir_node *block, ir_node *op0)
428 {
429  static arch_register_req_t const *in_reqs[] = {
430  &mips_class_reg_req_gp,
431  };
432 
433  /* construct in array */
434  ir_node *const in[] = {
435  op0,
436  };
437 
438  ir_graph *const irg = get_irn_irg(block);
439  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_ijmp, mode_X, 1, in);
440 
441  /* init node attributes */
442 
443  /* flags */
444  arch_irn_flags_t irn_flags = arch_irn_flags_none;
445  int const n_res = 1;
446  be_info_init_irn(res, irn_flags, in_reqs, n_res);
447  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
448  (void)attr; /* avoid potential warning */
449  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
450  out_infos[0].req = &arch_exec_requirement;
451 
452  verify_new_node(res);
453  return optimize_node(res);
454 }
455 
456 ir_node *new_bd_mips_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)
457 {
458 
459 
460  ir_graph *const irg = get_irn_irg(block);
461  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_jal, mode_T, arity, in);
462 
463  /* init node attributes */
464 
465  /* flags */
466  arch_irn_flags_t irn_flags = arch_irn_flags_none;
467  be_info_init_irn(res, irn_flags, in_reqs, n_res);
468  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
469  (void)attr; /* avoid potential warning */
470  attr->ent = ent;
471  attr->val = val;
472 
473  verify_new_node(res);
474  return optimize_node(res);
475 }
476 
477 ir_node *new_bd_mips_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)
478 {
479 
480 
481  ir_graph *const irg = get_irn_irg(block);
482  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_jalr, mode_T, arity, in);
483 
484  /* init node attributes */
485 
486  /* flags */
487  arch_irn_flags_t irn_flags = arch_irn_flags_none;
488  be_info_init_irn(res, irn_flags, in_reqs, n_res);
489  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
490  (void)attr; /* avoid potential warning */
491 
492  verify_new_node(res);
493  return optimize_node(res);
494 }
495 
496 ir_node *new_bd_mips_lb(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val)
497 {
498  static arch_register_req_t const *in_reqs[] = {
499  &arch_memory_requirement,
500  &mips_class_reg_req_gp,
501  };
502 
503  /* construct in array */
504  ir_node *const in[] = {
505  mem,
506  base,
507  };
508 
509  ir_graph *const irg = get_irn_irg(block);
510  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_lb, mode_T, 2, in);
511 
512  /* init node attributes */
513 
514  /* flags */
515  arch_irn_flags_t irn_flags = arch_irn_flags_none;
516  int const n_res = 2;
517  be_info_init_irn(res, irn_flags, in_reqs, n_res);
518  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
519  (void)attr; /* avoid potential warning */
520  attr->ent = ent;
521  attr->val = val;
522  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
523  out_infos[0].req = &arch_memory_requirement;
524  out_infos[1].req = &mips_class_reg_req_gp;
525 
526  verify_new_node(res);
527  return optimize_node(res);
528 }
529 
530 ir_node *new_bd_mips_lbu(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val)
531 {
532  static arch_register_req_t const *in_reqs[] = {
533  &arch_memory_requirement,
534  &mips_class_reg_req_gp,
535  };
536 
537  /* construct in array */
538  ir_node *const in[] = {
539  mem,
540  base,
541  };
542 
543  ir_graph *const irg = get_irn_irg(block);
544  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_lbu, mode_T, 2, in);
545 
546  /* init node attributes */
547 
548  /* flags */
549  arch_irn_flags_t irn_flags = arch_irn_flags_none;
550  int const n_res = 2;
551  be_info_init_irn(res, irn_flags, in_reqs, n_res);
552  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
553  (void)attr; /* avoid potential warning */
554  attr->ent = ent;
555  attr->val = val;
556  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
557  out_infos[0].req = &arch_memory_requirement;
558  out_infos[1].req = &mips_class_reg_req_gp;
559 
560  verify_new_node(res);
561  return optimize_node(res);
562 }
563 
564 ir_node *new_bd_mips_lh(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val)
565 {
566  static arch_register_req_t const *in_reqs[] = {
567  &arch_memory_requirement,
568  &mips_class_reg_req_gp,
569  };
570 
571  /* construct in array */
572  ir_node *const in[] = {
573  mem,
574  base,
575  };
576 
577  ir_graph *const irg = get_irn_irg(block);
578  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_lh, mode_T, 2, in);
579 
580  /* init node attributes */
581 
582  /* flags */
583  arch_irn_flags_t irn_flags = arch_irn_flags_none;
584  int const n_res = 2;
585  be_info_init_irn(res, irn_flags, in_reqs, n_res);
586  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
587  (void)attr; /* avoid potential warning */
588  attr->ent = ent;
589  attr->val = val;
590  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
591  out_infos[0].req = &arch_memory_requirement;
592  out_infos[1].req = &mips_class_reg_req_gp;
593 
594  verify_new_node(res);
595  return optimize_node(res);
596 }
597 
598 ir_node *new_bd_mips_lhu(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val)
599 {
600  static arch_register_req_t const *in_reqs[] = {
601  &arch_memory_requirement,
602  &mips_class_reg_req_gp,
603  };
604 
605  /* construct in array */
606  ir_node *const in[] = {
607  mem,
608  base,
609  };
610 
611  ir_graph *const irg = get_irn_irg(block);
612  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_lhu, mode_T, 2, in);
613 
614  /* init node attributes */
615 
616  /* flags */
617  arch_irn_flags_t irn_flags = arch_irn_flags_none;
618  int const n_res = 2;
619  be_info_init_irn(res, irn_flags, in_reqs, n_res);
620  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
621  (void)attr; /* avoid potential warning */
622  attr->ent = ent;
623  attr->val = val;
624  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
625  out_infos[0].req = &arch_memory_requirement;
626  out_infos[1].req = &mips_class_reg_req_gp;
627 
628  verify_new_node(res);
629  return optimize_node(res);
630 }
631 
632 ir_node *new_bd_mips_lui(dbg_info *dbgi, ir_node *block, ir_entity *const ent, int32_t const val)
633 {
634  static arch_register_req_t const *in_reqs[] = {
635  };
636 
637 
638  ir_graph *const irg = get_irn_irg(block);
639  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_lui, mode_Iu, 0, NULL);
640 
641  /* init node attributes */
642 
643  /* flags */
644  arch_irn_flags_t irn_flags = arch_irn_flags_none;
645  irn_flags |= arch_irn_flag_rematerializable;
646  int const n_res = 1;
647  be_info_init_irn(res, irn_flags, in_reqs, n_res);
648  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
649  (void)attr; /* avoid potential warning */
650  attr->ent = ent;
651  attr->val = val;
652  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
653  out_infos[0].req = &mips_class_reg_req_gp;
654 
655  verify_new_node(res);
656  return optimize_node(res);
657 }
658 
659 ir_node *new_bd_mips_lw(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_entity *const ent, int32_t const val)
660 {
661  static arch_register_req_t const *in_reqs[] = {
662  &arch_memory_requirement,
663  &mips_class_reg_req_gp,
664  };
665 
666  /* construct in array */
667  ir_node *const in[] = {
668  mem,
669  base,
670  };
671 
672  ir_graph *const irg = get_irn_irg(block);
673  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_lw, mode_T, 2, in);
674 
675  /* init node attributes */
676 
677  /* flags */
678  arch_irn_flags_t irn_flags = arch_irn_flags_none;
679  int const n_res = 2;
680  be_info_init_irn(res, irn_flags, in_reqs, n_res);
681  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
682  (void)attr; /* avoid potential warning */
683  attr->ent = ent;
684  attr->val = val;
685  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
686  out_infos[0].req = &arch_memory_requirement;
687  out_infos[1].req = &mips_class_reg_req_gp;
688 
689  verify_new_node(res);
690  return optimize_node(res);
691 }
692 
693 ir_node *new_bd_mips_mult_hi(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
694 {
695  static arch_register_req_t const *in_reqs[] = {
696  &mips_class_reg_req_gp,
697  &mips_class_reg_req_gp,
698  };
699 
700  /* construct in array */
701  ir_node *const in[] = {
702  left,
703  right,
704  };
705 
706  ir_graph *const irg = get_irn_irg(block);
707  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_mult_hi, mode_Iu, 2, in);
708 
709  /* init node attributes */
710 
711  /* flags */
712  arch_irn_flags_t irn_flags = arch_irn_flags_none;
713  irn_flags |= arch_irn_flag_rematerializable;
714  int const n_res = 1;
715  be_info_init_irn(res, irn_flags, in_reqs, n_res);
716  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
717  (void)attr; /* avoid potential warning */
718  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
719  out_infos[0].req = &mips_class_reg_req_gp;
720 
721  verify_new_node(res);
722  return optimize_node(res);
723 }
724 
725 ir_node *new_bd_mips_mult_lo(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
726 {
727  static arch_register_req_t const *in_reqs[] = {
728  &mips_class_reg_req_gp,
729  &mips_class_reg_req_gp,
730  };
731 
732  /* construct in array */
733  ir_node *const in[] = {
734  left,
735  right,
736  };
737 
738  ir_graph *const irg = get_irn_irg(block);
739  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_mult_lo, mode_Iu, 2, 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  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
749  (void)attr; /* avoid potential warning */
750  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
751  out_infos[0].req = &mips_class_reg_req_gp;
752 
753  verify_new_node(res);
754  return optimize_node(res);
755 }
756 
757 ir_node *new_bd_mips_multu_hi(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
758 {
759  static arch_register_req_t const *in_reqs[] = {
760  &mips_class_reg_req_gp,
761  &mips_class_reg_req_gp,
762  };
763 
764  /* construct in array */
765  ir_node *const in[] = {
766  left,
767  right,
768  };
769 
770  ir_graph *const irg = get_irn_irg(block);
771  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_multu_hi, mode_Iu, 2, in);
772 
773  /* init node attributes */
774 
775  /* flags */
776  arch_irn_flags_t irn_flags = arch_irn_flags_none;
777  irn_flags |= arch_irn_flag_rematerializable;
778  int const n_res = 1;
779  be_info_init_irn(res, irn_flags, in_reqs, n_res);
780  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
781  (void)attr; /* avoid potential warning */
782  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
783  out_infos[0].req = &mips_class_reg_req_gp;
784 
785  verify_new_node(res);
786  return optimize_node(res);
787 }
788 
789 ir_node *new_bd_mips_nor(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
790 {
791  static arch_register_req_t const *in_reqs[] = {
792  &mips_class_reg_req_gp,
793  &mips_class_reg_req_gp,
794  };
795 
796  /* construct in array */
797  ir_node *const in[] = {
798  left,
799  right,
800  };
801 
802  ir_graph *const irg = get_irn_irg(block);
803  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_nor, mode_Iu, 2, in);
804 
805  /* init node attributes */
806 
807  /* flags */
808  arch_irn_flags_t irn_flags = arch_irn_flags_none;
809  irn_flags |= arch_irn_flag_rematerializable;
810  int const n_res = 1;
811  be_info_init_irn(res, irn_flags, in_reqs, n_res);
812  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
813  (void)attr; /* avoid potential warning */
814  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
815  out_infos[0].req = &mips_class_reg_req_gp;
816 
817  verify_new_node(res);
818  return optimize_node(res);
819 }
820 
821 ir_node *new_bd_mips_or(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
822 {
823  static arch_register_req_t const *in_reqs[] = {
824  &mips_class_reg_req_gp,
825  &mips_class_reg_req_gp,
826  };
827 
828  /* construct in array */
829  ir_node *const in[] = {
830  left,
831  right,
832  };
833 
834  ir_graph *const irg = get_irn_irg(block);
835  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_or, mode_Iu, 2, in);
836 
837  /* init node attributes */
838 
839  /* flags */
840  arch_irn_flags_t irn_flags = arch_irn_flags_none;
841  irn_flags |= arch_irn_flag_rematerializable;
842  int const n_res = 1;
843  be_info_init_irn(res, irn_flags, in_reqs, n_res);
844  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
845  (void)attr; /* avoid potential warning */
846  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
847  out_infos[0].req = &mips_class_reg_req_gp;
848 
849  verify_new_node(res);
850  return optimize_node(res);
851 }
852 
853 ir_node *new_bd_mips_ori(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
854 {
855  static arch_register_req_t const *in_reqs[] = {
856  &mips_class_reg_req_gp,
857  };
858 
859  /* construct in array */
860  ir_node *const in[] = {
861  left,
862  };
863 
864  ir_graph *const irg = get_irn_irg(block);
865  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_ori, mode_Iu, 1, in);
866 
867  /* init node attributes */
868 
869  /* flags */
870  arch_irn_flags_t irn_flags = arch_irn_flags_none;
871  irn_flags |= arch_irn_flag_rematerializable;
872  int const n_res = 1;
873  be_info_init_irn(res, irn_flags, in_reqs, n_res);
874  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
875  (void)attr; /* avoid potential warning */
876  attr->ent = ent;
877  attr->val = val;
878  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
879  out_infos[0].req = &mips_class_reg_req_gp;
880 
881  verify_new_node(res);
882  return optimize_node(res);
883 }
884 
885 ir_node *new_bd_mips_ret(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs)
886 {
887 
888 
889  ir_graph *const irg = get_irn_irg(block);
890  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_ret, mode_X, arity, in);
891 
892  /* init node attributes */
893 
894  /* flags */
895  arch_irn_flags_t irn_flags = arch_irn_flags_none;
896  int const n_res = 1;
897  be_info_init_irn(res, irn_flags, in_reqs, n_res);
898  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
899  (void)attr; /* avoid potential warning */
900  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
901  out_infos[0].req = &arch_exec_requirement;
902 
903  verify_new_node(res);
904  return optimize_node(res);
905 }
906 
907 ir_node *new_bd_mips_sb(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_node *value, ir_entity *const ent, int32_t const val)
908 {
909  static arch_register_req_t const *in_reqs[] = {
910  &arch_memory_requirement,
911  &mips_class_reg_req_gp,
912  &mips_class_reg_req_gp,
913  };
914 
915  /* construct in array */
916  ir_node *const in[] = {
917  mem,
918  base,
919  value,
920  };
921 
922  ir_graph *const irg = get_irn_irg(block);
923  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_sb, mode_M, 3, in);
924 
925  /* init node attributes */
926 
927  /* flags */
928  arch_irn_flags_t irn_flags = arch_irn_flags_none;
929  int const n_res = 1;
930  be_info_init_irn(res, irn_flags, in_reqs, n_res);
931  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
932  (void)attr; /* avoid potential warning */
933  attr->ent = ent;
934  attr->val = val;
935  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
936  out_infos[0].req = &arch_memory_requirement;
937 
938  verify_new_node(res);
939  return optimize_node(res);
940 }
941 
942 ir_node *new_bd_mips_sh(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_node *value, ir_entity *const ent, int32_t const val)
943 {
944  static arch_register_req_t const *in_reqs[] = {
945  &arch_memory_requirement,
946  &mips_class_reg_req_gp,
947  &mips_class_reg_req_gp,
948  };
949 
950  /* construct in array */
951  ir_node *const in[] = {
952  mem,
953  base,
954  value,
955  };
956 
957  ir_graph *const irg = get_irn_irg(block);
958  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_sh, mode_M, 3, in);
959 
960  /* init node attributes */
961 
962  /* flags */
963  arch_irn_flags_t irn_flags = arch_irn_flags_none;
964  int const n_res = 1;
965  be_info_init_irn(res, irn_flags, in_reqs, n_res);
966  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
967  (void)attr; /* avoid potential warning */
968  attr->ent = ent;
969  attr->val = val;
970  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
971  out_infos[0].req = &arch_memory_requirement;
972 
973  verify_new_node(res);
974  return optimize_node(res);
975 }
976 
977 ir_node *new_bd_mips_sll(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
978 {
979  static arch_register_req_t const *in_reqs[] = {
980  &mips_class_reg_req_gp,
981  };
982 
983  /* construct in array */
984  ir_node *const in[] = {
985  left,
986  };
987 
988  ir_graph *const irg = get_irn_irg(block);
989  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_sll, mode_Iu, 1, in);
990 
991  /* init node attributes */
992 
993  /* flags */
994  arch_irn_flags_t irn_flags = arch_irn_flags_none;
995  irn_flags |= arch_irn_flag_rematerializable;
996  int const n_res = 1;
997  be_info_init_irn(res, irn_flags, in_reqs, n_res);
998  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
999  (void)attr; /* avoid potential warning */
1000  attr->ent = ent;
1001  attr->val = val;
1002  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1003  out_infos[0].req = &mips_class_reg_req_gp;
1004 
1005  verify_new_node(res);
1006  return optimize_node(res);
1007 }
1008 
1009 ir_node *new_bd_mips_sllv(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1010 {
1011  static arch_register_req_t const *in_reqs[] = {
1012  &mips_class_reg_req_gp,
1013  &mips_class_reg_req_gp,
1014  };
1015 
1016  /* construct in array */
1017  ir_node *const in[] = {
1018  left,
1019  right,
1020  };
1021 
1022  ir_graph *const irg = get_irn_irg(block);
1023  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_sllv, mode_Iu, 2, 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  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
1033  (void)attr; /* avoid potential warning */
1034  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1035  out_infos[0].req = &mips_class_reg_req_gp;
1036 
1037  verify_new_node(res);
1038  return optimize_node(res);
1039 }
1040 
1041 ir_node *new_bd_mips_slt(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1042 {
1043  static arch_register_req_t const *in_reqs[] = {
1044  &mips_class_reg_req_gp,
1045  &mips_class_reg_req_gp,
1046  };
1047 
1048  /* construct in array */
1049  ir_node *const in[] = {
1050  left,
1051  right,
1052  };
1053 
1054  ir_graph *const irg = get_irn_irg(block);
1055  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_slt, mode_Iu, 2, in);
1056 
1057  /* init node attributes */
1058 
1059  /* flags */
1060  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1061  irn_flags |= arch_irn_flag_rematerializable;
1062  int const n_res = 1;
1063  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1064  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
1065  (void)attr; /* avoid potential warning */
1066  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1067  out_infos[0].req = &mips_class_reg_req_gp;
1068 
1069  verify_new_node(res);
1070  return optimize_node(res);
1071 }
1072 
1073 ir_node *new_bd_mips_sltiu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
1074 {
1075  static arch_register_req_t const *in_reqs[] = {
1076  &mips_class_reg_req_gp,
1077  };
1078 
1079  /* construct in array */
1080  ir_node *const in[] = {
1081  left,
1082  };
1083 
1084  ir_graph *const irg = get_irn_irg(block);
1085  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_sltiu, mode_Iu, 1, in);
1086 
1087  /* init node attributes */
1088 
1089  /* flags */
1090  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1091  irn_flags |= arch_irn_flag_rematerializable;
1092  int const n_res = 1;
1093  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1094  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
1095  (void)attr; /* avoid potential warning */
1096  attr->ent = ent;
1097  attr->val = val;
1098  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1099  out_infos[0].req = &mips_class_reg_req_gp;
1100 
1101  verify_new_node(res);
1102  return optimize_node(res);
1103 }
1104 
1105 ir_node *new_bd_mips_sltu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1106 {
1107  static arch_register_req_t const *in_reqs[] = {
1108  &mips_class_reg_req_gp,
1109  &mips_class_reg_req_gp,
1110  };
1111 
1112  /* construct in array */
1113  ir_node *const in[] = {
1114  left,
1115  right,
1116  };
1117 
1118  ir_graph *const irg = get_irn_irg(block);
1119  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_sltu, mode_Iu, 2, 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  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
1129  (void)attr; /* avoid potential warning */
1130  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1131  out_infos[0].req = &mips_class_reg_req_gp;
1132 
1133  verify_new_node(res);
1134  return optimize_node(res);
1135 }
1136 
1137 ir_node *new_bd_mips_sra(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
1138 {
1139  static arch_register_req_t const *in_reqs[] = {
1140  &mips_class_reg_req_gp,
1141  };
1142 
1143  /* construct in array */
1144  ir_node *const in[] = {
1145  left,
1146  };
1147 
1148  ir_graph *const irg = get_irn_irg(block);
1149  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_sra, mode_Iu, 1, in);
1150 
1151  /* init node attributes */
1152 
1153  /* flags */
1154  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1155  irn_flags |= arch_irn_flag_rematerializable;
1156  int const n_res = 1;
1157  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1158  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
1159  (void)attr; /* avoid potential warning */
1160  attr->ent = ent;
1161  attr->val = val;
1162  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1163  out_infos[0].req = &mips_class_reg_req_gp;
1164 
1165  verify_new_node(res);
1166  return optimize_node(res);
1167 }
1168 
1169 ir_node *new_bd_mips_srav(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1170 {
1171  static arch_register_req_t const *in_reqs[] = {
1172  &mips_class_reg_req_gp,
1173  &mips_class_reg_req_gp,
1174  };
1175 
1176  /* construct in array */
1177  ir_node *const in[] = {
1178  left,
1179  right,
1180  };
1181 
1182  ir_graph *const irg = get_irn_irg(block);
1183  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_srav, mode_Iu, 2, 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  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
1193  (void)attr; /* avoid potential warning */
1194  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1195  out_infos[0].req = &mips_class_reg_req_gp;
1196 
1197  verify_new_node(res);
1198  return optimize_node(res);
1199 }
1200 
1201 ir_node *new_bd_mips_srl(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
1202 {
1203  static arch_register_req_t const *in_reqs[] = {
1204  &mips_class_reg_req_gp,
1205  };
1206 
1207  /* construct in array */
1208  ir_node *const in[] = {
1209  left,
1210  };
1211 
1212  ir_graph *const irg = get_irn_irg(block);
1213  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_srl, mode_Iu, 1, in);
1214 
1215  /* init node attributes */
1216 
1217  /* flags */
1218  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1219  irn_flags |= arch_irn_flag_rematerializable;
1220  int const n_res = 1;
1221  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1222  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
1223  (void)attr; /* avoid potential warning */
1224  attr->ent = ent;
1225  attr->val = val;
1226  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1227  out_infos[0].req = &mips_class_reg_req_gp;
1228 
1229  verify_new_node(res);
1230  return optimize_node(res);
1231 }
1232 
1233 ir_node *new_bd_mips_srlv(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1234 {
1235  static arch_register_req_t const *in_reqs[] = {
1236  &mips_class_reg_req_gp,
1237  &mips_class_reg_req_gp,
1238  };
1239 
1240  /* construct in array */
1241  ir_node *const in[] = {
1242  left,
1243  right,
1244  };
1245 
1246  ir_graph *const irg = get_irn_irg(block);
1247  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_srlv, mode_Iu, 2, in);
1248 
1249  /* init node attributes */
1250 
1251  /* flags */
1252  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1253  irn_flags |= arch_irn_flag_rematerializable;
1254  int const n_res = 1;
1255  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1256  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
1257  (void)attr; /* avoid potential warning */
1258  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1259  out_infos[0].req = &mips_class_reg_req_gp;
1260 
1261  verify_new_node(res);
1262  return optimize_node(res);
1263 }
1264 
1265 ir_node *new_bd_mips_subu(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1266 {
1267  static arch_register_req_t const *in_reqs[] = {
1268  &mips_class_reg_req_gp,
1269  &mips_class_reg_req_gp,
1270  };
1271 
1272  /* construct in array */
1273  ir_node *const in[] = {
1274  left,
1275  right,
1276  };
1277 
1278  ir_graph *const irg = get_irn_irg(block);
1279  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_subu, mode_Iu, 2, in);
1280 
1281  /* init node attributes */
1282 
1283  /* flags */
1284  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1285  irn_flags |= arch_irn_flag_rematerializable;
1286  int const n_res = 1;
1287  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1288  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
1289  (void)attr; /* avoid potential warning */
1290  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1291  out_infos[0].req = &mips_class_reg_req_gp;
1292 
1293  verify_new_node(res);
1294  return optimize_node(res);
1295 }
1296 
1297 ir_node *new_bd_mips_sw(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *base, ir_node *value, ir_entity *const ent, int32_t const val)
1298 {
1299  static arch_register_req_t const *in_reqs[] = {
1300  &arch_memory_requirement,
1301  &mips_class_reg_req_gp,
1302  &mips_class_reg_req_gp,
1303  };
1304 
1305  /* construct in array */
1306  ir_node *const in[] = {
1307  mem,
1308  base,
1309  value,
1310  };
1311 
1312  ir_graph *const irg = get_irn_irg(block);
1313  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_sw, mode_M, 3, in);
1314 
1315  /* init node attributes */
1316 
1317  /* flags */
1318  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1319  int const n_res = 1;
1320  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1321  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
1322  (void)attr; /* avoid potential warning */
1323  attr->ent = ent;
1324  attr->val = val;
1325  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1326  out_infos[0].req = &arch_memory_requirement;
1327 
1328  verify_new_node(res);
1329  return optimize_node(res);
1330 }
1331 
1332 ir_node *new_bd_mips_switch(dbg_info *dbgi, ir_node *block, ir_node *op0, int n_res, const ir_switch_table *table, ir_entity *table_entity)
1333 {
1334  static arch_register_req_t const *in_reqs[] = {
1335  &mips_class_reg_req_gp,
1336  };
1337 
1338  /* construct in array */
1339  ir_node *const in[] = {
1340  op0,
1341  };
1342 
1343  ir_graph *const irg = get_irn_irg(block);
1344  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_switch, mode_T, 1, in);
1345 
1346  /* init node attributes */
1347 
1348  /* flags */
1349  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1350  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1351  mips_switch_attr_t *const attr = (mips_switch_attr_t*)get_irn_generic_attr(res);
1352  (void)attr; /* avoid potential warning */
1353  be_switch_attr_init(res, &attr->swtch, table, table_entity);
1354 
1355  verify_new_node(res);
1356  return optimize_node(res);
1357 }
1358 
1359 ir_node *new_bd_mips_xor(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1360 {
1361  static arch_register_req_t const *in_reqs[] = {
1362  &mips_class_reg_req_gp,
1363  &mips_class_reg_req_gp,
1364  };
1365 
1366  /* construct in array */
1367  ir_node *const in[] = {
1368  left,
1369  right,
1370  };
1371 
1372  ir_graph *const irg = get_irn_irg(block);
1373  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_xor, mode_Iu, 2, in);
1374 
1375  /* init node attributes */
1376 
1377  /* flags */
1378  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1379  irn_flags |= arch_irn_flag_rematerializable;
1380  int const n_res = 1;
1381  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1382  mips_attr_t *const attr = (mips_attr_t*)get_irn_generic_attr(res);
1383  (void)attr; /* avoid potential warning */
1384  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1385  out_infos[0].req = &mips_class_reg_req_gp;
1386 
1387  verify_new_node(res);
1388  return optimize_node(res);
1389 }
1390 
1391 ir_node *new_bd_mips_xori(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *const ent, int32_t const val)
1392 {
1393  static arch_register_req_t const *in_reqs[] = {
1394  &mips_class_reg_req_gp,
1395  };
1396 
1397  /* construct in array */
1398  ir_node *const in[] = {
1399  left,
1400  };
1401 
1402  ir_graph *const irg = get_irn_irg(block);
1403  ir_node *const res = new_ir_node(dbgi, irg, block, op_mips_xori, mode_Iu, 1, in);
1404 
1405  /* init node attributes */
1406 
1407  /* flags */
1408  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1409  irn_flags |= arch_irn_flag_rematerializable;
1410  int const n_res = 1;
1411  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1412  mips_immediate_attr_t *const attr = (mips_immediate_attr_t*)get_irn_generic_attr(res);
1413  (void)attr; /* avoid potential warning */
1414  attr->ent = ent;
1415  attr->val = val;
1416  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1417  out_infos[0].req = &mips_class_reg_req_gp;
1418 
1419  verify_new_node(res);
1420  return optimize_node(res);
1421 }
1422 
1423 
1428 void mips_create_opcodes(void)
1429 {
1430  ir_op *op;
1431  int cur_opcode = get_next_ir_opcodes(iro_mips_last);
1432 
1433  mips_opcode_start = cur_opcode;
1434  op = new_ir_op(cur_opcode + iro_mips_addiu, "mips_addiu", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_immediate_attr_t));
1435  set_op_dump(op, mips_dump_node);
1436  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1437  set_op_copy_attr(op, be_copy_attr);
1438  set_op_tag(op, mips_op_tag);
1439  op_mips_addiu = op;
1440  op = new_ir_op(cur_opcode + iro_mips_addu, "mips_addu", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1441  set_op_dump(op, mips_dump_node);
1442  set_op_attrs_equal(op, mips_attrs_equal);
1443  set_op_copy_attr(op, be_copy_attr);
1444  set_op_tag(op, mips_op_tag);
1445  op_mips_addu = op;
1446  op = new_ir_op(cur_opcode + iro_mips_and, "mips_and", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1447  set_op_dump(op, mips_dump_node);
1448  set_op_attrs_equal(op, mips_attrs_equal);
1449  set_op_copy_attr(op, be_copy_attr);
1450  set_op_tag(op, mips_op_tag);
1451  op_mips_and = op;
1452  op = new_ir_op(cur_opcode + iro_mips_andi, "mips_andi", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_immediate_attr_t));
1453  set_op_dump(op, mips_dump_node);
1454  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1455  set_op_copy_attr(op, be_copy_attr);
1456  set_op_tag(op, mips_op_tag);
1457  op_mips_andi = op;
1458  op = new_ir_op(cur_opcode + iro_mips_b, "mips_b", op_pin_state_pinned, irop_flag_cfopcode, oparity_any, -1, sizeof(mips_attr_t));
1459  set_op_dump(op, mips_dump_node);
1460  set_op_attrs_equal(op, mips_attrs_equal);
1461  set_op_copy_attr(op, be_copy_attr);
1462  set_op_tag(op, mips_op_tag);
1463  op_mips_b = op;
1464  op = new_ir_op(cur_opcode + iro_mips_bcc, "mips_bcc", op_pin_state_pinned, irop_flag_cfopcode|irop_flag_forking, oparity_any, -1, sizeof(mips_cond_attr_t));
1465  set_op_dump(op, mips_dump_node);
1466  set_op_attrs_equal(op, mips_cond_attrs_equal);
1467  set_op_copy_attr(op, be_copy_attr);
1468  set_op_tag(op, mips_op_tag);
1469  op_mips_bcc = op;
1470  op = new_ir_op(cur_opcode + iro_mips_div_hi, "mips_div_hi", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1471  set_op_dump(op, mips_dump_node);
1472  set_op_attrs_equal(op, mips_attrs_equal);
1473  set_op_copy_attr(op, be_copy_attr);
1474  set_op_tag(op, mips_op_tag);
1475  op_mips_div_hi = op;
1476  op = new_ir_op(cur_opcode + iro_mips_div_lo, "mips_div_lo", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1477  set_op_dump(op, mips_dump_node);
1478  set_op_attrs_equal(op, mips_attrs_equal);
1479  set_op_copy_attr(op, be_copy_attr);
1480  set_op_tag(op, mips_op_tag);
1481  op_mips_div_lo = op;
1482  op = new_ir_op(cur_opcode + iro_mips_divu_hi, "mips_divu_hi", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1483  set_op_dump(op, mips_dump_node);
1484  set_op_attrs_equal(op, mips_attrs_equal);
1485  set_op_copy_attr(op, be_copy_attr);
1486  set_op_tag(op, mips_op_tag);
1487  op_mips_divu_hi = op;
1488  op = new_ir_op(cur_opcode + iro_mips_divu_lo, "mips_divu_lo", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1489  set_op_dump(op, mips_dump_node);
1490  set_op_attrs_equal(op, mips_attrs_equal);
1491  set_op_copy_attr(op, be_copy_attr);
1492  set_op_tag(op, mips_op_tag);
1493  op_mips_divu_lo = op;
1494  op = new_ir_op(cur_opcode + iro_mips_ijmp, "mips_ijmp", op_pin_state_pinned, irop_flag_cfopcode|irop_flag_unknown_jump, oparity_any, -1, sizeof(mips_attr_t));
1495  set_op_dump(op, mips_dump_node);
1496  set_op_attrs_equal(op, mips_attrs_equal);
1497  set_op_copy_attr(op, be_copy_attr);
1498  set_op_tag(op, mips_op_tag);
1499  op_mips_ijmp = op;
1500  op = new_ir_op(cur_opcode + iro_mips_jal, "mips_jal", op_pin_state_exc_pinned, irop_flag_none, oparity_any, -1, sizeof(mips_immediate_attr_t));
1501  set_op_dump(op, mips_dump_node);
1502  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1503  set_op_copy_attr(op, be_copy_attr);
1504  set_op_tag(op, mips_op_tag);
1505  op_mips_jal = op;
1506  op = new_ir_op(cur_opcode + iro_mips_jalr, "mips_jalr", op_pin_state_exc_pinned, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1507  set_op_dump(op, mips_dump_node);
1508  set_op_attrs_equal(op, mips_attrs_equal);
1509  set_op_copy_attr(op, be_copy_attr);
1510  set_op_tag(op, mips_op_tag);
1511  op_mips_jalr = op;
1512  op = new_ir_op(cur_opcode + iro_mips_lb, "mips_lb", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(mips_immediate_attr_t));
1513  ir_op_set_memory_index(op, 0); set_op_dump(op, mips_dump_node);
1514  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1515  set_op_copy_attr(op, be_copy_attr);
1516  set_op_tag(op, mips_op_tag);
1517  op_mips_lb = op;
1518  op = new_ir_op(cur_opcode + iro_mips_lbu, "mips_lbu", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(mips_immediate_attr_t));
1519  ir_op_set_memory_index(op, 0); set_op_dump(op, mips_dump_node);
1520  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1521  set_op_copy_attr(op, be_copy_attr);
1522  set_op_tag(op, mips_op_tag);
1523  op_mips_lbu = op;
1524  op = new_ir_op(cur_opcode + iro_mips_lh, "mips_lh", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(mips_immediate_attr_t));
1525  ir_op_set_memory_index(op, 0); set_op_dump(op, mips_dump_node);
1526  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1527  set_op_copy_attr(op, be_copy_attr);
1528  set_op_tag(op, mips_op_tag);
1529  op_mips_lh = op;
1530  op = new_ir_op(cur_opcode + iro_mips_lhu, "mips_lhu", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(mips_immediate_attr_t));
1531  ir_op_set_memory_index(op, 0); set_op_dump(op, mips_dump_node);
1532  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1533  set_op_copy_attr(op, be_copy_attr);
1534  set_op_tag(op, mips_op_tag);
1535  op_mips_lhu = op;
1536  op = new_ir_op(cur_opcode + iro_mips_lui, "mips_lui", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_immediate_attr_t));
1537  set_op_dump(op, mips_dump_node);
1538  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1539  set_op_copy_attr(op, be_copy_attr);
1540  set_op_tag(op, mips_op_tag);
1541  op_mips_lui = op;
1542  op = new_ir_op(cur_opcode + iro_mips_lw, "mips_lw", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(mips_immediate_attr_t));
1543  ir_op_set_memory_index(op, 0); set_op_dump(op, mips_dump_node);
1544  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1545  set_op_copy_attr(op, be_copy_attr);
1546  set_op_tag(op, mips_op_tag);
1547  op_mips_lw = op;
1548  op = new_ir_op(cur_opcode + iro_mips_mult_hi, "mips_mult_hi", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1549  set_op_dump(op, mips_dump_node);
1550  set_op_attrs_equal(op, mips_attrs_equal);
1551  set_op_copy_attr(op, be_copy_attr);
1552  set_op_tag(op, mips_op_tag);
1553  op_mips_mult_hi = op;
1554  op = new_ir_op(cur_opcode + iro_mips_mult_lo, "mips_mult_lo", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1555  set_op_dump(op, mips_dump_node);
1556  set_op_attrs_equal(op, mips_attrs_equal);
1557  set_op_copy_attr(op, be_copy_attr);
1558  set_op_tag(op, mips_op_tag);
1559  op_mips_mult_lo = op;
1560  op = new_ir_op(cur_opcode + iro_mips_multu_hi, "mips_multu_hi", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1561  set_op_dump(op, mips_dump_node);
1562  set_op_attrs_equal(op, mips_attrs_equal);
1563  set_op_copy_attr(op, be_copy_attr);
1564  set_op_tag(op, mips_op_tag);
1565  op_mips_multu_hi = op;
1566  op = new_ir_op(cur_opcode + iro_mips_nor, "mips_nor", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1567  set_op_dump(op, mips_dump_node);
1568  set_op_attrs_equal(op, mips_attrs_equal);
1569  set_op_copy_attr(op, be_copy_attr);
1570  set_op_tag(op, mips_op_tag);
1571  op_mips_nor = op;
1572  op = new_ir_op(cur_opcode + iro_mips_or, "mips_or", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1573  set_op_dump(op, mips_dump_node);
1574  set_op_attrs_equal(op, mips_attrs_equal);
1575  set_op_copy_attr(op, be_copy_attr);
1576  set_op_tag(op, mips_op_tag);
1577  op_mips_or = op;
1578  op = new_ir_op(cur_opcode + iro_mips_ori, "mips_ori", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_immediate_attr_t));
1579  set_op_dump(op, mips_dump_node);
1580  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1581  set_op_copy_attr(op, be_copy_attr);
1582  set_op_tag(op, mips_op_tag);
1583  op_mips_ori = op;
1584  op = new_ir_op(cur_opcode + iro_mips_ret, "mips_ret", op_pin_state_pinned, irop_flag_cfopcode, oparity_any, -1, sizeof(mips_attr_t));
1585  set_op_dump(op, mips_dump_node);
1586  set_op_attrs_equal(op, mips_attrs_equal);
1587  set_op_copy_attr(op, be_copy_attr);
1588  set_op_tag(op, mips_op_tag);
1589  op_mips_ret = op;
1590  op = new_ir_op(cur_opcode + iro_mips_sb, "mips_sb", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(mips_immediate_attr_t));
1591  ir_op_set_memory_index(op, 0); set_op_dump(op, mips_dump_node);
1592  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1593  set_op_copy_attr(op, be_copy_attr);
1594  set_op_tag(op, mips_op_tag);
1595  op_mips_sb = op;
1596  op = new_ir_op(cur_opcode + iro_mips_sh, "mips_sh", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(mips_immediate_attr_t));
1597  ir_op_set_memory_index(op, 0); set_op_dump(op, mips_dump_node);
1598  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1599  set_op_copy_attr(op, be_copy_attr);
1600  set_op_tag(op, mips_op_tag);
1601  op_mips_sh = op;
1602  op = new_ir_op(cur_opcode + iro_mips_sll, "mips_sll", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_immediate_attr_t));
1603  set_op_dump(op, mips_dump_node);
1604  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1605  set_op_copy_attr(op, be_copy_attr);
1606  set_op_tag(op, mips_op_tag);
1607  op_mips_sll = op;
1608  op = new_ir_op(cur_opcode + iro_mips_sllv, "mips_sllv", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1609  set_op_dump(op, mips_dump_node);
1610  set_op_attrs_equal(op, mips_attrs_equal);
1611  set_op_copy_attr(op, be_copy_attr);
1612  set_op_tag(op, mips_op_tag);
1613  op_mips_sllv = op;
1614  op = new_ir_op(cur_opcode + iro_mips_slt, "mips_slt", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1615  set_op_dump(op, mips_dump_node);
1616  set_op_attrs_equal(op, mips_attrs_equal);
1617  set_op_copy_attr(op, be_copy_attr);
1618  set_op_tag(op, mips_op_tag);
1619  op_mips_slt = op;
1620  op = new_ir_op(cur_opcode + iro_mips_sltiu, "mips_sltiu", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_immediate_attr_t));
1621  set_op_dump(op, mips_dump_node);
1622  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1623  set_op_copy_attr(op, be_copy_attr);
1624  set_op_tag(op, mips_op_tag);
1625  op_mips_sltiu = op;
1626  op = new_ir_op(cur_opcode + iro_mips_sltu, "mips_sltu", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1627  set_op_dump(op, mips_dump_node);
1628  set_op_attrs_equal(op, mips_attrs_equal);
1629  set_op_copy_attr(op, be_copy_attr);
1630  set_op_tag(op, mips_op_tag);
1631  op_mips_sltu = op;
1632  op = new_ir_op(cur_opcode + iro_mips_sra, "mips_sra", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_immediate_attr_t));
1633  set_op_dump(op, mips_dump_node);
1634  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1635  set_op_copy_attr(op, be_copy_attr);
1636  set_op_tag(op, mips_op_tag);
1637  op_mips_sra = op;
1638  op = new_ir_op(cur_opcode + iro_mips_srav, "mips_srav", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1639  set_op_dump(op, mips_dump_node);
1640  set_op_attrs_equal(op, mips_attrs_equal);
1641  set_op_copy_attr(op, be_copy_attr);
1642  set_op_tag(op, mips_op_tag);
1643  op_mips_srav = op;
1644  op = new_ir_op(cur_opcode + iro_mips_srl, "mips_srl", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_immediate_attr_t));
1645  set_op_dump(op, mips_dump_node);
1646  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1647  set_op_copy_attr(op, be_copy_attr);
1648  set_op_tag(op, mips_op_tag);
1649  op_mips_srl = op;
1650  op = new_ir_op(cur_opcode + iro_mips_srlv, "mips_srlv", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1651  set_op_dump(op, mips_dump_node);
1652  set_op_attrs_equal(op, mips_attrs_equal);
1653  set_op_copy_attr(op, be_copy_attr);
1654  set_op_tag(op, mips_op_tag);
1655  op_mips_srlv = op;
1656  op = new_ir_op(cur_opcode + iro_mips_subu, "mips_subu", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1657  set_op_dump(op, mips_dump_node);
1658  set_op_attrs_equal(op, mips_attrs_equal);
1659  set_op_copy_attr(op, be_copy_attr);
1660  set_op_tag(op, mips_op_tag);
1661  op_mips_subu = op;
1662  op = new_ir_op(cur_opcode + iro_mips_sw, "mips_sw", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(mips_immediate_attr_t));
1663  ir_op_set_memory_index(op, 0); set_op_dump(op, mips_dump_node);
1664  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1665  set_op_copy_attr(op, be_copy_attr);
1666  set_op_tag(op, mips_op_tag);
1667  op_mips_sw = op;
1668  op = new_ir_op(cur_opcode + iro_mips_switch, "mips_switch", op_pin_state_pinned, irop_flag_cfopcode|irop_flag_forking, oparity_any, -1, sizeof(mips_switch_attr_t));
1669  set_op_dump(op, mips_dump_node);
1670  set_op_attrs_equal(op, mips_switch_attrs_equal);
1671  set_op_copy_attr(op, be_copy_attr);
1672  set_op_tag(op, mips_op_tag);
1673  op_mips_switch = op;
1674  op = new_ir_op(cur_opcode + iro_mips_xor, "mips_xor", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_attr_t));
1675  set_op_dump(op, mips_dump_node);
1676  set_op_attrs_equal(op, mips_attrs_equal);
1677  set_op_copy_attr(op, be_copy_attr);
1678  set_op_tag(op, mips_op_tag);
1679  op_mips_xor = op;
1680  op = new_ir_op(cur_opcode + iro_mips_xori, "mips_xori", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(mips_immediate_attr_t));
1681  set_op_dump(op, mips_dump_node);
1682  set_op_attrs_equal(op, mips_immediate_attrs_equal);
1683  set_op_copy_attr(op, be_copy_attr);
1684  set_op_tag(op, mips_op_tag);
1685  op_mips_xori = op;
1686 
1687 }
1688 
1689 void mips_free_opcodes(void)
1690 {
1691  free_ir_op(op_mips_addiu); op_mips_addiu = NULL;
1692  free_ir_op(op_mips_addu); op_mips_addu = NULL;
1693  free_ir_op(op_mips_and); op_mips_and = NULL;
1694  free_ir_op(op_mips_andi); op_mips_andi = NULL;
1695  free_ir_op(op_mips_b); op_mips_b = NULL;
1696  free_ir_op(op_mips_bcc); op_mips_bcc = NULL;
1697  free_ir_op(op_mips_div_hi); op_mips_div_hi = NULL;
1698  free_ir_op(op_mips_div_lo); op_mips_div_lo = NULL;
1699  free_ir_op(op_mips_divu_hi); op_mips_divu_hi = NULL;
1700  free_ir_op(op_mips_divu_lo); op_mips_divu_lo = NULL;
1701  free_ir_op(op_mips_ijmp); op_mips_ijmp = NULL;
1702  free_ir_op(op_mips_jal); op_mips_jal = NULL;
1703  free_ir_op(op_mips_jalr); op_mips_jalr = NULL;
1704  free_ir_op(op_mips_lb); op_mips_lb = NULL;
1705  free_ir_op(op_mips_lbu); op_mips_lbu = NULL;
1706  free_ir_op(op_mips_lh); op_mips_lh = NULL;
1707  free_ir_op(op_mips_lhu); op_mips_lhu = NULL;
1708  free_ir_op(op_mips_lui); op_mips_lui = NULL;
1709  free_ir_op(op_mips_lw); op_mips_lw = NULL;
1710  free_ir_op(op_mips_mult_hi); op_mips_mult_hi = NULL;
1711  free_ir_op(op_mips_mult_lo); op_mips_mult_lo = NULL;
1712  free_ir_op(op_mips_multu_hi); op_mips_multu_hi = NULL;
1713  free_ir_op(op_mips_nor); op_mips_nor = NULL;
1714  free_ir_op(op_mips_or); op_mips_or = NULL;
1715  free_ir_op(op_mips_ori); op_mips_ori = NULL;
1716  free_ir_op(op_mips_ret); op_mips_ret = NULL;
1717  free_ir_op(op_mips_sb); op_mips_sb = NULL;
1718  free_ir_op(op_mips_sh); op_mips_sh = NULL;
1719  free_ir_op(op_mips_sll); op_mips_sll = NULL;
1720  free_ir_op(op_mips_sllv); op_mips_sllv = NULL;
1721  free_ir_op(op_mips_slt); op_mips_slt = NULL;
1722  free_ir_op(op_mips_sltiu); op_mips_sltiu = NULL;
1723  free_ir_op(op_mips_sltu); op_mips_sltu = NULL;
1724  free_ir_op(op_mips_sra); op_mips_sra = NULL;
1725  free_ir_op(op_mips_srav); op_mips_srav = NULL;
1726  free_ir_op(op_mips_srl); op_mips_srl = NULL;
1727  free_ir_op(op_mips_srlv); op_mips_srlv = NULL;
1728  free_ir_op(op_mips_subu); op_mips_subu = NULL;
1729  free_ir_op(op_mips_sw); op_mips_sw = NULL;
1730  free_ir_op(op_mips_switch); op_mips_switch = NULL;
1731  free_ir_op(op_mips_xor); op_mips_xor = NULL;
1732  free_ir_op(op_mips_xori); op_mips_xori = NULL;
1733 
1734 }
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