- add an extra filed for the bit offset\n- renamed access functions\n- renamed entity...

[r8441]

diff --git a/ir/tr/entity.c b/ir/tr/entity.c
index 89bab58..76be946 100644 (file)
--- a/ir/tr/entity.c
+++ b/ir/tr/entity.c
@@ -108,16 +108,17 @@ new_rd_entity(dbg_info *db, ir_type *owner, ident *name, ir_type *type)
   res->type    = type;
   res->owner   = owner;
 
-  res->allocation   = allocation_automatic;
-  res->visibility   = visibility_local;
-  res->volatility   = volatility_non_volatile;
-  res->stickyness   = stickyness_unsticky;
-  res->peculiarity  = peculiarity_existent;
-  res->final        = 0;
-  res->compiler_gen = 0;
-  res->offset       = -1;
-  res->link         = NULL;
-  res->repr_class   = NULL;
+  res->allocation           = allocation_automatic;
+  res->visibility           = visibility_local;
+  res->volatility           = volatility_non_volatile;
+  res->stickyness           = stickyness_unsticky;
+  res->peculiarity          = peculiarity_existent;
+  res->final                = 0;
+  res->compiler_gen         = 0;
+  res->offset               = -1;
+  res->offset_bit_remainder = 0;
+  res->link                 = NULL;
+  res->repr_class           = NULL;
 
   if (is_Method_type(type)) {
     symconst_symbol sym;
@@ -910,6 +911,7 @@ set_array_entity_values(ir_entity *ent, tarval **values, int num_vals) {
   current_ir_graph = rem;
 }
 
+/* Return the overall offset of value at position pos in bytes. */
 int get_compound_ent_value_offset_bytes(ir_entity *ent, int pos) {
        compound_graph_path *path;
        int path_len, i;
@@ -925,7 +927,7 @@ int get_compound_ent_value_offset_bytes(ir_entity *ent, int pos) {
                ir_type *node_tp = get_entity_type(node);
                ir_type *owner_tp = get_entity_owner(node);
 
-               if (owner_tp != NULL && is_Array_type(owner_tp)) {
+               if (is_Array_type(owner_tp)) {
                        int size  = get_type_size_bits(node_tp);
                        int align = get_type_alignment_bits(node_tp);
                        if(size % align > 0) {
@@ -935,22 +937,17 @@ int get_compound_ent_value_offset_bytes(ir_entity *ent, int pos) {
                        size /= 8;
                        offset += size * get_compound_graph_path_array_index(path, i - 1);
                } else {
-                       int     node_offset = get_entity_offset_bits(node);
-
-                       if(node_offset % 8 != 0) {
-                               assert(i == path_len - 1);
-                       }
-                       offset += node_offset / 8;
+                       offset += get_entity_offset(node);
                }
        }
 
        return offset;
-}
+}  /* get_compound_ent_value_offset_bytes */
 
-int get_compound_ent_value_offset_bit_part(ir_entity *ent, int pos) {
+/* Return the offset in bits from the last byte address. */
+int get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos) {
        compound_graph_path *path;
        int path_len;
-       int offset = 0;
        ir_entity *last_node;
 
        assert(get_type_state(get_entity_type(ent)) == layout_fixed);
@@ -959,18 +956,12 @@ int get_compound_ent_value_offset_bit_part(ir_entity *ent, int pos) {
        path_len = get_compound_graph_path_length(path);
        last_node = get_compound_graph_path_node(path, path_len - 1);
 
-       offset = get_entity_offset_bits(last_node);
-       if(offset < 0)
-               return 0;
-
-       return offset % 8;
-}
+       return get_entity_offset_bits_remainder(last_node);
+}  /* get_compound_ent_value_offset_bit_remainder */
 
 typedef struct {
-       /** number of elements the array can hold */
-       int n_elems;
-       /** current array index */
-       int current_elem;
+       int n_elems;      /**< number of elements the array can hold */
+       int current_elem; /**< current array index */
        ir_entity *ent;
 } array_info;
 
@@ -1090,23 +1081,23 @@ int compute_compound_ent_array_indices(ir_entity *ent) {
 }
 
 int
-(get_entity_offset_bytes)(const ir_entity *ent) {
-  return _get_entity_offset_bytes(ent);
+(get_entity_offset)(const ir_entity *ent) {
+  return _get_entity_offset(ent);
 }
 
-int
-(get_entity_offset_bits)(const ir_entity *ent) {
-  return _get_entity_offset_bits(ent);
+void
+(set_entity_offset)(ir_entity *ent, int offset) {
+  _set_entity_offset(ent, offset);
 }
 
-void
-(set_entity_offset_bytes)(ir_entity *ent, int offset) {
-  _set_entity_offset_bytes(ent, offset);
+unsigned char
+(get_entity_offset_bits_remainder)(const ir_entity *ent) {
+  return _get_entity_offset_bits_remainder(ent);
 }
 
 void
-(set_entity_offset_bits)(ir_entity *ent, int offset) {
-  _set_entity_offset_bits(ent, offset);
+(set_entity_offset_bits_remainder)(ir_entity *ent, unsigned char offset) {
+  _set_entity_offset_bits_remainder(ent, offset);
 }
 
 void

diff --git a/ir/tr/entity.h b/ir/tr/entity.h
index 7fce760..06a892d 100644 (file)
--- a/ir/tr/entity.h
+++ b/ir/tr/entity.h
@@ -291,16 +291,16 @@ ir_stickyness get_entity_stickyness(const ir_entity *ent);
 void          set_entity_stickyness(ir_entity *ent, ir_stickyness stickyness);
 
 /** Returns the offset of an entity (in a compound) in bytes. Only set if layout = fixed. */
-int       get_entity_offset_bytes(const ir_entity *ent);
-
-/** Returns the offset of an entity (in a compound) in bits. Only set if layout = fixed. */
-int       get_entity_offset_bits(const ir_entity *ent);
+int       get_entity_offset(const ir_entity *ent);
 
 /** Sets the offset of an entity (in a compound) in bytes. */
-void      set_entity_offset_bytes(ir_entity *ent, int offset);
+void      set_entity_offset(ir_entity *ent, int offset);
+
+/** Returns the offset bit remainder of a bitfield entity (in a compound) in bits. Only set if layout = fixed. */
+unsigned char get_entity_offset_bits_remainder(const ir_entity *ent);
 
-/** Sets the offset of an entity (in a compound) in bits. */
-void      set_entity_offset_bits(ir_entity *ent, int offset);
+/** Sets the offset bit remainder of a bitfield entity (in a compound) in bits. */
+void      set_entity_offset_bits_remainder(ir_entity *ent, unsigned char offset);
 
 /** Returns the stored intermediate information. */
 void *get_entity_link(const ir_entity *ent);
@@ -440,14 +440,14 @@ void     set_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member,
 void set_array_entity_values(ir_entity *ent, tarval **values, int num_vals);
 
 /**
- * Return the offset in bits from the last byte (result is in [0,7])
+ * Return the offset in bits from the last byte address.
  *
  * This requires that the layout of all concerned types is fixed.
  *
  * @param ent Any entity of compound type with at least pos initialization values.
  * @param pos The position of the value for which the offset is requested.
  */
-int get_compound_ent_value_offset_bit_part(ir_entity *ent, int pos);
+int get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos);
 
 /** Return the overall offset of value at position pos in bytes.
  *

diff --git a/ir/tr/entity_t.h b/ir/tr/entity_t.h
index 51c78a4..43e7fd4 100644 (file)
--- a/ir/tr/entity_t.h
+++ b/ir/tr/entity_t.h
@@ -49,14 +49,14 @@
 
 /** A path in a compound graph. */
 struct compound_graph_path {
-  firm_kind kind;       /**< The dynamic type tag for compound graph path. */
-  ir_type *tp;          /**< The type this path belongs to. */
-  int len;              /**< The length of the path. */
-  struct tuple {
-    int       index;    /**< Array index.  To compute position of array elements */
-    ir_entity *node;    /**< The accessed entity. */
-  } list[1];            /**< List of entity/index tuple of length len to express the
-                             access path. */
+       firm_kind kind;       /**< The dynamic type tag for compound graph path. */
+       ir_type *tp;          /**< The type this path belongs to. */
+       int len;              /**< The length of the path. */
+       struct tuple {
+               int       index;    /**< Array index.  To compute position of array elements */
+               ir_entity *node;    /**< The accessed entity. */
+       } list[1];            /**< List of entity/index tuple of length len to express the
+       access path. */
 };
 
 /** The attributes for atomic entities. */
@@ -67,10 +67,11 @@ typedef struct atomic_ent_attr {
 
 /** The attributes for compound entities. */
 typedef struct compound_ent_attr {
-  ir_node **values;     /**< constant values of compound entities. Only available if
-                             variability not uninitialized.  Must be set for variability constant. */
-  compound_graph_path **val_paths; /**< paths corresponding to constant values. Only available if
-                                        variability not uninitialized.  Must be set for variability constant. */
+       ir_node **values;     /**< constant values of compound entities. Only available if
+                                  variability not uninitialized.  Must be set for variability constant. */
+       compound_graph_path **val_paths;
+                            /**< paths corresponding to constant values. Only available if
+                                 variability not uninitialized.  Must be set for variability constant. */
 } compound_ent_attr;
 
 /** A reserved value for "not yet set". */
@@ -78,71 +79,74 @@ typedef struct compound_ent_attr {
 
 /** The attributes for methods. */
 typedef struct method_ent_attr {
-  ir_graph *irg;                 /**< The corresponding irg if known.
-                                      The ir_graph constructor automatically sets this field. */
-  unsigned irg_add_properties;   /**< Additional graph properties can be
-                                      stored in a entity if no irg is available. */
-
-  unsigned vtable_number;        /**< For a dynamically called method, the number assigned
-                                      in the virtual function table. */
-
-  ptr_access_kind *param_access; /**< the parameter access */
-  float *param_weight;           /**< The weight of method's parameters. Parameters
-                                      with a high weight are good for procedure cloning. */
-  ir_img_section section;        /**< The code section where this method should be placed */
+       ir_graph *irg;                 /**< The corresponding irg if known.
+                                           The ir_graph constructor automatically sets this field. */
+       unsigned irg_add_properties;   /**< Additional graph properties can be
+                                           stored in a entity if no irg is available. */
+
+       unsigned vtable_number;        /**< For a dynamically called method, the number assigned
+                                           in the virtual function table. */
+
+       ptr_access_kind *param_access; /**< the parameter access */
+       float *param_weight;           /**< The weight of method's parameters. Parameters
+                                           with a high weight are good for procedure cloning. */
+       ir_img_section section;        /**< The code section where this method should be placed */
 } method_ent_attr;
 
 
 /** The type of an entity. */
 struct ir_entity {
-  firm_kind kind;       /**< The dynamic type tag for entity. */
-  ident *name;          /**< The name of this entity. */
-  ident *ld_name;       /**< Unique name of this entity, i.e., the mangled
-                             name.  If the field is read before written a default
-                             mangling is applies.  The name of the owner is prepended
-                             to the name of the entity, separated by a underscore.
-                             E.g.,  for a class `A' with field `a' this
-                             is the ident for `A_a'. */
-  ir_type *type;        /**< The type of this entity, e.g., a method type, a
-                             basic type of the language or a class itself. */
-  ir_type *owner;                /**< The compound type (e.g. class type) this entity belongs to. */
-  ir_allocation allocation:3;    /**< Distinguishes static and dynamically allocated
-                                    entities and some further cases. */
-  ir_visibility visibility:3;    /**< Specifies visibility to external program
-                                      fragments. */
-  ir_variability variability:3;  /**< Specifies variability of entities content. */
-  ir_volatility volatility:2;    /**< Specifies volatility of entities content. */
-  ir_stickyness stickyness:2;    /**< Specifies whether this entity is sticky.  */
-  ir_peculiarity peculiarity:3;  /**< The peculiarity of this entity. */
-  unsigned final:1;              /**< If set, this entity cannot be overridden. */
-  unsigned compiler_gen:1;       /**< If set, this entity was compiler generated. */
-  int offset;                    /**< Offset in bits for this entity.  Fixed when layout
-                                      of owner is determined. */
-  unsigned long visit;           /**< visited counter for walks of the type information. */
-  struct dbg_info *dbi;          /**< A pointer to information for debug support. */
-  void *link;                    /**< To store some intermediate information. */
-  ir_type *repr_class;           /**< If this entity represents a class info, the associated class. */
-
-  /* ------------- fields for entities owned by a class type ---------------*/
-
-  ir_entity **overwrites;     /**< A list of entities this entity overwrites. */
-  ir_entity **overwrittenby;  /**< A list of entities that overwrite this entity.  */
-
-  /* ------------- fields for atomic entities  --------------- */
-  ir_node *value;          /**< value if entity is not of variability uninitialized.
-                                Only for atomic entities. */
-  union {
-    /* ------------- fields for compound entities -------------- */
-    compound_ent_attr cmpd_attr;
-    /* ------------- fields for method entities ---------------- */
-    method_ent_attr   mtd_attr;
-  } attr; /**< type specific attributes */
-
-  /* ------------- fields for analyses ---------------*/
+       firm_kind kind;       /**< The dynamic type tag for entity. */
+       ident *name;          /**< The name of this entity. */
+       ident *ld_name;       /**< Unique name of this entity, i.e., the mangled
+                                  name.  If the field is read before written a default
+                                  mangling is applies.  The name of the owner is prepended
+                                  to the name of the entity, separated by a underscore.
+                                  E.g.,  for a class `A' with field `a' this
+                                  is the ident for `A_a'. */
+       ir_type *type;        /**< The type of this entity, e.g., a method type, a
+                                  basic type of the language or a class itself. */
+       ir_type *owner;       /**< The compound type (e.g. class type) this entity belongs to. */
+       ir_allocation allocation:3;    /**< Distinguishes static and dynamically allocated
+                                           entities and some further cases. */
+       ir_visibility visibility:3;    /**< Specifies visibility to external program
+                                           fragments. */
+       ir_variability variability:3;  /**< Specifies variability of entities content. */
+       ir_volatility volatility:2;    /**< Specifies volatility of entities content. */
+       ir_stickyness stickyness:2;    /**< Specifies whether this entity is sticky.  */
+       ir_peculiarity peculiarity:3;  /**< The peculiarity of this entity. */
+       unsigned final:1;              /**< If set, this entity cannot be overridden. */
+       unsigned compiler_gen:1;       /**< If set, this entity was compiler generated. */
+       int offset;                    /**< Offset in bytes for this entity.  Fixed when layout
+                                           of owner is determined. */
+       unsigned char offset_bit_remainder;
+                                      /**< If the entity is a bit field, this is the offset of
+                                           the start of the bit field within the byte specified
+                                           by offset. */
+       unsigned long visit;           /**< visited counter for walks of the type information. */
+       struct dbg_info *dbi;          /**< A pointer to information for debug support. */
+       void *link;                    /**< To store some intermediate information. */
+       ir_type *repr_class;           /**< If this entity represents a class info, the associated class. */
+
+       /* ------------- fields for entities owned by a class type ---------------*/
+
+       ir_entity **overwrites;     /**< A list of entities this entity overwrites. */
+       ir_entity **overwrittenby;  /**< A list of entities that overwrite this entity.  */
+
+       /* ------------- fields for atomic entities  --------------- */
+       ir_node *value;          /**< value if entity is not of variability uninitialized.
+                                     Only for atomic entities. */
+       union {
+               /* ------------- fields for compound entities -------------- */
+               compound_ent_attr cmpd_attr;
+               /* ------------- fields for method entities ---------------- */
+               method_ent_attr   mtd_attr;
+       } attr; /**< type specific attributes */
+
+       /* ------------- fields for analyses ---------------*/
 
 #ifdef DEBUG_libfirm
-  long nr;             /**< A unique node number for each node to make output
-                            readable. */
+       long nr;             /**< A unique node number for each node to make output readable. */
 # endif /* DEBUG_libfirm */
 };
 
@@ -153,106 +157,106 @@ void firm_init_entity(void);
 /* ----------------------- inline functions ------------------------ */
 static INLINE int
 _is_entity(const void *thing) {
-  return get_kind(thing) == k_entity;
+       return get_kind(thing) == k_entity;
 }
 
 static INLINE const char *
 _get_entity_name(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return get_id_str(get_entity_ident(ent));
+       assert(ent && ent->kind == k_entity);
+       return get_id_str(get_entity_ident(ent));
 }
 
 static INLINE ident *
 _get_entity_ident(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->name;
+       assert(ent && ent->kind == k_entity);
+       return ent->name;
 }
 
 static INLINE void
 _set_entity_ident(ir_entity *ent, ident *id) {
-  assert(ent && ent->kind == k_entity);
-  ent->name = id;
+       assert(ent && ent->kind == k_entity);
+       ent->name = id;
 }
 
 static INLINE ir_type *
 _get_entity_owner(ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->owner = skip_tid(ent->owner);
+       assert(ent && ent->kind == k_entity);
+       return ent->owner = skip_tid(ent->owner);
 }
 
 static INLINE ident *
 _get_entity_ld_ident(ir_entity *ent)
 {
-  assert(ent && ent->kind == k_entity);
-  if (ent->ld_name == NULL)
-    ent->ld_name = mangle_entity(ent);
-  return ent->ld_name;
+       assert(ent && ent->kind == k_entity);
+       if (ent->ld_name == NULL)
+               ent->ld_name = mangle_entity(ent);
+       return ent->ld_name;
 }
 
 static INLINE void
 _set_entity_ld_ident(ir_entity *ent, ident *ld_ident) {
-  assert(ent && ent->kind == k_entity);
-  ent->ld_name = ld_ident;
+       assert(ent && ent->kind == k_entity);
+       ent->ld_name = ld_ident;
 }
 
 static INLINE const char *
 _get_entity_ld_name(ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return get_id_str(get_entity_ld_ident(ent));
+       assert(ent && ent->kind == k_entity);
+       return get_id_str(get_entity_ld_ident(ent));
 }
 
 static INLINE ir_type *
 _get_entity_type(ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->type = skip_tid(ent->type);
+       assert(ent && ent->kind == k_entity);
+       return ent->type = skip_tid(ent->type);
 }
 
 static INLINE void
 _set_entity_type(ir_entity *ent, ir_type *type) {
-  assert(ent && ent->kind == k_entity);
-  ent->type = type;
+       assert(ent && ent->kind == k_entity);
+       ent->type = type;
 }
 
 static INLINE ir_allocation
 _get_entity_allocation(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->allocation;
+       assert(ent && ent->kind == k_entity);
+       return ent->allocation;
 }
 
 static INLINE void
 _set_entity_allocation(ir_entity *ent, ir_allocation al) {
-  assert(ent && ent->kind == k_entity);
-  ent->allocation = al;
+       assert(ent && ent->kind == k_entity);
+       ent->allocation = al;
 }
 
 static INLINE ir_visibility
 _get_entity_visibility(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->visibility;
+       assert(ent && ent->kind == k_entity);
+       return ent->visibility;
 }
 
 static INLINE ir_variability
 _get_entity_variability(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->variability;
+       assert(ent && ent->kind == k_entity);
+       return ent->variability;
 }
 
 static INLINE ir_volatility
 _get_entity_volatility(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->volatility;
+       assert(ent && ent->kind == k_entity);
+       return ent->volatility;
 }
 
 static INLINE void
 _set_entity_volatility(ir_entity *ent, ir_volatility vol) {
-  assert(ent && ent->kind == k_entity);
-  ent->volatility = vol;
+       assert(ent && ent->kind == k_entity);
+       ent->volatility = vol;
 }
 
 static INLINE ir_peculiarity
 _get_entity_peculiarity(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->peculiarity;
+       assert(ent && ent->kind == k_entity);
+       return ent->peculiarity;
 }
 
 /**
@@ -264,116 +268,115 @@ _get_entity_peculiarity(const ir_entity *ent) {
  */
 static INLINE void
 _set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec) {
-  assert(ent && ent->kind == k_entity);
-  /* @@@ why peculiarity only for methods? */
-  //assert(is_Method_type(ent->type));
+       assert(ent && ent->kind == k_entity);
+       /* @@@ why peculiarity only for methods? */
+       //assert(is_Method_type(ent->type));
 
-  ent->peculiarity = pec;
+       ent->peculiarity = pec;
 }
 
 static INLINE ir_stickyness
 _get_entity_stickyness(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->stickyness;
+       assert(ent && ent->kind == k_entity);
+       return ent->stickyness;
 }
 
 static INLINE void
 _set_entity_stickyness(ir_entity *ent, ir_stickyness stickyness) {
-  assert(ent && ent->kind == k_entity);
-  ent->stickyness = stickyness;
+       assert(ent && ent->kind == k_entity);
+       ent->stickyness = stickyness;
 }
 
 static INLINE int
 _get_entity_final(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return (int)ent->final;
+       assert(ent && ent->kind == k_entity);
+       return (int)ent->final;
 }
 
 static INLINE void
 _set_entity_final(ir_entity *ent, int final) {
-  assert(ent && ent->kind == k_entity);
-  ent->final = final ? 1 : 0;
+       assert(ent && ent->kind == k_entity);
+       ent->final = final ? 1 : 0;
 }
 
 static INLINE int
-_get_entity_offset_bits(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->offset;
+_get_entity_offset(const ir_entity *ent) {
+       assert(ent && ent->kind == k_entity);
+       return ent->offset;
 }
 
-static INLINE int
-_get_entity_offset_bytes(const ir_entity *ent) {
-  int bits = _get_entity_offset_bits(ent);
-
-  if (bits & 7) return -1;
-  return bits >> 3;
+static INLINE void
+_set_entity_offset(ir_entity *ent, int offset) {
+       assert(ent && ent->kind == k_entity);
+       ent->offset = offset;
 }
 
-static INLINE void
-_set_entity_offset_bits(ir_entity *ent, int offset) {
-  assert(ent && ent->kind == k_entity);
-  ent->offset = offset;
+static INLINE unsigned char
+_get_entity_offset_bits_remainder(const ir_entity *ent) {
+       assert(ent && ent->kind == k_entity);
+       return ent->offset_bit_remainder;
 }
 
 static INLINE void
-_set_entity_offset_bytes(ir_entity *ent, int offset) {
-  _set_entity_offset_bits(ent, offset * 8);
+_set_entity_offset_bits_remainder(ir_entity *ent, unsigned char offset) {
+       assert(ent && ent->kind == k_entity);
+       ent->offset_bit_remainder = offset;
 }
 
 static INLINE void *
 _get_entity_link(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->link;
+       assert(ent && ent->kind == k_entity);
+       return ent->link;
 }
 
 static INLINE void
 _set_entity_link(ir_entity *ent, void *l) {
-  assert(ent && ent->kind == k_entity);
-  ent->link = l;
+       assert(ent && ent->kind == k_entity);
+       ent->link = l;
 }
 
 static INLINE ir_graph *
 _get_entity_irg(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  assert(ent == unknown_entity || is_Method_type(ent->type));
-  if (!get_visit_pseudo_irgs() && ent->attr.mtd_attr.irg
-      && is_pseudo_ir_graph(ent->attr.mtd_attr.irg))
-    return NULL;
-  return ent->attr.mtd_attr.irg;
+       assert(ent && ent->kind == k_entity);
+       assert(ent == unknown_entity || is_Method_type(ent->type));
+       if (!get_visit_pseudo_irgs() && ent->attr.mtd_attr.irg
+               && is_pseudo_ir_graph(ent->attr.mtd_attr.irg))
+               return NULL;
+       return ent->attr.mtd_attr.irg;
 }
 
 static INLINE unsigned long
 _get_entity_visited(ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->visit;
+       assert(ent && ent->kind == k_entity);
+       return ent->visit;
 }
 
 static INLINE void
 _set_entity_visited(ir_entity *ent, unsigned long num) {
-  assert(ent && ent->kind == k_entity);
-  ent->visit = num;
+       assert(ent && ent->kind == k_entity);
+       ent->visit = num;
 }
 
 static INLINE void
 _mark_entity_visited(ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  ent->visit = firm_type_visited;
+       assert(ent && ent->kind == k_entity);
+       ent->visit = firm_type_visited;
 }
 
 static INLINE int
 _entity_visited(ir_entity *ent) {
-  return _get_entity_visited(ent) >= firm_type_visited;
+       return _get_entity_visited(ent) >= firm_type_visited;
 }
 
 static INLINE int
 _entity_not_visited(ir_entity *ent) {
-  return _get_entity_visited(ent) < firm_type_visited;
+       return _get_entity_visited(ent) < firm_type_visited;
 }
 
 static INLINE ir_type *
 _get_entity_repr_class(const ir_entity *ent) {
-  assert(ent && ent->kind == k_entity);
-  return ent->repr_class;
+       assert(ent && ent->kind == k_entity);
+       return ent->repr_class;
 }
 
 #define is_entity(thing)                         _is_entity(thing)
@@ -398,10 +401,10 @@ _get_entity_repr_class(const ir_entity *ent) {
 #define set_entity_stickyness(ent, stickyness)   _set_entity_stickyness(ent, stickyness)
 #define get_entity_final(ent)                    _get_entity_final(ent)
 #define set_entity_final(ent, final)             _set_entity_final(ent, final)
-#define get_entity_offset_bits(ent)              _get_entity_offset_bits(ent)
-#define get_entity_offset_bytes(ent)             _get_entity_offset_bytes(ent)
-#define set_entity_offset_bits(ent, offset)      _set_entity_offset_bits(ent, offset)
-#define set_entity_offset_bytes(ent, offset)     _set_entity_offset_bytes(ent, offset)
+#define get_entity_offset(ent)                   _get_entity_offset(ent)
+#define set_entity_offset(ent, offset)           _set_entity_offset(ent, offset)
+#define get_entity_offset_bits_remainder(ent)    _get_entity_offset_bits_remainder(ent)
+#define set_entity_offset_bits_remainder(ent, o) _set_entity_offset_bits_remainder(ent, o)
 #define get_entity_link(ent)                     _get_entity_link(ent)
 #define set_entity_link(ent, l)                  _set_entity_link(ent, l)
 #define get_entity_irg(ent)                      _get_entity_irg(ent)