nsz Git - libfirm/blob - ir/tr/entity.c

   1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
   2 ** All rights reserved.
   3 **
   4 ** Authors: Martin Trapp, Christian Schaefer
   5 **
   6 */
   7
   8 #ifdef HAVE_CONFIG_H
   9 # include <config.h>
  10 #endif
  11
  12 # include <stdlib.h>
  13 # include <stddef.h>
  14 # include "entity_t.h"
  15 # include "mangle.h"
  16 # include "typegmod_t.h"
  17 # include "array.h"
  18
  19 /*******************************************************************/
  20 /** general                                                       **/
  21 /*******************************************************************/
  22
  23 void
  24 init_entity (void)
  25 {
  26 }
  27
  28 /*******************************************************************/
  29 /** ENTITY                                                        **/
  30 /*******************************************************************/
  31
  32 inline void insert_entity_in_owner (entity *ent) {
  33   type *owner = ent->owner;
  34   switch (get_type_tpop_code(owner)) {
  35   case tpo_class: {
  36     add_class_member (owner, ent);
  37   } break;
  38   case tpo_struct: {
  39     add_struct_member (owner, ent);
  40   } break;
  41   case tpo_union: {
  42     add_union_member (owner, ent);
  43   } break;
  44   case tpo_array: {
  45     set_array_element_entity(owner, ent);
  46   } break;
  47   default: assert(0);
  48   }
  49 }
  50
  51 entity *
  52 new_entity (type *owner, ident *name, type *type)
  53 {
  54   entity *res;
  55
  56   res = (entity *) malloc (sizeof (entity));
  57   res->kind = k_entity;
  58   assert_legal_owner_of_ent(owner);
  59   res->owner = owner;
  60   res->name = name;
  61   res->type = type;
  62   res->allocation = dynamic_allocated;
  63   res->visibility = local;
  64   res->ld_name = NULL;
  65   res->overwrites = NEW_ARR_F(entity *, 1);
  66
  67   res->visit = 0;
  68
  69   /* Remember entity in it's owner. */
  70   insert_entity_in_owner (res);
  71   return res;
  72 }
  73 inline void free_entity_attrs(entity *ent) {
  74   assert(ent);
  75   DEL_ARR_F(ent->overwrites);
  76 }
  77
  78 entity *
  79 copy_entity_own (entity *old, type *new_owner) {
  80   entity *new;
  81
  82   assert_legal_owner_of_ent(new_owner);
  83   if (old->owner == new_owner) return old;
  84   new = (entity *) malloc (sizeof (entity));
  85   memcpy (new, old, sizeof (entity));
  86   new->owner = new_owner;
  87   new->overwrites = DUP_ARR_F(entity *, old->overwrites);
  88
  89   insert_entity_in_owner (new);
  90
  91   return new;
  92 }
  93
  94 entity *
  95 copy_entity_name (entity *old, ident *new_name) {
  96   entity *new;
  97
  98   if (old->name == new_name) return old;
  99   new = (entity *) malloc (sizeof (entity));
 100   memcpy (new, old, sizeof (entity));
 101   new->name = new_name;
 102   new->ld_name = NULL;
 103   new->overwrites = DUP_ARR_F(entity *, old->overwrites);
 104
 105   insert_entity_in_owner (new);
 106
 107   return new;
 108 }
 109
 110 inline const char *
 111 get_entity_name (entity *ent) {
 112   assert (ent);
 113   return id_to_str(get_entity_ident(ent));
 114 }
 115
 116 ident *
 117 get_entity_ident    (entity *ent) {
 118   assert(ent);
 119   return ent->name;
 120 }
 121
 122 /*
 123 void   set_entity_ld_name  (entity *, char *ld_name);
 124 void   set_entity_ld_ident (entity *, ident *ld_ident);
 125 */
 126
 127 inline type *
 128 get_entity_owner (entity *ent) {
 129   return ent->owner = skip_tid(ent->owner);
 130 }
 131
 132 inline void
 133 set_entity_owner (entity *ent, type *owner) {
 134   assert_legal_owner_of_ent(owner);
 135   ent->owner = owner;
 136 }
 137
 138 inline void   /* should this go into type.c? */
 139 assert_legal_owner_of_ent(type *owner) {
 140   assert (get_type_tpop_code(owner) == tpo_class ||
 141           get_type_tpop_code(owner) == tpo_union ||
 142           get_type_tpop_code(owner) == tpo_struct ||
 143           get_type_tpop_code(owner) == tpo_array);   /* Yes, array has an entity
 144                                                         -- to select fields! */
 145 }
 146
 147 inline ident *
 148 get_entity_ld_ident (entity *ent)
 149 {
 150   if (ent->ld_name == NULL)
 151     ent->ld_name = mangle_entity (ent);
 152   return ent->ld_name;
 153 }
 154
 155 inline void
 156 set_entity_ld_ident (entity *ent, ident *ld_ident) {
 157   ent->ld_name = ld_ident;
 158 }
 159
 160 /*
 161 char  *get_entity_ld_name  (entity *);
 162 void   set_entity_ld_name  (entity *, char *ld_name);
 163 */
 164
 165 inline type *
 166 get_entity_type (entity *ent) {
 167   return ent->type = skip_tid(ent->type);
 168 }
 169
 170 inline void
 171 set_entity_type (entity *ent, type *type) {
 172   ent->type = type;
 173 }
 174
 175
 176 inline ent_allocation
 177 get_entity_allocation (entity *ent) {
 178   return ent->allocation;
 179 }
 180
 181 inline void
 182 set_entity_allocation (entity *ent, ent_allocation al) {
 183   ent->allocation = al;
 184 }
 185
 186
 187 inline ent_visibility
 188 get_entity_visibility (entity *ent) {
 189   return ent->visibility;
 190 }
 191
 192 inline void
 193 set_entity_visibility (entity *ent, ent_visibility vis) {
 194   if (vis != local) assert(ent->allocation == static_allocated);
 195   ent->visibility = vis;
 196 }
 197
 198 inline int
 199 get_entity_offset (entity *ent) {
 200   return ent->offset;
 201 }
 202
 203 inline void
 204 set_entity_offset (entity *ent, int offset) {
 205   ent->offset = offset;
 206 }
 207
 208 inline void
 209 add_entity_overwrites   (entity *ent, entity *overwritten) {
 210   assert(ent);
 211   ARR_APP1 (entity *, ent->overwrites, overwritten);
 212 }
 213
 214 inline int
 215 get_entity_n_overwrites (entity *ent){
 216   assert(ent);
 217   return (ARR_LEN (ent->overwrites))-1;
 218 }
 219
 220 inline entity *
 221 get_entity_overwrites   (entity *ent, int pos){
 222   assert(ent);
 223   return ent->overwrites[pos+1];
 224 }
 225
 226 inline void
 227 set_entity_overwrites   (entity *ent, int pos, entity *overwritten) {
 228   assert(ent);
 229   ent->overwrites[pos+1] = overwritten;
 230 }
 231
 232 inline ir_graph *
 233 get_entity_irg(entity *ent) {
 234   assert (ent);
 235   assert (is_method_type(ent->type));
 236   return ent->irg;
 237 }
 238
 239 inline void
 240 set_entity_irg(entity *ent, ir_graph *irg) {
 241   assert (ent && ent->type);
 242   assert (irg);
 243   assert (is_method_type(ent->type));
 244   ent->irg = irg;
 245 }