1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer
6 ** ircons.c: basic and more detailed irnode constructors
7 ** store, block and parameter administration ,
8 ** Adapted to extended FIRM nodes (exceptions...) and commented
9 ** by Goetz Lindenmaier
15 /* memset belongs to string.h */
18 /* irnode constructor */
19 /* create a new irnode in irg, with an op, mode, arity and */
20 /* some incoming irnodes */
21 /* this constructor is used in every specified irnode constructor */
23 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
24 int arity, ir_node **in)
27 int node_size = offsetof (ir_node, attr) + op->attr_size;
29 res = (ir_node *) obstack_alloc (irg->obst, node_size);
31 res->kind = k_ir_node;
37 res->in = NEW_ARR_F (ir_node *, 1);
39 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
40 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
49 /*********************************************** */
50 /** privat interfaces, for professional use only */
52 /* Creates a Phi node with 0 predecessors */
54 new_r_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
58 res = new_ir_node (irg, block, op_Phi, mode, 0, NULL);
60 /* GL I'm not sure whether we should optimize this guy. *
61 res = optimize (res); ??? */
66 /* Creates a Phi node with all predecessors. Calling this constructor
67 is only allowed if the corresponding block is mature. */
69 new_r_Phi (ir_graph *irg, ir_node *block, int arity, ir_node **in, ir_mode *mode)
73 assert( get_Block_matured(block) );
74 assert( get_irn_arity(block) == arity );
76 res = new_ir_node (irg, block, op_Phi, mode, arity, in);
83 /* This is a stack used for allocating and deallocating nodes in
84 new_r_Phi_in. The original implementation used the obstack
85 to model this stack, now it is explicit. This reduces side effects.
87 #if USE_EXPICIT_PHI_IN_STACK
92 res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
94 res->stack = NEW_ARR_F (ir_node *, 1);
101 void free_to_Phi_in_stack(ir_node *phi) {
102 assert(get_irn_opcode(phi) == iro_Phi);
104 if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
105 current_ir_graph->Phi_in_stack->pos)
106 ARR_APP1 (ir_node *, current_ir_graph->Phi_in_stack->stack, phi);
108 current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
110 (current_ir_graph->Phi_in_stack->pos)++;
114 alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
115 int arity, ir_node **in) {
117 ir_node **stack = current_ir_graph->Phi_in_stack->stack;
118 int pos = current_ir_graph->Phi_in_stack->pos;
122 /* We need to allocate a new node */
123 res = new_ir_node (irg, block, op_Phi, mode, arity, in);
125 /* reuse the old node and initialize it again. */
128 assert (res->kind == k_ir_node);
129 assert (res->op == op_Phi);
134 /* ???!!! How to free the old in array?? */
135 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
137 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
139 (current_ir_graph->Phi_in_stack->pos)--;
147 /* Creates a Phi node with a given, fixed array **in of predecessors.
148 If the Phi node is unnecessary, as the same value reaches the block
149 through all control flow paths, it is eliminated and the value
150 returned directly. This constructor is only intended for use in
151 the automatic Phi node generation triggered by get_value or mature.
152 The implementation is quite tricky and depends on the fact, that
153 the nodes are allocated on a stack:
154 The in array contains predecessors and NULLs. The NULLs appear,
155 if get_r_value_internal, that computed the predecessors, reached
156 the same block on two paths. In this case the same value reaches
157 this block on both paths, there is no definition in between. We need
158 not allocate a Phi where these path's merge, but we have to communicate
159 this fact to the caller. This happens by returning a pointer to the
160 node the caller _will_ allocate. (Yes, we predict the address. We can
161 do so because the nodes are allocated on the obstack.) The caller then
162 finds a pointer to itself and, when this routine is called again,
166 new_r_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
167 ir_node **in, int ins)
170 ir_node *res, *known;
172 /* allocate a new node on the obstack.
173 This can return a node to which some of the pointers in the in-array
175 Attention: the constructor copies the in array, i.e., the later changes
176 to the array in this routine do not affect the constructed node! If
177 the in array contains NULLs, there will be missing predecessors in the
179 Is this a possible internal state of the Phi node generation? */
180 #if USE_EXPICIT_PHI_IN_STACK
181 res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
183 res = known = new_ir_node (irg, block, op_Phi, mode, ins, in);
185 /* The in-array can contain NULLs. These were returned by get_r_value_internal
186 if it reached the same block/definition on a second path.
187 The NULLs are replaced by the node itself to simplify the test in the
189 for (i=0; i < ins; ++i)
190 if (in[i] == NULL) in[i] = res;
192 /* This loop checks whether the Phi has more than one predecessor.
193 If so, it is a real Phi node and we break the loop. Else the
194 Phi node merges the same definition on several paths and therefore
196 for (i=0; i < ins; ++i)
198 if (in[i]==res || in[i]==known) continue;
206 /* i==ins: there is at most one predecessor, we don't need a phi node. */
208 #if USE_EXPICIT_PHI_IN_STACK
209 free_to_Phi_in_stack(res);
211 obstack_free (current_ir_graph->obst, res);
215 res = optimize (res);
219 /* return the pointer to the Phi node. This node might be deallocated! */
224 new_r_Const (ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
227 res = new_ir_node (irg, block, op_Const, mode, 0, NULL);
229 res = optimize (res);
233 res = local_optimize_newby (res);
240 new_r_Id (ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
242 ir_node *in[1] = {val};
244 res = new_ir_node (irg, block, op_Id, mode, 1, in);
245 res = optimize (res);
251 new_r_Proj (ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode, long proj)
253 ir_node *in[1] = {arg};
255 res = new_ir_node (irg, block, op_Proj, mode, 1, in);
256 res->attr.proj = proj;
257 res = optimize (res);
264 new_r_Conv (ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
266 ir_node *in[1] = {op};
268 res = new_ir_node (irg, block, op_Conv, mode, 1, in);
269 res = optimize (res);
276 new_r_Tuple (ir_graph *irg, ir_node *block, int arity, ir_node **in)
280 res = new_ir_node (irg, block, op_Tuple, mode_T, arity, in);
281 res = optimize (res);
287 new_r_Add (ir_graph *irg, ir_node *block,
288 ir_node *op1, ir_node *op2, ir_mode *mode)
290 ir_node *in[2] = {op1, op2};
292 res = new_ir_node (irg, block, op_Add, mode, 2, in);
293 res = optimize (res);
299 new_r_Sub (ir_graph *irg, ir_node *block,
300 ir_node *op1, ir_node *op2, ir_mode *mode)
302 ir_node *in[2] = {op1, op2};
304 res = new_ir_node (irg, block, op_Sub, mode, 2, in);
305 res = optimize (res);
311 new_r_Minus (ir_graph *irg, ir_node *block,
312 ir_node *op, ir_mode *mode)
314 ir_node *in[1] = {op};
316 res = new_ir_node (irg, block, op_Minus, mode, 1, in);
317 res = optimize (res);
323 new_r_Mul (ir_graph *irg, ir_node *block,
324 ir_node *op1, ir_node *op2, ir_mode *mode)
326 ir_node *in[2] = {op1, op2};
328 res = new_ir_node (irg, block, op_Mul, mode, 2, in);
329 res = optimize (res);
335 new_r_Quot (ir_graph *irg, ir_node *block,
336 ir_node *memop, ir_node *op1, ir_node *op2)
338 ir_node *in[3] = {memop, op1, op2};
340 res = new_ir_node (irg, block, op_Quot, mode_T, 2, in);
341 res = optimize (res);
347 new_r_DivMod (ir_graph *irg, ir_node *block,
348 ir_node *memop, ir_node *op1, ir_node *op2)
350 ir_node *in[3] = {memop, op1, op2};
352 res = new_ir_node (irg, block, op_DivMod, mode_T, 2, in);
353 res = optimize (res);
359 new_r_Div (ir_graph *irg, ir_node *block,
360 ir_node *memop, ir_node *op1, ir_node *op2)
362 ir_node *in[3] = {memop, op1, op2};
364 res = new_ir_node (irg, block, op_Div, mode_T, 2, in);
365 res = optimize (res);
371 new_r_Mod (ir_graph *irg, ir_node *block,
372 ir_node *memop, ir_node *op1, ir_node *op2)
374 ir_node *in[3] = {memop, op1, op2};
376 res = new_ir_node (irg, block, op_Mod, mode_T, 2, in);
377 res = optimize (res);
383 new_r_And (ir_graph *irg, ir_node *block,
384 ir_node *op1, ir_node *op2, ir_mode *mode)
386 ir_node *in[2] = {op1, op2};
388 res = new_ir_node (irg, block, op_And, mode, 2, in);
389 res = optimize (res);
395 new_r_Or (ir_graph *irg, ir_node *block,
396 ir_node *op1, ir_node *op2, ir_mode *mode)
398 ir_node *in[2] = {op1, op2};
400 res = new_ir_node (irg, block, op_Or, mode, 2, in);
401 res = optimize (res);
407 new_r_Eor (ir_graph *irg, ir_node *block,
408 ir_node *op1, ir_node *op2, ir_mode *mode)
410 ir_node *in[2] = {op1, op2};
412 res = new_ir_node (irg, block, op_Eor, mode, 2, in);
413 res = optimize (res);
419 new_r_Not (ir_graph *irg, ir_node *block,
420 ir_node *op, ir_mode *mode)
422 ir_node *in[1] = {op};
424 res = new_ir_node (irg, block, op_Not, mode, 1, in);
425 res = optimize (res);
431 new_r_Shl (ir_graph *irg, ir_node *block,
432 ir_node *op, ir_node *k, ir_mode *mode)
434 ir_node *in[2] = {op, k};
436 res = new_ir_node (irg, block, op_Shl, mode, 2, in);
437 res = optimize (res);
443 new_r_Shr (ir_graph *irg, ir_node *block,
444 ir_node *op, ir_node *k, ir_mode *mode)
446 ir_node *in[2] = {op, k};
448 res = new_ir_node (irg, block, op_Shr, mode, 2, in);
449 res = optimize (res);
455 new_r_Shrs (ir_graph *irg, ir_node *block,
456 ir_node *op, ir_node *k, ir_mode *mode)
458 ir_node *in[2] = {op, k};
460 res = new_ir_node (irg, block, op_Shrs, mode, 2, in);
461 res = optimize (res);
467 new_r_Rot (ir_graph *irg, ir_node *block,
468 ir_node *op, ir_node *k, ir_mode *mode)
470 ir_node *in[2] = {op, k};
472 res = new_ir_node (irg, block, op_Rot, mode, 2, in);
473 res = optimize (res);
479 new_r_Abs (ir_graph *irg, ir_node *block,
480 ir_node *op, ir_mode *mode)
482 ir_node *in[1] = {op};
484 res = new_ir_node (irg, block, op_Abs, mode, 1, in);
485 res = optimize (res);
491 new_r_Cmp (ir_graph *irg, ir_node *block,
492 ir_node *op1, ir_node *op2)
494 ir_node *in[2] = {op1, op2};
496 res = new_ir_node (irg, block, op_Cmp, mode_T, 2, in);
497 res = optimize (res);
503 new_r_Jmp (ir_graph *irg, ir_node *block)
507 res = new_ir_node (irg, block, op_Jmp, mode_X, 0, in);
508 res = optimize (res);
514 new_r_Cond (ir_graph *irg, ir_node *block, ir_node *c)
516 ir_node *in[1] = {c};
518 res = new_ir_node (irg, block, op_Cond, mode_T, 1, in);
519 res = optimize (res);
525 new_r_Call (ir_graph *irg, ir_node *block, ir_node *store,
526 ir_node *callee, int arity, ir_node **in, type_method *type)
533 NEW_ARR_A (ir_node *, r_in, r_arity);
536 memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
538 res = new_ir_node (irg, block, op_Call, mode_T, r_arity, r_in);
540 set_Call_type(res, type);
541 res = optimize (res);
547 new_r_Return (ir_graph *irg, ir_node *block,
548 ir_node *store, int arity, ir_node **in)
556 NEW_ARR_A (ir_node *, r_in, r_arity);
560 memcpy (&r_in[1], in, sizeof (ir_node *) * arity);
562 res = new_ir_node (irg, block, op_Return, mode_X, r_arity, r_in);
564 res = optimize (res);
571 new_r_Raise (ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
573 ir_node *in[2] = {store, obj};
575 res = new_ir_node (irg, block, op_Raise, mode_X, 2, in);
577 res = optimize (res);
583 new_r_Load (ir_graph *irg, ir_node *block,
584 ir_node *store, ir_node *adr)
586 ir_node *in[2] = {store, adr};
588 res = new_ir_node (irg, block, op_Load, mode_T, 2, in);
590 res = optimize (res);
596 new_r_Store (ir_graph *irg, ir_node *block,
597 ir_node *store, ir_node *adr, ir_node *val)
599 ir_node *in[3] = {store, adr, val};
601 res = new_ir_node (irg, block, op_Store, mode_T, 3, in);
603 res = optimize (res);
609 new_r_Alloc (ir_graph *irg, ir_node *block, ir_node *store,
610 ir_node *size, type *alloc_type, where_alloc where)
612 ir_node *in[2] = {store, size};
614 res = new_ir_node (irg, block, op_Alloc, mode_T, 2, in);
616 res->attr.a.where = where;
617 res->attr.a.type = alloc_type;
619 res = optimize (res);
625 new_r_Free (ir_graph *irg, ir_node *block, ir_node *store,
626 ir_node *ptr, ir_node *size, type *free_type)
628 ir_node *in[3] = {store, ptr, size};
630 res = new_ir_node (irg, block, op_Free, mode_T, 3, in);
632 res->attr.f = free_type;
634 res = optimize (res);
640 new_r_Sel (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
641 int arity, ir_node **in, entity *ent)
648 NEW_ARR_A (ir_node *, r_in, r_arity);
651 memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
652 res = new_ir_node (irg, block, op_Sel, mode_p, r_arity, r_in);
654 res->attr.s.ltyp = static_linkage;
655 res->attr.s.ent = ent;
657 res = optimize (res);
663 new_r_SymConst (ir_graph *irg, ir_node *block, type_or_id *value,
664 symconst_kind symkind)
668 res = new_ir_node (irg, block, op_SymConst, mode_I, 0, in);
670 res->attr.i.num = symkind;
671 if (symkind == linkage_ptr_info) {
672 res->attr.i.tori.ptrinfo = (ident *)value;
674 assert ( ( (symkind == type_tag)
675 || (symkind == size))
676 && (is_type(value)));
677 res->attr.i.tori.typ = (type *)value;
679 res = optimize (res);
685 new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node **in)
689 res = new_ir_node (irg, block, op_Sync, mode_M, arity, in);
691 res = optimize (res);
698 new_r_Bad (ir_node *block)
700 return current_ir_graph->bad;
703 /***********************/
704 /** public interfaces */
705 /** construction tools */
712 res = new_ir_node (current_ir_graph, current_ir_graph->current_block,
713 op_Start, mode_T, 0, NULL);
715 res = optimize (res);
726 res = new_ir_node (current_ir_graph, current_ir_graph->current_block,
727 op_End, mode_X, -1, NULL);
729 res = optimize (res);
740 res = new_ir_node (current_ir_graph, NULL, op_Block, mode_R, -1, NULL);
741 current_ir_graph->current_block = res;
742 res->attr.block.matured = 0;
743 set_Block_block_visit(res, 0);
745 // res = optimize (res); /* GL: only optimize if mature!!!! */
748 /** create a new dynamic array, which stores all parameters in irnodes */
749 /** using the same obstack as the whole irgraph */
750 res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
751 current_ir_graph->params);
753 /** initialize the parameter array */
754 memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->params);
761 new_Phi (int arity, ir_node **in, ir_mode *mode)
763 return new_r_Phi (current_ir_graph, current_ir_graph->current_block,
768 new_Const (ir_mode *mode, tarval *con)
770 return new_r_Const (current_ir_graph, current_ir_graph->start_block,
775 new_Id (ir_node *val, ir_mode *mode)
777 return new_r_Id (current_ir_graph, current_ir_graph->current_block,
782 new_Proj (ir_node *arg, ir_mode *mode, long proj)
784 return new_r_Proj (current_ir_graph, current_ir_graph->current_block,
789 new_Conv (ir_node *op, ir_mode *mode)
791 return new_r_Conv (current_ir_graph, current_ir_graph->current_block,
796 new_Tuple (int arity, ir_node **in)
798 return new_r_Tuple (current_ir_graph, current_ir_graph->current_block,
803 new_Add (ir_node *op1, ir_node *op2, ir_mode *mode)
805 return new_r_Add (current_ir_graph, current_ir_graph->current_block,
810 new_Sub (ir_node *op1, ir_node *op2, ir_mode *mode)
812 return new_r_Sub (current_ir_graph, current_ir_graph->current_block,
818 new_Minus (ir_node *op, ir_mode *mode)
820 return new_r_Minus (current_ir_graph, current_ir_graph->current_block,
825 new_Mul (ir_node *op1, ir_node *op2, ir_mode *mode)
827 return new_r_Mul (current_ir_graph, current_ir_graph->current_block,
832 new_Quot (ir_node *memop, ir_node *op1, ir_node *op2)
834 return new_r_Quot (current_ir_graph, current_ir_graph->current_block,
839 new_DivMod (ir_node *memop, ir_node *op1, ir_node *op2)
841 return new_r_DivMod (current_ir_graph, current_ir_graph->current_block,
846 new_Div (ir_node *memop, ir_node *op1, ir_node *op2)
848 return new_r_Div (current_ir_graph, current_ir_graph->current_block,
853 new_Mod (ir_node *memop, ir_node *op1, ir_node *op2)
855 return new_r_Mod (current_ir_graph, current_ir_graph->current_block,
860 new_And (ir_node *op1, ir_node *op2, ir_mode *mode)
862 return new_r_And (current_ir_graph, current_ir_graph->current_block,
867 new_Or (ir_node *op1, ir_node *op2, ir_mode *mode)
869 return new_r_Or (current_ir_graph, current_ir_graph->current_block,
874 new_Eor (ir_node *op1, ir_node *op2, ir_mode *mode)
876 return new_r_Eor (current_ir_graph, current_ir_graph->current_block,
881 new_Not (ir_node *op, ir_mode *mode)
883 return new_r_Not (current_ir_graph, current_ir_graph->current_block,
888 new_Shl (ir_node *op, ir_node *k, ir_mode *mode)
890 return new_r_Shl (current_ir_graph, current_ir_graph->current_block,
895 new_Shr (ir_node *op, ir_node *k, ir_mode *mode)
897 return new_r_Shr (current_ir_graph, current_ir_graph->current_block,
902 new_Shrs (ir_node *op, ir_node *k, ir_mode *mode)
904 return new_r_Shrs (current_ir_graph, current_ir_graph->current_block,
909 new_Rotate (ir_node *op, ir_node *k, ir_mode *mode)
911 return new_r_Rot (current_ir_graph, current_ir_graph->current_block,
916 new_Abs (ir_node *op, ir_mode *mode)
918 return new_r_Abs (current_ir_graph, current_ir_graph->current_block,
923 new_Cmp (ir_node *op1, ir_node *op2)
925 return new_r_Cmp (current_ir_graph, current_ir_graph->current_block,
932 return new_r_Jmp (current_ir_graph, current_ir_graph->current_block);
936 new_Cond (ir_node *c)
938 return new_r_Cond (current_ir_graph, current_ir_graph->current_block, c);
942 new_Call (ir_node *store, ir_node *callee, int arity, ir_node **in,
945 return new_r_Call (current_ir_graph, current_ir_graph->current_block,
946 store, callee, arity, in, type);
949 /* make M parameter in call explicit:
950 new_Return (ir_node* store, int arity, ir_node **in) */
952 new_Return (ir_node* store, int arity, ir_node **in)
954 return new_r_Return (current_ir_graph, current_ir_graph->current_block,
959 new_Raise (ir_node *store, ir_node *obj)
961 return new_r_Raise (current_ir_graph, current_ir_graph->current_block,
966 new_Load (ir_node *store, ir_node *addr)
968 return new_r_Load (current_ir_graph, current_ir_graph->current_block,
973 new_Store (ir_node *store, ir_node *addr, ir_node *val)
975 return new_r_Store (current_ir_graph, current_ir_graph->current_block,
980 new_Alloc (ir_node *store, ir_node *size, type *alloc_type,
983 return new_r_Alloc (current_ir_graph, current_ir_graph->current_block,
984 store, size, alloc_type, where);
988 new_Free (ir_node *store, ir_node *ptr, ir_node *size, type *free_type)
990 return new_r_Free (current_ir_graph, current_ir_graph->current_block,
991 store, ptr, size, free_type);
995 new_simpleSel (ir_node *store, ir_node *objptr, entity *ent)
996 /* GL: objptr was called frame before. Frame was a bad choice for the name
997 as the operand could as well be a pointer to a dynamic object. */
999 return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
1000 store, objptr, 0, NULL, ent);
1004 new_Sel (ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)
1006 return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
1007 store, objptr, n_index, index, sel);
1011 new_SymConst (type_or_id *value, symconst_kind kind)
1013 return new_r_SymConst (current_ir_graph, current_ir_graph->current_block,
1018 new_Sync (int arity, ir_node** in)
1020 return new_r_Sync (current_ir_graph, current_ir_graph->current_block,
1028 return current_ir_graph->bad;
1032 /************************/
1033 /* ir block constructor */
1035 /* GL: what's this good for? */
1037 typedef struct ir_block {
1040 /* -1 = error, 0 = OK */
1057 /* call once for each run of the library */