1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
15 #include "irgraph_t.h"
18 #include "typegmod_t.h"
25 /* some constants fixing the positions of nodes predecessors
27 #define CALL_PARAM_OFFSET 2
28 #define SEL_INDEX_OFFSET 2
29 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
31 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
32 "Gt", "Ge", "Lg", "Leg", "Uo",
33 "Ue", "Ul", "Ule", "Ug", "Uge",
36 inline char *get_pnc_string(int pnc) {
37 return pnc_name_arr[pnc];
42 get_negated_pnc(int pnc) {
44 case False: return True; break;
45 case Eq: return Ne; break;
46 case Lt: return Uge; break;
47 case Le: return Ug; break;
48 case Gt: return Ule; break;
49 case Ge: return Ul; break;
50 case Lg: return Ue; break;
51 case Leg: return Uo; break;
52 case Uo: return Leg; break;
53 case Ue: return Lg; break;
54 case Ul: return Ge; break;
55 case Ule: return Gt; break;
56 case Ug: return Le; break;
57 case Uge: return Lt; break;
58 case Ne: return Eq; break;
59 case True: return False; break;
61 return 99; /* to shut up gcc */
64 static char *pns_name_arr [] = {"initial_exec", "global_store",
65 "frame_base", "globals", "args"};
67 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
74 /* irnode constructor */
75 /* create a new irnode in irg, with an op, mode, arity and */
76 /* some incoming irnodes */
77 /* this constructor is used in every specified irnode constructor */
79 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
80 int arity, ir_node **in)
83 int node_size = offsetof (ir_node, attr) + op->attr_size;
85 res = (ir_node *) obstack_alloc (irg->obst, node_size);
87 res->kind = k_ir_node;
93 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
95 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
96 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
102 res->node_nr = get_irp_new_node_nr();
108 /* Copies all attributes stored in the old node to the new node.
109 Assumes both have the same opcode and sufficient size. */
111 copy_attrs (ir_node *old, ir_node *new) {
112 assert (get_irn_opcode(old) == get_irn_opcode(new));
113 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
116 /* IR-Nodes with attributes */
118 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
121 ir_node *np = XP_GETARG (ir_node *, 0);
124 XPS ("<null ir_node>");
128 XPF1 ("%I", get_irn_opident(np));
130 switch (get_irn_opcode (np)) { /* node label */
132 XPF1 ("%I", get_irn_mode(np)->name);
134 XPF1 ("%v", get_irn_const_attr);
137 if (get_irn_modecode (np) == irm_b) {
139 XP (pnc_name_arr[get_irn_proj_attr(np)]);
140 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
142 XP (pns_name_arr[get_irn_proj_attr(np)]);
144 XPF1 ("%I", get_irn_mode(np)->name);
146 XPF1 ("%d", get_irn_proj_attr(np));
150 XPF1 ("%I", get_irn_mode(np)->name);
152 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
153 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
155 case iro_Start: /* don't dump mode of these */
164 XPF1 ("%I", get_irn_mode(np)->name);
170 /** getting some parameters from ir_nodes **/
172 /* returns the number of predecessors without the block predecessor. */
174 get_irn_arity (ir_node *node)
177 return (ARR_LEN((node)->in)-1);
180 /* Returns the array with ins. This array is shifted with respect to the
181 array accessed by get_irn_n: The block operand is at position 0 not -1.
182 (@@@ This should be changed.)
183 The order of the predecessors in this array is not guaranteed, except that
184 lists of operands as predecessors of Block or arguments of a Call are
187 get_irn_in (ir_node *node)
194 set_irn_in (ir_node *node, int arity, ir_node **in) {
196 if (arity != get_irn_arity(node)) {
197 ir_node *block = node->in[0];
198 node->in = NEW_ARR_D (ir_node *, current_ir_graph->obst, (arity+1));
201 memcpy (&node->in[1], in, sizeof (ir_node *) * arity);
204 /* to iterate through the predecessors without touching the array */
205 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
206 to iterate includind the Block predecessor iterate from i = -1 to
208 If it is a block, the entry -1 is NULL. */
210 get_irn_n (ir_node *node, int n)
214 assert ((get_irn_arity (node) > n) && (-1 <= n));
215 res = skip_nop(node->in[n+1]);
216 if (res != node->in[n+1]) node->in[n+1] = res;
221 set_irn_n (ir_node *node, int n, ir_node *in)
224 assert (get_irn_arity (node) > n);
229 get_irn_mode (ir_node *node)
236 get_irn_modecode (ir_node *node)
239 return node->mode->code;
244 get_irn_modeident (ir_node *node)
247 return node->mode->name;
251 get_irn_op (ir_node *node)
257 /* should be private to the library: */
259 set_irn_op (ir_node *node, ir_op *op)
266 get_irn_opcode (ir_node *node)
269 return node->op->code;
273 get_irn_opname (ir_node *node)
276 return id_to_str(node->op->name);
280 get_irn_opident (ir_node *node)
283 return node->op->name;
287 get_irn_visited (ir_node *node)
290 return node->visited;
294 set_irn_visited (ir_node *node, unsigned long visited)
297 node->visited = visited;
300 set_irn_link (ir_node *node, ir_node *link) {
306 get_irn_link (ir_node *node) {
312 /* Outputs a unique number for this node */
314 get_irn_node_nr(ir_node *node) {
316 return node->node_nr;
321 get_irn_const_attr (ir_node *node)
323 assert (node->op == op_Const);
324 return node->attr.con;
328 get_irn_proj_attr (ir_node *node)
330 assert (node->op == op_Proj);
331 return node->attr.proj;
335 get_irn_alloc_attr (ir_node *node)
337 assert (node->op == op_Alloc);
342 get_irn_free_attr (ir_node *node)
344 assert (node->op == op_Free);
345 return node->attr.f = skip_tid(node->attr.f);
349 get_irn_symconst_attr (ir_node *node)
351 assert (node->op == op_SymConst);
356 get_irn_call_attr (ir_node *node)
358 assert (node->op == op_Call);
359 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
363 get_irn_sel_attr (ir_node *node)
365 assert (node->op == op_Sel);
370 get_irn_phi_attr (ir_node *node)
372 assert (node->op == op_Phi);
373 return node->attr.phi0_pos;
377 get_irn_block_attr (ir_node *node)
379 assert (node->op == op_Block);
380 return node->attr.block;
383 /** manipulate fields of individual nodes **/
385 /* this works for all except Block */
387 get_nodes_Block (ir_node *node) {
388 assert (!(node->op == op_Block));
389 return get_irn_n(node, -1);
393 set_nodes_Block (ir_node *node, ir_node *block) {
394 assert (!(node->op == op_Block));
395 set_irn_n(node, -1, block);
398 /* Returns an array with the predecessors of the Block. Depending on
399 the implementation of the graph datastructure this can be a copy of
400 the internal representation of predecessors as well as the internal
401 array itself. Therefore writing to this array might obstruct the ir. */
403 get_Block_cfgpred_arr (ir_node *node)
405 assert ((node->op == op_Block));
406 return (ir_node **)&(get_irn_in(node)[1]);
411 get_Block_n_cfgpreds (ir_node *node) {
412 assert ((node->op == op_Block));
413 return (get_irn_arity(node));
418 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
419 assert ((node->op == op_Block));
424 get_Block_cfgpred (ir_node *node, int pos) {
425 assert (node->op == op_Block);
426 return get_irn_n(node, pos);
430 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
431 assert (node->op == op_Block);
432 set_irn_n(node, pos, pred);
436 get_Block_matured (ir_node *node) {
437 assert (node->op == op_Block);
438 return node->attr.block.matured;
442 set_Block_matured (ir_node *node, bool matured) {
443 assert (node->op == op_Block);
444 node->attr.block.matured = matured;
447 get_Block_block_visited (ir_node *node) {
448 assert (node->op == op_Block);
449 return node->attr.block.block_visited;
453 set_Block_block_visited (ir_node *node, unsigned long visit) {
454 assert (node->op == op_Block);
455 node->attr.block.block_visited = visit;
459 get_Block_graph_arr (ir_node *node, int pos) {
460 assert (node->op == op_Block);
461 return node->attr.block.graph_arr[pos+1];
465 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
466 assert (node->op == op_Block);
467 node->attr.block.graph_arr[pos+1] = value;
471 add_End_keepalive (ir_node *end, ir_node *ka) {
472 assert (end->op == op_End);
473 ARR_APP1 (ir_node *, end->in, ka);
477 free_End (ir_node *end) {
478 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
479 end->in = NULL; /* @@@ make sure we get an error if we use the in array afterwards ... */
483 > Implementing the case construct (which is where the constant Proj node is
484 > important) involves far more than simply determining the constant values.
485 > We could argue that this is more properly a function of the translator from
486 > Firm to the target machine. That could be done if there was some way of
487 > projecting "default" out of the Cond node.
488 I know it's complicated.
489 Basically there are two proglems:
490 - determining the gaps between the projs
491 - determining the biggest case constant to konw the proj number for
493 I see several solutions:
494 1. Introduce a ProjDefault node. Solves both problems.
495 This means to extend all optimizations executed during construction.
496 2. Give the Cond node for switch two flavors:
497 a) there are no gaps in the projs (existing flavor)
498 b) gaps may exist, default proj is still the Proj with the largest
499 projection number. This covers also the gaps.
500 3. Fix the semantic of the Cond to that of 2b)
502 Solution 2 seems to be the best:
503 Computing the gaps in the Firm representation is not too hard, i.e.,
504 libfirm can implement a routine that transforms betweeen the two
505 flavours. This is also possible for 1) but 2) does not require to
506 change any existing optimization.
507 Further it should be far simpler to determine the biggest constant than
509 I don't want to choose 3) as 2a) seems to have advantages for
510 dataflow analysis and 3) does not allow to convert the representation to
514 get_Cond_selector (ir_node *node) {
515 assert (node->op == op_Cond);
516 return get_irn_n(node, 0);
520 set_Cond_selector (ir_node *node, ir_node *selector) {
521 assert (node->op == op_Cond);
522 set_irn_n(node, 0, selector);
526 get_Cond_kind (ir_node *node) {
527 assert (node->op == op_Cond);
528 return node->attr.c.kind;
532 set_Cond_kind (ir_node *node, cond_kind kind) {
533 assert (node->op == op_Cond);
534 node->attr.c.kind = kind;
538 get_Return_mem (ir_node *node) {
539 assert (node->op == op_Return);
540 return get_irn_n(node, 0);
544 set_Return_mem (ir_node *node, ir_node *mem) {
545 assert (node->op == op_Return);
546 set_irn_n(node, 0, mem);
550 get_Return_res_arr (ir_node *node)
552 assert ((node->op == op_Return));
553 if (get_Return_n_res(node) > 0)
554 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
560 get_Return_n_res (ir_node *node) {
561 assert (node->op == op_Return);
562 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
567 set_Return_n_res (ir_node *node, int results) {
568 assert (node->op == op_Return);
573 get_Return_res (ir_node *node, int pos) {
574 assert (node->op == op_Return);
575 assert (get_Return_n_res(node) > pos);
576 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
580 set_Return_res (ir_node *node, int pos, ir_node *res){
581 assert (node->op == op_Return);
582 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
586 get_Raise_mem (ir_node *node) {
587 assert (node->op == op_Return);
588 return get_irn_n(node, 0);
592 set_Raise_mem (ir_node *node, ir_node *mem) {
593 assert (node->op == op_Raise);
594 set_irn_n(node, 0, mem);
598 get_Raise_exo_ptr (ir_node *node) {
599 assert (node->op == op_Raise);
600 return get_irn_n(node, 1);
604 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
605 assert (node->op == op_Raise);
606 set_irn_n(node, 1, exo_ptr);
609 inline tarval *get_Const_tarval (ir_node *node) {
610 assert (node->op == op_Const);
611 return get_irn_const_attr(node);
615 set_Const_tarval (ir_node *node, tarval *con) {
616 assert (node->op == op_Const);
617 node->attr.con = con;
621 get_SymConst_kind (ir_node *node) {
622 assert (node->op == op_SymConst);
623 return node->attr.i.num;
627 set_SymConst_kind (ir_node *node, symconst_kind num) {
628 assert (node->op == op_SymConst);
629 node->attr.i.num = num;
633 get_SymConst_type (ir_node *node) {
634 assert ( (node->op == op_SymConst)
635 && ( get_SymConst_kind(node) == type_tag
636 || get_SymConst_kind(node) == size));
637 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
641 set_SymConst_type (ir_node *node, type *type) {
642 assert ( (node->op == op_SymConst)
643 && ( get_SymConst_kind(node) == type_tag
644 || get_SymConst_kind(node) == size));
645 node->attr.i.tori.typ = type;
649 get_SymConst_ptrinfo (ir_node *node) {
650 assert ( (node->op == op_SymConst)
651 && (get_SymConst_kind(node) == linkage_ptr_info));
652 return node->attr.i.tori.ptrinfo;
656 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
657 assert ( (node->op == op_SymConst)
658 && (get_SymConst_kind(node) == linkage_ptr_info));
659 node->attr.i.tori.ptrinfo = ptrinfo;
663 get_SymConst_type_or_id (ir_node *node) {
664 assert (node->op == op_SymConst);
665 return &(node->attr.i.tori);
669 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
670 assert (node->op == op_SymConst);
671 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
675 get_Sel_mem (ir_node *node) {
676 assert (node->op == op_Sel);
677 return get_irn_n(node, 0);
681 set_Sel_mem (ir_node *node, ir_node *mem) {
682 assert (node->op == op_Sel);
683 set_irn_n(node, 0, mem);
687 get_Sel_ptr (ir_node *node) {
688 assert (node->op == op_Sel);
689 return get_irn_n(node, 1);
693 set_Sel_ptr (ir_node *node, ir_node *ptr) {
694 assert (node->op == op_Sel);
695 set_irn_n(node, 1, ptr);
699 get_Sel_index_arr (ir_node *node)
701 assert ((node->op == op_Sel));
702 if (get_Sel_n_index(node) > 0)
703 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
709 get_Sel_n_index (ir_node *node) {
710 assert (node->op == op_Sel);
711 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
716 set_Sel_n_index (ir_node *node, int n_index) {
717 assert (node->op == op_Sel);
722 get_Sel_index (ir_node *node, int pos) {
723 assert (node->op == op_Sel);
724 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
728 set_Sel_index (ir_node *node, int pos, ir_node *index) {
729 assert (node->op == op_Sel);
730 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
734 get_Sel_entity (ir_node *node) {
735 assert (node->op == op_Sel);
736 return node->attr.s.ent;
740 set_Sel_entity (ir_node *node, entity *ent) {
741 assert (node->op == op_Sel);
742 node->attr.s.ent = ent;
746 get_Sel_linkage_type (ir_node *node) {
747 assert (node->op == op_Sel);
748 return node->attr.s.ltyp;
752 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
753 assert (node->op == op_Sel);
754 node->attr.s.ltyp = lt;
758 get_Call_mem (ir_node *node) {
759 assert (node->op == op_Call);
760 return get_irn_n(node, 0);
764 set_Call_mem (ir_node *node, ir_node *mem) {
765 assert (node->op == op_Call);
766 set_irn_n(node, 0, mem);
770 get_Call_ptr (ir_node *node) {
771 assert (node->op == op_Call);
772 return get_irn_n(node, 1);
776 set_Call_ptr (ir_node *node, ir_node *ptr) {
777 assert (node->op == op_Call);
778 set_irn_n(node, 1, ptr);
782 get_Call_param_arr (ir_node *node) {
783 assert (node->op == op_Call);
784 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
788 get_Call_n_params (ir_node *node) {
789 assert (node->op == op_Call);
790 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
794 get_Call_arity (ir_node *node) {
795 return get_Call_n_params(node);
799 set_Call_arity (ir_node *node, ir_node *arity) {
800 assert (node->op == op_Call);
805 get_Call_param (ir_node *node, int pos) {
806 assert (node->op == op_Call);
807 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
811 set_Call_param (ir_node *node, int pos, ir_node *param) {
812 assert (node->op == op_Call);
813 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
817 get_Call_type (ir_node *node) {
818 assert (node->op == op_Call);
819 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
823 set_Call_type (ir_node *node, type *type) {
824 assert (node->op == op_Call);
825 assert (is_method_type(type));
826 node->attr.call.cld_tp = type;
829 /* For unary and binary arithmetic operations the access to the
830 operands can be factored out. Left is the first, right the
831 second arithmetic value as listed in tech report 0999-33.
832 unops are: Minus, Abs, Not, Conv
833 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
834 Shr, Shrs, Rotate, Cmp */
837 is_unop (ir_node *node) {
838 return ( node->op == op_Minus ||
839 node->op == op_Abs ||
840 node->op == op_Not ||
841 node->op == op_Conv );
845 get_unop_op (ir_node *node) {
846 assert ( node->op == op_Minus ||
847 node->op == op_Abs ||
848 node->op == op_Not ||
849 node->op == op_Conv );
850 switch (get_irn_opcode (node)) {
851 case iro_Minus: return get_Minus_op(node); break;
852 case iro_Abs: return get_Abs_op(node); break;
853 case iro_Not: return get_Not_op(node); break;
854 case iro_Conv: return get_Conv_op(node); break;
855 default: return NULL;
860 set_unop_op (ir_node *node, ir_node *op) {
861 assert (node->op == op_Minus ||
862 node->op == op_Abs ||
863 node->op == op_Not ||
864 node->op == op_Conv );
865 switch (get_irn_opcode (node)) {
866 case iro_Minus: set_Minus_op(node, op); break;
867 case iro_Abs: set_Abs_op(node, op); break;
868 case iro_Not: set_Not_op(node, op); break;
869 case iro_Conv: set_Conv_op(node, op); break;
876 is_binop (ir_node *node) {
877 return (node->op == op_Add ||
878 node->op == op_Sub ||
879 node->op == op_Mul ||
880 node->op == op_Quot ||
881 node->op == op_DivMod ||
882 node->op == op_Div ||
883 node->op == op_Mod ||
884 node->op == op_And ||
886 node->op == op_Eor ||
887 node->op == op_Shl ||
888 node->op == op_Shr ||
889 node->op == op_Shrs ||
890 node->op == op_Rot ||
891 node->op == op_Cmp );
895 get_binop_left (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_left(node); break;
914 case iro_Sub : return get_Sub_left(node); break;
915 case iro_Mul : return get_Mul_left(node); break;
916 case iro_Quot : return get_Quot_left(node); break;
917 case iro_DivMod: return get_DivMod_left(node); break;
918 case iro_Div : return get_Div_left(node); break;
919 case iro_Mod : return get_Mod_left(node); break;
920 case iro_And : return get_And_left(node); break;
921 case iro_Or : return get_Or_left(node); break;
922 case iro_Eor : return get_Eor_left(node); break;
923 case iro_Shl : return get_Shl_left(node); break;
924 case iro_Shr : return get_Shr_left(node); break;
925 case iro_Shrs : return get_Shrs_left(node); break;
926 case iro_Rot : return get_Rot_left(node); break;
927 case iro_Cmp : return get_Cmp_left(node); break;
928 default: return NULL;
933 set_binop_left (ir_node *node, ir_node *left) {
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_left(node, left); break;
952 case iro_Sub : set_Sub_left(node, left); break;
953 case iro_Mul : set_Mul_left(node, left); break;
954 case iro_Quot : set_Quot_left(node, left); break;
955 case iro_DivMod: set_DivMod_left(node, left); break;
956 case iro_Div : set_Div_left(node, left); break;
957 case iro_Mod : set_Mod_left(node, left); break;
958 case iro_And : set_And_left(node, left); break;
959 case iro_Or : set_Or_left(node, left); break;
960 case iro_Eor : set_Eor_left(node, left); break;
961 case iro_Shl : set_Shl_left(node, left); break;
962 case iro_Shr : set_Shr_left(node, left); break;
963 case iro_Shrs : set_Shrs_left(node, left); break;
964 case iro_Rot : set_Rot_left(node, left); break;
965 case iro_Cmp : set_Cmp_left(node, left); break;
971 get_binop_right (ir_node *node) {
972 assert (node->op == op_Add ||
973 node->op == op_Sub ||
974 node->op == op_Mul ||
975 node->op == op_Quot ||
976 node->op == op_DivMod ||
977 node->op == op_Div ||
978 node->op == op_Mod ||
979 node->op == op_And ||
981 node->op == op_Eor ||
982 node->op == op_Shl ||
983 node->op == op_Shr ||
984 node->op == op_Shrs ||
985 node->op == op_Rot ||
986 node->op == op_Cmp );
988 switch (get_irn_opcode (node)) {
989 case iro_Add : return get_Add_right(node); break;
990 case iro_Sub : return get_Sub_right(node); break;
991 case iro_Mul : return get_Mul_right(node); break;
992 case iro_Quot : return get_Quot_right(node); break;
993 case iro_DivMod: return get_DivMod_right(node); break;
994 case iro_Div : return get_Div_right(node); break;
995 case iro_Mod : return get_Mod_right(node); break;
996 case iro_And : return get_And_right(node); break;
997 case iro_Or : return get_Or_right(node); break;
998 case iro_Eor : return get_Eor_right(node); break;
999 case iro_Shl : return get_Shl_right(node); break;
1000 case iro_Shr : return get_Shr_right(node); break;
1001 case iro_Shrs : return get_Shrs_right(node); break;
1002 case iro_Rot : return get_Rot_right(node); break;
1003 case iro_Cmp : return get_Cmp_right(node); break;
1004 default: return NULL;
1009 set_binop_right (ir_node *node, ir_node *right) {
1010 assert (node->op == op_Add ||
1011 node->op == op_Sub ||
1012 node->op == op_Mul ||
1013 node->op == op_Quot ||
1014 node->op == op_DivMod ||
1015 node->op == op_Div ||
1016 node->op == op_Mod ||
1017 node->op == op_And ||
1018 node->op == op_Or ||
1019 node->op == op_Eor ||
1020 node->op == op_Shl ||
1021 node->op == op_Shr ||
1022 node->op == op_Shrs ||
1023 node->op == op_Rot ||
1024 node->op == op_Cmp );
1026 switch (get_irn_opcode (node)) {
1027 case iro_Add : set_Add_right(node, right); break;
1028 case iro_Sub : set_Sub_right(node, right); break;
1029 case iro_Mul : set_Mul_right(node, right); break;
1030 case iro_Quot : set_Quot_right(node, right); break;
1031 case iro_DivMod: set_DivMod_right(node, right); break;
1032 case iro_Div : set_Div_right(node, right); break;
1033 case iro_Mod : set_Mod_right(node, right); break;
1034 case iro_And : set_And_right(node, right); break;
1035 case iro_Or : set_Or_right(node, right); break;
1036 case iro_Eor : set_Eor_right(node, right); break;
1037 case iro_Shl : set_Shl_right(node, right); break;
1038 case iro_Shr : set_Shr_right(node, right); break;
1039 case iro_Shrs : set_Shrs_right(node, right); break;
1040 case iro_Rot : set_Rot_right(node, right); break;
1041 case iro_Cmp : set_Cmp_right(node, right); break;
1047 get_Add_left (ir_node *node) {
1048 assert (node->op == op_Add);
1049 return get_irn_n(node, 0);
1053 set_Add_left (ir_node *node, ir_node *left) {
1054 assert (node->op == op_Add);
1055 set_irn_n(node, 0, left);
1059 get_Add_right (ir_node *node) {
1060 assert (node->op == op_Add);
1061 return get_irn_n(node, 1);
1065 set_Add_right (ir_node *node, ir_node *right) {
1066 assert (node->op == op_Add);
1067 set_irn_n(node, 1, right);
1071 get_Sub_left (ir_node *node) {
1072 assert (node->op == op_Sub);
1073 return get_irn_n(node, 0);
1077 set_Sub_left (ir_node *node, ir_node *left) {
1078 assert (node->op == op_Sub);
1079 set_irn_n(node, 0, left);
1083 get_Sub_right (ir_node *node) {
1084 assert (node->op == op_Sub);
1085 return get_irn_n(node, 1);
1089 set_Sub_right (ir_node *node, ir_node *right) {
1090 assert (node->op == op_Sub);
1091 set_irn_n(node, 1, right);
1096 get_Minus_op (ir_node *node) {
1097 assert (node->op == op_Minus);
1098 return get_irn_n(node, 0);
1102 set_Minus_op (ir_node *node, ir_node *op) {
1103 assert (node->op == op_Minus);
1104 set_irn_n(node, 0, op);
1109 get_Mul_left (ir_node *node) {
1110 assert (node->op == op_Mul);
1111 return get_irn_n(node, 0);
1115 set_Mul_left (ir_node *node, ir_node *left) {
1116 assert (node->op == op_Mul);
1117 set_irn_n(node, 0, left);
1121 get_Mul_right (ir_node *node) {
1122 assert (node->op == op_Mul);
1123 return get_irn_n(node, 1);
1127 set_Mul_right (ir_node *node, ir_node *right) {
1128 assert (node->op == op_Mul);
1129 set_irn_n(node, 1, right);
1133 get_Quot_left (ir_node *node) {
1134 assert (node->op == op_Quot);
1135 return get_irn_n(node, 1);
1139 set_Quot_left (ir_node *node, ir_node *left) {
1140 assert (node->op == op_Quot);
1141 set_irn_n(node, 1, left);
1145 get_Quot_right (ir_node *node) {
1146 assert (node->op == op_Quot);
1147 return get_irn_n(node, 2);
1151 set_Quot_right (ir_node *node, ir_node *right) {
1152 assert (node->op == op_Quot);
1153 set_irn_n(node, 2, right);
1157 get_Quot_mem (ir_node *node) {
1158 assert (node->op == op_Quot);
1159 return get_irn_n(node, 0);
1163 set_Quot_mem (ir_node *node, ir_node *mem) {
1164 assert (node->op == op_Quot);
1165 set_irn_n(node, 0, mem);
1169 get_DivMod_left (ir_node *node) {
1170 assert (node->op == op_DivMod);
1171 return get_irn_n(node, 1);
1175 set_DivMod_left (ir_node *node, ir_node *left) {
1176 assert (node->op == op_DivMod);
1177 set_irn_n(node, 1, left);
1181 get_DivMod_right (ir_node *node) {
1182 assert (node->op == op_DivMod);
1183 return get_irn_n(node, 2);
1187 set_DivMod_right (ir_node *node, ir_node *right) {
1188 assert (node->op == op_DivMod);
1189 set_irn_n(node, 2, right);
1193 get_DivMod_mem (ir_node *node) {
1194 assert (node->op == op_DivMod);
1195 return get_irn_n(node, 0);
1199 set_DivMod_mem (ir_node *node, ir_node *mem) {
1200 assert (node->op == op_DivMod);
1201 set_irn_n(node, 0, mem);
1205 get_Div_left (ir_node *node) {
1206 assert (node->op == op_Div);
1207 return get_irn_n(node, 1);
1211 set_Div_left (ir_node *node, ir_node *left) {
1212 assert (node->op == op_Div);
1213 set_irn_n(node, 1, left);
1217 get_Div_right (ir_node *node) {
1218 assert (node->op == op_Div);
1219 return get_irn_n(node, 2);
1223 set_Div_right (ir_node *node, ir_node *right) {
1224 assert (node->op == op_Div);
1225 set_irn_n(node, 2, right);
1229 get_Div_mem (ir_node *node) {
1230 assert (node->op == op_Div);
1231 return get_irn_n(node, 0);
1235 set_Div_mem (ir_node *node, ir_node *mem) {
1236 assert (node->op == op_Div);
1237 set_irn_n(node, 0, mem);
1241 get_Mod_left (ir_node *node) {
1242 assert (node->op == op_Mod);
1243 return get_irn_n(node, 1);
1247 set_Mod_left (ir_node *node, ir_node *left) {
1248 assert (node->op == op_Mod);
1249 set_irn_n(node, 1, left);
1253 get_Mod_right (ir_node *node) {
1254 assert (node->op == op_Mod);
1255 return get_irn_n(node, 2);
1259 set_Mod_right (ir_node *node, ir_node *right) {
1260 assert (node->op == op_Mod);
1261 set_irn_n(node, 2, right);
1265 get_Mod_mem (ir_node *node) {
1266 assert (node->op == op_Mod);
1267 return get_irn_n(node, 0);
1271 set_Mod_mem (ir_node *node, ir_node *mem) {
1272 assert (node->op == op_Mod);
1273 set_irn_n(node, 0, mem);
1277 get_Abs_op (ir_node *node) {
1278 assert (node->op == op_Abs);
1279 return get_irn_n(node, 0);
1283 set_Abs_op (ir_node *node, ir_node *op) {
1284 assert (node->op == op_Abs);
1285 set_irn_n(node, 0, op);
1289 get_And_left (ir_node *node) {
1290 assert (node->op == op_And);
1291 return get_irn_n(node, 0);
1295 set_And_left (ir_node *node, ir_node *left) {
1296 assert (node->op == op_And);
1297 set_irn_n(node, 0, left);
1301 get_And_right (ir_node *node) {
1302 assert (node->op == op_And);
1303 return get_irn_n(node, 1);
1307 set_And_right (ir_node *node, ir_node *right) {
1308 assert (node->op == op_And);
1309 set_irn_n(node, 1, right);
1313 get_Or_left (ir_node *node) {
1314 assert (node->op == op_Or);
1315 return get_irn_n(node, 0);
1319 set_Or_left (ir_node *node, ir_node *left) {
1320 assert (node->op == op_Or);
1321 set_irn_n(node, 0, left);
1325 get_Or_right (ir_node *node) {
1326 assert (node->op == op_Or);
1327 return get_irn_n(node, 1);
1331 set_Or_right (ir_node *node, ir_node *right) {
1332 assert (node->op == op_Or);
1333 set_irn_n(node, 1, right);
1337 get_Eor_left (ir_node *node) {
1338 assert (node->op == op_Eor);
1339 return get_irn_n(node, 0);
1343 set_Eor_left (ir_node *node, ir_node *left) {
1344 assert (node->op == op_Eor);
1345 set_irn_n(node, 0, left);
1349 get_Eor_right (ir_node *node) {
1350 assert (node->op == op_Eor);
1351 return get_irn_n(node, 1);
1355 set_Eor_right (ir_node *node, ir_node *right) {
1356 assert (node->op == op_Eor);
1357 set_irn_n(node, 1, right);
1362 get_Not_op (ir_node *node) {
1363 assert (node->op == op_Not);
1364 return get_irn_n(node, 0);
1368 set_Not_op (ir_node *node, ir_node *op) {
1369 assert (node->op == op_Not);
1370 set_irn_n(node, 0, op);
1375 get_Shl_left (ir_node *node) {
1376 assert (node->op == op_Shl);
1377 return get_irn_n(node, 0);
1381 set_Shl_left (ir_node *node, ir_node *left) {
1382 assert (node->op == op_Shl);
1383 set_irn_n(node, 0, left);
1387 get_Shl_right (ir_node *node) {
1388 assert (node->op == op_Shl);
1389 return get_irn_n(node, 1);
1393 set_Shl_right (ir_node *node, ir_node *right) {
1394 assert (node->op == op_Shl);
1395 set_irn_n(node, 1, right);
1399 get_Shr_left (ir_node *node) {
1400 assert (node->op == op_Shr);
1401 return get_irn_n(node, 0);
1405 set_Shr_left (ir_node *node, ir_node *left) {
1406 assert (node->op == op_Shr);
1407 set_irn_n(node, 0, left);
1411 get_Shr_right (ir_node *node) {
1412 assert (node->op == op_Shr);
1413 return get_irn_n(node, 1);
1417 set_Shr_right (ir_node *node, ir_node *right) {
1418 assert (node->op == op_Shr);
1419 set_irn_n(node, 1, right);
1423 get_Shrs_left (ir_node *node) {
1424 assert (node->op == op_Shrs);
1425 return get_irn_n(node, 0);
1429 set_Shrs_left (ir_node *node, ir_node *left) {
1430 assert (node->op == op_Shrs);
1431 set_irn_n(node, 0, left);
1435 get_Shrs_right (ir_node *node) {
1436 assert (node->op == op_Shrs);
1437 return get_irn_n(node, 1);
1441 set_Shrs_right (ir_node *node, ir_node *right) {
1442 assert (node->op == op_Shrs);
1443 set_irn_n(node, 1, right);
1447 get_Rot_left (ir_node *node) {
1448 assert (node->op == op_Rot);
1449 return get_irn_n(node, 0);
1453 set_Rot_left (ir_node *node, ir_node *left) {
1454 assert (node->op == op_Rot);
1455 set_irn_n(node, 0, left);
1459 get_Rot_right (ir_node *node) {
1460 assert (node->op == op_Rot);
1461 return get_irn_n(node, 1);
1465 set_Rot_right (ir_node *node, ir_node *right) {
1466 assert (node->op == op_Rot);
1467 set_irn_n(node, 1, right);
1471 get_Cmp_left (ir_node *node) {
1472 assert (node->op == op_Cmp);
1473 return get_irn_n(node, 0);
1477 set_Cmp_left (ir_node *node, ir_node *left) {
1478 assert (node->op == op_Cmp);
1479 set_irn_n(node, 0, left);
1483 get_Cmp_right (ir_node *node) {
1484 assert (node->op == op_Cmp);
1485 return get_irn_n(node, 1);
1489 set_Cmp_right (ir_node *node, ir_node *right) {
1490 assert (node->op == op_Cmp);
1491 set_irn_n(node, 1, right);
1495 get_Conv_op (ir_node *node) {
1496 assert (node->op == op_Conv);
1497 return get_irn_n(node, 0);
1501 set_Conv_op (ir_node *node, ir_node *op) {
1502 assert (node->op == op_Conv);
1503 set_irn_n(node, 0, op);
1507 get_Phi_preds_arr (ir_node *node) {
1508 assert (node->op == op_Phi);
1509 return (ir_node **)&(get_irn_in(node)[1]);
1513 get_Phi_n_preds (ir_node *node) {
1514 assert (node->op == op_Phi);
1515 return (get_irn_arity(node));
1519 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1520 assert (node->op == op_Phi);
1525 get_Phi_pred (ir_node *node, int pos) {
1526 assert (node->op == op_Phi);
1527 return get_irn_n(node, pos);
1531 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1532 assert (node->op == op_Phi);
1533 set_irn_n(node, pos, pred);
1537 get_Load_mem (ir_node *node) {
1538 assert (node->op == op_Load);
1539 return get_irn_n(node, 0);
1543 set_Load_mem (ir_node *node, ir_node *mem) {
1544 assert (node->op == op_Load);
1545 set_irn_n(node, 0, mem);
1549 get_Load_ptr (ir_node *node) {
1550 assert (node->op == op_Load);
1551 return get_irn_n(node, 1);
1555 set_Load_ptr (ir_node *node, ir_node *ptr) {
1556 assert (node->op == op_Load);
1557 set_irn_n(node, 1, ptr);
1562 get_Store_mem (ir_node *node) {
1563 assert (node->op == op_Store);
1564 return get_irn_n(node, 0);
1568 set_Store_mem (ir_node *node, ir_node *mem) {
1569 assert (node->op == op_Store);
1570 set_irn_n(node, 0, mem);
1574 get_Store_ptr (ir_node *node) {
1575 assert (node->op == op_Store);
1576 return get_irn_n(node, 1);
1580 set_Store_ptr (ir_node *node, ir_node *ptr) {
1581 assert (node->op == op_Store);
1582 set_irn_n(node, 1, ptr);
1586 get_Store_value (ir_node *node) {
1587 assert (node->op == op_Store);
1588 return get_irn_n(node, 2);
1592 set_Store_value (ir_node *node, ir_node *value) {
1593 assert (node->op == op_Store);
1594 set_irn_n(node, 2, value);
1598 get_Alloc_mem (ir_node *node) {
1599 assert (node->op == op_Alloc);
1600 return get_irn_n(node, 0);
1604 set_Alloc_mem (ir_node *node, ir_node *mem) {
1605 assert (node->op == op_Alloc);
1606 set_irn_n(node, 0, mem);
1610 get_Alloc_size (ir_node *node) {
1611 assert (node->op == op_Alloc);
1612 return get_irn_n(node, 1);
1616 set_Alloc_size (ir_node *node, ir_node *size) {
1617 assert (node->op == op_Alloc);
1618 set_irn_n(node, 1, size);
1622 get_Alloc_type (ir_node *node) {
1623 assert (node->op == op_Alloc);
1624 return node->attr.a.type = skip_tid(node->attr.a.type);
1628 set_Alloc_type (ir_node *node, type *type) {
1629 assert (node->op == op_Alloc);
1630 node->attr.a.type = type;
1634 get_Alloc_where (ir_node *node) {
1635 assert (node->op == op_Alloc);
1636 return node->attr.a.where;
1640 set_Alloc_where (ir_node *node, where_alloc where) {
1641 assert (node->op == op_Alloc);
1642 node->attr.a.where = where;
1647 get_Free_mem (ir_node *node) {
1648 assert (node->op == op_Free);
1649 return get_irn_n(node, 0);
1653 set_Free_mem (ir_node *node, ir_node *mem) {
1654 assert (node->op == op_Free);
1655 set_irn_n(node, 0, mem);
1659 get_Free_ptr (ir_node *node) {
1660 assert (node->op == op_Free);
1661 return get_irn_n(node, 1);
1665 set_Free_ptr (ir_node *node, ir_node *ptr) {
1666 assert (node->op == op_Free);
1667 set_irn_n(node, 1, ptr);
1671 get_Free_size (ir_node *node) {
1672 assert (node->op == op_Free);
1673 return get_irn_n(node, 2);
1677 set_Free_size (ir_node *node, ir_node *size) {
1678 assert (node->op == op_Free);
1679 set_irn_n(node, 2, size);
1683 get_Free_type (ir_node *node) {
1684 assert (node->op == op_Free);
1685 return node->attr.f = skip_tid(node->attr.f);
1689 set_Free_type (ir_node *node, type *type) {
1690 assert (node->op == op_Free);
1691 node->attr.f = type;
1695 get_Sync_preds_arr (ir_node *node) {
1696 assert (node->op == op_Sync);
1697 return (ir_node **)&(get_irn_in(node)[1]);
1701 get_Sync_n_preds (ir_node *node) {
1702 assert (node->op == op_Sync);
1703 return (get_irn_arity(node));
1708 set_Sync_n_preds (ir_node *node, int n_preds) {
1709 assert (node->op == op_Sync);
1714 get_Sync_pred (ir_node *node, int pos) {
1715 assert (node->op == op_Sync);
1716 return get_irn_n(node, pos);
1720 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1721 assert (node->op == op_Sync);
1722 set_irn_n(node, pos, pred);
1726 get_Proj_pred (ir_node *node) {
1727 assert (node->op == op_Proj);
1728 return get_irn_n(node, 0);
1732 set_Proj_pred (ir_node *node, ir_node *pred) {
1733 assert (node->op == op_Proj);
1734 set_irn_n(node, 0, pred);
1738 get_Proj_proj (ir_node *node) {
1739 assert (node->op == op_Proj);
1740 return node->attr.proj;
1744 set_Proj_proj (ir_node *node, long proj) {
1745 assert (node->op == op_Proj);
1746 node->attr.proj = proj;
1750 get_Tuple_preds_arr (ir_node *node) {
1751 assert (node->op == op_Tuple);
1752 return (ir_node **)&(get_irn_in(node)[1]);
1756 get_Tuple_n_preds (ir_node *node) {
1757 assert (node->op == op_Tuple);
1758 return (get_irn_arity(node));
1763 set_Tuple_n_preds (ir_node *node, int n_preds) {
1764 assert (node->op == op_Tuple);
1769 get_Tuple_pred (ir_node *node, int pos) {
1770 assert (node->op == op_Tuple);
1771 return get_irn_n(node, pos);
1775 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1776 assert (node->op == op_Tuple);
1777 set_irn_n(node, pos, pred);
1781 get_Id_pred (ir_node *node) {
1782 assert (node->op == op_Id);
1783 return get_irn_n(node, 0);
1787 set_Id_pred (ir_node *node, ir_node *pred) {
1788 assert (node->op == op_Id);
1789 set_irn_n(node, 0, pred);
1792 /******************************************************************/
1793 /* Auxiliary routines */
1794 /******************************************************************/
1797 skip_Proj (ir_node *node) {
1798 /* don't assert node !!! */
1799 if (node && (node->op == op_Proj)) {
1800 return get_Proj_pred(node);
1807 skip_Tuple (ir_node *node) {
1808 if ((node->op == op_Proj) && (get_irn_op(get_Proj_pred(node)) == op_Tuple))
1809 return get_Tuple_pred(get_Proj_pred(node), get_Proj_proj(node));
1815 skip_nop (ir_node *node) {
1816 /* don't assert node !!! */
1818 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1819 /* Don't use get_Id_pred: We get into an endless loop for
1820 self-referencing Ids. */
1821 assert (get_irn_arity (node) > 0);
1822 return node->in[0+1];
1829 skip_Id (ir_node *node) {
1830 return skip_nop(node);
1834 is_Bad (ir_node *node) {
1836 if ((node) && get_irn_opcode(node) == iro_Bad)
1842 is_no_Block (ir_node *node) {
1844 return (get_irn_opcode(node) != iro_Block);
1847 /* Returns true if the operation manipulates control flow. */
1849 is_cfop(ir_node *node) {
1850 return is_cfopcode(get_irn_op(node));
1853 /* Returns true if the operation can change the control flow because
1856 is_fragile_op(ir_node *node) {
1857 return ( (get_irn_opcode(node) == iro_Call)
1858 || (get_irn_opcode(node) == iro_Quot)
1859 || (get_irn_opcode(node) == iro_DivMod)
1860 || (get_irn_opcode(node) == iro_Div)
1861 || (get_irn_opcode(node) == iro_Mod)
1862 || (get_irn_opcode(node) == iro_Load)
1863 || (get_irn_opcode(node) == iro_Store)
1864 || (get_irn_opcode(node) == iro_Alloc)
1865 || (get_irn_opcode(node) == iro_Bad));
1869 /* Returns the memory operand of fragile operations. */
1870 ir_node *get_fragile_op_mem(ir_node *node) {
1871 assert(node && is_fragile_op(node));
1873 switch (get_irn_opcode (node)) {
1882 return get_irn_n(node, 0);