assert(get_type_size(tp) > -1);
if (tp != get_glob_type())
for (i = 0; i < get_class_n_members(tp); i++) {
+ if (get_entity_offset(get_class_member(tp, i)) <= -1)
+ { DDMT(tp); DDME(get_class_member(tp, i)); }
assert(get_entity_offset(get_class_member(tp, i)) > -1);
assert(is_method_type(get_entity_type(get_class_member(tp, i))) ||
(get_entity_allocation(get_class_member(tp, i)) == automatic_allocated));
N_param is the number of parameters, n_res the number of results. */
INLINE type *new_type_method (ident *name, int n_param, int n_res) {
type *res;
- res = new_type(type_method, mode_P, name);
+ res = new_type(type_method, mode_P_mach, name);
res->state = layout_fixed;
- assert((get_mode_size_bytes(mode_P) != -1) && "unorthodox modes not implemented");
- res->size = get_mode_size_bytes(mode_P);
+ assert((get_mode_size_bytes(mode_P_mach) != -1) && "unorthodox modes not implemented");
+ res->size = get_mode_size_bytes(mode_P_mach);
res->attr.ma.n_params = n_param;
res->attr.ma.param_type = (type **) xmalloc (sizeof (type *) * n_param);
res->attr.ma.value_params = NULL;
return res;
}
+
type *new_d_type_method (ident *name, int n_param, int n_res, dbg_info* db) {
type *res = new_type_method (name, n_param, n_res);
set_type_dbg_info(res, db);
return res;
}
+
INLINE void free_method_attrs(type *method) {
assert(method && (method->type_op == type_method));
free(method->attr.ma.param_type);
free(method->attr.ma.res_type);
}
+
/* manipulate private fields of method. */
int get_method_n_params (type *method) {
assert(method && (method->type_op == type_method));
type *element_type) {
type *res;
int i;
+ ir_graph *rem = current_ir_graph;
assert(!is_method_type(element_type));
+
res = new_type(type_array, NULL, name);
res->attr.aa.n_dimensions = n_dimensions;
res->attr.aa.lower_bound = (ir_node **) xmalloc (sizeof (ir_node *) * n_dimensions);
res->attr.aa.upper_bound = (ir_node **) xmalloc (sizeof (ir_node *) * n_dimensions);
res->attr.aa.order = (int *) xmalloc (sizeof (int) * n_dimensions);
+ current_ir_graph = get_const_code_irg();
for (i = 0; i < n_dimensions; i++) {
- res->attr.aa.lower_bound[i] = NULL;
- res->attr.aa.upper_bound[i] = NULL;
+ res->attr.aa.lower_bound[i] = new_Unknown();
+ res->attr.aa.upper_bound[i] = new_Unknown();
res->attr.aa.order[i] = i;
}
+ current_ir_graph = rem;
+
res->attr.aa.element_type = element_type;
new_entity(res, mangle_u(name, id_from_str("elem_ent", 8)), element_type);
set_array_bounds (type *array, int dimension, ir_node * lower_bound,
ir_node * upper_bound) {
assert(array && (array->type_op == type_array));
+ assert(lower_bound && "lower_bound node may not be NULL.");
+ assert(upper_bound && "upper_bound node may not be NULL.");
+ assert(dimension < array->attr.aa.n_dimensions && dimension >= 0);
array->attr.aa.lower_bound[dimension] = lower_bound;
array->attr.aa.upper_bound[dimension] = upper_bound;
}
INLINE void
set_array_lower_bound (type *array, int dimension, ir_node * lower_bound) {
assert(array && (array->type_op == type_array));
+ assert(lower_bound && "lower_bound node may not be NULL.");
array->attr.aa.lower_bound[dimension] = lower_bound;
}
void set_array_lower_bound_int (type *array, int dimension, int lower_bound) {
INLINE void
set_array_upper_bound (type *array, int dimension, ir_node * upper_bound) {
assert(array && (array->type_op == type_array));
+ assert(upper_bound && "upper_bound node may not be NULL.");
array->attr.aa.upper_bound[dimension] = upper_bound;
}
void set_array_upper_bound_int (type *array, int dimension, int upper_bound) {
new_Const(mode_Iu, new_tarval_from_long (upper_bound, mode_Iu)));
current_ir_graph = rem;
}
+int has_array_lower_bound (type *array, int dimension) {
+ assert(array && (array->type_op == type_array));
+ return (get_irn_op(array->attr.aa.lower_bound[dimension]) != op_Unknown);
+}
ir_node * get_array_lower_bound (type *array, int dimension) {
assert(array && (array->type_op == type_array));
return array->attr.aa.lower_bound[dimension];
}
+int has_array_upper_bound (type *array, int dimension) {
+ assert(array && (array->type_op == type_array));
+ return (get_irn_op(array->attr.aa.upper_bound[dimension]) != op_Unknown);
+}
ir_node * get_array_upper_bound (type *array, int dimension) {
assert(array && (array->type_op == type_array));
return array->attr.aa.upper_bound[dimension];
/* create a new type primitive */
INLINE type *new_type_primitive (ident *name, ir_mode *mode) {
type *res;
- /* @@@ assert( mode_is_data(mode) && (!mode == mode_P)); */
+ /* @@@ assert( mode_is_data(mode) && (!mode_is_reference(mode))); */
res = new_type(type_primitive, mode, name);
assert((get_mode_size_bytes(mode) != -1) && "unorthodox modes not implemented");
res->size = get_mode_size_bytes(mode);