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