Skip to content
GitLab
Menu
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Sign in
Toggle navigation
Menu
Open sidebar
Zwinkau
libfirm
Commits
bc772df6
Commit
bc772df6
authored
Dec 13, 2006
by
Michael Beck
Browse files
- add an extra filed for the bit offset\n- renamed access functions\n- renamed entity -> ir_entity
[r8441]
parent
87f7c136
Changes
3
Hide whitespace changes
Inline
Side-by-side
ir/tr/entity.c
View file @
bc772df6
...
...
@@ -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
(
g
et_entity_offset
_bits
)(
const
ir_entity
*
ent
)
{
return
_g
et_entity_offset
_bits
(
en
t
);
void
(
s
et_entity_offset
)(
ir_entity
*
ent
,
int
offset
)
{
_s
et_entity_offset
(
ent
,
offse
t
);
}
void
(
s
et_entity_offset_b
ytes
)(
ir_entity
*
ent
,
int
offset
)
{
_s
et_entity_offset_b
ytes
(
ent
,
offse
t
);
unsigned
char
(
g
et_entity_offset_b
its_remainder
)(
const
ir_entity
*
ent
)
{
return
_g
et_entity_offset_b
its_remainder
(
en
t
);
}
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
...
...
ir/tr/entity.h
View file @
bc772df6
...
...
@@ -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.
*
...
...
ir/tr/entity_t.h
View file @
bc772df6
...
...
@@ -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
_
s
et_entity_offset_bits
(
ir_entity
*
ent
,
int
offset
)
{
assert
(
ent
&&
ent
->
kind
==
k_entity
);
ent
->
offset
=
offset
;
static
INLINE
unsigned
char
_
g
et_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
)
{