libFirm
gen_sparc_new_nodes.c
1 #include "gen_sparc_new_nodes.h"
2 
3 #include "benode.h"
4 #include "sparc_bearch_t.h"
5 #include "gen_sparc_regalloc_if.h"
6 #include "sparc_new_nodes_t.h"
7 #include "fourcc.h"
8 #include "irgopt.h"
9 #include "ircons_t.h"
10 
11 ir_op *op_sparc_Add = NULL;
12 ir_op *op_sparc_AddCC = NULL;
13 ir_op *op_sparc_AddCC_t = NULL;
14 ir_op *op_sparc_AddSP = NULL;
15 ir_op *op_sparc_AddX = NULL;
16 ir_op *op_sparc_AddX_t = NULL;
17 ir_op *op_sparc_And = NULL;
18 ir_op *op_sparc_AndCCZero = NULL;
19 ir_op *op_sparc_AndN = NULL;
20 ir_op *op_sparc_AndNCCZero = NULL;
21 ir_op *op_sparc_Ba = NULL;
22 ir_op *op_sparc_Bicc = NULL;
23 ir_op *op_sparc_Call = NULL;
24 ir_op *op_sparc_Cas = NULL;
25 ir_op *op_sparc_Cmp = NULL;
26 ir_op *op_sparc_FrameAddr = NULL;
27 ir_op *op_sparc_IJmp = NULL;
28 ir_op *op_sparc_Ld = NULL;
29 ir_op *op_sparc_Ldf = NULL;
30 ir_op *op_sparc_Or = NULL;
31 ir_op *op_sparc_OrCCZero = NULL;
32 ir_op *op_sparc_OrN = NULL;
33 ir_op *op_sparc_OrNCCZero = NULL;
34 ir_op *op_sparc_Restore = NULL;
35 ir_op *op_sparc_RestoreZero = NULL;
36 ir_op *op_sparc_Return = NULL;
37 ir_op *op_sparc_SDiv = NULL;
38 ir_op *op_sparc_SMul = NULL;
39 ir_op *op_sparc_SMulCCZero = NULL;
40 ir_op *op_sparc_SMulh = NULL;
41 ir_op *op_sparc_Save = NULL;
42 ir_op *op_sparc_SetHi = NULL;
43 ir_op *op_sparc_Sll = NULL;
44 ir_op *op_sparc_Sra = NULL;
45 ir_op *op_sparc_Srl = NULL;
46 ir_op *op_sparc_St = NULL;
47 ir_op *op_sparc_Stbar = NULL;
48 ir_op *op_sparc_Stf = NULL;
49 ir_op *op_sparc_Sub = NULL;
50 ir_op *op_sparc_SubCC = NULL;
51 ir_op *op_sparc_SubCC_t = NULL;
52 ir_op *op_sparc_SubSP = NULL;
53 ir_op *op_sparc_SubX = NULL;
54 ir_op *op_sparc_SubX_t = NULL;
55 ir_op *op_sparc_SwitchJmp = NULL;
56 ir_op *op_sparc_UDiv = NULL;
57 ir_op *op_sparc_UMulh = NULL;
58 ir_op *op_sparc_XNor = NULL;
59 ir_op *op_sparc_XNorCCZero = NULL;
60 ir_op *op_sparc_Xor = NULL;
61 ir_op *op_sparc_XorCCZero = NULL;
62 ir_op *op_sparc_fabs = NULL;
63 ir_op *op_sparc_fadd = NULL;
64 ir_op *op_sparc_fbfcc = NULL;
65 ir_op *op_sparc_fcmp = NULL;
66 ir_op *op_sparc_fdiv = NULL;
67 ir_op *op_sparc_fftof = NULL;
68 ir_op *op_sparc_fftoi = NULL;
69 ir_op *op_sparc_fitof = NULL;
70 ir_op *op_sparc_fmul = NULL;
71 ir_op *op_sparc_fneg = NULL;
72 ir_op *op_sparc_fsub = NULL;
73 
74 
75 static int sparc_opcode_start = -1;
76 
78 #define sparc_op_tag FOURCC('s', 'p', 'a', 'r')
79 
81 int is_sparc_op(const ir_op *op)
82 {
83  return get_op_tag(op) == sparc_op_tag;
84 }
85 
87 int is_sparc_irn(const ir_node *node)
88 {
89  return is_sparc_op(get_irn_op(node));
90 }
91 
92 int get_sparc_irn_opcode(const ir_node *node)
93 {
94  assert(is_sparc_irn(node));
95  return get_irn_opcode(node) - sparc_opcode_start;
96 }
97 
98 #undef BIT
99 #define BIT(x) (1 << (x))
100 
101 static const unsigned sparc_limit_gp_sp[] = { BIT(REG_GP_SP), 0 };
102 
103 static const arch_register_req_t sparc_requirements_gp_sp_I = {
104  .cls = &sparc_reg_classes[CLASS_sparc_gp],
105  .limited = sparc_limit_gp_sp,
106  .should_be_same = 0,
107  .must_be_different = 0,
108  .width = 1,
109  .ignore = true,
110 };
111 
112 static const arch_register_req_t sparc_requirements_gp_in_r2 = {
113  .cls = &sparc_reg_classes[CLASS_sparc_gp],
114  .limited = NULL,
115  .should_be_same = 4,
116  .must_be_different = 0,
117  .width = 1,
118 };
119 
120 static const arch_register_req_t sparc_requirements_fp_fp_2 = {
121  .cls = &sparc_reg_classes[CLASS_sparc_fp],
122  .width = 2,
123 };
124 
125 static const arch_register_req_t sparc_requirements_fp_fp_4 = {
126  .cls = &sparc_reg_classes[CLASS_sparc_fp],
127  .width = 4,
128 };
129 
130 
131 
132 ir_node *new_bd_sparc_Add_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
133 {
134  static arch_register_req_t const *in_reqs[] = {
135  &sparc_class_reg_req_gp,
136  };
137 
138  /* construct in array */
139  ir_node *const in[] = {
140  left,
141  };
142 
143  ir_graph *const irg = get_irn_irg(block);
144  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Add, mode_Iu, 1, in);
145 
146  /* flags */
147  arch_irn_flags_t irn_flags = arch_irn_flags_none;
148  irn_flags |= arch_irn_flag_rematerializable;
149 
150  /* init node attributes */
151  int const n_res = 1;
152  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
153  (void)attr; /* avoid potential warning */
154  be_info_init_irn(res, irn_flags, in_reqs, n_res);
155  sparc_set_attr_imm(res, immediate_entity, immediate_value);
156  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
157  out_infos[0].req = &sparc_class_reg_req_gp;
158 
159  verify_new_node(res);
160  return optimize_node(res);
161 }
162 
163 ir_node *new_bd_sparc_Add_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
164 {
165  static arch_register_req_t const *in_reqs[] = {
166  &sparc_class_reg_req_gp,
167  &sparc_class_reg_req_gp,
168  };
169 
170  /* construct in array */
171  ir_node *const in[] = {
172  left,
173  right,
174  };
175 
176  ir_graph *const irg = get_irn_irg(block);
177  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Add, mode_Iu, 2, in);
178 
179  /* flags */
180  arch_irn_flags_t irn_flags = arch_irn_flags_none;
181  irn_flags |= arch_irn_flag_rematerializable;
182 
183  /* init node attributes */
184  int const n_res = 1;
185  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
186  (void)attr; /* avoid potential warning */
187  be_info_init_irn(res, irn_flags, in_reqs, n_res);
188  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
189  out_infos[0].req = &sparc_class_reg_req_gp;
190 
191  verify_new_node(res);
192  return optimize_node(res);
193 }
194 
195 ir_node *new_bd_sparc_AddCC_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
196 {
197  static arch_register_req_t const *in_reqs[] = {
198  &sparc_class_reg_req_gp,
199  };
200 
201  /* construct in array */
202  ir_node *const in[] = {
203  left,
204  };
205 
206  ir_graph *const irg = get_irn_irg(block);
207  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AddCC, mode_T, 1, in);
208 
209  /* flags */
210  arch_irn_flags_t irn_flags = arch_irn_flags_none;
211  irn_flags |= arch_irn_flag_rematerializable;
212 
213  /* init node attributes */
214  int const n_res = 2;
215  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
216  (void)attr; /* avoid potential warning */
217  be_info_init_irn(res, irn_flags, in_reqs, n_res);
218  sparc_set_attr_imm(res, immediate_entity, immediate_value);
219  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
220  out_infos[0].req = &sparc_class_reg_req_gp;
221  out_infos[1].req = &sparc_class_reg_req_flags;
222 
223  verify_new_node(res);
224  return optimize_node(res);
225 }
226 
227 ir_node *new_bd_sparc_AddCC_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
228 {
229  static arch_register_req_t const *in_reqs[] = {
230  &sparc_class_reg_req_gp,
231  &sparc_class_reg_req_gp,
232  };
233 
234  /* construct in array */
235  ir_node *const in[] = {
236  left,
237  right,
238  };
239 
240  ir_graph *const irg = get_irn_irg(block);
241  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AddCC, mode_T, 2, in);
242 
243  /* flags */
244  arch_irn_flags_t irn_flags = arch_irn_flags_none;
245  irn_flags |= arch_irn_flag_rematerializable;
246 
247  /* init node attributes */
248  int const n_res = 2;
249  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
250  (void)attr; /* avoid potential warning */
251  be_info_init_irn(res, irn_flags, in_reqs, n_res);
252  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
253  out_infos[0].req = &sparc_class_reg_req_gp;
254  out_infos[1].req = &sparc_class_reg_req_flags;
255 
256  verify_new_node(res);
257  return optimize_node(res);
258 }
259 
260 ir_node *new_bd_sparc_AddCC_t(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
261 {
262 
263  /* construct in array */
264  ir_node *const in[] = {
265  left,
266  right,
267  };
268 
269  ir_graph *const irg = get_irn_irg(block);
270  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AddCC_t, mode_T, 2, in);
271 
272  /* flags */
273  arch_irn_flags_t irn_flags = arch_irn_flags_none;
274 
275  /* init node attributes */
276  int const n_res = 2;
277  (void)irn_flags, (void)n_res;
278 
279  verify_new_node(res);
280  return optimize_node(res);
281 }
282 
283 ir_node *new_bd_sparc_AddSP(dbg_info *dbgi, ir_node *block, ir_node *stack, ir_node *size)
284 {
285  static arch_register_req_t const *in_reqs[] = {
286  &sparc_single_reg_req_gp_sp,
287  &sparc_class_reg_req_gp,
288  };
289 
290  /* construct in array */
291  ir_node *const in[] = {
292  stack,
293  size,
294  };
295 
296  ir_graph *const irg = get_irn_irg(block);
297  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AddSP, mode_Iu, 2, in);
298 
299  /* flags */
300  arch_irn_flags_t irn_flags = arch_irn_flags_none;
301 
302  /* init node attributes */
303  int const n_res = 1;
304  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
305  (void)attr; /* avoid potential warning */
306  be_info_init_irn(res, irn_flags, in_reqs, n_res);
307  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
308  out_infos[0].req = &sparc_requirements_gp_sp_I;
309 
310  verify_new_node(res);
311  return optimize_node(res);
312 }
313 
314 ir_node *new_bd_sparc_AddX_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *carry, ir_entity *immediate_entity, int32_t immediate_value)
315 {
316  static arch_register_req_t const *in_reqs[] = {
317  &sparc_class_reg_req_gp,
318  &sparc_class_reg_req_flags,
319  };
320 
321  /* construct in array */
322  ir_node *const in[] = {
323  left,
324  carry,
325  };
326 
327  ir_graph *const irg = get_irn_irg(block);
328  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AddX, mode_Iu, 2, in);
329 
330  /* flags */
331  arch_irn_flags_t irn_flags = arch_irn_flags_none;
332 
333  /* init node attributes */
334  int const n_res = 1;
335  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
336  (void)attr; /* avoid potential warning */
337  be_info_init_irn(res, irn_flags, in_reqs, n_res);
338  sparc_set_attr_imm(res, immediate_entity, immediate_value);
339  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
340  out_infos[0].req = &sparc_class_reg_req_gp;
341 
342  verify_new_node(res);
343  return optimize_node(res);
344 }
345 
346 ir_node *new_bd_sparc_AddX_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_node *carry)
347 {
348  static arch_register_req_t const *in_reqs[] = {
349  &sparc_class_reg_req_gp,
350  &sparc_class_reg_req_gp,
351  &sparc_class_reg_req_flags,
352  };
353 
354  /* construct in array */
355  ir_node *const in[] = {
356  left,
357  right,
358  carry,
359  };
360 
361  ir_graph *const irg = get_irn_irg(block);
362  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AddX, mode_Iu, 3, in);
363 
364  /* flags */
365  arch_irn_flags_t irn_flags = arch_irn_flags_none;
366 
367  /* init node attributes */
368  int const n_res = 1;
369  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
370  (void)attr; /* avoid potential warning */
371  be_info_init_irn(res, irn_flags, in_reqs, n_res);
372  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
373  out_infos[0].req = &sparc_class_reg_req_gp;
374 
375  verify_new_node(res);
376  return optimize_node(res);
377 }
378 
379 ir_node *new_bd_sparc_AddX_t(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_node *flags_input, ir_mode *mode)
380 {
381 
382  /* construct in array */
383  ir_node *const in[] = {
384  left,
385  right,
386  flags_input,
387  };
388 
389  ir_graph *const irg = get_irn_irg(block);
390  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AddX_t, mode, 3, in);
391 
392  /* flags */
393  arch_irn_flags_t irn_flags = arch_irn_flags_none;
394 
395  /* init node attributes */
396  int const n_res = 0;
397  (void)irn_flags, (void)n_res;
398 
399  verify_new_node(res);
400  return optimize_node(res);
401 }
402 
403 ir_node *new_bd_sparc_And_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
404 {
405  static arch_register_req_t const *in_reqs[] = {
406  &sparc_class_reg_req_gp,
407  };
408 
409  /* construct in array */
410  ir_node *const in[] = {
411  left,
412  };
413 
414  ir_graph *const irg = get_irn_irg(block);
415  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_And, mode_Iu, 1, in);
416 
417  /* flags */
418  arch_irn_flags_t irn_flags = arch_irn_flags_none;
419  irn_flags |= arch_irn_flag_rematerializable;
420 
421  /* init node attributes */
422  int const n_res = 1;
423  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
424  (void)attr; /* avoid potential warning */
425  be_info_init_irn(res, irn_flags, in_reqs, n_res);
426  sparc_set_attr_imm(res, immediate_entity, immediate_value);
427  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
428  out_infos[0].req = &sparc_class_reg_req_gp;
429 
430  verify_new_node(res);
431  return optimize_node(res);
432 }
433 
434 ir_node *new_bd_sparc_And_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
435 {
436  static arch_register_req_t const *in_reqs[] = {
437  &sparc_class_reg_req_gp,
438  &sparc_class_reg_req_gp,
439  };
440 
441  /* construct in array */
442  ir_node *const in[] = {
443  left,
444  right,
445  };
446 
447  ir_graph *const irg = get_irn_irg(block);
448  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_And, mode_Iu, 2, in);
449 
450  /* flags */
451  arch_irn_flags_t irn_flags = arch_irn_flags_none;
452  irn_flags |= arch_irn_flag_rematerializable;
453 
454  /* init node attributes */
455  int const n_res = 1;
456  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
457  (void)attr; /* avoid potential warning */
458  be_info_init_irn(res, irn_flags, in_reqs, n_res);
459  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
460  out_infos[0].req = &sparc_class_reg_req_gp;
461 
462  verify_new_node(res);
463  return optimize_node(res);
464 }
465 
466 ir_node *new_bd_sparc_AndCCZero_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
467 {
468  static arch_register_req_t const *in_reqs[] = {
469  &sparc_class_reg_req_gp,
470  };
471 
472  /* construct in array */
473  ir_node *const in[] = {
474  left,
475  };
476 
477  ir_graph *const irg = get_irn_irg(block);
478  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AndCCZero, mode_Bu, 1, in);
479 
480  /* flags */
481  arch_irn_flags_t irn_flags = arch_irn_flags_none;
482  irn_flags |= arch_irn_flag_rematerializable;
483 
484  /* init node attributes */
485  int const n_res = 1;
486  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
487  (void)attr; /* avoid potential warning */
488  be_info_init_irn(res, irn_flags, in_reqs, n_res);
489  sparc_set_attr_imm(res, immediate_entity, immediate_value);
490  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
491  out_infos[0].req = &sparc_class_reg_req_flags;
492 
493  verify_new_node(res);
494  return optimize_node(res);
495 }
496 
497 ir_node *new_bd_sparc_AndCCZero_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
498 {
499  static arch_register_req_t const *in_reqs[] = {
500  &sparc_class_reg_req_gp,
501  &sparc_class_reg_req_gp,
502  };
503 
504  /* construct in array */
505  ir_node *const in[] = {
506  left,
507  right,
508  };
509 
510  ir_graph *const irg = get_irn_irg(block);
511  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AndCCZero, mode_Bu, 2, in);
512 
513  /* flags */
514  arch_irn_flags_t irn_flags = arch_irn_flags_none;
515  irn_flags |= arch_irn_flag_rematerializable;
516 
517  /* init node attributes */
518  int const n_res = 1;
519  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
520  (void)attr; /* avoid potential warning */
521  be_info_init_irn(res, irn_flags, in_reqs, n_res);
522  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
523  out_infos[0].req = &sparc_class_reg_req_flags;
524 
525  verify_new_node(res);
526  return optimize_node(res);
527 }
528 
529 ir_node *new_bd_sparc_AndN_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
530 {
531  static arch_register_req_t const *in_reqs[] = {
532  &sparc_class_reg_req_gp,
533  };
534 
535  /* construct in array */
536  ir_node *const in[] = {
537  left,
538  };
539 
540  ir_graph *const irg = get_irn_irg(block);
541  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AndN, mode_Iu, 1, in);
542 
543  /* flags */
544  arch_irn_flags_t irn_flags = arch_irn_flags_none;
545  irn_flags |= arch_irn_flag_rematerializable;
546 
547  /* init node attributes */
548  int const n_res = 1;
549  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
550  (void)attr; /* avoid potential warning */
551  be_info_init_irn(res, irn_flags, in_reqs, n_res);
552  sparc_set_attr_imm(res, immediate_entity, immediate_value);
553  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
554  out_infos[0].req = &sparc_class_reg_req_gp;
555 
556  verify_new_node(res);
557  return optimize_node(res);
558 }
559 
560 ir_node *new_bd_sparc_AndN_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
561 {
562  static arch_register_req_t const *in_reqs[] = {
563  &sparc_class_reg_req_gp,
564  &sparc_class_reg_req_gp,
565  };
566 
567  /* construct in array */
568  ir_node *const in[] = {
569  left,
570  right,
571  };
572 
573  ir_graph *const irg = get_irn_irg(block);
574  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AndN, mode_Iu, 2, in);
575 
576  /* flags */
577  arch_irn_flags_t irn_flags = arch_irn_flags_none;
578  irn_flags |= arch_irn_flag_rematerializable;
579 
580  /* init node attributes */
581  int const n_res = 1;
582  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
583  (void)attr; /* avoid potential warning */
584  be_info_init_irn(res, irn_flags, in_reqs, n_res);
585  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
586  out_infos[0].req = &sparc_class_reg_req_gp;
587 
588  verify_new_node(res);
589  return optimize_node(res);
590 }
591 
592 ir_node *new_bd_sparc_AndNCCZero_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
593 {
594  static arch_register_req_t const *in_reqs[] = {
595  &sparc_class_reg_req_gp,
596  };
597 
598  /* construct in array */
599  ir_node *const in[] = {
600  left,
601  };
602 
603  ir_graph *const irg = get_irn_irg(block);
604  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AndNCCZero, mode_Bu, 1, in);
605 
606  /* flags */
607  arch_irn_flags_t irn_flags = arch_irn_flags_none;
608  irn_flags |= arch_irn_flag_rematerializable;
609 
610  /* init node attributes */
611  int const n_res = 1;
612  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
613  (void)attr; /* avoid potential warning */
614  be_info_init_irn(res, irn_flags, in_reqs, n_res);
615  sparc_set_attr_imm(res, immediate_entity, immediate_value);
616  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
617  out_infos[0].req = &sparc_class_reg_req_flags;
618 
619  verify_new_node(res);
620  return optimize_node(res);
621 }
622 
623 ir_node *new_bd_sparc_AndNCCZero_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
624 {
625  static arch_register_req_t const *in_reqs[] = {
626  &sparc_class_reg_req_gp,
627  &sparc_class_reg_req_gp,
628  };
629 
630  /* construct in array */
631  ir_node *const in[] = {
632  left,
633  right,
634  };
635 
636  ir_graph *const irg = get_irn_irg(block);
637  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_AndNCCZero, mode_Bu, 2, in);
638 
639  /* flags */
640  arch_irn_flags_t irn_flags = arch_irn_flags_none;
641  irn_flags |= arch_irn_flag_rematerializable;
642 
643  /* init node attributes */
644  int const n_res = 1;
645  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
646  (void)attr; /* avoid potential warning */
647  be_info_init_irn(res, irn_flags, in_reqs, n_res);
648  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
649  out_infos[0].req = &sparc_class_reg_req_flags;
650 
651  verify_new_node(res);
652  return optimize_node(res);
653 }
654 
655 ir_node *new_bd_sparc_Ba(dbg_info *dbgi, ir_node *block)
656 {
657  arch_register_req_t const **const in_reqs = NULL;
658 
659 
660  ir_graph *const irg = get_irn_irg(block);
661  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Ba, mode_X, 0, NULL);
662 
663  /* flags */
664  arch_irn_flags_t irn_flags = arch_irn_flags_none;
665  irn_flags |= arch_irn_flag_simple_jump;
666 
667  /* init node attributes */
668  int const n_res = 1;
669  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
670  (void)attr; /* avoid potential warning */
671  be_info_init_irn(res, irn_flags, in_reqs, n_res);
672  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
673  out_infos[0].req = &arch_exec_requirement;
674 
675  verify_new_node(res);
676  return optimize_node(res);
677 }
678 
679 ir_node *new_bd_sparc_Bicc(dbg_info *dbgi, ir_node *block, ir_node *flags, ir_relation relation, bool is_unsigned)
680 {
681  static arch_register_req_t const *in_reqs[] = {
682  &sparc_class_reg_req_flags,
683  };
684 
685  /* construct in array */
686  ir_node *const in[] = {
687  flags,
688  };
689 
690  ir_graph *const irg = get_irn_irg(block);
691  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Bicc, mode_T, 1, in);
692 
693  /* flags */
694  arch_irn_flags_t irn_flags = arch_irn_flags_none;
695  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
696 
697  /* init node attributes */
698  int const n_res = 2;
699  sparc_jmp_cond_attr_t *const attr = (sparc_jmp_cond_attr_t*)get_irn_generic_attr(res);
700  (void)attr; /* avoid potential warning */
701  be_info_init_irn(res, irn_flags, in_reqs, n_res);
702  init_sparc_jmp_cond_attr(res, relation, is_unsigned);
703  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
704  out_infos[0].req = &arch_exec_requirement;
705  out_infos[1].req = &arch_exec_requirement;
706 
707  verify_new_node(res);
708  return optimize_node(res);
709 }
710 
711 ir_node *new_bd_sparc_Call_imm(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_type *call_type, ir_entity *entity, int32_t offset, bool aggregate_return)
712 {
713 
714 
715  ir_graph *const irg = get_irn_irg(block);
716  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Call, mode_T, arity, in);
717 
718  /* flags */
719  arch_irn_flags_t irn_flags = arch_irn_flags_none;
720  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
721 
722  /* init node attributes */
723  sparc_call_attr_t *const attr = (sparc_call_attr_t*)get_irn_generic_attr(res);
724  (void)attr; /* avoid potential warning */
725  be_info_init_irn(res, irn_flags, in_reqs, n_res);
726  init_sparc_call_attributes(res, call_type);
727  sparc_set_attr_imm(res, entity, offset);
728  if (aggregate_return) arch_add_irn_flags(res, (arch_irn_flags_t)sparc_arch_irn_flag_aggregate_return);
729 
730  verify_new_node(res);
731  return optimize_node(res);
732 }
733 
734 ir_node *new_bd_sparc_Call_reg(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_type *call_type, bool aggregate_return)
735 {
736 
737 
738  ir_graph *const irg = get_irn_irg(block);
739  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Call, mode_T, arity, in);
740 
741  /* flags */
742  arch_irn_flags_t irn_flags = arch_irn_flags_none;
743  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
744 
745  /* init node attributes */
746  sparc_call_attr_t *const attr = (sparc_call_attr_t*)get_irn_generic_attr(res);
747  (void)attr; /* avoid potential warning */
748  be_info_init_irn(res, irn_flags, in_reqs, n_res);
749  init_sparc_call_attributes(res, call_type);
750  if (aggregate_return) arch_add_irn_flags(res, (arch_irn_flags_t)sparc_arch_irn_flag_aggregate_return);
751 
752  verify_new_node(res);
753  return optimize_node(res);
754 }
755 
756 ir_node *new_bd_sparc_Cas(dbg_info *dbgi, ir_node *block, ir_node *ptr, ir_node *old, ir_node *new, ir_node *mem)
757 {
758  static arch_register_req_t const *in_reqs[] = {
759  &sparc_class_reg_req_gp,
760  &sparc_class_reg_req_gp,
761  &sparc_class_reg_req_gp,
762  &arch_memory_requirement,
763  };
764 
765  /* construct in array */
766  ir_node *const in[] = {
767  ptr,
768  old,
769  new,
770  mem,
771  };
772 
773  ir_graph *const irg = get_irn_irg(block);
774  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Cas, mode_T, 4, in);
775 
776  /* flags */
777  arch_irn_flags_t irn_flags = arch_irn_flags_none;
778 
779  /* init node attributes */
780  int const n_res = 2;
781  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
782  (void)attr; /* avoid potential warning */
783  be_info_init_irn(res, irn_flags, in_reqs, n_res);
784  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
785  out_infos[0].req = &sparc_requirements_gp_in_r2;
786  out_infos[1].req = &arch_memory_requirement;
787 
788  verify_new_node(res);
789  return optimize_node(res);
790 }
791 
792 ir_node *new_bd_sparc_Cmp_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
793 {
794  static arch_register_req_t const *in_reqs[] = {
795  &sparc_class_reg_req_gp,
796  };
797 
798  /* construct in array */
799  ir_node *const in[] = {
800  left,
801  };
802 
803  ir_graph *const irg = get_irn_irg(block);
804  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Cmp, mode_Bu, 1, in);
805 
806  /* flags */
807  arch_irn_flags_t irn_flags = arch_irn_flags_none;
808  irn_flags |= arch_irn_flag_rematerializable;
809 
810  /* init node attributes */
811  int const n_res = 1;
812  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
813  (void)attr; /* avoid potential warning */
814  be_info_init_irn(res, irn_flags, in_reqs, n_res);
815  sparc_set_attr_imm(res, immediate_entity, immediate_value);
816  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
817  out_infos[0].req = &sparc_class_reg_req_flags;
818 
819  verify_new_node(res);
820  return optimize_node(res);
821 }
822 
823 ir_node *new_bd_sparc_Cmp_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
824 {
825  static arch_register_req_t const *in_reqs[] = {
826  &sparc_class_reg_req_gp,
827  &sparc_class_reg_req_gp,
828  };
829 
830  /* construct in array */
831  ir_node *const in[] = {
832  left,
833  right,
834  };
835 
836  ir_graph *const irg = get_irn_irg(block);
837  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Cmp, mode_Bu, 2, in);
838 
839  /* flags */
840  arch_irn_flags_t irn_flags = arch_irn_flags_none;
841  irn_flags |= arch_irn_flag_rematerializable;
842 
843  /* init node attributes */
844  int const n_res = 1;
845  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
846  (void)attr; /* avoid potential warning */
847  be_info_init_irn(res, irn_flags, in_reqs, n_res);
848  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
849  out_infos[0].req = &sparc_class_reg_req_flags;
850 
851  verify_new_node(res);
852  return optimize_node(res);
853 }
854 
855 ir_node *new_bd_sparc_FrameAddr(dbg_info *dbgi, ir_node *block, ir_node *base, ir_entity *entity, int32_t offset)
856 {
857  static arch_register_req_t const *in_reqs[] = {
858  &sparc_class_reg_req_gp,
859  };
860 
861  /* construct in array */
862  ir_node *const in[] = {
863  base,
864  };
865 
866  ir_graph *const irg = get_irn_irg(block);
867  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_FrameAddr, mode_Iu, 1, in);
868 
869  /* flags */
870  arch_irn_flags_t irn_flags = arch_irn_flags_none;
871  irn_flags |= arch_irn_flag_rematerializable;
872 
873  /* init node attributes */
874  int const n_res = 1;
875  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
876  (void)attr; /* avoid potential warning */
877  be_info_init_irn(res, irn_flags, in_reqs, n_res);
878  sparc_set_attr_imm(res, entity, offset);
879  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
880  out_infos[0].req = &sparc_class_reg_req_gp;
881 
882  verify_new_node(res);
883  return optimize_node(res);
884 }
885 
886 ir_node *new_bd_sparc_IJmp_imm(dbg_info *dbgi, ir_node *block, ir_node *ptr, ir_entity *entity, int32_t offset, bool is_frame_entity)
887 {
888  static arch_register_req_t const *in_reqs[] = {
889  &sparc_class_reg_req_gp,
890  };
891 
892  /* construct in array */
893  ir_node *const in[] = {
894  ptr,
895  };
896 
897  ir_graph *const irg = get_irn_irg(block);
898  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_IJmp, mode_X, 1, in);
899 
900  /* flags */
901  arch_irn_flags_t irn_flags = arch_irn_flags_none;
902  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
903 
904  /* init node attributes */
905  int const n_res = 1;
906  sparc_load_store_attr_t *const attr = (sparc_load_store_attr_t*)get_irn_generic_attr(res);
907  (void)attr; /* avoid potential warning */
908  be_info_init_irn(res, irn_flags, in_reqs, n_res);
909  init_sparc_load_store_attributes(res, NULL, entity, offset, is_frame_entity, false);
910  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
911  out_infos[0].req = &arch_exec_requirement;
912 
913  verify_new_node(res);
914  return optimize_node(res);
915 }
916 
917 ir_node *new_bd_sparc_IJmp_reg(dbg_info *dbgi, ir_node *block, ir_node *ptr, ir_node *ptr2)
918 {
919  static arch_register_req_t const *in_reqs[] = {
920  &sparc_class_reg_req_gp,
921  &sparc_class_reg_req_gp,
922  };
923 
924  /* construct in array */
925  ir_node *const in[] = {
926  ptr,
927  ptr2,
928  };
929 
930  ir_graph *const irg = get_irn_irg(block);
931  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_IJmp, mode_X, 2, in);
932 
933  /* flags */
934  arch_irn_flags_t irn_flags = arch_irn_flags_none;
935  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
936 
937  /* init node attributes */
938  int const n_res = 1;
939  sparc_load_store_attr_t *const attr = (sparc_load_store_attr_t*)get_irn_generic_attr(res);
940  (void)attr; /* avoid potential warning */
941  be_info_init_irn(res, irn_flags, in_reqs, n_res);
942  init_sparc_load_store_attributes(res, NULL, NULL, 0, false, true);
943  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
944  out_infos[0].req = &arch_exec_requirement;
945 
946  verify_new_node(res);
947  return optimize_node(res);
948 }
949 
950 ir_node *new_bd_sparc_Ld_imm(dbg_info *dbgi, ir_node *block, ir_node *ptr, ir_node *mem, ir_mode *ls_mode, ir_entity *entity, int32_t offset, bool is_frame_entity)
951 {
952  static arch_register_req_t const *in_reqs[] = {
953  &sparc_class_reg_req_gp,
954  &arch_memory_requirement,
955  };
956 
957  /* construct in array */
958  ir_node *const in[] = {
959  ptr,
960  mem,
961  };
962 
963  ir_graph *const irg = get_irn_irg(block);
964  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Ld, mode_T, 2, in);
965 
966  /* flags */
967  arch_irn_flags_t irn_flags = arch_irn_flags_none;
968 
969  /* init node attributes */
970  int const n_res = 2;
971  sparc_load_store_attr_t *const attr = (sparc_load_store_attr_t*)get_irn_generic_attr(res);
972  (void)attr; /* avoid potential warning */
973  be_info_init_irn(res, irn_flags, in_reqs, n_res);
974  init_sparc_load_store_attributes(res, ls_mode, entity, offset, is_frame_entity, false);
975  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
976  out_infos[0].req = &sparc_class_reg_req_gp;
977  out_infos[1].req = &arch_memory_requirement;
978 
979  verify_new_node(res);
980  return optimize_node(res);
981 }
982 
983 ir_node *new_bd_sparc_Ld_reg(dbg_info *dbgi, ir_node *block, ir_node *ptr, ir_node *ptr2, ir_node *mem, ir_mode *ls_mode)
984 {
985  static arch_register_req_t const *in_reqs[] = {
986  &sparc_class_reg_req_gp,
987  &sparc_class_reg_req_gp,
988  &arch_memory_requirement,
989  };
990 
991  /* construct in array */
992  ir_node *const in[] = {
993  ptr,
994  ptr2,
995  mem,
996  };
997 
998  ir_graph *const irg = get_irn_irg(block);
999  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Ld, mode_T, 3, in);
1000 
1001  /* flags */
1002  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1003 
1004  /* init node attributes */
1005  int const n_res = 2;
1006  sparc_load_store_attr_t *const attr = (sparc_load_store_attr_t*)get_irn_generic_attr(res);
1007  (void)attr; /* avoid potential warning */
1008  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1009  init_sparc_load_store_attributes(res, ls_mode, NULL, 0, false, true);
1010  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1011  out_infos[0].req = &sparc_class_reg_req_gp;
1012  out_infos[1].req = &arch_memory_requirement;
1013 
1014  verify_new_node(res);
1015  return optimize_node(res);
1016 }
1017 
1018 ir_node *new_bd_sparc_Ldf_d(dbg_info *dbgi, ir_node *block, ir_node *ptr, ir_node *mem, ir_mode *ls_mode, ir_entity *entity, int32_t offset, bool is_frame_entity)
1019 {
1020  static arch_register_req_t const *in_reqs[] = {
1021  &sparc_class_reg_req_gp,
1022  &arch_memory_requirement,
1023  };
1024 
1025  /* construct in array */
1026  ir_node *const in[] = {
1027  ptr,
1028  mem,
1029  };
1030 
1031  ir_graph *const irg = get_irn_irg(block);
1032  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Ldf, mode_T, 2, in);
1033 
1034  /* flags */
1035  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1036 
1037  /* init node attributes */
1038  int const n_res = 2;
1039  sparc_load_store_attr_t *const attr = (sparc_load_store_attr_t*)get_irn_generic_attr(res);
1040  (void)attr; /* avoid potential warning */
1041  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1042  init_sparc_load_store_attributes(res, ls_mode, entity, offset, is_frame_entity, false);
1043  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1044  out_infos[0].req = &sparc_requirements_fp_fp_2;
1045  out_infos[1].req = &arch_memory_requirement;
1046 
1047  verify_new_node(res);
1048  return optimize_node(res);
1049 }
1050 
1051 ir_node *new_bd_sparc_Ldf_q(dbg_info *dbgi, ir_node *block, ir_node *ptr, ir_node *mem, ir_mode *ls_mode, ir_entity *entity, int32_t offset, bool is_frame_entity)
1052 {
1053  static arch_register_req_t const *in_reqs[] = {
1054  &sparc_class_reg_req_gp,
1055  &arch_memory_requirement,
1056  };
1057 
1058  /* construct in array */
1059  ir_node *const in[] = {
1060  ptr,
1061  mem,
1062  };
1063 
1064  ir_graph *const irg = get_irn_irg(block);
1065  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Ldf, mode_T, 2, in);
1066 
1067  /* flags */
1068  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1069 
1070  /* init node attributes */
1071  int const n_res = 2;
1072  sparc_load_store_attr_t *const attr = (sparc_load_store_attr_t*)get_irn_generic_attr(res);
1073  (void)attr; /* avoid potential warning */
1074  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1075  init_sparc_load_store_attributes(res, ls_mode, entity, offset, is_frame_entity, false);
1076  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1077  out_infos[0].req = &sparc_requirements_fp_fp_4;
1078  out_infos[1].req = &arch_memory_requirement;
1079 
1080  verify_new_node(res);
1081  return optimize_node(res);
1082 }
1083 
1084 ir_node *new_bd_sparc_Ldf_s(dbg_info *dbgi, ir_node *block, ir_node *ptr, ir_node *mem, ir_mode *ls_mode, ir_entity *entity, int32_t offset, bool is_frame_entity)
1085 {
1086  static arch_register_req_t const *in_reqs[] = {
1087  &sparc_class_reg_req_gp,
1088  &arch_memory_requirement,
1089  };
1090 
1091  /* construct in array */
1092  ir_node *const in[] = {
1093  ptr,
1094  mem,
1095  };
1096 
1097  ir_graph *const irg = get_irn_irg(block);
1098  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Ldf, mode_T, 2, in);
1099 
1100  /* flags */
1101  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1102 
1103  /* init node attributes */
1104  int const n_res = 2;
1105  sparc_load_store_attr_t *const attr = (sparc_load_store_attr_t*)get_irn_generic_attr(res);
1106  (void)attr; /* avoid potential warning */
1107  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1108  init_sparc_load_store_attributes(res, ls_mode, entity, offset, is_frame_entity, false);
1109  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1110  out_infos[0].req = &sparc_class_reg_req_fp;
1111  out_infos[1].req = &arch_memory_requirement;
1112 
1113  verify_new_node(res);
1114  return optimize_node(res);
1115 }
1116 
1117 ir_node *new_bd_sparc_Or_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
1118 {
1119  static arch_register_req_t const *in_reqs[] = {
1120  &sparc_class_reg_req_gp,
1121  };
1122 
1123  /* construct in array */
1124  ir_node *const in[] = {
1125  left,
1126  };
1127 
1128  ir_graph *const irg = get_irn_irg(block);
1129  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Or, mode_Iu, 1, in);
1130 
1131  /* flags */
1132  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1133  irn_flags |= arch_irn_flag_rematerializable;
1134 
1135  /* init node attributes */
1136  int const n_res = 1;
1137  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1138  (void)attr; /* avoid potential warning */
1139  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1140  sparc_set_attr_imm(res, immediate_entity, immediate_value);
1141  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1142  out_infos[0].req = &sparc_class_reg_req_gp;
1143 
1144  verify_new_node(res);
1145  return optimize_node(res);
1146 }
1147 
1148 ir_node *new_bd_sparc_Or_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1149 {
1150  static arch_register_req_t const *in_reqs[] = {
1151  &sparc_class_reg_req_gp,
1152  &sparc_class_reg_req_gp,
1153  };
1154 
1155  /* construct in array */
1156  ir_node *const in[] = {
1157  left,
1158  right,
1159  };
1160 
1161  ir_graph *const irg = get_irn_irg(block);
1162  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Or, mode_Iu, 2, in);
1163 
1164  /* flags */
1165  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1166  irn_flags |= arch_irn_flag_rematerializable;
1167 
1168  /* init node attributes */
1169  int const n_res = 1;
1170  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1171  (void)attr; /* avoid potential warning */
1172  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1173  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1174  out_infos[0].req = &sparc_class_reg_req_gp;
1175 
1176  verify_new_node(res);
1177  return optimize_node(res);
1178 }
1179 
1180 ir_node *new_bd_sparc_OrCCZero_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
1181 {
1182  static arch_register_req_t const *in_reqs[] = {
1183  &sparc_class_reg_req_gp,
1184  };
1185 
1186  /* construct in array */
1187  ir_node *const in[] = {
1188  left,
1189  };
1190 
1191  ir_graph *const irg = get_irn_irg(block);
1192  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_OrCCZero, mode_Bu, 1, in);
1193 
1194  /* flags */
1195  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1196  irn_flags |= arch_irn_flag_rematerializable;
1197 
1198  /* init node attributes */
1199  int const n_res = 1;
1200  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1201  (void)attr; /* avoid potential warning */
1202  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1203  sparc_set_attr_imm(res, immediate_entity, immediate_value);
1204  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1205  out_infos[0].req = &sparc_class_reg_req_flags;
1206 
1207  verify_new_node(res);
1208  return optimize_node(res);
1209 }
1210 
1211 ir_node *new_bd_sparc_OrCCZero_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1212 {
1213  static arch_register_req_t const *in_reqs[] = {
1214  &sparc_class_reg_req_gp,
1215  &sparc_class_reg_req_gp,
1216  };
1217 
1218  /* construct in array */
1219  ir_node *const in[] = {
1220  left,
1221  right,
1222  };
1223 
1224  ir_graph *const irg = get_irn_irg(block);
1225  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_OrCCZero, mode_Bu, 2, in);
1226 
1227  /* flags */
1228  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1229  irn_flags |= arch_irn_flag_rematerializable;
1230 
1231  /* init node attributes */
1232  int const n_res = 1;
1233  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1234  (void)attr; /* avoid potential warning */
1235  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1236  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1237  out_infos[0].req = &sparc_class_reg_req_flags;
1238 
1239  verify_new_node(res);
1240  return optimize_node(res);
1241 }
1242 
1243 ir_node *new_bd_sparc_OrN_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
1244 {
1245  static arch_register_req_t const *in_reqs[] = {
1246  &sparc_class_reg_req_gp,
1247  };
1248 
1249  /* construct in array */
1250  ir_node *const in[] = {
1251  left,
1252  };
1253 
1254  ir_graph *const irg = get_irn_irg(block);
1255  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_OrN, mode_Iu, 1, in);
1256 
1257  /* flags */
1258  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1259  irn_flags |= arch_irn_flag_rematerializable;
1260 
1261  /* init node attributes */
1262  int const n_res = 1;
1263  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1264  (void)attr; /* avoid potential warning */
1265  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1266  sparc_set_attr_imm(res, immediate_entity, immediate_value);
1267  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1268  out_infos[0].req = &sparc_class_reg_req_gp;
1269 
1270  verify_new_node(res);
1271  return optimize_node(res);
1272 }
1273 
1274 ir_node *new_bd_sparc_OrN_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1275 {
1276  static arch_register_req_t const *in_reqs[] = {
1277  &sparc_class_reg_req_gp,
1278  &sparc_class_reg_req_gp,
1279  };
1280 
1281  /* construct in array */
1282  ir_node *const in[] = {
1283  left,
1284  right,
1285  };
1286 
1287  ir_graph *const irg = get_irn_irg(block);
1288  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_OrN, mode_Iu, 2, in);
1289 
1290  /* flags */
1291  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1292  irn_flags |= arch_irn_flag_rematerializable;
1293 
1294  /* init node attributes */
1295  int const n_res = 1;
1296  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1297  (void)attr; /* avoid potential warning */
1298  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1299  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1300  out_infos[0].req = &sparc_class_reg_req_gp;
1301 
1302  verify_new_node(res);
1303  return optimize_node(res);
1304 }
1305 
1306 ir_node *new_bd_sparc_OrNCCZero_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
1307 {
1308  static arch_register_req_t const *in_reqs[] = {
1309  &sparc_class_reg_req_gp,
1310  };
1311 
1312  /* construct in array */
1313  ir_node *const in[] = {
1314  left,
1315  };
1316 
1317  ir_graph *const irg = get_irn_irg(block);
1318  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_OrNCCZero, mode_Bu, 1, in);
1319 
1320  /* flags */
1321  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1322  irn_flags |= arch_irn_flag_rematerializable;
1323 
1324  /* init node attributes */
1325  int const n_res = 1;
1326  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1327  (void)attr; /* avoid potential warning */
1328  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1329  sparc_set_attr_imm(res, immediate_entity, immediate_value);
1330  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1331  out_infos[0].req = &sparc_class_reg_req_flags;
1332 
1333  verify_new_node(res);
1334  return optimize_node(res);
1335 }
1336 
1337 ir_node *new_bd_sparc_OrNCCZero_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1338 {
1339  static arch_register_req_t const *in_reqs[] = {
1340  &sparc_class_reg_req_gp,
1341  &sparc_class_reg_req_gp,
1342  };
1343 
1344  /* construct in array */
1345  ir_node *const in[] = {
1346  left,
1347  right,
1348  };
1349 
1350  ir_graph *const irg = get_irn_irg(block);
1351  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_OrNCCZero, mode_Bu, 2, in);
1352 
1353  /* flags */
1354  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1355  irn_flags |= arch_irn_flag_rematerializable;
1356 
1357  /* init node attributes */
1358  int const n_res = 1;
1359  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1360  (void)attr; /* avoid potential warning */
1361  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1362  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1363  out_infos[0].req = &sparc_class_reg_req_flags;
1364 
1365  verify_new_node(res);
1366  return optimize_node(res);
1367 }
1368 
1369 ir_node *new_bd_sparc_Restore_imm(dbg_info *dbgi, ir_node *block, ir_node *stack, ir_node *frame_pointer, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
1370 {
1371  static arch_register_req_t const *in_reqs[] = {
1372  &sparc_single_reg_req_gp_sp,
1373  &sparc_single_reg_req_gp_fp,
1374  &sparc_class_reg_req_gp,
1375  };
1376 
1377  /* construct in array */
1378  ir_node *const in[] = {
1379  stack,
1380  frame_pointer,
1381  left,
1382  };
1383 
1384  ir_graph *const irg = get_irn_irg(block);
1385  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Restore, mode_T, 3, in);
1386 
1387  /* flags */
1388  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1389 
1390  /* init node attributes */
1391  int const n_res = 2;
1392  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1393  (void)attr; /* avoid potential warning */
1394  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1395  sparc_set_attr_imm(res, immediate_entity, immediate_value);
1396  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1397  out_infos[0].req = &sparc_requirements_gp_sp_I;
1398  out_infos[1].req = &sparc_class_reg_req_gp;
1399 
1400  verify_new_node(res);
1401  return optimize_node(res);
1402 }
1403 
1404 ir_node *new_bd_sparc_Restore_reg(dbg_info *dbgi, ir_node *block, ir_node *stack, ir_node *frame_pointer, ir_node *left, ir_node *right)
1405 {
1406  static arch_register_req_t const *in_reqs[] = {
1407  &sparc_single_reg_req_gp_sp,
1408  &sparc_single_reg_req_gp_fp,
1409  &sparc_class_reg_req_gp,
1410  &sparc_class_reg_req_gp,
1411  };
1412 
1413  /* construct in array */
1414  ir_node *const in[] = {
1415  stack,
1416  frame_pointer,
1417  left,
1418  right,
1419  };
1420 
1421  ir_graph *const irg = get_irn_irg(block);
1422  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Restore, mode_T, 4, in);
1423 
1424  /* flags */
1425  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1426 
1427  /* init node attributes */
1428  int const n_res = 2;
1429  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1430  (void)attr; /* avoid potential warning */
1431  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1432  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1433  out_infos[0].req = &sparc_requirements_gp_sp_I;
1434  out_infos[1].req = &sparc_class_reg_req_gp;
1435 
1436  verify_new_node(res);
1437  return optimize_node(res);
1438 }
1439 
1440 ir_node *new_bd_sparc_RestoreZero(dbg_info *dbgi, ir_node *block, ir_node *stack, ir_node *frame_pointer)
1441 {
1442  static arch_register_req_t const *in_reqs[] = {
1443  &sparc_single_reg_req_gp_sp,
1444  &sparc_single_reg_req_gp_fp,
1445  };
1446 
1447  /* construct in array */
1448  ir_node *const in[] = {
1449  stack,
1450  frame_pointer,
1451  };
1452 
1453  ir_graph *const irg = get_irn_irg(block);
1454  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_RestoreZero, mode_Iu, 2, in);
1455 
1456  /* flags */
1457  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1458 
1459  /* init node attributes */
1460  int const n_res = 1;
1461  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1462  (void)attr; /* avoid potential warning */
1463  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1464  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1465  out_infos[0].req = &sparc_requirements_gp_sp_I;
1466 
1467  verify_new_node(res);
1468  return optimize_node(res);
1469 }
1470 
1471 ir_node *new_bd_sparc_Return_imm(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs, ir_entity *entity, int32_t offset)
1472 {
1473 
1474 
1475  ir_graph *const irg = get_irn_irg(block);
1476  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Return, mode_X, arity, in);
1477 
1478  /* flags */
1479  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1480  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
1481 
1482  /* init node attributes */
1483  int const n_res = 1;
1484  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1485  (void)attr; /* avoid potential warning */
1486  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1487  sparc_set_attr_imm(res, entity, offset);
1488  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1489  out_infos[0].req = &arch_exec_requirement;
1490 
1491  verify_new_node(res);
1492  return optimize_node(res);
1493 }
1494 
1495 ir_node *new_bd_sparc_Return_reg(dbg_info *dbgi, ir_node *block, int const arity, ir_node *const *const in, arch_register_req_t const **const in_reqs)
1496 {
1497 
1498 
1499  ir_graph *const irg = get_irn_irg(block);
1500  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Return, mode_X, arity, in);
1501 
1502  /* flags */
1503  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1504  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
1505 
1506  /* init node attributes */
1507  int const n_res = 1;
1508  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1509  (void)attr; /* avoid potential warning */
1510  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1511  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1512  out_infos[0].req = &arch_exec_requirement;
1513 
1514  verify_new_node(res);
1515  return optimize_node(res);
1516 }
1517 
1518 ir_node *new_bd_sparc_SDiv_imm(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *dividend_high, ir_node *dividend_low, ir_entity *immediate_entity, int32_t immediate_value)
1519 {
1520  static arch_register_req_t const *in_reqs[] = {
1521  &arch_memory_requirement,
1522  &sparc_class_reg_req_gp,
1523  &sparc_class_reg_req_gp,
1524  };
1525 
1526  /* construct in array */
1527  ir_node *const in[] = {
1528  mem,
1529  dividend_high,
1530  dividend_low,
1531  };
1532 
1533  ir_graph *const irg = get_irn_irg(block);
1534  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SDiv, mode_T, 3, in);
1535 
1536  /* flags */
1537  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1538  irn_flags |= arch_irn_flag_rematerializable;
1539  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
1540 
1541  /* init node attributes */
1542  int const n_res = 2;
1543  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1544  (void)attr; /* avoid potential warning */
1545  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1546  sparc_set_attr_imm(res, immediate_entity, immediate_value);
1547  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1548  out_infos[0].req = &sparc_class_reg_req_gp;
1549  out_infos[1].req = &arch_memory_requirement;
1550 
1551  verify_new_node(res);
1552  return optimize_node(res);
1553 }
1554 
1555 ir_node *new_bd_sparc_SDiv_reg(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *dividend_high, ir_node *dividend_low, ir_node *divisor)
1556 {
1557  static arch_register_req_t const *in_reqs[] = {
1558  &arch_memory_requirement,
1559  &sparc_class_reg_req_gp,
1560  &sparc_class_reg_req_gp,
1561  &sparc_class_reg_req_gp,
1562  };
1563 
1564  /* construct in array */
1565  ir_node *const in[] = {
1566  mem,
1567  dividend_high,
1568  dividend_low,
1569  divisor,
1570  };
1571 
1572  ir_graph *const irg = get_irn_irg(block);
1573  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SDiv, mode_T, 4, in);
1574 
1575  /* flags */
1576  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1577  irn_flags |= arch_irn_flag_rematerializable;
1578  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
1579 
1580  /* init node attributes */
1581  int const n_res = 2;
1582  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1583  (void)attr; /* avoid potential warning */
1584  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1585  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1586  out_infos[0].req = &sparc_class_reg_req_gp;
1587  out_infos[1].req = &arch_memory_requirement;
1588 
1589  verify_new_node(res);
1590  return optimize_node(res);
1591 }
1592 
1593 ir_node *new_bd_sparc_SMul_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
1594 {
1595  static arch_register_req_t const *in_reqs[] = {
1596  &sparc_class_reg_req_gp,
1597  };
1598 
1599  /* construct in array */
1600  ir_node *const in[] = {
1601  left,
1602  };
1603 
1604  ir_graph *const irg = get_irn_irg(block);
1605  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SMul, mode_Iu, 1, in);
1606 
1607  /* flags */
1608  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1609  irn_flags |= arch_irn_flag_rematerializable;
1610 
1611  /* init node attributes */
1612  int const n_res = 1;
1613  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1614  (void)attr; /* avoid potential warning */
1615  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1616  sparc_set_attr_imm(res, immediate_entity, immediate_value);
1617  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1618  out_infos[0].req = &sparc_class_reg_req_gp;
1619 
1620  verify_new_node(res);
1621  return optimize_node(res);
1622 }
1623 
1624 ir_node *new_bd_sparc_SMul_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1625 {
1626  static arch_register_req_t const *in_reqs[] = {
1627  &sparc_class_reg_req_gp,
1628  &sparc_class_reg_req_gp,
1629  };
1630 
1631  /* construct in array */
1632  ir_node *const in[] = {
1633  left,
1634  right,
1635  };
1636 
1637  ir_graph *const irg = get_irn_irg(block);
1638  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SMul, mode_Iu, 2, in);
1639 
1640  /* flags */
1641  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1642  irn_flags |= arch_irn_flag_rematerializable;
1643 
1644  /* init node attributes */
1645  int const n_res = 1;
1646  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1647  (void)attr; /* avoid potential warning */
1648  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1649  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1650  out_infos[0].req = &sparc_class_reg_req_gp;
1651 
1652  verify_new_node(res);
1653  return optimize_node(res);
1654 }
1655 
1656 ir_node *new_bd_sparc_SMulCCZero_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
1657 {
1658  static arch_register_req_t const *in_reqs[] = {
1659  &sparc_class_reg_req_gp,
1660  };
1661 
1662  /* construct in array */
1663  ir_node *const in[] = {
1664  left,
1665  };
1666 
1667  ir_graph *const irg = get_irn_irg(block);
1668  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SMulCCZero, mode_Bu, 1, in);
1669 
1670  /* flags */
1671  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1672  irn_flags |= arch_irn_flag_rematerializable;
1673 
1674  /* init node attributes */
1675  int const n_res = 1;
1676  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1677  (void)attr; /* avoid potential warning */
1678  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1679  sparc_set_attr_imm(res, immediate_entity, immediate_value);
1680  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1681  out_infos[0].req = &sparc_class_reg_req_flags;
1682 
1683  verify_new_node(res);
1684  return optimize_node(res);
1685 }
1686 
1687 ir_node *new_bd_sparc_SMulCCZero_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1688 {
1689  static arch_register_req_t const *in_reqs[] = {
1690  &sparc_class_reg_req_gp,
1691  &sparc_class_reg_req_gp,
1692  };
1693 
1694  /* construct in array */
1695  ir_node *const in[] = {
1696  left,
1697  right,
1698  };
1699 
1700  ir_graph *const irg = get_irn_irg(block);
1701  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SMulCCZero, mode_Bu, 2, in);
1702 
1703  /* flags */
1704  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1705  irn_flags |= arch_irn_flag_rematerializable;
1706 
1707  /* init node attributes */
1708  int const n_res = 1;
1709  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1710  (void)attr; /* avoid potential warning */
1711  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1712  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1713  out_infos[0].req = &sparc_class_reg_req_flags;
1714 
1715  verify_new_node(res);
1716  return optimize_node(res);
1717 }
1718 
1719 ir_node *new_bd_sparc_SMulh_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
1720 {
1721  static arch_register_req_t const *in_reqs[] = {
1722  &sparc_class_reg_req_gp,
1723  };
1724 
1725  /* construct in array */
1726  ir_node *const in[] = {
1727  left,
1728  };
1729 
1730  ir_graph *const irg = get_irn_irg(block);
1731  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SMulh, mode_Iu, 1, in);
1732 
1733  /* flags */
1734  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1735  irn_flags |= arch_irn_flag_rematerializable;
1736 
1737  /* init node attributes */
1738  int const n_res = 1;
1739  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1740  (void)attr; /* avoid potential warning */
1741  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1742  sparc_set_attr_imm(res, immediate_entity, immediate_value);
1743  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1744  out_infos[0].req = &sparc_class_reg_req_gp;
1745 
1746  verify_new_node(res);
1747  return optimize_node(res);
1748 }
1749 
1750 ir_node *new_bd_sparc_SMulh_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1751 {
1752  static arch_register_req_t const *in_reqs[] = {
1753  &sparc_class_reg_req_gp,
1754  &sparc_class_reg_req_gp,
1755  };
1756 
1757  /* construct in array */
1758  ir_node *const in[] = {
1759  left,
1760  right,
1761  };
1762 
1763  ir_graph *const irg = get_irn_irg(block);
1764  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SMulh, mode_Iu, 2, in);
1765 
1766  /* flags */
1767  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1768  irn_flags |= arch_irn_flag_rematerializable;
1769 
1770  /* init node attributes */
1771  int const n_res = 1;
1772  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1773  (void)attr; /* avoid potential warning */
1774  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1775  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1776  out_infos[0].req = &sparc_class_reg_req_gp;
1777 
1778  verify_new_node(res);
1779  return optimize_node(res);
1780 }
1781 
1782 ir_node *new_bd_sparc_Save_imm(dbg_info *dbgi, ir_node *block, ir_node *stack, ir_entity *immediate_entity, int32_t immediate_value)
1783 {
1784  static arch_register_req_t const *in_reqs[] = {
1785  &sparc_single_reg_req_gp_sp,
1786  };
1787 
1788  /* construct in array */
1789  ir_node *const in[] = {
1790  stack,
1791  };
1792 
1793  ir_graph *const irg = get_irn_irg(block);
1794  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Save, mode_Iu, 1, in);
1795 
1796  /* flags */
1797  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1798  irn_flags |= arch_irn_flag_schedule_first;
1799 
1800  /* init node attributes */
1801  int const n_res = 1;
1802  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1803  (void)attr; /* avoid potential warning */
1804  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1805  sparc_set_attr_imm(res, immediate_entity, immediate_value);
1806  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1807  out_infos[0].req = &sparc_requirements_gp_sp_I;
1808 
1809  verify_new_node(res);
1810  return optimize_node(res);
1811 }
1812 
1813 ir_node *new_bd_sparc_Save_reg(dbg_info *dbgi, ir_node *block, ir_node *stack, ir_node *increment)
1814 {
1815  static arch_register_req_t const *in_reqs[] = {
1816  &sparc_single_reg_req_gp_sp,
1817  &sparc_class_reg_req_gp,
1818  };
1819 
1820  /* construct in array */
1821  ir_node *const in[] = {
1822  stack,
1823  increment,
1824  };
1825 
1826  ir_graph *const irg = get_irn_irg(block);
1827  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Save, mode_Iu, 2, in);
1828 
1829  /* flags */
1830  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1831  irn_flags |= arch_irn_flag_schedule_first;
1832 
1833  /* init node attributes */
1834  int const n_res = 1;
1835  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1836  (void)attr; /* avoid potential warning */
1837  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1838  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1839  out_infos[0].req = &sparc_requirements_gp_sp_I;
1840 
1841  verify_new_node(res);
1842  return optimize_node(res);
1843 }
1844 
1845 ir_node *new_bd_sparc_SetHi(dbg_info *dbgi, ir_node *block, ir_entity *entity, int32_t immediate_value)
1846 {
1847  arch_register_req_t const **const in_reqs = NULL;
1848 
1849 
1850  ir_graph *const irg = get_irn_irg(block);
1851  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SetHi, mode_Iu, 0, NULL);
1852 
1853  /* flags */
1854  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1855  irn_flags |= arch_irn_flag_rematerializable;
1856 
1857  /* init node attributes */
1858  int const n_res = 1;
1859  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1860  (void)attr; /* avoid potential warning */
1861  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1862  sparc_set_attr_imm(res, entity, immediate_value);
1863  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1864  out_infos[0].req = &sparc_class_reg_req_gp;
1865 
1866  verify_new_node(res);
1867  return optimize_node(res);
1868 }
1869 
1870 ir_node *new_bd_sparc_Sll_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
1871 {
1872  static arch_register_req_t const *in_reqs[] = {
1873  &sparc_class_reg_req_gp,
1874  };
1875 
1876  /* construct in array */
1877  ir_node *const in[] = {
1878  left,
1879  };
1880 
1881  ir_graph *const irg = get_irn_irg(block);
1882  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Sll, mode_Iu, 1, in);
1883 
1884  /* flags */
1885  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1886  irn_flags |= arch_irn_flag_rematerializable;
1887 
1888  /* init node attributes */
1889  int const n_res = 1;
1890  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1891  (void)attr; /* avoid potential warning */
1892  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1893  sparc_set_attr_imm(res, immediate_entity, immediate_value);
1894  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1895  out_infos[0].req = &sparc_class_reg_req_gp;
1896 
1897  verify_new_node(res);
1898  return optimize_node(res);
1899 }
1900 
1901 ir_node *new_bd_sparc_Sll_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1902 {
1903  static arch_register_req_t const *in_reqs[] = {
1904  &sparc_class_reg_req_gp,
1905  &sparc_class_reg_req_gp,
1906  };
1907 
1908  /* construct in array */
1909  ir_node *const in[] = {
1910  left,
1911  right,
1912  };
1913 
1914  ir_graph *const irg = get_irn_irg(block);
1915  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Sll, mode_Iu, 2, in);
1916 
1917  /* flags */
1918  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1919  irn_flags |= arch_irn_flag_rematerializable;
1920 
1921  /* init node attributes */
1922  int const n_res = 1;
1923  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1924  (void)attr; /* avoid potential warning */
1925  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1926  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1927  out_infos[0].req = &sparc_class_reg_req_gp;
1928 
1929  verify_new_node(res);
1930  return optimize_node(res);
1931 }
1932 
1933 ir_node *new_bd_sparc_Sra_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
1934 {
1935  static arch_register_req_t const *in_reqs[] = {
1936  &sparc_class_reg_req_gp,
1937  };
1938 
1939  /* construct in array */
1940  ir_node *const in[] = {
1941  left,
1942  };
1943 
1944  ir_graph *const irg = get_irn_irg(block);
1945  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Sra, mode_Iu, 1, in);
1946 
1947  /* flags */
1948  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1949  irn_flags |= arch_irn_flag_rematerializable;
1950 
1951  /* init node attributes */
1952  int const n_res = 1;
1953  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1954  (void)attr; /* avoid potential warning */
1955  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1956  sparc_set_attr_imm(res, immediate_entity, immediate_value);
1957  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1958  out_infos[0].req = &sparc_class_reg_req_gp;
1959 
1960  verify_new_node(res);
1961  return optimize_node(res);
1962 }
1963 
1964 ir_node *new_bd_sparc_Sra_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
1965 {
1966  static arch_register_req_t const *in_reqs[] = {
1967  &sparc_class_reg_req_gp,
1968  &sparc_class_reg_req_gp,
1969  };
1970 
1971  /* construct in array */
1972  ir_node *const in[] = {
1973  left,
1974  right,
1975  };
1976 
1977  ir_graph *const irg = get_irn_irg(block);
1978  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Sra, mode_Iu, 2, in);
1979 
1980  /* flags */
1981  arch_irn_flags_t irn_flags = arch_irn_flags_none;
1982  irn_flags |= arch_irn_flag_rematerializable;
1983 
1984  /* init node attributes */
1985  int const n_res = 1;
1986  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
1987  (void)attr; /* avoid potential warning */
1988  be_info_init_irn(res, irn_flags, in_reqs, n_res);
1989  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
1990  out_infos[0].req = &sparc_class_reg_req_gp;
1991 
1992  verify_new_node(res);
1993  return optimize_node(res);
1994 }
1995 
1996 ir_node *new_bd_sparc_Srl_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
1997 {
1998  static arch_register_req_t const *in_reqs[] = {
1999  &sparc_class_reg_req_gp,
2000  };
2001 
2002  /* construct in array */
2003  ir_node *const in[] = {
2004  left,
2005  };
2006 
2007  ir_graph *const irg = get_irn_irg(block);
2008  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Srl, mode_Iu, 1, in);
2009 
2010  /* flags */
2011  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2012  irn_flags |= arch_irn_flag_rematerializable;
2013 
2014  /* init node attributes */
2015  int const n_res = 1;
2016  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2017  (void)attr; /* avoid potential warning */
2018  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2019  sparc_set_attr_imm(res, immediate_entity, immediate_value);
2020  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2021  out_infos[0].req = &sparc_class_reg_req_gp;
2022 
2023  verify_new_node(res);
2024  return optimize_node(res);
2025 }
2026 
2027 ir_node *new_bd_sparc_Srl_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
2028 {
2029  static arch_register_req_t const *in_reqs[] = {
2030  &sparc_class_reg_req_gp,
2031  &sparc_class_reg_req_gp,
2032  };
2033 
2034  /* construct in array */
2035  ir_node *const in[] = {
2036  left,
2037  right,
2038  };
2039 
2040  ir_graph *const irg = get_irn_irg(block);
2041  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Srl, mode_Iu, 2, in);
2042 
2043  /* flags */
2044  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2045  irn_flags |= arch_irn_flag_rematerializable;
2046 
2047  /* init node attributes */
2048  int const n_res = 1;
2049  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2050  (void)attr; /* avoid potential warning */
2051  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2052  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2053  out_infos[0].req = &sparc_class_reg_req_gp;
2054 
2055  verify_new_node(res);
2056  return optimize_node(res);
2057 }
2058 
2059 ir_node *new_bd_sparc_St_imm(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *ptr, ir_node *mem, ir_mode *ls_mode, ir_entity *entity, int32_t offset, bool is_frame_entity)
2060 {
2061  static arch_register_req_t const *in_reqs[] = {
2062  &sparc_class_reg_req_gp,
2063  &sparc_class_reg_req_gp,
2064  &arch_memory_requirement,
2065  };
2066 
2067  /* construct in array */
2068  ir_node *const in[] = {
2069  val,
2070  ptr,
2071  mem,
2072  };
2073 
2074  ir_graph *const irg = get_irn_irg(block);
2075  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_St, mode_M, 3, in);
2076 
2077  /* flags */
2078  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2079 
2080  /* init node attributes */
2081  int const n_res = 1;
2082  sparc_load_store_attr_t *const attr = (sparc_load_store_attr_t*)get_irn_generic_attr(res);
2083  (void)attr; /* avoid potential warning */
2084  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2085  init_sparc_load_store_attributes(res, ls_mode, entity, offset, is_frame_entity, false);
2086  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2087  out_infos[0].req = &arch_memory_requirement;
2088 
2089  verify_new_node(res);
2090  return optimize_node(res);
2091 }
2092 
2093 ir_node *new_bd_sparc_St_reg(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *ptr, ir_node *ptr2, ir_node *mem, ir_mode *ls_mode)
2094 {
2095  static arch_register_req_t const *in_reqs[] = {
2096  &sparc_class_reg_req_gp,
2097  &sparc_class_reg_req_gp,
2098  &sparc_class_reg_req_gp,
2099  &arch_memory_requirement,
2100  };
2101 
2102  /* construct in array */
2103  ir_node *const in[] = {
2104  val,
2105  ptr,
2106  ptr2,
2107  mem,
2108  };
2109 
2110  ir_graph *const irg = get_irn_irg(block);
2111  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_St, mode_M, 4, in);
2112 
2113  /* flags */
2114  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2115 
2116  /* init node attributes */
2117  int const n_res = 1;
2118  sparc_load_store_attr_t *const attr = (sparc_load_store_attr_t*)get_irn_generic_attr(res);
2119  (void)attr; /* avoid potential warning */
2120  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2121  init_sparc_load_store_attributes(res, ls_mode, NULL, 0, false, true);
2122  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2123  out_infos[0].req = &arch_memory_requirement;
2124 
2125  verify_new_node(res);
2126  return optimize_node(res);
2127 }
2128 
2129 ir_node *new_bd_sparc_Stbar(dbg_info *dbgi, ir_node *block, ir_node *mem)
2130 {
2131  static arch_register_req_t const *in_reqs[] = {
2132  &arch_memory_requirement,
2133  };
2134 
2135  /* construct in array */
2136  ir_node *const in[] = {
2137  mem,
2138  };
2139 
2140  ir_graph *const irg = get_irn_irg(block);
2141  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Stbar, mode_M, 1, in);
2142 
2143  /* flags */
2144  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2145 
2146  /* init node attributes */
2147  int const n_res = 1;
2148  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2149  (void)attr; /* avoid potential warning */
2150  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2151  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2152  out_infos[0].req = &arch_memory_requirement;
2153 
2154  verify_new_node(res);
2155  return optimize_node(res);
2156 }
2157 
2158 ir_node *new_bd_sparc_Stf_d(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *ptr, ir_node *mem, ir_mode *ls_mode, ir_entity *entity, int32_t offset, bool is_frame_entity)
2159 {
2160  static arch_register_req_t const *in_reqs[] = {
2161  &sparc_requirements_fp_fp_2,
2162  &sparc_class_reg_req_gp,
2163  &arch_memory_requirement,
2164  };
2165 
2166  /* construct in array */
2167  ir_node *const in[] = {
2168  val,
2169  ptr,
2170  mem,
2171  };
2172 
2173  ir_graph *const irg = get_irn_irg(block);
2174  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Stf, mode_M, 3, in);
2175 
2176  /* flags */
2177  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2178 
2179  /* init node attributes */
2180  int const n_res = 1;
2181  sparc_load_store_attr_t *const attr = (sparc_load_store_attr_t*)get_irn_generic_attr(res);
2182  (void)attr; /* avoid potential warning */
2183  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2184  init_sparc_load_store_attributes(res, ls_mode, entity, offset, is_frame_entity, false);
2185  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2186  out_infos[0].req = &arch_memory_requirement;
2187 
2188  verify_new_node(res);
2189  return optimize_node(res);
2190 }
2191 
2192 ir_node *new_bd_sparc_Stf_q(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *ptr, ir_node *mem, ir_mode *ls_mode, ir_entity *entity, int32_t offset, bool is_frame_entity)
2193 {
2194  static arch_register_req_t const *in_reqs[] = {
2195  &sparc_requirements_fp_fp_4,
2196  &sparc_class_reg_req_gp,
2197  &arch_memory_requirement,
2198  };
2199 
2200  /* construct in array */
2201  ir_node *const in[] = {
2202  val,
2203  ptr,
2204  mem,
2205  };
2206 
2207  ir_graph *const irg = get_irn_irg(block);
2208  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Stf, mode_M, 3, in);
2209 
2210  /* flags */
2211  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2212 
2213  /* init node attributes */
2214  int const n_res = 1;
2215  sparc_load_store_attr_t *const attr = (sparc_load_store_attr_t*)get_irn_generic_attr(res);
2216  (void)attr; /* avoid potential warning */
2217  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2218  init_sparc_load_store_attributes(res, ls_mode, entity, offset, is_frame_entity, false);
2219  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2220  out_infos[0].req = &arch_memory_requirement;
2221 
2222  verify_new_node(res);
2223  return optimize_node(res);
2224 }
2225 
2226 ir_node *new_bd_sparc_Stf_s(dbg_info *dbgi, ir_node *block, ir_node *val, ir_node *ptr, ir_node *mem, ir_mode *ls_mode, ir_entity *entity, int32_t offset, bool is_frame_entity)
2227 {
2228  static arch_register_req_t const *in_reqs[] = {
2229  &sparc_class_reg_req_fp,
2230  &sparc_class_reg_req_gp,
2231  &arch_memory_requirement,
2232  };
2233 
2234  /* construct in array */
2235  ir_node *const in[] = {
2236  val,
2237  ptr,
2238  mem,
2239  };
2240 
2241  ir_graph *const irg = get_irn_irg(block);
2242  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Stf, mode_M, 3, in);
2243 
2244  /* flags */
2245  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2246 
2247  /* init node attributes */
2248  int const n_res = 1;
2249  sparc_load_store_attr_t *const attr = (sparc_load_store_attr_t*)get_irn_generic_attr(res);
2250  (void)attr; /* avoid potential warning */
2251  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2252  init_sparc_load_store_attributes(res, ls_mode, entity, offset, is_frame_entity, false);
2253  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2254  out_infos[0].req = &arch_memory_requirement;
2255 
2256  verify_new_node(res);
2257  return optimize_node(res);
2258 }
2259 
2260 ir_node *new_bd_sparc_Sub_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
2261 {
2262  static arch_register_req_t const *in_reqs[] = {
2263  &sparc_class_reg_req_gp,
2264  };
2265 
2266  /* construct in array */
2267  ir_node *const in[] = {
2268  left,
2269  };
2270 
2271  ir_graph *const irg = get_irn_irg(block);
2272  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Sub, mode_Iu, 1, in);
2273 
2274  /* flags */
2275  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2276  irn_flags |= arch_irn_flag_rematerializable;
2277 
2278  /* init node attributes */
2279  int const n_res = 1;
2280  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2281  (void)attr; /* avoid potential warning */
2282  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2283  sparc_set_attr_imm(res, immediate_entity, immediate_value);
2284  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2285  out_infos[0].req = &sparc_class_reg_req_gp;
2286 
2287  verify_new_node(res);
2288  return optimize_node(res);
2289 }
2290 
2291 ir_node *new_bd_sparc_Sub_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
2292 {
2293  static arch_register_req_t const *in_reqs[] = {
2294  &sparc_class_reg_req_gp,
2295  &sparc_class_reg_req_gp,
2296  };
2297 
2298  /* construct in array */
2299  ir_node *const in[] = {
2300  left,
2301  right,
2302  };
2303 
2304  ir_graph *const irg = get_irn_irg(block);
2305  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Sub, mode_Iu, 2, in);
2306 
2307  /* flags */
2308  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2309  irn_flags |= arch_irn_flag_rematerializable;
2310 
2311  /* init node attributes */
2312  int const n_res = 1;
2313  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2314  (void)attr; /* avoid potential warning */
2315  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2316  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2317  out_infos[0].req = &sparc_class_reg_req_gp;
2318 
2319  verify_new_node(res);
2320  return optimize_node(res);
2321 }
2322 
2323 ir_node *new_bd_sparc_SubCC_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
2324 {
2325  static arch_register_req_t const *in_reqs[] = {
2326  &sparc_class_reg_req_gp,
2327  };
2328 
2329  /* construct in array */
2330  ir_node *const in[] = {
2331  left,
2332  };
2333 
2334  ir_graph *const irg = get_irn_irg(block);
2335  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SubCC, mode_T, 1, in);
2336 
2337  /* flags */
2338  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2339  irn_flags |= arch_irn_flag_rematerializable;
2340 
2341  /* init node attributes */
2342  int const n_res = 2;
2343  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2344  (void)attr; /* avoid potential warning */
2345  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2346  sparc_set_attr_imm(res, immediate_entity, immediate_value);
2347  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2348  out_infos[0].req = &sparc_class_reg_req_gp;
2349  out_infos[1].req = &sparc_class_reg_req_flags;
2350 
2351  verify_new_node(res);
2352  return optimize_node(res);
2353 }
2354 
2355 ir_node *new_bd_sparc_SubCC_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
2356 {
2357  static arch_register_req_t const *in_reqs[] = {
2358  &sparc_class_reg_req_gp,
2359  &sparc_class_reg_req_gp,
2360  };
2361 
2362  /* construct in array */
2363  ir_node *const in[] = {
2364  left,
2365  right,
2366  };
2367 
2368  ir_graph *const irg = get_irn_irg(block);
2369  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SubCC, mode_T, 2, in);
2370 
2371  /* flags */
2372  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2373  irn_flags |= arch_irn_flag_rematerializable;
2374 
2375  /* init node attributes */
2376  int const n_res = 2;
2377  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2378  (void)attr; /* avoid potential warning */
2379  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2380  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2381  out_infos[0].req = &sparc_class_reg_req_gp;
2382  out_infos[1].req = &sparc_class_reg_req_flags;
2383 
2384  verify_new_node(res);
2385  return optimize_node(res);
2386 }
2387 
2388 ir_node *new_bd_sparc_SubCC_t(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
2389 {
2390 
2391  /* construct in array */
2392  ir_node *const in[] = {
2393  left,
2394  right,
2395  };
2396 
2397  ir_graph *const irg = get_irn_irg(block);
2398  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SubCC_t, mode_T, 2, in);
2399 
2400  /* flags */
2401  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2402 
2403  /* init node attributes */
2404  int const n_res = 2;
2405  (void)irn_flags, (void)n_res;
2406 
2407  verify_new_node(res);
2408  return optimize_node(res);
2409 }
2410 
2411 ir_node *new_bd_sparc_SubSP_imm(dbg_info *dbgi, ir_node *block, ir_node *stack, ir_node *mem, ir_entity *immediate_entity, int32_t immediate_value)
2412 {
2413  static arch_register_req_t const *in_reqs[] = {
2414  &sparc_single_reg_req_gp_sp,
2415  &arch_memory_requirement,
2416  };
2417 
2418  /* construct in array */
2419  ir_node *const in[] = {
2420  stack,
2421  mem,
2422  };
2423 
2424  ir_graph *const irg = get_irn_irg(block);
2425  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SubSP, mode_T, 2, in);
2426 
2427  /* flags */
2428  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2429 
2430  /* init node attributes */
2431  int const n_res = 3;
2432  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2433  (void)attr; /* avoid potential warning */
2434  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2435  sparc_set_attr_imm(res, immediate_entity, immediate_value);
2436  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2437  out_infos[0].req = &sparc_requirements_gp_sp_I;
2438  out_infos[1].req = &sparc_class_reg_req_gp;
2439  out_infos[2].req = &arch_memory_requirement;
2440 
2441  verify_new_node(res);
2442  return optimize_node(res);
2443 }
2444 
2445 ir_node *new_bd_sparc_SubSP_reg(dbg_info *dbgi, ir_node *block, ir_node *stack, ir_node *size, ir_node *mem)
2446 {
2447  static arch_register_req_t const *in_reqs[] = {
2448  &sparc_single_reg_req_gp_sp,
2449  &sparc_class_reg_req_gp,
2450  &arch_memory_requirement,
2451  };
2452 
2453  /* construct in array */
2454  ir_node *const in[] = {
2455  stack,
2456  size,
2457  mem,
2458  };
2459 
2460  ir_graph *const irg = get_irn_irg(block);
2461  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SubSP, mode_T, 3, in);
2462 
2463  /* flags */
2464  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2465 
2466  /* init node attributes */
2467  int const n_res = 3;
2468  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2469  (void)attr; /* avoid potential warning */
2470  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2471  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2472  out_infos[0].req = &sparc_requirements_gp_sp_I;
2473  out_infos[1].req = &sparc_class_reg_req_gp;
2474  out_infos[2].req = &arch_memory_requirement;
2475 
2476  verify_new_node(res);
2477  return optimize_node(res);
2478 }
2479 
2480 ir_node *new_bd_sparc_SubX_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *carry, ir_entity *immediate_entity, int32_t immediate_value)
2481 {
2482  static arch_register_req_t const *in_reqs[] = {
2483  &sparc_class_reg_req_gp,
2484  &sparc_class_reg_req_flags,
2485  };
2486 
2487  /* construct in array */
2488  ir_node *const in[] = {
2489  left,
2490  carry,
2491  };
2492 
2493  ir_graph *const irg = get_irn_irg(block);
2494  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SubX, mode_Iu, 2, in);
2495 
2496  /* flags */
2497  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2498 
2499  /* init node attributes */
2500  int const n_res = 1;
2501  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2502  (void)attr; /* avoid potential warning */
2503  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2504  sparc_set_attr_imm(res, immediate_entity, immediate_value);
2505  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2506  out_infos[0].req = &sparc_class_reg_req_gp;
2507 
2508  verify_new_node(res);
2509  return optimize_node(res);
2510 }
2511 
2512 ir_node *new_bd_sparc_SubX_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_node *carry)
2513 {
2514  static arch_register_req_t const *in_reqs[] = {
2515  &sparc_class_reg_req_gp,
2516  &sparc_class_reg_req_gp,
2517  &sparc_class_reg_req_flags,
2518  };
2519 
2520  /* construct in array */
2521  ir_node *const in[] = {
2522  left,
2523  right,
2524  carry,
2525  };
2526 
2527  ir_graph *const irg = get_irn_irg(block);
2528  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SubX, mode_Iu, 3, in);
2529 
2530  /* flags */
2531  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2532 
2533  /* init node attributes */
2534  int const n_res = 1;
2535  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2536  (void)attr; /* avoid potential warning */
2537  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2538  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2539  out_infos[0].req = &sparc_class_reg_req_gp;
2540 
2541  verify_new_node(res);
2542  return optimize_node(res);
2543 }
2544 
2545 ir_node *new_bd_sparc_SubX_t(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_node *flags_input, ir_mode *mode)
2546 {
2547 
2548  /* construct in array */
2549  ir_node *const in[] = {
2550  left,
2551  right,
2552  flags_input,
2553  };
2554 
2555  ir_graph *const irg = get_irn_irg(block);
2556  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SubX_t, mode, 3, in);
2557 
2558  /* flags */
2559  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2560 
2561  /* init node attributes */
2562  int const n_res = 0;
2563  (void)irn_flags, (void)n_res;
2564 
2565  verify_new_node(res);
2566  return optimize_node(res);
2567 }
2568 
2569 ir_node *new_bd_sparc_SwitchJmp(dbg_info *dbgi, ir_node *block, ir_node *op0, int n_res, const ir_switch_table *table, ir_entity *jump_table)
2570 {
2571  static arch_register_req_t const *in_reqs[] = {
2572  &sparc_class_reg_req_gp,
2573  };
2574 
2575  /* construct in array */
2576  ir_node *const in[] = {
2577  op0,
2578  };
2579 
2580  ir_graph *const irg = get_irn_irg(block);
2581  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_SwitchJmp, mode_T, 1, in);
2582 
2583  /* flags */
2584  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2585  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
2586 
2587  /* init node attributes */
2588  sparc_switch_jmp_attr_t *const attr = (sparc_switch_jmp_attr_t*)get_irn_generic_attr(res);
2589  (void)attr; /* avoid potential warning */
2590  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2591  be_switch_attr_init(res, &attr->swtch, table, jump_table);
2592 
2593 
2594  verify_new_node(res);
2595  return optimize_node(res);
2596 }
2597 
2598 ir_node *new_bd_sparc_UDiv_imm(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *dividend_high, ir_node *dividend_low, ir_entity *immediate_entity, int32_t immediate_value)
2599 {
2600  static arch_register_req_t const *in_reqs[] = {
2601  &arch_memory_requirement,
2602  &sparc_class_reg_req_gp,
2603  &sparc_class_reg_req_gp,
2604  };
2605 
2606  /* construct in array */
2607  ir_node *const in[] = {
2608  mem,
2609  dividend_high,
2610  dividend_low,
2611  };
2612 
2613  ir_graph *const irg = get_irn_irg(block);
2614  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_UDiv, mode_T, 3, in);
2615 
2616  /* flags */
2617  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2618  irn_flags |= arch_irn_flag_rematerializable;
2619  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
2620 
2621  /* init node attributes */
2622  int const n_res = 2;
2623  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2624  (void)attr; /* avoid potential warning */
2625  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2626  sparc_set_attr_imm(res, immediate_entity, immediate_value);
2627  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2628  out_infos[0].req = &sparc_class_reg_req_gp;
2629  out_infos[1].req = &arch_memory_requirement;
2630 
2631  verify_new_node(res);
2632  return optimize_node(res);
2633 }
2634 
2635 ir_node *new_bd_sparc_UDiv_reg(dbg_info *dbgi, ir_node *block, ir_node *mem, ir_node *dividend_high, ir_node *dividend_low, ir_node *divisor)
2636 {
2637  static arch_register_req_t const *in_reqs[] = {
2638  &arch_memory_requirement,
2639  &sparc_class_reg_req_gp,
2640  &sparc_class_reg_req_gp,
2641  &sparc_class_reg_req_gp,
2642  };
2643 
2644  /* construct in array */
2645  ir_node *const in[] = {
2646  mem,
2647  dividend_high,
2648  dividend_low,
2649  divisor,
2650  };
2651 
2652  ir_graph *const irg = get_irn_irg(block);
2653  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_UDiv, mode_T, 4, in);
2654 
2655  /* flags */
2656  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2657  irn_flags |= arch_irn_flag_rematerializable;
2658  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
2659 
2660  /* init node attributes */
2661  int const n_res = 2;
2662  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2663  (void)attr; /* avoid potential warning */
2664  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2665  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2666  out_infos[0].req = &sparc_class_reg_req_gp;
2667  out_infos[1].req = &arch_memory_requirement;
2668 
2669  verify_new_node(res);
2670  return optimize_node(res);
2671 }
2672 
2673 ir_node *new_bd_sparc_UMulh_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
2674 {
2675  static arch_register_req_t const *in_reqs[] = {
2676  &sparc_class_reg_req_gp,
2677  };
2678 
2679  /* construct in array */
2680  ir_node *const in[] = {
2681  left,
2682  };
2683 
2684  ir_graph *const irg = get_irn_irg(block);
2685  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_UMulh, mode_Iu, 1, in);
2686 
2687  /* flags */
2688  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2689  irn_flags |= arch_irn_flag_rematerializable;
2690 
2691  /* init node attributes */
2692  int const n_res = 1;
2693  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2694  (void)attr; /* avoid potential warning */
2695  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2696  sparc_set_attr_imm(res, immediate_entity, immediate_value);
2697  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2698  out_infos[0].req = &sparc_class_reg_req_gp;
2699 
2700  verify_new_node(res);
2701  return optimize_node(res);
2702 }
2703 
2704 ir_node *new_bd_sparc_UMulh_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
2705 {
2706  static arch_register_req_t const *in_reqs[] = {
2707  &sparc_class_reg_req_gp,
2708  &sparc_class_reg_req_gp,
2709  };
2710 
2711  /* construct in array */
2712  ir_node *const in[] = {
2713  left,
2714  right,
2715  };
2716 
2717  ir_graph *const irg = get_irn_irg(block);
2718  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_UMulh, mode_Iu, 2, in);
2719 
2720  /* flags */
2721  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2722  irn_flags |= arch_irn_flag_rematerializable;
2723 
2724  /* init node attributes */
2725  int const n_res = 1;
2726  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2727  (void)attr; /* avoid potential warning */
2728  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2729  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2730  out_infos[0].req = &sparc_class_reg_req_gp;
2731 
2732  verify_new_node(res);
2733  return optimize_node(res);
2734 }
2735 
2736 ir_node *new_bd_sparc_XNor_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
2737 {
2738  static arch_register_req_t const *in_reqs[] = {
2739  &sparc_class_reg_req_gp,
2740  };
2741 
2742  /* construct in array */
2743  ir_node *const in[] = {
2744  left,
2745  };
2746 
2747  ir_graph *const irg = get_irn_irg(block);
2748  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_XNor, mode_Iu, 1, in);
2749 
2750  /* flags */
2751  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2752  irn_flags |= arch_irn_flag_rematerializable;
2753 
2754  /* init node attributes */
2755  int const n_res = 1;
2756  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2757  (void)attr; /* avoid potential warning */
2758  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2759  sparc_set_attr_imm(res, immediate_entity, immediate_value);
2760  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2761  out_infos[0].req = &sparc_class_reg_req_gp;
2762 
2763  verify_new_node(res);
2764  return optimize_node(res);
2765 }
2766 
2767 ir_node *new_bd_sparc_XNor_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
2768 {
2769  static arch_register_req_t const *in_reqs[] = {
2770  &sparc_class_reg_req_gp,
2771  &sparc_class_reg_req_gp,
2772  };
2773 
2774  /* construct in array */
2775  ir_node *const in[] = {
2776  left,
2777  right,
2778  };
2779 
2780  ir_graph *const irg = get_irn_irg(block);
2781  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_XNor, mode_Iu, 2, in);
2782 
2783  /* flags */
2784  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2785  irn_flags |= arch_irn_flag_rematerializable;
2786 
2787  /* init node attributes */
2788  int const n_res = 1;
2789  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2790  (void)attr; /* avoid potential warning */
2791  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2792  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2793  out_infos[0].req = &sparc_class_reg_req_gp;
2794 
2795  verify_new_node(res);
2796  return optimize_node(res);
2797 }
2798 
2799 ir_node *new_bd_sparc_XNorCCZero_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
2800 {
2801  static arch_register_req_t const *in_reqs[] = {
2802  &sparc_class_reg_req_gp,
2803  };
2804 
2805  /* construct in array */
2806  ir_node *const in[] = {
2807  left,
2808  };
2809 
2810  ir_graph *const irg = get_irn_irg(block);
2811  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_XNorCCZero, mode_Bu, 1, in);
2812 
2813  /* flags */
2814  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2815  irn_flags |= arch_irn_flag_rematerializable;
2816 
2817  /* init node attributes */
2818  int const n_res = 1;
2819  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2820  (void)attr; /* avoid potential warning */
2821  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2822  sparc_set_attr_imm(res, immediate_entity, immediate_value);
2823  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2824  out_infos[0].req = &sparc_class_reg_req_flags;
2825 
2826  verify_new_node(res);
2827  return optimize_node(res);
2828 }
2829 
2830 ir_node *new_bd_sparc_XNorCCZero_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
2831 {
2832  static arch_register_req_t const *in_reqs[] = {
2833  &sparc_class_reg_req_gp,
2834  &sparc_class_reg_req_gp,
2835  };
2836 
2837  /* construct in array */
2838  ir_node *const in[] = {
2839  left,
2840  right,
2841  };
2842 
2843  ir_graph *const irg = get_irn_irg(block);
2844  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_XNorCCZero, mode_Bu, 2, in);
2845 
2846  /* flags */
2847  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2848  irn_flags |= arch_irn_flag_rematerializable;
2849 
2850  /* init node attributes */
2851  int const n_res = 1;
2852  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2853  (void)attr; /* avoid potential warning */
2854  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2855  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2856  out_infos[0].req = &sparc_class_reg_req_flags;
2857 
2858  verify_new_node(res);
2859  return optimize_node(res);
2860 }
2861 
2862 ir_node *new_bd_sparc_Xor_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
2863 {
2864  static arch_register_req_t const *in_reqs[] = {
2865  &sparc_class_reg_req_gp,
2866  };
2867 
2868  /* construct in array */
2869  ir_node *const in[] = {
2870  left,
2871  };
2872 
2873  ir_graph *const irg = get_irn_irg(block);
2874  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Xor, mode_Iu, 1, in);
2875 
2876  /* flags */
2877  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2878  irn_flags |= arch_irn_flag_rematerializable;
2879 
2880  /* init node attributes */
2881  int const n_res = 1;
2882  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2883  (void)attr; /* avoid potential warning */
2884  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2885  sparc_set_attr_imm(res, immediate_entity, immediate_value);
2886  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2887  out_infos[0].req = &sparc_class_reg_req_gp;
2888 
2889  verify_new_node(res);
2890  return optimize_node(res);
2891 }
2892 
2893 ir_node *new_bd_sparc_Xor_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
2894 {
2895  static arch_register_req_t const *in_reqs[] = {
2896  &sparc_class_reg_req_gp,
2897  &sparc_class_reg_req_gp,
2898  };
2899 
2900  /* construct in array */
2901  ir_node *const in[] = {
2902  left,
2903  right,
2904  };
2905 
2906  ir_graph *const irg = get_irn_irg(block);
2907  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_Xor, mode_Iu, 2, in);
2908 
2909  /* flags */
2910  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2911  irn_flags |= arch_irn_flag_rematerializable;
2912 
2913  /* init node attributes */
2914  int const n_res = 1;
2915  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2916  (void)attr; /* avoid potential warning */
2917  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2918  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2919  out_infos[0].req = &sparc_class_reg_req_gp;
2920 
2921  verify_new_node(res);
2922  return optimize_node(res);
2923 }
2924 
2925 ir_node *new_bd_sparc_XorCCZero_imm(dbg_info *dbgi, ir_node *block, ir_node *left, ir_entity *immediate_entity, int32_t immediate_value)
2926 {
2927  static arch_register_req_t const *in_reqs[] = {
2928  &sparc_class_reg_req_gp,
2929  };
2930 
2931  /* construct in array */
2932  ir_node *const in[] = {
2933  left,
2934  };
2935 
2936  ir_graph *const irg = get_irn_irg(block);
2937  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_XorCCZero, mode_Bu, 1, in);
2938 
2939  /* flags */
2940  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2941  irn_flags |= arch_irn_flag_rematerializable;
2942 
2943  /* init node attributes */
2944  int const n_res = 1;
2945  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2946  (void)attr; /* avoid potential warning */
2947  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2948  sparc_set_attr_imm(res, immediate_entity, immediate_value);
2949  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2950  out_infos[0].req = &sparc_class_reg_req_flags;
2951 
2952  verify_new_node(res);
2953  return optimize_node(res);
2954 }
2955 
2956 ir_node *new_bd_sparc_XorCCZero_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
2957 {
2958  static arch_register_req_t const *in_reqs[] = {
2959  &sparc_class_reg_req_gp,
2960  &sparc_class_reg_req_gp,
2961  };
2962 
2963  /* construct in array */
2964  ir_node *const in[] = {
2965  left,
2966  right,
2967  };
2968 
2969  ir_graph *const irg = get_irn_irg(block);
2970  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_XorCCZero, mode_Bu, 2, in);
2971 
2972  /* flags */
2973  arch_irn_flags_t irn_flags = arch_irn_flags_none;
2974  irn_flags |= arch_irn_flag_rematerializable;
2975 
2976  /* init node attributes */
2977  int const n_res = 1;
2978  sparc_attr_t *const attr = (sparc_attr_t*)get_irn_generic_attr(res);
2979  (void)attr; /* avoid potential warning */
2980  be_info_init_irn(res, irn_flags, in_reqs, n_res);
2981  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
2982  out_infos[0].req = &sparc_class_reg_req_flags;
2983 
2984  verify_new_node(res);
2985  return optimize_node(res);
2986 }
2987 
2988 ir_node *new_bd_sparc_fabs_d(dbg_info *dbgi, ir_node *block, ir_node *val, ir_mode *fp_mode)
2989 {
2990  static arch_register_req_t const *in_reqs[] = {
2991  &sparc_requirements_fp_fp_2,
2992  };
2993 
2994  /* construct in array */
2995  ir_node *const in[] = {
2996  val,
2997  };
2998 
2999  ir_graph *const irg = get_irn_irg(block);
3000  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fabs, mode_D, 1, in);
3001 
3002  /* flags */
3003  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3004  irn_flags |= arch_irn_flag_rematerializable;
3005 
3006  /* init node attributes */
3007  int const n_res = 1;
3008  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3009  (void)attr; /* avoid potential warning */
3010  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3011  init_sparc_fp_attributes(res, fp_mode);
3012 
3013  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3014  out_infos[0].req = &sparc_requirements_fp_fp_2;
3015 
3016  verify_new_node(res);
3017  return optimize_node(res);
3018 }
3019 
3020 ir_node *new_bd_sparc_fabs_q(dbg_info *dbgi, ir_node *block, ir_node *val, ir_mode *fp_mode)
3021 {
3022  static arch_register_req_t const *in_reqs[] = {
3023  &sparc_requirements_fp_fp_4,
3024  };
3025 
3026  /* construct in array */
3027  ir_node *const in[] = {
3028  val,
3029  };
3030 
3031  ir_graph *const irg = get_irn_irg(block);
3032  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fabs, sparc_mode_Q, 1, in);
3033 
3034  /* flags */
3035  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3036  irn_flags |= arch_irn_flag_rematerializable;
3037 
3038  /* init node attributes */
3039  int const n_res = 1;
3040  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3041  (void)attr; /* avoid potential warning */
3042  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3043  init_sparc_fp_attributes(res, fp_mode);
3044 
3045  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3046  out_infos[0].req = &sparc_requirements_fp_fp_4;
3047 
3048  verify_new_node(res);
3049  return optimize_node(res);
3050 }
3051 
3052 ir_node *new_bd_sparc_fabs_s(dbg_info *dbgi, ir_node *block, ir_node *val, ir_mode *fp_mode)
3053 {
3054  static arch_register_req_t const *in_reqs[] = {
3055  &sparc_class_reg_req_fp,
3056  };
3057 
3058  /* construct in array */
3059  ir_node *const in[] = {
3060  val,
3061  };
3062 
3063  ir_graph *const irg = get_irn_irg(block);
3064  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fabs, mode_F, 1, in);
3065 
3066  /* flags */
3067  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3068  irn_flags |= arch_irn_flag_rematerializable;
3069 
3070  /* init node attributes */
3071  int const n_res = 1;
3072  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3073  (void)attr; /* avoid potential warning */
3074  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3075  init_sparc_fp_attributes(res, fp_mode);
3076 
3077  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3078  out_infos[0].req = &sparc_class_reg_req_fp;
3079 
3080  verify_new_node(res);
3081  return optimize_node(res);
3082 }
3083 
3084 ir_node *new_bd_sparc_fadd_d(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_mode *fp_mode)
3085 {
3086  static arch_register_req_t const *in_reqs[] = {
3087  &sparc_requirements_fp_fp_2,
3088  &sparc_requirements_fp_fp_2,
3089  };
3090 
3091  /* construct in array */
3092  ir_node *const in[] = {
3093  left,
3094  right,
3095  };
3096 
3097  ir_graph *const irg = get_irn_irg(block);
3098  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fadd, mode_D, 2, in);
3099 
3100  /* flags */
3101  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3102  irn_flags |= arch_irn_flag_rematerializable;
3103 
3104  /* init node attributes */
3105  int const n_res = 1;
3106  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3107  (void)attr; /* avoid potential warning */
3108  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3109  init_sparc_fp_attributes(res, fp_mode);
3110 
3111  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3112  out_infos[0].req = &sparc_requirements_fp_fp_2;
3113 
3114  verify_new_node(res);
3115  return optimize_node(res);
3116 }
3117 
3118 ir_node *new_bd_sparc_fadd_q(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_mode *fp_mode)
3119 {
3120  static arch_register_req_t const *in_reqs[] = {
3121  &sparc_requirements_fp_fp_4,
3122  &sparc_requirements_fp_fp_4,
3123  };
3124 
3125  /* construct in array */
3126  ir_node *const in[] = {
3127  left,
3128  right,
3129  };
3130 
3131  ir_graph *const irg = get_irn_irg(block);
3132  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fadd, sparc_mode_Q, 2, in);
3133 
3134  /* flags */
3135  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3136  irn_flags |= arch_irn_flag_rematerializable;
3137 
3138  /* init node attributes */
3139  int const n_res = 1;
3140  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3141  (void)attr; /* avoid potential warning */
3142  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3143  init_sparc_fp_attributes(res, fp_mode);
3144 
3145  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3146  out_infos[0].req = &sparc_requirements_fp_fp_4;
3147 
3148  verify_new_node(res);
3149  return optimize_node(res);
3150 }
3151 
3152 ir_node *new_bd_sparc_fadd_s(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_mode *fp_mode)
3153 {
3154  static arch_register_req_t const *in_reqs[] = {
3155  &sparc_class_reg_req_fp,
3156  &sparc_class_reg_req_fp,
3157  };
3158 
3159  /* construct in array */
3160  ir_node *const in[] = {
3161  left,
3162  right,
3163  };
3164 
3165  ir_graph *const irg = get_irn_irg(block);
3166  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fadd, mode_F, 2, in);
3167 
3168  /* flags */
3169  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3170  irn_flags |= arch_irn_flag_rematerializable;
3171 
3172  /* init node attributes */
3173  int const n_res = 1;
3174  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3175  (void)attr; /* avoid potential warning */
3176  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3177  init_sparc_fp_attributes(res, fp_mode);
3178 
3179  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3180  out_infos[0].req = &sparc_class_reg_req_fp;
3181 
3182  verify_new_node(res);
3183  return optimize_node(res);
3184 }
3185 
3186 ir_node *new_bd_sparc_fbfcc(dbg_info *dbgi, ir_node *block, ir_node *flags, ir_relation relation)
3187 {
3188  static arch_register_req_t const *in_reqs[] = {
3189  &sparc_class_reg_req_fpflags,
3190  };
3191 
3192  /* construct in array */
3193  ir_node *const in[] = {
3194  flags,
3195  };
3196 
3197  ir_graph *const irg = get_irn_irg(block);
3198  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fbfcc, mode_T, 1, in);
3199 
3200  /* flags */
3201  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3202  irn_flags |= (arch_irn_flags_t)sparc_arch_irn_flag_has_delay_slot;
3203 
3204  /* init node attributes */
3205  int const n_res = 2;
3206  sparc_jmp_cond_attr_t *const attr = (sparc_jmp_cond_attr_t*)get_irn_generic_attr(res);
3207  (void)attr; /* avoid potential warning */
3208  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3209  init_sparc_jmp_cond_attr(res, relation, false);
3210  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3211  out_infos[0].req = &arch_exec_requirement;
3212  out_infos[1].req = &arch_exec_requirement;
3213 
3214  verify_new_node(res);
3215  return optimize_node(res);
3216 }
3217 
3218 ir_node *new_bd_sparc_fcmp_d(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1, ir_mode *fp_mode)
3219 {
3220  static arch_register_req_t const *in_reqs[] = {
3221  &sparc_requirements_fp_fp_2,
3222  &sparc_requirements_fp_fp_2,
3223  };
3224 
3225  /* construct in array */
3226  ir_node *const in[] = {
3227  op0,
3228  op1,
3229  };
3230 
3231  ir_graph *const irg = get_irn_irg(block);
3232  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fcmp, mode_Bu, 2, in);
3233 
3234  /* flags */
3235  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3236  irn_flags |= arch_irn_flag_rematerializable;
3237 
3238  /* init node attributes */
3239  int const n_res = 1;
3240  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3241  (void)attr; /* avoid potential warning */
3242  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3243  init_sparc_fp_attributes(res, fp_mode);
3244 
3245  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3246  out_infos[0].req = &sparc_class_reg_req_fpflags;
3247 
3248  verify_new_node(res);
3249  return optimize_node(res);
3250 }
3251 
3252 ir_node *new_bd_sparc_fcmp_q(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1, ir_mode *fp_mode)
3253 {
3254  static arch_register_req_t const *in_reqs[] = {
3255  &sparc_requirements_fp_fp_4,
3256  &sparc_requirements_fp_fp_4,
3257  };
3258 
3259  /* construct in array */
3260  ir_node *const in[] = {
3261  op0,
3262  op1,
3263  };
3264 
3265  ir_graph *const irg = get_irn_irg(block);
3266  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fcmp, mode_Bu, 2, in);
3267 
3268  /* flags */
3269  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3270  irn_flags |= arch_irn_flag_rematerializable;
3271 
3272  /* init node attributes */
3273  int const n_res = 1;
3274  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3275  (void)attr; /* avoid potential warning */
3276  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3277  init_sparc_fp_attributes(res, fp_mode);
3278 
3279  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3280  out_infos[0].req = &sparc_class_reg_req_fpflags;
3281 
3282  verify_new_node(res);
3283  return optimize_node(res);
3284 }
3285 
3286 ir_node *new_bd_sparc_fcmp_s(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_node *op1, ir_mode *fp_mode)
3287 {
3288  static arch_register_req_t const *in_reqs[] = {
3289  &sparc_class_reg_req_fp,
3290  &sparc_class_reg_req_fp,
3291  };
3292 
3293  /* construct in array */
3294  ir_node *const in[] = {
3295  op0,
3296  op1,
3297  };
3298 
3299  ir_graph *const irg = get_irn_irg(block);
3300  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fcmp, mode_Bu, 2, in);
3301 
3302  /* flags */
3303  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3304  irn_flags |= arch_irn_flag_rematerializable;
3305 
3306  /* init node attributes */
3307  int const n_res = 1;
3308  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3309  (void)attr; /* avoid potential warning */
3310  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3311  init_sparc_fp_attributes(res, fp_mode);
3312 
3313  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3314  out_infos[0].req = &sparc_class_reg_req_fpflags;
3315 
3316  verify_new_node(res);
3317  return optimize_node(res);
3318 }
3319 
3320 ir_node *new_bd_sparc_fdiv_d(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_mode *fp_mode)
3321 {
3322  static arch_register_req_t const *in_reqs[] = {
3323  &sparc_requirements_fp_fp_2,
3324  &sparc_requirements_fp_fp_2,
3325  };
3326 
3327  /* construct in array */
3328  ir_node *const in[] = {
3329  left,
3330  right,
3331  };
3332 
3333  ir_graph *const irg = get_irn_irg(block);
3334  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fdiv, mode_T, 2, in);
3335 
3336  /* flags */
3337  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3338  irn_flags |= arch_irn_flag_rematerializable;
3339 
3340  /* init node attributes */
3341  int const n_res = 2;
3342  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3343  (void)attr; /* avoid potential warning */
3344  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3345  init_sparc_fp_attributes(res, fp_mode);
3346 
3347  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3348  out_infos[0].req = &sparc_requirements_fp_fp_2;
3349  out_infos[1].req = &arch_memory_requirement;
3350 
3351  verify_new_node(res);
3352  return optimize_node(res);
3353 }
3354 
3355 ir_node *new_bd_sparc_fdiv_q(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_mode *fp_mode)
3356 {
3357  static arch_register_req_t const *in_reqs[] = {
3358  &sparc_requirements_fp_fp_4,
3359  &sparc_requirements_fp_fp_4,
3360  };
3361 
3362  /* construct in array */
3363  ir_node *const in[] = {
3364  left,
3365  right,
3366  };
3367 
3368  ir_graph *const irg = get_irn_irg(block);
3369  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fdiv, mode_T, 2, in);
3370 
3371  /* flags */
3372  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3373  irn_flags |= arch_irn_flag_rematerializable;
3374 
3375  /* init node attributes */
3376  int const n_res = 2;
3377  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3378  (void)attr; /* avoid potential warning */
3379  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3380  init_sparc_fp_attributes(res, fp_mode);
3381 
3382  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3383  out_infos[0].req = &sparc_requirements_fp_fp_4;
3384  out_infos[1].req = &arch_memory_requirement;
3385 
3386  verify_new_node(res);
3387  return optimize_node(res);
3388 }
3389 
3390 ir_node *new_bd_sparc_fdiv_s(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_mode *fp_mode)
3391 {
3392  static arch_register_req_t const *in_reqs[] = {
3393  &sparc_class_reg_req_fp,
3394  &sparc_class_reg_req_fp,
3395  };
3396 
3397  /* construct in array */
3398  ir_node *const in[] = {
3399  left,
3400  right,
3401  };
3402 
3403  ir_graph *const irg = get_irn_irg(block);
3404  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fdiv, mode_T, 2, in);
3405 
3406  /* flags */
3407  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3408  irn_flags |= arch_irn_flag_rematerializable;
3409 
3410  /* init node attributes */
3411  int const n_res = 2;
3412  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3413  (void)attr; /* avoid potential warning */
3414  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3415  init_sparc_fp_attributes(res, fp_mode);
3416 
3417  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3418  out_infos[0].req = &sparc_class_reg_req_fp;
3419  out_infos[1].req = &arch_memory_requirement;
3420 
3421  verify_new_node(res);
3422  return optimize_node(res);
3423 }
3424 
3425 ir_node *new_bd_sparc_fftof_d_q(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_mode *src_mode, ir_mode *dest_mode)
3426 {
3427  static arch_register_req_t const *in_reqs[] = {
3428  &sparc_requirements_fp_fp_2,
3429  };
3430 
3431  /* construct in array */
3432  ir_node *const in[] = {
3433  op0,
3434  };
3435 
3436  ir_graph *const irg = get_irn_irg(block);
3437  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fftof, sparc_mode_Q, 1, in);
3438 
3439  /* flags */
3440  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3441  irn_flags |= arch_irn_flag_rematerializable;
3442 
3443  /* init node attributes */
3444  int const n_res = 1;
3445  sparc_fp_conv_attr_t *const attr = (sparc_fp_conv_attr_t*)get_irn_generic_attr(res);
3446  (void)attr; /* avoid potential warning */
3447  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3448  init_sparc_fp_conv_attributes(res, src_mode, dest_mode);
3449 
3450  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3451  out_infos[0].req = &sparc_requirements_fp_fp_4;
3452 
3453  verify_new_node(res);
3454  return optimize_node(res);
3455 }
3456 
3457 ir_node *new_bd_sparc_fftof_d_s(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_mode *src_mode, ir_mode *dest_mode)
3458 {
3459  static arch_register_req_t const *in_reqs[] = {
3460  &sparc_requirements_fp_fp_2,
3461  };
3462 
3463  /* construct in array */
3464  ir_node *const in[] = {
3465  op0,
3466  };
3467 
3468  ir_graph *const irg = get_irn_irg(block);
3469  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fftof, mode_F, 1, in);
3470 
3471  /* flags */
3472  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3473  irn_flags |= arch_irn_flag_rematerializable;
3474 
3475  /* init node attributes */
3476  int const n_res = 1;
3477  sparc_fp_conv_attr_t *const attr = (sparc_fp_conv_attr_t*)get_irn_generic_attr(res);
3478  (void)attr; /* avoid potential warning */
3479  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3480  init_sparc_fp_conv_attributes(res, src_mode, dest_mode);
3481 
3482  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3483  out_infos[0].req = &sparc_class_reg_req_fp;
3484 
3485  verify_new_node(res);
3486  return optimize_node(res);
3487 }
3488 
3489 ir_node *new_bd_sparc_fftof_q_d(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_mode *src_mode, ir_mode *dest_mode)
3490 {
3491  static arch_register_req_t const *in_reqs[] = {
3492  &sparc_requirements_fp_fp_4,
3493  };
3494 
3495  /* construct in array */
3496  ir_node *const in[] = {
3497  op0,
3498  };
3499 
3500  ir_graph *const irg = get_irn_irg(block);
3501  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fftof, mode_D, 1, in);
3502 
3503  /* flags */
3504  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3505  irn_flags |= arch_irn_flag_rematerializable;
3506 
3507  /* init node attributes */
3508  int const n_res = 1;
3509  sparc_fp_conv_attr_t *const attr = (sparc_fp_conv_attr_t*)get_irn_generic_attr(res);
3510  (void)attr; /* avoid potential warning */
3511  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3512  init_sparc_fp_conv_attributes(res, src_mode, dest_mode);
3513 
3514  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3515  out_infos[0].req = &sparc_requirements_fp_fp_2;
3516 
3517  verify_new_node(res);
3518  return optimize_node(res);
3519 }
3520 
3521 ir_node *new_bd_sparc_fftof_q_s(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_mode *src_mode, ir_mode *dest_mode)
3522 {
3523  static arch_register_req_t const *in_reqs[] = {
3524  &sparc_requirements_fp_fp_4,
3525  };
3526 
3527  /* construct in array */
3528  ir_node *const in[] = {
3529  op0,
3530  };
3531 
3532  ir_graph *const irg = get_irn_irg(block);
3533  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fftof, mode_F, 1, in);
3534 
3535  /* flags */
3536  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3537  irn_flags |= arch_irn_flag_rematerializable;
3538 
3539  /* init node attributes */
3540  int const n_res = 1;
3541  sparc_fp_conv_attr_t *const attr = (sparc_fp_conv_attr_t*)get_irn_generic_attr(res);
3542  (void)attr; /* avoid potential warning */
3543  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3544  init_sparc_fp_conv_attributes(res, src_mode, dest_mode);
3545 
3546  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3547  out_infos[0].req = &sparc_class_reg_req_fp;
3548 
3549  verify_new_node(res);
3550  return optimize_node(res);
3551 }
3552 
3553 ir_node *new_bd_sparc_fftof_s_d(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_mode *src_mode, ir_mode *dest_mode)
3554 {
3555  static arch_register_req_t const *in_reqs[] = {
3556  &sparc_class_reg_req_fp,
3557  };
3558 
3559  /* construct in array */
3560  ir_node *const in[] = {
3561  op0,
3562  };
3563 
3564  ir_graph *const irg = get_irn_irg(block);
3565  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fftof, mode_D, 1, in);
3566 
3567  /* flags */
3568  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3569  irn_flags |= arch_irn_flag_rematerializable;
3570 
3571  /* init node attributes */
3572  int const n_res = 1;
3573  sparc_fp_conv_attr_t *const attr = (sparc_fp_conv_attr_t*)get_irn_generic_attr(res);
3574  (void)attr; /* avoid potential warning */
3575  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3576  init_sparc_fp_conv_attributes(res, src_mode, dest_mode);
3577 
3578  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3579  out_infos[0].req = &sparc_requirements_fp_fp_2;
3580 
3581  verify_new_node(res);
3582  return optimize_node(res);
3583 }
3584 
3585 ir_node *new_bd_sparc_fftof_s_q(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_mode *src_mode, ir_mode *dest_mode)
3586 {
3587  static arch_register_req_t const *in_reqs[] = {
3588  &sparc_class_reg_req_fp,
3589  };
3590 
3591  /* construct in array */
3592  ir_node *const in[] = {
3593  op0,
3594  };
3595 
3596  ir_graph *const irg = get_irn_irg(block);
3597  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fftof, sparc_mode_Q, 1, in);
3598 
3599  /* flags */
3600  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3601  irn_flags |= arch_irn_flag_rematerializable;
3602 
3603  /* init node attributes */
3604  int const n_res = 1;
3605  sparc_fp_conv_attr_t *const attr = (sparc_fp_conv_attr_t*)get_irn_generic_attr(res);
3606  (void)attr; /* avoid potential warning */
3607  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3608  init_sparc_fp_conv_attributes(res, src_mode, dest_mode);
3609 
3610  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3611  out_infos[0].req = &sparc_requirements_fp_fp_2;
3612 
3613  verify_new_node(res);
3614  return optimize_node(res);
3615 }
3616 
3617 ir_node *new_bd_sparc_fftoi_d(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_mode *fp_mode)
3618 {
3619  static arch_register_req_t const *in_reqs[] = {
3620  &sparc_requirements_fp_fp_2,
3621  };
3622 
3623  /* construct in array */
3624  ir_node *const in[] = {
3625  op0,
3626  };
3627 
3628  ir_graph *const irg = get_irn_irg(block);
3629  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fftoi, mode_F, 1, in);
3630 
3631  /* flags */
3632  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3633  irn_flags |= arch_irn_flag_rematerializable;
3634 
3635  /* init node attributes */
3636  int const n_res = 1;
3637  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3638  (void)attr; /* avoid potential warning */
3639  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3640  init_sparc_fp_attributes(res, fp_mode);
3641 
3642  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3643  out_infos[0].req = &sparc_class_reg_req_fp;
3644 
3645  verify_new_node(res);
3646  return optimize_node(res);
3647 }
3648 
3649 ir_node *new_bd_sparc_fftoi_q(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_mode *fp_mode)
3650 {
3651  static arch_register_req_t const *in_reqs[] = {
3652  &sparc_requirements_fp_fp_4,
3653  };
3654 
3655  /* construct in array */
3656  ir_node *const in[] = {
3657  op0,
3658  };
3659 
3660  ir_graph *const irg = get_irn_irg(block);
3661  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fftoi, mode_F, 1, in);
3662 
3663  /* flags */
3664  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3665  irn_flags |= arch_irn_flag_rematerializable;
3666 
3667  /* init node attributes */
3668  int const n_res = 1;
3669  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3670  (void)attr; /* avoid potential warning */
3671  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3672  init_sparc_fp_attributes(res, fp_mode);
3673 
3674  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3675  out_infos[0].req = &sparc_class_reg_req_fp;
3676 
3677  verify_new_node(res);
3678  return optimize_node(res);
3679 }
3680 
3681 ir_node *new_bd_sparc_fftoi_s(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_mode *fp_mode)
3682 {
3683  static arch_register_req_t const *in_reqs[] = {
3684  &sparc_class_reg_req_fp,
3685  };
3686 
3687  /* construct in array */
3688  ir_node *const in[] = {
3689  op0,
3690  };
3691 
3692  ir_graph *const irg = get_irn_irg(block);
3693  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fftoi, mode_F, 1, in);
3694 
3695  /* flags */
3696  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3697  irn_flags |= arch_irn_flag_rematerializable;
3698 
3699  /* init node attributes */
3700  int const n_res = 1;
3701  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3702  (void)attr; /* avoid potential warning */
3703  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3704  init_sparc_fp_attributes(res, fp_mode);
3705 
3706  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3707  out_infos[0].req = &sparc_class_reg_req_fp;
3708 
3709  verify_new_node(res);
3710  return optimize_node(res);
3711 }
3712 
3713 ir_node *new_bd_sparc_fitof_d(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_mode *fp_mode)
3714 {
3715  static arch_register_req_t const *in_reqs[] = {
3716  &sparc_class_reg_req_fp,
3717  };
3718 
3719  /* construct in array */
3720  ir_node *const in[] = {
3721  op0,
3722  };
3723 
3724  ir_graph *const irg = get_irn_irg(block);
3725  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fitof, mode_D, 1, in);
3726 
3727  /* flags */
3728  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3729  irn_flags |= arch_irn_flag_rematerializable;
3730 
3731  /* init node attributes */
3732  int const n_res = 1;
3733  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3734  (void)attr; /* avoid potential warning */
3735  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3736  init_sparc_fp_attributes(res, fp_mode);
3737 
3738  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3739  out_infos[0].req = &sparc_requirements_fp_fp_2;
3740 
3741  verify_new_node(res);
3742  return optimize_node(res);
3743 }
3744 
3745 ir_node *new_bd_sparc_fitof_q(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_mode *fp_mode)
3746 {
3747  static arch_register_req_t const *in_reqs[] = {
3748  &sparc_class_reg_req_fp,
3749  };
3750 
3751  /* construct in array */
3752  ir_node *const in[] = {
3753  op0,
3754  };
3755 
3756  ir_graph *const irg = get_irn_irg(block);
3757  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fitof, sparc_mode_Q, 1, in);
3758 
3759  /* flags */
3760  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3761  irn_flags |= arch_irn_flag_rematerializable;
3762 
3763  /* init node attributes */
3764  int const n_res = 1;
3765  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3766  (void)attr; /* avoid potential warning */
3767  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3768  init_sparc_fp_attributes(res, fp_mode);
3769 
3770  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3771  out_infos[0].req = &sparc_requirements_fp_fp_4;
3772 
3773  verify_new_node(res);
3774  return optimize_node(res);
3775 }
3776 
3777 ir_node *new_bd_sparc_fitof_s(dbg_info *dbgi, ir_node *block, ir_node *op0, ir_mode *fp_mode)
3778 {
3779  static arch_register_req_t const *in_reqs[] = {
3780  &sparc_class_reg_req_fp,
3781  };
3782 
3783  /* construct in array */
3784  ir_node *const in[] = {
3785  op0,
3786  };
3787 
3788  ir_graph *const irg = get_irn_irg(block);
3789  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fitof, mode_F, 1, in);
3790 
3791  /* flags */
3792  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3793  irn_flags |= arch_irn_flag_rematerializable;
3794 
3795  /* init node attributes */
3796  int const n_res = 1;
3797  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3798  (void)attr; /* avoid potential warning */
3799  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3800  init_sparc_fp_attributes(res, fp_mode);
3801 
3802  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3803  out_infos[0].req = &sparc_class_reg_req_fp;
3804 
3805  verify_new_node(res);
3806  return optimize_node(res);
3807 }
3808 
3809 ir_node *new_bd_sparc_fmul_d(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_mode *fp_mode)
3810 {
3811  static arch_register_req_t const *in_reqs[] = {
3812  &sparc_requirements_fp_fp_2,
3813  &sparc_requirements_fp_fp_2,
3814  };
3815 
3816  /* construct in array */
3817  ir_node *const in[] = {
3818  left,
3819  right,
3820  };
3821 
3822  ir_graph *const irg = get_irn_irg(block);
3823  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fmul, mode_D, 2, in);
3824 
3825  /* flags */
3826  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3827  irn_flags |= arch_irn_flag_rematerializable;
3828 
3829  /* init node attributes */
3830  int const n_res = 1;
3831  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3832  (void)attr; /* avoid potential warning */
3833  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3834  init_sparc_fp_attributes(res, fp_mode);
3835 
3836  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3837  out_infos[0].req = &sparc_requirements_fp_fp_2;
3838 
3839  verify_new_node(res);
3840  return optimize_node(res);
3841 }
3842 
3843 ir_node *new_bd_sparc_fmul_q(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_mode *fp_mode)
3844 {
3845  static arch_register_req_t const *in_reqs[] = {
3846  &sparc_requirements_fp_fp_4,
3847  &sparc_requirements_fp_fp_4,
3848  };
3849 
3850  /* construct in array */
3851  ir_node *const in[] = {
3852  left,
3853  right,
3854  };
3855 
3856  ir_graph *const irg = get_irn_irg(block);
3857  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fmul, sparc_mode_Q, 2, in);
3858 
3859  /* flags */
3860  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3861  irn_flags |= arch_irn_flag_rematerializable;
3862 
3863  /* init node attributes */
3864  int const n_res = 1;
3865  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3866  (void)attr; /* avoid potential warning */
3867  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3868  init_sparc_fp_attributes(res, fp_mode);
3869 
3870  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3871  out_infos[0].req = &sparc_requirements_fp_fp_4;
3872 
3873  verify_new_node(res);
3874  return optimize_node(res);
3875 }
3876 
3877 ir_node *new_bd_sparc_fmul_s(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_mode *fp_mode)
3878 {
3879  static arch_register_req_t const *in_reqs[] = {
3880  &sparc_class_reg_req_fp,
3881  &sparc_class_reg_req_fp,
3882  };
3883 
3884  /* construct in array */
3885  ir_node *const in[] = {
3886  left,
3887  right,
3888  };
3889 
3890  ir_graph *const irg = get_irn_irg(block);
3891  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fmul, mode_F, 2, in);
3892 
3893  /* flags */
3894  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3895  irn_flags |= arch_irn_flag_rematerializable;
3896 
3897  /* init node attributes */
3898  int const n_res = 1;
3899  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3900  (void)attr; /* avoid potential warning */
3901  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3902  init_sparc_fp_attributes(res, fp_mode);
3903 
3904  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3905  out_infos[0].req = &sparc_class_reg_req_fp;
3906 
3907  verify_new_node(res);
3908  return optimize_node(res);
3909 }
3910 
3911 ir_node *new_bd_sparc_fneg_d(dbg_info *dbgi, ir_node *block, ir_node *val, ir_mode *fp_mode)
3912 {
3913  static arch_register_req_t const *in_reqs[] = {
3914  &sparc_requirements_fp_fp_2,
3915  };
3916 
3917  /* construct in array */
3918  ir_node *const in[] = {
3919  val,
3920  };
3921 
3922  ir_graph *const irg = get_irn_irg(block);
3923  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fneg, mode_D, 1, in);
3924 
3925  /* flags */
3926  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3927  irn_flags |= arch_irn_flag_rematerializable;
3928 
3929  /* init node attributes */
3930  int const n_res = 1;
3931  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3932  (void)attr; /* avoid potential warning */
3933  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3934  init_sparc_fp_attributes(res, fp_mode);
3935 
3936  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3937  out_infos[0].req = &sparc_requirements_fp_fp_2;
3938 
3939  verify_new_node(res);
3940  return optimize_node(res);
3941 }
3942 
3943 ir_node *new_bd_sparc_fneg_q(dbg_info *dbgi, ir_node *block, ir_node *val, ir_mode *fp_mode)
3944 {
3945  static arch_register_req_t const *in_reqs[] = {
3946  &sparc_requirements_fp_fp_4,
3947  };
3948 
3949  /* construct in array */
3950  ir_node *const in[] = {
3951  val,
3952  };
3953 
3954  ir_graph *const irg = get_irn_irg(block);
3955  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fneg, sparc_mode_Q, 1, in);
3956 
3957  /* flags */
3958  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3959  irn_flags |= arch_irn_flag_rematerializable;
3960 
3961  /* init node attributes */
3962  int const n_res = 1;
3963  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3964  (void)attr; /* avoid potential warning */
3965  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3966  init_sparc_fp_attributes(res, fp_mode);
3967 
3968  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
3969  out_infos[0].req = &sparc_requirements_fp_fp_4;
3970 
3971  verify_new_node(res);
3972  return optimize_node(res);
3973 }
3974 
3975 ir_node *new_bd_sparc_fneg_s(dbg_info *dbgi, ir_node *block, ir_node *val, ir_mode *fp_mode)
3976 {
3977  static arch_register_req_t const *in_reqs[] = {
3978  &sparc_class_reg_req_fp,
3979  };
3980 
3981  /* construct in array */
3982  ir_node *const in[] = {
3983  val,
3984  };
3985 
3986  ir_graph *const irg = get_irn_irg(block);
3987  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fneg, mode_F, 1, in);
3988 
3989  /* flags */
3990  arch_irn_flags_t irn_flags = arch_irn_flags_none;
3991  irn_flags |= arch_irn_flag_rematerializable;
3992 
3993  /* init node attributes */
3994  int const n_res = 1;
3995  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
3996  (void)attr; /* avoid potential warning */
3997  be_info_init_irn(res, irn_flags, in_reqs, n_res);
3998  init_sparc_fp_attributes(res, fp_mode);
3999 
4000  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
4001  out_infos[0].req = &sparc_class_reg_req_fp;
4002 
4003  verify_new_node(res);
4004  return optimize_node(res);
4005 }
4006 
4007 ir_node *new_bd_sparc_fsub_d(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_mode *fp_mode)
4008 {
4009  static arch_register_req_t const *in_reqs[] = {
4010  &sparc_requirements_fp_fp_2,
4011  &sparc_requirements_fp_fp_2,
4012  };
4013 
4014  /* construct in array */
4015  ir_node *const in[] = {
4016  left,
4017  right,
4018  };
4019 
4020  ir_graph *const irg = get_irn_irg(block);
4021  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fsub, mode_D, 2, in);
4022 
4023  /* flags */
4024  arch_irn_flags_t irn_flags = arch_irn_flags_none;
4025  irn_flags |= arch_irn_flag_rematerializable;
4026 
4027  /* init node attributes */
4028  int const n_res = 1;
4029  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
4030  (void)attr; /* avoid potential warning */
4031  be_info_init_irn(res, irn_flags, in_reqs, n_res);
4032  init_sparc_fp_attributes(res, fp_mode);
4033 
4034  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
4035  out_infos[0].req = &sparc_requirements_fp_fp_2;
4036 
4037  verify_new_node(res);
4038  return optimize_node(res);
4039 }
4040 
4041 ir_node *new_bd_sparc_fsub_q(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_mode *fp_mode)
4042 {
4043  static arch_register_req_t const *in_reqs[] = {
4044  &sparc_requirements_fp_fp_4,
4045  &sparc_requirements_fp_fp_4,
4046  };
4047 
4048  /* construct in array */
4049  ir_node *const in[] = {
4050  left,
4051  right,
4052  };
4053 
4054  ir_graph *const irg = get_irn_irg(block);
4055  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fsub, sparc_mode_Q, 2, in);
4056 
4057  /* flags */
4058  arch_irn_flags_t irn_flags = arch_irn_flags_none;
4059  irn_flags |= arch_irn_flag_rematerializable;
4060 
4061  /* init node attributes */
4062  int const n_res = 1;
4063  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
4064  (void)attr; /* avoid potential warning */
4065  be_info_init_irn(res, irn_flags, in_reqs, n_res);
4066  init_sparc_fp_attributes(res, fp_mode);
4067 
4068  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
4069  out_infos[0].req = &sparc_requirements_fp_fp_4;
4070 
4071  verify_new_node(res);
4072  return optimize_node(res);
4073 }
4074 
4075 ir_node *new_bd_sparc_fsub_s(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, ir_mode *fp_mode)
4076 {
4077  static arch_register_req_t const *in_reqs[] = {
4078  &sparc_class_reg_req_fp,
4079  &sparc_class_reg_req_fp,
4080  };
4081 
4082  /* construct in array */
4083  ir_node *const in[] = {
4084  left,
4085  right,
4086  };
4087 
4088  ir_graph *const irg = get_irn_irg(block);
4089  ir_node *const res = new_ir_node(dbgi, irg, block, op_sparc_fsub, mode_F, 2, in);
4090 
4091  /* flags */
4092  arch_irn_flags_t irn_flags = arch_irn_flags_none;
4093  irn_flags |= arch_irn_flag_rematerializable;
4094 
4095  /* init node attributes */
4096  int const n_res = 1;
4097  sparc_fp_attr_t *const attr = (sparc_fp_attr_t*)get_irn_generic_attr(res);
4098  (void)attr; /* avoid potential warning */
4099  be_info_init_irn(res, irn_flags, in_reqs, n_res);
4100  init_sparc_fp_attributes(res, fp_mode);
4101 
4102  reg_out_info_t *const out_infos = be_get_info(res)->out_infos;
4103  out_infos[0].req = &sparc_class_reg_req_fp;
4104 
4105  verify_new_node(res);
4106  return optimize_node(res);
4107 }
4108 
4109 
4114 void sparc_create_opcodes(void)
4115 {
4116  ir_op *op;
4117  int cur_opcode = get_next_ir_opcodes(iro_sparc_last);
4118 
4119  sparc_opcode_start = cur_opcode;
4120  op = new_ir_op(cur_opcode + iro_sparc_Add, "sparc_Add", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4121  set_op_dump(op, sparc_dump_node);
4122  set_op_attrs_equal(op, sparc_attrs_equal);
4123  set_op_copy_attr(op, be_copy_attr);
4124  set_op_tag(op, sparc_op_tag);
4125  op_sparc_Add = op;
4126  op = new_ir_op(cur_opcode + iro_sparc_AddCC, "sparc_AddCC", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4127  set_op_dump(op, sparc_dump_node);
4128  set_op_attrs_equal(op, sparc_attrs_equal);
4129  set_op_copy_attr(op, be_copy_attr);
4130  set_op_tag(op, sparc_op_tag);
4131  op_sparc_AddCC = op;
4132  op = new_ir_op(cur_opcode + iro_sparc_AddCC_t, "sparc_AddCC_t", op_pin_state_floats, irop_flag_none, oparity_any, -1, 0);
4133  set_op_dump(op, NULL);
4134  set_op_tag(op, sparc_op_tag);
4135  op_sparc_AddCC_t = op;
4136  op = new_ir_op(cur_opcode + iro_sparc_AddSP, "sparc_AddSP", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4137  set_op_dump(op, sparc_dump_node);
4138  set_op_attrs_equal(op, sparc_attrs_equal);
4139  set_op_copy_attr(op, be_copy_attr);
4140  set_op_tag(op, sparc_op_tag);
4141  op_sparc_AddSP = op;
4142  op = new_ir_op(cur_opcode + iro_sparc_AddX, "sparc_AddX", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4143  set_op_dump(op, sparc_dump_node);
4144  set_op_attrs_equal(op, sparc_attrs_equal);
4145  set_op_copy_attr(op, be_copy_attr);
4146  set_op_tag(op, sparc_op_tag);
4147  op_sparc_AddX = op;
4148  op = new_ir_op(cur_opcode + iro_sparc_AddX_t, "sparc_AddX_t", op_pin_state_floats, irop_flag_none, oparity_any, -1, 0);
4149  set_op_dump(op, NULL);
4150  set_op_tag(op, sparc_op_tag);
4151  op_sparc_AddX_t = op;
4152  op = new_ir_op(cur_opcode + iro_sparc_And, "sparc_And", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4153  set_op_dump(op, sparc_dump_node);
4154  set_op_attrs_equal(op, sparc_attrs_equal);
4155  set_op_copy_attr(op, be_copy_attr);
4156  set_op_tag(op, sparc_op_tag);
4157  op_sparc_And = op;
4158  op = new_ir_op(cur_opcode + iro_sparc_AndCCZero, "sparc_AndCCZero", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4159  set_op_dump(op, sparc_dump_node);
4160  set_op_attrs_equal(op, sparc_attrs_equal);
4161  set_op_copy_attr(op, be_copy_attr);
4162  set_op_tag(op, sparc_op_tag);
4163  op_sparc_AndCCZero = op;
4164  op = new_ir_op(cur_opcode + iro_sparc_AndN, "sparc_AndN", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4165  set_op_dump(op, sparc_dump_node);
4166  set_op_attrs_equal(op, sparc_attrs_equal);
4167  set_op_copy_attr(op, be_copy_attr);
4168  set_op_tag(op, sparc_op_tag);
4169  op_sparc_AndN = op;
4170  op = new_ir_op(cur_opcode + iro_sparc_AndNCCZero, "sparc_AndNCCZero", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4171  set_op_dump(op, sparc_dump_node);
4172  set_op_attrs_equal(op, sparc_attrs_equal);
4173  set_op_copy_attr(op, be_copy_attr);
4174  set_op_tag(op, sparc_op_tag);
4175  op_sparc_AndNCCZero = op;
4176  op = new_ir_op(cur_opcode + iro_sparc_Ba, "sparc_Ba", op_pin_state_pinned, irop_flag_cfopcode, oparity_any, -1, sizeof(sparc_attr_t));
4177  set_op_dump(op, sparc_dump_node);
4178  set_op_attrs_equal(op, sparc_attrs_equal);
4179  set_op_copy_attr(op, be_copy_attr);
4180  set_op_tag(op, sparc_op_tag);
4181  op_sparc_Ba = op;
4182  op = new_ir_op(cur_opcode + iro_sparc_Bicc, "sparc_Bicc", op_pin_state_pinned, irop_flag_cfopcode|irop_flag_forking, oparity_any, -1, sizeof(sparc_jmp_cond_attr_t));
4183  set_op_dump(op, sparc_dump_node);
4184  set_op_attrs_equal(op, sparc_jmp_cond_attrs_equal);
4185  set_op_copy_attr(op, be_copy_attr);
4186  set_op_tag(op, sparc_op_tag);
4187  op_sparc_Bicc = op;
4188  op = new_ir_op(cur_opcode + iro_sparc_Call, "sparc_Call", op_pin_state_exc_pinned, irop_flag_none, oparity_variable, -1, sizeof(sparc_call_attr_t));
4189  set_op_dump(op, sparc_dump_node);
4190  set_op_attrs_equal(op, sparc_call_attrs_equal);
4191  set_op_copy_attr(op, be_copy_attr);
4192  set_op_tag(op, sparc_op_tag);
4193  op_sparc_Call = op;
4194  op = new_ir_op(cur_opcode + iro_sparc_Cas, "sparc_Cas", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(sparc_attr_t));
4195  set_op_dump(op, sparc_dump_node);
4196  set_op_attrs_equal(op, sparc_attrs_equal);
4197  set_op_copy_attr(op, be_copy_attr);
4198  set_op_tag(op, sparc_op_tag);
4199  op_sparc_Cas = op;
4200  op = new_ir_op(cur_opcode + iro_sparc_Cmp, "sparc_Cmp", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4201  set_op_dump(op, sparc_dump_node);
4202  set_op_attrs_equal(op, sparc_attrs_equal);
4203  set_op_copy_attr(op, be_copy_attr);
4204  set_op_tag(op, sparc_op_tag);
4205  op_sparc_Cmp = op;
4206  op = new_ir_op(cur_opcode + iro_sparc_FrameAddr, "sparc_FrameAddr", op_pin_state_floats, irop_flag_constlike, oparity_any, -1, sizeof(sparc_attr_t));
4207  set_op_dump(op, sparc_dump_node);
4208  set_op_attrs_equal(op, sparc_attrs_equal);
4209  set_op_copy_attr(op, be_copy_attr);
4210  set_op_tag(op, sparc_op_tag);
4211  op_sparc_FrameAddr = op;
4212  op = new_ir_op(cur_opcode + iro_sparc_IJmp, "sparc_IJmp", op_pin_state_pinned, irop_flag_cfopcode|irop_flag_forking, oparity_any, -1, sizeof(sparc_load_store_attr_t));
4213  set_op_dump(op, sparc_dump_node);
4214  set_op_attrs_equal(op, sparc_load_store_attrs_equal);
4215  set_op_copy_attr(op, be_copy_attr);
4216  set_op_tag(op, sparc_op_tag);
4217  op_sparc_IJmp = op;
4218  op = new_ir_op(cur_opcode + iro_sparc_Ld, "sparc_Ld", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(sparc_load_store_attr_t));
4219  set_op_dump(op, sparc_dump_node);
4220  set_op_attrs_equal(op, sparc_load_store_attrs_equal);
4221  set_op_copy_attr(op, be_copy_attr);
4222  set_op_tag(op, sparc_op_tag);
4223  op_sparc_Ld = op;
4224  op = new_ir_op(cur_opcode + iro_sparc_Ldf, "sparc_Ldf", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(sparc_load_store_attr_t));
4225  set_op_dump(op, sparc_dump_node);
4226  set_op_attrs_equal(op, sparc_load_store_attrs_equal);
4227  set_op_copy_attr(op, be_copy_attr);
4228  set_op_tag(op, sparc_op_tag);
4229  op_sparc_Ldf = op;
4230  op = new_ir_op(cur_opcode + iro_sparc_Or, "sparc_Or", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4231  set_op_dump(op, sparc_dump_node);
4232  set_op_attrs_equal(op, sparc_attrs_equal);
4233  set_op_copy_attr(op, be_copy_attr);
4234  set_op_tag(op, sparc_op_tag);
4235  op_sparc_Or = op;
4236  op = new_ir_op(cur_opcode + iro_sparc_OrCCZero, "sparc_OrCCZero", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4237  set_op_dump(op, sparc_dump_node);
4238  set_op_attrs_equal(op, sparc_attrs_equal);
4239  set_op_copy_attr(op, be_copy_attr);
4240  set_op_tag(op, sparc_op_tag);
4241  op_sparc_OrCCZero = op;
4242  op = new_ir_op(cur_opcode + iro_sparc_OrN, "sparc_OrN", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4243  set_op_dump(op, sparc_dump_node);
4244  set_op_attrs_equal(op, sparc_attrs_equal);
4245  set_op_copy_attr(op, be_copy_attr);
4246  set_op_tag(op, sparc_op_tag);
4247  op_sparc_OrN = op;
4248  op = new_ir_op(cur_opcode + iro_sparc_OrNCCZero, "sparc_OrNCCZero", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4249  set_op_dump(op, sparc_dump_node);
4250  set_op_attrs_equal(op, sparc_attrs_equal);
4251  set_op_copy_attr(op, be_copy_attr);
4252  set_op_tag(op, sparc_op_tag);
4253  op_sparc_OrNCCZero = op;
4254  op = new_ir_op(cur_opcode + iro_sparc_Restore, "sparc_Restore", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4255  set_op_dump(op, sparc_dump_node);
4256  set_op_attrs_equal(op, sparc_attrs_equal);
4257  set_op_copy_attr(op, be_copy_attr);
4258  set_op_tag(op, sparc_op_tag);
4259  op_sparc_Restore = op;
4260  op = new_ir_op(cur_opcode + iro_sparc_RestoreZero, "sparc_RestoreZero", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4261  set_op_dump(op, sparc_dump_node);
4262  set_op_attrs_equal(op, sparc_attrs_equal);
4263  set_op_copy_attr(op, be_copy_attr);
4264  set_op_tag(op, sparc_op_tag);
4265  op_sparc_RestoreZero = op;
4266  op = new_ir_op(cur_opcode + iro_sparc_Return, "sparc_Return", op_pin_state_pinned, irop_flag_cfopcode, oparity_variable, -1, sizeof(sparc_attr_t));
4267  set_op_dump(op, sparc_dump_node);
4268  set_op_attrs_equal(op, sparc_attrs_equal);
4269  set_op_copy_attr(op, be_copy_attr);
4270  set_op_tag(op, sparc_op_tag);
4271  op_sparc_Return = op;
4272  op = new_ir_op(cur_opcode + iro_sparc_SDiv, "sparc_SDiv", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(sparc_attr_t));
4273  set_op_dump(op, sparc_dump_node);
4274  set_op_attrs_equal(op, sparc_attrs_equal);
4275  set_op_copy_attr(op, be_copy_attr);
4276  set_op_tag(op, sparc_op_tag);
4277  op_sparc_SDiv = op;
4278  op = new_ir_op(cur_opcode + iro_sparc_SMul, "sparc_SMul", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4279  set_op_dump(op, sparc_dump_node);
4280  set_op_attrs_equal(op, sparc_attrs_equal);
4281  set_op_copy_attr(op, be_copy_attr);
4282  set_op_tag(op, sparc_op_tag);
4283  op_sparc_SMul = op;
4284  op = new_ir_op(cur_opcode + iro_sparc_SMulCCZero, "sparc_SMulCCZero", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4285  set_op_dump(op, sparc_dump_node);
4286  set_op_attrs_equal(op, sparc_attrs_equal);
4287  set_op_copy_attr(op, be_copy_attr);
4288  set_op_tag(op, sparc_op_tag);
4289  op_sparc_SMulCCZero = op;
4290  op = new_ir_op(cur_opcode + iro_sparc_SMulh, "sparc_SMulh", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4291  set_op_dump(op, sparc_dump_node);
4292  set_op_attrs_equal(op, sparc_attrs_equal);
4293  set_op_copy_attr(op, be_copy_attr);
4294  set_op_tag(op, sparc_op_tag);
4295  op_sparc_SMulh = op;
4296  op = new_ir_op(cur_opcode + iro_sparc_Save, "sparc_Save", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4297  set_op_dump(op, sparc_dump_node);
4298  set_op_attrs_equal(op, sparc_attrs_equal);
4299  set_op_copy_attr(op, be_copy_attr);
4300  set_op_tag(op, sparc_op_tag);
4301  op_sparc_Save = op;
4302  op = new_ir_op(cur_opcode + iro_sparc_SetHi, "sparc_SetHi", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4303  set_op_dump(op, sparc_dump_node);
4304  set_op_attrs_equal(op, sparc_attrs_equal);
4305  set_op_copy_attr(op, be_copy_attr);
4306  set_op_tag(op, sparc_op_tag);
4307  op_sparc_SetHi = op;
4308  op = new_ir_op(cur_opcode + iro_sparc_Sll, "sparc_Sll", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4309  set_op_dump(op, sparc_dump_node);
4310  set_op_attrs_equal(op, sparc_attrs_equal);
4311  set_op_copy_attr(op, be_copy_attr);
4312  set_op_tag(op, sparc_op_tag);
4313  op_sparc_Sll = op;
4314  op = new_ir_op(cur_opcode + iro_sparc_Sra, "sparc_Sra", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4315  set_op_dump(op, sparc_dump_node);
4316  set_op_attrs_equal(op, sparc_attrs_equal);
4317  set_op_copy_attr(op, be_copy_attr);
4318  set_op_tag(op, sparc_op_tag);
4319  op_sparc_Sra = op;
4320  op = new_ir_op(cur_opcode + iro_sparc_Srl, "sparc_Srl", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4321  set_op_dump(op, sparc_dump_node);
4322  set_op_attrs_equal(op, sparc_attrs_equal);
4323  set_op_copy_attr(op, be_copy_attr);
4324  set_op_tag(op, sparc_op_tag);
4325  op_sparc_Srl = op;
4326  op = new_ir_op(cur_opcode + iro_sparc_St, "sparc_St", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(sparc_load_store_attr_t));
4327  set_op_dump(op, sparc_dump_node);
4328  set_op_attrs_equal(op, sparc_load_store_attrs_equal);
4329  set_op_copy_attr(op, be_copy_attr);
4330  set_op_tag(op, sparc_op_tag);
4331  op_sparc_St = op;
4332  op = new_ir_op(cur_opcode + iro_sparc_Stbar, "sparc_Stbar", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(sparc_attr_t));
4333  set_op_dump(op, sparc_dump_node);
4334  set_op_attrs_equal(op, sparc_attrs_equal);
4335  set_op_copy_attr(op, be_copy_attr);
4336  set_op_tag(op, sparc_op_tag);
4337  op_sparc_Stbar = op;
4338  op = new_ir_op(cur_opcode + iro_sparc_Stf, "sparc_Stf", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(sparc_load_store_attr_t));
4339  set_op_dump(op, sparc_dump_node);
4340  set_op_attrs_equal(op, sparc_load_store_attrs_equal);
4341  set_op_copy_attr(op, be_copy_attr);
4342  set_op_tag(op, sparc_op_tag);
4343  op_sparc_Stf = op;
4344  op = new_ir_op(cur_opcode + iro_sparc_Sub, "sparc_Sub", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4345  set_op_dump(op, sparc_dump_node);
4346  set_op_attrs_equal(op, sparc_attrs_equal);
4347  set_op_copy_attr(op, be_copy_attr);
4348  set_op_tag(op, sparc_op_tag);
4349  op_sparc_Sub = op;
4350  op = new_ir_op(cur_opcode + iro_sparc_SubCC, "sparc_SubCC", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4351  set_op_dump(op, sparc_dump_node);
4352  set_op_attrs_equal(op, sparc_attrs_equal);
4353  set_op_copy_attr(op, be_copy_attr);
4354  set_op_tag(op, sparc_op_tag);
4355  op_sparc_SubCC = op;
4356  op = new_ir_op(cur_opcode + iro_sparc_SubCC_t, "sparc_SubCC_t", op_pin_state_floats, irop_flag_none, oparity_any, -1, 0);
4357  set_op_dump(op, NULL);
4358  set_op_tag(op, sparc_op_tag);
4359  op_sparc_SubCC_t = op;
4360  op = new_ir_op(cur_opcode + iro_sparc_SubSP, "sparc_SubSP", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4361  set_op_dump(op, sparc_dump_node);
4362  set_op_attrs_equal(op, sparc_attrs_equal);
4363  set_op_copy_attr(op, be_copy_attr);
4364  set_op_tag(op, sparc_op_tag);
4365  op_sparc_SubSP = op;
4366  op = new_ir_op(cur_opcode + iro_sparc_SubX, "sparc_SubX", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4367  set_op_dump(op, sparc_dump_node);
4368  set_op_attrs_equal(op, sparc_attrs_equal);
4369  set_op_copy_attr(op, be_copy_attr);
4370  set_op_tag(op, sparc_op_tag);
4371  op_sparc_SubX = op;
4372  op = new_ir_op(cur_opcode + iro_sparc_SubX_t, "sparc_SubX_t", op_pin_state_floats, irop_flag_none, oparity_any, -1, 0);
4373  set_op_dump(op, NULL);
4374  set_op_tag(op, sparc_op_tag);
4375  op_sparc_SubX_t = op;
4376  op = new_ir_op(cur_opcode + iro_sparc_SwitchJmp, "sparc_SwitchJmp", op_pin_state_pinned, irop_flag_cfopcode|irop_flag_forking, oparity_any, -1, sizeof(sparc_switch_jmp_attr_t));
4377  set_op_dump(op, sparc_dump_node);
4378  set_op_attrs_equal(op, sparc_switch_jmp_attrs_equal);
4379  set_op_copy_attr(op, be_copy_attr);
4380  set_op_tag(op, sparc_op_tag);
4381  op_sparc_SwitchJmp = op;
4382  op = new_ir_op(cur_opcode + iro_sparc_UDiv, "sparc_UDiv", op_pin_state_exc_pinned, irop_flag_uses_memory, oparity_any, -1, sizeof(sparc_attr_t));
4383  set_op_dump(op, sparc_dump_node);
4384  set_op_attrs_equal(op, sparc_attrs_equal);
4385  set_op_copy_attr(op, be_copy_attr);
4386  set_op_tag(op, sparc_op_tag);
4387  op_sparc_UDiv = op;
4388  op = new_ir_op(cur_opcode + iro_sparc_UMulh, "sparc_UMulh", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4389  set_op_dump(op, sparc_dump_node);
4390  set_op_attrs_equal(op, sparc_attrs_equal);
4391  set_op_copy_attr(op, be_copy_attr);
4392  set_op_tag(op, sparc_op_tag);
4393  op_sparc_UMulh = op;
4394  op = new_ir_op(cur_opcode + iro_sparc_XNor, "sparc_XNor", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4395  set_op_dump(op, sparc_dump_node);
4396  set_op_attrs_equal(op, sparc_attrs_equal);
4397  set_op_copy_attr(op, be_copy_attr);
4398  set_op_tag(op, sparc_op_tag);
4399  op_sparc_XNor = op;
4400  op = new_ir_op(cur_opcode + iro_sparc_XNorCCZero, "sparc_XNorCCZero", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4401  set_op_dump(op, sparc_dump_node);
4402  set_op_attrs_equal(op, sparc_attrs_equal);
4403  set_op_copy_attr(op, be_copy_attr);
4404  set_op_tag(op, sparc_op_tag);
4405  op_sparc_XNorCCZero = op;
4406  op = new_ir_op(cur_opcode + iro_sparc_Xor, "sparc_Xor", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4407  set_op_dump(op, sparc_dump_node);
4408  set_op_attrs_equal(op, sparc_attrs_equal);
4409  set_op_copy_attr(op, be_copy_attr);
4410  set_op_tag(op, sparc_op_tag);
4411  op_sparc_Xor = op;
4412  op = new_ir_op(cur_opcode + iro_sparc_XorCCZero, "sparc_XorCCZero", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_attr_t));
4413  set_op_dump(op, sparc_dump_node);
4414  set_op_attrs_equal(op, sparc_attrs_equal);
4415  set_op_copy_attr(op, be_copy_attr);
4416  set_op_tag(op, sparc_op_tag);
4417  op_sparc_XorCCZero = op;
4418  op = new_ir_op(cur_opcode + iro_sparc_fabs, "sparc_fabs", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_fp_attr_t));
4419  set_op_dump(op, sparc_dump_node);
4420  set_op_attrs_equal(op, sparc_fp_attrs_equal);
4421  set_op_copy_attr(op, be_copy_attr);
4422  set_op_tag(op, sparc_op_tag);
4423  op_sparc_fabs = op;
4424  op = new_ir_op(cur_opcode + iro_sparc_fadd, "sparc_fadd", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_fp_attr_t));
4425  set_op_dump(op, sparc_dump_node);
4426  set_op_attrs_equal(op, sparc_fp_attrs_equal);
4427  set_op_copy_attr(op, be_copy_attr);
4428  set_op_tag(op, sparc_op_tag);
4429  op_sparc_fadd = op;
4430  op = new_ir_op(cur_opcode + iro_sparc_fbfcc, "sparc_fbfcc", op_pin_state_pinned, irop_flag_cfopcode|irop_flag_forking, oparity_any, -1, sizeof(sparc_jmp_cond_attr_t));
4431  set_op_dump(op, sparc_dump_node);
4432  set_op_attrs_equal(op, sparc_jmp_cond_attrs_equal);
4433  set_op_copy_attr(op, be_copy_attr);
4434  set_op_tag(op, sparc_op_tag);
4435  op_sparc_fbfcc = op;
4436  op = new_ir_op(cur_opcode + iro_sparc_fcmp, "sparc_fcmp", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_fp_attr_t));
4437  set_op_dump(op, sparc_dump_node);
4438  set_op_attrs_equal(op, sparc_fp_attrs_equal);
4439  set_op_copy_attr(op, be_copy_attr);
4440  set_op_tag(op, sparc_op_tag);
4441  op_sparc_fcmp = op;
4442  op = new_ir_op(cur_opcode + iro_sparc_fdiv, "sparc_fdiv", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_fp_attr_t));
4443  set_op_dump(op, sparc_dump_node);
4444  set_op_attrs_equal(op, sparc_fp_attrs_equal);
4445  set_op_copy_attr(op, be_copy_attr);
4446  set_op_tag(op, sparc_op_tag);
4447  op_sparc_fdiv = op;
4448  op = new_ir_op(cur_opcode + iro_sparc_fftof, "sparc_fftof", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_fp_conv_attr_t));
4449  set_op_dump(op, sparc_dump_node);
4450  set_op_attrs_equal(op, sparc_fp_conv_attrs_equal);
4451  set_op_copy_attr(op, be_copy_attr);
4452  set_op_tag(op, sparc_op_tag);
4453  op_sparc_fftof = op;
4454  op = new_ir_op(cur_opcode + iro_sparc_fftoi, "sparc_fftoi", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_fp_attr_t));
4455  set_op_dump(op, sparc_dump_node);
4456  set_op_attrs_equal(op, sparc_fp_attrs_equal);
4457  set_op_copy_attr(op, be_copy_attr);
4458  set_op_tag(op, sparc_op_tag);
4459  op_sparc_fftoi = op;
4460  op = new_ir_op(cur_opcode + iro_sparc_fitof, "sparc_fitof", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_fp_attr_t));
4461  set_op_dump(op, sparc_dump_node);
4462  set_op_attrs_equal(op, sparc_fp_attrs_equal);
4463  set_op_copy_attr(op, be_copy_attr);
4464  set_op_tag(op, sparc_op_tag);
4465  op_sparc_fitof = op;
4466  op = new_ir_op(cur_opcode + iro_sparc_fmul, "sparc_fmul", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_fp_attr_t));
4467  set_op_dump(op, sparc_dump_node);
4468  set_op_attrs_equal(op, sparc_fp_attrs_equal);
4469  set_op_copy_attr(op, be_copy_attr);
4470  set_op_tag(op, sparc_op_tag);
4471  op_sparc_fmul = op;
4472  op = new_ir_op(cur_opcode + iro_sparc_fneg, "sparc_fneg", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_fp_attr_t));
4473  set_op_dump(op, sparc_dump_node);
4474  set_op_attrs_equal(op, sparc_fp_attrs_equal);
4475  set_op_copy_attr(op, be_copy_attr);
4476  set_op_tag(op, sparc_op_tag);
4477  op_sparc_fneg = op;
4478  op = new_ir_op(cur_opcode + iro_sparc_fsub, "sparc_fsub", op_pin_state_floats, irop_flag_none, oparity_any, -1, sizeof(sparc_fp_attr_t));
4479  set_op_dump(op, sparc_dump_node);
4480  set_op_attrs_equal(op, sparc_fp_attrs_equal);
4481  set_op_copy_attr(op, be_copy_attr);
4482  set_op_tag(op, sparc_op_tag);
4483  op_sparc_fsub = op;
4484 
4485 }
4486 
4487 void sparc_free_opcodes(void)
4488 {
4489  free_ir_op(op_sparc_Add); op_sparc_Add = NULL;
4490  free_ir_op(op_sparc_AddCC); op_sparc_AddCC = NULL;
4491  free_ir_op(op_sparc_AddCC_t); op_sparc_AddCC_t = NULL;
4492  free_ir_op(op_sparc_AddSP); op_sparc_AddSP = NULL;
4493  free_ir_op(op_sparc_AddX); op_sparc_AddX = NULL;
4494  free_ir_op(op_sparc_AddX_t); op_sparc_AddX_t = NULL;
4495  free_ir_op(op_sparc_And); op_sparc_And = NULL;
4496  free_ir_op(op_sparc_AndCCZero); op_sparc_AndCCZero = NULL;
4497  free_ir_op(op_sparc_AndN); op_sparc_AndN = NULL;
4498  free_ir_op(op_sparc_AndNCCZero); op_sparc_AndNCCZero = NULL;
4499  free_ir_op(op_sparc_Ba); op_sparc_Ba = NULL;
4500  free_ir_op(op_sparc_Bicc); op_sparc_Bicc = NULL;
4501  free_ir_op(op_sparc_Call); op_sparc_Call = NULL;
4502  free_ir_op(op_sparc_Cas); op_sparc_Cas = NULL;
4503  free_ir_op(op_sparc_Cmp); op_sparc_Cmp = NULL;
4504  free_ir_op(op_sparc_FrameAddr); op_sparc_FrameAddr = NULL;
4505  free_ir_op(op_sparc_IJmp); op_sparc_IJmp = NULL;
4506  free_ir_op(op_sparc_Ld); op_sparc_Ld = NULL;
4507  free_ir_op(op_sparc_Ldf); op_sparc_Ldf = NULL;
4508  free_ir_op(op_sparc_Or); op_sparc_Or = NULL;
4509  free_ir_op(op_sparc_OrCCZero); op_sparc_OrCCZero = NULL;
4510  free_ir_op(op_sparc_OrN); op_sparc_OrN = NULL;
4511  free_ir_op(op_sparc_OrNCCZero); op_sparc_OrNCCZero = NULL;
4512  free_ir_op(op_sparc_Restore); op_sparc_Restore = NULL;
4513  free_ir_op(op_sparc_RestoreZero); op_sparc_RestoreZero = NULL;
4514  free_ir_op(op_sparc_Return); op_sparc_Return = NULL;
4515  free_ir_op(op_sparc_SDiv); op_sparc_SDiv = NULL;
4516  free_ir_op(op_sparc_SMul); op_sparc_SMul = NULL;
4517  free_ir_op(op_sparc_SMulCCZero); op_sparc_SMulCCZero = NULL;
4518  free_ir_op(op_sparc_SMulh); op_sparc_SMulh = NULL;
4519  free_ir_op(op_sparc_Save); op_sparc_Save = NULL;
4520  free_ir_op(op_sparc_SetHi); op_sparc_SetHi = NULL;
4521  free_ir_op(op_sparc_Sll); op_sparc_Sll = NULL;
4522  free_ir_op(op_sparc_Sra); op_sparc_Sra = NULL;
4523  free_ir_op(op_sparc_Srl); op_sparc_Srl = NULL;
4524  free_ir_op(op_sparc_St); op_sparc_St = NULL;
4525  free_ir_op(op_sparc_Stbar); op_sparc_Stbar = NULL;
4526  free_ir_op(op_sparc_Stf); op_sparc_Stf = NULL;
4527  free_ir_op(op_sparc_Sub); op_sparc_Sub = NULL;
4528  free_ir_op(op_sparc_SubCC); op_sparc_SubCC = NULL;
4529  free_ir_op(op_sparc_SubCC_t); op_sparc_SubCC_t = NULL;
4530  free_ir_op(op_sparc_SubSP); op_sparc_SubSP = NULL;
4531  free_ir_op(op_sparc_SubX); op_sparc_SubX = NULL;
4532  free_ir_op(op_sparc_SubX_t); op_sparc_SubX_t = NULL;
4533  free_ir_op(op_sparc_SwitchJmp); op_sparc_SwitchJmp = NULL;
4534  free_ir_op(op_sparc_UDiv); op_sparc_UDiv = NULL;
4535  free_ir_op(op_sparc_UMulh); op_sparc_UMulh = NULL;
4536  free_ir_op(op_sparc_XNor); op_sparc_XNor = NULL;
4537  free_ir_op(op_sparc_XNorCCZero); op_sparc_XNorCCZero = NULL;
4538  free_ir_op(op_sparc_Xor); op_sparc_Xor = NULL;
4539  free_ir_op(op_sparc_XorCCZero); op_sparc_XorCCZero = NULL;
4540  free_ir_op(op_sparc_fabs); op_sparc_fabs = NULL;
4541  free_ir_op(op_sparc_fadd); op_sparc_fadd = NULL;
4542  free_ir_op(op_sparc_fbfcc); op_sparc_fbfcc = NULL;
4543  free_ir_op(op_sparc_fcmp); op_sparc_fcmp = NULL;
4544  free_ir_op(op_sparc_fdiv); op_sparc_fdiv = NULL;
4545  free_ir_op(op_sparc_fftof); op_sparc_fftof = NULL;
4546  free_ir_op(op_sparc_fftoi); op_sparc_fftoi = NULL;
4547  free_ir_op(op_sparc_fitof); op_sparc_fitof = NULL;
4548  free_ir_op(op_sparc_fmul); op_sparc_fmul = NULL;
4549  free_ir_op(op_sparc_fneg); op_sparc_fneg = NULL;
4550  free_ir_op(op_sparc_fsub); op_sparc_fsub = NULL;
4551 
4552 }
irop_flag_none
Nothing.
Definition: irop.h:43
mode_Bu
ir_mode * mode_Bu
uint8
Definition: irmode.h:195
get_irn_opcode
unsigned get_irn_opcode(const ir_node *node)
Returns the opcode-enum of the node.
irop_flag_forking
Forking control flow at this operation.
Definition: irop.h:49
get_irn_irg
ir_graph * get_irn_irg(const ir_node *node)
Returns the ir_graph this node belongs to.
ir_op
struct ir_op ir_op
Node Opcode.
Definition: firm_types.h:56
mode_D
ir_mode * mode_D
ieee754 binary64 float (double precision)
Definition: irmode.h:193
set_op_attrs_equal
void set_op_attrs_equal(ir_op *op, node_attrs_equal_func func)
Sets attrs_equal callback func for operation op.
verify_new_node
void verify_new_node(ir_node *node)
If firm is built in debug mode, verify that a newly created node is fine.
ir_type
struct ir_type ir_type
Type.
Definition: firm_types.h:71
dbg_info
struct dbg_info dbg_info
Source Reference.
Definition: firm_types.h:40
get_irn_generic_attr
void * get_irn_generic_attr(ir_node *node)
Returns a pointer to the node attributes.
mode_M
ir_mode * mode_M
memory
Definition: irmode.h:190
get_irn_op
ir_op * get_irn_op(const ir_node *node)
Returns the opcode struct of the node.
optimize_node
ir_node * optimize_node(ir_node *n)
Applies local optimizations to a single node.
new_ir_node
ir_node * new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode, int arity, ir_node *const *in)
IR node constructor.
irop_flag_cfopcode
This operation is a control flow operation.
Definition: irop.h:45
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:102
mode_T
ir_mode * mode_T
tuple (none)
Definition: irmode.h:220
op_pin_state_pinned
Nodes must remain in this basic block.
Definition: firm_types.h:200
irop_flag_uses_memory
This operation has a memory input and may change the memory state.
Definition: irop.h:54
op_pin_state_exc_pinned
Node must remain in this basic block if it can throw an exception, else can float.
Definition: firm_types.h:201
set_op_copy_attr
void set_op_copy_attr(ir_op *op, copy_attr_func func)
Sets attribute copy callback func for operation op.
oparity_variable
The arity is not fixed by opcode, but statically known.
Definition: irop.h:32
new_ir_op
ir_op * new_ir_op(unsigned code, const char *name, op_pin_state p, irop_flags flags, op_arity opar, int op_index, size_t attr_size)
Creates a new IR operation.
ir_relation
ir_relation
Relations for comparing numbers.
Definition: firm_types.h:159
irop_flag_constlike
This operation has no arguments and is some kind of a constant.
Definition: irop.h:50
ir_mode
struct ir_mode ir_mode
SSA Value mode.
Definition: firm_types.h:59
get_next_ir_opcodes
unsigned get_next_ir_opcodes(unsigned num)
Returns the next free n IR opcode number, allows to register a bunch of user ops. ...
set_op_dump
void set_op_dump(ir_op *op, dump_node_func func)
Sets dump callback func for operation op.
ir_entity
struct ir_entity ir_entity
Entity.
Definition: firm_types.h:83
ir_node
struct ir_node ir_node
Procedure Graph Node.
Definition: firm_types.h:53
mode_Iu
ir_mode * mode_Iu
uint32
Definition: irmode.h:199
mode_F
ir_mode * mode_F
ieee754 binary32 float (single precision)
Definition: irmode.h:192
free_ir_op
void free_ir_op(ir_op *code)
Frees an ir operation.
ir_graph
struct ir_graph ir_graph
Procedure Graph.
Definition: firm_types.h:74
mode_X
ir_mode * mode_X
execution
Definition: irmode.h:217
op_pin_state_floats
Nodes of this opcode can be placed in any basic block.
Definition: firm_types.h:199
oparity_any
Any other arity.
Definition: irop.h:37