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