1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
10 #include "irgraph_t.h"
19 /* some constants fixing the positions of nodes predecessors
21 #define CALL_PARAM_OFFSET 2
22 #define SEL_INDEX_OFFSET 2
23 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
25 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
26 "Gt", "Ge", "Lg", "Leg", "Uo",
27 "Ue", "Ul", "Ule", "Ug", "Uge",
30 inline char *get_pnc_string(int pnc) {
31 return pnc_name_arr[pnc];
36 get_negated_pnc(int pnc) {
38 case False: return True; break;
39 case Eq: return Ne; break;
40 case Lt: return Uge; break;
41 case Le: return Ug; break;
42 case Gt: return Ule; break;
43 case Ge: return Ul; break;
44 case Lg: return Ue; break;
45 case Leg: return Uo; break;
46 case Uo: return Leg; break;
47 case Ue: return Lg; break;
48 case Ul: return Ge; break;
49 case Ule: return Gt; break;
50 case Ug: return Le; break;
51 case Uge: return Lt; break;
52 case Ne: return Eq; break;
53 case True: return False; break;
55 return 99; /* to shut up gcc */
58 static char *pns_name_arr [] = {"initial_exec", "global_store",
59 "frame_base", "globals", "args"};
61 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
68 /* irnode constructor */
69 /* create a new irnode in irg, with an op, mode, arity and */
70 /* some incoming irnodes */
71 /* this constructor is used in every specified irnode constructor */
73 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
74 int arity, ir_node **in)
77 int node_size = offsetof (ir_node, attr) + op->attr_size;
79 res = (ir_node *) obstack_alloc (irg->obst, node_size);
81 res->kind = k_ir_node;
87 res->in = NEW_ARR_F (ir_node *, 1);
89 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
90 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
95 res->node_nr = get_irp_new_node_nr();
101 /* Copies all attributes stored in the old node to the new node.
102 Assumes both have the same opcode and sufficient size. */
104 copy_attrs (ir_node *old, ir_node *new) {
105 assert (get_irn_opcode(old) == get_irn_opcode(new));
106 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
109 /* IR-Nodes with attributes */
111 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
114 ir_node *np = XP_GETARG (ir_node *, 0);
117 XPS ("<null ir_node>");
121 XPF1 ("%I", get_irn_opident(np));
123 switch (get_irn_opcode (np)) { /* node label */
125 XPF1 ("%I", get_irn_mode(np)->name);
127 XPF1 ("%v", get_irn_const_attr);
130 if (get_irn_modecode (np) == irm_b) {
132 XP (pnc_name_arr[get_irn_proj_attr(np)]);
133 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
135 XP (pns_name_arr[get_irn_proj_attr(np)]);
137 XPF1 ("%I", get_irn_mode(np)->name);
139 XPF1 ("%d", get_irn_proj_attr(np));
143 XPF1 ("%I", get_irn_mode(np)->name);
145 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
146 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
148 case iro_Start: /* don't dump mode of these */
157 XPF1 ("%I", get_irn_mode(np)->name);
164 /** getting some parameters from ir_nodes **/
166 /* returns the number of predecessors without the block predecessor. */
168 get_irn_arity (ir_node *node)
171 return (ARR_LEN((node)->in)-1);
174 /* Returns the array with ins. This array is shifted with respect to the
175 array accessed by get_irn_n: The block operand is at position 0 not -1.
176 (@@@ This should be changed.)
177 The order of the predecessors in this array is not guaranteed, except that
178 lists of operands as predecessors of Block or arguments of a Call are
181 get_irn_in (ir_node *node)
187 /* to iterate through the predecessors without touching the array */
188 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
189 to iterate includind the Block predecessor iterate from i = -1 to
191 If it is a block, the entry -1 is NULL. */
193 get_irn_n (ir_node *node, int n)
196 assert (get_irn_arity (node) > n);
197 return skip_nop(node->in[n+1]);
201 set_irn_n (ir_node *node, int n, ir_node *in)
204 assert (get_irn_arity (node) > n);
209 get_irn_mode (ir_node *node)
216 get_irn_modecode (ir_node *node)
219 return node->mode->code;
224 get_irn_modeident (ir_node *node)
227 return node->mode->name;
231 get_irn_op (ir_node *node)
237 /* should be private to the library: */
239 set_irn_op (ir_node *node, ir_op *op)
246 get_irn_opcode (ir_node *node)
249 return node->op->code;
253 get_irn_opname (ir_node *node)
256 return id_to_str(node->op->name);
260 get_irn_opident (ir_node *node)
263 return node->op->name;
267 get_irn_visited (ir_node *node)
270 return node->visited;
274 set_irn_visited (ir_node *node, unsigned long visited)
277 node->visited = visited;
280 set_irn_link (ir_node *node, ir_node *link) {
286 get_irn_link (ir_node *node) {
292 /* Outputs a unique number for this node */
294 get_irn_node_nr(ir_node *node) {
296 return node->node_nr;
301 get_irn_const_attr (ir_node *node)
303 assert (node->op == op_Const);
304 return node->attr.con;
308 get_irn_proj_attr (ir_node *node)
310 assert (node->op == op_Proj);
311 return node->attr.proj;
315 get_irn_alloc_attr (ir_node *node)
317 assert (node->op == op_Alloc);
322 get_irn_free_attr (ir_node *node)
324 assert (node->op == op_Free);
329 get_irn_symconst_attr (ir_node *node)
331 assert (node->op == op_SymConst);
336 get_irn_call_attr (ir_node *node)
338 assert (node->op == op_Call);
339 return node->attr.call;
343 get_irn_sel_attr (ir_node *node)
345 assert (node->op == op_Sel);
350 get_irn_phi_attr (ir_node *node)
352 assert (node->op == op_Phi);
353 return node->attr.phi0_pos;
357 get_irn_block_attr (ir_node *node)
359 assert (node->op == op_Block);
360 return node->attr.block;
363 /** manipulate fields of individual nodes **/
365 /* this works for all except Block */
367 get_nodes_Block (ir_node *node) {
368 assert (!(node->op == op_Block));
369 return get_irn_n(node, -1);
373 set_nodes_Block (ir_node *node, ir_node *block) {
374 assert (!(node->op == op_Block));
375 set_irn_n(node, -1, block);
378 /* Returns an array with the predecessors of the Block. Depending on
379 the implementation of the graph datastructure this can be a copy of
380 the internal representation of predecessors as well as the internal
381 array itself. Therefore writing to this array might obstruct the ir. */
383 get_Block_cfgpred_arr (ir_node *node)
385 assert ((node->op == op_Block));
386 return (ir_node **)&(get_irn_in(node)[1]);
391 get_Block_n_cfgpreds (ir_node *node) {
392 assert ((node->op == op_Block));
393 return (get_irn_arity(node));
398 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
399 assert ((node->op == op_Block));
404 get_Block_cfgpred (ir_node *node, int pos) {
405 assert (node->op == op_Block);
406 return get_irn_n(node, pos);
410 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
411 assert (node->op == op_Block);
412 set_irn_n(node, pos, pred);
416 get_Block_matured (ir_node *node) {
417 assert (node->op == op_Block);
418 return node->attr.block.matured;
422 set_Block_matured (ir_node *node, bool matured) {
423 assert (node->op == op_Block);
424 node->attr.block.matured = matured;
427 get_Block_block_visited (ir_node *node) {
428 assert (node->op == op_Block);
429 return node->attr.block.block_visited;
433 set_Block_block_visited (ir_node *node, unsigned long visit) {
434 assert (node->op == op_Block);
435 node->attr.block.block_visited = visit;
439 get_Block_graph_arr (ir_node *node, int pos) {
440 assert (node->op == op_Block);
441 return node->attr.block.graph_arr[pos+1];
445 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
446 assert (node->op == op_Block);
447 node->attr.block.graph_arr[pos+1] = value;
451 get_Cond_selector (ir_node *node) {
452 assert (node->op == op_Cond);
453 return get_irn_n(node, 0);
457 set_Cond_selector (ir_node *node, ir_node *selector) {
458 assert (node->op == op_Cond);
459 set_irn_n(node, 0, selector);
463 get_Return_mem (ir_node *node) {
464 assert (node->op == op_Return);
465 return get_irn_n(node, 0);
469 set_Return_mem (ir_node *node, ir_node *mem) {
470 assert (node->op == op_Return);
471 set_irn_n(node, 0, mem);
475 get_Return_res_arr (ir_node *node)
477 assert ((node->op == op_Return));
478 if (get_Return_n_res(node) > 0)
479 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
485 get_Return_n_res (ir_node *node) {
486 assert (node->op == op_Return);
487 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
492 set_Return_n_res (ir_node *node, int results) {
493 assert (node->op == op_Return);
498 get_Return_res (ir_node *node, int pos) {
499 assert (node->op == op_Return);
500 assert (get_Return_n_res(node) > pos);
501 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
505 set_Return_res (ir_node *node, int pos, ir_node *res){
506 assert (node->op == op_Return);
507 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
511 get_Raise_mem (ir_node *node) {
512 assert (node->op == op_Return);
513 return get_irn_n(node, 0);
517 set_Raise_mem (ir_node *node, ir_node *mem) {
518 assert (node->op == op_Raise);
519 set_irn_n(node, 0, mem);
523 get_Raise_exo_ptr (ir_node *node) {
524 assert (node->op == op_Raise);
525 return get_irn_n(node, 1);
529 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
530 assert (node->op == op_Raise);
531 set_irn_n(node, 1, exo_ptr);
534 inline tarval *get_Const_tarval (ir_node *node) {
535 assert (node->op == op_Const);
536 return get_irn_const_attr(node);
540 set_Const_tarval (ir_node *node, tarval *con) {
541 assert (node->op == op_Const);
542 node->attr.con = con;
546 get_SymConst_kind (ir_node *node) {
547 assert (node->op == op_SymConst);
548 return node->attr.i.num;
552 set_SymConst_kind (ir_node *node, symconst_kind num) {
553 assert (node->op == op_SymConst);
554 node->attr.i.num = num;
558 get_SymConst_type (ir_node *node) {
559 assert ( (node->op == op_SymConst)
560 && ( get_SymConst_kind(node) == type_tag
561 || get_SymConst_kind(node) == size));
562 return node->attr.i.tori.typ;
566 set_SymConst_type (ir_node *node, type *type) {
567 assert ( (node->op == op_SymConst)
568 && ( get_SymConst_kind(node) == type_tag
569 || get_SymConst_kind(node) == size));
570 node->attr.i.tori.typ = type;
574 get_SymConst_ptrinfo (ir_node *node) {
575 assert ( (node->op == op_SymConst)
576 && (get_SymConst_kind(node) == linkage_ptr_info));
577 return node->attr.i.tori.ptrinfo;
581 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
582 assert ( (node->op == op_SymConst)
583 && (get_SymConst_kind(node) == linkage_ptr_info));
584 node->attr.i.tori.ptrinfo = ptrinfo;
588 get_SymConst_type_or_id (ir_node *node) {
589 assert (node->op == op_SymConst);
590 return &(node->attr.i.tori);
594 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
595 assert (node->op == op_SymConst);
596 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
600 get_Sel_mem (ir_node *node) {
601 assert (node->op == op_Sel);
602 return get_irn_n(node, 0);
606 set_Sel_mem (ir_node *node, ir_node *mem) {
607 assert (node->op == op_Sel);
608 set_irn_n(node, 0, mem);
612 get_Sel_ptr (ir_node *node) {
613 assert (node->op == op_Sel);
614 return get_irn_n(node, 1);
618 set_Sel_ptr (ir_node *node, ir_node *ptr) {
619 assert (node->op == op_Sel);
620 set_irn_n(node, 1, ptr);
624 get_Sel_index_arr (ir_node *node)
626 assert ((node->op == op_Sel));
627 if (get_Sel_n_index(node) > 0)
628 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
634 get_Sel_n_index (ir_node *node) {
635 assert (node->op == op_Sel);
636 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
641 set_Sel_n_index (ir_node *node, int n_index) {
642 assert (node->op == op_Sel);
647 get_Sel_index (ir_node *node, int pos) {
648 assert (node->op == op_Sel);
649 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
653 set_Sel_index (ir_node *node, int pos, ir_node *index) {
654 assert (node->op == op_Sel);
655 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
659 get_Sel_entity (ir_node *node) {
660 assert (node->op == op_Sel);
661 return node->attr.s.ent;
665 set_Sel_entity (ir_node *node, entity *ent) {
666 assert (node->op == op_Sel);
667 node->attr.s.ent = ent;
671 get_Sel_linkage_type (ir_node *node) {
672 assert (node->op == op_Sel);
673 return node->attr.s.ltyp;
677 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
678 assert (node->op == op_Sel);
679 node->attr.s.ltyp = lt;
683 get_Call_mem (ir_node *node) {
684 assert (node->op == op_Call);
685 return get_irn_n(node, 0);
689 set_Call_mem (ir_node *node, ir_node *mem) {
690 assert (node->op == op_Call);
691 set_irn_n(node, 0, mem);
695 get_Call_ptr (ir_node *node) {
696 assert (node->op == op_Call);
697 return get_irn_n(node, 1);
701 set_Call_ptr (ir_node *node, ir_node *ptr) {
702 assert (node->op == op_Call);
703 set_irn_n(node, 1, ptr);
707 get_Call_param_arr (ir_node *node) {
708 assert (node->op == op_Call);
709 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
713 get_Call_n_params (ir_node *node) {
714 assert (node->op == op_Call);
715 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
719 get_Call_arity (ir_node *node) {
720 return get_Call_n_params(node);
724 set_Call_arity (ir_node *node, ir_node *arity) {
725 assert (node->op == op_Call);
730 get_Call_param (ir_node *node, int pos) {
731 assert (node->op == op_Call);
732 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
736 set_Call_param (ir_node *node, int pos, ir_node *param) {
737 assert (node->op == op_Call);
738 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
742 get_Call_type (ir_node *node) {
743 assert (node->op == op_Call);
744 return node->attr.call;
748 set_Call_type (ir_node *node, type_method *type) {
749 assert (node->op == op_Call);
750 node->attr.call = type;
753 /* For unary and binary arithmetic operations the access to the
754 operands can be factored out. Left is the first, right the
755 second arithmetic value as listed in tech report 0999-33.
756 unops are: Minus, Abs, Not, Conv
757 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
758 Shr, Shrs, Rotate, Cmp */
761 is_unop (ir_node *node) {
762 return ( node->op == op_Minus ||
763 node->op == op_Abs ||
764 node->op == op_Not ||
765 node->op == op_Conv );
769 get_unop_op (ir_node *node) {
770 assert ( node->op == op_Minus ||
771 node->op == op_Abs ||
772 node->op == op_Not ||
773 node->op == op_Conv );
774 switch (get_irn_opcode (node)) {
775 case iro_Minus: return get_Minus_op(node); break;
776 case iro_Abs: return get_Abs_op(node); break;
777 case iro_Not: return get_Not_op(node); break;
778 case iro_Conv: return get_Conv_op(node); break;
779 default: return NULL;
784 set_unop_op (ir_node *node, ir_node *op) {
785 assert (node->op == op_Minus ||
786 node->op == op_Abs ||
787 node->op == op_Not ||
788 node->op == op_Conv );
789 switch (get_irn_opcode (node)) {
790 case iro_Minus: set_Minus_op(node, op); break;
791 case iro_Abs: set_Abs_op(node, op); break;
792 case iro_Not: set_Not_op(node, op); break;
793 case iro_Conv: set_Conv_op(node, op); break;
800 is_binop (ir_node *node) {
801 return (node->op == op_Add ||
802 node->op == op_Sub ||
803 node->op == op_Mul ||
804 node->op == op_Quot ||
805 node->op == op_DivMod ||
806 node->op == op_Div ||
807 node->op == op_Mod ||
808 node->op == op_And ||
810 node->op == op_Eor ||
811 node->op == op_Shl ||
812 node->op == op_Shr ||
813 node->op == op_Shrs ||
814 node->op == op_Rot ||
815 node->op == op_Cmp );
819 get_binop_left (ir_node *node) {
820 assert (node->op == op_Add ||
821 node->op == op_Sub ||
822 node->op == op_Mul ||
823 node->op == op_Quot ||
824 node->op == op_DivMod ||
825 node->op == op_Div ||
826 node->op == op_Mod ||
827 node->op == op_And ||
829 node->op == op_Eor ||
830 node->op == op_Shl ||
831 node->op == op_Shr ||
832 node->op == op_Shrs ||
833 node->op == op_Rot ||
834 node->op == op_Cmp );
836 switch (get_irn_opcode (node)) {
837 case iro_Add : return get_Add_left(node); break;
838 case iro_Sub : return get_Sub_left(node); break;
839 case iro_Mul : return get_Mul_left(node); break;
840 case iro_Quot : return get_Quot_left(node); break;
841 case iro_DivMod: return get_DivMod_left(node); break;
842 case iro_Div : return get_Div_left(node); break;
843 case iro_Mod : return get_Mod_left(node); break;
844 case iro_And : return get_And_left(node); break;
845 case iro_Or : return get_Or_left(node); break;
846 case iro_Eor : return get_Eor_left(node); break;
847 case iro_Shl : return get_Shl_left(node); break;
848 case iro_Shr : return get_Shr_left(node); break;
849 case iro_Shrs : return get_Shrs_left(node); break;
850 case iro_Rot : return get_Rot_left(node); break;
851 case iro_Cmp : return get_Cmp_left(node); break;
852 default: return NULL;
857 set_binop_left (ir_node *node, ir_node *left) {
858 assert (node->op == op_Add ||
859 node->op == op_Sub ||
860 node->op == op_Mul ||
861 node->op == op_Quot ||
862 node->op == op_DivMod ||
863 node->op == op_Div ||
864 node->op == op_Mod ||
865 node->op == op_And ||
867 node->op == op_Eor ||
868 node->op == op_Shl ||
869 node->op == op_Shr ||
870 node->op == op_Shrs ||
871 node->op == op_Rot ||
872 node->op == op_Cmp );
874 switch (get_irn_opcode (node)) {
875 case iro_Add : set_Add_left(node, left); break;
876 case iro_Sub : set_Sub_left(node, left); break;
877 case iro_Mul : set_Mul_left(node, left); break;
878 case iro_Quot : set_Quot_left(node, left); break;
879 case iro_DivMod: set_DivMod_left(node, left); break;
880 case iro_Div : set_Div_left(node, left); break;
881 case iro_Mod : set_Mod_left(node, left); break;
882 case iro_And : set_And_left(node, left); break;
883 case iro_Or : set_Or_left(node, left); break;
884 case iro_Eor : set_Eor_left(node, left); break;
885 case iro_Shl : set_Shl_left(node, left); break;
886 case iro_Shr : set_Shr_left(node, left); break;
887 case iro_Shrs : set_Shrs_left(node, left); break;
888 case iro_Rot : set_Rot_left(node, left); break;
889 case iro_Cmp : set_Cmp_left(node, left); break;
895 get_binop_right (ir_node *node) {
896 assert (node->op == op_Add ||
897 node->op == op_Sub ||
898 node->op == op_Mul ||
899 node->op == op_Quot ||
900 node->op == op_DivMod ||
901 node->op == op_Div ||
902 node->op == op_Mod ||
903 node->op == op_And ||
905 node->op == op_Eor ||
906 node->op == op_Shl ||
907 node->op == op_Shr ||
908 node->op == op_Shrs ||
909 node->op == op_Rot ||
910 node->op == op_Cmp );
912 switch (get_irn_opcode (node)) {
913 case iro_Add : return get_Add_right(node); break;
914 case iro_Sub : return get_Sub_right(node); break;
915 case iro_Mul : return get_Mul_right(node); break;
916 case iro_Quot : return get_Quot_right(node); break;
917 case iro_DivMod: return get_DivMod_right(node); break;
918 case iro_Div : return get_Div_right(node); break;
919 case iro_Mod : return get_Mod_right(node); break;
920 case iro_And : return get_And_right(node); break;
921 case iro_Or : return get_Or_right(node); break;
922 case iro_Eor : return get_Eor_right(node); break;
923 case iro_Shl : return get_Shl_right(node); break;
924 case iro_Shr : return get_Shr_right(node); break;
925 case iro_Shrs : return get_Shrs_right(node); break;
926 case iro_Rot : return get_Rot_right(node); break;
927 case iro_Cmp : return get_Cmp_right(node); break;
928 default: return NULL;
933 set_binop_right (ir_node *node, ir_node *right) {
934 assert (node->op == op_Add ||
935 node->op == op_Sub ||
936 node->op == op_Mul ||
937 node->op == op_Quot ||
938 node->op == op_DivMod ||
939 node->op == op_Div ||
940 node->op == op_Mod ||
941 node->op == op_And ||
943 node->op == op_Eor ||
944 node->op == op_Shl ||
945 node->op == op_Shr ||
946 node->op == op_Shrs ||
947 node->op == op_Rot ||
948 node->op == op_Cmp );
950 switch (get_irn_opcode (node)) {
951 case iro_Add : set_Add_right(node, right); break;
952 case iro_Sub : set_Sub_right(node, right); break;
953 case iro_Mul : set_Mul_right(node, right); break;
954 case iro_Quot : set_Quot_right(node, right); break;
955 case iro_DivMod: set_DivMod_right(node, right); break;
956 case iro_Div : set_Div_right(node, right); break;
957 case iro_Mod : set_Mod_right(node, right); break;
958 case iro_And : set_And_right(node, right); break;
959 case iro_Or : set_Or_right(node, right); break;
960 case iro_Eor : set_Eor_right(node, right); break;
961 case iro_Shl : set_Shl_right(node, right); break;
962 case iro_Shr : set_Shr_right(node, right); break;
963 case iro_Shrs : set_Shrs_right(node, right); break;
964 case iro_Rot : set_Rot_right(node, right); break;
965 case iro_Cmp : set_Cmp_right(node, right); break;
971 get_Add_left (ir_node *node) {
972 assert (node->op == op_Add);
973 return get_irn_n(node, 0);
977 set_Add_left (ir_node *node, ir_node *left) {
978 assert (node->op == op_Add);
979 set_irn_n(node, 0, left);
983 get_Add_right (ir_node *node) {
984 assert (node->op == op_Add);
985 return get_irn_n(node, 1);
989 set_Add_right (ir_node *node, ir_node *right) {
990 assert (node->op == op_Add);
991 set_irn_n(node, 1, right);
995 get_Sub_left (ir_node *node) {
996 assert (node->op == op_Sub);
997 return get_irn_n(node, 0);
1001 set_Sub_left (ir_node *node, ir_node *left) {
1002 assert (node->op == op_Sub);
1003 set_irn_n(node, 0, left);
1007 get_Sub_right (ir_node *node) {
1008 assert (node->op == op_Sub);
1009 return get_irn_n(node, 1);
1013 set_Sub_right (ir_node *node, ir_node *right) {
1014 assert (node->op == op_Sub);
1015 set_irn_n(node, 1, right);
1020 get_Minus_op (ir_node *node) {
1021 assert (node->op == op_Minus);
1022 return get_irn_n(node, 0);
1026 set_Minus_op (ir_node *node, ir_node *op) {
1027 assert (node->op == op_Minus);
1028 set_irn_n(node, 0, op);
1033 get_Mul_left (ir_node *node) {
1034 assert (node->op == op_Mul);
1035 return get_irn_n(node, 0);
1039 set_Mul_left (ir_node *node, ir_node *left) {
1040 assert (node->op == op_Mul);
1041 set_irn_n(node, 0, left);
1045 get_Mul_right (ir_node *node) {
1046 assert (node->op == op_Mul);
1047 return get_irn_n(node, 1);
1051 set_Mul_right (ir_node *node, ir_node *right) {
1052 assert (node->op == op_Mul);
1053 set_irn_n(node, 1, right);
1057 get_Quot_left (ir_node *node) {
1058 assert (node->op == op_Quot);
1059 return get_irn_n(node, 1);
1063 set_Quot_left (ir_node *node, ir_node *left) {
1064 assert (node->op == op_Quot);
1065 set_irn_n(node, 1, left);
1069 get_Quot_right (ir_node *node) {
1070 assert (node->op == op_Quot);
1071 return get_irn_n(node, 2);
1075 set_Quot_right (ir_node *node, ir_node *right) {
1076 assert (node->op == op_Quot);
1077 set_irn_n(node, 2, right);
1081 get_Quot_mem (ir_node *node) {
1082 assert (node->op == op_Quot);
1083 return get_irn_n(node, 0);
1087 set_Quot_mem (ir_node *node, ir_node *mem) {
1088 assert (node->op == op_Quot);
1089 set_irn_n(node, 0, mem);
1093 get_DivMod_left (ir_node *node) {
1094 assert (node->op == op_DivMod);
1095 return get_irn_n(node, 1);
1099 set_DivMod_left (ir_node *node, ir_node *left) {
1100 assert (node->op == op_DivMod);
1101 set_irn_n(node, 1, left);
1105 get_DivMod_right (ir_node *node) {
1106 assert (node->op == op_DivMod);
1107 return get_irn_n(node, 2);
1111 set_DivMod_right (ir_node *node, ir_node *right) {
1112 assert (node->op == op_DivMod);
1113 set_irn_n(node, 2, right);
1117 get_DivMod_mem (ir_node *node) {
1118 assert (node->op == op_DivMod);
1119 return get_irn_n(node, 0);
1123 set_DivMod_mem (ir_node *node, ir_node *mem) {
1124 assert (node->op == op_DivMod);
1125 set_irn_n(node, 0, mem);
1129 get_Div_left (ir_node *node) {
1130 assert (node->op == op_Div);
1131 return get_irn_n(node, 1);
1135 set_Div_left (ir_node *node, ir_node *left) {
1136 assert (node->op == op_Div);
1137 set_irn_n(node, 1, left);
1141 get_Div_right (ir_node *node) {
1142 assert (node->op == op_Div);
1143 return get_irn_n(node, 2);
1147 set_Div_right (ir_node *node, ir_node *right) {
1148 assert (node->op == op_Div);
1149 set_irn_n(node, 2, right);
1153 get_Div_mem (ir_node *node) {
1154 assert (node->op == op_Div);
1155 return get_irn_n(node, 0);
1159 set_Div_mem (ir_node *node, ir_node *mem) {
1160 assert (node->op == op_Div);
1161 set_irn_n(node, 0, mem);
1165 get_Mod_left (ir_node *node) {
1166 assert (node->op == op_Mod);
1167 return get_irn_n(node, 1);
1171 set_Mod_left (ir_node *node, ir_node *left) {
1172 assert (node->op == op_Mod);
1173 set_irn_n(node, 1, left);
1177 get_Mod_right (ir_node *node) {
1178 assert (node->op == op_Mod);
1179 return get_irn_n(node, 2);
1183 set_Mod_right (ir_node *node, ir_node *right) {
1184 assert (node->op == op_Mod);
1185 set_irn_n(node, 2, right);
1189 get_Mod_mem (ir_node *node) {
1190 assert (node->op == op_Mod);
1191 return get_irn_n(node, 0);
1195 set_Mod_mem (ir_node *node, ir_node *mem) {
1196 assert (node->op == op_Mod);
1197 set_irn_n(node, 0, mem);
1201 get_Abs_op (ir_node *node) {
1202 assert (node->op == op_Abs);
1203 return get_irn_n(node, 0);
1207 set_Abs_op (ir_node *node, ir_node *op) {
1208 assert (node->op == op_Abs);
1209 set_irn_n(node, 0, op);
1213 get_And_left (ir_node *node) {
1214 assert (node->op == op_And);
1215 return get_irn_n(node, 0);
1219 set_And_left (ir_node *node, ir_node *left) {
1220 assert (node->op == op_And);
1221 set_irn_n(node, 0, left);
1225 get_And_right (ir_node *node) {
1226 assert (node->op == op_And);
1227 return get_irn_n(node, 1);
1231 set_And_right (ir_node *node, ir_node *right) {
1232 assert (node->op == op_And);
1233 set_irn_n(node, 1, right);
1237 get_Or_left (ir_node *node) {
1238 assert (node->op == op_Or);
1239 return get_irn_n(node, 0);
1243 set_Or_left (ir_node *node, ir_node *left) {
1244 assert (node->op == op_Or);
1245 set_irn_n(node, 0, left);
1249 get_Or_right (ir_node *node) {
1250 assert (node->op == op_Or);
1251 return get_irn_n(node, 1);
1255 set_Or_right (ir_node *node, ir_node *right) {
1256 assert (node->op == op_Or);
1257 set_irn_n(node, 1, right);
1261 get_Eor_left (ir_node *node) {
1262 assert (node->op == op_Eor);
1263 return get_irn_n(node, 0);
1267 set_Eor_left (ir_node *node, ir_node *left) {
1268 assert (node->op == op_Eor);
1269 set_irn_n(node, 0, left);
1273 get_Eor_right (ir_node *node) {
1274 assert (node->op == op_Eor);
1275 return get_irn_n(node, 1);
1279 set_Eor_right (ir_node *node, ir_node *right) {
1280 assert (node->op == op_Eor);
1281 set_irn_n(node, 1, right);
1286 get_Not_op (ir_node *node) {
1287 assert (node->op == op_Not);
1288 return get_irn_n(node, 0);
1292 set_Not_op (ir_node *node, ir_node *op) {
1293 assert (node->op == op_Not);
1294 set_irn_n(node, 0, op);
1299 get_Shl_left (ir_node *node) {
1300 assert (node->op == op_Shl);
1301 return get_irn_n(node, 0);
1305 set_Shl_left (ir_node *node, ir_node *left) {
1306 assert (node->op == op_Shl);
1307 set_irn_n(node, 0, left);
1311 get_Shl_right (ir_node *node) {
1312 assert (node->op == op_Shl);
1313 return get_irn_n(node, 1);
1317 set_Shl_right (ir_node *node, ir_node *right) {
1318 assert (node->op == op_Shl);
1319 set_irn_n(node, 1, right);
1323 get_Shr_left (ir_node *node) {
1324 assert (node->op == op_Shr);
1325 return get_irn_n(node, 0);
1329 set_Shr_left (ir_node *node, ir_node *left) {
1330 assert (node->op == op_Shr);
1331 set_irn_n(node, 0, left);
1335 get_Shr_right (ir_node *node) {
1336 assert (node->op == op_Shr);
1337 return get_irn_n(node, 1);
1341 set_Shr_right (ir_node *node, ir_node *right) {
1342 assert (node->op == op_Shr);
1343 set_irn_n(node, 1, right);
1347 get_Shrs_left (ir_node *node) {
1348 assert (node->op == op_Shrs);
1349 return get_irn_n(node, 0);
1353 set_Shrs_left (ir_node *node, ir_node *left) {
1354 assert (node->op == op_Shrs);
1355 set_irn_n(node, 0, left);
1359 get_Shrs_right (ir_node *node) {
1360 assert (node->op == op_Shrs);
1361 return get_irn_n(node, 1);
1365 set_Shrs_right (ir_node *node, ir_node *right) {
1366 assert (node->op == op_Shrs);
1367 set_irn_n(node, 1, right);
1371 get_Rot_left (ir_node *node) {
1372 assert (node->op == op_Rot);
1373 return get_irn_n(node, 0);
1377 set_Rot_left (ir_node *node, ir_node *left) {
1378 assert (node->op == op_Rot);
1379 set_irn_n(node, 0, left);
1383 get_Rot_right (ir_node *node) {
1384 assert (node->op == op_Rot);
1385 return get_irn_n(node, 1);
1389 set_Rot_right (ir_node *node, ir_node *right) {
1390 assert (node->op == op_Rot);
1391 set_irn_n(node, 1, right);
1395 get_Cmp_left (ir_node *node) {
1396 assert (node->op == op_Cmp);
1397 return get_irn_n(node, 0);
1401 set_Cmp_left (ir_node *node, ir_node *left) {
1402 assert (node->op == op_Cmp);
1403 set_irn_n(node, 0, left);
1407 get_Cmp_right (ir_node *node) {
1408 assert (node->op == op_Cmp);
1409 return get_irn_n(node, 1);
1413 set_Cmp_right (ir_node *node, ir_node *right) {
1414 assert (node->op == op_Cmp);
1415 set_irn_n(node, 1, right);
1419 get_Conv_op (ir_node *node) {
1420 assert (node->op == op_Conv);
1421 return get_irn_n(node, 0);
1425 set_Conv_op (ir_node *node, ir_node *op) {
1426 assert (node->op == op_Conv);
1427 set_irn_n(node, 0, op);
1431 get_Phi_preds_arr (ir_node *node) {
1432 assert (node->op == op_Phi);
1433 return (ir_node **)&(get_irn_in(node)[1]);
1437 get_Phi_n_preds (ir_node *node) {
1438 assert (node->op == op_Phi);
1439 return (get_irn_arity(node));
1443 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1444 assert (node->op == op_Phi);
1449 get_Phi_pred (ir_node *node, int pos) {
1450 assert (node->op == op_Phi);
1451 return get_irn_n(node, pos);
1455 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1456 assert (node->op == op_Phi);
1457 set_irn_n(node, pos, pred);
1461 get_Load_mem (ir_node *node) {
1462 assert (node->op == op_Load);
1463 return get_irn_n(node, 0);
1467 set_Load_mem (ir_node *node, ir_node *mem) {
1468 assert (node->op == op_Load);
1469 set_irn_n(node, 0, mem);
1473 get_Load_ptr (ir_node *node) {
1474 assert (node->op == op_Load);
1475 return get_irn_n(node, 1);
1479 set_Load_ptr (ir_node *node, ir_node *ptr) {
1480 assert (node->op == op_Load);
1481 set_irn_n(node, 1, ptr);
1486 get_Store_mem (ir_node *node) {
1487 assert (node->op == op_Store);
1488 return get_irn_n(node, 0);
1492 set_Store_mem (ir_node *node, ir_node *mem) {
1493 assert (node->op == op_Store);
1494 set_irn_n(node, 0, mem);
1498 get_Store_ptr (ir_node *node) {
1499 assert (node->op == op_Store);
1500 return get_irn_n(node, 1);
1504 set_Store_ptr (ir_node *node, ir_node *ptr) {
1505 assert (node->op == op_Store);
1506 set_irn_n(node, 1, ptr);
1510 get_Store_value (ir_node *node) {
1511 assert (node->op == op_Store);
1512 return get_irn_n(node, 2);
1516 set_Store_value (ir_node *node, ir_node *value) {
1517 assert (node->op == op_Store);
1518 set_irn_n(node, 2, value);
1522 get_Alloc_mem (ir_node *node) {
1523 assert (node->op == op_Alloc);
1524 return get_irn_n(node, 0);
1528 set_Alloc_mem (ir_node *node, ir_node *mem) {
1529 assert (node->op == op_Alloc);
1530 set_irn_n(node, 0, mem);
1534 get_Alloc_size (ir_node *node) {
1535 assert (node->op == op_Alloc);
1536 return get_irn_n(node, 1);
1540 set_Alloc_size (ir_node *node, ir_node *size) {
1541 assert (node->op == op_Alloc);
1542 set_irn_n(node, 1, size);
1546 get_Alloc_type (ir_node *node) {
1547 assert (node->op == op_Alloc);
1548 return node->attr.a.type;
1552 set_Alloc_type (ir_node *node, type *type) {
1553 assert (node->op == op_Alloc);
1554 node->attr.a.type = type;
1558 get_Alloc_where (ir_node *node) {
1559 assert (node->op == op_Alloc);
1560 return node->attr.a.where;
1564 set_Alloc_where (ir_node *node, where_alloc where) {
1565 assert (node->op == op_Alloc);
1566 node->attr.a.where = where;
1571 get_Free_mem (ir_node *node) {
1572 assert (node->op == op_Free);
1573 return get_irn_n(node, 0);
1577 set_Free_mem (ir_node *node, ir_node *mem) {
1578 assert (node->op == op_Free);
1579 set_irn_n(node, 0, mem);
1583 get_Free_ptr (ir_node *node) {
1584 assert (node->op == op_Free);
1585 return get_irn_n(node, 1);
1589 set_Free_ptr (ir_node *node, ir_node *ptr) {
1590 assert (node->op == op_Free);
1591 set_irn_n(node, 1, ptr);
1595 get_Free_size (ir_node *node) {
1596 assert (node->op == op_Free);
1597 return get_irn_n(node, 2);
1601 set_Free_size (ir_node *node, ir_node *size) {
1602 assert (node->op == op_Free);
1603 set_irn_n(node, 2, size);
1607 get_Free_type (ir_node *node) {
1608 assert (node->op == op_Free);
1609 return node->attr.f;
1613 set_Free_type (ir_node *node, type *type) {
1614 assert (node->op == op_Free);
1615 node->attr.f = type;
1619 get_Sync_preds_arr (ir_node *node) {
1620 assert (node->op == op_Sync);
1621 return (ir_node **)&(get_irn_in(node)[1]);
1625 get_Sync_n_preds (ir_node *node) {
1626 assert (node->op == op_Sync);
1627 return (get_irn_arity(node));
1632 set_Sync_n_preds (ir_node *node, int n_preds) {
1633 assert (node->op == op_Sync);
1638 get_Sync_pred (ir_node *node, int pos) {
1639 assert (node->op == op_Sync);
1640 return get_irn_n(node, pos);
1644 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1645 assert (node->op == op_Sync);
1646 set_irn_n(node, pos, pred);
1650 get_Proj_pred (ir_node *node) {
1651 assert (node->op == op_Proj);
1652 return get_irn_n(node, 0);
1656 set_Proj_pred (ir_node *node, ir_node *pred) {
1657 assert (node->op == op_Proj);
1658 set_irn_n(node, 0, pred);
1662 get_Proj_proj (ir_node *node) {
1663 assert (node->op == op_Proj);
1664 return node->attr.proj;
1668 set_Proj_proj (ir_node *node, long proj) {
1669 assert (node->op == op_Proj);
1670 node->attr.proj = proj;
1674 get_Tuple_preds_arr (ir_node *node) {
1675 assert (node->op == op_Tuple);
1676 return (ir_node **)&(get_irn_in(node)[1]);
1680 get_Tuple_n_preds (ir_node *node) {
1681 assert (node->op == op_Tuple);
1682 return (get_irn_arity(node));
1687 set_Tuple_n_preds (ir_node *node, int n_preds) {
1688 assert (node->op == op_Tuple);
1693 get_Tuple_pred (ir_node *node, int pos) {
1694 assert (node->op == op_Tuple);
1695 return get_irn_n(node, pos);
1699 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1700 assert (node->op == op_Tuple);
1701 set_irn_n(node, pos, pred);
1705 get_Id_pred (ir_node *node) {
1706 assert (node->op == op_Id);
1707 return get_irn_n(node, 0);
1711 set_Id_pred (ir_node *node, ir_node *pred) {
1712 assert (node->op == op_Id);
1713 set_irn_n(node, 0, pred);
1716 /******************************************************************/
1717 /* Auxiliary routines */
1718 /******************************************************************/
1721 skip_Proj (ir_node *node) {
1722 /* don't assert node !!! */
1723 if (node && (node->op == op_Proj)) {
1724 return get_Proj_pred(node);
1731 skip_nop (ir_node *node) {
1732 /* don't assert node !!! */
1734 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1735 /* Don't use get_Id_pred: We get into an endless loop for
1736 self-referencing Ids. */
1737 assert (get_irn_arity (node) > 0);
1738 return node->in[0+1];
1745 is_Bad (ir_node *node) {
1747 if ((node) && get_irn_opcode(node) == iro_Bad)
1753 is_no_Block (ir_node *node) {
1755 return (get_irn_opcode(node) != iro_Block);
1758 /* Returns true if the operation manipulates control flow. */
1760 is_cfop(ir_node *node) {
1761 return ( (get_irn_opcode(node) == iro_Start)
1762 || (get_irn_opcode(node) == iro_Jmp)
1763 || (get_irn_opcode(node) == iro_Cond)
1764 || (get_irn_opcode(node) == iro_Return)
1765 || (get_irn_opcode(node) == iro_Raise)
1766 || (get_irn_opcode(node) == iro_Bad));
1769 /* Returns true if the operation can change the control flow because
1772 is_fragile_op(ir_node *node) {
1773 return ( (get_irn_opcode(node) == iro_Call)
1774 || (get_irn_opcode(node) == iro_Quot)
1775 || (get_irn_opcode(node) == iro_DivMod)
1776 || (get_irn_opcode(node) == iro_Div)
1777 || (get_irn_opcode(node) == iro_Mod)
1778 || (get_irn_opcode(node) == iro_Load)
1779 || (get_irn_opcode(node) == iro_Store)
1780 || (get_irn_opcode(node) == iro_Alloc)
1781 || (get_irn_opcode(node) == iro_Bad));