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;
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_Sel_mem (ir_node *node) {
589 assert (node->op == op_Sel);
590 return get_irn_n(node, 0);
594 set_Sel_mem (ir_node *node, ir_node *mem) {
595 assert (node->op == op_Sel);
596 set_irn_n(node, 0, mem);
600 get_Sel_ptr (ir_node *node) {
601 assert (node->op == op_Sel);
602 return get_irn_n(node, 1);
606 set_Sel_ptr (ir_node *node, ir_node *ptr) {
607 assert (node->op == op_Sel);
608 set_irn_n(node, 1, ptr);
612 get_Sel_index_arr (ir_node *node)
614 assert ((node->op == op_Sel));
615 if (get_Sel_n_index(node) > 0)
616 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
622 get_Sel_n_index (ir_node *node) {
623 assert (node->op == op_Sel);
624 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
629 set_Sel_n_index (ir_node *node, int n_index) {
630 assert (node->op == op_Sel);
635 get_Sel_index (ir_node *node, int pos) {
636 assert (node->op == op_Sel);
637 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
641 set_Sel_index (ir_node *node, int pos, ir_node *index) {
642 assert (node->op == op_Sel);
643 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
647 get_Sel_entity (ir_node *node) {
648 assert (node->op == op_Sel);
649 return node->attr.s.ent;
653 set_Sel_entity (ir_node *node, entity *ent) {
654 assert (node->op == op_Sel);
655 node->attr.s.ent = ent;
659 get_Sel_linkage_type (ir_node *node) {
660 assert (node->op == op_Sel);
661 return node->attr.s.ltyp;
665 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
666 assert (node->op == op_Sel);
667 node->attr.s.ltyp = lt;
671 get_Call_mem (ir_node *node) {
672 assert (node->op == op_Call);
673 return get_irn_n(node, 0);
677 set_Call_mem (ir_node *node, ir_node *mem) {
678 assert (node->op == op_Call);
679 set_irn_n(node, 0, mem);
683 get_Call_ptr (ir_node *node) {
684 assert (node->op == op_Call);
685 return get_irn_n(node, 1);
689 set_Call_ptr (ir_node *node, ir_node *ptr) {
690 assert (node->op == op_Call);
691 set_irn_n(node, 1, ptr);
695 get_Call_param_arr (ir_node *node) {
696 assert (node->op == op_Call);
697 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
701 get_Call_n_params (ir_node *node) {
702 assert (node->op == op_Call);
703 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
707 get_Call_arity (ir_node *node) {
708 return get_Call_n_params(node);
712 set_Call_arity (ir_node *node, ir_node *arity) {
713 assert (node->op == op_Call);
718 get_Call_param (ir_node *node, int pos) {
719 assert (node->op == op_Call);
720 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
724 set_Call_param (ir_node *node, int pos, ir_node *param) {
725 assert (node->op == op_Call);
726 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
730 get_Call_type (ir_node *node) {
731 assert (node->op == op_Call);
732 return node->attr.call;
736 set_Call_type (ir_node *node, type_method *type) {
737 assert (node->op == op_Call);
738 node->attr.call = type;
741 /* For unary and binary arithmetic operations the access to the
742 operands can be factored out. Left is the first, right the
743 second arithmetic value as listed in tech report 0999-33.
744 unops are: Minus, Abs, Not, Conv
745 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
746 Shr, Shrs, Rotate, Cmp */
749 is_unop (ir_node *node) {
750 return ( node->op == op_Minus ||
751 node->op == op_Abs ||
752 node->op == op_Not ||
753 node->op == op_Conv );
757 get_unop_op (ir_node *node) {
758 assert ( node->op == op_Minus ||
759 node->op == op_Abs ||
760 node->op == op_Not ||
761 node->op == op_Conv );
762 switch (get_irn_opcode (node)) {
763 case iro_Minus: return get_Minus_op(node); break;
764 case iro_Abs: return get_Abs_op(node); break;
765 case iro_Not: return get_Not_op(node); break;
766 case iro_Conv: return get_Conv_op(node); break;
767 default: return NULL;
772 set_unop_op (ir_node *node, ir_node *op) {
773 assert (node->op == op_Minus ||
774 node->op == op_Abs ||
775 node->op == op_Not ||
776 node->op == op_Conv );
777 switch (get_irn_opcode (node)) {
778 case iro_Minus: set_Minus_op(node, op); break;
779 case iro_Abs: set_Abs_op(node, op); break;
780 case iro_Not: set_Not_op(node, op); break;
781 case iro_Conv: set_Conv_op(node, op); break;
788 is_binop (ir_node *node) {
789 return (node->op == op_Add ||
790 node->op == op_Sub ||
791 node->op == op_Mul ||
792 node->op == op_Quot ||
793 node->op == op_DivMod ||
794 node->op == op_Div ||
795 node->op == op_Mod ||
796 node->op == op_And ||
798 node->op == op_Eor ||
799 node->op == op_Shl ||
800 node->op == op_Shr ||
801 node->op == op_Shrs ||
802 node->op == op_Rot ||
803 node->op == op_Cmp );
807 get_binop_left (ir_node *node) {
808 assert (node->op == op_Add ||
809 node->op == op_Sub ||
810 node->op == op_Mul ||
811 node->op == op_Quot ||
812 node->op == op_DivMod ||
813 node->op == op_Div ||
814 node->op == op_Mod ||
815 node->op == op_And ||
817 node->op == op_Eor ||
818 node->op == op_Shl ||
819 node->op == op_Shr ||
820 node->op == op_Shrs ||
821 node->op == op_Rot ||
822 node->op == op_Cmp );
824 switch (get_irn_opcode (node)) {
825 case iro_Add : return get_Add_left(node); break;
826 case iro_Sub : return get_Sub_left(node); break;
827 case iro_Mul : return get_Mul_left(node); break;
828 case iro_Quot : return get_Quot_left(node); break;
829 case iro_DivMod: return get_DivMod_left(node); break;
830 case iro_Div : return get_Div_left(node); break;
831 case iro_Mod : return get_Mod_left(node); break;
832 case iro_And : return get_And_left(node); break;
833 case iro_Or : return get_Or_left(node); break;
834 case iro_Eor : return get_Eor_left(node); break;
835 case iro_Shl : return get_Shl_left(node); break;
836 case iro_Shr : return get_Shr_left(node); break;
837 case iro_Shrs : return get_Shrs_left(node); break;
838 case iro_Rot : return get_Rot_left(node); break;
839 case iro_Cmp : return get_Cmp_left(node); break;
840 default: return NULL;
845 set_binop_left (ir_node *node, ir_node *left) {
846 assert (node->op == op_Add ||
847 node->op == op_Sub ||
848 node->op == op_Mul ||
849 node->op == op_Quot ||
850 node->op == op_DivMod ||
851 node->op == op_Div ||
852 node->op == op_Mod ||
853 node->op == op_And ||
855 node->op == op_Eor ||
856 node->op == op_Shl ||
857 node->op == op_Shr ||
858 node->op == op_Shrs ||
859 node->op == op_Rot ||
860 node->op == op_Cmp );
862 switch (get_irn_opcode (node)) {
863 case iro_Add : set_Add_left(node, left); break;
864 case iro_Sub : set_Sub_left(node, left); break;
865 case iro_Mul : set_Mul_left(node, left); break;
866 case iro_Quot : set_Quot_left(node, left); break;
867 case iro_DivMod: set_DivMod_left(node, left); break;
868 case iro_Div : set_Div_left(node, left); break;
869 case iro_Mod : set_Mod_left(node, left); break;
870 case iro_And : set_And_left(node, left); break;
871 case iro_Or : set_Or_left(node, left); break;
872 case iro_Eor : set_Eor_left(node, left); break;
873 case iro_Shl : set_Shl_left(node, left); break;
874 case iro_Shr : set_Shr_left(node, left); break;
875 case iro_Shrs : set_Shrs_left(node, left); break;
876 case iro_Rot : set_Rot_left(node, left); break;
877 case iro_Cmp : set_Cmp_left(node, left); break;
883 get_binop_right (ir_node *node) {
884 assert (node->op == op_Add ||
885 node->op == op_Sub ||
886 node->op == op_Mul ||
887 node->op == op_Quot ||
888 node->op == op_DivMod ||
889 node->op == op_Div ||
890 node->op == op_Mod ||
891 node->op == op_And ||
893 node->op == op_Eor ||
894 node->op == op_Shl ||
895 node->op == op_Shr ||
896 node->op == op_Shrs ||
897 node->op == op_Rot ||
898 node->op == op_Cmp );
900 switch (get_irn_opcode (node)) {
901 case iro_Add : return get_Add_right(node); break;
902 case iro_Sub : return get_Sub_right(node); break;
903 case iro_Mul : return get_Mul_right(node); break;
904 case iro_Quot : return get_Quot_right(node); break;
905 case iro_DivMod: return get_DivMod_right(node); break;
906 case iro_Div : return get_Div_right(node); break;
907 case iro_Mod : return get_Mod_right(node); break;
908 case iro_And : return get_And_right(node); break;
909 case iro_Or : return get_Or_right(node); break;
910 case iro_Eor : return get_Eor_right(node); break;
911 case iro_Shl : return get_Shl_right(node); break;
912 case iro_Shr : return get_Shr_right(node); break;
913 case iro_Shrs : return get_Shrs_right(node); break;
914 case iro_Rot : return get_Rot_right(node); break;
915 case iro_Cmp : return get_Cmp_right(node); break;
916 default: return NULL;
921 set_binop_right (ir_node *node, ir_node *right) {
922 assert (node->op == op_Add ||
923 node->op == op_Sub ||
924 node->op == op_Mul ||
925 node->op == op_Quot ||
926 node->op == op_DivMod ||
927 node->op == op_Div ||
928 node->op == op_Mod ||
929 node->op == op_And ||
931 node->op == op_Eor ||
932 node->op == op_Shl ||
933 node->op == op_Shr ||
934 node->op == op_Shrs ||
935 node->op == op_Rot ||
936 node->op == op_Cmp );
938 switch (get_irn_opcode (node)) {
939 case iro_Add : set_Add_right(node, right); break;
940 case iro_Sub : set_Sub_right(node, right); break;
941 case iro_Mul : set_Mul_right(node, right); break;
942 case iro_Quot : set_Quot_right(node, right); break;
943 case iro_DivMod: set_DivMod_right(node, right); break;
944 case iro_Div : set_Div_right(node, right); break;
945 case iro_Mod : set_Mod_right(node, right); break;
946 case iro_And : set_And_right(node, right); break;
947 case iro_Or : set_Or_right(node, right); break;
948 case iro_Eor : set_Eor_right(node, right); break;
949 case iro_Shl : set_Shl_right(node, right); break;
950 case iro_Shr : set_Shr_right(node, right); break;
951 case iro_Shrs : set_Shrs_right(node, right); break;
952 case iro_Rot : set_Rot_right(node, right); break;
953 case iro_Cmp : set_Cmp_right(node, right); break;
959 get_Add_left (ir_node *node) {
960 assert (node->op == op_Add);
961 return get_irn_n(node, 0);
965 set_Add_left (ir_node *node, ir_node *left) {
966 assert (node->op == op_Add);
967 set_irn_n(node, 0, left);
971 get_Add_right (ir_node *node) {
972 assert (node->op == op_Add);
973 return get_irn_n(node, 1);
977 set_Add_right (ir_node *node, ir_node *right) {
978 assert (node->op == op_Add);
979 set_irn_n(node, 1, right);
983 get_Sub_left (ir_node *node) {
984 assert (node->op == op_Sub);
985 return get_irn_n(node, 0);
989 set_Sub_left (ir_node *node, ir_node *left) {
990 assert (node->op == op_Sub);
991 set_irn_n(node, 0, left);
995 get_Sub_right (ir_node *node) {
996 assert (node->op == op_Sub);
997 return get_irn_n(node, 1);
1001 set_Sub_right (ir_node *node, ir_node *right) {
1002 assert (node->op == op_Sub);
1003 set_irn_n(node, 1, right);
1008 get_Minus_op (ir_node *node) {
1009 assert (node->op == op_Minus);
1010 return get_irn_n(node, 0);
1014 set_Minus_op (ir_node *node, ir_node *op) {
1015 assert (node->op == op_Minus);
1016 set_irn_n(node, 0, op);
1021 get_Mul_left (ir_node *node) {
1022 assert (node->op == op_Mul);
1023 return get_irn_n(node, 0);
1027 set_Mul_left (ir_node *node, ir_node *left) {
1028 assert (node->op == op_Mul);
1029 set_irn_n(node, 0, left);
1033 get_Mul_right (ir_node *node) {
1034 assert (node->op == op_Mul);
1035 return get_irn_n(node, 1);
1039 set_Mul_right (ir_node *node, ir_node *right) {
1040 assert (node->op == op_Mul);
1041 set_irn_n(node, 1, right);
1045 get_Quot_left (ir_node *node) {
1046 assert (node->op == op_Quot);
1047 return get_irn_n(node, 1);
1051 set_Quot_left (ir_node *node, ir_node *left) {
1052 assert (node->op == op_Quot);
1053 set_irn_n(node, 1, left);
1057 get_Quot_right (ir_node *node) {
1058 assert (node->op == op_Quot);
1059 return get_irn_n(node, 2);
1063 set_Quot_right (ir_node *node, ir_node *right) {
1064 assert (node->op == op_Quot);
1065 set_irn_n(node, 2, right);
1069 get_Quot_mem (ir_node *node) {
1070 assert (node->op == op_Quot);
1071 return get_irn_n(node, 0);
1075 set_Quot_mem (ir_node *node, ir_node *mem) {
1076 assert (node->op == op_Quot);
1077 set_irn_n(node, 0, mem);
1081 get_DivMod_left (ir_node *node) {
1082 assert (node->op == op_DivMod);
1083 return get_irn_n(node, 1);
1087 set_DivMod_left (ir_node *node, ir_node *left) {
1088 assert (node->op == op_DivMod);
1089 set_irn_n(node, 1, left);
1093 get_DivMod_right (ir_node *node) {
1094 assert (node->op == op_DivMod);
1095 return get_irn_n(node, 2);
1099 set_DivMod_right (ir_node *node, ir_node *right) {
1100 assert (node->op == op_DivMod);
1101 set_irn_n(node, 2, right);
1105 get_DivMod_mem (ir_node *node) {
1106 assert (node->op == op_DivMod);
1107 return get_irn_n(node, 0);
1111 set_DivMod_mem (ir_node *node, ir_node *mem) {
1112 assert (node->op == op_DivMod);
1113 set_irn_n(node, 0, mem);
1117 get_Div_left (ir_node *node) {
1118 assert (node->op == op_Div);
1119 return get_irn_n(node, 1);
1123 set_Div_left (ir_node *node, ir_node *left) {
1124 assert (node->op == op_Div);
1125 set_irn_n(node, 1, left);
1129 get_Div_right (ir_node *node) {
1130 assert (node->op == op_Div);
1131 return get_irn_n(node, 2);
1135 set_Div_right (ir_node *node, ir_node *right) {
1136 assert (node->op == op_Div);
1137 set_irn_n(node, 2, right);
1141 get_Div_mem (ir_node *node) {
1142 assert (node->op == op_Div);
1143 return get_irn_n(node, 0);
1147 set_Div_mem (ir_node *node, ir_node *mem) {
1148 assert (node->op == op_Div);
1149 set_irn_n(node, 0, mem);
1153 get_Mod_left (ir_node *node) {
1154 assert (node->op == op_Mod);
1155 return get_irn_n(node, 1);
1159 set_Mod_left (ir_node *node, ir_node *left) {
1160 assert (node->op == op_Mod);
1161 set_irn_n(node, 1, left);
1165 get_Mod_right (ir_node *node) {
1166 assert (node->op == op_Mod);
1167 return get_irn_n(node, 2);
1171 set_Mod_right (ir_node *node, ir_node *right) {
1172 assert (node->op == op_Mod);
1173 set_irn_n(node, 2, right);
1177 get_Mod_mem (ir_node *node) {
1178 assert (node->op == op_Mod);
1179 return get_irn_n(node, 0);
1183 set_Mod_mem (ir_node *node, ir_node *mem) {
1184 assert (node->op == op_Mod);
1185 set_irn_n(node, 0, mem);
1189 get_Abs_op (ir_node *node) {
1190 assert (node->op == op_Abs);
1191 return get_irn_n(node, 0);
1195 set_Abs_op (ir_node *node, ir_node *op) {
1196 assert (node->op == op_Abs);
1197 set_irn_n(node, 0, op);
1201 get_And_left (ir_node *node) {
1202 assert (node->op == op_And);
1203 return get_irn_n(node, 0);
1207 set_And_left (ir_node *node, ir_node *left) {
1208 assert (node->op == op_And);
1209 set_irn_n(node, 0, left);
1213 get_And_right (ir_node *node) {
1214 assert (node->op == op_And);
1215 return get_irn_n(node, 1);
1219 set_And_right (ir_node *node, ir_node *right) {
1220 assert (node->op == op_And);
1221 set_irn_n(node, 1, right);
1225 get_Or_left (ir_node *node) {
1226 assert (node->op == op_Or);
1227 return get_irn_n(node, 0);
1231 set_Or_left (ir_node *node, ir_node *left) {
1232 assert (node->op == op_Or);
1233 set_irn_n(node, 0, left);
1237 get_Or_right (ir_node *node) {
1238 assert (node->op == op_Or);
1239 return get_irn_n(node, 1);
1243 set_Or_right (ir_node *node, ir_node *right) {
1244 assert (node->op == op_Or);
1245 set_irn_n(node, 1, right);
1249 get_Eor_left (ir_node *node) {
1250 assert (node->op == op_Eor);
1251 return get_irn_n(node, 0);
1255 set_Eor_left (ir_node *node, ir_node *left) {
1256 assert (node->op == op_Eor);
1257 set_irn_n(node, 0, left);
1261 get_Eor_right (ir_node *node) {
1262 assert (node->op == op_Eor);
1263 return get_irn_n(node, 1);
1267 set_Eor_right (ir_node *node, ir_node *right) {
1268 assert (node->op == op_Eor);
1269 set_irn_n(node, 1, right);
1274 get_Not_op (ir_node *node) {
1275 assert (node->op == op_Not);
1276 return get_irn_n(node, 0);
1280 set_Not_op (ir_node *node, ir_node *op) {
1281 assert (node->op == op_Not);
1282 set_irn_n(node, 0, op);
1287 get_Shl_left (ir_node *node) {
1288 assert (node->op == op_Shl);
1289 return get_irn_n(node, 0);
1293 set_Shl_left (ir_node *node, ir_node *left) {
1294 assert (node->op == op_Shl);
1295 set_irn_n(node, 0, left);
1299 get_Shl_right (ir_node *node) {
1300 assert (node->op == op_Shl);
1301 return get_irn_n(node, 1);
1305 set_Shl_right (ir_node *node, ir_node *right) {
1306 assert (node->op == op_Shl);
1307 set_irn_n(node, 1, right);
1311 get_Shr_left (ir_node *node) {
1312 assert (node->op == op_Shr);
1313 return get_irn_n(node, 0);
1317 set_Shr_left (ir_node *node, ir_node *left) {
1318 assert (node->op == op_Shr);
1319 set_irn_n(node, 0, left);
1323 get_Shr_right (ir_node *node) {
1324 assert (node->op == op_Shr);
1325 return get_irn_n(node, 1);
1329 set_Shr_right (ir_node *node, ir_node *right) {
1330 assert (node->op == op_Shr);
1331 set_irn_n(node, 1, right);
1335 get_Shrs_left (ir_node *node) {
1336 assert (node->op == op_Shrs);
1337 return get_irn_n(node, 0);
1341 set_Shrs_left (ir_node *node, ir_node *left) {
1342 assert (node->op == op_Shrs);
1343 set_irn_n(node, 0, left);
1347 get_Shrs_right (ir_node *node) {
1348 assert (node->op == op_Shrs);
1349 return get_irn_n(node, 1);
1353 set_Shrs_right (ir_node *node, ir_node *right) {
1354 assert (node->op == op_Shrs);
1355 set_irn_n(node, 1, right);
1359 get_Rot_left (ir_node *node) {
1360 assert (node->op == op_Rot);
1361 return get_irn_n(node, 0);
1365 set_Rot_left (ir_node *node, ir_node *left) {
1366 assert (node->op == op_Rot);
1367 set_irn_n(node, 0, left);
1371 get_Rot_right (ir_node *node) {
1372 assert (node->op == op_Rot);
1373 return get_irn_n(node, 1);
1377 set_Rot_right (ir_node *node, ir_node *right) {
1378 assert (node->op == op_Rot);
1379 set_irn_n(node, 1, right);
1383 get_Cmp_left (ir_node *node) {
1384 assert (node->op == op_Cmp);
1385 return get_irn_n(node, 0);
1389 set_Cmp_left (ir_node *node, ir_node *left) {
1390 assert (node->op == op_Cmp);
1391 set_irn_n(node, 0, left);
1395 get_Cmp_right (ir_node *node) {
1396 assert (node->op == op_Cmp);
1397 return get_irn_n(node, 1);
1401 set_Cmp_right (ir_node *node, ir_node *right) {
1402 assert (node->op == op_Cmp);
1403 set_irn_n(node, 1, right);
1407 get_Conv_op (ir_node *node) {
1408 assert (node->op == op_Conv);
1409 return get_irn_n(node, 0);
1413 set_Conv_op (ir_node *node, ir_node *op) {
1414 assert (node->op == op_Conv);
1415 set_irn_n(node, 0, op);
1419 get_Phi_preds_arr (ir_node *node) {
1420 assert (node->op == op_Phi);
1421 return (ir_node **)&(get_irn_in(node)[1]);
1425 get_Phi_n_preds (ir_node *node) {
1426 assert (node->op == op_Phi);
1427 return (get_irn_arity(node));
1431 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1432 assert (node->op == op_Phi);
1437 get_Phi_pred (ir_node *node, int pos) {
1438 assert (node->op == op_Phi);
1439 return get_irn_n(node, pos);
1443 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1444 assert (node->op == op_Phi);
1445 set_irn_n(node, pos, pred);
1449 get_Load_mem (ir_node *node) {
1450 assert (node->op == op_Load);
1451 return get_irn_n(node, 0);
1455 set_Load_mem (ir_node *node, ir_node *mem) {
1456 assert (node->op == op_Load);
1457 set_irn_n(node, 0, mem);
1461 get_Load_ptr (ir_node *node) {
1462 assert (node->op == op_Load);
1463 return get_irn_n(node, 1);
1467 set_Load_ptr (ir_node *node, ir_node *ptr) {
1468 assert (node->op == op_Load);
1469 set_irn_n(node, 1, ptr);
1474 get_Store_mem (ir_node *node) {
1475 assert (node->op == op_Store);
1476 return get_irn_n(node, 0);
1480 set_Store_mem (ir_node *node, ir_node *mem) {
1481 assert (node->op == op_Store);
1482 set_irn_n(node, 0, mem);
1486 get_Store_ptr (ir_node *node) {
1487 assert (node->op == op_Store);
1488 return get_irn_n(node, 1);
1492 set_Store_ptr (ir_node *node, ir_node *ptr) {
1493 assert (node->op == op_Store);
1494 set_irn_n(node, 1, ptr);
1498 get_Store_value (ir_node *node) {
1499 assert (node->op == op_Store);
1500 return get_irn_n(node, 2);
1504 set_Store_value (ir_node *node, ir_node *value) {
1505 assert (node->op == op_Store);
1506 set_irn_n(node, 2, value);
1510 get_Alloc_mem (ir_node *node) {
1511 assert (node->op == op_Alloc);
1512 return get_irn_n(node, 0);
1516 set_Alloc_mem (ir_node *node, ir_node *mem) {
1517 assert (node->op == op_Alloc);
1518 set_irn_n(node, 0, mem);
1522 get_Alloc_size (ir_node *node) {
1523 assert (node->op == op_Alloc);
1524 return get_irn_n(node, 1);
1528 set_Allco_size (ir_node *node, ir_node *size) {
1529 assert (node->op == op_Alloc);
1530 set_irn_n(node, 1, size);
1534 get_Alloc_type (ir_node *node) {
1535 assert (node->op == op_Alloc);
1536 return node->attr.a.type;
1540 set_Alloc_type (ir_node *node, type *type) {
1541 assert (node->op == op_Alloc);
1542 node->attr.a.type = type;
1546 get_Alloc_where (ir_node *node) {
1547 assert (node->op == op_Alloc);
1548 return node->attr.a.where;
1552 set_Alloc_where (ir_node *node, where_alloc where) {
1553 assert (node->op == op_Alloc);
1554 node->attr.a.where = where;
1559 get_Free_mem (ir_node *node) {
1560 assert (node->op == op_Free);
1561 return get_irn_n(node, 0);
1565 set_Free_mem (ir_node *node, ir_node *mem) {
1566 assert (node->op == op_Free);
1567 set_irn_n(node, 0, mem);
1571 get_Free_ptr (ir_node *node) {
1572 assert (node->op == op_Free);
1573 return get_irn_n(node, 1);
1577 set_Free_ptr (ir_node *node, ir_node *ptr) {
1578 assert (node->op == op_Free);
1579 set_irn_n(node, 1, ptr);
1583 get_Free_size (ir_node *node) {
1584 assert (node->op == op_Free);
1585 return get_irn_n(node, 2);
1589 set_Free_size (ir_node *node, ir_node *size) {
1590 assert (node->op == op_Free);
1591 set_irn_n(node, 2, size);
1595 get_Free_type (ir_node *node) {
1596 assert (node->op == op_Free);
1597 return node->attr.f;
1601 set_Free_type (ir_node *node, type *type) {
1602 assert (node->op == op_Free);
1603 node->attr.f = type;
1607 get_Sync_preds_arr (ir_node *node) {
1608 assert (node->op == op_Sync);
1609 return (ir_node **)&(get_irn_in(node)[1]);
1613 get_Sync_n_preds (ir_node *node) {
1614 assert (node->op == op_Sync);
1615 return (get_irn_arity(node));
1620 set_Sync_n_preds (ir_node *node, int n_preds) {
1621 assert (node->op == op_Sync);
1626 get_Sync_pred (ir_node *node, int pos) {
1627 assert (node->op == op_Sync);
1628 return get_irn_n(node, pos);
1632 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1633 assert (node->op == op_Sync);
1634 set_irn_n(node, pos, pred);
1638 get_Proj_pred (ir_node *node) {
1639 assert (node->op == op_Proj);
1640 return get_irn_n(node, 0);
1644 set_Proj_pred (ir_node *node, ir_node *pred) {
1645 assert (node->op == op_Proj);
1646 set_irn_n(node, 0, pred);
1650 get_Proj_proj (ir_node *node) {
1651 assert (node->op == op_Proj);
1652 return node->attr.proj;
1656 set_Proj_proj (ir_node *node, long proj) {
1657 assert (node->op == op_Proj);
1658 node->attr.proj = proj;
1662 get_Tuple_preds_arr (ir_node *node) {
1663 assert (node->op == op_Tuple);
1664 return (ir_node **)&(get_irn_in(node)[1]);
1668 get_Tuple_n_preds (ir_node *node) {
1669 assert (node->op == op_Tuple);
1670 return (get_irn_arity(node));
1675 set_Tuple_n_preds (ir_node *node, int n_preds) {
1676 assert (node->op == op_Tuple);
1681 get_Tuple_pred (ir_node *node, int pos) {
1682 assert (node->op == op_Tuple);
1683 return get_irn_n(node, pos);
1687 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1688 assert (node->op == op_Tuple);
1689 set_irn_n(node, pos, pred);
1693 get_Id_pred (ir_node *node) {
1694 assert (node->op == op_Id);
1695 return get_irn_n(node, 0);
1699 set_Id_pred (ir_node *node, ir_node *pred) {
1700 assert (node->op == op_Id);
1701 set_irn_n(node, 0, pred);
1704 /******************************************************************/
1705 /* Auxiliary routines */
1706 /******************************************************************/
1709 skip_Proj (ir_node *node) {
1710 /* don't assert node !!! */
1711 if (node && (node->op == op_Proj)) {
1712 return get_Proj_pred(node);
1719 skip_nop (ir_node *node) {
1720 /* don't assert node !!! */
1722 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1723 return get_Id_pred(node);
1730 is_Bad (ir_node *node) {
1732 if ((node) && get_irn_opcode(node) == iro_Bad)
1738 is_no_Block (ir_node *node) {
1740 return (get_irn_opcode(node) != iro_Block);
1743 /* Returns true if the operation manipulates control flow. */
1745 is_cfop(ir_node *node) {
1746 return ( (get_irn_opcode(node) == iro_Start)
1747 || (get_irn_opcode(node) == iro_Jmp)
1748 || (get_irn_opcode(node) == iro_Cond)
1749 || (get_irn_opcode(node) == iro_Return)
1750 || (get_irn_opcode(node) == iro_Raise)
1751 || (get_irn_opcode(node) == iro_Bad));
1754 /* Returns true if the operation can change the control flow because
1757 is_fragile_op(ir_node *node) {
1758 return ( (get_irn_opcode(node) == iro_Call)
1759 || (get_irn_opcode(node) == iro_Quot)
1760 || (get_irn_opcode(node) == iro_DivMod)
1761 || (get_irn_opcode(node) == iro_Div)
1762 || (get_irn_opcode(node) == iro_Mod)
1763 || (get_irn_opcode(node) == iro_Load)
1764 || (get_irn_opcode(node) == iro_Store)
1765 || (get_irn_opcode(node) == iro_Alloc)
1766 || (get_irn_opcode(node) == iro_Bad));