/*
- * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved.
- *
* This file is part of libFirm.
- *
- * This file may be distributed and/or modified under the terms of the
- * GNU General Public License version 2 as published by the Free Software
- * Foundation and appearing in the file LICENSE.GPL included in the
- * packaging of this file.
- *
- * Licensees holding valid libFirm Professional Edition licenses may use
- * this file in accordance with the libFirm Commercial License.
- * Agreement provided with the Software.
- *
- * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
- * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE.
+ * Copyright (C) 2012 University of Karlsruhe.
*/
/**
#include "array_t.h"
#include "pmap.h"
#include "error.h"
+#include "util.h"
static pmap *pointer_types;
static pmap *lowered_mtps;
+static bool needs_lowering(const ir_type *type)
+{
+ return is_compound_type(type) || is_Array_type(type);
+}
+
/**
* Default implementation for finding a pointer type for a given element type.
* Simply create a new one.
continue;
type = get_entity_type(member);
- if (is_compound_type(type)) {
+ if (needs_lowering(type)) {
free_entity(member);
}
}
n_ress = get_method_n_ress(mtp);
for (i = 0; i < n_ress; ++i) {
ir_type *res_tp = get_method_res_type(mtp, i);
- if (is_compound_type(res_tp)) {
+ if (needs_lowering(res_tp)) {
must_be_lowered = true;
break;
}
if (!must_be_lowered && !(flags & LF_DONT_LOWER_ARGUMENTS)) {
for (i = 0; i < n_params; ++i) {
ir_type *param_type = get_method_param_type(mtp, i);
- if (is_compound_type(param_type)) {
+ if (needs_lowering(param_type)) {
must_be_lowered = true;
break;
}
for (i = 0; i < n_ress; ++i) {
ir_type *res_tp = get_method_res_type(mtp, i);
- if (is_compound_type(res_tp)) {
+ if (needs_lowering(res_tp)) {
/* this compound will be allocated on callers stack and its
address will be transmitted as a hidden parameter. */
ir_type *ptr_tp = get_pointer_type(res_tp);
/* copy over parameter types */
for (i = 0; i < n_params; ++i) {
ir_type *param_type = get_method_param_type(mtp, i);
- if (! (flags & LF_DONT_LOWER_ARGUMENTS)
- && is_compound_type(param_type)) {
+ if (! (flags & LF_DONT_LOWER_ARGUMENTS) && needs_lowering(param_type)) {
/* turn parameter into a pointer type */
param_type = new_type_pointer(param_type);
}
/* check for compound returns */
for (i = 0; i < n_ress; ++i) {
ir_type *type = get_method_res_type(ctp, i);
- if (is_compound_type(type)) {
+ if (needs_lowering(type)) {
/*
* This is a call with a compound return. As the result
* might be ignored, we must put it in the list.
}
for (i = 0; i < n_params; ++i) {
ir_type *type = get_method_param_type(ctp, i);
- if (is_compound_type(type)) {
+ if (needs_lowering(type)) {
cl_entry *entry = get_call_entry(n, env);
entry->has_compound_param = true;
break;
ir_node *call = get_Proj_pred(proj);
if (is_Call(call)) {
ir_type *ctp = get_Call_type(call);
- if (is_compound_type(get_method_res_type(ctp, get_Proj_proj(src)))) {
+ if (needs_lowering(get_method_res_type(ctp, get_Proj_proj(src)))) {
/* found a CopyB from compound Call result */
cl_entry *e = get_call_entry(call, env);
set_irn_link(n, e->copyb);
ir_entity *entity = get_Sel_entity(n);
ir_type *type = get_entity_type(entity);
- if (is_parameter_entity(entity) && is_compound_type(type)) {
+ if (is_parameter_entity(entity) && needs_lowering(type)) {
if (! (env->flags & LF_DONT_LOWER_ARGUMENTS)) {
/* note that num was already modified by fix_parameter_entities
* so no need to add env->arg_shift again */
/* get rid of the CopyB */
if (ir_throws_exception(p)) {
- turn_into_tuple(p, pn_CopyB_max+1);
- set_Tuple_pred(p, pn_CopyB_M, mem);
- set_Tuple_pred(p, pn_CopyB_X_regular, new_r_Jmp(block));
- set_Tuple_pred(p, pn_CopyB_X_except, new_r_Bad(irg, mode_X));
+ ir_node *const in[] = {
+ [pn_CopyB_M] = mem,
+ [pn_CopyB_X_regular] = new_r_Jmp(block),
+ [pn_CopyB_X_except] = new_r_Bad(irg, mode_X),
+ };
+ turn_into_tuple(p, ARRAY_SIZE(in), in);
} else {
- turn_into_tuple(p, pn_CopyB_M+1);
- set_Tuple_pred(p, pn_CopyB_M, mem);
+ ir_node *const in[] = { mem };
+ turn_into_tuple(p, ARRAY_SIZE(in), in);
}
++n_args;
}
for (j = i = 0; i < get_method_n_ress(ctp); ++i) {
ir_type *rtp = get_method_res_type(ctp, i);
- if (is_compound_type(rtp)) {
+ if (needs_lowering(rtp)) {
if (ins[j] == NULL)
ins[j] = get_dummy_sel(irg, get_nodes_block(entry->call), rtp);
++j;
for (i = 0; i < n_res; ++i) {
ir_type *type = get_method_res_type(ctp, i);
- if (is_compound_type(type))
+ if (needs_lowering(type))
++n_com;
}
ir_node *sel;
ir_node *copyb;
ir_entity *arg_entity;
- if (!is_compound_type(type))
+ if (!needs_lowering(type))
continue;
arg = get_Call_param(call, i);
size_t n_ret_com = 0;
for (i = 0; i < n_ress; ++i) {
ir_type *type = get_method_res_type(mtp, i);
- if (is_compound_type(type))
+ if (needs_lowering(type))
++n_ret_com;
}
for (i = 0; i < n_params; ++i) {
ir_type *type = get_method_param_type(mtp, i);
- if (is_compound_type(type))
+ if (needs_lowering(type))
++n_param_com;
}
/* much easier if we have only one return */
normalize_one_return(irg);
- /* This graph has a compound argument. Create a new type */
- lowered_mtp = lower_mtp(flags, mtp);
- set_entity_type(ent, lowered_mtp);
-
/* hidden arguments are added first */
env.arg_shift = n_ret_com;
} else {
env.arg_shift = 0;
lowered_mtp = NULL;
}
+
+ lowered_mtp = lower_mtp(flags, mtp);
+ set_entity_type(ent, lowered_mtp);
+
obstack_init(&env.obst);
env.cl_list = NULL;
env.flags = flags;
ir_node *pred = get_Return_res(ret, i);
tp = get_method_res_type(mtp, i);
- if (is_compound_type(tp)) {
+ if (needs_lowering(tp)) {
ir_node *arg = get_irg_args(irg);
arg = new_r_Proj(arg, mode_P_data, k);
++k;
projects / libfirm / blobdiff