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