1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
18 /* some constants fixing the positions of nodes predecessors
20 #define CALL_PARAM_OFFSET 2
21 #define SEL_INDEX_OFFSET 2
22 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
24 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
25 "Gt", "Ge", "Lg", "Leg", "Uo",
26 "Ue", "Ul", "Ule", "Ug", "Uge",
29 inline char *get_pnc_string(int pnc) {
30 return pnc_name_arr[pnc];
35 get_negated_pnc(int pnc) {
37 case False: return True; break;
38 case Eq: return Ne; break;
39 case Lt: return Uge; break;
40 case Le: return Ug; break;
41 case Gt: return Ule; break;
42 case Ge: return Ul; break;
43 case Lg: return Ue; break;
44 case Leg: return Uo; break;
45 case Uo: return Leg; break;
46 case Ue: return Lg; break;
47 case Ul: return Ge; break;
48 case Ule: return Gt; break;
49 case Ug: return Le; break;
50 case Uge: return Lt; break;
51 case Ne: return Eq; break;
52 case True: return False; break;
54 return 99; /* to shut up gcc */
57 static char *pns_name_arr [] = {"initial_exec", "global_store",
58 "frame_base", "globals", "args"};
60 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
67 /* irnode constructor */
68 /* create a new irnode in irg, with an op, mode, arity and */
69 /* some incoming irnodes */
70 /* this constructor is used in every specified irnode constructor */
72 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
73 int arity, ir_node **in)
76 int node_size = offsetof (ir_node, attr) + op->attr_size;
78 res = (ir_node *) obstack_alloc (irg->obst, node_size);
80 res->kind = k_ir_node;
86 res->in = NEW_ARR_F (ir_node *, 1);
88 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
89 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
94 res->node_nr = get_irp_new_node_nr();
100 /* Copies all attributes stored in the old node to the new node.
101 Assumes both have the same opcode and sufficient size. */
103 copy_attrs (ir_node *old, ir_node *new) {
104 assert (get_irn_opcode(old) == get_irn_opcode(new));
105 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
108 /* IR-Nodes with attributes */
110 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
113 ir_node *np = XP_GETARG (ir_node *, 0);
116 XPS ("<null ir_node>");
120 XPF1 ("%I", get_irn_opident(np));
122 switch (get_irn_opcode (np)) { /* node label */
124 XPF1 ("%I", get_irn_mode(np)->name);
126 XPF1 ("%v", get_irn_const_attr);
129 if (get_irn_modecode (np) == irm_b) {
131 XP (pnc_name_arr[get_irn_proj_attr(np)]);
132 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
134 XP (pns_name_arr[get_irn_proj_attr(np)]);
136 XPF1 ("%I", get_irn_mode(np)->name);
138 XPF1 ("%d", get_irn_proj_attr(np));
142 XPF1 ("%I", get_irn_mode(np)->name);
144 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
145 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
147 case iro_Start: /* don't dump mode of these */
156 XPF1 ("%I", get_irn_mode(np)->name);
163 /** getting some parameters from ir_nodes **/
165 /* returns the number of predecessors without the block predecessor. */
167 get_irn_arity (ir_node *node)
170 return (ARR_LEN((node)->in)-1);
173 /* Returns the array with ins. This array is shifted with respect to the
174 array accessed by get_irn_n: The block operand is at position 0 not -1.
175 (@@@ This should be changed.)
176 The order of the predecessors in this array is not guaranteed, except that
177 lists of operands as predecessors of Block or arguments of a Call are
180 get_irn_in (ir_node *node)
186 /* to iterate through the predecessors without touching the array */
187 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
188 to iterate includind the Block predecessor iterate from i = -1 to
190 If it is a block, the entry -1 is NULL. */
192 get_irn_n (ir_node *node, int n)
195 assert (get_irn_arity (node) > n);
196 return skip_nop(node->in[n+1]);
200 set_irn_n (ir_node *node, int n, ir_node *in)
203 assert (get_irn_arity (node) > n);
208 get_irn_mode (ir_node *node)
215 get_irn_modecode (ir_node *node)
218 return node->mode->code;
223 get_irn_modeident (ir_node *node)
226 return node->mode->name;
230 get_irn_op (ir_node *node)
236 /* should be private to the library: */
238 set_irn_op (ir_node *node, ir_op *op)
245 get_irn_opcode (ir_node *node)
248 return node->op->code;
252 get_irn_opname (ir_node *node)
255 return id_to_str(node->op->name);
259 get_irn_opident (ir_node *node)
262 return node->op->name;
266 get_irn_visited (ir_node *node)
269 return node->visited;
273 set_irn_visited (ir_node *node, unsigned long visited)
276 node->visited = visited;
279 set_irn_link (ir_node *node, ir_node *link) {
285 get_irn_link (ir_node *node) {
291 /* Outputs a unique number for this node */
293 get_irn_node_nr(ir_node *node) {
295 return node->node_nr;
300 get_irn_const_attr (ir_node *node)
302 assert (node->op == op_Const);
303 return node->attr.con;
307 get_irn_proj_attr (ir_node *node)
309 assert (node->op == op_Proj);
310 return node->attr.proj;
314 get_irn_alloc_attr (ir_node *node)
316 assert (node->op == op_Alloc);
321 get_irn_free_attr (ir_node *node)
323 assert (node->op == op_Free);
328 get_irn_symconst_attr (ir_node *node)
330 assert (node->op == op_SymConst);
335 get_irn_call_attr (ir_node *node)
337 assert (node->op == op_Call);
338 return node->attr.call;
342 get_irn_sel_attr (ir_node *node)
344 assert (node->op == op_Sel);
349 get_irn_phi_attr (ir_node *node)
351 assert (node->op == op_Phi);
352 return node->attr.phi0_pos;
356 get_irn_block_attr (ir_node *node)
358 assert (node->op == op_Block);
359 return node->attr.block;
362 /** manipulate fields of individual nodes **/
364 /* this works for all except Block */
366 get_nodes_Block (ir_node *node) {
367 assert (!(node->op == op_Block));
368 return get_irn_n(node, -1);
372 set_nodes_Block (ir_node *node, ir_node *block) {
373 assert (!(node->op == op_Block));
374 set_irn_n(node, -1, block);
377 /* Returns an array with the predecessors of the Block. Depending on
378 the implementation of the graph datastructure this can be a copy of
379 the internal representation of predecessors as well as the internal
380 array itself. Therefore writing to this array might obstruct the ir. */
382 get_Block_cfgpred_arr (ir_node *node)
384 assert ((node->op == op_Block));
385 return (ir_node **)&(get_irn_in(node)[1]);
390 get_Block_n_cfgpreds (ir_node *node) {
391 assert ((node->op == op_Block));
392 return (get_irn_arity(node));
397 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
398 assert ((node->op == op_Block));
403 get_Block_cfgpred (ir_node *node, int pos) {
404 assert (node->op == op_Block);
405 return get_irn_n(node, pos);
409 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
410 assert (node->op == op_Block);
411 set_irn_n(node, pos, pred);
415 get_Block_matured (ir_node *node) {
416 assert (node->op == op_Block);
417 return node->attr.block.matured;
421 set_Block_matured (ir_node *node, bool matured) {
422 assert (node->op == op_Block);
423 node->attr.block.matured = matured;
426 get_Block_block_visited (ir_node *node) {
427 assert (node->op == op_Block);
428 return node->attr.block.block_visited;
432 set_Block_block_visited (ir_node *node, unsigned long visit) {
433 assert (node->op == op_Block);
434 node->attr.block.block_visited = visit;
438 get_Block_graph_arr (ir_node *node, int pos) {
439 assert (node->op == op_Block);
440 return node->attr.block.graph_arr[pos+1];
444 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
445 assert (node->op == op_Block);
446 node->attr.block.graph_arr[pos+1] = value;
450 get_Cond_selector (ir_node *node) {
451 assert (node->op == op_Cond);
452 return get_irn_n(node, 0);
456 set_Cond_selector (ir_node *node, ir_node *selector) {
457 assert (node->op == op_Cond);
458 set_irn_n(node, 0, selector);
462 get_Return_mem (ir_node *node) {
463 assert (node->op == op_Return);
464 return get_irn_n(node, 0);
468 set_Return_mem (ir_node *node, ir_node *mem) {
469 assert (node->op == op_Return);
470 set_irn_n(node, 0, mem);
474 get_Return_res_arr (ir_node *node)
476 assert ((node->op == op_Return));
477 if (get_Return_n_res(node) > 0)
478 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
484 get_Return_n_res (ir_node *node) {
485 assert (node->op == op_Return);
486 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
491 set_Return_n_res (ir_node *node, int results) {
492 assert (node->op == op_Return);
497 get_Return_res (ir_node *node, int pos) {
498 assert (node->op == op_Return);
499 assert (get_Return_n_res(node) > pos);
500 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
504 set_Return_res (ir_node *node, int pos, ir_node *res){
505 assert (node->op == op_Return);
506 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
510 get_Raise_mem (ir_node *node) {
511 assert (node->op == op_Return);
512 return get_irn_n(node, 0);
516 set_Raise_mem (ir_node *node, ir_node *mem) {
517 assert (node->op == op_Raise);
518 set_irn_n(node, 0, mem);
522 get_Raise_exo_ptr (ir_node *node) {
523 assert (node->op == op_Raise);
524 return get_irn_n(node, 1);
528 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
529 assert (node->op == op_Raise);
530 set_irn_n(node, 1, exo_ptr);
533 inline tarval *get_Const_tarval (ir_node *node) {
534 assert (node->op == op_Const);
535 return get_irn_const_attr(node);
539 set_Const_tarval (ir_node *node, tarval *con) {
540 assert (node->op == op_Const);
541 node->attr.con = con;
545 get_SymConst_kind (ir_node *node) {
546 assert (node->op == op_SymConst);
547 return node->attr.i.num;
551 set_SymConst_kind (ir_node *node, symconst_kind num) {
552 assert (node->op == op_SymConst);
553 node->attr.i.num = num;
557 get_SymConst_type (ir_node *node) {
558 assert ( (node->op == op_SymConst)
559 && ( get_SymConst_kind(node) == type_tag
560 || get_SymConst_kind(node) == size));
561 return node->attr.i.tori.typ;
565 set_SymConst_type (ir_node *node, type *type) {
566 assert ( (node->op == op_SymConst)
567 && ( get_SymConst_kind(node) == type_tag
568 || get_SymConst_kind(node) == size));
569 node->attr.i.tori.typ = type;
573 get_SymConst_ptrinfo (ir_node *node) {
574 assert ( (node->op == op_SymConst)
575 && (get_SymConst_kind(node) == linkage_ptr_info));
576 return node->attr.i.tori.ptrinfo;
580 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
581 assert ( (node->op == op_SymConst)
582 && (get_SymConst_kind(node) == linkage_ptr_info));
583 node->attr.i.tori.ptrinfo = ptrinfo;
587 get_SymConst_type_or_id (ir_node *node) {
588 assert (node->op == op_SymConst);
589 return &(node->attr.i.tori);
593 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
594 assert (node->op == op_SymConst);
595 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
599 get_Sel_mem (ir_node *node) {
600 assert (node->op == op_Sel);
601 return get_irn_n(node, 0);
605 set_Sel_mem (ir_node *node, ir_node *mem) {
606 assert (node->op == op_Sel);
607 set_irn_n(node, 0, mem);
611 get_Sel_ptr (ir_node *node) {
612 assert (node->op == op_Sel);
613 return get_irn_n(node, 1);
617 set_Sel_ptr (ir_node *node, ir_node *ptr) {
618 assert (node->op == op_Sel);
619 set_irn_n(node, 1, ptr);
623 get_Sel_index_arr (ir_node *node)
625 assert ((node->op == op_Sel));
626 if (get_Sel_n_index(node) > 0)
627 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
633 get_Sel_n_index (ir_node *node) {
634 assert (node->op == op_Sel);
635 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
640 set_Sel_n_index (ir_node *node, int n_index) {
641 assert (node->op == op_Sel);
646 get_Sel_index (ir_node *node, int pos) {
647 assert (node->op == op_Sel);
648 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
652 set_Sel_index (ir_node *node, int pos, ir_node *index) {
653 assert (node->op == op_Sel);
654 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
658 get_Sel_entity (ir_node *node) {
659 assert (node->op == op_Sel);
660 return node->attr.s.ent;
664 set_Sel_entity (ir_node *node, entity *ent) {
665 assert (node->op == op_Sel);
666 node->attr.s.ent = ent;
670 get_Sel_linkage_type (ir_node *node) {
671 assert (node->op == op_Sel);
672 return node->attr.s.ltyp;
676 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
677 assert (node->op == op_Sel);
678 node->attr.s.ltyp = lt;
682 get_Call_mem (ir_node *node) {
683 assert (node->op == op_Call);
684 return get_irn_n(node, 0);
688 set_Call_mem (ir_node *node, ir_node *mem) {
689 assert (node->op == op_Call);
690 set_irn_n(node, 0, mem);
694 get_Call_ptr (ir_node *node) {
695 assert (node->op == op_Call);
696 return get_irn_n(node, 1);
700 set_Call_ptr (ir_node *node, ir_node *ptr) {
701 assert (node->op == op_Call);
702 set_irn_n(node, 1, ptr);
706 get_Call_param_arr (ir_node *node) {
707 assert (node->op == op_Call);
708 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
712 get_Call_n_params (ir_node *node) {
713 assert (node->op == op_Call);
714 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
718 get_Call_arity (ir_node *node) {
719 return get_Call_n_params(node);
723 set_Call_arity (ir_node *node, ir_node *arity) {
724 assert (node->op == op_Call);
729 get_Call_param (ir_node *node, int pos) {
730 assert (node->op == op_Call);
731 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
735 set_Call_param (ir_node *node, int pos, ir_node *param) {
736 assert (node->op == op_Call);
737 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
741 get_Call_type (ir_node *node) {
742 assert (node->op == op_Call);
743 return node->attr.call;
747 set_Call_type (ir_node *node, type_method *type) {
748 assert (node->op == op_Call);
749 node->attr.call = type;
752 /* For unary and binary arithmetic operations the access to the
753 operands can be factored out. Left is the first, right the
754 second arithmetic value as listed in tech report 0999-33.
755 unops are: Minus, Abs, Not, Conv
756 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
757 Shr, Shrs, Rotate, Cmp */
760 is_unop (ir_node *node) {
761 return ( node->op == op_Minus ||
762 node->op == op_Abs ||
763 node->op == op_Not ||
764 node->op == op_Conv );
768 get_unop_op (ir_node *node) {
769 assert ( node->op == op_Minus ||
770 node->op == op_Abs ||
771 node->op == op_Not ||
772 node->op == op_Conv );
773 switch (get_irn_opcode (node)) {
774 case iro_Minus: return get_Minus_op(node); break;
775 case iro_Abs: return get_Abs_op(node); break;
776 case iro_Not: return get_Not_op(node); break;
777 case iro_Conv: return get_Conv_op(node); break;
778 default: return NULL;
783 set_unop_op (ir_node *node, ir_node *op) {
784 assert (node->op == op_Minus ||
785 node->op == op_Abs ||
786 node->op == op_Not ||
787 node->op == op_Conv );
788 switch (get_irn_opcode (node)) {
789 case iro_Minus: set_Minus_op(node, op); break;
790 case iro_Abs: set_Abs_op(node, op); break;
791 case iro_Not: set_Not_op(node, op); break;
792 case iro_Conv: set_Conv_op(node, op); break;
799 is_binop (ir_node *node) {
800 return (node->op == op_Add ||
801 node->op == op_Sub ||
802 node->op == op_Mul ||
803 node->op == op_Quot ||
804 node->op == op_DivMod ||
805 node->op == op_Div ||
806 node->op == op_Mod ||
807 node->op == op_And ||
809 node->op == op_Eor ||
810 node->op == op_Shl ||
811 node->op == op_Shr ||
812 node->op == op_Shrs ||
813 node->op == op_Rot ||
814 node->op == op_Cmp );
818 get_binop_left (ir_node *node) {
819 assert (node->op == op_Add ||
820 node->op == op_Sub ||
821 node->op == op_Mul ||
822 node->op == op_Quot ||
823 node->op == op_DivMod ||
824 node->op == op_Div ||
825 node->op == op_Mod ||
826 node->op == op_And ||
828 node->op == op_Eor ||
829 node->op == op_Shl ||
830 node->op == op_Shr ||
831 node->op == op_Shrs ||
832 node->op == op_Rot ||
833 node->op == op_Cmp );
835 switch (get_irn_opcode (node)) {
836 case iro_Add : return get_Add_left(node); break;
837 case iro_Sub : return get_Sub_left(node); break;
838 case iro_Mul : return get_Mul_left(node); break;
839 case iro_Quot : return get_Quot_left(node); break;
840 case iro_DivMod: return get_DivMod_left(node); break;
841 case iro_Div : return get_Div_left(node); break;
842 case iro_Mod : return get_Mod_left(node); break;
843 case iro_And : return get_And_left(node); break;
844 case iro_Or : return get_Or_left(node); break;
845 case iro_Eor : return get_Eor_left(node); break;
846 case iro_Shl : return get_Shl_left(node); break;
847 case iro_Shr : return get_Shr_left(node); break;
848 case iro_Shrs : return get_Shrs_left(node); break;
849 case iro_Rot : return get_Rot_left(node); break;
850 case iro_Cmp : return get_Cmp_left(node); break;
851 default: return NULL;
856 set_binop_left (ir_node *node, ir_node *left) {
857 assert (node->op == op_Add ||
858 node->op == op_Sub ||
859 node->op == op_Mul ||
860 node->op == op_Quot ||
861 node->op == op_DivMod ||
862 node->op == op_Div ||
863 node->op == op_Mod ||
864 node->op == op_And ||
866 node->op == op_Eor ||
867 node->op == op_Shl ||
868 node->op == op_Shr ||
869 node->op == op_Shrs ||
870 node->op == op_Rot ||
871 node->op == op_Cmp );
873 switch (get_irn_opcode (node)) {
874 case iro_Add : set_Add_left(node, left); break;
875 case iro_Sub : set_Sub_left(node, left); break;
876 case iro_Mul : set_Mul_left(node, left); break;
877 case iro_Quot : set_Quot_left(node, left); break;
878 case iro_DivMod: set_DivMod_left(node, left); break;
879 case iro_Div : set_Div_left(node, left); break;
880 case iro_Mod : set_Mod_left(node, left); break;
881 case iro_And : set_And_left(node, left); break;
882 case iro_Or : set_Or_left(node, left); break;
883 case iro_Eor : set_Eor_left(node, left); break;
884 case iro_Shl : set_Shl_left(node, left); break;
885 case iro_Shr : set_Shr_left(node, left); break;
886 case iro_Shrs : set_Shrs_left(node, left); break;
887 case iro_Rot : set_Rot_left(node, left); break;
888 case iro_Cmp : set_Cmp_left(node, left); break;
894 get_binop_right (ir_node *node) {
895 assert (node->op == op_Add ||
896 node->op == op_Sub ||
897 node->op == op_Mul ||
898 node->op == op_Quot ||
899 node->op == op_DivMod ||
900 node->op == op_Div ||
901 node->op == op_Mod ||
902 node->op == op_And ||
904 node->op == op_Eor ||
905 node->op == op_Shl ||
906 node->op == op_Shr ||
907 node->op == op_Shrs ||
908 node->op == op_Rot ||
909 node->op == op_Cmp );
911 switch (get_irn_opcode (node)) {
912 case iro_Add : return get_Add_right(node); break;
913 case iro_Sub : return get_Sub_right(node); break;
914 case iro_Mul : return get_Mul_right(node); break;
915 case iro_Quot : return get_Quot_right(node); break;
916 case iro_DivMod: return get_DivMod_right(node); break;
917 case iro_Div : return get_Div_right(node); break;
918 case iro_Mod : return get_Mod_right(node); break;
919 case iro_And : return get_And_right(node); break;
920 case iro_Or : return get_Or_right(node); break;
921 case iro_Eor : return get_Eor_right(node); break;
922 case iro_Shl : return get_Shl_right(node); break;
923 case iro_Shr : return get_Shr_right(node); break;
924 case iro_Shrs : return get_Shrs_right(node); break;
925 case iro_Rot : return get_Rot_right(node); break;
926 case iro_Cmp : return get_Cmp_right(node); break;
927 default: return NULL;
932 set_binop_right (ir_node *node, ir_node *right) {
933 assert (node->op == op_Add ||
934 node->op == op_Sub ||
935 node->op == op_Mul ||
936 node->op == op_Quot ||
937 node->op == op_DivMod ||
938 node->op == op_Div ||
939 node->op == op_Mod ||
940 node->op == op_And ||
942 node->op == op_Eor ||
943 node->op == op_Shl ||
944 node->op == op_Shr ||
945 node->op == op_Shrs ||
946 node->op == op_Rot ||
947 node->op == op_Cmp );
949 switch (get_irn_opcode (node)) {
950 case iro_Add : set_Add_right(node, right); break;
951 case iro_Sub : set_Sub_right(node, right); break;
952 case iro_Mul : set_Mul_right(node, right); break;
953 case iro_Quot : set_Quot_right(node, right); break;
954 case iro_DivMod: set_DivMod_right(node, right); break;
955 case iro_Div : set_Div_right(node, right); break;
956 case iro_Mod : set_Mod_right(node, right); break;
957 case iro_And : set_And_right(node, right); break;
958 case iro_Or : set_Or_right(node, right); break;
959 case iro_Eor : set_Eor_right(node, right); break;
960 case iro_Shl : set_Shl_right(node, right); break;
961 case iro_Shr : set_Shr_right(node, right); break;
962 case iro_Shrs : set_Shrs_right(node, right); break;
963 case iro_Rot : set_Rot_right(node, right); break;
964 case iro_Cmp : set_Cmp_right(node, right); break;
970 get_Add_left (ir_node *node) {
971 assert (node->op == op_Add);
972 return get_irn_n(node, 0);
976 set_Add_left (ir_node *node, ir_node *left) {
977 assert (node->op == op_Add);
978 set_irn_n(node, 0, left);
982 get_Add_right (ir_node *node) {
983 assert (node->op == op_Add);
984 return get_irn_n(node, 1);
988 set_Add_right (ir_node *node, ir_node *right) {
989 assert (node->op == op_Add);
990 set_irn_n(node, 1, right);
994 get_Sub_left (ir_node *node) {
995 assert (node->op == op_Sub);
996 return get_irn_n(node, 0);
1000 set_Sub_left (ir_node *node, ir_node *left) {
1001 assert (node->op == op_Sub);
1002 set_irn_n(node, 0, left);
1006 get_Sub_right (ir_node *node) {
1007 assert (node->op == op_Sub);
1008 return get_irn_n(node, 1);
1012 set_Sub_right (ir_node *node, ir_node *right) {
1013 assert (node->op == op_Sub);
1014 set_irn_n(node, 1, right);
1019 get_Minus_op (ir_node *node) {
1020 assert (node->op == op_Minus);
1021 return get_irn_n(node, 0);
1025 set_Minus_op (ir_node *node, ir_node *op) {
1026 assert (node->op == op_Minus);
1027 set_irn_n(node, 0, op);
1032 get_Mul_left (ir_node *node) {
1033 assert (node->op == op_Mul);
1034 return get_irn_n(node, 0);
1038 set_Mul_left (ir_node *node, ir_node *left) {
1039 assert (node->op == op_Mul);
1040 set_irn_n(node, 0, left);
1044 get_Mul_right (ir_node *node) {
1045 assert (node->op == op_Mul);
1046 return get_irn_n(node, 1);
1050 set_Mul_right (ir_node *node, ir_node *right) {
1051 assert (node->op == op_Mul);
1052 set_irn_n(node, 1, right);
1056 get_Quot_left (ir_node *node) {
1057 assert (node->op == op_Quot);
1058 return get_irn_n(node, 1);
1062 set_Quot_left (ir_node *node, ir_node *left) {
1063 assert (node->op == op_Quot);
1064 set_irn_n(node, 1, left);
1068 get_Quot_right (ir_node *node) {
1069 assert (node->op == op_Quot);
1070 return get_irn_n(node, 2);
1074 set_Quot_right (ir_node *node, ir_node *right) {
1075 assert (node->op == op_Quot);
1076 set_irn_n(node, 2, right);
1080 get_Quot_mem (ir_node *node) {
1081 assert (node->op == op_Quot);
1082 return get_irn_n(node, 0);
1086 set_Quot_mem (ir_node *node, ir_node *mem) {
1087 assert (node->op == op_Quot);
1088 set_irn_n(node, 0, mem);
1092 get_DivMod_left (ir_node *node) {
1093 assert (node->op == op_DivMod);
1094 return get_irn_n(node, 1);
1098 set_DivMod_left (ir_node *node, ir_node *left) {
1099 assert (node->op == op_DivMod);
1100 set_irn_n(node, 1, left);
1104 get_DivMod_right (ir_node *node) {
1105 assert (node->op == op_DivMod);
1106 return get_irn_n(node, 2);
1110 set_DivMod_right (ir_node *node, ir_node *right) {
1111 assert (node->op == op_DivMod);
1112 set_irn_n(node, 2, right);
1116 get_DivMod_mem (ir_node *node) {
1117 assert (node->op == op_DivMod);
1118 return get_irn_n(node, 0);
1122 set_DivMod_mem (ir_node *node, ir_node *mem) {
1123 assert (node->op == op_DivMod);
1124 set_irn_n(node, 0, mem);
1128 get_Div_left (ir_node *node) {
1129 assert (node->op == op_Div);
1130 return get_irn_n(node, 1);
1134 set_Div_left (ir_node *node, ir_node *left) {
1135 assert (node->op == op_Div);
1136 set_irn_n(node, 1, left);
1140 get_Div_right (ir_node *node) {
1141 assert (node->op == op_Div);
1142 return get_irn_n(node, 2);
1146 set_Div_right (ir_node *node, ir_node *right) {
1147 assert (node->op == op_Div);
1148 set_irn_n(node, 2, right);
1152 get_Div_mem (ir_node *node) {
1153 assert (node->op == op_Div);
1154 return get_irn_n(node, 0);
1158 set_Div_mem (ir_node *node, ir_node *mem) {
1159 assert (node->op == op_Div);
1160 set_irn_n(node, 0, mem);
1164 get_Mod_left (ir_node *node) {
1165 assert (node->op == op_Mod);
1166 return get_irn_n(node, 1);
1170 set_Mod_left (ir_node *node, ir_node *left) {
1171 assert (node->op == op_Mod);
1172 set_irn_n(node, 1, left);
1176 get_Mod_right (ir_node *node) {
1177 assert (node->op == op_Mod);
1178 return get_irn_n(node, 2);
1182 set_Mod_right (ir_node *node, ir_node *right) {
1183 assert (node->op == op_Mod);
1184 set_irn_n(node, 2, right);
1188 get_Mod_mem (ir_node *node) {
1189 assert (node->op == op_Mod);
1190 return get_irn_n(node, 0);
1194 set_Mod_mem (ir_node *node, ir_node *mem) {
1195 assert (node->op == op_Mod);
1196 set_irn_n(node, 0, mem);
1200 get_Abs_op (ir_node *node) {
1201 assert (node->op == op_Abs);
1202 return get_irn_n(node, 0);
1206 set_Abs_op (ir_node *node, ir_node *op) {
1207 assert (node->op == op_Abs);
1208 set_irn_n(node, 0, op);
1212 get_And_left (ir_node *node) {
1213 assert (node->op == op_And);
1214 return get_irn_n(node, 0);
1218 set_And_left (ir_node *node, ir_node *left) {
1219 assert (node->op == op_And);
1220 set_irn_n(node, 0, left);
1224 get_And_right (ir_node *node) {
1225 assert (node->op == op_And);
1226 return get_irn_n(node, 1);
1230 set_And_right (ir_node *node, ir_node *right) {
1231 assert (node->op == op_And);
1232 set_irn_n(node, 1, right);
1236 get_Or_left (ir_node *node) {
1237 assert (node->op == op_Or);
1238 return get_irn_n(node, 0);
1242 set_Or_left (ir_node *node, ir_node *left) {
1243 assert (node->op == op_Or);
1244 set_irn_n(node, 0, left);
1248 get_Or_right (ir_node *node) {
1249 assert (node->op == op_Or);
1250 return get_irn_n(node, 1);
1254 set_Or_right (ir_node *node, ir_node *right) {
1255 assert (node->op == op_Or);
1256 set_irn_n(node, 1, right);
1260 get_Eor_left (ir_node *node) {
1261 assert (node->op == op_Eor);
1262 return get_irn_n(node, 0);
1266 set_Eor_left (ir_node *node, ir_node *left) {
1267 assert (node->op == op_Eor);
1268 set_irn_n(node, 0, left);
1272 get_Eor_right (ir_node *node) {
1273 assert (node->op == op_Eor);
1274 return get_irn_n(node, 1);
1278 set_Eor_right (ir_node *node, ir_node *right) {
1279 assert (node->op == op_Eor);
1280 set_irn_n(node, 1, right);
1285 get_Not_op (ir_node *node) {
1286 assert (node->op == op_Not);
1287 return get_irn_n(node, 0);
1291 set_Not_op (ir_node *node, ir_node *op) {
1292 assert (node->op == op_Not);
1293 set_irn_n(node, 0, op);
1298 get_Shl_left (ir_node *node) {
1299 assert (node->op == op_Shl);
1300 return get_irn_n(node, 0);
1304 set_Shl_left (ir_node *node, ir_node *left) {
1305 assert (node->op == op_Shl);
1306 set_irn_n(node, 0, left);
1310 get_Shl_right (ir_node *node) {
1311 assert (node->op == op_Shl);
1312 return get_irn_n(node, 1);
1316 set_Shl_right (ir_node *node, ir_node *right) {
1317 assert (node->op == op_Shl);
1318 set_irn_n(node, 1, right);
1322 get_Shr_left (ir_node *node) {
1323 assert (node->op == op_Shr);
1324 return get_irn_n(node, 0);
1328 set_Shr_left (ir_node *node, ir_node *left) {
1329 assert (node->op == op_Shr);
1330 set_irn_n(node, 0, left);
1334 get_Shr_right (ir_node *node) {
1335 assert (node->op == op_Shr);
1336 return get_irn_n(node, 1);
1340 set_Shr_right (ir_node *node, ir_node *right) {
1341 assert (node->op == op_Shr);
1342 set_irn_n(node, 1, right);
1346 get_Shrs_left (ir_node *node) {
1347 assert (node->op == op_Shrs);
1348 return get_irn_n(node, 0);
1352 set_Shrs_left (ir_node *node, ir_node *left) {
1353 assert (node->op == op_Shrs);
1354 set_irn_n(node, 0, left);
1358 get_Shrs_right (ir_node *node) {
1359 assert (node->op == op_Shrs);
1360 return get_irn_n(node, 1);
1364 set_Shrs_right (ir_node *node, ir_node *right) {
1365 assert (node->op == op_Shrs);
1366 set_irn_n(node, 1, right);
1370 get_Rot_left (ir_node *node) {
1371 assert (node->op == op_Rot);
1372 return get_irn_n(node, 0);
1376 set_Rot_left (ir_node *node, ir_node *left) {
1377 assert (node->op == op_Rot);
1378 set_irn_n(node, 0, left);
1382 get_Rot_right (ir_node *node) {
1383 assert (node->op == op_Rot);
1384 return get_irn_n(node, 1);
1388 set_Rot_right (ir_node *node, ir_node *right) {
1389 assert (node->op == op_Rot);
1390 set_irn_n(node, 1, right);
1394 get_Cmp_left (ir_node *node) {
1395 assert (node->op == op_Cmp);
1396 return get_irn_n(node, 0);
1400 set_Cmp_left (ir_node *node, ir_node *left) {
1401 assert (node->op == op_Cmp);
1402 set_irn_n(node, 0, left);
1406 get_Cmp_right (ir_node *node) {
1407 assert (node->op == op_Cmp);
1408 return get_irn_n(node, 1);
1412 set_Cmp_right (ir_node *node, ir_node *right) {
1413 assert (node->op == op_Cmp);
1414 set_irn_n(node, 1, right);
1418 get_Conv_op (ir_node *node) {
1419 assert (node->op == op_Conv);
1420 return get_irn_n(node, 0);
1424 set_Conv_op (ir_node *node, ir_node *op) {
1425 assert (node->op == op_Conv);
1426 set_irn_n(node, 0, op);
1430 get_Phi_preds_arr (ir_node *node) {
1431 assert (node->op == op_Phi);
1432 return (ir_node **)&(get_irn_in(node)[1]);
1436 get_Phi_n_preds (ir_node *node) {
1437 assert (node->op == op_Phi);
1438 return (get_irn_arity(node));
1442 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1443 assert (node->op == op_Phi);
1448 get_Phi_pred (ir_node *node, int pos) {
1449 assert (node->op == op_Phi);
1450 return get_irn_n(node, pos);
1454 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1455 assert (node->op == op_Phi);
1456 set_irn_n(node, pos, pred);
1460 get_Load_mem (ir_node *node) {
1461 assert (node->op == op_Load);
1462 return get_irn_n(node, 0);
1466 set_Load_mem (ir_node *node, ir_node *mem) {
1467 assert (node->op == op_Load);
1468 set_irn_n(node, 0, mem);
1472 get_Load_ptr (ir_node *node) {
1473 assert (node->op == op_Load);
1474 return get_irn_n(node, 1);
1478 set_Load_ptr (ir_node *node, ir_node *ptr) {
1479 assert (node->op == op_Load);
1480 set_irn_n(node, 1, ptr);
1485 get_Store_mem (ir_node *node) {
1486 assert (node->op == op_Store);
1487 return get_irn_n(node, 0);
1491 set_Store_mem (ir_node *node, ir_node *mem) {
1492 assert (node->op == op_Store);
1493 set_irn_n(node, 0, mem);
1497 get_Store_ptr (ir_node *node) {
1498 assert (node->op == op_Store);
1499 return get_irn_n(node, 1);
1503 set_Store_ptr (ir_node *node, ir_node *ptr) {
1504 assert (node->op == op_Store);
1505 set_irn_n(node, 1, ptr);
1509 get_Store_value (ir_node *node) {
1510 assert (node->op == op_Store);
1511 return get_irn_n(node, 2);
1515 set_Store_value (ir_node *node, ir_node *value) {
1516 assert (node->op == op_Store);
1517 set_irn_n(node, 2, value);
1521 get_Alloc_mem (ir_node *node) {
1522 assert (node->op == op_Alloc);
1523 return get_irn_n(node, 0);
1527 set_Alloc_mem (ir_node *node, ir_node *mem) {
1528 assert (node->op == op_Alloc);
1529 set_irn_n(node, 0, mem);
1533 get_Alloc_size (ir_node *node) {
1534 assert (node->op == op_Alloc);
1535 return get_irn_n(node, 1);
1539 set_Alloc_size (ir_node *node, ir_node *size) {
1540 assert (node->op == op_Alloc);
1541 set_irn_n(node, 1, size);
1545 get_Alloc_type (ir_node *node) {
1546 assert (node->op == op_Alloc);
1547 return node->attr.a.type;
1551 set_Alloc_type (ir_node *node, type *type) {
1552 assert (node->op == op_Alloc);
1553 node->attr.a.type = type;
1557 get_Alloc_where (ir_node *node) {
1558 assert (node->op == op_Alloc);
1559 return node->attr.a.where;
1563 set_Alloc_where (ir_node *node, where_alloc where) {
1564 assert (node->op == op_Alloc);
1565 node->attr.a.where = where;
1570 get_Free_mem (ir_node *node) {
1571 assert (node->op == op_Free);
1572 return get_irn_n(node, 0);
1576 set_Free_mem (ir_node *node, ir_node *mem) {
1577 assert (node->op == op_Free);
1578 set_irn_n(node, 0, mem);
1582 get_Free_ptr (ir_node *node) {
1583 assert (node->op == op_Free);
1584 return get_irn_n(node, 1);
1588 set_Free_ptr (ir_node *node, ir_node *ptr) {
1589 assert (node->op == op_Free);
1590 set_irn_n(node, 1, ptr);
1594 get_Free_size (ir_node *node) {
1595 assert (node->op == op_Free);
1596 return get_irn_n(node, 2);
1600 set_Free_size (ir_node *node, ir_node *size) {
1601 assert (node->op == op_Free);
1602 set_irn_n(node, 2, size);
1606 get_Free_type (ir_node *node) {
1607 assert (node->op == op_Free);
1608 return node->attr.f;
1612 set_Free_type (ir_node *node, type *type) {
1613 assert (node->op == op_Free);
1614 node->attr.f = type;
1618 get_Sync_preds_arr (ir_node *node) {
1619 assert (node->op == op_Sync);
1620 return (ir_node **)&(get_irn_in(node)[1]);
1624 get_Sync_n_preds (ir_node *node) {
1625 assert (node->op == op_Sync);
1626 return (get_irn_arity(node));
1631 set_Sync_n_preds (ir_node *node, int n_preds) {
1632 assert (node->op == op_Sync);
1637 get_Sync_pred (ir_node *node, int pos) {
1638 assert (node->op == op_Sync);
1639 return get_irn_n(node, pos);
1643 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1644 assert (node->op == op_Sync);
1645 set_irn_n(node, pos, pred);
1649 get_Proj_pred (ir_node *node) {
1650 assert (node->op == op_Proj);
1651 return get_irn_n(node, 0);
1655 set_Proj_pred (ir_node *node, ir_node *pred) {
1656 assert (node->op == op_Proj);
1657 set_irn_n(node, 0, pred);
1661 get_Proj_proj (ir_node *node) {
1662 assert (node->op == op_Proj);
1663 return node->attr.proj;
1667 set_Proj_proj (ir_node *node, long proj) {
1668 assert (node->op == op_Proj);
1669 node->attr.proj = proj;
1673 get_Tuple_preds_arr (ir_node *node) {
1674 assert (node->op == op_Tuple);
1675 return (ir_node **)&(get_irn_in(node)[1]);
1679 get_Tuple_n_preds (ir_node *node) {
1680 assert (node->op == op_Tuple);
1681 return (get_irn_arity(node));
1686 set_Tuple_n_preds (ir_node *node, int n_preds) {
1687 assert (node->op == op_Tuple);
1692 get_Tuple_pred (ir_node *node, int pos) {
1693 assert (node->op == op_Tuple);
1694 return get_irn_n(node, pos);
1698 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1699 assert (node->op == op_Tuple);
1700 set_irn_n(node, pos, pred);
1704 get_Id_pred (ir_node *node) {
1705 assert (node->op == op_Id);
1706 return get_irn_n(node, 0);
1710 set_Id_pred (ir_node *node, ir_node *pred) {
1711 assert (node->op == op_Id);
1712 set_irn_n(node, 0, pred);
1715 /******************************************************************/
1716 /* Auxiliary routines */
1717 /******************************************************************/
1720 skip_Proj (ir_node *node) {
1721 /* don't assert node !!! */
1722 if (node && (node->op == op_Proj)) {
1723 return get_Proj_pred(node);
1730 skip_nop (ir_node *node) {
1731 /* don't assert node !!! */
1733 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1734 /* Don't use get_Id_pred: We get into an endless loop for
1735 self-referencing Ids. */
1736 assert (get_irn_arity (node) > 0);
1737 return node->in[0+1];
1744 is_Bad (ir_node *node) {
1746 if ((node) && get_irn_opcode(node) == iro_Bad)
1752 is_no_Block (ir_node *node) {
1754 return (get_irn_opcode(node) != iro_Block);
1757 /* Returns true if the operation manipulates control flow. */
1759 is_cfop(ir_node *node) {
1760 return ( (get_irn_opcode(node) == iro_Start)
1761 || (get_irn_opcode(node) == iro_Jmp)
1762 || (get_irn_opcode(node) == iro_Cond)
1763 || (get_irn_opcode(node) == iro_Return)
1764 || (get_irn_opcode(node) == iro_Raise)
1765 || (get_irn_opcode(node) == iro_Bad));
1768 /* Returns true if the operation can change the control flow because
1771 is_fragile_op(ir_node *node) {
1772 return ( (get_irn_opcode(node) == iro_Call)
1773 || (get_irn_opcode(node) == iro_Quot)
1774 || (get_irn_opcode(node) == iro_DivMod)
1775 || (get_irn_opcode(node) == iro_Div)
1776 || (get_irn_opcode(node) == iro_Mod)
1777 || (get_irn_opcode(node) == iro_Load)
1778 || (get_irn_opcode(node) == iro_Store)
1779 || (get_irn_opcode(node) == iro_Alloc)
1780 || (get_irn_opcode(node) == iro_Bad));