X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=testprograms%2Farray-stack_example.c;h=96e29a4e276fde24058830c864de9a2dfd4eff68;hb=0aa04a84a758e40748fc25eb8a2fef7343f8f49e;hp=38287fd48a3449a3a3ad41126d9827ad85572c2e;hpb=3e5692defee7bec4dcd584b83d1c79baaf6a63c7;p=libfirm diff --git a/testprograms/array-stack_example.c b/testprograms/array-stack_example.c index 38287fd48..96e29a4e2 100644 --- a/testprograms/array-stack_example.c +++ b/testprograms/array-stack_example.c @@ -1,32 +1,42 @@ - /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe -** All rights reserved. -** -** Authors: Goetz Lindenmaier -** -** testprogram. -*/ - -# include "irdump.h" -# include "firm.h" - -/** This example describes representation of stack allocated variables of -*** imperative programs. -*** It constructs the IR for the following program: -*** -*** -*** main(): int -*** int a[10]; -*** -*** return (a[3]); -*** end; -*** -*** The array is placed on the stack, i.e., a pointer to the array -*** is obtained by selecting the entity "a" from the stack. The variables -*** on the stack are considered to be entities of the method, as locals -*** of a method are only visible within the method. (An alternative to -*** make the method owner of the stack variables is to give the ownership -*** to the class representing the C-file. This would extend the visibility -*** of the locals, though.) + +/* + * Project: libFIRM + * File name: testprograms/array-stack_example.c + * Purpose: Show representation of array on stack. + * Author: Goetz Lindenmaier + * Modified by: + * Created: + * CVS-ID: $Id$ + * Copyright: (c) 1999-2003 Universität Karlsruhe + * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + */ + + +#include +#include + + + +#include + +/** +* imperative programs. +* It constructs the IR for the following program: +* +* +* main(): int +* int a[10]; +* +* return (a[3]); +* end; +* +* The array is placed on the stack, i.e., a pointer to the array +* is obtained by selecting the ir_entity "a" from the stack. The variables +* on the stack are considered to be entities of the method, as locals +* of a method are only visible within the method. (An alternative to +* make the method owner of the stack variables is to give the ownership +* to the class representing the C-file. This would extend the visibility +* of the locals, though.) **/ @@ -35,66 +45,64 @@ int main(void) { + char *dump_file_suffix = ""; /* describes the general structure of a C-file */ - type *owner; /* the class standing for everything in this file */ - type *proc_main; /* Typeinformation for method main. */ - entity *proc_main_e; /* The entity describing that method main is an - entity of the fake class representing the file. */ + ir_type *owner; /* the class standing for everything in this file */ + ir_type *proc_main; /* Typeinformation for method main. */ + ir_entity *proc_main_e; /* The ir_entity describing that method main is an + ir_entity of the fake class representing the file. */ /* describes types defined by the language */ - type *prim_t_int; + ir_type *prim_t_int; /* describes the array and its fields. */ - entity *array_ent; /* the entity representing the array as member + ir_entity *array_ent; /* the ir_entity representing the array as member of the stack/method */ - type *array_type; /* the type information for the array */ - entity *field_ent; /* the entity representing a field of the array */ - - /* Needed while finding the element size. */ - type *elt_type; - ir_mode *elt_type_mode; - int size; - ir_node *arr_size; + ir_type *array_type; /* the ir_type information for the array */ + ir_entity *field_ent; /* the ir_entity representing a field of the + array */ /* holds the graph and nodes. */ ir_graph *main_irg; - ir_node *array, *array_ptr, *c3, *elt, *val, *x; - + ir_node *array_ptr, *c3, *elt, *val, *x; - init_firm (); + init_firm (NULL); printf("\nCreating an IR graph: ARRAY-STACK_EXAMPLE...\n"); - /* make basic type information for primitive type int. + /* make basic ir_type information for primitive ir_type int. In Sather primitive types are represented by a class. This is the modeling appropriate for other languages. Mode_i says that all language-integers shall be implemented as a 32 bit processor-integer value. */ - prim_t_int = new_type_primitive(id_from_str ("int", 3), mode_i); + prim_t_int = new_type_primitive(new_id_from_chars ("int", 3), mode_Is); /* build typeinformation of procedure main */ - owner = new_type_class (id_from_str ("ARRAY-STACK_EXAMPLE", 19)); - proc_main = new_type_method(id_from_str("main_tp", 4), 0, 1); + owner = new_type_class (new_id_from_chars ("ARRAY-STACK_EXAMPLE", 19)); + proc_main = new_type_method(new_id_from_chars("main_tp", 7), 0, 1); set_method_res_type(proc_main, 0, prim_t_int); - proc_main_e = new_entity (owner, id_from_str ("main", 4), proc_main); + proc_main_e = new_entity (owner, new_id_from_chars ("main", 4), proc_main); + get_entity_ld_name(proc_main_e); /* force name mangling */ - main_irg = new_ir_graph (proc_main_e, 4); - - /* make type information for the array and set the bounds */ + /* make ir_type information for the array and set the bounds */ # define N_DIMS 1 # define L_BOUND 0 # define U_BOUND 9 - array_type = new_type_array(id_from_str("a_tp", 4), N_DIMS, prim_t_int); - set_array_bounds(array_type, 1, - new_Const(mode_I, tarval_from_long (mode_I, L_BOUND)), - new_Const(mode_I, tarval_from_long (mode_I, U_BOUND))); - /* The array is an entity of the method, placed on the mehtod's own memory, + array_type = new_type_array(new_id_from_chars("a_tp", 4), N_DIMS, prim_t_int); + current_ir_graph = get_const_code_irg(); + set_array_bounds(array_type, 0, + new_Const(mode_Iu, new_tarval_from_long (L_BOUND, mode_Iu)), + new_Const(mode_Iu, new_tarval_from_long (U_BOUND, mode_Iu))); + + main_irg = new_ir_graph (proc_main_e, 4); + + /* The array is an ir_entity of the method, placed on the mehtod's own memory, the stack frame. */ - array_ent = new_entity(get_cur_frame_type(), id_from_str("a", 1), array_type); + array_ent = new_entity(get_cur_frame_type(), new_id_from_chars("a", 1), array_type); /* As the array is accessed by Sel nodes, we need information about - the entity the node selects. Entities of an array are it's elements + the ir_entity the node selects. Entities of an array are it's elements which are, in this case, integers. */ - /* change entity owner types. */ + /* change ir_entity owner types. */ field_ent = get_array_element_entity(array_type); @@ -105,17 +113,17 @@ main(void) /* Load element 3 of the array. For this first generate the pointer to this the element by a select node. (Alternative: increase array pointer by (three * elt_size), but this complicates some - optimizations.) The type information accessible via the entity + optimizations.) The ir_type information accessible via the ir_entity allows to generate the pointer increment later. */ - c3 = new_Const (mode_I, tarval_from_long (mode_I, 3)); + c3 = new_Const (mode_Iu, new_tarval_from_long (3, mode_Iu)); { ir_node *in[1]; in[0] = c3; elt = new_Sel(get_store(), array_ptr, 1, in, field_ent); } - val = new_Load(get_store(), elt); - set_store(new_Proj(val, mode_M, 0)); - val = new_Proj(val, mode_i, 2); + val = new_Load(get_store(), elt, mode_Is); + set_store(new_Proj(val, mode_M, pn_Load_M)); + val = new_Proj(val, mode_Is, pn_Load_res); /* return the result of procedure main */ { @@ -124,25 +132,26 @@ main(void) x = new_Return (get_store (), 1, in); } - mature_block (get_irg_current_block(main_irg)); + mature_immBlock (get_irg_current_block(main_irg)); /* complete the end_block */ - add_in_edge (get_irg_end_block(main_irg), x); - mature_block (get_irg_end_block(main_irg)); + add_immBlock_pred (get_irg_end_block(main_irg), x); + mature_immBlock (get_irg_end_block(main_irg)); + + irg_finalize_cons (main_irg); printf("Optimizing ...\n"); dead_node_elimination(main_irg); /* verify the graph */ irg_vrfy(main_irg); - - - printf("Dumping the graph and a type graph.\n"); - dump_ir_block_graph (main_irg); - dump_type_graph(main_irg); - dump_ir_block_graph_w_types(main_irg); - printf("Use xvcg to view these graphs:\n"); - printf("/ben/goetz/bin/xvcg GRAPHNAME\n\n"); - - return (1); + printf("Dumping the graph and a ir_type graph.\n"); + dump_ir_block_graph (main_irg, dump_file_suffix); + dump_type_graph(main_irg, dump_file_suffix); + dump_ir_block_graph_w_types(main_irg, dump_file_suffix); + dump_all_types(dump_file_suffix); + printf("Use ycomp to view these graphs:\n"); + printf("ycomp GRAPHNAME\n\n"); + + return (0); }