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"
16 #include "typegmod_t.h"
23 /* some constants fixing the positions of nodes predecessors
25 #define CALL_PARAM_OFFSET 2
26 #define SEL_INDEX_OFFSET 2
27 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
29 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
30 "Gt", "Ge", "Lg", "Leg", "Uo",
31 "Ue", "Ul", "Ule", "Ug", "Uge",
34 inline char *get_pnc_string(int pnc) {
35 return pnc_name_arr[pnc];
40 get_negated_pnc(int pnc) {
42 case False: return True; break;
43 case Eq: return Ne; break;
44 case Lt: return Uge; break;
45 case Le: return Ug; break;
46 case Gt: return Ule; break;
47 case Ge: return Ul; break;
48 case Lg: return Ue; break;
49 case Leg: return Uo; break;
50 case Uo: return Leg; break;
51 case Ue: return Lg; break;
52 case Ul: return Ge; break;
53 case Ule: return Gt; break;
54 case Ug: return Le; break;
55 case Uge: return Lt; break;
56 case Ne: return Eq; break;
57 case True: return False; break;
59 return 99; /* to shut up gcc */
62 static char *pns_name_arr [] = {"initial_exec", "global_store",
63 "frame_base", "globals", "args"};
65 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
72 /* irnode constructor */
73 /* create a new irnode in irg, with an op, mode, arity and */
74 /* some incoming irnodes */
75 /* this constructor is used in every specified irnode constructor */
77 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
78 int arity, ir_node **in)
81 int node_size = offsetof (ir_node, attr) + op->attr_size;
83 res = (ir_node *) obstack_alloc (irg->obst, node_size);
85 res->kind = k_ir_node;
91 res->in = NEW_ARR_F (ir_node *, 1);
93 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
94 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
99 res->node_nr = get_irp_new_node_nr();
105 /* Copies all attributes stored in the old node to the new node.
106 Assumes both have the same opcode and sufficient size. */
108 copy_attrs (ir_node *old, ir_node *new) {
109 assert (get_irn_opcode(old) == get_irn_opcode(new));
110 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
113 /* IR-Nodes with attributes */
115 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
118 ir_node *np = XP_GETARG (ir_node *, 0);
121 XPS ("<null ir_node>");
125 XPF1 ("%I", get_irn_opident(np));
127 switch (get_irn_opcode (np)) { /* node label */
129 XPF1 ("%I", get_irn_mode(np)->name);
131 XPF1 ("%v", get_irn_const_attr);
134 if (get_irn_modecode (np) == irm_b) {
136 XP (pnc_name_arr[get_irn_proj_attr(np)]);
137 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
139 XP (pns_name_arr[get_irn_proj_attr(np)]);
141 XPF1 ("%I", get_irn_mode(np)->name);
143 XPF1 ("%d", get_irn_proj_attr(np));
147 XPF1 ("%I", get_irn_mode(np)->name);
149 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
150 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
152 case iro_Start: /* don't dump mode of these */
161 XPF1 ("%I", get_irn_mode(np)->name);
167 /** getting some parameters from ir_nodes **/
169 /* returns the number of predecessors without the block predecessor. */
171 get_irn_arity (ir_node *node)
174 return (ARR_LEN((node)->in)-1);
177 /* Returns the array with ins. This array is shifted with respect to the
178 array accessed by get_irn_n: The block operand is at position 0 not -1.
179 (@@@ This should be changed.)
180 The order of the predecessors in this array is not guaranteed, except that
181 lists of operands as predecessors of Block or arguments of a Call are
184 get_irn_in (ir_node *node)
191 set_irn_in (ir_node *node, int arity, ir_node **in) {
193 if (arity != get_irn_arity(node)) {
194 ir_node *block = node->in[0];
195 node->in = NEW_ARR_D (ir_node *, current_ir_graph->obst, (arity+1));
198 memcpy (&node->in[1], in, sizeof (ir_node *) * arity);
201 /* to iterate through the predecessors without touching the array */
202 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
203 to iterate includind the Block predecessor iterate from i = -1 to
205 If it is a block, the entry -1 is NULL. */
207 get_irn_n (ir_node *node, int n)
210 assert (get_irn_arity (node) > n);
211 return skip_nop(node->in[n+1]);
215 set_irn_n (ir_node *node, int n, ir_node *in)
218 assert (get_irn_arity (node) > n);
223 get_irn_mode (ir_node *node)
230 get_irn_modecode (ir_node *node)
233 return node->mode->code;
238 get_irn_modeident (ir_node *node)
241 return node->mode->name;
245 get_irn_op (ir_node *node)
251 /* should be private to the library: */
253 set_irn_op (ir_node *node, ir_op *op)
260 get_irn_opcode (ir_node *node)
263 return node->op->code;
267 get_irn_opname (ir_node *node)
270 return id_to_str(node->op->name);
274 get_irn_opident (ir_node *node)
277 return node->op->name;
281 get_irn_visited (ir_node *node)
284 return node->visited;
288 set_irn_visited (ir_node *node, unsigned long visited)
291 node->visited = visited;
294 set_irn_link (ir_node *node, ir_node *link) {
300 get_irn_link (ir_node *node) {
306 /* Outputs a unique number for this node */
308 get_irn_node_nr(ir_node *node) {
310 return node->node_nr;
315 get_irn_const_attr (ir_node *node)
317 assert (node->op == op_Const);
318 return node->attr.con;
322 get_irn_proj_attr (ir_node *node)
324 assert (node->op == op_Proj);
325 return node->attr.proj;
329 get_irn_alloc_attr (ir_node *node)
331 assert (node->op == op_Alloc);
336 get_irn_free_attr (ir_node *node)
338 assert (node->op == op_Free);
339 return node->attr.f = skip_tid(node->attr.f);
343 get_irn_symconst_attr (ir_node *node)
345 assert (node->op == op_SymConst);
350 get_irn_call_attr (ir_node *node)
352 assert (node->op == op_Call);
353 return node->attr.call = skip_tid(node->attr.call);
357 get_irn_sel_attr (ir_node *node)
359 assert (node->op == op_Sel);
364 get_irn_phi_attr (ir_node *node)
366 assert (node->op == op_Phi);
367 return node->attr.phi0_pos;
371 get_irn_block_attr (ir_node *node)
373 assert (node->op == op_Block);
374 return node->attr.block;
377 /** manipulate fields of individual nodes **/
379 /* this works for all except Block */
381 get_nodes_Block (ir_node *node) {
382 assert (!(node->op == op_Block));
383 return get_irn_n(node, -1);
387 set_nodes_Block (ir_node *node, ir_node *block) {
388 assert (!(node->op == op_Block));
389 set_irn_n(node, -1, block);
392 /* Returns an array with the predecessors of the Block. Depending on
393 the implementation of the graph datastructure this can be a copy of
394 the internal representation of predecessors as well as the internal
395 array itself. Therefore writing to this array might obstruct the ir. */
397 get_Block_cfgpred_arr (ir_node *node)
399 assert ((node->op == op_Block));
400 return (ir_node **)&(get_irn_in(node)[1]);
405 get_Block_n_cfgpreds (ir_node *node) {
406 assert ((node->op == op_Block));
407 return (get_irn_arity(node));
412 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
413 assert ((node->op == op_Block));
418 get_Block_cfgpred (ir_node *node, int pos) {
419 assert (node->op == op_Block);
420 return get_irn_n(node, pos);
424 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
425 assert (node->op == op_Block);
426 set_irn_n(node, pos, pred);
430 get_Block_matured (ir_node *node) {
431 assert (node->op == op_Block);
432 return node->attr.block.matured;
436 set_Block_matured (ir_node *node, bool matured) {
437 assert (node->op == op_Block);
438 node->attr.block.matured = matured;
441 get_Block_block_visited (ir_node *node) {
442 assert (node->op == op_Block);
443 return node->attr.block.block_visited;
447 set_Block_block_visited (ir_node *node, unsigned long visit) {
448 assert (node->op == op_Block);
449 node->attr.block.block_visited = visit;
453 get_Block_graph_arr (ir_node *node, int pos) {
454 assert (node->op == op_Block);
455 return node->attr.block.graph_arr[pos+1];
459 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
460 assert (node->op == op_Block);
461 node->attr.block.graph_arr[pos+1] = value;
464 > Implementing the case construct (which is where the constant Proj node is
465 > important) involves far more than simply determining the constant values.
466 > We could argue that this is more properly a function of the translator from
467 > Firm to the target machine. That could be done if there was some way of
468 > projecting "default" out of the Cond node.
469 I know it's complicated.
470 Basically there are two proglems:
471 - determining the gaps between the projs
472 - determining the biggest case constant to konw the proj number for
474 I see several solutions:
475 1. Introduce a ProjDefault node. Solves both problems.
476 This means to extend all optimizations executed during construction.
477 2. Give the Cond node for switch two flavors:
478 a) there are no gaps in the projs (existing flavor)
479 b) gaps may exist, default proj is still the Proj with the largest
480 projection number. This covers also the gaps.
481 3. Fix the semantic of the Cond to that of 2b)
483 Solution 2 seems to be the best:
484 Computing the gaps in the Firm representation is not too hard, i.e.,
485 libfirm can implement a routine that transforms betweeen the two
486 flavours. This is also possible for 1) but 2) does not require to
487 change any existing optimization.
488 Further it should be far simpler to determine the biggest constant than
490 I don't want to choose 3) as 2a) seems to have advantages for
491 dataflow analysis and 3) does not allow to convert the representation to
495 get_Cond_selector (ir_node *node) {
496 assert (node->op == op_Cond);
497 return get_irn_n(node, 0);
501 set_Cond_selector (ir_node *node, ir_node *selector) {
502 assert (node->op == op_Cond);
503 set_irn_n(node, 0, selector);
507 get_Cond_kind (ir_node *node) {
508 assert (node->op == op_Cond);
509 return node->attr.c.kind;
513 set_Cond_kind (ir_node *node, cond_kind kind) {
514 assert (node->op == op_Cond);
515 node->attr.c.kind = kind;
519 get_Return_mem (ir_node *node) {
520 assert (node->op == op_Return);
521 return get_irn_n(node, 0);
525 set_Return_mem (ir_node *node, ir_node *mem) {
526 assert (node->op == op_Return);
527 set_irn_n(node, 0, mem);
531 get_Return_res_arr (ir_node *node)
533 assert ((node->op == op_Return));
534 if (get_Return_n_res(node) > 0)
535 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
541 get_Return_n_res (ir_node *node) {
542 assert (node->op == op_Return);
543 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
548 set_Return_n_res (ir_node *node, int results) {
549 assert (node->op == op_Return);
554 get_Return_res (ir_node *node, int pos) {
555 assert (node->op == op_Return);
556 assert (get_Return_n_res(node) > pos);
557 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
561 set_Return_res (ir_node *node, int pos, ir_node *res){
562 assert (node->op == op_Return);
563 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
567 get_Raise_mem (ir_node *node) {
568 assert (node->op == op_Return);
569 return get_irn_n(node, 0);
573 set_Raise_mem (ir_node *node, ir_node *mem) {
574 assert (node->op == op_Raise);
575 set_irn_n(node, 0, mem);
579 get_Raise_exo_ptr (ir_node *node) {
580 assert (node->op == op_Raise);
581 return get_irn_n(node, 1);
585 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
586 assert (node->op == op_Raise);
587 set_irn_n(node, 1, exo_ptr);
590 inline tarval *get_Const_tarval (ir_node *node) {
591 assert (node->op == op_Const);
592 return get_irn_const_attr(node);
596 set_Const_tarval (ir_node *node, tarval *con) {
597 assert (node->op == op_Const);
598 node->attr.con = con;
602 get_SymConst_kind (ir_node *node) {
603 assert (node->op == op_SymConst);
604 return node->attr.i.num;
608 set_SymConst_kind (ir_node *node, symconst_kind num) {
609 assert (node->op == op_SymConst);
610 node->attr.i.num = num;
614 get_SymConst_type (ir_node *node) {
615 assert ( (node->op == op_SymConst)
616 && ( get_SymConst_kind(node) == type_tag
617 || get_SymConst_kind(node) == size));
618 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
622 set_SymConst_type (ir_node *node, type *type) {
623 assert ( (node->op == op_SymConst)
624 && ( get_SymConst_kind(node) == type_tag
625 || get_SymConst_kind(node) == size));
626 node->attr.i.tori.typ = type;
630 get_SymConst_ptrinfo (ir_node *node) {
631 assert ( (node->op == op_SymConst)
632 && (get_SymConst_kind(node) == linkage_ptr_info));
633 return node->attr.i.tori.ptrinfo;
637 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
638 assert ( (node->op == op_SymConst)
639 && (get_SymConst_kind(node) == linkage_ptr_info));
640 node->attr.i.tori.ptrinfo = ptrinfo;
644 get_SymConst_type_or_id (ir_node *node) {
645 assert (node->op == op_SymConst);
646 return &(node->attr.i.tori);
650 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
651 assert (node->op == op_SymConst);
652 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
656 get_Sel_mem (ir_node *node) {
657 assert (node->op == op_Sel);
658 return get_irn_n(node, 0);
662 set_Sel_mem (ir_node *node, ir_node *mem) {
663 assert (node->op == op_Sel);
664 set_irn_n(node, 0, mem);
668 get_Sel_ptr (ir_node *node) {
669 assert (node->op == op_Sel);
670 return get_irn_n(node, 1);
674 set_Sel_ptr (ir_node *node, ir_node *ptr) {
675 assert (node->op == op_Sel);
676 set_irn_n(node, 1, ptr);
680 get_Sel_index_arr (ir_node *node)
682 assert ((node->op == op_Sel));
683 if (get_Sel_n_index(node) > 0)
684 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
690 get_Sel_n_index (ir_node *node) {
691 assert (node->op == op_Sel);
692 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
697 set_Sel_n_index (ir_node *node, int n_index) {
698 assert (node->op == op_Sel);
703 get_Sel_index (ir_node *node, int pos) {
704 assert (node->op == op_Sel);
705 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
709 set_Sel_index (ir_node *node, int pos, ir_node *index) {
710 assert (node->op == op_Sel);
711 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
715 get_Sel_entity (ir_node *node) {
716 assert (node->op == op_Sel);
717 return node->attr.s.ent;
721 set_Sel_entity (ir_node *node, entity *ent) {
722 assert (node->op == op_Sel);
723 node->attr.s.ent = ent;
727 get_Sel_linkage_type (ir_node *node) {
728 assert (node->op == op_Sel);
729 return node->attr.s.ltyp;
733 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
734 assert (node->op == op_Sel);
735 node->attr.s.ltyp = lt;
739 get_Call_mem (ir_node *node) {
740 assert (node->op == op_Call);
741 return get_irn_n(node, 0);
745 set_Call_mem (ir_node *node, ir_node *mem) {
746 assert (node->op == op_Call);
747 set_irn_n(node, 0, mem);
751 get_Call_ptr (ir_node *node) {
752 assert (node->op == op_Call);
753 return get_irn_n(node, 1);
757 set_Call_ptr (ir_node *node, ir_node *ptr) {
758 assert (node->op == op_Call);
759 set_irn_n(node, 1, ptr);
763 get_Call_param_arr (ir_node *node) {
764 assert (node->op == op_Call);
765 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
769 get_Call_n_params (ir_node *node) {
770 assert (node->op == op_Call);
771 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
775 get_Call_arity (ir_node *node) {
776 return get_Call_n_params(node);
780 set_Call_arity (ir_node *node, ir_node *arity) {
781 assert (node->op == op_Call);
786 get_Call_param (ir_node *node, int pos) {
787 assert (node->op == op_Call);
788 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
792 set_Call_param (ir_node *node, int pos, ir_node *param) {
793 assert (node->op == op_Call);
794 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
798 get_Call_type (ir_node *node) {
799 assert (node->op == op_Call);
800 return node->attr.call = skip_tid(node->attr.call);
804 set_Call_type (ir_node *node, type *type) {
805 assert (node->op == op_Call);
806 assert (is_method_type(type));
807 node->attr.call = type;
810 /* For unary and binary arithmetic operations the access to the
811 operands can be factored out. Left is the first, right the
812 second arithmetic value as listed in tech report 0999-33.
813 unops are: Minus, Abs, Not, Conv
814 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
815 Shr, Shrs, Rotate, Cmp */
818 is_unop (ir_node *node) {
819 return ( node->op == op_Minus ||
820 node->op == op_Abs ||
821 node->op == op_Not ||
822 node->op == op_Conv );
826 get_unop_op (ir_node *node) {
827 assert ( node->op == op_Minus ||
828 node->op == op_Abs ||
829 node->op == op_Not ||
830 node->op == op_Conv );
831 switch (get_irn_opcode (node)) {
832 case iro_Minus: return get_Minus_op(node); break;
833 case iro_Abs: return get_Abs_op(node); break;
834 case iro_Not: return get_Not_op(node); break;
835 case iro_Conv: return get_Conv_op(node); break;
836 default: return NULL;
841 set_unop_op (ir_node *node, ir_node *op) {
842 assert (node->op == op_Minus ||
843 node->op == op_Abs ||
844 node->op == op_Not ||
845 node->op == op_Conv );
846 switch (get_irn_opcode (node)) {
847 case iro_Minus: set_Minus_op(node, op); break;
848 case iro_Abs: set_Abs_op(node, op); break;
849 case iro_Not: set_Not_op(node, op); break;
850 case iro_Conv: set_Conv_op(node, op); break;
857 is_binop (ir_node *node) {
858 return (node->op == op_Add ||
859 node->op == op_Sub ||
860 node->op == op_Mul ||
861 node->op == op_Quot ||
862 node->op == op_DivMod ||
863 node->op == op_Div ||
864 node->op == op_Mod ||
865 node->op == op_And ||
867 node->op == op_Eor ||
868 node->op == op_Shl ||
869 node->op == op_Shr ||
870 node->op == op_Shrs ||
871 node->op == op_Rot ||
872 node->op == op_Cmp );
876 get_binop_left (ir_node *node) {
877 assert (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 );
893 switch (get_irn_opcode (node)) {
894 case iro_Add : return get_Add_left(node); break;
895 case iro_Sub : return get_Sub_left(node); break;
896 case iro_Mul : return get_Mul_left(node); break;
897 case iro_Quot : return get_Quot_left(node); break;
898 case iro_DivMod: return get_DivMod_left(node); break;
899 case iro_Div : return get_Div_left(node); break;
900 case iro_Mod : return get_Mod_left(node); break;
901 case iro_And : return get_And_left(node); break;
902 case iro_Or : return get_Or_left(node); break;
903 case iro_Eor : return get_Eor_left(node); break;
904 case iro_Shl : return get_Shl_left(node); break;
905 case iro_Shr : return get_Shr_left(node); break;
906 case iro_Shrs : return get_Shrs_left(node); break;
907 case iro_Rot : return get_Rot_left(node); break;
908 case iro_Cmp : return get_Cmp_left(node); break;
909 default: return NULL;
914 set_binop_left (ir_node *node, ir_node *left) {
915 assert (node->op == op_Add ||
916 node->op == op_Sub ||
917 node->op == op_Mul ||
918 node->op == op_Quot ||
919 node->op == op_DivMod ||
920 node->op == op_Div ||
921 node->op == op_Mod ||
922 node->op == op_And ||
924 node->op == op_Eor ||
925 node->op == op_Shl ||
926 node->op == op_Shr ||
927 node->op == op_Shrs ||
928 node->op == op_Rot ||
929 node->op == op_Cmp );
931 switch (get_irn_opcode (node)) {
932 case iro_Add : set_Add_left(node, left); break;
933 case iro_Sub : set_Sub_left(node, left); break;
934 case iro_Mul : set_Mul_left(node, left); break;
935 case iro_Quot : set_Quot_left(node, left); break;
936 case iro_DivMod: set_DivMod_left(node, left); break;
937 case iro_Div : set_Div_left(node, left); break;
938 case iro_Mod : set_Mod_left(node, left); break;
939 case iro_And : set_And_left(node, left); break;
940 case iro_Or : set_Or_left(node, left); break;
941 case iro_Eor : set_Eor_left(node, left); break;
942 case iro_Shl : set_Shl_left(node, left); break;
943 case iro_Shr : set_Shr_left(node, left); break;
944 case iro_Shrs : set_Shrs_left(node, left); break;
945 case iro_Rot : set_Rot_left(node, left); break;
946 case iro_Cmp : set_Cmp_left(node, left); break;
952 get_binop_right (ir_node *node) {
953 assert (node->op == op_Add ||
954 node->op == op_Sub ||
955 node->op == op_Mul ||
956 node->op == op_Quot ||
957 node->op == op_DivMod ||
958 node->op == op_Div ||
959 node->op == op_Mod ||
960 node->op == op_And ||
962 node->op == op_Eor ||
963 node->op == op_Shl ||
964 node->op == op_Shr ||
965 node->op == op_Shrs ||
966 node->op == op_Rot ||
967 node->op == op_Cmp );
969 switch (get_irn_opcode (node)) {
970 case iro_Add : return get_Add_right(node); break;
971 case iro_Sub : return get_Sub_right(node); break;
972 case iro_Mul : return get_Mul_right(node); break;
973 case iro_Quot : return get_Quot_right(node); break;
974 case iro_DivMod: return get_DivMod_right(node); break;
975 case iro_Div : return get_Div_right(node); break;
976 case iro_Mod : return get_Mod_right(node); break;
977 case iro_And : return get_And_right(node); break;
978 case iro_Or : return get_Or_right(node); break;
979 case iro_Eor : return get_Eor_right(node); break;
980 case iro_Shl : return get_Shl_right(node); break;
981 case iro_Shr : return get_Shr_right(node); break;
982 case iro_Shrs : return get_Shrs_right(node); break;
983 case iro_Rot : return get_Rot_right(node); break;
984 case iro_Cmp : return get_Cmp_right(node); break;
985 default: return NULL;
990 set_binop_right (ir_node *node, ir_node *right) {
991 assert (node->op == op_Add ||
992 node->op == op_Sub ||
993 node->op == op_Mul ||
994 node->op == op_Quot ||
995 node->op == op_DivMod ||
996 node->op == op_Div ||
997 node->op == op_Mod ||
998 node->op == op_And ||
1000 node->op == op_Eor ||
1001 node->op == op_Shl ||
1002 node->op == op_Shr ||
1003 node->op == op_Shrs ||
1004 node->op == op_Rot ||
1005 node->op == op_Cmp );
1007 switch (get_irn_opcode (node)) {
1008 case iro_Add : set_Add_right(node, right); break;
1009 case iro_Sub : set_Sub_right(node, right); break;
1010 case iro_Mul : set_Mul_right(node, right); break;
1011 case iro_Quot : set_Quot_right(node, right); break;
1012 case iro_DivMod: set_DivMod_right(node, right); break;
1013 case iro_Div : set_Div_right(node, right); break;
1014 case iro_Mod : set_Mod_right(node, right); break;
1015 case iro_And : set_And_right(node, right); break;
1016 case iro_Or : set_Or_right(node, right); break;
1017 case iro_Eor : set_Eor_right(node, right); break;
1018 case iro_Shl : set_Shl_right(node, right); break;
1019 case iro_Shr : set_Shr_right(node, right); break;
1020 case iro_Shrs : set_Shrs_right(node, right); break;
1021 case iro_Rot : set_Rot_right(node, right); break;
1022 case iro_Cmp : set_Cmp_right(node, right); break;
1028 get_Add_left (ir_node *node) {
1029 assert (node->op == op_Add);
1030 return get_irn_n(node, 0);
1034 set_Add_left (ir_node *node, ir_node *left) {
1035 assert (node->op == op_Add);
1036 set_irn_n(node, 0, left);
1040 get_Add_right (ir_node *node) {
1041 assert (node->op == op_Add);
1042 return get_irn_n(node, 1);
1046 set_Add_right (ir_node *node, ir_node *right) {
1047 assert (node->op == op_Add);
1048 set_irn_n(node, 1, right);
1052 get_Sub_left (ir_node *node) {
1053 assert (node->op == op_Sub);
1054 return get_irn_n(node, 0);
1058 set_Sub_left (ir_node *node, ir_node *left) {
1059 assert (node->op == op_Sub);
1060 set_irn_n(node, 0, left);
1064 get_Sub_right (ir_node *node) {
1065 assert (node->op == op_Sub);
1066 return get_irn_n(node, 1);
1070 set_Sub_right (ir_node *node, ir_node *right) {
1071 assert (node->op == op_Sub);
1072 set_irn_n(node, 1, right);
1077 get_Minus_op (ir_node *node) {
1078 assert (node->op == op_Minus);
1079 return get_irn_n(node, 0);
1083 set_Minus_op (ir_node *node, ir_node *op) {
1084 assert (node->op == op_Minus);
1085 set_irn_n(node, 0, op);
1090 get_Mul_left (ir_node *node) {
1091 assert (node->op == op_Mul);
1092 return get_irn_n(node, 0);
1096 set_Mul_left (ir_node *node, ir_node *left) {
1097 assert (node->op == op_Mul);
1098 set_irn_n(node, 0, left);
1102 get_Mul_right (ir_node *node) {
1103 assert (node->op == op_Mul);
1104 return get_irn_n(node, 1);
1108 set_Mul_right (ir_node *node, ir_node *right) {
1109 assert (node->op == op_Mul);
1110 set_irn_n(node, 1, right);
1114 get_Quot_left (ir_node *node) {
1115 assert (node->op == op_Quot);
1116 return get_irn_n(node, 1);
1120 set_Quot_left (ir_node *node, ir_node *left) {
1121 assert (node->op == op_Quot);
1122 set_irn_n(node, 1, left);
1126 get_Quot_right (ir_node *node) {
1127 assert (node->op == op_Quot);
1128 return get_irn_n(node, 2);
1132 set_Quot_right (ir_node *node, ir_node *right) {
1133 assert (node->op == op_Quot);
1134 set_irn_n(node, 2, right);
1138 get_Quot_mem (ir_node *node) {
1139 assert (node->op == op_Quot);
1140 return get_irn_n(node, 0);
1144 set_Quot_mem (ir_node *node, ir_node *mem) {
1145 assert (node->op == op_Quot);
1146 set_irn_n(node, 0, mem);
1150 get_DivMod_left (ir_node *node) {
1151 assert (node->op == op_DivMod);
1152 return get_irn_n(node, 1);
1156 set_DivMod_left (ir_node *node, ir_node *left) {
1157 assert (node->op == op_DivMod);
1158 set_irn_n(node, 1, left);
1162 get_DivMod_right (ir_node *node) {
1163 assert (node->op == op_DivMod);
1164 return get_irn_n(node, 2);
1168 set_DivMod_right (ir_node *node, ir_node *right) {
1169 assert (node->op == op_DivMod);
1170 set_irn_n(node, 2, right);
1174 get_DivMod_mem (ir_node *node) {
1175 assert (node->op == op_DivMod);
1176 return get_irn_n(node, 0);
1180 set_DivMod_mem (ir_node *node, ir_node *mem) {
1181 assert (node->op == op_DivMod);
1182 set_irn_n(node, 0, mem);
1186 get_Div_left (ir_node *node) {
1187 assert (node->op == op_Div);
1188 return get_irn_n(node, 1);
1192 set_Div_left (ir_node *node, ir_node *left) {
1193 assert (node->op == op_Div);
1194 set_irn_n(node, 1, left);
1198 get_Div_right (ir_node *node) {
1199 assert (node->op == op_Div);
1200 return get_irn_n(node, 2);
1204 set_Div_right (ir_node *node, ir_node *right) {
1205 assert (node->op == op_Div);
1206 set_irn_n(node, 2, right);
1210 get_Div_mem (ir_node *node) {
1211 assert (node->op == op_Div);
1212 return get_irn_n(node, 0);
1216 set_Div_mem (ir_node *node, ir_node *mem) {
1217 assert (node->op == op_Div);
1218 set_irn_n(node, 0, mem);
1222 get_Mod_left (ir_node *node) {
1223 assert (node->op == op_Mod);
1224 return get_irn_n(node, 1);
1228 set_Mod_left (ir_node *node, ir_node *left) {
1229 assert (node->op == op_Mod);
1230 set_irn_n(node, 1, left);
1234 get_Mod_right (ir_node *node) {
1235 assert (node->op == op_Mod);
1236 return get_irn_n(node, 2);
1240 set_Mod_right (ir_node *node, ir_node *right) {
1241 assert (node->op == op_Mod);
1242 set_irn_n(node, 2, right);
1246 get_Mod_mem (ir_node *node) {
1247 assert (node->op == op_Mod);
1248 return get_irn_n(node, 0);
1252 set_Mod_mem (ir_node *node, ir_node *mem) {
1253 assert (node->op == op_Mod);
1254 set_irn_n(node, 0, mem);
1258 get_Abs_op (ir_node *node) {
1259 assert (node->op == op_Abs);
1260 return get_irn_n(node, 0);
1264 set_Abs_op (ir_node *node, ir_node *op) {
1265 assert (node->op == op_Abs);
1266 set_irn_n(node, 0, op);
1270 get_And_left (ir_node *node) {
1271 assert (node->op == op_And);
1272 return get_irn_n(node, 0);
1276 set_And_left (ir_node *node, ir_node *left) {
1277 assert (node->op == op_And);
1278 set_irn_n(node, 0, left);
1282 get_And_right (ir_node *node) {
1283 assert (node->op == op_And);
1284 return get_irn_n(node, 1);
1288 set_And_right (ir_node *node, ir_node *right) {
1289 assert (node->op == op_And);
1290 set_irn_n(node, 1, right);
1294 get_Or_left (ir_node *node) {
1295 assert (node->op == op_Or);
1296 return get_irn_n(node, 0);
1300 set_Or_left (ir_node *node, ir_node *left) {
1301 assert (node->op == op_Or);
1302 set_irn_n(node, 0, left);
1306 get_Or_right (ir_node *node) {
1307 assert (node->op == op_Or);
1308 return get_irn_n(node, 1);
1312 set_Or_right (ir_node *node, ir_node *right) {
1313 assert (node->op == op_Or);
1314 set_irn_n(node, 1, right);
1318 get_Eor_left (ir_node *node) {
1319 assert (node->op == op_Eor);
1320 return get_irn_n(node, 0);
1324 set_Eor_left (ir_node *node, ir_node *left) {
1325 assert (node->op == op_Eor);
1326 set_irn_n(node, 0, left);
1330 get_Eor_right (ir_node *node) {
1331 assert (node->op == op_Eor);
1332 return get_irn_n(node, 1);
1336 set_Eor_right (ir_node *node, ir_node *right) {
1337 assert (node->op == op_Eor);
1338 set_irn_n(node, 1, right);
1343 get_Not_op (ir_node *node) {
1344 assert (node->op == op_Not);
1345 return get_irn_n(node, 0);
1349 set_Not_op (ir_node *node, ir_node *op) {
1350 assert (node->op == op_Not);
1351 set_irn_n(node, 0, op);
1356 get_Shl_left (ir_node *node) {
1357 assert (node->op == op_Shl);
1358 return get_irn_n(node, 0);
1362 set_Shl_left (ir_node *node, ir_node *left) {
1363 assert (node->op == op_Shl);
1364 set_irn_n(node, 0, left);
1368 get_Shl_right (ir_node *node) {
1369 assert (node->op == op_Shl);
1370 return get_irn_n(node, 1);
1374 set_Shl_right (ir_node *node, ir_node *right) {
1375 assert (node->op == op_Shl);
1376 set_irn_n(node, 1, right);
1380 get_Shr_left (ir_node *node) {
1381 assert (node->op == op_Shr);
1382 return get_irn_n(node, 0);
1386 set_Shr_left (ir_node *node, ir_node *left) {
1387 assert (node->op == op_Shr);
1388 set_irn_n(node, 0, left);
1392 get_Shr_right (ir_node *node) {
1393 assert (node->op == op_Shr);
1394 return get_irn_n(node, 1);
1398 set_Shr_right (ir_node *node, ir_node *right) {
1399 assert (node->op == op_Shr);
1400 set_irn_n(node, 1, right);
1404 get_Shrs_left (ir_node *node) {
1405 assert (node->op == op_Shrs);
1406 return get_irn_n(node, 0);
1410 set_Shrs_left (ir_node *node, ir_node *left) {
1411 assert (node->op == op_Shrs);
1412 set_irn_n(node, 0, left);
1416 get_Shrs_right (ir_node *node) {
1417 assert (node->op == op_Shrs);
1418 return get_irn_n(node, 1);
1422 set_Shrs_right (ir_node *node, ir_node *right) {
1423 assert (node->op == op_Shrs);
1424 set_irn_n(node, 1, right);
1428 get_Rot_left (ir_node *node) {
1429 assert (node->op == op_Rot);
1430 return get_irn_n(node, 0);
1434 set_Rot_left (ir_node *node, ir_node *left) {
1435 assert (node->op == op_Rot);
1436 set_irn_n(node, 0, left);
1440 get_Rot_right (ir_node *node) {
1441 assert (node->op == op_Rot);
1442 return get_irn_n(node, 1);
1446 set_Rot_right (ir_node *node, ir_node *right) {
1447 assert (node->op == op_Rot);
1448 set_irn_n(node, 1, right);
1452 get_Cmp_left (ir_node *node) {
1453 assert (node->op == op_Cmp);
1454 return get_irn_n(node, 0);
1458 set_Cmp_left (ir_node *node, ir_node *left) {
1459 assert (node->op == op_Cmp);
1460 set_irn_n(node, 0, left);
1464 get_Cmp_right (ir_node *node) {
1465 assert (node->op == op_Cmp);
1466 return get_irn_n(node, 1);
1470 set_Cmp_right (ir_node *node, ir_node *right) {
1471 assert (node->op == op_Cmp);
1472 set_irn_n(node, 1, right);
1476 get_Conv_op (ir_node *node) {
1477 assert (node->op == op_Conv);
1478 return get_irn_n(node, 0);
1482 set_Conv_op (ir_node *node, ir_node *op) {
1483 assert (node->op == op_Conv);
1484 set_irn_n(node, 0, op);
1488 get_Phi_preds_arr (ir_node *node) {
1489 assert (node->op == op_Phi);
1490 return (ir_node **)&(get_irn_in(node)[1]);
1494 get_Phi_n_preds (ir_node *node) {
1495 assert (node->op == op_Phi);
1496 return (get_irn_arity(node));
1500 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1501 assert (node->op == op_Phi);
1506 get_Phi_pred (ir_node *node, int pos) {
1507 assert (node->op == op_Phi);
1508 return get_irn_n(node, pos);
1512 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1513 assert (node->op == op_Phi);
1514 set_irn_n(node, pos, pred);
1518 get_Load_mem (ir_node *node) {
1519 assert (node->op == op_Load);
1520 return get_irn_n(node, 0);
1524 set_Load_mem (ir_node *node, ir_node *mem) {
1525 assert (node->op == op_Load);
1526 set_irn_n(node, 0, mem);
1530 get_Load_ptr (ir_node *node) {
1531 assert (node->op == op_Load);
1532 return get_irn_n(node, 1);
1536 set_Load_ptr (ir_node *node, ir_node *ptr) {
1537 assert (node->op == op_Load);
1538 set_irn_n(node, 1, ptr);
1543 get_Store_mem (ir_node *node) {
1544 assert (node->op == op_Store);
1545 return get_irn_n(node, 0);
1549 set_Store_mem (ir_node *node, ir_node *mem) {
1550 assert (node->op == op_Store);
1551 set_irn_n(node, 0, mem);
1555 get_Store_ptr (ir_node *node) {
1556 assert (node->op == op_Store);
1557 return get_irn_n(node, 1);
1561 set_Store_ptr (ir_node *node, ir_node *ptr) {
1562 assert (node->op == op_Store);
1563 set_irn_n(node, 1, ptr);
1567 get_Store_value (ir_node *node) {
1568 assert (node->op == op_Store);
1569 return get_irn_n(node, 2);
1573 set_Store_value (ir_node *node, ir_node *value) {
1574 assert (node->op == op_Store);
1575 set_irn_n(node, 2, value);
1579 get_Alloc_mem (ir_node *node) {
1580 assert (node->op == op_Alloc);
1581 return get_irn_n(node, 0);
1585 set_Alloc_mem (ir_node *node, ir_node *mem) {
1586 assert (node->op == op_Alloc);
1587 set_irn_n(node, 0, mem);
1591 get_Alloc_size (ir_node *node) {
1592 assert (node->op == op_Alloc);
1593 return get_irn_n(node, 1);
1597 set_Alloc_size (ir_node *node, ir_node *size) {
1598 assert (node->op == op_Alloc);
1599 set_irn_n(node, 1, size);
1603 get_Alloc_type (ir_node *node) {
1604 assert (node->op == op_Alloc);
1605 return node->attr.a.type = skip_tid(node->attr.a.type);
1609 set_Alloc_type (ir_node *node, type *type) {
1610 assert (node->op == op_Alloc);
1611 node->attr.a.type = type;
1615 get_Alloc_where (ir_node *node) {
1616 assert (node->op == op_Alloc);
1617 return node->attr.a.where;
1621 set_Alloc_where (ir_node *node, where_alloc where) {
1622 assert (node->op == op_Alloc);
1623 node->attr.a.where = where;
1628 get_Free_mem (ir_node *node) {
1629 assert (node->op == op_Free);
1630 return get_irn_n(node, 0);
1634 set_Free_mem (ir_node *node, ir_node *mem) {
1635 assert (node->op == op_Free);
1636 set_irn_n(node, 0, mem);
1640 get_Free_ptr (ir_node *node) {
1641 assert (node->op == op_Free);
1642 return get_irn_n(node, 1);
1646 set_Free_ptr (ir_node *node, ir_node *ptr) {
1647 assert (node->op == op_Free);
1648 set_irn_n(node, 1, ptr);
1652 get_Free_size (ir_node *node) {
1653 assert (node->op == op_Free);
1654 return get_irn_n(node, 2);
1658 set_Free_size (ir_node *node, ir_node *size) {
1659 assert (node->op == op_Free);
1660 set_irn_n(node, 2, size);
1664 get_Free_type (ir_node *node) {
1665 assert (node->op == op_Free);
1666 return node->attr.f = skip_tid(node->attr.f);
1670 set_Free_type (ir_node *node, type *type) {
1671 assert (node->op == op_Free);
1672 node->attr.f = type;
1676 get_Sync_preds_arr (ir_node *node) {
1677 assert (node->op == op_Sync);
1678 return (ir_node **)&(get_irn_in(node)[1]);
1682 get_Sync_n_preds (ir_node *node) {
1683 assert (node->op == op_Sync);
1684 return (get_irn_arity(node));
1689 set_Sync_n_preds (ir_node *node, int n_preds) {
1690 assert (node->op == op_Sync);
1695 get_Sync_pred (ir_node *node, int pos) {
1696 assert (node->op == op_Sync);
1697 return get_irn_n(node, pos);
1701 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1702 assert (node->op == op_Sync);
1703 set_irn_n(node, pos, pred);
1707 get_Proj_pred (ir_node *node) {
1708 assert (node->op == op_Proj);
1709 return get_irn_n(node, 0);
1713 set_Proj_pred (ir_node *node, ir_node *pred) {
1714 assert (node->op == op_Proj);
1715 set_irn_n(node, 0, pred);
1719 get_Proj_proj (ir_node *node) {
1720 assert (node->op == op_Proj);
1721 return node->attr.proj;
1725 set_Proj_proj (ir_node *node, long proj) {
1726 assert (node->op == op_Proj);
1727 node->attr.proj = proj;
1731 get_Tuple_preds_arr (ir_node *node) {
1732 assert (node->op == op_Tuple);
1733 return (ir_node **)&(get_irn_in(node)[1]);
1737 get_Tuple_n_preds (ir_node *node) {
1738 assert (node->op == op_Tuple);
1739 return (get_irn_arity(node));
1744 set_Tuple_n_preds (ir_node *node, int n_preds) {
1745 assert (node->op == op_Tuple);
1750 get_Tuple_pred (ir_node *node, int pos) {
1751 assert (node->op == op_Tuple);
1752 return get_irn_n(node, pos);
1756 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1757 assert (node->op == op_Tuple);
1758 set_irn_n(node, pos, pred);
1762 get_Id_pred (ir_node *node) {
1763 assert (node->op == op_Id);
1764 return get_irn_n(node, 0);
1768 set_Id_pred (ir_node *node, ir_node *pred) {
1769 assert (node->op == op_Id);
1770 set_irn_n(node, 0, pred);
1773 /******************************************************************/
1774 /* Auxiliary routines */
1775 /******************************************************************/
1778 skip_Proj (ir_node *node) {
1779 /* don't assert node !!! */
1780 if (node && (node->op == op_Proj)) {
1781 return get_Proj_pred(node);
1788 skip_Tuple (ir_node *node) {
1789 if ((node->op == op_Proj) && (get_irn_op(get_Proj_pred(node)) == op_Tuple))
1790 return get_Tuple_pred(get_Proj_pred(node), get_Proj_proj(node));
1796 skip_nop (ir_node *node) {
1797 /* don't assert node !!! */
1799 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1800 /* Don't use get_Id_pred: We get into an endless loop for
1801 self-referencing Ids. */
1802 assert (get_irn_arity (node) > 0);
1803 return node->in[0+1];
1810 is_Bad (ir_node *node) {
1812 if ((node) && get_irn_opcode(node) == iro_Bad)
1818 is_no_Block (ir_node *node) {
1820 return (get_irn_opcode(node) != iro_Block);
1823 /* Returns true if the operation manipulates control flow. */
1825 is_cfop(ir_node *node) {
1826 return ( (get_irn_opcode(node) == iro_Start)
1827 || (get_irn_opcode(node) == iro_Jmp)
1828 || (get_irn_opcode(node) == iro_Cond)
1829 || (get_irn_opcode(node) == iro_Return)
1830 || (get_irn_opcode(node) == iro_Raise)
1831 || (get_irn_opcode(node) == iro_Bad));
1834 /* Returns true if the operation can change the control flow because
1837 is_fragile_op(ir_node *node) {
1838 return ( (get_irn_opcode(node) == iro_Call)
1839 || (get_irn_opcode(node) == iro_Quot)
1840 || (get_irn_opcode(node) == iro_DivMod)
1841 || (get_irn_opcode(node) == iro_Div)
1842 || (get_irn_opcode(node) == iro_Mod)
1843 || (get_irn_opcode(node) == iro_Load)
1844 || (get_irn_opcode(node) == iro_Store)
1845 || (get_irn_opcode(node) == iro_Alloc)
1846 || (get_irn_opcode(node) == iro_Bad));
1850 /* Returns the memory operand of fragile operations. */
1851 ir_node *get_fragile_op_mem(ir_node *node) {
1852 assert(node && is_fragile_op(node));
1854 switch (get_irn_opcode (node)) {
1863 return get_irn_n(node, 0);