X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=testprograms%2Fcall_str_example.c;h=2ea856ab307f69d4f748107033b9c23624050795;hb=b863ba4c0942c387ea18167a6b970a67b26c7ec1;hp=604a1d7e6d502056fd0ef671bf23423f6897c607;hpb=76572961989e62cef01b295c6c8af7460f6080dd;p=libfirm diff --git a/testprograms/call_str_example.c b/testprograms/call_str_example.c index 604a1d7e6..2ea856ab3 100644 --- a/testprograms/call_str_example.c +++ b/testprograms/call_str_example.c @@ -10,12 +10,10 @@ * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. */ -# include -# include +#include +#include -# include "irvrfy.h" -# include "irdump.h" -# include "firm.h" +#include /** * This file constructs the ir for the following pseudo-program: @@ -29,31 +27,35 @@ * This program demonstrates how to represent string constants. */ -int main(int argc, char **argv) +int main(void) { + char *dump_file_suffix = ""; ir_graph *irg; /* this variable contains the irgraph */ - type *owner; /* the class in which this method is defined */ - type *proc_main; /* type information for the method main */ - type *proc_called; /* type information for called method f */ - type *U8, *U8array, *string_ptr; /* type for pointers to strings. */ - entity *ent; /* represents this method as entity of owner */ - entity *const_str; /* represents a constant string. */ + ir_type *owner; /* the class in which this method is defined */ + ir_type *proc_main; /* ir_type information for the method main */ + ir_type *proc_called; /* ir_type information for called method f */ + ir_type *U8, *U8array, *string_ptr; /* ir_type for pointers to strings. */ + ir_entity *ent; /* represents this method as ir_entity of owner */ + ir_entity *const_str; /* represents a constant string. */ char *str = "Hello World\n"; /* The constant string. */ ir_node *x, *str_addr, *proc_ptr, *call; - int i; + symconst_symbol sym; + size_t i; printf("\nCreating an IR graph: CALL_STR_EXAMPLE...\n"); /* init library */ init_firm (NULL); - /* An unsinged 8 bit type */ - U8 = new_type_primitive (id_from_str("char", 4), mode_Bu); + /* An unsinged 8 bit ir_type */ + U8 = new_type_primitive (new_id_from_chars("char", 4), mode_Bu); /* An array containing unsigned 8 bit elements. */ - U8array = new_type_array (id_from_str ("char_arr", 8), 1, U8); - string_ptr = new_type_pointer (id_from_str ("ptr_to_string", 13), U8array); + U8array = new_type_array (new_id_from_chars("char_arr", 8), 1, U8); + set_array_lower_bound_int(U8array, 0, 0); - /* Make a global entity that represents the constant String. */ + string_ptr = new_type_pointer (new_id_from_chars ("ptr_to_string", 13), U8array, mode_P); + + /* Make a global ir_entity that represents the constant String. */ const_str = new_entity(get_glob_type(), new_id_from_str("constStr"), U8array); set_entity_variability(const_str, variability_constant); for (i = 0; i < strlen(str); i++) { @@ -66,32 +68,32 @@ int main(int argc, char **argv) * For imperative languages like C we view a program as a large class containing * all functions of the program as methods in this class. This class is * automatically generated. - * We use the same name for the method type as for the method entity. + * We use the same name for the method ir_type as for the method ir_entity. */ #define METHODNAME "CALL_STR_EXAMPLE_main" #define NRARGS 0 #define NRES 0 owner = get_glob_type(); - proc_main = new_type_method(id_from_str(METHODNAME, strlen(METHODNAME)), + proc_main = new_type_method(new_id_from_chars(METHODNAME, strlen(METHODNAME)), NRARGS, NRES); - /* Make type information for called method which also belongs to the - global type. */ + /* Make ir_type information for called method which also belongs to the + global ir_type. */ #define F_METHODNAME "f" #define F_NRARGS 1 #define F_NRES 0 owner = get_glob_type(); - proc_called = new_type_method(id_from_str(F_METHODNAME, strlen(F_METHODNAME)), + proc_called = new_type_method(new_id_from_chars(F_METHODNAME, strlen(F_METHODNAME)), F_NRARGS, F_NRES); set_method_param_type(proc_called, 0, string_ptr); - /* Make the entity for main needed for a correct ir_graph. */ + /* Make the ir_entity for main needed for a correct ir_graph. */ #define ENTITYNAME "CALL_STR_EXAMPLE_main" - ent = new_entity (owner, id_from_str (ENTITYNAME, strlen(ENTITYNAME)), + ent = new_entity (owner, new_id_from_chars (ENTITYNAME, strlen(ENTITYNAME)), proc_main); - /* Generates the basic graph for the method represented by entity ent, that + /* Generates the basic graph for the method represented by ir_entity ent, that * is, generates start and end blocks and nodes and a first, initial block. * The constructor needs to know how many local variables the method has. */ @@ -99,12 +101,13 @@ int main(int argc, char **argv) irg = new_ir_graph (ent, NUM_OF_LOCAL_VARS); /* get the pointer to the string constant */ - str_addr = new_Const(mode_P, new_tarval_from_entity(const_str, mode_P)); + sym.entity_p = const_str; + str_addr = new_SymConst(mode_P, sym, symconst_addr_ent); - /* get the pointer to the procedure from the class type */ + /* get the pointer to the procedure from the class ir_type */ /* this is how a pointer to be fixed by the linker is represented. */ - proc_ptr = new_SymConst ((type_or_id_p)id_from_str (F_METHODNAME, strlen(F_METHODNAME)), - linkage_ptr_info); + sym.ident_p = new_id_from_str (F_METHODNAME); + proc_ptr = new_SymConst (mode_P, sym, symconst_addr_name); /* call procedure set_a, first built array with parameters */ { @@ -113,21 +116,21 @@ int main(int argc, char **argv) call = new_Call(get_store(), proc_ptr, 1, in, proc_called); } /* make the possible changes by the called method to memory visible */ - set_store(new_Proj(call, mode_M, 0)); + set_store(new_Proj(call, mode_M, pn_Call_M)); /* Make the return node returning the memory. */ x = new_Return (get_store(), 0, NULL); /* Now we generated all instructions for this block and all its predecessor blocks * so we can mature it. */ - mature_block (get_irg_current_block(irg)); + mature_immBlock (get_irg_current_block(irg)); /* This adds the in edge of the end block which originates at the return statement. * The return node passes controlflow to the end block. */ - add_in_edge (get_irg_end_block(irg), x); + add_immBlock_pred (get_irg_end_block(irg), x); /* Now we can mature the end block as all it's predecessors are known. */ - mature_block (get_irg_end_block(irg)); + mature_immBlock (get_irg_end_block(irg)); - finalize_cons (irg); + irg_finalize_cons (irg); printf("Optimizing ...\n"); dead_node_elimination(irg); @@ -136,10 +139,10 @@ int main(int argc, char **argv) irg_vrfy(irg); printf("Done building the graph. Dumping it.\n"); - dump_ir_block_graph (irg); - dump_all_types(); - printf("Use xvcg to view this graph:\n"); - printf("/ben/goetz/bin/xvcg GRAPHNAME\n\n"); + dump_ir_block_graph (irg, dump_file_suffix); + dump_all_types(dump_file_suffix); + printf("Use ycomp to view this graph:\n"); + printf("ycomp GRAPHNAME\n\n"); return (0); }