1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
17 /* some constants fixing the positions of nodes predecessors
19 #define CALL_PARAM_OFFSET 2
20 #define SEL_INDEX_OFFSET 2
21 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
23 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
24 "Gt", "Ge", "Lg", "Leg", "Uo",
25 "Ue", "Ul", "Ule", "Ug", "Uge",
28 inline char *get_pnc_string(int pnc) {
29 return pnc_name_arr[pnc];
34 get_negated_pnc(int pnc) {
36 case False: return True; break;
37 case Eq: return Ne; break;
38 case Lt: return Uge; break;
39 case Le: return Ug; break;
40 case Gt: return Ule; break;
41 case Ge: return Ul; break;
42 case Lg: return Ue; break;
43 case Leg: return Uo; break;
44 case Uo: return Leg; break;
45 case Ue: return Lg; break;
46 case Ul: return Ge; break;
47 case Ule: return Gt; break;
48 case Ug: return Le; break;
49 case Uge: return Lt; break;
50 case Ne: return Eq; break;
51 case True: return False; break;
53 return 99; /* to shut up gcc */
56 static char *pns_name_arr [] = {"initial_exec", "global_store",
57 "frame_base", "globals", "args"};
59 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
66 /* irnode constructor */
67 /* create a new irnode in irg, with an op, mode, arity and */
68 /* some incoming irnodes */
69 /* this constructor is used in every specified irnode constructor */
71 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
72 int arity, ir_node **in)
75 int node_size = offsetof (ir_node, attr) + op->attr_size;
77 res = (ir_node *) obstack_alloc (irg->obst, node_size);
79 res->kind = k_ir_node;
85 res->in = NEW_ARR_F (ir_node *, 1);
87 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
88 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
93 res->node_nr = get_irp_new_node_nr();
99 /* Copies all attributes stored in the old node to the new node.
100 Assumes both have the same opcode and sufficient size. */
102 copy_attrs (ir_node *old, ir_node *new) {
103 assert (get_irn_opcode(old) == get_irn_opcode(new));
104 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
107 /* IR-Nodes with attributes */
109 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
112 ir_node *np = XP_GETARG (ir_node *, 0);
115 XPS ("<null ir_node>");
119 XPF1 ("%I", get_irn_opident(np));
121 switch (get_irn_opcode (np)) { /* node label */
123 XPF1 ("%I", get_irn_mode(np)->name);
125 XPF1 ("%v", get_irn_const_attr);
128 if (get_irn_modecode (np) == irm_b) {
130 XP (pnc_name_arr[get_irn_proj_attr(np)]);
131 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
133 XP (pns_name_arr[get_irn_proj_attr(np)]);
135 XPF1 ("%I", get_irn_mode(np)->name);
137 XPF1 ("%d", get_irn_proj_attr(np));
141 XPF1 ("%I", get_irn_mode(np)->name);
143 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
144 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
146 case iro_Start: /* don't dump mode of these */
155 XPF1 ("%I", get_irn_mode(np)->name);
162 /** getting some parameters from ir_nodes **/
164 /* returns the number of predecessors without the block predecessor. */
166 get_irn_arity (ir_node *node)
169 return (ARR_LEN((node)->in)-1);
172 /* Returns the array with ins. This array is shifted with respect to the
173 array accessed by get_irn_n: The block operand is at position 0 not -1.
174 (@@@ This should be changed.)
175 The order of the predecessors in this array is not guaranteed, except that
176 lists of operands as predecessors of Block or arguments of a Call are
179 get_irn_in (ir_node *node)
185 /* to iterate through the predecessors without touching the array */
186 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
187 to iterate includind the Block predecessor iterate from i = -1 to
189 If it is a block, the entry -1 is NULL. */
191 get_irn_n (ir_node *node, int n)
194 assert (get_irn_arity (node) > n);
195 return skip_nop(node->in[n+1]);
199 set_irn_n (ir_node *node, int n, ir_node *in)
202 assert (get_irn_arity (node) > n);
207 get_irn_mode (ir_node *node)
214 get_irn_modecode (ir_node *node)
217 return node->mode->code;
222 get_irn_modename (ir_node *node)
225 return node->mode->name;
229 get_irn_op (ir_node *node)
235 /* should be private to the library: */
237 set_irn_op (ir_node *node, ir_op *op)
244 get_irn_opcode (ir_node *node)
247 return node->op->code;
251 get_irn_opname (ir_node *node)
254 return id_to_str(node->op->name);
258 get_irn_opident (ir_node *node)
261 return node->op->name;
265 get_irn_visited (ir_node *node)
268 return node->visited;
272 set_irn_visited (ir_node *node, unsigned long visited)
275 node->visited = visited;
278 set_irn_link (ir_node *node, ir_node *link) {
284 get_irn_link (ir_node *node) {
290 /* Outputs a unique number for this node */
292 get_irn_node_nr(ir_node *node) {
294 return node->node_nr;
299 get_irn_const_attr (ir_node *node)
301 assert (node->op == op_Const);
302 return node->attr.con;
306 get_irn_proj_attr (ir_node *node)
308 assert (node->op == op_Proj);
309 return node->attr.proj;
313 get_irn_alloc_attr (ir_node *node)
315 assert (node->op == op_Alloc);
320 get_irn_free_attr (ir_node *node)
322 assert (node->op == op_Free);
327 get_irn_symconst_attr (ir_node *node)
329 assert (node->op == op_SymConst);
334 get_irn_call_attr (ir_node *node)
336 assert (node->op == op_Call);
337 return node->attr.call;
341 get_irn_sel_attr (ir_node *node)
343 assert (node->op == op_Sel);
348 get_irn_phi_attr (ir_node *node)
350 assert (node->op == op_Phi);
351 return node->attr.phi0_pos;
355 get_irn_block_attr (ir_node *node)
357 assert (node->op == op_Block);
358 return node->attr.block;
361 /** manipulate fields of individual nodes **/
363 /* this works for all except Block */
365 get_nodes_Block (ir_node *node) {
366 assert (!(node->op == op_Block));
367 return get_irn_n(node, -1);
371 set_nodes_Block (ir_node *node, ir_node *block) {
372 assert (!(node->op == op_Block));
373 set_irn_n(node, -1, block);
376 /* Returns an array with the predecessors of the Block. Depending on
377 the implementation of the graph datastructure this can be a copy of
378 the internal representation of predecessors as well as the internal
379 array itself. Therefore writing to this array might obstruct the ir. */
381 get_Block_cfgpred_arr (ir_node *node)
383 assert ((node->op == op_Block));
384 return (ir_node **)&(get_irn_in(node)[1]);
389 get_Block_n_cfgpreds (ir_node *node) {
390 assert ((node->op == op_Block));
391 return (get_irn_arity(node));
396 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
397 assert ((node->op == op_Block));
402 get_Block_cfgpred (ir_node *node, int pos) {
403 assert (node->op == op_Block);
404 return get_irn_n(node, pos);
408 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
409 assert (node->op == op_Block);
410 set_irn_n(node, pos, pred);
414 get_Block_matured (ir_node *node) {
415 assert (node->op == op_Block);
416 return node->attr.block.matured;
420 set_Block_matured (ir_node *node, bool matured) {
421 assert (node->op == op_Block);
422 node->attr.block.matured = matured;
425 get_Block_block_visited (ir_node *node) {
426 assert (node->op == op_Block);
427 return node->attr.block.block_visited;
431 set_Block_block_visited (ir_node *node, unsigned long visit) {
432 assert (node->op == op_Block);
433 node->attr.block.block_visited = visit;
437 get_Block_graph_arr (ir_node *node, int pos) {
438 assert (node->op == op_Block);
439 return node->attr.block.graph_arr[pos+1];
443 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
444 assert (node->op == op_Block);
445 node->attr.block.graph_arr[pos+1] = value;
449 get_Cond_selector (ir_node *node) {
450 assert (node->op == op_Cond);
451 return get_irn_n(node, 0);
455 set_Cond_selector (ir_node *node, ir_node *selector) {
456 assert (node->op == op_Cond);
457 set_irn_n(node, 0, selector);
461 get_Return_mem (ir_node *node) {
462 assert (node->op == op_Return);
463 return get_irn_n(node, 0);
467 set_Return_mem (ir_node *node, ir_node *mem) {
468 assert (node->op == op_Return);
469 set_irn_n(node, 0, mem);
473 get_Return_res_arr (ir_node *node)
475 assert ((node->op == op_Return));
476 if (get_Return_n_res(node) > 0)
477 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
483 get_Return_n_res (ir_node *node) {
484 assert (node->op == op_Return);
485 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
490 set_Return_n_res (ir_node *node, int results) {
491 assert (node->op == op_Return);
496 get_Return_res (ir_node *node, int pos) {
497 assert (node->op == op_Return);
498 assert (get_Return_n_res(node) > pos);
499 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
503 set_Return_res (ir_node *node, int pos, ir_node *res){
504 assert (node->op == op_Return);
505 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
509 get_Raise_mem (ir_node *node) {
510 assert (node->op == op_Return);
511 return get_irn_n(node, 0);
515 set_Raise_mem (ir_node *node, ir_node *mem) {
516 assert (node->op == op_Raise);
517 set_irn_n(node, 0, mem);
521 get_Raise_exo_ptr (ir_node *node) {
522 assert (node->op == op_Raise);
523 return get_irn_n(node, 1);
527 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
528 assert (node->op == op_Raise);
529 set_irn_n(node, 1, exo_ptr);
532 inline tarval *get_Const_tarval (ir_node *node) {
533 assert (node->op == op_Const);
534 return get_irn_const_attr(node);
538 set_Const_tarval (ir_node *node, tarval *con) {
539 assert (node->op == op_Const);
540 node->attr.con = con;
544 get_SymConst_kind (ir_node *node) {
545 assert (node->op == op_SymConst);
546 return node->attr.i.num;
550 set_SymConst_kind (ir_node *node, symconst_kind num) {
551 assert (node->op == op_SymConst);
552 node->attr.i.num = num;
556 get_SymConst_type (ir_node *node) {
557 assert ( (node->op == op_SymConst)
558 && ( get_SymConst_kind(node) == type_tag
559 || get_SymConst_kind(node) == size));
560 return node->attr.i.tori.typ;
564 set_SymConst_type (ir_node *node, type *type) {
565 assert ( (node->op == op_SymConst)
566 && ( get_SymConst_kind(node) == type_tag
567 || get_SymConst_kind(node) == size));
568 node->attr.i.tori.typ = type;
572 get_SymConst_ptrinfo (ir_node *node) {
573 assert ( (node->op == op_SymConst)
574 && (get_SymConst_kind(node) == linkage_ptr_info));
575 return node->attr.i.tori.ptrinfo;
579 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
580 assert ( (node->op == op_SymConst)
581 && (get_SymConst_kind(node) == linkage_ptr_info));
582 node->attr.i.tori.ptrinfo = ptrinfo;
586 get_SymConst_type_or_id (ir_node *node) {
587 assert (node->op == op_SymConst);
588 return &(node->attr.i.tori);
592 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
593 assert (node->op == op_SymConst);
594 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
598 get_Sel_mem (ir_node *node) {
599 assert (node->op == op_Sel);
600 return get_irn_n(node, 0);
604 set_Sel_mem (ir_node *node, ir_node *mem) {
605 assert (node->op == op_Sel);
606 set_irn_n(node, 0, mem);
610 get_Sel_ptr (ir_node *node) {
611 assert (node->op == op_Sel);
612 return get_irn_n(node, 1);
616 set_Sel_ptr (ir_node *node, ir_node *ptr) {
617 assert (node->op == op_Sel);
618 set_irn_n(node, 1, ptr);
622 get_Sel_index_arr (ir_node *node)
624 assert ((node->op == op_Sel));
625 if (get_Sel_n_index(node) > 0)
626 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
632 get_Sel_n_index (ir_node *node) {
633 assert (node->op == op_Sel);
634 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
639 set_Sel_n_index (ir_node *node, int n_index) {
640 assert (node->op == op_Sel);
645 get_Sel_index (ir_node *node, int pos) {
646 assert (node->op == op_Sel);
647 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
651 set_Sel_index (ir_node *node, int pos, ir_node *index) {
652 assert (node->op == op_Sel);
653 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
657 get_Sel_entity (ir_node *node) {
658 assert (node->op == op_Sel);
659 return node->attr.s.ent;
663 set_Sel_entity (ir_node *node, entity *ent) {
664 assert (node->op == op_Sel);
665 node->attr.s.ent = ent;
669 get_Sel_linkage_type (ir_node *node) {
670 assert (node->op == op_Sel);
671 return node->attr.s.ltyp;
675 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
676 assert (node->op == op_Sel);
677 node->attr.s.ltyp = lt;
681 get_Call_mem (ir_node *node) {
682 assert (node->op == op_Call);
683 return get_irn_n(node, 0);
687 set_Call_mem (ir_node *node, ir_node *mem) {
688 assert (node->op == op_Call);
689 set_irn_n(node, 0, mem);
693 get_Call_ptr (ir_node *node) {
694 assert (node->op == op_Call);
695 return get_irn_n(node, 1);
699 set_Call_ptr (ir_node *node, ir_node *ptr) {
700 assert (node->op == op_Call);
701 set_irn_n(node, 1, ptr);
705 get_Call_param_arr (ir_node *node) {
706 assert (node->op == op_Call);
707 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
711 get_Call_n_params (ir_node *node) {
712 assert (node->op == op_Call);
713 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
717 get_Call_arity (ir_node *node) {
718 return get_Call_n_params(node);
722 set_Call_arity (ir_node *node, ir_node *arity) {
723 assert (node->op == op_Call);
728 get_Call_param (ir_node *node, int pos) {
729 assert (node->op == op_Call);
730 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
734 set_Call_param (ir_node *node, int pos, ir_node *param) {
735 assert (node->op == op_Call);
736 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
740 get_Call_type (ir_node *node) {
741 assert (node->op == op_Call);
742 return node->attr.call;
746 set_Call_type (ir_node *node, type_method *type) {
747 assert (node->op == op_Call);
748 node->attr.call = type;
751 /* For unary and binary arithmetic operations the access to the
752 operands can be factored out. Left is the first, right the
753 second arithmetic value as listed in tech report 0999-33.
754 unops are: Minus, Abs, Not, Conv
755 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
756 Shr, Shrs, Rotate, Cmp */
759 is_unop (ir_node *node) {
760 return ( node->op == op_Minus ||
761 node->op == op_Abs ||
762 node->op == op_Not ||
763 node->op == op_Conv );
767 get_unop_op (ir_node *node) {
768 assert ( node->op == op_Minus ||
769 node->op == op_Abs ||
770 node->op == op_Not ||
771 node->op == op_Conv );
772 switch (get_irn_opcode (node)) {
773 case iro_Minus: return get_Minus_op(node); break;
774 case iro_Abs: return get_Abs_op(node); break;
775 case iro_Not: return get_Not_op(node); break;
776 case iro_Conv: return get_Conv_op(node); break;
777 default: return NULL;
782 set_unop_op (ir_node *node, ir_node *op) {
783 assert (node->op == op_Minus ||
784 node->op == op_Abs ||
785 node->op == op_Not ||
786 node->op == op_Conv );
787 switch (get_irn_opcode (node)) {
788 case iro_Minus: set_Minus_op(node, op); break;
789 case iro_Abs: set_Abs_op(node, op); break;
790 case iro_Not: set_Not_op(node, op); break;
791 case iro_Conv: set_Conv_op(node, op); break;
798 is_binop (ir_node *node) {
799 return (node->op == op_Add ||
800 node->op == op_Sub ||
801 node->op == op_Mul ||
802 node->op == op_Quot ||
803 node->op == op_DivMod ||
804 node->op == op_Div ||
805 node->op == op_Mod ||
806 node->op == op_And ||
808 node->op == op_Eor ||
809 node->op == op_Shl ||
810 node->op == op_Shr ||
811 node->op == op_Shrs ||
812 node->op == op_Rot ||
813 node->op == op_Cmp );
817 get_binop_left (ir_node *node) {
818 assert (node->op == op_Add ||
819 node->op == op_Sub ||
820 node->op == op_Mul ||
821 node->op == op_Quot ||
822 node->op == op_DivMod ||
823 node->op == op_Div ||
824 node->op == op_Mod ||
825 node->op == op_And ||
827 node->op == op_Eor ||
828 node->op == op_Shl ||
829 node->op == op_Shr ||
830 node->op == op_Shrs ||
831 node->op == op_Rot ||
832 node->op == op_Cmp );
834 switch (get_irn_opcode (node)) {
835 case iro_Add : return get_Add_left(node); break;
836 case iro_Sub : return get_Sub_left(node); break;
837 case iro_Mul : return get_Mul_left(node); break;
838 case iro_Quot : return get_Quot_left(node); break;
839 case iro_DivMod: return get_DivMod_left(node); break;
840 case iro_Div : return get_Div_left(node); break;
841 case iro_Mod : return get_Mod_left(node); break;
842 case iro_And : return get_And_left(node); break;
843 case iro_Or : return get_Or_left(node); break;
844 case iro_Eor : return get_Eor_left(node); break;
845 case iro_Shl : return get_Shl_left(node); break;
846 case iro_Shr : return get_Shr_left(node); break;
847 case iro_Shrs : return get_Shrs_left(node); break;
848 case iro_Rot : return get_Rot_left(node); break;
849 case iro_Cmp : return get_Cmp_left(node); break;
850 default: return NULL;
855 set_binop_left (ir_node *node, ir_node *left) {
856 assert (node->op == op_Add ||
857 node->op == op_Sub ||
858 node->op == op_Mul ||
859 node->op == op_Quot ||
860 node->op == op_DivMod ||
861 node->op == op_Div ||
862 node->op == op_Mod ||
863 node->op == op_And ||
865 node->op == op_Eor ||
866 node->op == op_Shl ||
867 node->op == op_Shr ||
868 node->op == op_Shrs ||
869 node->op == op_Rot ||
870 node->op == op_Cmp );
872 switch (get_irn_opcode (node)) {
873 case iro_Add : set_Add_left(node, left); break;
874 case iro_Sub : set_Sub_left(node, left); break;
875 case iro_Mul : set_Mul_left(node, left); break;
876 case iro_Quot : set_Quot_left(node, left); break;
877 case iro_DivMod: set_DivMod_left(node, left); break;
878 case iro_Div : set_Div_left(node, left); break;
879 case iro_Mod : set_Mod_left(node, left); break;
880 case iro_And : set_And_left(node, left); break;
881 case iro_Or : set_Or_left(node, left); break;
882 case iro_Eor : set_Eor_left(node, left); break;
883 case iro_Shl : set_Shl_left(node, left); break;
884 case iro_Shr : set_Shr_left(node, left); break;
885 case iro_Shrs : set_Shrs_left(node, left); break;
886 case iro_Rot : set_Rot_left(node, left); break;
887 case iro_Cmp : set_Cmp_left(node, left); break;
893 get_binop_right (ir_node *node) {
894 assert (node->op == op_Add ||
895 node->op == op_Sub ||
896 node->op == op_Mul ||
897 node->op == op_Quot ||
898 node->op == op_DivMod ||
899 node->op == op_Div ||
900 node->op == op_Mod ||
901 node->op == op_And ||
903 node->op == op_Eor ||
904 node->op == op_Shl ||
905 node->op == op_Shr ||
906 node->op == op_Shrs ||
907 node->op == op_Rot ||
908 node->op == op_Cmp );
910 switch (get_irn_opcode (node)) {
911 case iro_Add : return get_Add_right(node); break;
912 case iro_Sub : return get_Sub_right(node); break;
913 case iro_Mul : return get_Mul_right(node); break;
914 case iro_Quot : return get_Quot_right(node); break;
915 case iro_DivMod: return get_DivMod_right(node); break;
916 case iro_Div : return get_Div_right(node); break;
917 case iro_Mod : return get_Mod_right(node); break;
918 case iro_And : return get_And_right(node); break;
919 case iro_Or : return get_Or_right(node); break;
920 case iro_Eor : return get_Eor_right(node); break;
921 case iro_Shl : return get_Shl_right(node); break;
922 case iro_Shr : return get_Shr_right(node); break;
923 case iro_Shrs : return get_Shrs_right(node); break;
924 case iro_Rot : return get_Rot_right(node); break;
925 case iro_Cmp : return get_Cmp_right(node); break;
926 default: return NULL;
931 set_binop_right (ir_node *node, ir_node *right) {
932 assert (node->op == op_Add ||
933 node->op == op_Sub ||
934 node->op == op_Mul ||
935 node->op == op_Quot ||
936 node->op == op_DivMod ||
937 node->op == op_Div ||
938 node->op == op_Mod ||
939 node->op == op_And ||
941 node->op == op_Eor ||
942 node->op == op_Shl ||
943 node->op == op_Shr ||
944 node->op == op_Shrs ||
945 node->op == op_Rot ||
946 node->op == op_Cmp );
948 switch (get_irn_opcode (node)) {
949 case iro_Add : set_Add_right(node, right); break;
950 case iro_Sub : set_Sub_right(node, right); break;
951 case iro_Mul : set_Mul_right(node, right); break;
952 case iro_Quot : set_Quot_right(node, right); break;
953 case iro_DivMod: set_DivMod_right(node, right); break;
954 case iro_Div : set_Div_right(node, right); break;
955 case iro_Mod : set_Mod_right(node, right); break;
956 case iro_And : set_And_right(node, right); break;
957 case iro_Or : set_Or_right(node, right); break;
958 case iro_Eor : set_Eor_right(node, right); break;
959 case iro_Shl : set_Shl_right(node, right); break;
960 case iro_Shr : set_Shr_right(node, right); break;
961 case iro_Shrs : set_Shrs_right(node, right); break;
962 case iro_Rot : set_Rot_right(node, right); break;
963 case iro_Cmp : set_Cmp_right(node, right); break;
969 get_Add_left (ir_node *node) {
970 assert (node->op == op_Add);
971 return get_irn_n(node, 0);
975 set_Add_left (ir_node *node, ir_node *left) {
976 assert (node->op == op_Add);
977 set_irn_n(node, 0, left);
981 get_Add_right (ir_node *node) {
982 assert (node->op == op_Add);
983 return get_irn_n(node, 1);
987 set_Add_right (ir_node *node, ir_node *right) {
988 assert (node->op == op_Add);
989 set_irn_n(node, 1, right);
993 get_Sub_left (ir_node *node) {
994 assert (node->op == op_Sub);
995 return get_irn_n(node, 0);
999 set_Sub_left (ir_node *node, ir_node *left) {
1000 assert (node->op == op_Sub);
1001 set_irn_n(node, 0, left);
1005 get_Sub_right (ir_node *node) {
1006 assert (node->op == op_Sub);
1007 return get_irn_n(node, 1);
1011 set_Sub_right (ir_node *node, ir_node *right) {
1012 assert (node->op == op_Sub);
1013 set_irn_n(node, 1, right);
1018 get_Minus_op (ir_node *node) {
1019 assert (node->op == op_Minus);
1020 return get_irn_n(node, 0);
1024 set_Minus_op (ir_node *node, ir_node *op) {
1025 assert (node->op == op_Minus);
1026 set_irn_n(node, 0, op);
1031 get_Mul_left (ir_node *node) {
1032 assert (node->op == op_Mul);
1033 return get_irn_n(node, 0);
1037 set_Mul_left (ir_node *node, ir_node *left) {
1038 assert (node->op == op_Mul);
1039 set_irn_n(node, 0, left);
1043 get_Mul_right (ir_node *node) {
1044 assert (node->op == op_Mul);
1045 return get_irn_n(node, 1);
1049 set_Mul_right (ir_node *node, ir_node *right) {
1050 assert (node->op == op_Mul);
1051 set_irn_n(node, 1, right);
1055 get_Quot_left (ir_node *node) {
1056 assert (node->op == op_Quot);
1057 return get_irn_n(node, 1);
1061 set_Quot_left (ir_node *node, ir_node *left) {
1062 assert (node->op == op_Quot);
1063 set_irn_n(node, 1, left);
1067 get_Quot_right (ir_node *node) {
1068 assert (node->op == op_Quot);
1069 return get_irn_n(node, 2);
1073 set_Quot_right (ir_node *node, ir_node *right) {
1074 assert (node->op == op_Quot);
1075 set_irn_n(node, 2, right);
1079 get_Quot_mem (ir_node *node) {
1080 assert (node->op == op_Quot);
1081 return get_irn_n(node, 0);
1085 set_Quot_mem (ir_node *node, ir_node *mem) {
1086 assert (node->op == op_Quot);
1087 set_irn_n(node, 0, mem);
1091 get_DivMod_left (ir_node *node) {
1092 assert (node->op == op_DivMod);
1093 return get_irn_n(node, 1);
1097 set_DivMod_left (ir_node *node, ir_node *left) {
1098 assert (node->op == op_DivMod);
1099 set_irn_n(node, 1, left);
1103 get_DivMod_right (ir_node *node) {
1104 assert (node->op == op_DivMod);
1105 return get_irn_n(node, 2);
1109 set_DivMod_right (ir_node *node, ir_node *right) {
1110 assert (node->op == op_DivMod);
1111 set_irn_n(node, 2, right);
1115 get_DivMod_mem (ir_node *node) {
1116 assert (node->op == op_DivMod);
1117 return get_irn_n(node, 0);
1121 set_DivMod_mem (ir_node *node, ir_node *mem) {
1122 assert (node->op == op_DivMod);
1123 set_irn_n(node, 0, mem);
1127 get_Div_left (ir_node *node) {
1128 assert (node->op == op_Div);
1129 return get_irn_n(node, 1);
1133 set_Div_left (ir_node *node, ir_node *left) {
1134 assert (node->op == op_Div);
1135 set_irn_n(node, 1, left);
1139 get_Div_right (ir_node *node) {
1140 assert (node->op == op_Div);
1141 return get_irn_n(node, 2);
1145 set_Div_right (ir_node *node, ir_node *right) {
1146 assert (node->op == op_Div);
1147 set_irn_n(node, 2, right);
1151 get_Div_mem (ir_node *node) {
1152 assert (node->op == op_Div);
1153 return get_irn_n(node, 0);
1157 set_Div_mem (ir_node *node, ir_node *mem) {
1158 assert (node->op == op_Div);
1159 set_irn_n(node, 0, mem);
1163 get_Mod_left (ir_node *node) {
1164 assert (node->op == op_Mod);
1165 return get_irn_n(node, 1);
1169 set_Mod_left (ir_node *node, ir_node *left) {
1170 assert (node->op == op_Mod);
1171 set_irn_n(node, 1, left);
1175 get_Mod_right (ir_node *node) {
1176 assert (node->op == op_Mod);
1177 return get_irn_n(node, 2);
1181 set_Mod_right (ir_node *node, ir_node *right) {
1182 assert (node->op == op_Mod);
1183 set_irn_n(node, 2, right);
1187 get_Mod_mem (ir_node *node) {
1188 assert (node->op == op_Mod);
1189 return get_irn_n(node, 0);
1193 set_Mod_mem (ir_node *node, ir_node *mem) {
1194 assert (node->op == op_Mod);
1195 set_irn_n(node, 0, mem);
1199 get_Abs_op (ir_node *node) {
1200 assert (node->op == op_Abs);
1201 return get_irn_n(node, 0);
1205 set_Abs_op (ir_node *node, ir_node *op) {
1206 assert (node->op == op_Abs);
1207 set_irn_n(node, 0, op);
1211 get_And_left (ir_node *node) {
1212 assert (node->op == op_And);
1213 return get_irn_n(node, 0);
1217 set_And_left (ir_node *node, ir_node *left) {
1218 assert (node->op == op_And);
1219 set_irn_n(node, 0, left);
1223 get_And_right (ir_node *node) {
1224 assert (node->op == op_And);
1225 return get_irn_n(node, 1);
1229 set_And_right (ir_node *node, ir_node *right) {
1230 assert (node->op == op_And);
1231 set_irn_n(node, 1, right);
1235 get_Or_left (ir_node *node) {
1236 assert (node->op == op_Or);
1237 return get_irn_n(node, 0);
1241 set_Or_left (ir_node *node, ir_node *left) {
1242 assert (node->op == op_Or);
1243 set_irn_n(node, 0, left);
1247 get_Or_right (ir_node *node) {
1248 assert (node->op == op_Or);
1249 return get_irn_n(node, 1);
1253 set_Or_right (ir_node *node, ir_node *right) {
1254 assert (node->op == op_Or);
1255 set_irn_n(node, 1, right);
1259 get_Eor_left (ir_node *node) {
1260 assert (node->op == op_Eor);
1261 return get_irn_n(node, 0);
1265 set_Eor_left (ir_node *node, ir_node *left) {
1266 assert (node->op == op_Eor);
1267 set_irn_n(node, 0, left);
1271 get_Eor_right (ir_node *node) {
1272 assert (node->op == op_Eor);
1273 return get_irn_n(node, 1);
1277 set_Eor_right (ir_node *node, ir_node *right) {
1278 assert (node->op == op_Eor);
1279 set_irn_n(node, 1, right);
1284 get_Not_op (ir_node *node) {
1285 assert (node->op == op_Not);
1286 return get_irn_n(node, 0);
1290 set_Not_op (ir_node *node, ir_node *op) {
1291 assert (node->op == op_Not);
1292 set_irn_n(node, 0, op);
1297 get_Shl_left (ir_node *node) {
1298 assert (node->op == op_Shl);
1299 return get_irn_n(node, 0);
1303 set_Shl_left (ir_node *node, ir_node *left) {
1304 assert (node->op == op_Shl);
1305 set_irn_n(node, 0, left);
1309 get_Shl_right (ir_node *node) {
1310 assert (node->op == op_Shl);
1311 return get_irn_n(node, 1);
1315 set_Shl_right (ir_node *node, ir_node *right) {
1316 assert (node->op == op_Shl);
1317 set_irn_n(node, 1, right);
1321 get_Shr_left (ir_node *node) {
1322 assert (node->op == op_Shr);
1323 return get_irn_n(node, 0);
1327 set_Shr_left (ir_node *node, ir_node *left) {
1328 assert (node->op == op_Shr);
1329 set_irn_n(node, 0, left);
1333 get_Shr_right (ir_node *node) {
1334 assert (node->op == op_Shr);
1335 return get_irn_n(node, 1);
1339 set_Shr_right (ir_node *node, ir_node *right) {
1340 assert (node->op == op_Shr);
1341 set_irn_n(node, 1, right);
1345 get_Shrs_left (ir_node *node) {
1346 assert (node->op == op_Shrs);
1347 return get_irn_n(node, 0);
1351 set_Shrs_left (ir_node *node, ir_node *left) {
1352 assert (node->op == op_Shrs);
1353 set_irn_n(node, 0, left);
1357 get_Shrs_right (ir_node *node) {
1358 assert (node->op == op_Shrs);
1359 return get_irn_n(node, 1);
1363 set_Shrs_right (ir_node *node, ir_node *right) {
1364 assert (node->op == op_Shrs);
1365 set_irn_n(node, 1, right);
1369 get_Rot_left (ir_node *node) {
1370 assert (node->op == op_Rot);
1371 return get_irn_n(node, 0);
1375 set_Rot_left (ir_node *node, ir_node *left) {
1376 assert (node->op == op_Rot);
1377 set_irn_n(node, 0, left);
1381 get_Rot_right (ir_node *node) {
1382 assert (node->op == op_Rot);
1383 return get_irn_n(node, 1);
1387 set_Rot_right (ir_node *node, ir_node *right) {
1388 assert (node->op == op_Rot);
1389 set_irn_n(node, 1, right);
1393 get_Cmp_left (ir_node *node) {
1394 assert (node->op == op_Cmp);
1395 return get_irn_n(node, 0);
1399 set_Cmp_left (ir_node *node, ir_node *left) {
1400 assert (node->op == op_Cmp);
1401 set_irn_n(node, 0, left);
1405 get_Cmp_right (ir_node *node) {
1406 assert (node->op == op_Cmp);
1407 return get_irn_n(node, 1);
1411 set_Cmp_right (ir_node *node, ir_node *right) {
1412 assert (node->op == op_Cmp);
1413 set_irn_n(node, 1, right);
1417 get_Conv_op (ir_node *node) {
1418 assert (node->op == op_Conv);
1419 return get_irn_n(node, 0);
1423 set_Conv_op (ir_node *node, ir_node *op) {
1424 assert (node->op == op_Conv);
1425 set_irn_n(node, 0, op);
1429 get_Phi_preds_arr (ir_node *node) {
1430 assert (node->op == op_Phi);
1431 return (ir_node **)&(get_irn_in(node)[1]);
1435 get_Phi_n_preds (ir_node *node) {
1436 assert (node->op == op_Phi);
1437 return (get_irn_arity(node));
1441 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1442 assert (node->op == op_Phi);
1447 get_Phi_pred (ir_node *node, int pos) {
1448 assert (node->op == op_Phi);
1449 return get_irn_n(node, pos);
1453 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1454 assert (node->op == op_Phi);
1455 set_irn_n(node, pos, pred);
1459 get_Load_mem (ir_node *node) {
1460 assert (node->op == op_Load);
1461 return get_irn_n(node, 0);
1465 set_Load_mem (ir_node *node, ir_node *mem) {
1466 assert (node->op == op_Load);
1467 set_irn_n(node, 0, mem);
1471 get_Load_ptr (ir_node *node) {
1472 assert (node->op == op_Load);
1473 return get_irn_n(node, 1);
1477 set_Load_ptr (ir_node *node, ir_node *ptr) {
1478 assert (node->op == op_Load);
1479 set_irn_n(node, 1, ptr);
1484 get_Store_mem (ir_node *node) {
1485 assert (node->op == op_Store);
1486 return get_irn_n(node, 0);
1490 set_Store_mem (ir_node *node, ir_node *mem) {
1491 assert (node->op == op_Store);
1492 set_irn_n(node, 0, mem);
1496 get_Store_ptr (ir_node *node) {
1497 assert (node->op == op_Store);
1498 return get_irn_n(node, 1);
1502 set_Store_ptr (ir_node *node, ir_node *ptr) {
1503 assert (node->op == op_Store);
1504 set_irn_n(node, 1, ptr);
1508 get_Store_value (ir_node *node) {
1509 assert (node->op == op_Store);
1510 return get_irn_n(node, 2);
1514 set_Store_value (ir_node *node, ir_node *value) {
1515 assert (node->op == op_Store);
1516 set_irn_n(node, 2, value);
1520 get_Alloc_mem (ir_node *node) {
1521 assert (node->op == op_Alloc);
1522 return get_irn_n(node, 0);
1526 set_Alloc_mem (ir_node *node, ir_node *mem) {
1527 assert (node->op == op_Alloc);
1528 set_irn_n(node, 0, mem);
1532 get_Alloc_size (ir_node *node) {
1533 assert (node->op == op_Alloc);
1534 return get_irn_n(node, 1);
1538 set_Allco_size (ir_node *node, ir_node *size) {
1539 assert (node->op == op_Alloc);
1540 set_irn_n(node, 1, size);
1544 get_Alloc_type (ir_node *node) {
1545 assert (node->op == op_Alloc);
1546 return node->attr.a.type;
1550 set_Alloc_type (ir_node *node, type *type) {
1551 assert (node->op == op_Alloc);
1552 node->attr.a.type = type;
1556 get_Alloc_where (ir_node *node) {
1557 assert (node->op == op_Alloc);
1558 return node->attr.a.where;
1562 set_Alloc_where (ir_node *node, where_alloc where) {
1563 assert (node->op == op_Alloc);
1564 node->attr.a.where = where;
1569 get_Free_mem (ir_node *node) {
1570 assert (node->op == op_Free);
1571 return get_irn_n(node, 0);
1575 set_Free_mem (ir_node *node, ir_node *mem) {
1576 assert (node->op == op_Free);
1577 set_irn_n(node, 0, mem);
1581 get_Free_ptr (ir_node *node) {
1582 assert (node->op == op_Free);
1583 return get_irn_n(node, 1);
1587 set_Free_ptr (ir_node *node, ir_node *ptr) {
1588 assert (node->op == op_Free);
1589 set_irn_n(node, 1, ptr);
1593 get_Free_size (ir_node *node) {
1594 assert (node->op == op_Free);
1595 return get_irn_n(node, 2);
1599 set_Free_size (ir_node *node, ir_node *size) {
1600 assert (node->op == op_Free);
1601 set_irn_n(node, 2, size);
1605 get_Free_type (ir_node *node) {
1606 assert (node->op == op_Free);
1607 return node->attr.f;
1611 set_Free_type (ir_node *node, type *type) {
1612 assert (node->op == op_Free);
1613 node->attr.f = type;
1617 get_Sync_preds_arr (ir_node *node) {
1618 assert (node->op == op_Sync);
1619 return (ir_node **)&(get_irn_in(node)[1]);
1623 get_Sync_n_preds (ir_node *node) {
1624 assert (node->op == op_Sync);
1625 return (get_irn_arity(node));
1630 set_Sync_n_preds (ir_node *node, int n_preds) {
1631 assert (node->op == op_Sync);
1636 get_Sync_pred (ir_node *node, int pos) {
1637 assert (node->op == op_Sync);
1638 return get_irn_n(node, pos);
1642 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1643 assert (node->op == op_Sync);
1644 set_irn_n(node, pos, pred);
1648 get_Proj_pred (ir_node *node) {
1649 assert (node->op == op_Proj);
1650 return get_irn_n(node, 0);
1654 set_Proj_pred (ir_node *node, ir_node *pred) {
1655 assert (node->op == op_Proj);
1656 set_irn_n(node, 0, pred);
1660 get_Proj_proj (ir_node *node) {
1661 assert (node->op == op_Proj);
1662 return node->attr.proj;
1666 set_Proj_proj (ir_node *node, long proj) {
1667 assert (node->op == op_Proj);
1668 node->attr.proj = proj;
1672 get_Tuple_preds_arr (ir_node *node) {
1673 assert (node->op == op_Tuple);
1674 return (ir_node **)&(get_irn_in(node)[1]);
1678 get_Tuple_n_preds (ir_node *node) {
1679 assert (node->op == op_Tuple);
1680 return (get_irn_arity(node));
1685 set_Tuple_n_preds (ir_node *node, int n_preds) {
1686 assert (node->op == op_Tuple);
1691 get_Tuple_pred (ir_node *node, int pos) {
1692 assert (node->op == op_Tuple);
1693 return get_irn_n(node, pos);
1697 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1698 assert (node->op == op_Tuple);
1699 set_irn_n(node, pos, pred);
1703 get_Id_pred (ir_node *node) {
1704 assert (node->op == op_Id);
1705 return get_irn_n(node, 0);
1709 set_Id_pred (ir_node *node, ir_node *pred) {
1710 assert (node->op == op_Id);
1711 set_irn_n(node, 0, pred);
1714 /******************************************************************/
1715 /* Auxiliary routines */
1716 /******************************************************************/
1719 skip_Proj (ir_node *node) {
1720 /* don't assert node !!! */
1721 if (node && (node->op == op_Proj)) {
1722 return get_Proj_pred(node);
1729 skip_nop (ir_node *node) {
1730 /* don't assert node !!! */
1732 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1733 return get_Id_pred(node);
1740 is_Bad (ir_node *node) {
1742 if ((node) && get_irn_opcode(node) == iro_Bad)
1748 is_no_Block (ir_node *node) {
1750 return (get_irn_opcode(node) != iro_Block);
1753 /* Returns true if the operation manipulates control flow. */
1755 is_cfop(ir_node *node) {
1756 return ( (get_irn_opcode(node) == iro_Start)
1757 || (get_irn_opcode(node) == iro_Jmp)
1758 || (get_irn_opcode(node) == iro_Cond)
1759 || (get_irn_opcode(node) == iro_Return)
1760 || (get_irn_opcode(node) == iro_Raise)
1761 || (get_irn_opcode(node) == iro_Bad));
1764 /* Returns true if the operation can change the control flow because
1767 is_fragile_op(ir_node *node) {
1768 return ( (get_irn_opcode(node) == iro_Call)
1769 || (get_irn_opcode(node) == iro_Quot)
1770 || (get_irn_opcode(node) == iro_DivMod)
1771 || (get_irn_opcode(node) == iro_Div)
1772 || (get_irn_opcode(node) == iro_Mod)
1773 || (get_irn_opcode(node) == iro_Load)
1774 || (get_irn_opcode(node) == iro_Store)
1775 || (get_irn_opcode(node) == iro_Alloc)
1776 || (get_irn_opcode(node) == iro_Bad));