nsz Git - libfirm/blob - ir/be/beabihelper.c

   1 /*
   2  * This file is part of libFirm.
   3  * Copyright (C) 2012 University of Karlsruhe.
   4  */
   5
   6 /**
   7  * @file
   8  * @brief       Helper functions for handling ABI constraints in the code
   9  *              selection phase.
  10  * @author      Matthias Braun
  11  */
  12 #include "config.h"
  13
  14 #include "beabihelper.h"
  15 #include "bearch.h"
  16 #include "beirg.h"
  17 #include "benode.h"
  18 #include "besched.h"
  19 #include "ircons.h"
  20 #include "iredges.h"
  21 #include "irgwalk.h"
  22 #include "irnodemap.h"
  23 #include "irtools.h"
  24 #include "heights.h"
  25
  26 /**
  27  * An entry in the register state map.
  28  */
  29 typedef struct reg_flag_t {
  30         const arch_register_t *reg;     /**< register at an input position.
  31                                              may be NULL in case of memory input */
  32         arch_register_req_type_t flags; /**< requirement flags for this register. */
  33 } reg_flag_t;
  34
  35 /**
  36  * A register state mapping keeps track of the symbol values (=firm nodes)
  37  * to registers. This is useful when constructing straight line code
  38  * like the function prolog or epilog in some architectures.
  39  */
  40 typedef struct register_state_mapping_t {
  41         ir_node   **value_map;     /**< mapping of state indices to values */
  42         size_t    **reg_index_map; /**< mapping of regclass,regnum to an index
  43                                         into the value_map */
  44         reg_flag_t *regs;          /**< registers (and memory values) that form a
  45                                         state */
  46 } register_state_mapping_t;
  47
  48 /**
  49  * The environment for all helper functions.
  50  */
  51 struct beabi_helper_env_t {
  52         ir_graph                 *irg;         /**< the graph we operate on */
  53         register_state_mapping_t  prolog;      /**< the register state map for the prolog */
  54         register_state_mapping_t  epilog;      /**< the register state map for the epilog */
  55 };
  56
  57 /**
  58  * Create a new empty register state map for the given
  59  * architecture.
  60  *
  61  * @param rsm       the register state map to be initialized
  62  * @param arch_env  the architecture environment
  63  *
  64  * After this call, the register map is initialized to empty.
  65  */
  66 static void prepare_rsm(register_state_mapping_t *rsm,
  67                         const arch_env_t *arch_env)
  68 {
  69         unsigned   n_reg_classes = arch_env->n_register_classes;
  70         unsigned   c;
  71         reg_flag_t memory = { NULL, arch_register_req_type_none };
  72
  73         rsm->regs = NEW_ARR_F(reg_flag_t, 0);
  74         /* memory input at 0 */
  75         ARR_APP1(reg_flag_t, rsm->regs, memory);
  76
  77         rsm->value_map     = NULL;
  78         rsm->reg_index_map = XMALLOCN(size_t*, n_reg_classes);
  79         for (c = 0; c < n_reg_classes; ++c) {
  80                 const arch_register_class_t *cls    = &arch_env->register_classes[c];
  81                 unsigned                     n_regs = arch_register_class_n_regs(cls);
  82                 unsigned                     r;
  83
  84                 rsm->reg_index_map[c] = XMALLOCN(size_t, n_regs);
  85                 for (r = 0; r < n_regs; ++r) {
  86                         rsm->reg_index_map[c][r] = (size_t)-1;
  87                 }
  88         }
  89 }
  90
  91 /**
  92  * Destroy a register state map for the given
  93  * architecture.
  94  *
  95  * @param rsm       the register state map to be destroyed
  96  * @param arch_env  the architecture environment
  97  *
  98  * After this call, the register map is initialized to empty.
  99  */
 100 static void free_rsm(register_state_mapping_t *rsm, const arch_env_t *arch_env)
 101 {
 102         unsigned n_reg_classes = arch_env->n_register_classes;
 103         unsigned c;
 104
 105         for (c = 0; c < n_reg_classes; ++c) {
 106                 free(rsm->reg_index_map[c]);
 107         }
 108
 109         free(rsm->reg_index_map);
 110         if (rsm->value_map != NULL)
 111                 DEL_ARR_F(rsm->value_map);
 112         DEL_ARR_F(rsm->regs);
 113
 114         rsm->regs          = NULL;
 115         rsm->reg_index_map = NULL;
 116         rsm->value_map     = NULL;
 117 }
 118
 119 /**
 120  * Remove all registers from a register state map.
 121  *
 122  * @param rsm       the register state map to be destroyed
 123  * @param arch_env  the architecture environment
 124  */
 125 static void rsm_clear_regs(register_state_mapping_t *rsm,
 126                            const arch_env_t *arch_env)
 127 {
 128         unsigned   n_reg_classes = arch_env->n_register_classes;
 129         unsigned   c;
 130         reg_flag_t memory = { NULL, arch_register_req_type_none };
 131
 132         for (c = 0; c < n_reg_classes; ++c) {
 133                 const arch_register_class_t *cls    = &arch_env->register_classes[c];
 134                 unsigned                     n_regs = arch_register_class_n_regs(cls);
 135                 unsigned                     r;
 136
 137                 for (r = 0; r < n_regs; ++r) {
 138                         rsm->reg_index_map[c][r] = (size_t)-1;
 139                 }
 140         }
 141         ARR_RESIZE(reg_flag_t, rsm->regs, 0);
 142         ARR_APP1(reg_flag_t, rsm->regs, memory);
 143
 144         if (rsm->value_map != NULL) {
 145                 DEL_ARR_F(rsm->value_map);
 146                 rsm->value_map = NULL;
 147         }
 148 }
 149
 150 /**
 151  * Add a register and its constraint flags to a register state map
 152  * and return its index inside the map.
 153  */
 154 static size_t rsm_add_reg(register_state_mapping_t *rsm,
 155                           const arch_register_t *reg,
 156                            arch_register_req_type_t flags)
 157 {
 158         size_t     input_idx = ARR_LEN(rsm->regs);
 159         int        cls_idx   = reg->reg_class->index;
 160         int        reg_idx   = reg->index;
 161         reg_flag_t regflag   = { reg, flags };
 162
 163         /* we must not have used get_value yet */
 164         assert(rsm->reg_index_map[cls_idx][reg_idx] == (size_t)-1);
 165         rsm->reg_index_map[cls_idx][reg_idx] = input_idx;
 166         ARR_APP1(reg_flag_t, rsm->regs, regflag);
 167
 168         if (rsm->value_map != NULL) {
 169                 ARR_APP1(ir_node*, rsm->value_map, NULL);
 170                 assert(ARR_LEN(rsm->value_map) == ARR_LEN(rsm->regs));
 171         }
 172         return input_idx;
 173 }
 174
 175 /**
 176  * Retrieve the ir_node stored at the given index in the register state map.
 177  */
 178 static ir_node *rsm_get_value(register_state_mapping_t *rsm, size_t index)
 179 {
 180         assert(index < ARR_LEN(rsm->value_map));
 181         return rsm->value_map[index];
 182 }
 183
 184 /**
 185  * Retrieve the ir_node occupying the given register in the register state map.
 186  */
 187 static ir_node *rsm_get_reg_value(register_state_mapping_t *rsm,
 188                                   const arch_register_t *reg)
 189 {
 190         int    cls_idx   = reg->reg_class->index;
 191         int    reg_idx   = reg->index;
 192         size_t input_idx = rsm->reg_index_map[cls_idx][reg_idx];
 193
 194         return rsm_get_value(rsm, input_idx);
 195 }
 196
 197 /**
 198  * Enter a ir_node at the given index in the register state map.
 199  */
 200 static void rsm_set_value(register_state_mapping_t *rsm, size_t index,
 201                           ir_node *value)
 202 {
 203         assert(index < ARR_LEN(rsm->value_map));
 204         rsm->value_map[index] = value;
 205 }
 206
 207 /**
 208  * Enter a ir_node at the given register in the register state map.
 209  */
 210 static void rsm_set_reg_value(register_state_mapping_t *rsm,
 211                               const arch_register_t *reg, ir_node *value)
 212 {
 213         int    cls_idx   = reg->reg_class->index;
 214         int    reg_idx   = reg->index;
 215         size_t input_idx = rsm->reg_index_map[cls_idx][reg_idx];
 216         rsm_set_value(rsm, input_idx, value);
 217 }
 218
 219
 220 beabi_helper_env_t *be_abihelper_prepare(ir_graph *irg)
 221 {
 222         const arch_env_t   *arch_env = be_get_irg_arch_env(irg);
 223         beabi_helper_env_t *env      = XMALLOCZ(beabi_helper_env_t);
 224
 225         env->irg = irg;
 226         prepare_rsm(&env->prolog, arch_env);
 227         prepare_rsm(&env->epilog, arch_env);
 228
 229         return env;
 230 }
 231
 232 void be_abihelper_finish(beabi_helper_env_t *env)
 233 {
 234         const arch_env_t *arch_env = be_get_irg_arch_env(env->irg);
 235
 236         free_rsm(&env->prolog, arch_env);
 237         if (env->epilog.reg_index_map != NULL) {
 238                 free_rsm(&env->epilog, arch_env);
 239         }
 240         xfree(env);
 241 }
 242
 243 void be_prolog_add_reg(beabi_helper_env_t *env, const arch_register_t *reg,
 244                        arch_register_req_type_t flags)
 245 {
 246         rsm_add_reg(&env->prolog, reg, flags);
 247 }
 248
 249 ir_node *be_prolog_create_start(beabi_helper_env_t *env, dbg_info *dbgi,
 250                                 ir_node *block)
 251 {
 252         int      n_start_outs = ARR_LEN(env->prolog.regs);
 253         ir_node *start        = be_new_Start(dbgi, block, n_start_outs);
 254         int      o;
 255
 256         assert(env->prolog.value_map == NULL);
 257         env->prolog.value_map = NEW_ARR_F(ir_node*, n_start_outs);
 258
 259         for (o = 0; o < n_start_outs; ++o) {
 260                 const reg_flag_t      *regflag = &env->prolog.regs[o];
 261                 const arch_register_t *reg     = regflag->reg;
 262                 ir_node               *proj;
 263                 if (reg == NULL) {
 264                         arch_set_irn_register_req_out(start, o, arch_no_register_req);
 265                         proj = new_r_Proj(start, mode_M, o);
 266                 } else {
 267                         be_set_constr_single_reg_out(start, o, regflag->reg,
 268                                                      regflag->flags);
 269                         arch_set_irn_register_out(start, o, regflag->reg);
 270                         proj = new_r_Proj(start, reg->reg_class->mode, o);
 271                 }
 272                 env->prolog.value_map[o] = proj;
 273         }
 274
 275         return start;
 276 }
 277
 278 ir_node *be_prolog_get_reg_value(beabi_helper_env_t *env,
 279                                  const arch_register_t *reg)
 280 {
 281         return rsm_get_reg_value(&env->prolog, reg);
 282 }
 283
 284 ir_node *be_prolog_get_memory(beabi_helper_env_t *env)
 285 {
 286         return rsm_get_value(&env->prolog, 0);
 287 }
 288
 289 void be_prolog_set_reg_value(beabi_helper_env_t *env,
 290                              const arch_register_t *reg, ir_node *value)
 291 {
 292         rsm_set_reg_value(&env->prolog, reg, value);
 293 }
 294
 295 void be_prolog_set_memory(beabi_helper_env_t *env, ir_node *value)
 296 {
 297         rsm_set_value(&env->prolog, 0, value);
 298 }
 299
 300
 301
 302 void be_epilog_begin(beabi_helper_env_t *env)
 303 {
 304         const arch_env_t *arch_env = be_get_irg_arch_env(env->irg);
 305         rsm_clear_regs(&env->epilog, arch_env);
 306         env->epilog.value_map    = NEW_ARR_F(ir_node*, 1);
 307         env->epilog.value_map[0] = NULL;
 308 }
 309
 310 void be_epilog_add_reg(beabi_helper_env_t *env, const arch_register_t *reg,
 311                        arch_register_req_type_t flags, ir_node *value)
 312 {
 313         size_t index = rsm_add_reg(&env->epilog, reg, flags);
 314         rsm_set_value(&env->epilog, index, value);
 315 }
 316
 317 void be_epilog_set_reg_value(beabi_helper_env_t *env,
 318                              const arch_register_t *reg, ir_node *value)
 319 {
 320         rsm_set_reg_value(&env->epilog, reg, value);
 321 }
 322
 323 void be_epilog_set_memory(beabi_helper_env_t *env, ir_node *value)
 324 {
 325         rsm_set_value(&env->epilog, 0, value);
 326 }
 327
 328 ir_node *be_epilog_get_reg_value(beabi_helper_env_t *env,
 329                                  const arch_register_t *reg)
 330 {
 331         return rsm_get_reg_value(&env->epilog, reg);
 332 }
 333
 334 ir_node *be_epilog_get_memory(beabi_helper_env_t *env)
 335 {
 336         return rsm_get_value(&env->epilog, 0);
 337 }
 338
 339 ir_node *be_epilog_create_return(beabi_helper_env_t *env, dbg_info *dbgi,
 340                                  ir_node *block)
 341 {
 342         size_t    n_return_in = ARR_LEN(env->epilog.regs);
 343         ir_node **in          = env->epilog.value_map;
 344         int       n_res       = 1; /* TODO */
 345         unsigned  pop         = 0; /* TODO */
 346         size_t    i;
 347
 348         assert(ARR_LEN(env->epilog.value_map) == n_return_in);
 349
 350         ir_node *const ret = be_new_Return(dbgi, block, n_res, pop, n_return_in, in);
 351         for (i = 0; i < n_return_in; ++i) {
 352                 const reg_flag_t      *regflag = &env->epilog.regs[i];
 353                 const arch_register_t *reg     = regflag->reg;
 354                 if (reg != NULL) {
 355                         be_set_constr_single_reg_in(ret, i, reg,
 356                                                     arch_register_req_type_none);
 357                 }
 358         }
 359
 360         rsm_clear_regs(&env->epilog, be_get_irg_arch_env(env->irg));
 361
 362         return ret;
 363 }
 364
 365 /**
 366  * Tests whether a node has a real user and is not just kept by the End or
 367  * Anchor node
 368  */
 369 static bool has_real_user(const ir_node *node)
 370 {
 371         foreach_out_edge(node, edge) {
 372                 ir_node *user = get_edge_src_irn(edge);
 373                 if (!is_End(user) && !is_Anchor(user))
 374                         return true;
 375         }
 376         return false;
 377 }
 378
 379 static ir_node *add_to_keep(ir_node *last_keep,
 380                             const arch_register_class_t *cls, ir_node *node)
 381 {
 382         if (last_keep != NULL) {
 383                 be_Keep_add_node(last_keep, cls, node);
 384         } else {
 385                 ir_node *in[1] = { node };
 386                 ir_node *block = get_nodes_block(node);
 387                 ir_node *schedpoint;
 388                 last_keep = be_new_Keep(block, 1, in);
 389
 390                 schedpoint = skip_Proj(node);
 391                 if (sched_is_scheduled(schedpoint)) {
 392                         sched_add_after(schedpoint, last_keep);
 393                 }
 394         }
 395         return last_keep;
 396 }
 397
 398 void be_add_missing_keeps_node(ir_node *node)
 399 {
 400         int       n_outs, i;
 401         ir_mode  *mode = get_irn_mode(node);
 402         ir_node  *last_keep;
 403
 404         if (mode != mode_T) {
 405                 if (!has_real_user(node)) {
 406                         const arch_register_req_t   *req = arch_get_irn_register_req(node);
 407                         const arch_register_class_t *cls = req->cls;
 408                         if (cls == NULL
 409                                         || (cls->flags & arch_register_class_flag_manual_ra)) {
 410                                 return;
 411                         }
 412
 413                         add_to_keep(NULL, cls, node);
 414                 }
 415                 return;
 416         }
 417
 418         n_outs = arch_get_irn_n_outs(node);
 419         if (n_outs <= 0)
 420                 return;
 421
 422         unsigned *const found_projs    = rbitset_alloca(n_outs);
 423         ir_node **const existing_projs = ALLOCANZ(ir_node*, n_outs);
 424         foreach_out_edge(node, edge) {
 425                 ir_node *succ = get_edge_src_irn(edge);
 426                 ir_mode *mode = get_irn_mode(succ);
 427                 int      pn;
 428
 429                 /* The node could be kept */
 430                 if (is_End(succ) || is_Anchor(succ))
 431                         continue;
 432                 if (mode == mode_M || mode == mode_X)
 433                         continue;
 434                 pn                 = get_Proj_proj(succ);
 435                 existing_projs[pn] = succ;
 436                 if (!has_real_user(succ))
 437                         continue;
 438
 439                 assert(pn < n_outs);
 440                 rbitset_set(found_projs, pn);
 441         }
 442
 443         /* are keeps missing? */
 444         last_keep = NULL;
 445         for (i = 0; i < n_outs; ++i) {
 446                 ir_node                     *value;
 447                 const arch_register_req_t   *req;
 448                 const arch_register_class_t *cls;
 449
 450                 if (rbitset_is_set(found_projs, i)) {
 451                         continue;
 452                 }
 453
 454                 req = arch_get_irn_register_req_out(node, i);
 455                 cls = req->cls;
 456                 if (cls == NULL || (cls->flags & arch_register_class_flag_manual_ra)) {
 457                         continue;
 458                 }
 459
 460                 value = existing_projs[i];
 461                 if (value == NULL)
 462                         value = new_r_Proj(node, arch_register_class_mode(cls), i);
 463                 last_keep = add_to_keep(last_keep, cls, value);
 464         }
 465 }
 466
 467 static void add_missing_keep_walker(ir_node *node, void *data)
 468 {
 469         (void)data;
 470         be_add_missing_keeps_node(node);
 471 }
 472
 473 void be_add_missing_keeps(ir_graph *irg)
 474 {
 475         irg_walk_graph(irg, add_missing_keep_walker, NULL, NULL);
 476 }
 477
 478
 479 /**
 480  * Link the node into its block list as a new head.
 481  */
 482 static void collect_node(ir_node *node)
 483 {
 484         ir_node *block = get_nodes_block(node);
 485         ir_node *old   = (ir_node*)get_irn_link(block);
 486
 487         set_irn_link(node, old);
 488         set_irn_link(block, node);
 489 }
 490
 491 /**
 492  * Post-walker: link all nodes that probably access the stack into lists of their block.
 493  */
 494 static void link_ops_in_block_walker(ir_node *node, void *data)
 495 {
 496         (void) data;
 497
 498         switch (get_irn_opcode(node)) {
 499         case iro_Return:
 500         case iro_Call:
 501                 collect_node(node);
 502                 break;
 503         case iro_Alloc:
 504                 /** all non-stack alloc nodes should be lowered before the backend */
 505                 assert(get_Alloc_where(node) == stack_alloc);
 506                 collect_node(node);
 507                 break;
 508         case iro_Free:
 509                 assert(get_Free_where(node) == stack_alloc);
 510                 collect_node(node);
 511                 break;
 512         case iro_Builtin:
 513                 if (get_Builtin_kind(node) == ir_bk_return_address) {
 514                         ir_node   *param = get_Builtin_param(node, 0);
 515                         ir_tarval *tv    = get_Const_tarval(param); /* must be Const */
 516                         long       value = get_tarval_long(tv);
 517                         if (value > 0) {
 518                                 /* not the return address of the current function:
 519                                  * we need the stack pointer for the frame climbing */
 520                                 collect_node(node);
 521                         }
 522                 }
 523                 break;
 524         default:
 525                 break;
 526         }
 527 }
 528
 529 static ir_heights_t *heights;
 530
 531 /**
 532  * Check if a node is somehow data dependent on another one.
 533  * both nodes must be in the same basic block.
 534  * @param n1 The first node.
 535  * @param n2 The second node.
 536  * @return 1, if n1 is data dependent (transitively) on n2, 0 if not.
 537  */
 538 static int dependent_on(const ir_node *n1, const ir_node *n2)
 539 {
 540         assert(get_nodes_block(n1) == get_nodes_block(n2));
 541
 542         return heights_reachable_in_block(heights, n1, n2);
 543 }
 544
 545 /**
 546  * Classical qsort() comparison function behavior:
 547  *
 548  * 0  if both elements are equal, no node depend on the other
 549  * +1 if first depends on second (first is greater)
 550  * -1 if second depends on first (second is greater)
 551 */
 552 static int cmp_call_dependency(const void *c1, const void *c2)
 553 {
 554         const ir_node *n1 = *(const ir_node **) c1;
 555         const ir_node *n2 = *(const ir_node **) c2;
 556         unsigned h1, h2;
 557
 558         if (dependent_on(n1, n2))
 559                 return 1;
 560
 561         if (dependent_on(n2, n1))
 562                 return -1;
 563
 564         /* The nodes have no depth order, but we need a total order because qsort()
 565          * is not stable.
 566          *
 567          * Additionally, we need to respect transitive dependencies. Consider a
 568          * Call a depending on Call b and an independent Call c.
 569          * We MUST NOT order c > a and b > c. */
 570         h1 = get_irn_height(heights, n1);
 571         h2 = get_irn_height(heights, n2);
 572         if (h1 < h2) return  1;
 573         if (h1 > h2) return -1;
 574         /* Same height, so use a random (but stable) order */
 575         return get_irn_idx(n2) - get_irn_idx(n1);
 576 }
 577
 578 /**
 579  * Block-walker: sorts dependencies and remember them into a phase
 580  */
 581 static void process_ops_in_block(ir_node *block, void *data)
 582 {
 583         ir_nodemap *map = (ir_nodemap*)data;
 584         unsigned    n;
 585         unsigned    n_nodes;
 586         ir_node    *node;
 587         ir_node   **nodes;
 588
 589         n_nodes = 0;
 590         for (node = (ir_node*)get_irn_link(block); node != NULL;
 591              node = (ir_node*)get_irn_link(node)) {
 592                 ++n_nodes;
 593         }
 594
 595         if (n_nodes == 0)
 596                 return;
 597
 598         nodes = XMALLOCN(ir_node*, n_nodes);
 599         n = 0;
 600         for (node = (ir_node*)get_irn_link(block); node != NULL;
 601              node = (ir_node*)get_irn_link(node)) {
 602                 nodes[n++] = node;
 603         }
 604         assert(n == n_nodes);
 605
 606         /* order nodes according to their data dependencies */
 607         qsort(nodes, n_nodes, sizeof(nodes[0]), cmp_call_dependency);
 608
 609         /* remember the calculated dependency into a phase */
 610         for (n = n_nodes-1; n > 0; --n) {
 611                 ir_node *node = nodes[n];
 612                 ir_node *pred = nodes[n-1];
 613
 614                 ir_nodemap_insert(map, node, pred);
 615         }
 616         xfree(nodes);
 617 }
 618
 619
 620
 621 struct be_stackorder_t {
 622         ir_nodemap stack_order; /**< a phase to handle stack dependencies. */
 623 };
 624
 625 be_stackorder_t *be_collect_stacknodes(ir_graph *irg)
 626 {
 627         be_stackorder_t *env = XMALLOCZ(be_stackorder_t);
 628
 629         ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
 630
 631         /* collect all potential^stack accessing nodes */
 632         irg_walk_graph(irg, firm_clear_link, link_ops_in_block_walker, NULL);
 633
 634         ir_nodemap_init(&env->stack_order, irg);
 635
 636         /* use heights to create a total order for those nodes: this order is stored
 637          * in the created phase */
 638         heights = heights_new(irg);
 639         irg_block_walk_graph(irg, NULL, process_ops_in_block, &env->stack_order);
 640         heights_free(heights);
 641
 642         ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
 643
 644         return env;
 645 }
 646
 647 ir_node *be_get_stack_pred(const be_stackorder_t *env, const ir_node *node)
 648 {
 649         return ir_nodemap_get(ir_node, &env->stack_order, node);
 650 }
 651
 652 void be_free_stackorder(be_stackorder_t *env)
 653 {
 654         ir_nodemap_destroy(&env->stack_order);
 655         free(env);
 656 }
 657
 658 static void create_stores_for_type(ir_graph *irg, ir_type *type)
 659 {
 660         size_t   n           = get_compound_n_members(type);
 661         ir_node *frame       = get_irg_frame(irg);
 662         ir_node *initial_mem = get_irg_initial_mem(irg);
 663         ir_node *mem         = initial_mem;
 664         ir_node *first_store = NULL;
 665         ir_node *start_block = get_irg_start_block(irg);
 666         ir_node *args        = get_irg_args(irg);
 667         size_t   i;
 668
 669         /* all parameter entities left in the frame type require stores.
 670          * (The ones passed on the stack have been moved to the arg type) */
 671         for (i = 0; i < n; ++i) {
 672                 ir_entity *entity = get_compound_member(type, i);
 673                 ir_node   *addr;
 674                 size_t     arg;
 675                 if (!is_parameter_entity(entity))
 676                         continue;
 677
 678                 arg = get_entity_parameter_number(entity);
 679                 if (arg == IR_VA_START_PARAMETER_NUMBER)
 680                         continue;
 681
 682                 addr = new_r_Sel(start_block, mem, frame, 0, NULL, entity);
 683                 if (entity->attr.parameter.doubleword_low_mode != NULL) {
 684                         ir_mode *mode      = entity->attr.parameter.doubleword_low_mode;
 685                         ir_node *val0      = new_r_Proj(args, mode, arg);
 686                         ir_node *val1      = new_r_Proj(args, mode, arg+1);
 687                         ir_node *store0    = new_r_Store(start_block, mem, addr, val0,
 688                                                          cons_none);
 689                         ir_node *mem0      = new_r_Proj(store0, mode_M, pn_Store_M);
 690                         size_t   offset    = get_mode_size_bits(mode)/8;
 691                         ir_mode *addr_mode = get_irn_mode(addr);
 692                         ir_node *cnst      = new_r_Const_long(irg, addr_mode, offset);
 693                         ir_node *next_addr = new_r_Add(start_block, addr, cnst, addr_mode);
 694                         ir_node *store1    = new_r_Store(start_block, mem0, next_addr, val1,
 695                                                          cons_none);
 696                         mem = new_r_Proj(store1, mode_M, pn_Store_M);
 697                         if (first_store == NULL)
 698                                 first_store = store0;
 699                 } else {
 700                         ir_type *tp    = get_entity_type(entity);
 701                         ir_mode *mode  = is_compound_type(tp) ? mode_P : get_type_mode(tp);
 702                         ir_node *val   = new_r_Proj(args, mode, arg);
 703                         ir_node *store = new_r_Store(start_block, mem, addr, val, cons_none);
 704                         mem = new_r_Proj(store, mode_M, pn_Store_M);
 705                         if (first_store == NULL)
 706                                 first_store = store;
 707                 }
 708         }
 709
 710         if (mem != initial_mem)
 711                 edges_reroute_except(initial_mem, mem, first_store);
 712 }
 713
 714 void be_add_parameter_entity_stores(ir_graph *irg)
 715 {
 716         ir_type           *frame_type   = get_irg_frame_type(irg);
 717         be_stack_layout_t *layout       = be_get_irg_stack_layout(irg);
 718         ir_type           *between_type = layout->between_type;
 719
 720         create_stores_for_type(irg, frame_type);
 721         if (between_type != NULL) {
 722                 create_stores_for_type(irg, between_type);
 723         }
 724 }