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_nameid(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)
190 /* to iterate through the predecessors without touching the array */
191 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
192 to iterate includind the Block predecessor iterate from i = -1 to
194 If it is a block, the entry -1 is NULL. */
196 get_irn_n (ir_node *node, int n)
199 assert (get_irn_arity (node) > n);
200 return skip_nop(node->in[n+1]);
204 set_irn_n (ir_node *node, int n, ir_node *in)
207 assert (get_irn_arity (node) > n);
212 get_irn_mode (ir_node *node)
219 get_irn_modecode (ir_node *node)
222 return node->mode->code;
227 get_irn_modeident (ir_node *node)
230 return node->mode->name;
234 get_irn_op (ir_node *node)
240 /* should be private to the library: */
242 set_irn_op (ir_node *node, ir_op *op)
249 get_irn_opcode (ir_node *node)
252 return node->op->code;
256 get_irn_opname (ir_node *node)
259 return id_to_str(node->op->name);
263 get_irn_opident (ir_node *node)
266 return node->op->name;
270 get_irn_visited (ir_node *node)
273 return node->visited;
277 set_irn_visited (ir_node *node, unsigned long visited)
280 node->visited = visited;
283 set_irn_link (ir_node *node, ir_node *link) {
289 get_irn_link (ir_node *node) {
295 /* Outputs a unique number for this node */
297 get_irn_node_nr(ir_node *node) {
299 return node->node_nr;
304 get_irn_const_attr (ir_node *node)
306 assert (node->op == op_Const);
307 return node->attr.con;
311 get_irn_proj_attr (ir_node *node)
313 assert (node->op == op_Proj);
314 return node->attr.proj;
318 get_irn_alloc_attr (ir_node *node)
320 assert (node->op == op_Alloc);
325 get_irn_free_attr (ir_node *node)
327 assert (node->op == op_Free);
328 return node->attr.f = skip_tid(node->attr.f);
332 get_irn_symconst_attr (ir_node *node)
334 assert (node->op == op_SymConst);
339 get_irn_call_attr (ir_node *node)
341 assert (node->op == op_Call);
342 return node->attr.call = skip_tid(node->attr.call);
346 get_irn_sel_attr (ir_node *node)
348 assert (node->op == op_Sel);
353 get_irn_phi_attr (ir_node *node)
355 assert (node->op == op_Phi);
356 return node->attr.phi0_pos;
360 get_irn_block_attr (ir_node *node)
362 assert (node->op == op_Block);
363 return node->attr.block;
366 /** manipulate fields of individual nodes **/
368 /* this works for all except Block */
370 get_nodes_Block (ir_node *node) {
371 assert (!(node->op == op_Block));
372 return get_irn_n(node, -1);
376 set_nodes_Block (ir_node *node, ir_node *block) {
377 assert (!(node->op == op_Block));
378 set_irn_n(node, -1, block);
381 /* Returns an array with the predecessors of the Block. Depending on
382 the implementation of the graph datastructure this can be a copy of
383 the internal representation of predecessors as well as the internal
384 array itself. Therefore writing to this array might obstruct the ir. */
386 get_Block_cfgpred_arr (ir_node *node)
388 assert ((node->op == op_Block));
389 return (ir_node **)&(get_irn_in(node)[1]);
394 get_Block_n_cfgpreds (ir_node *node) {
395 assert ((node->op == op_Block));
396 return (get_irn_arity(node));
401 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
402 assert ((node->op == op_Block));
407 get_Block_cfgpred (ir_node *node, int pos) {
408 assert (node->op == op_Block);
409 return get_irn_n(node, pos);
413 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
414 assert (node->op == op_Block);
415 set_irn_n(node, pos, pred);
419 get_Block_matured (ir_node *node) {
420 assert (node->op == op_Block);
421 return node->attr.block.matured;
425 set_Block_matured (ir_node *node, bool matured) {
426 assert (node->op == op_Block);
427 node->attr.block.matured = matured;
430 get_Block_block_visited (ir_node *node) {
431 assert (node->op == op_Block);
432 return node->attr.block.block_visited;
436 set_Block_block_visited (ir_node *node, unsigned long visit) {
437 assert (node->op == op_Block);
438 node->attr.block.block_visited = visit;
442 get_Block_graph_arr (ir_node *node, int pos) {
443 assert (node->op == op_Block);
444 return node->attr.block.graph_arr[pos+1];
448 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
449 assert (node->op == op_Block);
450 node->attr.block.graph_arr[pos+1] = value;
453 > Implementing the case construct (which is where the constant Proj node is
454 > important) involves far more than simply determining the constant values.
455 > We could argue that this is more properly a function of the translator from
456 > Firm to the target machine. That could be done if there was some way of
457 > projecting "default" out of the Cond node.
458 I know it's complicated.
459 Basically there are two proglems:
460 - determining the gaps between the projs
461 - determining the biggest case constant to konw the proj number for
463 I see several solutions:
464 1. Introduce a ProjDefault node. Solves both problems.
465 This means to extend all optimizations executed during construction.
466 2. Give the Cond node for switch two flavors:
467 a) there are no gaps in the projs (existing flavor)
468 b) gaps may exist, default proj is still the Proj with the largest
469 projection number. This covers also the gaps.
470 3. Fix the semantic of the Cond to that of 2b)
472 Solution 2 seems to be the best:
473 Computing the gaps in the Firm representation is not too hard, i.e.,
474 libfirm can implement a routine that transforms betweeen the two
475 flavours. This is also possible for 1) but 2) does not require to
476 change any existing optimization.
477 Further it should be far simpler to determine the biggest constant than
479 I don't want to choose 3) as 2a) seems to have advantages for
480 dataflow analysis and 3) does not allow to convert the representation to
484 get_Cond_selector (ir_node *node) {
485 assert (node->op == op_Cond);
486 return get_irn_n(node, 0);
490 set_Cond_selector (ir_node *node, ir_node *selector) {
491 assert (node->op == op_Cond);
492 set_irn_n(node, 0, selector);
496 get_Cond_kind (ir_node *node) {
497 assert (node->op == op_Cond);
498 return node->attr.c.kind;
502 set_Cond_kind (ir_node *node, cond_kind kind) {
503 assert (node->op == op_Cond);
504 node->attr.c.kind = kind;
508 get_Return_mem (ir_node *node) {
509 assert (node->op == op_Return);
510 return get_irn_n(node, 0);
514 set_Return_mem (ir_node *node, ir_node *mem) {
515 assert (node->op == op_Return);
516 set_irn_n(node, 0, mem);
520 get_Return_res_arr (ir_node *node)
522 assert ((node->op == op_Return));
523 if (get_Return_n_res(node) > 0)
524 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
530 get_Return_n_res (ir_node *node) {
531 assert (node->op == op_Return);
532 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
537 set_Return_n_res (ir_node *node, int results) {
538 assert (node->op == op_Return);
543 get_Return_res (ir_node *node, int pos) {
544 assert (node->op == op_Return);
545 assert (get_Return_n_res(node) > pos);
546 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
550 set_Return_res (ir_node *node, int pos, ir_node *res){
551 assert (node->op == op_Return);
552 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
556 get_Raise_mem (ir_node *node) {
557 assert (node->op == op_Return);
558 return get_irn_n(node, 0);
562 set_Raise_mem (ir_node *node, ir_node *mem) {
563 assert (node->op == op_Raise);
564 set_irn_n(node, 0, mem);
568 get_Raise_exo_ptr (ir_node *node) {
569 assert (node->op == op_Raise);
570 return get_irn_n(node, 1);
574 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
575 assert (node->op == op_Raise);
576 set_irn_n(node, 1, exo_ptr);
579 inline tarval *get_Const_tarval (ir_node *node) {
580 assert (node->op == op_Const);
581 return get_irn_const_attr(node);
585 set_Const_tarval (ir_node *node, tarval *con) {
586 assert (node->op == op_Const);
587 node->attr.con = con;
591 get_SymConst_kind (ir_node *node) {
592 assert (node->op == op_SymConst);
593 return node->attr.i.num;
597 set_SymConst_kind (ir_node *node, symconst_kind num) {
598 assert (node->op == op_SymConst);
599 node->attr.i.num = num;
603 get_SymConst_type (ir_node *node) {
604 assert ( (node->op == op_SymConst)
605 && ( get_SymConst_kind(node) == type_tag
606 || get_SymConst_kind(node) == size));
607 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
611 set_SymConst_type (ir_node *node, type *type) {
612 assert ( (node->op == op_SymConst)
613 && ( get_SymConst_kind(node) == type_tag
614 || get_SymConst_kind(node) == size));
615 node->attr.i.tori.typ = type;
619 get_SymConst_ptrinfo (ir_node *node) {
620 assert ( (node->op == op_SymConst)
621 && (get_SymConst_kind(node) == linkage_ptr_info));
622 return node->attr.i.tori.ptrinfo;
626 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
627 assert ( (node->op == op_SymConst)
628 && (get_SymConst_kind(node) == linkage_ptr_info));
629 node->attr.i.tori.ptrinfo = ptrinfo;
633 get_SymConst_type_or_id (ir_node *node) {
634 assert (node->op == op_SymConst);
635 return &(node->attr.i.tori);
639 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
640 assert (node->op == op_SymConst);
641 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
645 get_Sel_mem (ir_node *node) {
646 assert (node->op == op_Sel);
647 return get_irn_n(node, 0);
651 set_Sel_mem (ir_node *node, ir_node *mem) {
652 assert (node->op == op_Sel);
653 set_irn_n(node, 0, mem);
657 get_Sel_ptr (ir_node *node) {
658 assert (node->op == op_Sel);
659 return get_irn_n(node, 1);
663 set_Sel_ptr (ir_node *node, ir_node *ptr) {
664 assert (node->op == op_Sel);
665 set_irn_n(node, 1, ptr);
669 get_Sel_index_arr (ir_node *node)
671 assert ((node->op == op_Sel));
672 if (get_Sel_n_index(node) > 0)
673 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
679 get_Sel_n_index (ir_node *node) {
680 assert (node->op == op_Sel);
681 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
686 set_Sel_n_index (ir_node *node, int n_index) {
687 assert (node->op == op_Sel);
692 get_Sel_index (ir_node *node, int pos) {
693 assert (node->op == op_Sel);
694 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
698 set_Sel_index (ir_node *node, int pos, ir_node *index) {
699 assert (node->op == op_Sel);
700 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
704 get_Sel_entity (ir_node *node) {
705 assert (node->op == op_Sel);
706 return node->attr.s.ent;
710 set_Sel_entity (ir_node *node, entity *ent) {
711 assert (node->op == op_Sel);
712 node->attr.s.ent = ent;
716 get_Sel_linkage_type (ir_node *node) {
717 assert (node->op == op_Sel);
718 return node->attr.s.ltyp;
722 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
723 assert (node->op == op_Sel);
724 node->attr.s.ltyp = lt;
728 get_Call_mem (ir_node *node) {
729 assert (node->op == op_Call);
730 return get_irn_n(node, 0);
734 set_Call_mem (ir_node *node, ir_node *mem) {
735 assert (node->op == op_Call);
736 set_irn_n(node, 0, mem);
740 get_Call_ptr (ir_node *node) {
741 assert (node->op == op_Call);
742 return get_irn_n(node, 1);
746 set_Call_ptr (ir_node *node, ir_node *ptr) {
747 assert (node->op == op_Call);
748 set_irn_n(node, 1, ptr);
752 get_Call_param_arr (ir_node *node) {
753 assert (node->op == op_Call);
754 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
758 get_Call_n_params (ir_node *node) {
759 assert (node->op == op_Call);
760 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
764 get_Call_arity (ir_node *node) {
765 return get_Call_n_params(node);
769 set_Call_arity (ir_node *node, ir_node *arity) {
770 assert (node->op == op_Call);
775 get_Call_param (ir_node *node, int pos) {
776 assert (node->op == op_Call);
777 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
781 set_Call_param (ir_node *node, int pos, ir_node *param) {
782 assert (node->op == op_Call);
783 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
787 get_Call_type (ir_node *node) {
788 assert (node->op == op_Call);
789 return node->attr.call = skip_tid(node->attr.call);
793 set_Call_type (ir_node *node, type *type) {
794 assert (node->op == op_Call);
795 assert (is_method_type(type));
796 node->attr.call = type;
799 /* For unary and binary arithmetic operations the access to the
800 operands can be factored out. Left is the first, right the
801 second arithmetic value as listed in tech report 0999-33.
802 unops are: Minus, Abs, Not, Conv
803 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
804 Shr, Shrs, Rotate, Cmp */
807 is_unop (ir_node *node) {
808 return ( node->op == op_Minus ||
809 node->op == op_Abs ||
810 node->op == op_Not ||
811 node->op == op_Conv );
815 get_unop_op (ir_node *node) {
816 assert ( node->op == op_Minus ||
817 node->op == op_Abs ||
818 node->op == op_Not ||
819 node->op == op_Conv );
820 switch (get_irn_opcode (node)) {
821 case iro_Minus: return get_Minus_op(node); break;
822 case iro_Abs: return get_Abs_op(node); break;
823 case iro_Not: return get_Not_op(node); break;
824 case iro_Conv: return get_Conv_op(node); break;
825 default: return NULL;
830 set_unop_op (ir_node *node, ir_node *op) {
831 assert (node->op == op_Minus ||
832 node->op == op_Abs ||
833 node->op == op_Not ||
834 node->op == op_Conv );
835 switch (get_irn_opcode (node)) {
836 case iro_Minus: set_Minus_op(node, op); break;
837 case iro_Abs: set_Abs_op(node, op); break;
838 case iro_Not: set_Not_op(node, op); break;
839 case iro_Conv: set_Conv_op(node, op); break;
846 is_binop (ir_node *node) {
847 return (node->op == op_Add ||
848 node->op == op_Sub ||
849 node->op == op_Mul ||
850 node->op == op_Quot ||
851 node->op == op_DivMod ||
852 node->op == op_Div ||
853 node->op == op_Mod ||
854 node->op == op_And ||
856 node->op == op_Eor ||
857 node->op == op_Shl ||
858 node->op == op_Shr ||
859 node->op == op_Shrs ||
860 node->op == op_Rot ||
861 node->op == op_Cmp );
865 get_binop_left (ir_node *node) {
866 assert (node->op == op_Add ||
867 node->op == op_Sub ||
868 node->op == op_Mul ||
869 node->op == op_Quot ||
870 node->op == op_DivMod ||
871 node->op == op_Div ||
872 node->op == op_Mod ||
873 node->op == op_And ||
875 node->op == op_Eor ||
876 node->op == op_Shl ||
877 node->op == op_Shr ||
878 node->op == op_Shrs ||
879 node->op == op_Rot ||
880 node->op == op_Cmp );
882 switch (get_irn_opcode (node)) {
883 case iro_Add : return get_Add_left(node); break;
884 case iro_Sub : return get_Sub_left(node); break;
885 case iro_Mul : return get_Mul_left(node); break;
886 case iro_Quot : return get_Quot_left(node); break;
887 case iro_DivMod: return get_DivMod_left(node); break;
888 case iro_Div : return get_Div_left(node); break;
889 case iro_Mod : return get_Mod_left(node); break;
890 case iro_And : return get_And_left(node); break;
891 case iro_Or : return get_Or_left(node); break;
892 case iro_Eor : return get_Eor_left(node); break;
893 case iro_Shl : return get_Shl_left(node); break;
894 case iro_Shr : return get_Shr_left(node); break;
895 case iro_Shrs : return get_Shrs_left(node); break;
896 case iro_Rot : return get_Rot_left(node); break;
897 case iro_Cmp : return get_Cmp_left(node); break;
898 default: return NULL;
903 set_binop_left (ir_node *node, ir_node *left) {
904 assert (node->op == op_Add ||
905 node->op == op_Sub ||
906 node->op == op_Mul ||
907 node->op == op_Quot ||
908 node->op == op_DivMod ||
909 node->op == op_Div ||
910 node->op == op_Mod ||
911 node->op == op_And ||
913 node->op == op_Eor ||
914 node->op == op_Shl ||
915 node->op == op_Shr ||
916 node->op == op_Shrs ||
917 node->op == op_Rot ||
918 node->op == op_Cmp );
920 switch (get_irn_opcode (node)) {
921 case iro_Add : set_Add_left(node, left); break;
922 case iro_Sub : set_Sub_left(node, left); break;
923 case iro_Mul : set_Mul_left(node, left); break;
924 case iro_Quot : set_Quot_left(node, left); break;
925 case iro_DivMod: set_DivMod_left(node, left); break;
926 case iro_Div : set_Div_left(node, left); break;
927 case iro_Mod : set_Mod_left(node, left); break;
928 case iro_And : set_And_left(node, left); break;
929 case iro_Or : set_Or_left(node, left); break;
930 case iro_Eor : set_Eor_left(node, left); break;
931 case iro_Shl : set_Shl_left(node, left); break;
932 case iro_Shr : set_Shr_left(node, left); break;
933 case iro_Shrs : set_Shrs_left(node, left); break;
934 case iro_Rot : set_Rot_left(node, left); break;
935 case iro_Cmp : set_Cmp_left(node, left); break;
941 get_binop_right (ir_node *node) {
942 assert (node->op == op_Add ||
943 node->op == op_Sub ||
944 node->op == op_Mul ||
945 node->op == op_Quot ||
946 node->op == op_DivMod ||
947 node->op == op_Div ||
948 node->op == op_Mod ||
949 node->op == op_And ||
951 node->op == op_Eor ||
952 node->op == op_Shl ||
953 node->op == op_Shr ||
954 node->op == op_Shrs ||
955 node->op == op_Rot ||
956 node->op == op_Cmp );
958 switch (get_irn_opcode (node)) {
959 case iro_Add : return get_Add_right(node); break;
960 case iro_Sub : return get_Sub_right(node); break;
961 case iro_Mul : return get_Mul_right(node); break;
962 case iro_Quot : return get_Quot_right(node); break;
963 case iro_DivMod: return get_DivMod_right(node); break;
964 case iro_Div : return get_Div_right(node); break;
965 case iro_Mod : return get_Mod_right(node); break;
966 case iro_And : return get_And_right(node); break;
967 case iro_Or : return get_Or_right(node); break;
968 case iro_Eor : return get_Eor_right(node); break;
969 case iro_Shl : return get_Shl_right(node); break;
970 case iro_Shr : return get_Shr_right(node); break;
971 case iro_Shrs : return get_Shrs_right(node); break;
972 case iro_Rot : return get_Rot_right(node); break;
973 case iro_Cmp : return get_Cmp_right(node); break;
974 default: return NULL;
979 set_binop_right (ir_node *node, ir_node *right) {
980 assert (node->op == op_Add ||
981 node->op == op_Sub ||
982 node->op == op_Mul ||
983 node->op == op_Quot ||
984 node->op == op_DivMod ||
985 node->op == op_Div ||
986 node->op == op_Mod ||
987 node->op == op_And ||
989 node->op == op_Eor ||
990 node->op == op_Shl ||
991 node->op == op_Shr ||
992 node->op == op_Shrs ||
993 node->op == op_Rot ||
994 node->op == op_Cmp );
996 switch (get_irn_opcode (node)) {
997 case iro_Add : set_Add_right(node, right); break;
998 case iro_Sub : set_Sub_right(node, right); break;
999 case iro_Mul : set_Mul_right(node, right); break;
1000 case iro_Quot : set_Quot_right(node, right); break;
1001 case iro_DivMod: set_DivMod_right(node, right); break;
1002 case iro_Div : set_Div_right(node, right); break;
1003 case iro_Mod : set_Mod_right(node, right); break;
1004 case iro_And : set_And_right(node, right); break;
1005 case iro_Or : set_Or_right(node, right); break;
1006 case iro_Eor : set_Eor_right(node, right); break;
1007 case iro_Shl : set_Shl_right(node, right); break;
1008 case iro_Shr : set_Shr_right(node, right); break;
1009 case iro_Shrs : set_Shrs_right(node, right); break;
1010 case iro_Rot : set_Rot_right(node, right); break;
1011 case iro_Cmp : set_Cmp_right(node, right); break;
1017 get_Add_left (ir_node *node) {
1018 assert (node->op == op_Add);
1019 return get_irn_n(node, 0);
1023 set_Add_left (ir_node *node, ir_node *left) {
1024 assert (node->op == op_Add);
1025 set_irn_n(node, 0, left);
1029 get_Add_right (ir_node *node) {
1030 assert (node->op == op_Add);
1031 return get_irn_n(node, 1);
1035 set_Add_right (ir_node *node, ir_node *right) {
1036 assert (node->op == op_Add);
1037 set_irn_n(node, 1, right);
1041 get_Sub_left (ir_node *node) {
1042 assert (node->op == op_Sub);
1043 return get_irn_n(node, 0);
1047 set_Sub_left (ir_node *node, ir_node *left) {
1048 assert (node->op == op_Sub);
1049 set_irn_n(node, 0, left);
1053 get_Sub_right (ir_node *node) {
1054 assert (node->op == op_Sub);
1055 return get_irn_n(node, 1);
1059 set_Sub_right (ir_node *node, ir_node *right) {
1060 assert (node->op == op_Sub);
1061 set_irn_n(node, 1, right);
1066 get_Minus_op (ir_node *node) {
1067 assert (node->op == op_Minus);
1068 return get_irn_n(node, 0);
1072 set_Minus_op (ir_node *node, ir_node *op) {
1073 assert (node->op == op_Minus);
1074 set_irn_n(node, 0, op);
1079 get_Mul_left (ir_node *node) {
1080 assert (node->op == op_Mul);
1081 return get_irn_n(node, 0);
1085 set_Mul_left (ir_node *node, ir_node *left) {
1086 assert (node->op == op_Mul);
1087 set_irn_n(node, 0, left);
1091 get_Mul_right (ir_node *node) {
1092 assert (node->op == op_Mul);
1093 return get_irn_n(node, 1);
1097 set_Mul_right (ir_node *node, ir_node *right) {
1098 assert (node->op == op_Mul);
1099 set_irn_n(node, 1, right);
1103 get_Quot_left (ir_node *node) {
1104 assert (node->op == op_Quot);
1105 return get_irn_n(node, 1);
1109 set_Quot_left (ir_node *node, ir_node *left) {
1110 assert (node->op == op_Quot);
1111 set_irn_n(node, 1, left);
1115 get_Quot_right (ir_node *node) {
1116 assert (node->op == op_Quot);
1117 return get_irn_n(node, 2);
1121 set_Quot_right (ir_node *node, ir_node *right) {
1122 assert (node->op == op_Quot);
1123 set_irn_n(node, 2, right);
1127 get_Quot_mem (ir_node *node) {
1128 assert (node->op == op_Quot);
1129 return get_irn_n(node, 0);
1133 set_Quot_mem (ir_node *node, ir_node *mem) {
1134 assert (node->op == op_Quot);
1135 set_irn_n(node, 0, mem);
1139 get_DivMod_left (ir_node *node) {
1140 assert (node->op == op_DivMod);
1141 return get_irn_n(node, 1);
1145 set_DivMod_left (ir_node *node, ir_node *left) {
1146 assert (node->op == op_DivMod);
1147 set_irn_n(node, 1, left);
1151 get_DivMod_right (ir_node *node) {
1152 assert (node->op == op_DivMod);
1153 return get_irn_n(node, 2);
1157 set_DivMod_right (ir_node *node, ir_node *right) {
1158 assert (node->op == op_DivMod);
1159 set_irn_n(node, 2, right);
1163 get_DivMod_mem (ir_node *node) {
1164 assert (node->op == op_DivMod);
1165 return get_irn_n(node, 0);
1169 set_DivMod_mem (ir_node *node, ir_node *mem) {
1170 assert (node->op == op_DivMod);
1171 set_irn_n(node, 0, mem);
1175 get_Div_left (ir_node *node) {
1176 assert (node->op == op_Div);
1177 return get_irn_n(node, 1);
1181 set_Div_left (ir_node *node, ir_node *left) {
1182 assert (node->op == op_Div);
1183 set_irn_n(node, 1, left);
1187 get_Div_right (ir_node *node) {
1188 assert (node->op == op_Div);
1189 return get_irn_n(node, 2);
1193 set_Div_right (ir_node *node, ir_node *right) {
1194 assert (node->op == op_Div);
1195 set_irn_n(node, 2, right);
1199 get_Div_mem (ir_node *node) {
1200 assert (node->op == op_Div);
1201 return get_irn_n(node, 0);
1205 set_Div_mem (ir_node *node, ir_node *mem) {
1206 assert (node->op == op_Div);
1207 set_irn_n(node, 0, mem);
1211 get_Mod_left (ir_node *node) {
1212 assert (node->op == op_Mod);
1213 return get_irn_n(node, 1);
1217 set_Mod_left (ir_node *node, ir_node *left) {
1218 assert (node->op == op_Mod);
1219 set_irn_n(node, 1, left);
1223 get_Mod_right (ir_node *node) {
1224 assert (node->op == op_Mod);
1225 return get_irn_n(node, 2);
1229 set_Mod_right (ir_node *node, ir_node *right) {
1230 assert (node->op == op_Mod);
1231 set_irn_n(node, 2, right);
1235 get_Mod_mem (ir_node *node) {
1236 assert (node->op == op_Mod);
1237 return get_irn_n(node, 0);
1241 set_Mod_mem (ir_node *node, ir_node *mem) {
1242 assert (node->op == op_Mod);
1243 set_irn_n(node, 0, mem);
1247 get_Abs_op (ir_node *node) {
1248 assert (node->op == op_Abs);
1249 return get_irn_n(node, 0);
1253 set_Abs_op (ir_node *node, ir_node *op) {
1254 assert (node->op == op_Abs);
1255 set_irn_n(node, 0, op);
1259 get_And_left (ir_node *node) {
1260 assert (node->op == op_And);
1261 return get_irn_n(node, 0);
1265 set_And_left (ir_node *node, ir_node *left) {
1266 assert (node->op == op_And);
1267 set_irn_n(node, 0, left);
1271 get_And_right (ir_node *node) {
1272 assert (node->op == op_And);
1273 return get_irn_n(node, 1);
1277 set_And_right (ir_node *node, ir_node *right) {
1278 assert (node->op == op_And);
1279 set_irn_n(node, 1, right);
1283 get_Or_left (ir_node *node) {
1284 assert (node->op == op_Or);
1285 return get_irn_n(node, 0);
1289 set_Or_left (ir_node *node, ir_node *left) {
1290 assert (node->op == op_Or);
1291 set_irn_n(node, 0, left);
1295 get_Or_right (ir_node *node) {
1296 assert (node->op == op_Or);
1297 return get_irn_n(node, 1);
1301 set_Or_right (ir_node *node, ir_node *right) {
1302 assert (node->op == op_Or);
1303 set_irn_n(node, 1, right);
1307 get_Eor_left (ir_node *node) {
1308 assert (node->op == op_Eor);
1309 return get_irn_n(node, 0);
1313 set_Eor_left (ir_node *node, ir_node *left) {
1314 assert (node->op == op_Eor);
1315 set_irn_n(node, 0, left);
1319 get_Eor_right (ir_node *node) {
1320 assert (node->op == op_Eor);
1321 return get_irn_n(node, 1);
1325 set_Eor_right (ir_node *node, ir_node *right) {
1326 assert (node->op == op_Eor);
1327 set_irn_n(node, 1, right);
1332 get_Not_op (ir_node *node) {
1333 assert (node->op == op_Not);
1334 return get_irn_n(node, 0);
1338 set_Not_op (ir_node *node, ir_node *op) {
1339 assert (node->op == op_Not);
1340 set_irn_n(node, 0, op);
1345 get_Shl_left (ir_node *node) {
1346 assert (node->op == op_Shl);
1347 return get_irn_n(node, 0);
1351 set_Shl_left (ir_node *node, ir_node *left) {
1352 assert (node->op == op_Shl);
1353 set_irn_n(node, 0, left);
1357 get_Shl_right (ir_node *node) {
1358 assert (node->op == op_Shl);
1359 return get_irn_n(node, 1);
1363 set_Shl_right (ir_node *node, ir_node *right) {
1364 assert (node->op == op_Shl);
1365 set_irn_n(node, 1, right);
1369 get_Shr_left (ir_node *node) {
1370 assert (node->op == op_Shr);
1371 return get_irn_n(node, 0);
1375 set_Shr_left (ir_node *node, ir_node *left) {
1376 assert (node->op == op_Shr);
1377 set_irn_n(node, 0, left);
1381 get_Shr_right (ir_node *node) {
1382 assert (node->op == op_Shr);
1383 return get_irn_n(node, 1);
1387 set_Shr_right (ir_node *node, ir_node *right) {
1388 assert (node->op == op_Shr);
1389 set_irn_n(node, 1, right);
1393 get_Shrs_left (ir_node *node) {
1394 assert (node->op == op_Shrs);
1395 return get_irn_n(node, 0);
1399 set_Shrs_left (ir_node *node, ir_node *left) {
1400 assert (node->op == op_Shrs);
1401 set_irn_n(node, 0, left);
1405 get_Shrs_right (ir_node *node) {
1406 assert (node->op == op_Shrs);
1407 return get_irn_n(node, 1);
1411 set_Shrs_right (ir_node *node, ir_node *right) {
1412 assert (node->op == op_Shrs);
1413 set_irn_n(node, 1, right);
1417 get_Rot_left (ir_node *node) {
1418 assert (node->op == op_Rot);
1419 return get_irn_n(node, 0);
1423 set_Rot_left (ir_node *node, ir_node *left) {
1424 assert (node->op == op_Rot);
1425 set_irn_n(node, 0, left);
1429 get_Rot_right (ir_node *node) {
1430 assert (node->op == op_Rot);
1431 return get_irn_n(node, 1);
1435 set_Rot_right (ir_node *node, ir_node *right) {
1436 assert (node->op == op_Rot);
1437 set_irn_n(node, 1, right);
1441 get_Cmp_left (ir_node *node) {
1442 assert (node->op == op_Cmp);
1443 return get_irn_n(node, 0);
1447 set_Cmp_left (ir_node *node, ir_node *left) {
1448 assert (node->op == op_Cmp);
1449 set_irn_n(node, 0, left);
1453 get_Cmp_right (ir_node *node) {
1454 assert (node->op == op_Cmp);
1455 return get_irn_n(node, 1);
1459 set_Cmp_right (ir_node *node, ir_node *right) {
1460 assert (node->op == op_Cmp);
1461 set_irn_n(node, 1, right);
1465 get_Conv_op (ir_node *node) {
1466 assert (node->op == op_Conv);
1467 return get_irn_n(node, 0);
1471 set_Conv_op (ir_node *node, ir_node *op) {
1472 assert (node->op == op_Conv);
1473 set_irn_n(node, 0, op);
1477 get_Phi_preds_arr (ir_node *node) {
1478 assert (node->op == op_Phi);
1479 return (ir_node **)&(get_irn_in(node)[1]);
1483 get_Phi_n_preds (ir_node *node) {
1484 assert (node->op == op_Phi);
1485 return (get_irn_arity(node));
1489 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1490 assert (node->op == op_Phi);
1495 get_Phi_pred (ir_node *node, int pos) {
1496 assert (node->op == op_Phi);
1497 return get_irn_n(node, pos);
1501 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1502 assert (node->op == op_Phi);
1503 set_irn_n(node, pos, pred);
1507 get_Load_mem (ir_node *node) {
1508 assert (node->op == op_Load);
1509 return get_irn_n(node, 0);
1513 set_Load_mem (ir_node *node, ir_node *mem) {
1514 assert (node->op == op_Load);
1515 set_irn_n(node, 0, mem);
1519 get_Load_ptr (ir_node *node) {
1520 assert (node->op == op_Load);
1521 return get_irn_n(node, 1);
1525 set_Load_ptr (ir_node *node, ir_node *ptr) {
1526 assert (node->op == op_Load);
1527 set_irn_n(node, 1, ptr);
1532 get_Store_mem (ir_node *node) {
1533 assert (node->op == op_Store);
1534 return get_irn_n(node, 0);
1538 set_Store_mem (ir_node *node, ir_node *mem) {
1539 assert (node->op == op_Store);
1540 set_irn_n(node, 0, mem);
1544 get_Store_ptr (ir_node *node) {
1545 assert (node->op == op_Store);
1546 return get_irn_n(node, 1);
1550 set_Store_ptr (ir_node *node, ir_node *ptr) {
1551 assert (node->op == op_Store);
1552 set_irn_n(node, 1, ptr);
1556 get_Store_value (ir_node *node) {
1557 assert (node->op == op_Store);
1558 return get_irn_n(node, 2);
1562 set_Store_value (ir_node *node, ir_node *value) {
1563 assert (node->op == op_Store);
1564 set_irn_n(node, 2, value);
1568 get_Alloc_mem (ir_node *node) {
1569 assert (node->op == op_Alloc);
1570 return get_irn_n(node, 0);
1574 set_Alloc_mem (ir_node *node, ir_node *mem) {
1575 assert (node->op == op_Alloc);
1576 set_irn_n(node, 0, mem);
1580 get_Alloc_size (ir_node *node) {
1581 assert (node->op == op_Alloc);
1582 return get_irn_n(node, 1);
1586 set_Alloc_size (ir_node *node, ir_node *size) {
1587 assert (node->op == op_Alloc);
1588 set_irn_n(node, 1, size);
1592 get_Alloc_type (ir_node *node) {
1593 assert (node->op == op_Alloc);
1594 return node->attr.a.type = skip_tid(node->attr.a.type);
1598 set_Alloc_type (ir_node *node, type *type) {
1599 assert (node->op == op_Alloc);
1600 node->attr.a.type = type;
1604 get_Alloc_where (ir_node *node) {
1605 assert (node->op == op_Alloc);
1606 return node->attr.a.where;
1610 set_Alloc_where (ir_node *node, where_alloc where) {
1611 assert (node->op == op_Alloc);
1612 node->attr.a.where = where;
1617 get_Free_mem (ir_node *node) {
1618 assert (node->op == op_Free);
1619 return get_irn_n(node, 0);
1623 set_Free_mem (ir_node *node, ir_node *mem) {
1624 assert (node->op == op_Free);
1625 set_irn_n(node, 0, mem);
1629 get_Free_ptr (ir_node *node) {
1630 assert (node->op == op_Free);
1631 return get_irn_n(node, 1);
1635 set_Free_ptr (ir_node *node, ir_node *ptr) {
1636 assert (node->op == op_Free);
1637 set_irn_n(node, 1, ptr);
1641 get_Free_size (ir_node *node) {
1642 assert (node->op == op_Free);
1643 return get_irn_n(node, 2);
1647 set_Free_size (ir_node *node, ir_node *size) {
1648 assert (node->op == op_Free);
1649 set_irn_n(node, 2, size);
1653 get_Free_type (ir_node *node) {
1654 assert (node->op == op_Free);
1655 return node->attr.f = skip_tid(node->attr.f);
1659 set_Free_type (ir_node *node, type *type) {
1660 assert (node->op == op_Free);
1661 node->attr.f = type;
1665 get_Sync_preds_arr (ir_node *node) {
1666 assert (node->op == op_Sync);
1667 return (ir_node **)&(get_irn_in(node)[1]);
1671 get_Sync_n_preds (ir_node *node) {
1672 assert (node->op == op_Sync);
1673 return (get_irn_arity(node));
1678 set_Sync_n_preds (ir_node *node, int n_preds) {
1679 assert (node->op == op_Sync);
1684 get_Sync_pred (ir_node *node, int pos) {
1685 assert (node->op == op_Sync);
1686 return get_irn_n(node, pos);
1690 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1691 assert (node->op == op_Sync);
1692 set_irn_n(node, pos, pred);
1696 get_Proj_pred (ir_node *node) {
1697 assert (node->op == op_Proj);
1698 return get_irn_n(node, 0);
1702 set_Proj_pred (ir_node *node, ir_node *pred) {
1703 assert (node->op == op_Proj);
1704 set_irn_n(node, 0, pred);
1708 get_Proj_proj (ir_node *node) {
1709 assert (node->op == op_Proj);
1710 return node->attr.proj;
1714 set_Proj_proj (ir_node *node, long proj) {
1715 assert (node->op == op_Proj);
1716 node->attr.proj = proj;
1720 get_Tuple_preds_arr (ir_node *node) {
1721 assert (node->op == op_Tuple);
1722 return (ir_node **)&(get_irn_in(node)[1]);
1726 get_Tuple_n_preds (ir_node *node) {
1727 assert (node->op == op_Tuple);
1728 return (get_irn_arity(node));
1733 set_Tuple_n_preds (ir_node *node, int n_preds) {
1734 assert (node->op == op_Tuple);
1739 get_Tuple_pred (ir_node *node, int pos) {
1740 assert (node->op == op_Tuple);
1741 return get_irn_n(node, pos);
1745 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1746 assert (node->op == op_Tuple);
1747 set_irn_n(node, pos, pred);
1751 get_Id_pred (ir_node *node) {
1752 assert (node->op == op_Id);
1753 return get_irn_n(node, 0);
1757 set_Id_pred (ir_node *node, ir_node *pred) {
1758 assert (node->op == op_Id);
1759 set_irn_n(node, 0, pred);
1762 /******************************************************************/
1763 /* Auxiliary routines */
1764 /******************************************************************/
1767 skip_Proj (ir_node *node) {
1768 /* don't assert node !!! */
1769 if (node && (node->op == op_Proj)) {
1770 return get_Proj_pred(node);
1777 skip_nop (ir_node *node) {
1778 /* don't assert node !!! */
1780 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1781 /* Don't use get_Id_pred: We get into an endless loop for
1782 self-referencing Ids. */
1783 assert (get_irn_arity (node) > 0);
1784 return node->in[0+1];
1791 is_Bad (ir_node *node) {
1793 if ((node) && get_irn_opcode(node) == iro_Bad)
1799 is_no_Block (ir_node *node) {
1801 return (get_irn_opcode(node) != iro_Block);
1804 /* Returns true if the operation manipulates control flow. */
1806 is_cfop(ir_node *node) {
1807 return ( (get_irn_opcode(node) == iro_Start)
1808 || (get_irn_opcode(node) == iro_Jmp)
1809 || (get_irn_opcode(node) == iro_Cond)
1810 || (get_irn_opcode(node) == iro_Return)
1811 || (get_irn_opcode(node) == iro_Raise)
1812 || (get_irn_opcode(node) == iro_Bad));
1815 /* Returns true if the operation can change the control flow because
1818 is_fragile_op(ir_node *node) {
1819 return ( (get_irn_opcode(node) == iro_Call)
1820 || (get_irn_opcode(node) == iro_Quot)
1821 || (get_irn_opcode(node) == iro_DivMod)
1822 || (get_irn_opcode(node) == iro_Div)
1823 || (get_irn_opcode(node) == iro_Mod)
1824 || (get_irn_opcode(node) == iro_Load)
1825 || (get_irn_opcode(node) == iro_Store)
1826 || (get_irn_opcode(node) == iro_Alloc)
1827 || (get_irn_opcode(node) == iro_Bad));