* @brief Procedure cloning.
* @author Beyhan Veliev, Michael Beck
* @version $Id$
- * @summary
+ * @brief
*
* The purpose is first to find and analyze functions, that are called
* with constant parameter(s).
#include "irtools.h"
#include "irgmod.h"
#include "array_t.h"
+#include "irpass_t.h"
/**
* This struct contains the information quadruple for a Call, which we need to
*
* @return zero if they are identically, non-zero else
*/
-static int entry_cmp(const void *elt, const void *key) {
+static int entry_cmp(const void *elt, const void *key)
+{
const entry_t *e1 = elt;
const entry_t *e2 = key;
*
* @param entry The element to be hashed.
*/
-static int hash_entry(const entry_t *entry) {
+static int hash_entry(const entry_t *entry)
+{
return HASH_PTR(entry->q.ent) ^ HASH_PTR(entry->q.tv) ^ (entry->q.pos * 9);
}
/**
* Free memory associated with a quadruplet.
*/
-static void kill_entry(entry_t *entry) {
+static void kill_entry(entry_t *entry)
+{
if (entry->q.calls) {
DEL_ARR_F(entry->q.calls);
entry->q.calls = NULL;
* @param callee The entity of the callee
* @param hmap The quadruple-set containing the calls with constant parameters
*/
-static void process_call(ir_node *call, ir_entity *callee, q_set *hmap) {
+static void process_call(ir_node *call, ir_entity *callee, q_set *hmap)
+{
ir_type *mtp;
entry_t *key, *entry;
ir_node *call_param;
if (! hmap->map)
hmap->map = new_pset(entry_cmp, 8);
- key = obstack_alloc(&hmap->obst, sizeof(*key));
+ key = OALLOC(&hmap->obst, entry_t);
key->q.ent = callee;
key->q.pos = i;
* @param call A ir_node to be checked.
* @param env The quadruple-set containing the calls with constant parameters
*/
-static void collect_irg_calls(ir_node *call, void *env) {
+static void collect_irg_calls(ir_node *call, void *env)
+{
q_set *hmap = env;
ir_node *call_ptr;
ir_entity *callee;
callee = get_Global_entity(call_ptr);
- /* we can only clone calls to existing entities */
- if (get_entity_visibility(callee) == visibility_external_allocated)
+ /* we don't know which function gets finally bound to a weak symbol */
+ if (get_entity_linkage(callee) & IR_LINKAGE_WEAK)
return;
- /* we cannot clone calls to weak functions */
- if (get_entity_additional_properties(callee) & mtp_property_weak)
+ /* we can only clone calls to existing entities */
+ if (get_entity_irg(callee) == NULL)
return;
process_call(call, callee, hmap);
* @param pos The "pos" from our quadruplet.
* @param nr A counter for the clones.
*/
-static ident *get_clone_ident(ident *id, int pos, unsigned nr) {
+static ident *get_clone_ident(ident *id, int pos, unsigned nr)
+{
char clone_postfix[32];
snprintf(clone_postfix, sizeof(clone_postfix), "_cl_%d_%u", pos, nr);
* @param irn A node from the original method graph.
* @param env The clone graph.
*/
-static void copy_nodes(ir_node *irn, void *env) {
+static void copy_nodes(ir_node *irn, void *env)
+{
ir_node *arg, *irg_args, *irn_copy;
int proj_nr;
ir_graph *clone_irg = env;
* The copied nodes are set as link of their original nodes. The links of
* "irn" predecessors are the predecessors of copied node.
*/
-static void set_preds(ir_node *irn, void *env) {
+static void set_preds(ir_node *irn, void *env)
+{
int i;
ir_node *irn_copy, *pred, *arg;
ir_graph *clone_irg = env;
* @param irg irg that must be cloned.
* @param pos The position of the argument.
*/
-static ir_node *get_irg_arg(ir_graph *irg, int pos) {
+static ir_node *get_irg_arg(ir_graph *irg, int pos)
+{
ir_node *irg_args = get_irg_args(irg), *arg = NULL;
int i;
* @param ent The entity of the method that must be cloned.
* @param q Our quadruplet.
*/
-static void create_clone_proc_irg(ir_entity *ent, quadruple_t *q) {
+static void create_clone_proc_irg(ir_entity *ent, quadruple_t *q)
+{
ir_graph *method_irg, *clone_irg;
ir_node *arg, *const_arg;
* @param ent The entity of the clone.
* @param nr A pointer to the counter of clones.
**/
-static void change_entity_type(quadruple_t *q, ir_entity *ent, unsigned *nr) {
+static void change_entity_type(quadruple_t *q, ir_entity *ent)
+{
ir_type *mtp, *new_mtp, *tp;
- ident *tp_name;
int i, j, n_params, n_ress;
mtp = get_entity_type(q->ent);
- tp_name = get_clone_ident(get_type_ident(mtp), q->pos, (*nr)++);
n_params = get_method_n_params(mtp);
n_ress = get_method_n_ress(mtp);
/* Create the new type for our clone. It must have one parameter
less then the original.*/
- new_mtp = new_type_method(tp_name, n_params - 1, n_ress);
+ new_mtp = new_type_method(n_params - 1, n_ress);
/* We must set the type of the methods parameters.*/
for (i = j = 0; i < n_params; ++i) {
*
* @param q Contains information for the method to clone.
*/
-static ir_entity *clone_method(quadruple_t *q) {
+static ir_entity *clone_method(quadruple_t *q)
+{
ir_entity *new_entity;
ident *clone_ident;
- ir_graph *rem;
symconst_symbol sym;
/* A counter for the clones.*/
static unsigned nr = 0;
new_entity = copy_entity_name(q->ent, clone_ident);
/* a cloned entity is always local */
- set_entity_visibility(new_entity, visibility_local);
+ set_entity_visibility(new_entity, ir_visibility_local);
/* set a ld name here: Should we mangle this ? */
set_entity_ld_ident(new_entity, get_entity_ident(new_entity));
/* set a new type here. */
- change_entity_type(q, new_entity, &nr);
+ change_entity_type(q, new_entity);
/* We need now a new ir_graph for our clone method. */
create_clone_proc_irg(new_entity, q);
/* We must set the atomic value of our "new_entity". */
sym.entity_p = new_entity;
- rem = current_ir_graph;
- current_ir_graph = get_const_code_irg();
- new_entity->value = new_SymConst(mode_P_code, sym, symconst_addr_ent);
- current_ir_graph = rem;
/* The "new_entity" don't have this information. */
new_entity->attr.mtd_attr.param_access = NULL;
* @param new_entity The entity of the cloned function.
* @param pos The position of the replaced parameter of this call.
**/
-static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos) {
+static ir_node *new_cl_Call(ir_node *call, ir_entity *new_entity, int pos)
+{
ir_node **in;
- ir_type *mtp;
int i, n_params, new_params = 0;
ir_node *callee;
symconst_symbol sym;
ir_node *bl = get_nodes_block(call);
sym.entity_p = new_entity;
- callee = new_r_SymConst(irg, bl, mode_P_code, sym, symconst_addr_ent);
+ callee = new_r_SymConst(irg, mode_P_code, sym, symconst_addr_ent);
- mtp = get_entity_type(new_entity);
n_params = get_Call_n_params(call);
NEW_ARR_A(ir_node *, in, n_params - 1);
in[new_params++] = get_Call_param(call, i);
}
/* Create and return the new Call. */
- return new_r_Call(irg, bl, get_Call_mem(call),
+ return new_r_Call(bl, get_Call_mem(call),
callee, n_params - 1, in, get_entity_type(new_entity));
}
* @param cloned_ent The entity of the new function that must be called
* from the new Call.
*/
-static void exchange_calls(quadruple_t *q, ir_entity *cloned_ent) {
+static void exchange_calls(quadruple_t *q, ir_entity *cloned_ent)
+{
int pos = q->pos;
ir_node *new_call, *call;
int i;
* We save one instruction in every caller and param_weight instructions
* in the callee.
*/
-static float calculate_weight(const entry_t *entry) {
+static float calculate_weight(const entry_t *entry)
+{
return ARR_LEN(entry->q.calls) *
(float)(get_method_param_weight(entry->q.ent, entry->q.pos) + 1);
}
* the next cloned entity may get invalid, so we have to check
* them and may even update the list of heavy uses.
*/
-static void reorder_weights(q_set *hmap, float threshold) {
+static void reorder_weights(q_set *hmap, float threshold)
+{
entry_t **adr, *p, *entry;
int i, len;
ir_entity *callee;
* call(..., Const, ...). If the weight is bigger than threshold,
* clone the entity and fix the calls.
*/
-void proc_cloning(float threshold) {
+void proc_cloning(float threshold)
+{
entry_t *entry = NULL, *p;
ir_graph *irg;
int i;
}
obstack_free(&hmap.obst, NULL);
}
+
+struct pass_t {
+ ir_prog_pass_t pass;
+ float threshold;
+};
+
+/**
+ * Wrapper to run proc_cloning() as an ir_prog pass.
+ */
+static int proc_cloning_wrapper(ir_prog *irp, void *context)
+{
+ struct pass_t *pass = context;
+
+ (void)irp;
+ proc_cloning(pass->threshold);
+ return 0;
+}
+
+/* create a ir_prog pass */
+ir_prog_pass_t *proc_cloning_pass(const char *name, float threshold)
+{
+ struct pass_t *pass = XMALLOCZ(struct pass_t);
+
+ pass->threshold = threshold;
+ return def_prog_pass_constructor(
+ &pass->pass, name ? name : "cloning", proc_cloning_wrapper);
+}
projects / libfirm / blobdiff