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 */
54 new_r_Block (ir_graph *irg, int arity, ir_node **in)
58 res = new_ir_node (current_ir_graph, NULL, op_Block, mode_R, -1, NULL);
65 new_r_Start (ir_graph *irg, ir_node *block)
69 res = new_ir_node (irg, block, op_Start, mode_T, 0, NULL);
77 new_r_End (ir_graph *irg, ir_node *block)
81 res = new_ir_node (irg, block, op_End, mode_X, -1, NULL);
89 /* Creates a Phi node with 0 predecessors */
91 new_r_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
95 res = new_ir_node (irg, block, op_Phi, mode, 0, NULL);
97 /* GL I'm not sure whether we should optimize this guy. *
98 res = optimize (res); ??? */
103 /* Creates a Phi node with all predecessors. Calling this constructor
104 is only allowed if the corresponding block is mature. */
106 new_r_Phi (ir_graph *irg, ir_node *block, int arity, ir_node **in, ir_mode *mode)
110 assert( get_Block_matured(block) );
111 assert( get_irn_arity(block) == arity );
113 res = new_ir_node (irg, block, op_Phi, mode, arity, in);
115 res = optimize (res);
120 /* This is a stack used for allocating and deallocating nodes in
121 new_r_Phi_in. The original implementation used the obstack
122 to model this stack, now it is explicit. This reduces side effects.
124 #if USE_EXPICIT_PHI_IN_STACK
129 res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
131 res->stack = NEW_ARR_F (ir_node *, 1);
138 void free_to_Phi_in_stack(ir_node *phi) {
139 assert(get_irn_opcode(phi) == iro_Phi);
141 if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
142 current_ir_graph->Phi_in_stack->pos)
143 ARR_APP1 (ir_node *, current_ir_graph->Phi_in_stack->stack, phi);
145 current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
147 (current_ir_graph->Phi_in_stack->pos)++;
151 alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
152 int arity, ir_node **in) {
154 ir_node **stack = current_ir_graph->Phi_in_stack->stack;
155 int pos = current_ir_graph->Phi_in_stack->pos;
159 /* We need to allocate a new node */
160 res = new_ir_node (irg, block, op_Phi, mode, arity, in);
162 /* reuse the old node and initialize it again. */
165 assert (res->kind == k_ir_node);
166 assert (res->op == op_Phi);
171 /* ???!!! How to free the old in array?? */
172 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
174 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
176 (current_ir_graph->Phi_in_stack->pos)--;
184 /* Creates a Phi node with a given, fixed array **in of predecessors.
185 If the Phi node is unnecessary, as the same value reaches the block
186 through all control flow paths, it is eliminated and the value
187 returned directly. This constructor is only intended for use in
188 the automatic Phi node generation triggered by get_value or mature.
189 The implementation is quite tricky and depends on the fact, that
190 the nodes are allocated on a stack:
191 The in array contains predecessors and NULLs. The NULLs appear,
192 if get_r_value_internal, that computed the predecessors, reached
193 the same block on two paths. In this case the same value reaches
194 this block on both paths, there is no definition in between. We need
195 not allocate a Phi where these path's merge, but we have to communicate
196 this fact to the caller. This happens by returning a pointer to the
197 node the caller _will_ allocate. (Yes, we predict the address. We can
198 do so because the nodes are allocated on the obstack.) The caller then
199 finds a pointer to itself and, when this routine is called again,
203 new_r_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
204 ir_node **in, int ins)
207 ir_node *res, *known;
209 /* allocate a new node on the obstack.
210 This can return a node to which some of the pointers in the in-array
212 Attention: the constructor copies the in array, i.e., the later changes
213 to the array in this routine do not affect the constructed node! If
214 the in array contains NULLs, there will be missing predecessors in the
216 Is this a possible internal state of the Phi node generation? */
217 #if USE_EXPICIT_PHI_IN_STACK
218 res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
220 res = known = new_ir_node (irg, block, op_Phi, mode, ins, in);
222 /* The in-array can contain NULLs. These were returned by get_r_value_internal
223 if it reached the same block/definition on a second path.
224 The NULLs are replaced by the node itself to simplify the test in the
226 for (i=0; i < ins; ++i)
227 if (in[i] == NULL) in[i] = res;
229 /* This loop checks whether the Phi has more than one predecessor.
230 If so, it is a real Phi node and we break the loop. Else the
231 Phi node merges the same definition on several paths and therefore
233 for (i=0; i < ins; ++i)
235 if (in[i]==res || in[i]==known) continue;
243 /* i==ins: there is at most one predecessor, we don't need a phi node. */
245 #if USE_EXPICIT_PHI_IN_STACK
246 free_to_Phi_in_stack(res);
248 obstack_free (current_ir_graph->obst, res);
252 res = optimize (res);
256 /* return the pointer to the Phi node. This node might be deallocated! */
261 new_r_Const (ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
264 res = new_ir_node (irg, block, op_Const, mode, 0, NULL);
266 res = optimize (res);
270 res = local_optimize_newby (res);
277 new_r_Id (ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
279 ir_node *in[1] = {val};
281 res = new_ir_node (irg, block, op_Id, mode, 1, in);
282 res = optimize (res);
288 new_r_Proj (ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode, long proj)
290 ir_node *in[1] = {arg};
292 res = new_ir_node (irg, block, op_Proj, mode, 1, in);
293 res->attr.proj = proj;
294 res = optimize (res);
301 new_r_Conv (ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
303 ir_node *in[1] = {op};
305 res = new_ir_node (irg, block, op_Conv, mode, 1, in);
306 res = optimize (res);
313 new_r_Tuple (ir_graph *irg, ir_node *block, int arity, ir_node **in)
317 res = new_ir_node (irg, block, op_Tuple, mode_T, arity, in);
318 res = optimize (res);
324 new_r_Add (ir_graph *irg, ir_node *block,
325 ir_node *op1, ir_node *op2, ir_mode *mode)
327 ir_node *in[2] = {op1, op2};
329 res = new_ir_node (irg, block, op_Add, mode, 2, in);
330 res = optimize (res);
336 new_r_Sub (ir_graph *irg, ir_node *block,
337 ir_node *op1, ir_node *op2, ir_mode *mode)
339 ir_node *in[2] = {op1, op2};
341 res = new_ir_node (irg, block, op_Sub, mode, 2, in);
342 res = optimize (res);
348 new_r_Minus (ir_graph *irg, ir_node *block,
349 ir_node *op, ir_mode *mode)
351 ir_node *in[1] = {op};
353 res = new_ir_node (irg, block, op_Minus, mode, 1, in);
354 res = optimize (res);
360 new_r_Mul (ir_graph *irg, ir_node *block,
361 ir_node *op1, ir_node *op2, ir_mode *mode)
363 ir_node *in[2] = {op1, op2};
365 res = new_ir_node (irg, block, op_Mul, mode, 2, in);
366 res = optimize (res);
372 new_r_Quot (ir_graph *irg, ir_node *block,
373 ir_node *memop, ir_node *op1, ir_node *op2)
375 ir_node *in[3] = {memop, op1, op2};
377 res = new_ir_node (irg, block, op_Quot, mode_T, 2, in);
378 res = optimize (res);
384 new_r_DivMod (ir_graph *irg, ir_node *block,
385 ir_node *memop, ir_node *op1, ir_node *op2)
387 ir_node *in[3] = {memop, op1, op2};
389 res = new_ir_node (irg, block, op_DivMod, mode_T, 2, in);
390 res = optimize (res);
396 new_r_Div (ir_graph *irg, ir_node *block,
397 ir_node *memop, ir_node *op1, ir_node *op2)
399 ir_node *in[3] = {memop, op1, op2};
401 res = new_ir_node (irg, block, op_Div, mode_T, 2, in);
402 res = optimize (res);
408 new_r_Mod (ir_graph *irg, ir_node *block,
409 ir_node *memop, ir_node *op1, ir_node *op2)
411 ir_node *in[3] = {memop, op1, op2};
413 res = new_ir_node (irg, block, op_Mod, mode_T, 2, in);
414 res = optimize (res);
420 new_r_And (ir_graph *irg, ir_node *block,
421 ir_node *op1, ir_node *op2, ir_mode *mode)
423 ir_node *in[2] = {op1, op2};
425 res = new_ir_node (irg, block, op_And, mode, 2, in);
426 res = optimize (res);
432 new_r_Or (ir_graph *irg, ir_node *block,
433 ir_node *op1, ir_node *op2, ir_mode *mode)
435 ir_node *in[2] = {op1, op2};
437 res = new_ir_node (irg, block, op_Or, mode, 2, in);
438 res = optimize (res);
444 new_r_Eor (ir_graph *irg, ir_node *block,
445 ir_node *op1, ir_node *op2, ir_mode *mode)
447 ir_node *in[2] = {op1, op2};
449 res = new_ir_node (irg, block, op_Eor, mode, 2, in);
450 res = optimize (res);
456 new_r_Not (ir_graph *irg, ir_node *block,
457 ir_node *op, ir_mode *mode)
459 ir_node *in[1] = {op};
461 res = new_ir_node (irg, block, op_Not, mode, 1, in);
462 res = optimize (res);
468 new_r_Shl (ir_graph *irg, ir_node *block,
469 ir_node *op, ir_node *k, ir_mode *mode)
471 ir_node *in[2] = {op, k};
473 res = new_ir_node (irg, block, op_Shl, mode, 2, in);
474 res = optimize (res);
480 new_r_Shr (ir_graph *irg, ir_node *block,
481 ir_node *op, ir_node *k, ir_mode *mode)
483 ir_node *in[2] = {op, k};
485 res = new_ir_node (irg, block, op_Shr, mode, 2, in);
486 res = optimize (res);
492 new_r_Shrs (ir_graph *irg, ir_node *block,
493 ir_node *op, ir_node *k, ir_mode *mode)
495 ir_node *in[2] = {op, k};
497 res = new_ir_node (irg, block, op_Shrs, mode, 2, in);
498 res = optimize (res);
504 new_r_Rot (ir_graph *irg, ir_node *block,
505 ir_node *op, ir_node *k, ir_mode *mode)
507 ir_node *in[2] = {op, k};
509 res = new_ir_node (irg, block, op_Rot, mode, 2, in);
510 res = optimize (res);
516 new_r_Abs (ir_graph *irg, ir_node *block,
517 ir_node *op, ir_mode *mode)
519 ir_node *in[1] = {op};
521 res = new_ir_node (irg, block, op_Abs, mode, 1, in);
522 res = optimize (res);
528 new_r_Cmp (ir_graph *irg, ir_node *block,
529 ir_node *op1, ir_node *op2)
531 ir_node *in[2] = {op1, op2};
533 res = new_ir_node (irg, block, op_Cmp, mode_T, 2, in);
534 res = optimize (res);
540 new_r_Jmp (ir_graph *irg, ir_node *block)
544 res = new_ir_node (irg, block, op_Jmp, mode_X, 0, in);
545 res = optimize (res);
551 new_r_Cond (ir_graph *irg, ir_node *block, ir_node *c)
553 ir_node *in[1] = {c};
555 res = new_ir_node (irg, block, op_Cond, mode_T, 1, in);
556 res = optimize (res);
562 new_r_Call (ir_graph *irg, ir_node *block, ir_node *store,
563 ir_node *callee, int arity, ir_node **in, type_method *type)
570 NEW_ARR_A (ir_node *, r_in, r_arity);
573 memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
575 res = new_ir_node (irg, block, op_Call, mode_T, r_arity, r_in);
577 set_Call_type(res, type);
578 res = optimize (res);
584 new_r_Return (ir_graph *irg, ir_node *block,
585 ir_node *store, int arity, ir_node **in)
593 NEW_ARR_A (ir_node *, r_in, r_arity);
597 memcpy (&r_in[1], in, sizeof (ir_node *) * arity);
599 res = new_ir_node (irg, block, op_Return, mode_X, r_arity, r_in);
601 res = optimize (res);
608 new_r_Raise (ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
610 ir_node *in[2] = {store, obj};
612 res = new_ir_node (irg, block, op_Raise, mode_X, 2, in);
614 res = optimize (res);
620 new_r_Load (ir_graph *irg, ir_node *block,
621 ir_node *store, ir_node *adr)
623 ir_node *in[2] = {store, adr};
625 res = new_ir_node (irg, block, op_Load, mode_T, 2, in);
627 res = optimize (res);
633 new_r_Store (ir_graph *irg, ir_node *block,
634 ir_node *store, ir_node *adr, ir_node *val)
636 ir_node *in[3] = {store, adr, val};
638 res = new_ir_node (irg, block, op_Store, mode_T, 3, in);
640 res = optimize (res);
646 new_r_Alloc (ir_graph *irg, ir_node *block, ir_node *store,
647 ir_node *size, type *alloc_type, where_alloc where)
649 ir_node *in[2] = {store, size};
651 res = new_ir_node (irg, block, op_Alloc, mode_T, 2, in);
653 res->attr.a.where = where;
654 res->attr.a.type = alloc_type;
656 res = optimize (res);
662 new_r_Free (ir_graph *irg, ir_node *block, ir_node *store,
663 ir_node *ptr, ir_node *size, type *free_type)
665 ir_node *in[3] = {store, ptr, size};
667 res = new_ir_node (irg, block, op_Free, mode_T, 3, in);
669 res->attr.f = free_type;
671 res = optimize (res);
677 new_r_Sel (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
678 int arity, ir_node **in, entity *ent)
685 NEW_ARR_A (ir_node *, r_in, r_arity);
688 memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
689 res = new_ir_node (irg, block, op_Sel, mode_p, r_arity, r_in);
691 res->attr.s.ltyp = static_linkage;
692 res->attr.s.ent = ent;
694 res = optimize (res);
700 new_r_SymConst (ir_graph *irg, ir_node *block, type_or_id *value,
701 symconst_kind symkind)
705 res = new_ir_node (irg, block, op_SymConst, mode_I, 0, in);
707 res->attr.i.num = symkind;
708 if (symkind == linkage_ptr_info) {
709 res->attr.i.tori.ptrinfo = (ident *)value;
711 assert ( ( (symkind == type_tag)
712 || (symkind == size))
713 && (is_type(value)));
714 res->attr.i.tori.typ = (type *)value;
716 res = optimize (res);
722 new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node **in)
726 res = new_ir_node (irg, block, op_Sync, mode_M, arity, in);
728 res = optimize (res);
735 new_r_Bad (ir_node *block)
737 return current_ir_graph->bad;
740 /***********************/
741 /** public interfaces */
742 /** construction tools */
749 res = new_ir_node (current_ir_graph, current_ir_graph->current_block,
750 op_Start, mode_T, 0, NULL);
752 res = optimize (res);
763 res = new_ir_node (current_ir_graph, current_ir_graph->current_block,
764 op_End, mode_X, -1, NULL);
766 res = optimize (res);
777 res = new_ir_node (current_ir_graph, NULL, op_Block, mode_R, -1, NULL);
778 current_ir_graph->current_block = res;
779 res->attr.block.matured = 0;
780 set_Block_block_visit(res, 0);
782 /* forget this optimization. use this only if mature !!!!
783 res = optimize (res); */
786 /** create a new dynamic array, which stores all parameters in irnodes */
787 /** using the same obstack as the whole irgraph */
788 res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
789 current_ir_graph->params);
791 /** initialize the parameter array */
792 memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->params);
799 new_Phi (int arity, ir_node **in, ir_mode *mode)
801 return new_r_Phi (current_ir_graph, current_ir_graph->current_block,
806 new_Const (ir_mode *mode, tarval *con)
808 return new_r_Const (current_ir_graph, current_ir_graph->start_block,
813 new_Id (ir_node *val, ir_mode *mode)
815 return new_r_Id (current_ir_graph, current_ir_graph->current_block,
820 new_Proj (ir_node *arg, ir_mode *mode, long proj)
822 return new_r_Proj (current_ir_graph, current_ir_graph->current_block,
827 new_Conv (ir_node *op, ir_mode *mode)
829 return new_r_Conv (current_ir_graph, current_ir_graph->current_block,
834 new_Tuple (int arity, ir_node **in)
836 return new_r_Tuple (current_ir_graph, current_ir_graph->current_block,
841 new_Add (ir_node *op1, ir_node *op2, ir_mode *mode)
843 return new_r_Add (current_ir_graph, current_ir_graph->current_block,
848 new_Sub (ir_node *op1, ir_node *op2, ir_mode *mode)
850 return new_r_Sub (current_ir_graph, current_ir_graph->current_block,
856 new_Minus (ir_node *op, ir_mode *mode)
858 return new_r_Minus (current_ir_graph, current_ir_graph->current_block,
863 new_Mul (ir_node *op1, ir_node *op2, ir_mode *mode)
865 return new_r_Mul (current_ir_graph, current_ir_graph->current_block,
870 new_Quot (ir_node *memop, ir_node *op1, ir_node *op2)
872 return new_r_Quot (current_ir_graph, current_ir_graph->current_block,
877 new_DivMod (ir_node *memop, ir_node *op1, ir_node *op2)
879 return new_r_DivMod (current_ir_graph, current_ir_graph->current_block,
884 new_Div (ir_node *memop, ir_node *op1, ir_node *op2)
886 return new_r_Div (current_ir_graph, current_ir_graph->current_block,
891 new_Mod (ir_node *memop, ir_node *op1, ir_node *op2)
893 return new_r_Mod (current_ir_graph, current_ir_graph->current_block,
898 new_And (ir_node *op1, ir_node *op2, ir_mode *mode)
900 return new_r_And (current_ir_graph, current_ir_graph->current_block,
905 new_Or (ir_node *op1, ir_node *op2, ir_mode *mode)
907 return new_r_Or (current_ir_graph, current_ir_graph->current_block,
912 new_Eor (ir_node *op1, ir_node *op2, ir_mode *mode)
914 return new_r_Eor (current_ir_graph, current_ir_graph->current_block,
919 new_Not (ir_node *op, ir_mode *mode)
921 return new_r_Not (current_ir_graph, current_ir_graph->current_block,
926 new_Shl (ir_node *op, ir_node *k, ir_mode *mode)
928 return new_r_Shl (current_ir_graph, current_ir_graph->current_block,
933 new_Shr (ir_node *op, ir_node *k, ir_mode *mode)
935 return new_r_Shr (current_ir_graph, current_ir_graph->current_block,
940 new_Shrs (ir_node *op, ir_node *k, ir_mode *mode)
942 return new_r_Shrs (current_ir_graph, current_ir_graph->current_block,
947 new_Rotate (ir_node *op, ir_node *k, ir_mode *mode)
949 return new_r_Rot (current_ir_graph, current_ir_graph->current_block,
954 new_Abs (ir_node *op, ir_mode *mode)
956 return new_r_Abs (current_ir_graph, current_ir_graph->current_block,
961 new_Cmp (ir_node *op1, ir_node *op2)
963 return new_r_Cmp (current_ir_graph, current_ir_graph->current_block,
970 return new_r_Jmp (current_ir_graph, current_ir_graph->current_block);
974 new_Cond (ir_node *c)
976 return new_r_Cond (current_ir_graph, current_ir_graph->current_block, c);
980 new_Call (ir_node *store, ir_node *callee, int arity, ir_node **in,
983 return new_r_Call (current_ir_graph, current_ir_graph->current_block,
984 store, callee, arity, in, type);
987 /* make M parameter in call explicit:
988 new_Return (ir_node* store, int arity, ir_node **in) */
990 new_Return (ir_node* store, int arity, ir_node **in)
992 return new_r_Return (current_ir_graph, current_ir_graph->current_block,
997 new_Raise (ir_node *store, ir_node *obj)
999 return new_r_Raise (current_ir_graph, current_ir_graph->current_block,
1004 new_Load (ir_node *store, ir_node *addr)
1006 return new_r_Load (current_ir_graph, current_ir_graph->current_block,
1011 new_Store (ir_node *store, ir_node *addr, ir_node *val)
1013 return new_r_Store (current_ir_graph, current_ir_graph->current_block,
1018 new_Alloc (ir_node *store, ir_node *size, type *alloc_type,
1021 return new_r_Alloc (current_ir_graph, current_ir_graph->current_block,
1022 store, size, alloc_type, where);
1026 new_Free (ir_node *store, ir_node *ptr, ir_node *size, type *free_type)
1028 return new_r_Free (current_ir_graph, current_ir_graph->current_block,
1029 store, ptr, size, free_type);
1033 new_simpleSel (ir_node *store, ir_node *objptr, entity *ent)
1034 /* GL: objptr was called frame before. Frame was a bad choice for the name
1035 as the operand could as well be a pointer to a dynamic object. */
1037 return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
1038 store, objptr, 0, NULL, ent);
1042 new_Sel (ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)
1044 return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
1045 store, objptr, n_index, index, sel);
1049 new_SymConst (type_or_id *value, symconst_kind kind)
1051 return new_r_SymConst (current_ir_graph, current_ir_graph->current_block,
1056 new_Sync (int arity, ir_node** in)
1058 return new_r_Sync (current_ir_graph, current_ir_graph->current_block,
1066 return current_ir_graph->bad;
1070 /************************/
1071 /* ir block constructor */
1073 /* GL: what's this good for? */
1075 typedef struct ir_block {
1078 /* -1 = error, 0 = OK */
1095 /* call once for each run of the library */