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);
95 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
96 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
101 res->node_nr = get_irp_new_node_nr();
107 /* Copies all attributes stored in the old node to the new node.
108 Assumes both have the same opcode and sufficient size. */
110 copy_attrs (ir_node *old, ir_node *new) {
111 assert (get_irn_opcode(old) == get_irn_opcode(new));
112 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
115 /* IR-Nodes with attributes */
117 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
120 ir_node *np = XP_GETARG (ir_node *, 0);
123 XPS ("<null ir_node>");
127 XPF1 ("%I", get_irn_opident(np));
129 switch (get_irn_opcode (np)) { /* node label */
131 XPF1 ("%I", get_irn_mode(np)->name);
133 XPF1 ("%v", get_irn_const_attr);
136 if (get_irn_modecode (np) == irm_b) {
138 XP (pnc_name_arr[get_irn_proj_attr(np)]);
139 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
141 XP (pns_name_arr[get_irn_proj_attr(np)]);
143 XPF1 ("%I", get_irn_mode(np)->name);
145 XPF1 ("%d", get_irn_proj_attr(np));
149 XPF1 ("%I", get_irn_mode(np)->name);
151 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
152 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
154 case iro_Start: /* don't dump mode of these */
163 XPF1 ("%I", get_irn_mode(np)->name);
169 /** getting some parameters from ir_nodes **/
171 /* returns the number of predecessors without the block predecessor. */
173 get_irn_arity (ir_node *node)
176 return (ARR_LEN((node)->in)-1);
179 /* Returns the array with ins. This array is shifted with respect to the
180 array accessed by get_irn_n: The block operand is at position 0 not -1.
181 (@@@ This should be changed.)
182 The order of the predecessors in this array is not guaranteed, except that
183 lists of operands as predecessors of Block or arguments of a Call are
186 get_irn_in (ir_node *node)
193 set_irn_in (ir_node *node, int arity, ir_node **in) {
195 if (arity != get_irn_arity(node)) {
196 ir_node *block = node->in[0];
197 node->in = NEW_ARR_D (ir_node *, current_ir_graph->obst, (arity+1));
200 memcpy (&node->in[1], in, sizeof (ir_node *) * arity);
203 /* to iterate through the predecessors without touching the array */
204 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
205 to iterate includind the Block predecessor iterate from i = -1 to
207 If it is a block, the entry -1 is NULL. */
209 get_irn_n (ir_node *node, int n)
212 assert (get_irn_arity (node) > n);
213 return skip_nop(node->in[n+1]);
217 set_irn_n (ir_node *node, int n, ir_node *in)
220 assert (get_irn_arity (node) > n);
225 get_irn_mode (ir_node *node)
232 get_irn_modecode (ir_node *node)
235 return node->mode->code;
240 get_irn_modeident (ir_node *node)
243 return node->mode->name;
247 get_irn_op (ir_node *node)
253 /* should be private to the library: */
255 set_irn_op (ir_node *node, ir_op *op)
262 get_irn_opcode (ir_node *node)
265 return node->op->code;
269 get_irn_opname (ir_node *node)
272 return id_to_str(node->op->name);
276 get_irn_opident (ir_node *node)
279 return node->op->name;
283 get_irn_visited (ir_node *node)
286 return node->visited;
290 set_irn_visited (ir_node *node, unsigned long visited)
293 node->visited = visited;
296 set_irn_link (ir_node *node, ir_node *link) {
302 get_irn_link (ir_node *node) {
308 /* Outputs a unique number for this node */
310 get_irn_node_nr(ir_node *node) {
312 return node->node_nr;
317 get_irn_const_attr (ir_node *node)
319 assert (node->op == op_Const);
320 return node->attr.con;
324 get_irn_proj_attr (ir_node *node)
326 assert (node->op == op_Proj);
327 return node->attr.proj;
331 get_irn_alloc_attr (ir_node *node)
333 assert (node->op == op_Alloc);
338 get_irn_free_attr (ir_node *node)
340 assert (node->op == op_Free);
341 return node->attr.f = skip_tid(node->attr.f);
345 get_irn_symconst_attr (ir_node *node)
347 assert (node->op == op_SymConst);
352 get_irn_call_attr (ir_node *node)
354 assert (node->op == op_Call);
355 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
359 get_irn_sel_attr (ir_node *node)
361 assert (node->op == op_Sel);
366 get_irn_phi_attr (ir_node *node)
368 assert (node->op == op_Phi);
369 return node->attr.phi0_pos;
373 get_irn_block_attr (ir_node *node)
375 assert (node->op == op_Block);
376 return node->attr.block;
379 /** manipulate fields of individual nodes **/
381 /* this works for all except Block */
383 get_nodes_Block (ir_node *node) {
384 assert (!(node->op == op_Block));
385 return get_irn_n(node, -1);
389 set_nodes_Block (ir_node *node, ir_node *block) {
390 assert (!(node->op == op_Block));
391 set_irn_n(node, -1, block);
394 /* Returns an array with the predecessors of the Block. Depending on
395 the implementation of the graph datastructure this can be a copy of
396 the internal representation of predecessors as well as the internal
397 array itself. Therefore writing to this array might obstruct the ir. */
399 get_Block_cfgpred_arr (ir_node *node)
401 assert ((node->op == op_Block));
402 return (ir_node **)&(get_irn_in(node)[1]);
407 get_Block_n_cfgpreds (ir_node *node) {
408 assert ((node->op == op_Block));
409 return (get_irn_arity(node));
414 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
415 assert ((node->op == op_Block));
420 get_Block_cfgpred (ir_node *node, int pos) {
421 assert (node->op == op_Block);
422 return get_irn_n(node, pos);
426 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
427 assert (node->op == op_Block);
428 set_irn_n(node, pos, pred);
432 get_Block_matured (ir_node *node) {
433 assert (node->op == op_Block);
434 return node->attr.block.matured;
438 set_Block_matured (ir_node *node, bool matured) {
439 assert (node->op == op_Block);
440 node->attr.block.matured = matured;
443 get_Block_block_visited (ir_node *node) {
444 assert (node->op == op_Block);
445 return node->attr.block.block_visited;
449 set_Block_block_visited (ir_node *node, unsigned long visit) {
450 assert (node->op == op_Block);
451 node->attr.block.block_visited = visit;
455 get_Block_graph_arr (ir_node *node, int pos) {
456 assert (node->op == op_Block);
457 return node->attr.block.graph_arr[pos+1];
461 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
462 assert (node->op == op_Block);
463 node->attr.block.graph_arr[pos+1] = value;
466 > Implementing the case construct (which is where the constant Proj node is
467 > important) involves far more than simply determining the constant values.
468 > We could argue that this is more properly a function of the translator from
469 > Firm to the target machine. That could be done if there was some way of
470 > projecting "default" out of the Cond node.
471 I know it's complicated.
472 Basically there are two proglems:
473 - determining the gaps between the projs
474 - determining the biggest case constant to konw the proj number for
476 I see several solutions:
477 1. Introduce a ProjDefault node. Solves both problems.
478 This means to extend all optimizations executed during construction.
479 2. Give the Cond node for switch two flavors:
480 a) there are no gaps in the projs (existing flavor)
481 b) gaps may exist, default proj is still the Proj with the largest
482 projection number. This covers also the gaps.
483 3. Fix the semantic of the Cond to that of 2b)
485 Solution 2 seems to be the best:
486 Computing the gaps in the Firm representation is not too hard, i.e.,
487 libfirm can implement a routine that transforms betweeen the two
488 flavours. This is also possible for 1) but 2) does not require to
489 change any existing optimization.
490 Further it should be far simpler to determine the biggest constant than
492 I don't want to choose 3) as 2a) seems to have advantages for
493 dataflow analysis and 3) does not allow to convert the representation to
497 get_Cond_selector (ir_node *node) {
498 assert (node->op == op_Cond);
499 return get_irn_n(node, 0);
503 set_Cond_selector (ir_node *node, ir_node *selector) {
504 assert (node->op == op_Cond);
505 set_irn_n(node, 0, selector);
509 get_Cond_kind (ir_node *node) {
510 assert (node->op == op_Cond);
511 return node->attr.c.kind;
515 set_Cond_kind (ir_node *node, cond_kind kind) {
516 assert (node->op == op_Cond);
517 node->attr.c.kind = kind;
521 get_Return_mem (ir_node *node) {
522 assert (node->op == op_Return);
523 return get_irn_n(node, 0);
527 set_Return_mem (ir_node *node, ir_node *mem) {
528 assert (node->op == op_Return);
529 set_irn_n(node, 0, mem);
533 get_Return_res_arr (ir_node *node)
535 assert ((node->op == op_Return));
536 if (get_Return_n_res(node) > 0)
537 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
543 get_Return_n_res (ir_node *node) {
544 assert (node->op == op_Return);
545 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
550 set_Return_n_res (ir_node *node, int results) {
551 assert (node->op == op_Return);
556 get_Return_res (ir_node *node, int pos) {
557 assert (node->op == op_Return);
558 assert (get_Return_n_res(node) > pos);
559 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
563 set_Return_res (ir_node *node, int pos, ir_node *res){
564 assert (node->op == op_Return);
565 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
569 get_Raise_mem (ir_node *node) {
570 assert (node->op == op_Return);
571 return get_irn_n(node, 0);
575 set_Raise_mem (ir_node *node, ir_node *mem) {
576 assert (node->op == op_Raise);
577 set_irn_n(node, 0, mem);
581 get_Raise_exo_ptr (ir_node *node) {
582 assert (node->op == op_Raise);
583 return get_irn_n(node, 1);
587 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
588 assert (node->op == op_Raise);
589 set_irn_n(node, 1, exo_ptr);
592 inline tarval *get_Const_tarval (ir_node *node) {
593 assert (node->op == op_Const);
594 return get_irn_const_attr(node);
598 set_Const_tarval (ir_node *node, tarval *con) {
599 assert (node->op == op_Const);
600 node->attr.con = con;
604 get_SymConst_kind (ir_node *node) {
605 assert (node->op == op_SymConst);
606 return node->attr.i.num;
610 set_SymConst_kind (ir_node *node, symconst_kind num) {
611 assert (node->op == op_SymConst);
612 node->attr.i.num = num;
616 get_SymConst_type (ir_node *node) {
617 assert ( (node->op == op_SymConst)
618 && ( get_SymConst_kind(node) == type_tag
619 || get_SymConst_kind(node) == size));
620 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
624 set_SymConst_type (ir_node *node, type *type) {
625 assert ( (node->op == op_SymConst)
626 && ( get_SymConst_kind(node) == type_tag
627 || get_SymConst_kind(node) == size));
628 node->attr.i.tori.typ = type;
632 get_SymConst_ptrinfo (ir_node *node) {
633 assert ( (node->op == op_SymConst)
634 && (get_SymConst_kind(node) == linkage_ptr_info));
635 return node->attr.i.tori.ptrinfo;
639 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
640 assert ( (node->op == op_SymConst)
641 && (get_SymConst_kind(node) == linkage_ptr_info));
642 node->attr.i.tori.ptrinfo = ptrinfo;
646 get_SymConst_type_or_id (ir_node *node) {
647 assert (node->op == op_SymConst);
648 return &(node->attr.i.tori);
652 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
653 assert (node->op == op_SymConst);
654 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
658 get_Sel_mem (ir_node *node) {
659 assert (node->op == op_Sel);
660 return get_irn_n(node, 0);
664 set_Sel_mem (ir_node *node, ir_node *mem) {
665 assert (node->op == op_Sel);
666 set_irn_n(node, 0, mem);
670 get_Sel_ptr (ir_node *node) {
671 assert (node->op == op_Sel);
672 return get_irn_n(node, 1);
676 set_Sel_ptr (ir_node *node, ir_node *ptr) {
677 assert (node->op == op_Sel);
678 set_irn_n(node, 1, ptr);
682 get_Sel_index_arr (ir_node *node)
684 assert ((node->op == op_Sel));
685 if (get_Sel_n_index(node) > 0)
686 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
692 get_Sel_n_index (ir_node *node) {
693 assert (node->op == op_Sel);
694 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
699 set_Sel_n_index (ir_node *node, int n_index) {
700 assert (node->op == op_Sel);
705 get_Sel_index (ir_node *node, int pos) {
706 assert (node->op == op_Sel);
707 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
711 set_Sel_index (ir_node *node, int pos, ir_node *index) {
712 assert (node->op == op_Sel);
713 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
717 get_Sel_entity (ir_node *node) {
718 assert (node->op == op_Sel);
719 return node->attr.s.ent;
723 set_Sel_entity (ir_node *node, entity *ent) {
724 assert (node->op == op_Sel);
725 node->attr.s.ent = ent;
729 get_Sel_linkage_type (ir_node *node) {
730 assert (node->op == op_Sel);
731 return node->attr.s.ltyp;
735 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
736 assert (node->op == op_Sel);
737 node->attr.s.ltyp = lt;
741 get_Call_mem (ir_node *node) {
742 assert (node->op == op_Call);
743 return get_irn_n(node, 0);
747 set_Call_mem (ir_node *node, ir_node *mem) {
748 assert (node->op == op_Call);
749 set_irn_n(node, 0, mem);
753 get_Call_ptr (ir_node *node) {
754 assert (node->op == op_Call);
755 return get_irn_n(node, 1);
759 set_Call_ptr (ir_node *node, ir_node *ptr) {
760 assert (node->op == op_Call);
761 set_irn_n(node, 1, ptr);
765 get_Call_param_arr (ir_node *node) {
766 assert (node->op == op_Call);
767 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
771 get_Call_n_params (ir_node *node) {
772 assert (node->op == op_Call);
773 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
777 get_Call_arity (ir_node *node) {
778 return get_Call_n_params(node);
782 set_Call_arity (ir_node *node, ir_node *arity) {
783 assert (node->op == op_Call);
788 get_Call_param (ir_node *node, int pos) {
789 assert (node->op == op_Call);
790 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
794 set_Call_param (ir_node *node, int pos, ir_node *param) {
795 assert (node->op == op_Call);
796 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
800 get_Call_type (ir_node *node) {
801 assert (node->op == op_Call);
802 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
806 set_Call_type (ir_node *node, type *type) {
807 assert (node->op == op_Call);
808 assert (is_method_type(type));
809 node->attr.call.cld_tp = type;
812 /* For unary and binary arithmetic operations the access to the
813 operands can be factored out. Left is the first, right the
814 second arithmetic value as listed in tech report 0999-33.
815 unops are: Minus, Abs, Not, Conv
816 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
817 Shr, Shrs, Rotate, Cmp */
820 is_unop (ir_node *node) {
821 return ( node->op == op_Minus ||
822 node->op == op_Abs ||
823 node->op == op_Not ||
824 node->op == op_Conv );
828 get_unop_op (ir_node *node) {
829 assert ( node->op == op_Minus ||
830 node->op == op_Abs ||
831 node->op == op_Not ||
832 node->op == op_Conv );
833 switch (get_irn_opcode (node)) {
834 case iro_Minus: return get_Minus_op(node); break;
835 case iro_Abs: return get_Abs_op(node); break;
836 case iro_Not: return get_Not_op(node); break;
837 case iro_Conv: return get_Conv_op(node); break;
838 default: return NULL;
843 set_unop_op (ir_node *node, ir_node *op) {
844 assert (node->op == op_Minus ||
845 node->op == op_Abs ||
846 node->op == op_Not ||
847 node->op == op_Conv );
848 switch (get_irn_opcode (node)) {
849 case iro_Minus: set_Minus_op(node, op); break;
850 case iro_Abs: set_Abs_op(node, op); break;
851 case iro_Not: set_Not_op(node, op); break;
852 case iro_Conv: set_Conv_op(node, op); break;
859 is_binop (ir_node *node) {
860 return (node->op == op_Add ||
861 node->op == op_Sub ||
862 node->op == op_Mul ||
863 node->op == op_Quot ||
864 node->op == op_DivMod ||
865 node->op == op_Div ||
866 node->op == op_Mod ||
867 node->op == op_And ||
869 node->op == op_Eor ||
870 node->op == op_Shl ||
871 node->op == op_Shr ||
872 node->op == op_Shrs ||
873 node->op == op_Rot ||
874 node->op == op_Cmp );
878 get_binop_left (ir_node *node) {
879 assert (node->op == op_Add ||
880 node->op == op_Sub ||
881 node->op == op_Mul ||
882 node->op == op_Quot ||
883 node->op == op_DivMod ||
884 node->op == op_Div ||
885 node->op == op_Mod ||
886 node->op == op_And ||
888 node->op == op_Eor ||
889 node->op == op_Shl ||
890 node->op == op_Shr ||
891 node->op == op_Shrs ||
892 node->op == op_Rot ||
893 node->op == op_Cmp );
895 switch (get_irn_opcode (node)) {
896 case iro_Add : return get_Add_left(node); break;
897 case iro_Sub : return get_Sub_left(node); break;
898 case iro_Mul : return get_Mul_left(node); break;
899 case iro_Quot : return get_Quot_left(node); break;
900 case iro_DivMod: return get_DivMod_left(node); break;
901 case iro_Div : return get_Div_left(node); break;
902 case iro_Mod : return get_Mod_left(node); break;
903 case iro_And : return get_And_left(node); break;
904 case iro_Or : return get_Or_left(node); break;
905 case iro_Eor : return get_Eor_left(node); break;
906 case iro_Shl : return get_Shl_left(node); break;
907 case iro_Shr : return get_Shr_left(node); break;
908 case iro_Shrs : return get_Shrs_left(node); break;
909 case iro_Rot : return get_Rot_left(node); break;
910 case iro_Cmp : return get_Cmp_left(node); break;
911 default: return NULL;
916 set_binop_left (ir_node *node, ir_node *left) {
917 assert (node->op == op_Add ||
918 node->op == op_Sub ||
919 node->op == op_Mul ||
920 node->op == op_Quot ||
921 node->op == op_DivMod ||
922 node->op == op_Div ||
923 node->op == op_Mod ||
924 node->op == op_And ||
926 node->op == op_Eor ||
927 node->op == op_Shl ||
928 node->op == op_Shr ||
929 node->op == op_Shrs ||
930 node->op == op_Rot ||
931 node->op == op_Cmp );
933 switch (get_irn_opcode (node)) {
934 case iro_Add : set_Add_left(node, left); break;
935 case iro_Sub : set_Sub_left(node, left); break;
936 case iro_Mul : set_Mul_left(node, left); break;
937 case iro_Quot : set_Quot_left(node, left); break;
938 case iro_DivMod: set_DivMod_left(node, left); break;
939 case iro_Div : set_Div_left(node, left); break;
940 case iro_Mod : set_Mod_left(node, left); break;
941 case iro_And : set_And_left(node, left); break;
942 case iro_Or : set_Or_left(node, left); break;
943 case iro_Eor : set_Eor_left(node, left); break;
944 case iro_Shl : set_Shl_left(node, left); break;
945 case iro_Shr : set_Shr_left(node, left); break;
946 case iro_Shrs : set_Shrs_left(node, left); break;
947 case iro_Rot : set_Rot_left(node, left); break;
948 case iro_Cmp : set_Cmp_left(node, left); break;
954 get_binop_right (ir_node *node) {
955 assert (node->op == op_Add ||
956 node->op == op_Sub ||
957 node->op == op_Mul ||
958 node->op == op_Quot ||
959 node->op == op_DivMod ||
960 node->op == op_Div ||
961 node->op == op_Mod ||
962 node->op == op_And ||
964 node->op == op_Eor ||
965 node->op == op_Shl ||
966 node->op == op_Shr ||
967 node->op == op_Shrs ||
968 node->op == op_Rot ||
969 node->op == op_Cmp );
971 switch (get_irn_opcode (node)) {
972 case iro_Add : return get_Add_right(node); break;
973 case iro_Sub : return get_Sub_right(node); break;
974 case iro_Mul : return get_Mul_right(node); break;
975 case iro_Quot : return get_Quot_right(node); break;
976 case iro_DivMod: return get_DivMod_right(node); break;
977 case iro_Div : return get_Div_right(node); break;
978 case iro_Mod : return get_Mod_right(node); break;
979 case iro_And : return get_And_right(node); break;
980 case iro_Or : return get_Or_right(node); break;
981 case iro_Eor : return get_Eor_right(node); break;
982 case iro_Shl : return get_Shl_right(node); break;
983 case iro_Shr : return get_Shr_right(node); break;
984 case iro_Shrs : return get_Shrs_right(node); break;
985 case iro_Rot : return get_Rot_right(node); break;
986 case iro_Cmp : return get_Cmp_right(node); break;
987 default: return NULL;
992 set_binop_right (ir_node *node, ir_node *right) {
993 assert (node->op == op_Add ||
994 node->op == op_Sub ||
995 node->op == op_Mul ||
996 node->op == op_Quot ||
997 node->op == op_DivMod ||
998 node->op == op_Div ||
999 node->op == op_Mod ||
1000 node->op == op_And ||
1001 node->op == op_Or ||
1002 node->op == op_Eor ||
1003 node->op == op_Shl ||
1004 node->op == op_Shr ||
1005 node->op == op_Shrs ||
1006 node->op == op_Rot ||
1007 node->op == op_Cmp );
1009 switch (get_irn_opcode (node)) {
1010 case iro_Add : set_Add_right(node, right); break;
1011 case iro_Sub : set_Sub_right(node, right); break;
1012 case iro_Mul : set_Mul_right(node, right); break;
1013 case iro_Quot : set_Quot_right(node, right); break;
1014 case iro_DivMod: set_DivMod_right(node, right); break;
1015 case iro_Div : set_Div_right(node, right); break;
1016 case iro_Mod : set_Mod_right(node, right); break;
1017 case iro_And : set_And_right(node, right); break;
1018 case iro_Or : set_Or_right(node, right); break;
1019 case iro_Eor : set_Eor_right(node, right); break;
1020 case iro_Shl : set_Shl_right(node, right); break;
1021 case iro_Shr : set_Shr_right(node, right); break;
1022 case iro_Shrs : set_Shrs_right(node, right); break;
1023 case iro_Rot : set_Rot_right(node, right); break;
1024 case iro_Cmp : set_Cmp_right(node, right); break;
1030 get_Add_left (ir_node *node) {
1031 assert (node->op == op_Add);
1032 return get_irn_n(node, 0);
1036 set_Add_left (ir_node *node, ir_node *left) {
1037 assert (node->op == op_Add);
1038 set_irn_n(node, 0, left);
1042 get_Add_right (ir_node *node) {
1043 assert (node->op == op_Add);
1044 return get_irn_n(node, 1);
1048 set_Add_right (ir_node *node, ir_node *right) {
1049 assert (node->op == op_Add);
1050 set_irn_n(node, 1, right);
1054 get_Sub_left (ir_node *node) {
1055 assert (node->op == op_Sub);
1056 return get_irn_n(node, 0);
1060 set_Sub_left (ir_node *node, ir_node *left) {
1061 assert (node->op == op_Sub);
1062 set_irn_n(node, 0, left);
1066 get_Sub_right (ir_node *node) {
1067 assert (node->op == op_Sub);
1068 return get_irn_n(node, 1);
1072 set_Sub_right (ir_node *node, ir_node *right) {
1073 assert (node->op == op_Sub);
1074 set_irn_n(node, 1, right);
1079 get_Minus_op (ir_node *node) {
1080 assert (node->op == op_Minus);
1081 return get_irn_n(node, 0);
1085 set_Minus_op (ir_node *node, ir_node *op) {
1086 assert (node->op == op_Minus);
1087 set_irn_n(node, 0, op);
1092 get_Mul_left (ir_node *node) {
1093 assert (node->op == op_Mul);
1094 return get_irn_n(node, 0);
1098 set_Mul_left (ir_node *node, ir_node *left) {
1099 assert (node->op == op_Mul);
1100 set_irn_n(node, 0, left);
1104 get_Mul_right (ir_node *node) {
1105 assert (node->op == op_Mul);
1106 return get_irn_n(node, 1);
1110 set_Mul_right (ir_node *node, ir_node *right) {
1111 assert (node->op == op_Mul);
1112 set_irn_n(node, 1, right);
1116 get_Quot_left (ir_node *node) {
1117 assert (node->op == op_Quot);
1118 return get_irn_n(node, 1);
1122 set_Quot_left (ir_node *node, ir_node *left) {
1123 assert (node->op == op_Quot);
1124 set_irn_n(node, 1, left);
1128 get_Quot_right (ir_node *node) {
1129 assert (node->op == op_Quot);
1130 return get_irn_n(node, 2);
1134 set_Quot_right (ir_node *node, ir_node *right) {
1135 assert (node->op == op_Quot);
1136 set_irn_n(node, 2, right);
1140 get_Quot_mem (ir_node *node) {
1141 assert (node->op == op_Quot);
1142 return get_irn_n(node, 0);
1146 set_Quot_mem (ir_node *node, ir_node *mem) {
1147 assert (node->op == op_Quot);
1148 set_irn_n(node, 0, mem);
1152 get_DivMod_left (ir_node *node) {
1153 assert (node->op == op_DivMod);
1154 return get_irn_n(node, 1);
1158 set_DivMod_left (ir_node *node, ir_node *left) {
1159 assert (node->op == op_DivMod);
1160 set_irn_n(node, 1, left);
1164 get_DivMod_right (ir_node *node) {
1165 assert (node->op == op_DivMod);
1166 return get_irn_n(node, 2);
1170 set_DivMod_right (ir_node *node, ir_node *right) {
1171 assert (node->op == op_DivMod);
1172 set_irn_n(node, 2, right);
1176 get_DivMod_mem (ir_node *node) {
1177 assert (node->op == op_DivMod);
1178 return get_irn_n(node, 0);
1182 set_DivMod_mem (ir_node *node, ir_node *mem) {
1183 assert (node->op == op_DivMod);
1184 set_irn_n(node, 0, mem);
1188 get_Div_left (ir_node *node) {
1189 assert (node->op == op_Div);
1190 return get_irn_n(node, 1);
1194 set_Div_left (ir_node *node, ir_node *left) {
1195 assert (node->op == op_Div);
1196 set_irn_n(node, 1, left);
1200 get_Div_right (ir_node *node) {
1201 assert (node->op == op_Div);
1202 return get_irn_n(node, 2);
1206 set_Div_right (ir_node *node, ir_node *right) {
1207 assert (node->op == op_Div);
1208 set_irn_n(node, 2, right);
1212 get_Div_mem (ir_node *node) {
1213 assert (node->op == op_Div);
1214 return get_irn_n(node, 0);
1218 set_Div_mem (ir_node *node, ir_node *mem) {
1219 assert (node->op == op_Div);
1220 set_irn_n(node, 0, mem);
1224 get_Mod_left (ir_node *node) {
1225 assert (node->op == op_Mod);
1226 return get_irn_n(node, 1);
1230 set_Mod_left (ir_node *node, ir_node *left) {
1231 assert (node->op == op_Mod);
1232 set_irn_n(node, 1, left);
1236 get_Mod_right (ir_node *node) {
1237 assert (node->op == op_Mod);
1238 return get_irn_n(node, 2);
1242 set_Mod_right (ir_node *node, ir_node *right) {
1243 assert (node->op == op_Mod);
1244 set_irn_n(node, 2, right);
1248 get_Mod_mem (ir_node *node) {
1249 assert (node->op == op_Mod);
1250 return get_irn_n(node, 0);
1254 set_Mod_mem (ir_node *node, ir_node *mem) {
1255 assert (node->op == op_Mod);
1256 set_irn_n(node, 0, mem);
1260 get_Abs_op (ir_node *node) {
1261 assert (node->op == op_Abs);
1262 return get_irn_n(node, 0);
1266 set_Abs_op (ir_node *node, ir_node *op) {
1267 assert (node->op == op_Abs);
1268 set_irn_n(node, 0, op);
1272 get_And_left (ir_node *node) {
1273 assert (node->op == op_And);
1274 return get_irn_n(node, 0);
1278 set_And_left (ir_node *node, ir_node *left) {
1279 assert (node->op == op_And);
1280 set_irn_n(node, 0, left);
1284 get_And_right (ir_node *node) {
1285 assert (node->op == op_And);
1286 return get_irn_n(node, 1);
1290 set_And_right (ir_node *node, ir_node *right) {
1291 assert (node->op == op_And);
1292 set_irn_n(node, 1, right);
1296 get_Or_left (ir_node *node) {
1297 assert (node->op == op_Or);
1298 return get_irn_n(node, 0);
1302 set_Or_left (ir_node *node, ir_node *left) {
1303 assert (node->op == op_Or);
1304 set_irn_n(node, 0, left);
1308 get_Or_right (ir_node *node) {
1309 assert (node->op == op_Or);
1310 return get_irn_n(node, 1);
1314 set_Or_right (ir_node *node, ir_node *right) {
1315 assert (node->op == op_Or);
1316 set_irn_n(node, 1, right);
1320 get_Eor_left (ir_node *node) {
1321 assert (node->op == op_Eor);
1322 return get_irn_n(node, 0);
1326 set_Eor_left (ir_node *node, ir_node *left) {
1327 assert (node->op == op_Eor);
1328 set_irn_n(node, 0, left);
1332 get_Eor_right (ir_node *node) {
1333 assert (node->op == op_Eor);
1334 return get_irn_n(node, 1);
1338 set_Eor_right (ir_node *node, ir_node *right) {
1339 assert (node->op == op_Eor);
1340 set_irn_n(node, 1, right);
1345 get_Not_op (ir_node *node) {
1346 assert (node->op == op_Not);
1347 return get_irn_n(node, 0);
1351 set_Not_op (ir_node *node, ir_node *op) {
1352 assert (node->op == op_Not);
1353 set_irn_n(node, 0, op);
1358 get_Shl_left (ir_node *node) {
1359 assert (node->op == op_Shl);
1360 return get_irn_n(node, 0);
1364 set_Shl_left (ir_node *node, ir_node *left) {
1365 assert (node->op == op_Shl);
1366 set_irn_n(node, 0, left);
1370 get_Shl_right (ir_node *node) {
1371 assert (node->op == op_Shl);
1372 return get_irn_n(node, 1);
1376 set_Shl_right (ir_node *node, ir_node *right) {
1377 assert (node->op == op_Shl);
1378 set_irn_n(node, 1, right);
1382 get_Shr_left (ir_node *node) {
1383 assert (node->op == op_Shr);
1384 return get_irn_n(node, 0);
1388 set_Shr_left (ir_node *node, ir_node *left) {
1389 assert (node->op == op_Shr);
1390 set_irn_n(node, 0, left);
1394 get_Shr_right (ir_node *node) {
1395 assert (node->op == op_Shr);
1396 return get_irn_n(node, 1);
1400 set_Shr_right (ir_node *node, ir_node *right) {
1401 assert (node->op == op_Shr);
1402 set_irn_n(node, 1, right);
1406 get_Shrs_left (ir_node *node) {
1407 assert (node->op == op_Shrs);
1408 return get_irn_n(node, 0);
1412 set_Shrs_left (ir_node *node, ir_node *left) {
1413 assert (node->op == op_Shrs);
1414 set_irn_n(node, 0, left);
1418 get_Shrs_right (ir_node *node) {
1419 assert (node->op == op_Shrs);
1420 return get_irn_n(node, 1);
1424 set_Shrs_right (ir_node *node, ir_node *right) {
1425 assert (node->op == op_Shrs);
1426 set_irn_n(node, 1, right);
1430 get_Rot_left (ir_node *node) {
1431 assert (node->op == op_Rot);
1432 return get_irn_n(node, 0);
1436 set_Rot_left (ir_node *node, ir_node *left) {
1437 assert (node->op == op_Rot);
1438 set_irn_n(node, 0, left);
1442 get_Rot_right (ir_node *node) {
1443 assert (node->op == op_Rot);
1444 return get_irn_n(node, 1);
1448 set_Rot_right (ir_node *node, ir_node *right) {
1449 assert (node->op == op_Rot);
1450 set_irn_n(node, 1, right);
1454 get_Cmp_left (ir_node *node) {
1455 assert (node->op == op_Cmp);
1456 return get_irn_n(node, 0);
1460 set_Cmp_left (ir_node *node, ir_node *left) {
1461 assert (node->op == op_Cmp);
1462 set_irn_n(node, 0, left);
1466 get_Cmp_right (ir_node *node) {
1467 assert (node->op == op_Cmp);
1468 return get_irn_n(node, 1);
1472 set_Cmp_right (ir_node *node, ir_node *right) {
1473 assert (node->op == op_Cmp);
1474 set_irn_n(node, 1, right);
1478 get_Conv_op (ir_node *node) {
1479 assert (node->op == op_Conv);
1480 return get_irn_n(node, 0);
1484 set_Conv_op (ir_node *node, ir_node *op) {
1485 assert (node->op == op_Conv);
1486 set_irn_n(node, 0, op);
1490 get_Phi_preds_arr (ir_node *node) {
1491 assert (node->op == op_Phi);
1492 return (ir_node **)&(get_irn_in(node)[1]);
1496 get_Phi_n_preds (ir_node *node) {
1497 assert (node->op == op_Phi);
1498 return (get_irn_arity(node));
1502 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1503 assert (node->op == op_Phi);
1508 get_Phi_pred (ir_node *node, int pos) {
1509 assert (node->op == op_Phi);
1510 return get_irn_n(node, pos);
1514 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1515 assert (node->op == op_Phi);
1516 set_irn_n(node, pos, pred);
1520 get_Load_mem (ir_node *node) {
1521 assert (node->op == op_Load);
1522 return get_irn_n(node, 0);
1526 set_Load_mem (ir_node *node, ir_node *mem) {
1527 assert (node->op == op_Load);
1528 set_irn_n(node, 0, mem);
1532 get_Load_ptr (ir_node *node) {
1533 assert (node->op == op_Load);
1534 return get_irn_n(node, 1);
1538 set_Load_ptr (ir_node *node, ir_node *ptr) {
1539 assert (node->op == op_Load);
1540 set_irn_n(node, 1, ptr);
1545 get_Store_mem (ir_node *node) {
1546 assert (node->op == op_Store);
1547 return get_irn_n(node, 0);
1551 set_Store_mem (ir_node *node, ir_node *mem) {
1552 assert (node->op == op_Store);
1553 set_irn_n(node, 0, mem);
1557 get_Store_ptr (ir_node *node) {
1558 assert (node->op == op_Store);
1559 return get_irn_n(node, 1);
1563 set_Store_ptr (ir_node *node, ir_node *ptr) {
1564 assert (node->op == op_Store);
1565 set_irn_n(node, 1, ptr);
1569 get_Store_value (ir_node *node) {
1570 assert (node->op == op_Store);
1571 return get_irn_n(node, 2);
1575 set_Store_value (ir_node *node, ir_node *value) {
1576 assert (node->op == op_Store);
1577 set_irn_n(node, 2, value);
1581 get_Alloc_mem (ir_node *node) {
1582 assert (node->op == op_Alloc);
1583 return get_irn_n(node, 0);
1587 set_Alloc_mem (ir_node *node, ir_node *mem) {
1588 assert (node->op == op_Alloc);
1589 set_irn_n(node, 0, mem);
1593 get_Alloc_size (ir_node *node) {
1594 assert (node->op == op_Alloc);
1595 return get_irn_n(node, 1);
1599 set_Alloc_size (ir_node *node, ir_node *size) {
1600 assert (node->op == op_Alloc);
1601 set_irn_n(node, 1, size);
1605 get_Alloc_type (ir_node *node) {
1606 assert (node->op == op_Alloc);
1607 return node->attr.a.type = skip_tid(node->attr.a.type);
1611 set_Alloc_type (ir_node *node, type *type) {
1612 assert (node->op == op_Alloc);
1613 node->attr.a.type = type;
1617 get_Alloc_where (ir_node *node) {
1618 assert (node->op == op_Alloc);
1619 return node->attr.a.where;
1623 set_Alloc_where (ir_node *node, where_alloc where) {
1624 assert (node->op == op_Alloc);
1625 node->attr.a.where = where;
1630 get_Free_mem (ir_node *node) {
1631 assert (node->op == op_Free);
1632 return get_irn_n(node, 0);
1636 set_Free_mem (ir_node *node, ir_node *mem) {
1637 assert (node->op == op_Free);
1638 set_irn_n(node, 0, mem);
1642 get_Free_ptr (ir_node *node) {
1643 assert (node->op == op_Free);
1644 return get_irn_n(node, 1);
1648 set_Free_ptr (ir_node *node, ir_node *ptr) {
1649 assert (node->op == op_Free);
1650 set_irn_n(node, 1, ptr);
1654 get_Free_size (ir_node *node) {
1655 assert (node->op == op_Free);
1656 return get_irn_n(node, 2);
1660 set_Free_size (ir_node *node, ir_node *size) {
1661 assert (node->op == op_Free);
1662 set_irn_n(node, 2, size);
1666 get_Free_type (ir_node *node) {
1667 assert (node->op == op_Free);
1668 return node->attr.f = skip_tid(node->attr.f);
1672 set_Free_type (ir_node *node, type *type) {
1673 assert (node->op == op_Free);
1674 node->attr.f = type;
1678 get_Sync_preds_arr (ir_node *node) {
1679 assert (node->op == op_Sync);
1680 return (ir_node **)&(get_irn_in(node)[1]);
1684 get_Sync_n_preds (ir_node *node) {
1685 assert (node->op == op_Sync);
1686 return (get_irn_arity(node));
1691 set_Sync_n_preds (ir_node *node, int n_preds) {
1692 assert (node->op == op_Sync);
1697 get_Sync_pred (ir_node *node, int pos) {
1698 assert (node->op == op_Sync);
1699 return get_irn_n(node, pos);
1703 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1704 assert (node->op == op_Sync);
1705 set_irn_n(node, pos, pred);
1709 get_Proj_pred (ir_node *node) {
1710 assert (node->op == op_Proj);
1711 return get_irn_n(node, 0);
1715 set_Proj_pred (ir_node *node, ir_node *pred) {
1716 assert (node->op == op_Proj);
1717 set_irn_n(node, 0, pred);
1721 get_Proj_proj (ir_node *node) {
1722 assert (node->op == op_Proj);
1723 return node->attr.proj;
1727 set_Proj_proj (ir_node *node, long proj) {
1728 assert (node->op == op_Proj);
1729 node->attr.proj = proj;
1733 get_Tuple_preds_arr (ir_node *node) {
1734 assert (node->op == op_Tuple);
1735 return (ir_node **)&(get_irn_in(node)[1]);
1739 get_Tuple_n_preds (ir_node *node) {
1740 assert (node->op == op_Tuple);
1741 return (get_irn_arity(node));
1746 set_Tuple_n_preds (ir_node *node, int n_preds) {
1747 assert (node->op == op_Tuple);
1752 get_Tuple_pred (ir_node *node, int pos) {
1753 assert (node->op == op_Tuple);
1754 return get_irn_n(node, pos);
1758 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1759 assert (node->op == op_Tuple);
1760 set_irn_n(node, pos, pred);
1764 get_Id_pred (ir_node *node) {
1765 assert (node->op == op_Id);
1766 return get_irn_n(node, 0);
1770 set_Id_pred (ir_node *node, ir_node *pred) {
1771 assert (node->op == op_Id);
1772 set_irn_n(node, 0, pred);
1775 /******************************************************************/
1776 /* Auxiliary routines */
1777 /******************************************************************/
1780 skip_Proj (ir_node *node) {
1781 /* don't assert node !!! */
1782 if (node && (node->op == op_Proj)) {
1783 return get_Proj_pred(node);
1790 skip_Tuple (ir_node *node) {
1791 if ((node->op == op_Proj) && (get_irn_op(get_Proj_pred(node)) == op_Tuple))
1792 return get_Tuple_pred(get_Proj_pred(node), get_Proj_proj(node));
1798 skip_nop (ir_node *node) {
1799 /* don't assert node !!! */
1801 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1802 /* Don't use get_Id_pred: We get into an endless loop for
1803 self-referencing Ids. */
1804 assert (get_irn_arity (node) > 0);
1805 return node->in[0+1];
1812 is_Bad (ir_node *node) {
1814 if ((node) && get_irn_opcode(node) == iro_Bad)
1820 is_no_Block (ir_node *node) {
1822 return (get_irn_opcode(node) != iro_Block);
1825 /* Returns true if the operation manipulates control flow. */
1827 is_cfop(ir_node *node) {
1828 return ( (get_irn_opcode(node) == iro_Start)
1829 || (get_irn_opcode(node) == iro_Jmp)
1830 || (get_irn_opcode(node) == iro_Cond)
1831 || (get_irn_opcode(node) == iro_Return)
1832 || (get_irn_opcode(node) == iro_Raise)
1833 || (get_irn_opcode(node) == iro_Bad));
1836 /* Returns true if the operation can change the control flow because
1839 is_fragile_op(ir_node *node) {
1840 return ( (get_irn_opcode(node) == iro_Call)
1841 || (get_irn_opcode(node) == iro_Quot)
1842 || (get_irn_opcode(node) == iro_DivMod)
1843 || (get_irn_opcode(node) == iro_Div)
1844 || (get_irn_opcode(node) == iro_Mod)
1845 || (get_irn_opcode(node) == iro_Load)
1846 || (get_irn_opcode(node) == iro_Store)
1847 || (get_irn_opcode(node) == iro_Alloc)
1848 || (get_irn_opcode(node) == iro_Bad));
1852 /* Returns the memory operand of fragile operations. */
1853 ir_node *get_fragile_op_mem(ir_node *node) {
1854 assert(node && is_fragile_op(node));
1856 switch (get_irn_opcode (node)) {
1865 return get_irn_n(node, 0);