1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
13 #include "irgraph_t.h"
22 /* some constants fixing the positions of nodes predecessors
24 #define CALL_PARAM_OFFSET 2
25 #define SEL_INDEX_OFFSET 2
26 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
28 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
29 "Gt", "Ge", "Lg", "Leg", "Uo",
30 "Ue", "Ul", "Ule", "Ug", "Uge",
33 inline char *get_pnc_string(int pnc) {
34 return pnc_name_arr[pnc];
39 get_negated_pnc(int pnc) {
41 case False: return True; break;
42 case Eq: return Ne; break;
43 case Lt: return Uge; break;
44 case Le: return Ug; break;
45 case Gt: return Ule; break;
46 case Ge: return Ul; break;
47 case Lg: return Ue; break;
48 case Leg: return Uo; break;
49 case Uo: return Leg; break;
50 case Ue: return Lg; break;
51 case Ul: return Ge; break;
52 case Ule: return Gt; break;
53 case Ug: return Le; break;
54 case Uge: return Lt; break;
55 case Ne: return Eq; break;
56 case True: return False; break;
58 return 99; /* to shut up gcc */
61 static char *pns_name_arr [] = {"initial_exec", "global_store",
62 "frame_base", "globals", "args"};
64 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
71 /* irnode constructor */
72 /* create a new irnode in irg, with an op, mode, arity and */
73 /* some incoming irnodes */
74 /* this constructor is used in every specified irnode constructor */
76 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
77 int arity, ir_node **in)
80 int node_size = offsetof (ir_node, attr) + op->attr_size;
82 res = (ir_node *) obstack_alloc (irg->obst, node_size);
84 res->kind = k_ir_node;
90 res->in = NEW_ARR_F (ir_node *, 1);
92 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
93 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
98 res->node_nr = get_irp_new_node_nr();
104 /* Copies all attributes stored in the old node to the new node.
105 Assumes both have the same opcode and sufficient size. */
107 copy_attrs (ir_node *old, ir_node *new) {
108 assert (get_irn_opcode(old) == get_irn_opcode(new));
109 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
112 /* IR-Nodes with attributes */
114 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
117 ir_node *np = XP_GETARG (ir_node *, 0);
120 XPS ("<null ir_node>");
124 XPF1 ("%I", get_irn_opident(np));
126 switch (get_irn_opcode (np)) { /* node label */
128 XPF1 ("%I", get_irn_mode(np)->name);
130 XPF1 ("%v", get_irn_const_attr);
133 if (get_irn_modecode (np) == irm_b) {
135 XP (pnc_name_arr[get_irn_proj_attr(np)]);
136 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
138 XP (pns_name_arr[get_irn_proj_attr(np)]);
140 XPF1 ("%I", get_irn_mode(np)->name);
142 XPF1 ("%d", get_irn_proj_attr(np));
146 XPF1 ("%I", get_irn_mode(np)->name);
148 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
149 XPF1 (" %#N", get_type_nameid(get_SymConst_type(np)));
151 case iro_Start: /* don't dump mode of these */
160 XPF1 ("%I", get_irn_mode(np)->name);
166 /** getting some parameters from ir_nodes **/
168 /* returns the number of predecessors without the block predecessor. */
170 get_irn_arity (ir_node *node)
173 return (ARR_LEN((node)->in)-1);
176 /* Returns the array with ins. This array is shifted with respect to the
177 array accessed by get_irn_n: The block operand is at position 0 not -1.
178 (@@@ This should be changed.)
179 The order of the predecessors in this array is not guaranteed, except that
180 lists of operands as predecessors of Block or arguments of a Call are
183 get_irn_in (ir_node *node)
189 /* to iterate through the predecessors without touching the array */
190 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
191 to iterate includind the Block predecessor iterate from i = -1 to
193 If it is a block, the entry -1 is NULL. */
195 get_irn_n (ir_node *node, int n)
198 assert (get_irn_arity (node) > n);
199 return skip_nop(node->in[n+1]);
203 set_irn_n (ir_node *node, int n, ir_node *in)
206 assert (get_irn_arity (node) > n);
211 get_irn_mode (ir_node *node)
218 get_irn_modecode (ir_node *node)
221 return node->mode->code;
226 get_irn_modeident (ir_node *node)
229 return node->mode->name;
233 get_irn_op (ir_node *node)
239 /* should be private to the library: */
241 set_irn_op (ir_node *node, ir_op *op)
248 get_irn_opcode (ir_node *node)
251 return node->op->code;
255 get_irn_opname (ir_node *node)
258 return id_to_str(node->op->name);
262 get_irn_opident (ir_node *node)
265 return node->op->name;
269 get_irn_visited (ir_node *node)
272 return node->visited;
276 set_irn_visited (ir_node *node, unsigned long visited)
279 node->visited = visited;
282 set_irn_link (ir_node *node, ir_node *link) {
288 get_irn_link (ir_node *node) {
294 /* Outputs a unique number for this node */
296 get_irn_node_nr(ir_node *node) {
298 return node->node_nr;
303 get_irn_const_attr (ir_node *node)
305 assert (node->op == op_Const);
306 return node->attr.con;
310 get_irn_proj_attr (ir_node *node)
312 assert (node->op == op_Proj);
313 return node->attr.proj;
317 get_irn_alloc_attr (ir_node *node)
319 assert (node->op == op_Alloc);
324 get_irn_free_attr (ir_node *node)
326 assert (node->op == op_Free);
331 get_irn_symconst_attr (ir_node *node)
333 assert (node->op == op_SymConst);
338 get_irn_call_attr (ir_node *node)
340 assert (node->op == op_Call);
341 return node->attr.call;
345 get_irn_sel_attr (ir_node *node)
347 assert (node->op == op_Sel);
352 get_irn_phi_attr (ir_node *node)
354 assert (node->op == op_Phi);
355 return node->attr.phi0_pos;
359 get_irn_block_attr (ir_node *node)
361 assert (node->op == op_Block);
362 return node->attr.block;
365 /** manipulate fields of individual nodes **/
367 /* this works for all except Block */
369 get_nodes_Block (ir_node *node) {
370 assert (!(node->op == op_Block));
371 return get_irn_n(node, -1);
375 set_nodes_Block (ir_node *node, ir_node *block) {
376 assert (!(node->op == op_Block));
377 set_irn_n(node, -1, block);
380 /* Returns an array with the predecessors of the Block. Depending on
381 the implementation of the graph datastructure this can be a copy of
382 the internal representation of predecessors as well as the internal
383 array itself. Therefore writing to this array might obstruct the ir. */
385 get_Block_cfgpred_arr (ir_node *node)
387 assert ((node->op == op_Block));
388 return (ir_node **)&(get_irn_in(node)[1]);
393 get_Block_n_cfgpreds (ir_node *node) {
394 assert ((node->op == op_Block));
395 return (get_irn_arity(node));
400 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
401 assert ((node->op == op_Block));
406 get_Block_cfgpred (ir_node *node, int pos) {
407 assert (node->op == op_Block);
408 return get_irn_n(node, pos);
412 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
413 assert (node->op == op_Block);
414 set_irn_n(node, pos, pred);
418 get_Block_matured (ir_node *node) {
419 assert (node->op == op_Block);
420 return node->attr.block.matured;
424 set_Block_matured (ir_node *node, bool matured) {
425 assert (node->op == op_Block);
426 node->attr.block.matured = matured;
429 get_Block_block_visited (ir_node *node) {
430 assert (node->op == op_Block);
431 return node->attr.block.block_visited;
435 set_Block_block_visited (ir_node *node, unsigned long visit) {
436 assert (node->op == op_Block);
437 node->attr.block.block_visited = visit;
441 get_Block_graph_arr (ir_node *node, int pos) {
442 assert (node->op == op_Block);
443 return node->attr.block.graph_arr[pos+1];
447 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
448 assert (node->op == op_Block);
449 node->attr.block.graph_arr[pos+1] = value;
452 > Implementing the case construct (which is where the constant Proj node is
453 > important) involves far more than simply determining the constant values.
454 > We could argue that this is more properly a function of the translator from
455 > Firm to the target machine. That could be done if there was some way of
456 > projecting "default" out of the Cond node.
457 I know it's complicated.
458 Basically there are two proglems:
459 - determining the gaps between the projs
460 - determining the biggest case constant to konw the proj number for
462 I see several solutions:
463 1. Introduce a ProjDefault node. Solves both problems.
464 This means to extend all optimizations executed during construction.
465 2. Give the Cond node for switch two flavors:
466 a) there are no gaps in the projs (existing flavor)
467 b) gaps may exist, default proj is still the Proj with the largest
468 projection number. This covers also the gaps.
469 3. Fix the semantic of the Cond to that of 2b)
471 Solution 2 seems to be the best:
472 Computing the gaps in the Firm representation is not too hard, i.e.,
473 libfirm can implement a routine that transforms betweeen the two
474 flavours. This is also possible for 1) but 2) does not require to
475 change any existing optimization.
476 Further it should be far simpler to determine the biggest constant than
478 I don't want to choose 3) as 2a) seems to have advantages for
479 dataflow analysis and 3) does not allow to convert the representation to
483 get_Cond_selector (ir_node *node) {
484 assert (node->op == op_Cond);
485 return get_irn_n(node, 0);
489 set_Cond_selector (ir_node *node, ir_node *selector) {
490 assert (node->op == op_Cond);
491 set_irn_n(node, 0, selector);
495 get_Cond_kind (ir_node *node) {
496 assert (node->op == op_Cond);
497 return node->attr.c.kind;
501 set_Cond_kind (ir_node *node, cond_kind kind) {
502 assert (node->op == op_Cond);
503 node->attr.c.kind = kind;
507 get_Return_mem (ir_node *node) {
508 assert (node->op == op_Return);
509 return get_irn_n(node, 0);
513 set_Return_mem (ir_node *node, ir_node *mem) {
514 assert (node->op == op_Return);
515 set_irn_n(node, 0, mem);
519 get_Return_res_arr (ir_node *node)
521 assert ((node->op == op_Return));
522 if (get_Return_n_res(node) > 0)
523 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
529 get_Return_n_res (ir_node *node) {
530 assert (node->op == op_Return);
531 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
536 set_Return_n_res (ir_node *node, int results) {
537 assert (node->op == op_Return);
542 get_Return_res (ir_node *node, int pos) {
543 assert (node->op == op_Return);
544 assert (get_Return_n_res(node) > pos);
545 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
549 set_Return_res (ir_node *node, int pos, ir_node *res){
550 assert (node->op == op_Return);
551 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
555 get_Raise_mem (ir_node *node) {
556 assert (node->op == op_Return);
557 return get_irn_n(node, 0);
561 set_Raise_mem (ir_node *node, ir_node *mem) {
562 assert (node->op == op_Raise);
563 set_irn_n(node, 0, mem);
567 get_Raise_exo_ptr (ir_node *node) {
568 assert (node->op == op_Raise);
569 return get_irn_n(node, 1);
573 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
574 assert (node->op == op_Raise);
575 set_irn_n(node, 1, exo_ptr);
578 inline tarval *get_Const_tarval (ir_node *node) {
579 assert (node->op == op_Const);
580 return get_irn_const_attr(node);
584 set_Const_tarval (ir_node *node, tarval *con) {
585 assert (node->op == op_Const);
586 node->attr.con = con;
590 get_SymConst_kind (ir_node *node) {
591 assert (node->op == op_SymConst);
592 return node->attr.i.num;
596 set_SymConst_kind (ir_node *node, symconst_kind num) {
597 assert (node->op == op_SymConst);
598 node->attr.i.num = num;
602 get_SymConst_type (ir_node *node) {
603 assert ( (node->op == op_SymConst)
604 && ( get_SymConst_kind(node) == type_tag
605 || get_SymConst_kind(node) == size));
606 return node->attr.i.tori.typ;
610 set_SymConst_type (ir_node *node, type *type) {
611 assert ( (node->op == op_SymConst)
612 && ( get_SymConst_kind(node) == type_tag
613 || get_SymConst_kind(node) == size));
614 node->attr.i.tori.typ = type;
618 get_SymConst_ptrinfo (ir_node *node) {
619 assert ( (node->op == op_SymConst)
620 && (get_SymConst_kind(node) == linkage_ptr_info));
621 return node->attr.i.tori.ptrinfo;
625 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
626 assert ( (node->op == op_SymConst)
627 && (get_SymConst_kind(node) == linkage_ptr_info));
628 node->attr.i.tori.ptrinfo = ptrinfo;
632 get_SymConst_type_or_id (ir_node *node) {
633 assert (node->op == op_SymConst);
634 return &(node->attr.i.tori);
638 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
639 assert (node->op == op_SymConst);
640 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
644 get_Sel_mem (ir_node *node) {
645 assert (node->op == op_Sel);
646 return get_irn_n(node, 0);
650 set_Sel_mem (ir_node *node, ir_node *mem) {
651 assert (node->op == op_Sel);
652 set_irn_n(node, 0, mem);
656 get_Sel_ptr (ir_node *node) {
657 assert (node->op == op_Sel);
658 return get_irn_n(node, 1);
662 set_Sel_ptr (ir_node *node, ir_node *ptr) {
663 assert (node->op == op_Sel);
664 set_irn_n(node, 1, ptr);
668 get_Sel_index_arr (ir_node *node)
670 assert ((node->op == op_Sel));
671 if (get_Sel_n_index(node) > 0)
672 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
678 get_Sel_n_index (ir_node *node) {
679 assert (node->op == op_Sel);
680 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
685 set_Sel_n_index (ir_node *node, int n_index) {
686 assert (node->op == op_Sel);
691 get_Sel_index (ir_node *node, int pos) {
692 assert (node->op == op_Sel);
693 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
697 set_Sel_index (ir_node *node, int pos, ir_node *index) {
698 assert (node->op == op_Sel);
699 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
703 get_Sel_entity (ir_node *node) {
704 assert (node->op == op_Sel);
705 return node->attr.s.ent;
709 set_Sel_entity (ir_node *node, entity *ent) {
710 assert (node->op == op_Sel);
711 node->attr.s.ent = ent;
715 get_Sel_linkage_type (ir_node *node) {
716 assert (node->op == op_Sel);
717 return node->attr.s.ltyp;
721 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
722 assert (node->op == op_Sel);
723 node->attr.s.ltyp = lt;
727 get_Call_mem (ir_node *node) {
728 assert (node->op == op_Call);
729 return get_irn_n(node, 0);
733 set_Call_mem (ir_node *node, ir_node *mem) {
734 assert (node->op == op_Call);
735 set_irn_n(node, 0, mem);
739 get_Call_ptr (ir_node *node) {
740 assert (node->op == op_Call);
741 return get_irn_n(node, 1);
745 set_Call_ptr (ir_node *node, ir_node *ptr) {
746 assert (node->op == op_Call);
747 set_irn_n(node, 1, ptr);
751 get_Call_param_arr (ir_node *node) {
752 assert (node->op == op_Call);
753 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
757 get_Call_n_params (ir_node *node) {
758 assert (node->op == op_Call);
759 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
763 get_Call_arity (ir_node *node) {
764 return get_Call_n_params(node);
768 set_Call_arity (ir_node *node, ir_node *arity) {
769 assert (node->op == op_Call);
774 get_Call_param (ir_node *node, int pos) {
775 assert (node->op == op_Call);
776 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
780 set_Call_param (ir_node *node, int pos, ir_node *param) {
781 assert (node->op == op_Call);
782 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
786 get_Call_type (ir_node *node) {
787 assert (node->op == op_Call);
788 return node->attr.call;
792 set_Call_type (ir_node *node, type *type) {
793 assert (node->op == op_Call);
794 assert (is_method_type(type));
795 node->attr.call = type;
798 /* For unary and binary arithmetic operations the access to the
799 operands can be factored out. Left is the first, right the
800 second arithmetic value as listed in tech report 0999-33.
801 unops are: Minus, Abs, Not, Conv
802 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
803 Shr, Shrs, Rotate, Cmp */
806 is_unop (ir_node *node) {
807 return ( node->op == op_Minus ||
808 node->op == op_Abs ||
809 node->op == op_Not ||
810 node->op == op_Conv );
814 get_unop_op (ir_node *node) {
815 assert ( node->op == op_Minus ||
816 node->op == op_Abs ||
817 node->op == op_Not ||
818 node->op == op_Conv );
819 switch (get_irn_opcode (node)) {
820 case iro_Minus: return get_Minus_op(node); break;
821 case iro_Abs: return get_Abs_op(node); break;
822 case iro_Not: return get_Not_op(node); break;
823 case iro_Conv: return get_Conv_op(node); break;
824 default: return NULL;
829 set_unop_op (ir_node *node, ir_node *op) {
830 assert (node->op == op_Minus ||
831 node->op == op_Abs ||
832 node->op == op_Not ||
833 node->op == op_Conv );
834 switch (get_irn_opcode (node)) {
835 case iro_Minus: set_Minus_op(node, op); break;
836 case iro_Abs: set_Abs_op(node, op); break;
837 case iro_Not: set_Not_op(node, op); break;
838 case iro_Conv: set_Conv_op(node, op); break;
845 is_binop (ir_node *node) {
846 return (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 );
864 get_binop_left (ir_node *node) {
865 assert (node->op == op_Add ||
866 node->op == op_Sub ||
867 node->op == op_Mul ||
868 node->op == op_Quot ||
869 node->op == op_DivMod ||
870 node->op == op_Div ||
871 node->op == op_Mod ||
872 node->op == op_And ||
874 node->op == op_Eor ||
875 node->op == op_Shl ||
876 node->op == op_Shr ||
877 node->op == op_Shrs ||
878 node->op == op_Rot ||
879 node->op == op_Cmp );
881 switch (get_irn_opcode (node)) {
882 case iro_Add : return get_Add_left(node); break;
883 case iro_Sub : return get_Sub_left(node); break;
884 case iro_Mul : return get_Mul_left(node); break;
885 case iro_Quot : return get_Quot_left(node); break;
886 case iro_DivMod: return get_DivMod_left(node); break;
887 case iro_Div : return get_Div_left(node); break;
888 case iro_Mod : return get_Mod_left(node); break;
889 case iro_And : return get_And_left(node); break;
890 case iro_Or : return get_Or_left(node); break;
891 case iro_Eor : return get_Eor_left(node); break;
892 case iro_Shl : return get_Shl_left(node); break;
893 case iro_Shr : return get_Shr_left(node); break;
894 case iro_Shrs : return get_Shrs_left(node); break;
895 case iro_Rot : return get_Rot_left(node); break;
896 case iro_Cmp : return get_Cmp_left(node); break;
897 default: return NULL;
902 set_binop_left (ir_node *node, ir_node *left) {
903 assert (node->op == op_Add ||
904 node->op == op_Sub ||
905 node->op == op_Mul ||
906 node->op == op_Quot ||
907 node->op == op_DivMod ||
908 node->op == op_Div ||
909 node->op == op_Mod ||
910 node->op == op_And ||
912 node->op == op_Eor ||
913 node->op == op_Shl ||
914 node->op == op_Shr ||
915 node->op == op_Shrs ||
916 node->op == op_Rot ||
917 node->op == op_Cmp );
919 switch (get_irn_opcode (node)) {
920 case iro_Add : set_Add_left(node, left); break;
921 case iro_Sub : set_Sub_left(node, left); break;
922 case iro_Mul : set_Mul_left(node, left); break;
923 case iro_Quot : set_Quot_left(node, left); break;
924 case iro_DivMod: set_DivMod_left(node, left); break;
925 case iro_Div : set_Div_left(node, left); break;
926 case iro_Mod : set_Mod_left(node, left); break;
927 case iro_And : set_And_left(node, left); break;
928 case iro_Or : set_Or_left(node, left); break;
929 case iro_Eor : set_Eor_left(node, left); break;
930 case iro_Shl : set_Shl_left(node, left); break;
931 case iro_Shr : set_Shr_left(node, left); break;
932 case iro_Shrs : set_Shrs_left(node, left); break;
933 case iro_Rot : set_Rot_left(node, left); break;
934 case iro_Cmp : set_Cmp_left(node, left); break;
940 get_binop_right (ir_node *node) {
941 assert (node->op == op_Add ||
942 node->op == op_Sub ||
943 node->op == op_Mul ||
944 node->op == op_Quot ||
945 node->op == op_DivMod ||
946 node->op == op_Div ||
947 node->op == op_Mod ||
948 node->op == op_And ||
950 node->op == op_Eor ||
951 node->op == op_Shl ||
952 node->op == op_Shr ||
953 node->op == op_Shrs ||
954 node->op == op_Rot ||
955 node->op == op_Cmp );
957 switch (get_irn_opcode (node)) {
958 case iro_Add : return get_Add_right(node); break;
959 case iro_Sub : return get_Sub_right(node); break;
960 case iro_Mul : return get_Mul_right(node); break;
961 case iro_Quot : return get_Quot_right(node); break;
962 case iro_DivMod: return get_DivMod_right(node); break;
963 case iro_Div : return get_Div_right(node); break;
964 case iro_Mod : return get_Mod_right(node); break;
965 case iro_And : return get_And_right(node); break;
966 case iro_Or : return get_Or_right(node); break;
967 case iro_Eor : return get_Eor_right(node); break;
968 case iro_Shl : return get_Shl_right(node); break;
969 case iro_Shr : return get_Shr_right(node); break;
970 case iro_Shrs : return get_Shrs_right(node); break;
971 case iro_Rot : return get_Rot_right(node); break;
972 case iro_Cmp : return get_Cmp_right(node); break;
973 default: return NULL;
978 set_binop_right (ir_node *node, ir_node *right) {
979 assert (node->op == op_Add ||
980 node->op == op_Sub ||
981 node->op == op_Mul ||
982 node->op == op_Quot ||
983 node->op == op_DivMod ||
984 node->op == op_Div ||
985 node->op == op_Mod ||
986 node->op == op_And ||
988 node->op == op_Eor ||
989 node->op == op_Shl ||
990 node->op == op_Shr ||
991 node->op == op_Shrs ||
992 node->op == op_Rot ||
993 node->op == op_Cmp );
995 switch (get_irn_opcode (node)) {
996 case iro_Add : set_Add_right(node, right); break;
997 case iro_Sub : set_Sub_right(node, right); break;
998 case iro_Mul : set_Mul_right(node, right); break;
999 case iro_Quot : set_Quot_right(node, right); break;
1000 case iro_DivMod: set_DivMod_right(node, right); break;
1001 case iro_Div : set_Div_right(node, right); break;
1002 case iro_Mod : set_Mod_right(node, right); break;
1003 case iro_And : set_And_right(node, right); break;
1004 case iro_Or : set_Or_right(node, right); break;
1005 case iro_Eor : set_Eor_right(node, right); break;
1006 case iro_Shl : set_Shl_right(node, right); break;
1007 case iro_Shr : set_Shr_right(node, right); break;
1008 case iro_Shrs : set_Shrs_right(node, right); break;
1009 case iro_Rot : set_Rot_right(node, right); break;
1010 case iro_Cmp : set_Cmp_right(node, right); break;
1016 get_Add_left (ir_node *node) {
1017 assert (node->op == op_Add);
1018 return get_irn_n(node, 0);
1022 set_Add_left (ir_node *node, ir_node *left) {
1023 assert (node->op == op_Add);
1024 set_irn_n(node, 0, left);
1028 get_Add_right (ir_node *node) {
1029 assert (node->op == op_Add);
1030 return get_irn_n(node, 1);
1034 set_Add_right (ir_node *node, ir_node *right) {
1035 assert (node->op == op_Add);
1036 set_irn_n(node, 1, right);
1040 get_Sub_left (ir_node *node) {
1041 assert (node->op == op_Sub);
1042 return get_irn_n(node, 0);
1046 set_Sub_left (ir_node *node, ir_node *left) {
1047 assert (node->op == op_Sub);
1048 set_irn_n(node, 0, left);
1052 get_Sub_right (ir_node *node) {
1053 assert (node->op == op_Sub);
1054 return get_irn_n(node, 1);
1058 set_Sub_right (ir_node *node, ir_node *right) {
1059 assert (node->op == op_Sub);
1060 set_irn_n(node, 1, right);
1065 get_Minus_op (ir_node *node) {
1066 assert (node->op == op_Minus);
1067 return get_irn_n(node, 0);
1071 set_Minus_op (ir_node *node, ir_node *op) {
1072 assert (node->op == op_Minus);
1073 set_irn_n(node, 0, op);
1078 get_Mul_left (ir_node *node) {
1079 assert (node->op == op_Mul);
1080 return get_irn_n(node, 0);
1084 set_Mul_left (ir_node *node, ir_node *left) {
1085 assert (node->op == op_Mul);
1086 set_irn_n(node, 0, left);
1090 get_Mul_right (ir_node *node) {
1091 assert (node->op == op_Mul);
1092 return get_irn_n(node, 1);
1096 set_Mul_right (ir_node *node, ir_node *right) {
1097 assert (node->op == op_Mul);
1098 set_irn_n(node, 1, right);
1102 get_Quot_left (ir_node *node) {
1103 assert (node->op == op_Quot);
1104 return get_irn_n(node, 1);
1108 set_Quot_left (ir_node *node, ir_node *left) {
1109 assert (node->op == op_Quot);
1110 set_irn_n(node, 1, left);
1114 get_Quot_right (ir_node *node) {
1115 assert (node->op == op_Quot);
1116 return get_irn_n(node, 2);
1120 set_Quot_right (ir_node *node, ir_node *right) {
1121 assert (node->op == op_Quot);
1122 set_irn_n(node, 2, right);
1126 get_Quot_mem (ir_node *node) {
1127 assert (node->op == op_Quot);
1128 return get_irn_n(node, 0);
1132 set_Quot_mem (ir_node *node, ir_node *mem) {
1133 assert (node->op == op_Quot);
1134 set_irn_n(node, 0, mem);
1138 get_DivMod_left (ir_node *node) {
1139 assert (node->op == op_DivMod);
1140 return get_irn_n(node, 1);
1144 set_DivMod_left (ir_node *node, ir_node *left) {
1145 assert (node->op == op_DivMod);
1146 set_irn_n(node, 1, left);
1150 get_DivMod_right (ir_node *node) {
1151 assert (node->op == op_DivMod);
1152 return get_irn_n(node, 2);
1156 set_DivMod_right (ir_node *node, ir_node *right) {
1157 assert (node->op == op_DivMod);
1158 set_irn_n(node, 2, right);
1162 get_DivMod_mem (ir_node *node) {
1163 assert (node->op == op_DivMod);
1164 return get_irn_n(node, 0);
1168 set_DivMod_mem (ir_node *node, ir_node *mem) {
1169 assert (node->op == op_DivMod);
1170 set_irn_n(node, 0, mem);
1174 get_Div_left (ir_node *node) {
1175 assert (node->op == op_Div);
1176 return get_irn_n(node, 1);
1180 set_Div_left (ir_node *node, ir_node *left) {
1181 assert (node->op == op_Div);
1182 set_irn_n(node, 1, left);
1186 get_Div_right (ir_node *node) {
1187 assert (node->op == op_Div);
1188 return get_irn_n(node, 2);
1192 set_Div_right (ir_node *node, ir_node *right) {
1193 assert (node->op == op_Div);
1194 set_irn_n(node, 2, right);
1198 get_Div_mem (ir_node *node) {
1199 assert (node->op == op_Div);
1200 return get_irn_n(node, 0);
1204 set_Div_mem (ir_node *node, ir_node *mem) {
1205 assert (node->op == op_Div);
1206 set_irn_n(node, 0, mem);
1210 get_Mod_left (ir_node *node) {
1211 assert (node->op == op_Mod);
1212 return get_irn_n(node, 1);
1216 set_Mod_left (ir_node *node, ir_node *left) {
1217 assert (node->op == op_Mod);
1218 set_irn_n(node, 1, left);
1222 get_Mod_right (ir_node *node) {
1223 assert (node->op == op_Mod);
1224 return get_irn_n(node, 2);
1228 set_Mod_right (ir_node *node, ir_node *right) {
1229 assert (node->op == op_Mod);
1230 set_irn_n(node, 2, right);
1234 get_Mod_mem (ir_node *node) {
1235 assert (node->op == op_Mod);
1236 return get_irn_n(node, 0);
1240 set_Mod_mem (ir_node *node, ir_node *mem) {
1241 assert (node->op == op_Mod);
1242 set_irn_n(node, 0, mem);
1246 get_Abs_op (ir_node *node) {
1247 assert (node->op == op_Abs);
1248 return get_irn_n(node, 0);
1252 set_Abs_op (ir_node *node, ir_node *op) {
1253 assert (node->op == op_Abs);
1254 set_irn_n(node, 0, op);
1258 get_And_left (ir_node *node) {
1259 assert (node->op == op_And);
1260 return get_irn_n(node, 0);
1264 set_And_left (ir_node *node, ir_node *left) {
1265 assert (node->op == op_And);
1266 set_irn_n(node, 0, left);
1270 get_And_right (ir_node *node) {
1271 assert (node->op == op_And);
1272 return get_irn_n(node, 1);
1276 set_And_right (ir_node *node, ir_node *right) {
1277 assert (node->op == op_And);
1278 set_irn_n(node, 1, right);
1282 get_Or_left (ir_node *node) {
1283 assert (node->op == op_Or);
1284 return get_irn_n(node, 0);
1288 set_Or_left (ir_node *node, ir_node *left) {
1289 assert (node->op == op_Or);
1290 set_irn_n(node, 0, left);
1294 get_Or_right (ir_node *node) {
1295 assert (node->op == op_Or);
1296 return get_irn_n(node, 1);
1300 set_Or_right (ir_node *node, ir_node *right) {
1301 assert (node->op == op_Or);
1302 set_irn_n(node, 1, right);
1306 get_Eor_left (ir_node *node) {
1307 assert (node->op == op_Eor);
1308 return get_irn_n(node, 0);
1312 set_Eor_left (ir_node *node, ir_node *left) {
1313 assert (node->op == op_Eor);
1314 set_irn_n(node, 0, left);
1318 get_Eor_right (ir_node *node) {
1319 assert (node->op == op_Eor);
1320 return get_irn_n(node, 1);
1324 set_Eor_right (ir_node *node, ir_node *right) {
1325 assert (node->op == op_Eor);
1326 set_irn_n(node, 1, right);
1331 get_Not_op (ir_node *node) {
1332 assert (node->op == op_Not);
1333 return get_irn_n(node, 0);
1337 set_Not_op (ir_node *node, ir_node *op) {
1338 assert (node->op == op_Not);
1339 set_irn_n(node, 0, op);
1344 get_Shl_left (ir_node *node) {
1345 assert (node->op == op_Shl);
1346 return get_irn_n(node, 0);
1350 set_Shl_left (ir_node *node, ir_node *left) {
1351 assert (node->op == op_Shl);
1352 set_irn_n(node, 0, left);
1356 get_Shl_right (ir_node *node) {
1357 assert (node->op == op_Shl);
1358 return get_irn_n(node, 1);
1362 set_Shl_right (ir_node *node, ir_node *right) {
1363 assert (node->op == op_Shl);
1364 set_irn_n(node, 1, right);
1368 get_Shr_left (ir_node *node) {
1369 assert (node->op == op_Shr);
1370 return get_irn_n(node, 0);
1374 set_Shr_left (ir_node *node, ir_node *left) {
1375 assert (node->op == op_Shr);
1376 set_irn_n(node, 0, left);
1380 get_Shr_right (ir_node *node) {
1381 assert (node->op == op_Shr);
1382 return get_irn_n(node, 1);
1386 set_Shr_right (ir_node *node, ir_node *right) {
1387 assert (node->op == op_Shr);
1388 set_irn_n(node, 1, right);
1392 get_Shrs_left (ir_node *node) {
1393 assert (node->op == op_Shrs);
1394 return get_irn_n(node, 0);
1398 set_Shrs_left (ir_node *node, ir_node *left) {
1399 assert (node->op == op_Shrs);
1400 set_irn_n(node, 0, left);
1404 get_Shrs_right (ir_node *node) {
1405 assert (node->op == op_Shrs);
1406 return get_irn_n(node, 1);
1410 set_Shrs_right (ir_node *node, ir_node *right) {
1411 assert (node->op == op_Shrs);
1412 set_irn_n(node, 1, right);
1416 get_Rot_left (ir_node *node) {
1417 assert (node->op == op_Rot);
1418 return get_irn_n(node, 0);
1422 set_Rot_left (ir_node *node, ir_node *left) {
1423 assert (node->op == op_Rot);
1424 set_irn_n(node, 0, left);
1428 get_Rot_right (ir_node *node) {
1429 assert (node->op == op_Rot);
1430 return get_irn_n(node, 1);
1434 set_Rot_right (ir_node *node, ir_node *right) {
1435 assert (node->op == op_Rot);
1436 set_irn_n(node, 1, right);
1440 get_Cmp_left (ir_node *node) {
1441 assert (node->op == op_Cmp);
1442 return get_irn_n(node, 0);
1446 set_Cmp_left (ir_node *node, ir_node *left) {
1447 assert (node->op == op_Cmp);
1448 set_irn_n(node, 0, left);
1452 get_Cmp_right (ir_node *node) {
1453 assert (node->op == op_Cmp);
1454 return get_irn_n(node, 1);
1458 set_Cmp_right (ir_node *node, ir_node *right) {
1459 assert (node->op == op_Cmp);
1460 set_irn_n(node, 1, right);
1464 get_Conv_op (ir_node *node) {
1465 assert (node->op == op_Conv);
1466 return get_irn_n(node, 0);
1470 set_Conv_op (ir_node *node, ir_node *op) {
1471 assert (node->op == op_Conv);
1472 set_irn_n(node, 0, op);
1476 get_Phi_preds_arr (ir_node *node) {
1477 assert (node->op == op_Phi);
1478 return (ir_node **)&(get_irn_in(node)[1]);
1482 get_Phi_n_preds (ir_node *node) {
1483 assert (node->op == op_Phi);
1484 return (get_irn_arity(node));
1488 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1489 assert (node->op == op_Phi);
1494 get_Phi_pred (ir_node *node, int pos) {
1495 assert (node->op == op_Phi);
1496 return get_irn_n(node, pos);
1500 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1501 assert (node->op == op_Phi);
1502 set_irn_n(node, pos, pred);
1506 get_Load_mem (ir_node *node) {
1507 assert (node->op == op_Load);
1508 return get_irn_n(node, 0);
1512 set_Load_mem (ir_node *node, ir_node *mem) {
1513 assert (node->op == op_Load);
1514 set_irn_n(node, 0, mem);
1518 get_Load_ptr (ir_node *node) {
1519 assert (node->op == op_Load);
1520 return get_irn_n(node, 1);
1524 set_Load_ptr (ir_node *node, ir_node *ptr) {
1525 assert (node->op == op_Load);
1526 set_irn_n(node, 1, ptr);
1531 get_Store_mem (ir_node *node) {
1532 assert (node->op == op_Store);
1533 return get_irn_n(node, 0);
1537 set_Store_mem (ir_node *node, ir_node *mem) {
1538 assert (node->op == op_Store);
1539 set_irn_n(node, 0, mem);
1543 get_Store_ptr (ir_node *node) {
1544 assert (node->op == op_Store);
1545 return get_irn_n(node, 1);
1549 set_Store_ptr (ir_node *node, ir_node *ptr) {
1550 assert (node->op == op_Store);
1551 set_irn_n(node, 1, ptr);
1555 get_Store_value (ir_node *node) {
1556 assert (node->op == op_Store);
1557 return get_irn_n(node, 2);
1561 set_Store_value (ir_node *node, ir_node *value) {
1562 assert (node->op == op_Store);
1563 set_irn_n(node, 2, value);
1567 get_Alloc_mem (ir_node *node) {
1568 assert (node->op == op_Alloc);
1569 return get_irn_n(node, 0);
1573 set_Alloc_mem (ir_node *node, ir_node *mem) {
1574 assert (node->op == op_Alloc);
1575 set_irn_n(node, 0, mem);
1579 get_Alloc_size (ir_node *node) {
1580 assert (node->op == op_Alloc);
1581 return get_irn_n(node, 1);
1585 set_Alloc_size (ir_node *node, ir_node *size) {
1586 assert (node->op == op_Alloc);
1587 set_irn_n(node, 1, size);
1591 get_Alloc_type (ir_node *node) {
1592 assert (node->op == op_Alloc);
1593 return node->attr.a.type;
1597 set_Alloc_type (ir_node *node, type *type) {
1598 assert (node->op == op_Alloc);
1599 node->attr.a.type = type;
1603 get_Alloc_where (ir_node *node) {
1604 assert (node->op == op_Alloc);
1605 return node->attr.a.where;
1609 set_Alloc_where (ir_node *node, where_alloc where) {
1610 assert (node->op == op_Alloc);
1611 node->attr.a.where = where;
1616 get_Free_mem (ir_node *node) {
1617 assert (node->op == op_Free);
1618 return get_irn_n(node, 0);
1622 set_Free_mem (ir_node *node, ir_node *mem) {
1623 assert (node->op == op_Free);
1624 set_irn_n(node, 0, mem);
1628 get_Free_ptr (ir_node *node) {
1629 assert (node->op == op_Free);
1630 return get_irn_n(node, 1);
1634 set_Free_ptr (ir_node *node, ir_node *ptr) {
1635 assert (node->op == op_Free);
1636 set_irn_n(node, 1, ptr);
1640 get_Free_size (ir_node *node) {
1641 assert (node->op == op_Free);
1642 return get_irn_n(node, 2);
1646 set_Free_size (ir_node *node, ir_node *size) {
1647 assert (node->op == op_Free);
1648 set_irn_n(node, 2, size);
1652 get_Free_type (ir_node *node) {
1653 assert (node->op == op_Free);
1654 return node->attr.f;
1658 set_Free_type (ir_node *node, type *type) {
1659 assert (node->op == op_Free);
1660 node->attr.f = type;
1664 get_Sync_preds_arr (ir_node *node) {
1665 assert (node->op == op_Sync);
1666 return (ir_node **)&(get_irn_in(node)[1]);
1670 get_Sync_n_preds (ir_node *node) {
1671 assert (node->op == op_Sync);
1672 return (get_irn_arity(node));
1677 set_Sync_n_preds (ir_node *node, int n_preds) {
1678 assert (node->op == op_Sync);
1683 get_Sync_pred (ir_node *node, int pos) {
1684 assert (node->op == op_Sync);
1685 return get_irn_n(node, pos);
1689 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1690 assert (node->op == op_Sync);
1691 set_irn_n(node, pos, pred);
1695 get_Proj_pred (ir_node *node) {
1696 assert (node->op == op_Proj);
1697 return get_irn_n(node, 0);
1701 set_Proj_pred (ir_node *node, ir_node *pred) {
1702 assert (node->op == op_Proj);
1703 set_irn_n(node, 0, pred);
1707 get_Proj_proj (ir_node *node) {
1708 assert (node->op == op_Proj);
1709 return node->attr.proj;
1713 set_Proj_proj (ir_node *node, long proj) {
1714 assert (node->op == op_Proj);
1715 node->attr.proj = proj;
1719 get_Tuple_preds_arr (ir_node *node) {
1720 assert (node->op == op_Tuple);
1721 return (ir_node **)&(get_irn_in(node)[1]);
1725 get_Tuple_n_preds (ir_node *node) {
1726 assert (node->op == op_Tuple);
1727 return (get_irn_arity(node));
1732 set_Tuple_n_preds (ir_node *node, int n_preds) {
1733 assert (node->op == op_Tuple);
1738 get_Tuple_pred (ir_node *node, int pos) {
1739 assert (node->op == op_Tuple);
1740 return get_irn_n(node, pos);
1744 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1745 assert (node->op == op_Tuple);
1746 set_irn_n(node, pos, pred);
1750 get_Id_pred (ir_node *node) {
1751 assert (node->op == op_Id);
1752 return get_irn_n(node, 0);
1756 set_Id_pred (ir_node *node, ir_node *pred) {
1757 assert (node->op == op_Id);
1758 set_irn_n(node, 0, pred);
1761 /******************************************************************/
1762 /* Auxiliary routines */
1763 /******************************************************************/
1766 skip_Proj (ir_node *node) {
1767 /* don't assert node !!! */
1768 if (node && (node->op == op_Proj)) {
1769 return get_Proj_pred(node);
1776 skip_nop (ir_node *node) {
1777 /* don't assert node !!! */
1779 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1780 /* Don't use get_Id_pred: We get into an endless loop for
1781 self-referencing Ids. */
1782 assert (get_irn_arity (node) > 0);
1783 return node->in[0+1];
1790 is_Bad (ir_node *node) {
1792 if ((node) && get_irn_opcode(node) == iro_Bad)
1798 is_no_Block (ir_node *node) {
1800 return (get_irn_opcode(node) != iro_Block);
1803 /* Returns true if the operation manipulates control flow. */
1805 is_cfop(ir_node *node) {
1806 return ( (get_irn_opcode(node) == iro_Start)
1807 || (get_irn_opcode(node) == iro_Jmp)
1808 || (get_irn_opcode(node) == iro_Cond)
1809 || (get_irn_opcode(node) == iro_Return)
1810 || (get_irn_opcode(node) == iro_Raise)
1811 || (get_irn_opcode(node) == iro_Bad));
1814 /* Returns true if the operation can change the control flow because
1817 is_fragile_op(ir_node *node) {
1818 return ( (get_irn_opcode(node) == iro_Call)
1819 || (get_irn_opcode(node) == iro_Quot)
1820 || (get_irn_opcode(node) == iro_DivMod)
1821 || (get_irn_opcode(node) == iro_Div)
1822 || (get_irn_opcode(node) == iro_Mod)
1823 || (get_irn_opcode(node) == iro_Load)
1824 || (get_irn_opcode(node) == iro_Store)
1825 || (get_irn_opcode(node) == iro_Alloc)
1826 || (get_irn_opcode(node) == iro_Bad));