X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.c;h=3eaedfa96d8f9c82560fc15d61c7d3aaa1d0a3b9;hb=93ec9eb45d1630e73ed4932d66683adcc9c28d71;hp=4975d0f44bebf274e107d71be7661bd8b5b48491;hpb=51f4c92b8bbb63562c833e2f989afc2e80b716c9;p=libfirm

diff --git a/ir/tr/type.c b/ir/tr/type.c
index 4975d0f44..3eaedfa96 100644
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -6,7 +6,7 @@
  * Modified by: Michael Beck
  * Created:
  * CVS-ID:      $Id$
- * Copyright:   (c) 2001-2003 Universität Karlsruhe
+ * Copyright:   (c) 2001-2006 Universität Karlsruhe
  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  */
 
@@ -255,7 +255,7 @@ int (get_type_size_bits)(const ir_type *tp) {
 }
 
 
-visibility get_type_visibility (const ir_type *tp) {
+ir_visibility get_type_visibility (const ir_type *tp) {
 #if 0
   visibility res =  visibility_local;
   if (is_compound_type(tp)) {
@@ -279,7 +279,7 @@ visibility get_type_visibility (const ir_type *tp) {
   return tp->visibility;
 }
 
-void       set_type_visibility (ir_type *tp, visibility v) {
+void       set_type_visibility (ir_type *tp, ir_visibility v) {
   assert(is_type(tp));
 #if 0
   /* check for correctness */
@@ -955,7 +955,7 @@ void set_class_type_info(ir_type *clss, entity *ent) {
   clss->attr.ca.type_info = ent;
 }
 
-const char *get_peculiarity_name(peculiarity p) {
+const char *get_peculiarity_name(ir_peculiarity p) {
 #define X(a)    case a: return #a
   switch (p) {
     X(peculiarity_description);
@@ -966,12 +966,12 @@ const char *get_peculiarity_name(peculiarity p) {
   return "invalid peculiarity";
 }
 
-peculiarity get_class_peculiarity (const ir_type *clss) {
+ir_peculiarity get_class_peculiarity (const ir_type *clss) {
   assert(clss && (clss->type_op == type_class));
   return clss->attr.ca.peculiarity;
 }
 
-void        set_class_peculiarity (ir_type *clss, peculiarity pec) {
+void        set_class_peculiarity (ir_type *clss, ir_peculiarity pec) {
   assert(clss && (clss->type_op == type_class));
   assert(pec != peculiarity_inherited);  /* There is no inheritance of types in libFirm. */
   clss->attr.ca.peculiarity = pec;
@@ -1157,10 +1157,15 @@ build_value_type(ident *name, int len, tp_ent_pair *tps) {
   /* Remove type from type list.  Must be treated differently than other types. */
   remove_irp_type(res);
   for (i = 0; i < len; i++) {
+    ident *id = tps[i].param_name;
+
     /* use res as default if corresponding type is not yet set. */
     ir_type *elt_type = tps[i].tp ? tps[i].tp : res;
 
-    tps[i].ent = new_entity(res, mangle_u(name, get_type_ident(elt_type)), elt_type);
+    /* use the parameter name if specified */
+    if (! id)
+      id = mangle_u(name, get_type_ident(elt_type));
+    tps[i].ent = new_entity(res, id, elt_type);
     set_entity_allocation(tps[i].ent, allocation_parameter);
   }
   return res;
@@ -1176,7 +1181,7 @@ ir_type *new_d_type_method(ident *name, int n_param, int n_res, dbg_info *db) {
   res->flags                       |= tf_layout_fixed;
   res->size                         = get_mode_size_bits(mode_P_code);
   res->attr.ma.n_params             = n_param;
-  res->attr.ma.param_type           = xcalloc(n_param, sizeof(res->attr.ma.param_type[0]));
+  res->attr.ma.params               = xcalloc(n_param, sizeof(res->attr.ma.params[0]));
   res->attr.ma.value_params         = NULL;
   res->attr.ma.n_res                = n_res;
   res->attr.ma.res_type             = xcalloc(n_res, sizeof(res->attr.ma.res_type[0]));
@@ -1200,7 +1205,7 @@ void free_method_entities(ir_type *method) {
 /* Attention: also frees entities in value parameter subtypes! */
 void free_method_attrs(ir_type *method) {
   assert(method && (method->type_op == type_method));
-  free(method->attr.ma.param_type);
+  free(method->attr.ma.params);
   free(method->attr.ma.res_type);
   if (method->attr.ma.value_params) {
     free_type_entities(method->attr.ma.value_params);
@@ -1217,19 +1222,20 @@ int (get_method_n_params)(const ir_type *method) {
   return _get_method_n_params(method);
 }
 
+/* Returns the type of the parameter at position pos of a method. */
 ir_type *get_method_param_type(ir_type *method, int pos) {
   ir_type *res;
   assert(method && (method->type_op == type_method));
   assert(pos >= 0 && pos < get_method_n_params(method));
-  res = method->attr.ma.param_type[pos].tp;
+  res = method->attr.ma.params[pos].tp;
   assert(res != NULL && "empty method param type");
-  return method->attr.ma.param_type[pos].tp = skip_tid(res);
+  return method->attr.ma.params[pos].tp = skip_tid(res);
 }
 
 void  set_method_param_type(ir_type *method, int pos, ir_type *tp) {
   assert(method && (method->type_op == type_method));
   assert(pos >= 0 && pos < get_method_n_params(method));
-  method->attr.ma.param_type[pos].tp = tp;
+  method->attr.ma.params[pos].tp = tp;
   /* If information constructed set pass-by-value representation. */
   if (method->attr.ma.value_params) {
     assert(get_method_n_params(method) == get_struct_n_members(method->attr.ma.value_params));
@@ -1237,6 +1243,28 @@ void  set_method_param_type(ir_type *method, int pos, ir_type *tp) {
   }
 }
 
+/* Returns an ident representing the parameters name. Returns NULL if not set.
+   For debug support only. */
+ident *get_method_param_ident(ir_type *method, int pos) {
+  assert(method && (method->type_op == type_method));
+  assert(pos >= 0 && pos < get_method_n_params(method));
+  return method->attr.ma.params[pos].param_name;
+}
+
+/* Returns a string representing the parameters name. Returns NULL if not set.
+   For debug support only. */
+const char *get_method_param_name(ir_type *method, int pos) {
+  ident *id = get_method_param_ident(method, pos);
+  return id ? get_id_str(id) : NULL;
+}
+
+/* Sets an ident representing the parameters name. For debug support only. */
+void set_method_param_ident(ir_type *method, int pos, ident *id) {
+  assert(method && (method->type_op == type_method));
+  assert(pos >= 0 && pos < get_method_n_params(method));
+  method->attr.ma.params[pos].param_name = id;
+}
+
 /* Returns an entity that represents the copied value argument.  Only necessary
    for compounds passed by value. */
 entity *get_method_value_param_ent(ir_type *method, int pos) {
@@ -1247,15 +1275,15 @@ entity *get_method_value_param_ent(ir_type *method, int pos) {
     /* parameter value type not created yet, build */
     method->attr.ma.value_params
       = build_value_type(mangle_u(get_type_ident(method), value_params_suffix),
-             get_method_n_params(method), method->attr.ma.param_type);
+             get_method_n_params(method), method->attr.ma.params);
   }
   /*
    * build_value_type() sets the method->attr.ma.value_params type as default if
    * no type is set!
    */
-  assert((get_entity_type(method->attr.ma.param_type[pos].ent) != method->attr.ma.value_params)
+  assert((get_entity_type(method->attr.ma.params[pos].ent) != method->attr.ma.value_params)
      && "param type not yet set");
-  return method->attr.ma.param_type[pos].ent;
+  return method->attr.ma.params[pos].ent;
 }
 
 /*
@@ -1697,16 +1725,18 @@ void set_array_size_bits(ir_type *tp, int size) {
 /*-----------------------------------------------------------------*/
 
 /* create a new type enumeration -- set the enumerators independently */
-ir_type *new_d_type_enumeration(ident *name, dbg_info *db) {
-  ir_type *res = new_type(type_enumeration, NULL, name, db);
+ir_type *new_d_type_enumeration(ident *name, int n_enums, dbg_info *db) {
+  ir_type *res;
 
-  res->attr.ea.enumer = NEW_ARR_F(ir_enum_const, 0);
+  assert(n_enums >= 0);
+  res = new_type(type_enumeration, NULL, name, db);
+  res->attr.ea.enumer = NEW_ARR_F(ir_enum_const, n_enums);
   hook_new_type(res);
   return res;
 }
 
-ir_type *new_type_enumeration(ident *name) {
-  return new_d_type_enumeration(name, NULL);
+ir_type *new_type_enumeration(ident *name, int n_enums) {
+  return new_d_type_enumeration(name, n_enums, NULL);
 }
 
 void free_enumeration_entities(ir_type *enumeration) {
@@ -1724,16 +1754,11 @@ int     get_enumeration_n_enums(const ir_type *enumeration) {
 }
 
 /* create a new constant */
-int add_enumeration_const(ir_type *enumeration, ident *nameid, tarval *con) {
-  ir_enum_const c;
-  int idx = ARR_LEN(enumeration->attr.ea.enumer);
-
-  c.nameid = nameid;
-  c.value  = con;
-  c.owner  = enumeration;
-
-  ARR_APP1(ir_enum_const, enumeration->attr.ea.enumer, c);
-  return idx;
+void set_enumeration_const(ir_type *enumeration, int pos, ident *nameid, tarval *con) {
+  assert(0 <= pos && pos < ARR_LEN(enumeration->attr.ea.enumer));
+  enumeration->attr.ea.enumer[pos].nameid = nameid;
+  enumeration->attr.ea.enumer[pos].value  = con;
+  enumeration->attr.ea.enumer[pos].owner  = enumeration;
 }
 
 ir_enum_const *get_enumeration_const(const ir_type *enumeration, int pos) {
@@ -2041,5 +2066,7 @@ entity *frame_alloc_area(ir_type *frame_type, int size, int alignment, int at_st
   set_entity_offset_bytes(area, offset);
   set_type_size_bytes(frame_type, frame_size);
 
+  /* mark this entity as compiler generated */
+  set_entity_compiler_generated(area, 1);
   return area;
 }