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

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief       Backend ABI implementation.
  23  * @author      Sebastian Hack, Michael Beck
  24  * @version     $Id$
  25  */
  26 #include "config.h"
  27
  28 #include "obst.h"
  29 #include "offset.h"
  30
  31 #include "irgopt.h"
  32
  33 #include "irgraph_t.h"
  34 #include "irnode_t.h"
  35 #include "ircons_t.h"
  36 #include "iredges_t.h"
  37 #include "irgmod.h"
  38 #include "irgwalk.h"
  39 #include "irprintf_t.h"
  40 #include "irgopt.h"
  41 #include "irbitset.h"
  42 #include "height.h"
  43 #include "pdeq.h"
  44 #include "irtools.h"
  45 #include "raw_bitset.h"
  46 #include "error.h"
  47
  48 #include "be.h"
  49 #include "beabi.h"
  50 #include "bearch_t.h"
  51 #include "benode_t.h"
  52 #include "belive_t.h"
  53 #include "besched_t.h"
  54 #include "beirg_t.h"
  55 #include "bessaconstr.h"
  56
  57 typedef struct _be_abi_call_arg_t {
  58         unsigned is_res   : 1;  /**< 1: the call argument is a return value. 0: it's a call parameter. */
  59         unsigned in_reg   : 1;  /**< 1: this argument is transmitted in registers. */
  60         unsigned on_stack : 1;  /**< 1: this argument is transmitted on the stack. */
  61
  62         int                    pos;
  63         const arch_register_t *reg;
  64         ir_entity             *stack_ent;
  65         ir_mode               *load_mode;
  66         unsigned               alignment;    /**< stack alignment */
  67         unsigned               space_before; /**< allocate space before */
  68         unsigned               space_after;  /**< allocate space after */
  69 } be_abi_call_arg_t;
  70
  71 struct _be_abi_call_t {
  72         be_abi_call_flags_t          flags;  /**< Flags describing the ABI behavior on calls */
  73         int                          pop;    /**< number of bytes the stack frame is shrinked by the callee on return. */
  74         const be_abi_callbacks_t    *cb;
  75         ir_type                     *between_type;
  76         set                         *params;
  77         const arch_register_class_t *cls_addr; /**< register class of the call address */
  78 };
  79
  80 /**
  81  * The ABI information for the current birg.
  82  */
  83 struct _be_abi_irg_t {
  84         struct obstack       obst;
  85         be_irg_t             *birg;         /**< The back end IRG. */
  86         const arch_env_t     *arch_env;
  87         survive_dce_t        *dce_survivor;
  88
  89         be_abi_call_t        *call;         /**< The ABI call information. */
  90         ir_type              *method_type;  /**< The type of the method of the IRG. */
  91
  92         ir_node              *init_sp;      /**< The node representing the stack pointer
  93                                                  at the start of the function. */
  94
  95         ir_node              *reg_params;   /**< The reg params node. */
  96         pmap                 *regs;         /**< A map of all callee-save and ignore regs to
  97                                                  their Projs to the RegParams node. */
  98
  99         int                  start_block_bias; /**< The stack bias at the end of the start block. */
 100
 101         void                 *cb;           /**< ABI Callback self pointer. */
 102
 103         pmap                 *keep_map;     /**< mapping blocks to keep nodes. */
 104         pset                 *ignore_regs;  /**< Additional registers which shall be ignored. */
 105
 106         ir_node              **calls;       /**< flexible array containing all be_Call nodes */
 107
 108         arch_register_req_t  sp_req;
 109         arch_register_req_t  sp_cls_req;
 110
 111         be_stack_layout_t    frame;         /**< The stack frame model. */
 112
 113         DEBUG_ONLY(firm_dbg_module_t    *dbg;)  /**< The debugging module. */
 114 };
 115
 116 static heights_t *ir_heights;
 117
 118 /** Flag: if set, try to omit the frame pointer in all routines. */
 119 static int be_omit_fp = 1;
 120
 121 /** Flag: if set, try to omit the frame pointer in leaf routines only. */
 122 static int be_omit_leaf_fp = 1;
 123
 124 /*
 125      _    ____ ___    ____      _ _ _                _
 126     / \  | __ )_ _|  / ___|__ _| | | |__   __ _  ___| | _____
 127    / _ \ |  _ \| |  | |   / _` | | | '_ \ / _` |/ __| |/ / __|
 128   / ___ \| |_) | |  | |__| (_| | | | |_) | (_| | (__|   <\__ \
 129  /_/   \_\____/___|  \____\__,_|_|_|_.__/ \__,_|\___|_|\_\___/
 130
 131   These callbacks are used by the backend to set the parameters
 132   for a specific call type.
 133 */
 134
 135 /**
 136  * Set compare function: compares two ABI call object arguments.
 137  */
 138 static int cmp_call_arg(const void *a, const void *b, size_t n)
 139 {
 140         const be_abi_call_arg_t *p = a, *q = b;
 141         (void) n;
 142         return !(p->is_res == q->is_res && p->pos == q->pos);
 143 }
 144
 145 /**
 146  * Get  an ABI call object argument.
 147  *
 148  * @param call      the abi call
 149  * @param is_res    true for call results, false for call arguments
 150  * @param pos       position of the argument
 151  */
 152 static be_abi_call_arg_t *get_call_arg(be_abi_call_t *call, int is_res, int pos)
 153 {
 154         be_abi_call_arg_t arg;
 155         unsigned hash;
 156
 157         memset(&arg, 0, sizeof(arg));
 158         arg.is_res = is_res;
 159         arg.pos    = pos;
 160
 161         hash = is_res * 128 + pos;
 162
 163         return set_find(call->params, &arg, sizeof(arg), hash);
 164 }
 165
 166 /**
 167  * Set an ABI call object argument.
 168  *
 169  * @param call      the abi call
 170  * @param is_res    true for call results, false for call arguments
 171  * @param pos       position of the argument
 172  */
 173 static be_abi_call_arg_t *create_call_arg(be_abi_call_t *call, int is_res, int pos)
 174 {
 175         be_abi_call_arg_t arg;
 176         unsigned hash;
 177
 178         memset(&arg, 0, sizeof(arg));
 179         arg.is_res = is_res;
 180         arg.pos    = pos;
 181
 182         hash = is_res * 128 + pos;
 183
 184         return set_insert(call->params, &arg, sizeof(arg), hash);
 185 }
 186
 187 /* Set the flags for a call. */
 188 void be_abi_call_set_flags(be_abi_call_t *call, be_abi_call_flags_t flags, const be_abi_callbacks_t *cb)
 189 {
 190         call->flags = flags;
 191         call->cb    = cb;
 192 }
 193
 194 /* Sets the number of bytes the stackframe is shrinked by the callee on return */
 195 void be_abi_call_set_pop(be_abi_call_t *call, int pop)
 196 {
 197         assert(pop >= 0);
 198         call->pop = pop;
 199 }
 200
 201 /* Set register class for call address */
 202 void be_abi_call_set_call_address_reg_class(be_abi_call_t *call, const arch_register_class_t *cls)
 203 {
 204         call->cls_addr = cls;
 205 }
 206
 207
 208 void be_abi_call_param_stack(be_abi_call_t *call, int arg_pos, ir_mode *load_mode, unsigned alignment, unsigned space_before, unsigned space_after)
 209 {
 210         be_abi_call_arg_t *arg = create_call_arg(call, 0, arg_pos);
 211         arg->on_stack     = 1;
 212         arg->load_mode    = load_mode;
 213         arg->alignment    = alignment;
 214         arg->space_before = space_before;
 215         arg->space_after  = space_after;
 216         assert(alignment > 0 && "Alignment must be greater than 0");
 217 }
 218
 219 void be_abi_call_param_reg(be_abi_call_t *call, int arg_pos, const arch_register_t *reg)
 220 {
 221         be_abi_call_arg_t *arg = create_call_arg(call, 0, arg_pos);
 222         arg->in_reg = 1;
 223         arg->reg = reg;
 224 }
 225
 226 void be_abi_call_res_reg(be_abi_call_t *call, int arg_pos, const arch_register_t *reg)
 227 {
 228         be_abi_call_arg_t *arg = create_call_arg(call, 1, arg_pos);
 229         arg->in_reg = 1;
 230         arg->reg = reg;
 231 }
 232
 233 /* Get the flags of a ABI call object. */
 234 be_abi_call_flags_t be_abi_call_get_flags(const be_abi_call_t *call)
 235 {
 236         return call->flags;
 237 }
 238
 239 /**
 240  * Constructor for a new ABI call object.
 241  *
 242  * @param cls_addr  register class of the call address
 243  *
 244  * @return the new ABI call object
 245  */
 246 static be_abi_call_t *be_abi_call_new(const arch_register_class_t *cls_addr)
 247 {
 248         be_abi_call_t *call = XMALLOCZ(be_abi_call_t);
 249
 250         call->flags.val  = 0;
 251         call->params     = new_set(cmp_call_arg, 16);
 252         call->cb         = NULL;
 253         call->cls_addr   = cls_addr;
 254
 255         call->flags.bits.try_omit_fp = be_omit_fp | be_omit_leaf_fp;
 256
 257         return call;
 258 }
 259
 260 /**
 261  * Destructor for an ABI call object.
 262  */
 263 static void be_abi_call_free(be_abi_call_t *call)
 264 {
 265         del_set(call->params);
 266         free(call);
 267 }
 268
 269 /*
 270   _____                           _   _                 _ _ _
 271  |  ___| __ __ _ _ __ ___   ___  | | | | __ _ _ __   __| | (_)_ __   __ _
 272  | |_ | '__/ _` | '_ ` _ \ / _ \ | |_| |/ _` | '_ \ / _` | | | '_ \ / _` |
 273  |  _|| | | (_| | | | | | |  __/ |  _  | (_| | | | | (_| | | | | | | (_| |
 274  |_|  |_|  \__,_|_| |_| |_|\___| |_| |_|\__,_|_| |_|\__,_|_|_|_| |_|\__, |
 275                                                                     |___/
 276
 277   Handling of the stack frame. It is composed of three types:
 278   1) The type of the arguments which are pushed on the stack.
 279   2) The "between type" which consists of stuff the call of the
 280      function pushes on the stack (like the return address and
 281          the old base pointer for ia32).
 282   3) The Firm frame type which consists of all local variables
 283      and the spills.
 284 */
 285
 286 static int get_stack_entity_offset(be_stack_layout_t *frame, ir_entity *ent,
 287                                    int bias)
 288 {
 289         ir_type *t = get_entity_owner(ent);
 290         int ofs    = get_entity_offset(ent);
 291
 292         int index;
 293
 294         /* Find the type the entity is contained in. */
 295         for (index = 0; index < N_FRAME_TYPES; ++index) {
 296                 if (frame->order[index] == t)
 297                         break;
 298                 /* Add the size of all the types below the one of the entity to the entity's offset */
 299                 ofs += get_type_size_bytes(frame->order[index]);
 300         }
 301
 302         /* correct the offset by the initial position of the frame pointer */
 303         ofs -= frame->initial_offset;
 304
 305         /* correct the offset with the current bias. */
 306         ofs += bias;
 307
 308         return ofs;
 309 }
 310
 311 /**
 312  * Retrieve the entity with given offset from a frame type.
 313  */
 314 static ir_entity *search_ent_with_offset(ir_type *t, int offset)
 315 {
 316         int i, n;
 317
 318         for (i = 0, n = get_compound_n_members(t); i < n; ++i) {
 319                 ir_entity *ent = get_compound_member(t, i);
 320                 if (get_entity_offset(ent) == offset)
 321                         return ent;
 322         }
 323
 324         return NULL;
 325 }
 326
 327 static int stack_frame_compute_initial_offset(be_stack_layout_t *frame)
 328 {
 329         ir_type  *base = frame->stack_dir < 0 ? frame->between_type : frame->frame_type;
 330         ir_entity *ent = search_ent_with_offset(base, 0);
 331
 332         frame->initial_offset = ent ? get_stack_entity_offset(frame, ent, 0) : 0;
 333
 334         return frame->initial_offset;
 335 }
 336
 337 /**
 338  * Initializes the frame layout from parts
 339  *
 340  * @param frame     the stack layout that will be initialized
 341  * @param args      the stack argument layout type
 342  * @param between   the between layout type
 343  * @param locals    the method frame type
 344  * @param stack_dir the stack direction
 345  * @param param_map an array mapping method argument positions to the stack argument type
 346  *
 347  * @return the initialized stack layout
 348  */
 349 static be_stack_layout_t *stack_frame_init(be_stack_layout_t *frame, ir_type *args,
 350                                            ir_type *between, ir_type *locals, int stack_dir,
 351                                            ir_entity *param_map[])
 352 {
 353         frame->arg_type       = args;
 354         frame->between_type   = between;
 355         frame->frame_type     = locals;
 356         frame->initial_offset = 0;
 357         frame->initial_bias   = 0;
 358         frame->stack_dir      = stack_dir;
 359         frame->order[1]       = between;
 360         frame->param_map      = param_map;
 361
 362         if (stack_dir > 0) {
 363                 frame->order[0] = args;
 364                 frame->order[2] = locals;
 365         }
 366         else {
 367                 frame->order[0] = locals;
 368                 frame->order[2] = args;
 369         }
 370         return frame;
 371 }
 372
 373 #if 0
 374 /** Dumps the stack layout to file. */
 375 static void stack_layout_dump(FILE *file, be_stack_layout_t *frame)
 376 {
 377         int i, j, n;
 378
 379         ir_fprintf(file, "initial offset: %d\n", frame->initial_offset);
 380         for (j = 0; j < N_FRAME_TYPES; ++j) {
 381                 ir_type *t = frame->order[j];
 382
 383                 ir_fprintf(file, "type %d: %F size: %d\n", j, t, get_type_size_bytes(t));
 384                 for (i = 0, n = get_compound_n_members(t); i < n; ++i) {
 385                         ir_entity *ent = get_compound_member(t, i);
 386                         ir_fprintf(file, "\t%F int ofs: %d glob ofs: %d\n", ent, get_entity_offset_bytes(ent), get_stack_entity_offset(frame, ent, 0));
 387                 }
 388         }
 389 }
 390 #endif
 391
 392 /**
 393  * Returns non-zero if the call argument at given position
 394  * is transfered on the stack.
 395  */
 396 static inline int is_on_stack(be_abi_call_t *call, int pos)
 397 {
 398         be_abi_call_arg_t *arg = get_call_arg(call, 0, pos);
 399         return arg && !arg->in_reg;
 400 }
 401
 402 /*
 403    ____      _ _
 404   / ___|__ _| | |___
 405  | |   / _` | | / __|
 406  | |__| (_| | | \__ \
 407   \____\__,_|_|_|___/
 408
 409   Adjustment of the calls inside a graph.
 410
 411 */
 412
 413 /**
 414  * Transform a call node into a be_Call node.
 415  *
 416  * @param env The ABI environment for the current irg.
 417  * @param irn The call node.
 418  * @param curr_sp The stack pointer node to use.
 419  * @return The stack pointer after the call.
 420  */
 421 static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 422 {
 423         ir_graph *irg              = env->birg->irg;
 424         const arch_env_t *arch_env = env->birg->main_env->arch_env;
 425         ir_type *call_tp           = get_Call_type(irn);
 426         ir_node *call_ptr          = get_Call_ptr(irn);
 427         int n_params               = get_method_n_params(call_tp);
 428         ir_node *curr_mem          = get_Call_mem(irn);
 429         ir_node *bl                = get_nodes_block(irn);
 430         pset *results              = pset_new_ptr(8);
 431         pset *caller_save          = pset_new_ptr(8);
 432         pset *states               = pset_new_ptr(2);
 433         int stack_size             = 0;
 434         int stack_dir              = arch_env_stack_dir(arch_env);
 435         const arch_register_t *sp  = arch_env_sp(arch_env);
 436         be_abi_call_t *call        = be_abi_call_new(sp->reg_class);
 437         ir_mode *mach_mode         = sp->reg_class->mode;
 438         struct obstack *obst       = &env->obst;
 439         int no_alloc               = call->flags.bits.frame_is_setup_on_call;
 440         int n_res                  = get_method_n_ress(call_tp);
 441         int do_seq                 = call->flags.bits.store_args_sequential && !no_alloc;
 442
 443         ir_node *res_proj  = NULL;
 444         int n_reg_params   = 0;
 445         int n_stack_params = 0;
 446         int n_ins;
 447
 448         ir_node                *low_call;
 449         ir_node               **in;
 450         ir_node               **res_projs;
 451         int                     n_reg_results = 0;
 452         const arch_register_t  *reg;
 453         const ir_edge_t        *edge;
 454         int                    *reg_param_idxs;
 455         int                    *stack_param_idx;
 456         int                     i;
 457         int                     n;
 458         dbg_info               *dbgi;
 459
 460         /* Let the isa fill out the abi description for that call node. */
 461         arch_env_get_call_abi(arch_env, call_tp, call);
 462
 463         /* Insert code to put the stack arguments on the stack. */
 464         assert(get_Call_n_params(irn) == n_params);
 465         for (i = 0; i < n_params; ++i) {
 466                 be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
 467                 assert(arg);
 468                 if (arg->on_stack) {
 469                         int arg_size = get_type_size_bytes(get_method_param_type(call_tp, i));
 470
 471                         stack_size += round_up2(arg->space_before, arg->alignment);
 472                         stack_size += round_up2(arg_size, arg->alignment);
 473                         stack_size += round_up2(arg->space_after, arg->alignment);
 474                         obstack_int_grow(obst, i);
 475                         ++n_stack_params;
 476                 }
 477         }
 478         stack_param_idx = obstack_finish(obst);
 479
 480         /* Collect all arguments which are passed in registers. */
 481         for (i = 0; i < n_params; ++i) {
 482                 be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
 483                 if (arg && arg->in_reg) {
 484                         obstack_int_grow(obst, i);
 485                         ++n_reg_params;
 486                 }
 487         }
 488         reg_param_idxs = obstack_finish(obst);
 489
 490         /*
 491          * If the stack is decreasing and we do not want to store sequentially,
 492          * or someone else allocated the call frame
 493          * we allocate as much space on the stack all parameters need, by
 494          * moving the stack pointer along the stack's direction.
 495          *
 496          * Note: we also have to do this for stack_size == 0, because we may have
 497          * to adjust stack alignment for the call.
 498          */
 499         if (stack_dir < 0 && !do_seq && !no_alloc) {
 500                 curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, stack_size, 1);
 501         }
 502
 503         dbgi = get_irn_dbg_info(irn);
 504         /* If there are some parameters which shall be passed on the stack. */
 505         if (n_stack_params > 0) {
 506                 int curr_ofs      = 0;
 507
 508                 /*
 509                  * Reverse list of stack parameters if call arguments are from left to right.
 510                  * We must them reverse again if they are pushed (not stored) and the stack
 511                  * direction is downwards.
 512                  */
 513                 if (call->flags.bits.left_to_right ^ (do_seq && stack_dir < 0)) {
 514                         for (i = 0; i < n_stack_params >> 1; ++i) {
 515                                 int other  = n_stack_params - i - 1;
 516                                 int tmp    = stack_param_idx[i];
 517                                 stack_param_idx[i]     = stack_param_idx[other];
 518                                 stack_param_idx[other] = tmp;
 519                         }
 520                 }
 521
 522                 curr_mem = get_Call_mem(irn);
 523                 if (! do_seq) {
 524                         obstack_ptr_grow(obst, curr_mem);
 525                 }
 526
 527                 for (i = 0; i < n_stack_params; ++i) {
 528                         int p                  = stack_param_idx[i];
 529                         be_abi_call_arg_t *arg = get_call_arg(call, 0, p);
 530                         ir_node *param         = get_Call_param(irn, p);
 531                         ir_node *addr          = curr_sp;
 532                         ir_node *mem           = NULL;
 533                         ir_type *param_type    = get_method_param_type(call_tp, p);
 534                         int param_size         = get_type_size_bytes(param_type) + arg->space_after;
 535
 536                         /*
 537                          * If we wanted to build the arguments sequentially,
 538                          * the stack pointer for the next must be incremented,
 539                          * and the memory value propagated.
 540                          */
 541                         if (do_seq) {
 542                                 curr_ofs = 0;
 543                                 addr = curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, param_size + arg->space_before, 0);
 544                                 add_irn_dep(curr_sp, curr_mem);
 545                         }
 546                         else {
 547                                 curr_ofs += arg->space_before;
 548                                 curr_ofs =  round_up2(curr_ofs, arg->alignment);
 549
 550                                 /* Make the expression to compute the argument's offset. */
 551                                 if (curr_ofs > 0) {
 552                                         ir_mode *constmode = mach_mode;
 553                                         if (mode_is_reference(mach_mode)) {
 554                                                 constmode = mode_Is;
 555                                         }
 556                                         addr = new_r_Const_long(irg, constmode, curr_ofs);
 557                                         addr = new_r_Add(irg, bl, curr_sp, addr, mach_mode);
 558                                 }
 559                         }
 560
 561                         /* Insert a store for primitive arguments. */
 562                         if (is_atomic_type(param_type)) {
 563                                 ir_node *store;
 564                                 ir_node *mem_input = do_seq ? curr_mem : new_NoMem();
 565                                 store = new_rd_Store(dbgi, irg, bl, mem_input, addr, param);
 566                                 mem = new_r_Proj(irg, bl, store, mode_M, pn_Store_M);
 567                         }
 568
 569                         /* Make a mem copy for compound arguments. */
 570                         else {
 571                                 ir_node *copy;
 572
 573                                 assert(mode_is_reference(get_irn_mode(param)));
 574                                 copy = new_rd_CopyB(dbgi, irg, bl, curr_mem, addr, param, param_type);
 575                                 mem = new_r_Proj(irg, bl, copy, mode_M, pn_CopyB_M_regular);
 576                         }
 577
 578                         curr_ofs += param_size;
 579
 580                         if (do_seq)
 581                                 curr_mem = mem;
 582                         else
 583                                 obstack_ptr_grow(obst, mem);
 584                 }
 585
 586                 in = (ir_node **) obstack_finish(obst);
 587
 588                 /* We need the sync only, if we didn't build the stores sequentially. */
 589                 if (! do_seq) {
 590                         if (n_stack_params >= 1) {
 591                                 curr_mem = new_r_Sync(irg, bl, n_stack_params + 1, in);
 592                         } else {
 593                                 curr_mem = get_Call_mem(irn);
 594                         }
 595                 }
 596                 obstack_free(obst, in);
 597         }
 598
 599         /* Collect caller save registers */
 600         for (i = 0, n = arch_env_get_n_reg_class(arch_env); i < n; ++i) {
 601                 unsigned j;
 602                 const arch_register_class_t *cls = arch_env_get_reg_class(arch_env, i);
 603                 for (j = 0; j < cls->n_regs; ++j) {
 604                         const arch_register_t *reg = arch_register_for_index(cls, j);
 605                         if (arch_register_type_is(reg, caller_save)) {
 606                                 pset_insert_ptr(caller_save, (void *) reg);
 607                         }
 608                         if (arch_register_type_is(reg, state)) {
 609                                 pset_insert_ptr(caller_save, (void*) reg);
 610                                 pset_insert_ptr(states, (void*) reg);
 611                         }
 612                 }
 613         }
 614
 615         /* search the greatest result proj number */
 616
 617         res_projs = ALLOCANZ(ir_node*, n_res);
 618
 619         foreach_out_edge(irn, edge) {
 620                 const ir_edge_t *res_edge;
 621                 ir_node         *irn = get_edge_src_irn(edge);
 622
 623                 if (!is_Proj(irn) || get_Proj_proj(irn) != pn_Call_T_result)
 624                         continue;
 625
 626                 foreach_out_edge(irn, res_edge) {
 627                         int proj;
 628                         ir_node *res = get_edge_src_irn(res_edge);
 629
 630                         assert(is_Proj(res));
 631
 632                         proj = get_Proj_proj(res);
 633                         assert(proj < n_res);
 634                         assert(res_projs[proj] == NULL);
 635                         res_projs[proj] = res;
 636                 }
 637                 res_proj = irn;
 638                 break;
 639         }
 640
 641         /** TODO: this is not correct for cases where return values are passed
 642          * on the stack, but no known ABI does this currently...
 643          */
 644         n_reg_results = n_res;
 645
 646         /* make the back end call node and set its register requirements. */
 647         for (i = 0; i < n_reg_params; ++i) {
 648                 obstack_ptr_grow(obst, get_Call_param(irn, reg_param_idxs[i]));
 649         }
 650         foreach_pset(states, reg) {
 651                 const arch_register_class_t *cls = arch_register_get_class(reg);
 652 #if 0
 653                 ir_node *regnode = be_abi_reg_map_get(env->regs, reg);
 654                 ir_fprintf(stderr, "Adding %+F\n", regnode);
 655 #endif
 656                 ir_node *regnode = new_rd_Unknown(irg, arch_register_class_mode(cls));
 657                 obstack_ptr_grow(obst, regnode);
 658         }
 659         n_ins = n_reg_params + pset_count(states);
 660
 661         in = obstack_finish(obst);
 662
 663         if (env->call->flags.bits.call_has_imm && is_SymConst(call_ptr)) {
 664                 /* direct call */
 665                 low_call = be_new_Call(dbgi, irg, bl, curr_mem, curr_sp, curr_sp,
 666                                        n_reg_results + pn_be_Call_first_res + pset_count(caller_save),
 667                                        n_ins, in, get_Call_type(irn));
 668                 be_Call_set_entity(low_call, get_SymConst_entity(call_ptr));
 669         } else {
 670                 /* indirect call */
 671                 low_call = be_new_Call(dbgi, irg, bl, curr_mem, curr_sp, call_ptr,
 672                                        n_reg_results + pn_be_Call_first_res + pset_count(caller_save),
 673                                        n_ins, in, get_Call_type(irn));
 674         }
 675         be_Call_set_pop(low_call, call->pop);
 676         ARR_APP1(ir_node *, env->calls, low_call);
 677
 678         /* create new stack pointer */
 679         curr_sp = new_r_Proj(irg, bl, low_call, get_irn_mode(curr_sp),
 680                              pn_be_Call_sp);
 681         be_set_constr_single_reg_out(low_call, pn_be_Call_sp, sp,
 682                         arch_register_req_type_ignore | arch_register_req_type_produces_sp);
 683         arch_set_irn_register(curr_sp, sp);
 684
 685         for (i = 0; i < n_res; ++i) {
 686                 int pn;
 687                 ir_node           *proj = res_projs[i];
 688                 be_abi_call_arg_t *arg  = get_call_arg(call, 1, i);
 689
 690                 /* returns values on stack not supported yet */
 691                 assert(arg->in_reg);
 692
 693                 /*
 694                         shift the proj number to the right, since we will drop the
 695                         unspeakable Proj_T from the Call. Therefore, all real argument
 696                         Proj numbers must be increased by pn_be_Call_first_res
 697                 */
 698                 pn = i + pn_be_Call_first_res;
 699
 700                 if (proj == NULL) {
 701                         ir_type *res_type = get_method_res_type(call_tp, i);
 702                         ir_mode *mode     = get_type_mode(res_type);
 703                         proj              = new_r_Proj(irg, bl, low_call, mode, pn);
 704                         res_projs[i]      = proj;
 705                 } else {
 706                         set_Proj_pred(proj, low_call);
 707                         set_Proj_proj(proj, pn);
 708                 }
 709
 710                 if (arg->in_reg) {
 711                         pset_remove_ptr(caller_save, arg->reg);
 712                 }
 713         }
 714
 715         /*
 716                 Set the register class of the call address to
 717                 the backend provided class (default: stack pointer class)
 718         */
 719         be_node_set_reg_class_in(low_call, be_pos_Call_ptr, call->cls_addr);
 720
 721         DBG((env->dbg, LEVEL_3, "\tcreated backend call %+F\n", low_call));
 722
 723         /* Set the register classes and constraints of the Call parameters. */
 724         for (i = 0; i < n_reg_params; ++i) {
 725                 int index = reg_param_idxs[i];
 726                 be_abi_call_arg_t *arg = get_call_arg(call, 0, index);
 727                 assert(arg->reg != NULL);
 728
 729                 be_set_constr_single_reg_in(low_call, be_pos_Call_first_arg + i,
 730                                             arg->reg, 0);
 731         }
 732
 733         /* Set the register constraints of the results. */
 734         for (i = 0; i < n_res; ++i) {
 735                 ir_node                 *proj = res_projs[i];
 736                 const be_abi_call_arg_t *arg  = get_call_arg(call, 1, i);
 737                 int                      pn   = get_Proj_proj(proj);
 738
 739                 assert(arg->in_reg);
 740                 be_set_constr_single_reg_out(low_call, pn, arg->reg, 0);
 741                 arch_set_irn_register(proj, arg->reg);
 742         }
 743         obstack_free(obst, in);
 744         exchange(irn, low_call);
 745
 746         /* kill the ProjT node */
 747         if (res_proj != NULL) {
 748                 kill_node(res_proj);
 749         }
 750
 751         /* Make additional projs for the caller save registers
 752            and the Keep node which keeps them alive. */
 753         if (1 || pset_count(caller_save) + n_reg_results > 0) {
 754                 const arch_register_t *reg;
 755                 ir_node               **in, *keep;
 756                 int                   i;
 757                 int                   n = 0;
 758                 int                   curr_res_proj
 759                         = pn_be_Call_first_res + n_reg_results;
 760
 761                 /* also keep the stack pointer */
 762                 ++n;
 763                 set_irn_link(curr_sp, (void*) sp);
 764                 obstack_ptr_grow(obst, curr_sp);
 765
 766                 for (reg = pset_first(caller_save); reg; reg = pset_next(caller_save), ++n) {
 767                         ir_node *proj = new_r_Proj(irg, bl, low_call, reg->reg_class->mode,
 768                                                    curr_res_proj);
 769
 770                         /* memorize the register in the link field. we need afterwards to set the register class of the keep correctly. */
 771                         be_set_constr_single_reg_out(low_call, curr_res_proj, reg, 0);
 772                         arch_set_irn_register(proj, reg);
 773
 774                         set_irn_link(proj, (void*) reg);
 775                         obstack_ptr_grow(obst, proj);
 776                         curr_res_proj++;
 777                 }
 778
 779                 for (i = 0; i < n_reg_results; ++i) {
 780                         ir_node *proj = res_projs[i];
 781                         const arch_register_t *reg = arch_get_irn_register(proj);
 782                         set_irn_link(proj, (void*) reg);
 783                         obstack_ptr_grow(obst, proj);
 784                 }
 785                 n += n_reg_results;
 786
 787                 /* create the Keep for the caller save registers */
 788                 in   = (ir_node **) obstack_finish(obst);
 789                 keep = be_new_Keep(NULL, irg, bl, n, in);
 790                 for (i = 0; i < n; ++i) {
 791                         const arch_register_t *reg = get_irn_link(in[i]);
 792                         be_node_set_reg_class_in(keep, i, reg->reg_class);
 793                 }
 794                 obstack_free(obst, in);
 795         }
 796
 797         /* Clean up the stack. */
 798         assert(stack_size >= call->pop);
 799         stack_size -= call->pop;
 800
 801         if (stack_size > 0) {
 802                 ir_node *mem_proj = NULL;
 803
 804                 foreach_out_edge(low_call, edge) {
 805                         ir_node *irn = get_edge_src_irn(edge);
 806                         if (is_Proj(irn) && get_Proj_proj(irn) == pn_Call_M) {
 807                                 mem_proj = irn;
 808                                 break;
 809                         }
 810                 }
 811
 812                 if (! mem_proj) {
 813                         mem_proj = new_r_Proj(irg, bl, low_call, mode_M, pn_be_Call_M_regular);
 814                         keep_alive(mem_proj);
 815                 }
 816         }
 817         /* Clean up the stack frame or revert alignment fixes if we allocated it */
 818         if (! no_alloc) {
 819                 curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, -stack_size, 0);
 820         }
 821
 822         be_abi_call_free(call);
 823         obstack_free(obst, stack_param_idx);
 824         del_pset(results);
 825         del_pset(states);
 826         del_pset(caller_save);
 827
 828         return curr_sp;
 829 }
 830
 831 /**
 832  * Adjust the size of a node representing a stack alloc or free for the minimum stack alignment.
 833  *
 834  * @param alignment  the minimum stack alignment
 835  * @param size       the node containing the non-aligned size
 836  * @param irg        the irg where new nodes are allocated on
 837  * @param irg        the block where new nodes are allocated on
 838  * @param dbg        debug info for new nodes
 839  *
 840  * @return a node representing the aligned size
 841  */
 842 static ir_node *adjust_alloc_size(unsigned stack_alignment, ir_node *size,
 843                                   ir_graph *irg, ir_node *block, dbg_info *dbg)
 844 {
 845         if (stack_alignment > 1) {
 846                 ir_mode *mode;
 847                 tarval  *tv;
 848                 ir_node *mask;
 849
 850                 assert(is_po2(stack_alignment));
 851
 852                 mode = get_irn_mode(size);
 853                 tv   = new_tarval_from_long(stack_alignment-1, mode);
 854                 mask = new_r_Const(irg, tv);
 855                 size = new_rd_Add(dbg, irg, block, size, mask, mode);
 856
 857                 tv   = new_tarval_from_long(-(long)stack_alignment, mode);
 858                 mask = new_r_Const(irg, tv);
 859                 size = new_rd_And(dbg, irg, block, size, mask, mode);
 860         }
 861         return size;
 862 }
 863 /**
 864  * Adjust an alloca.
 865  * The alloca is transformed into a back end alloca node and connected to the stack nodes.
 866  */
 867 static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp)
 868 {
 869         ir_node *block;
 870         ir_graph *irg;
 871         ir_node *alloc_mem;
 872         ir_node *alloc_res;
 873         ir_type *type;
 874         dbg_info *dbg;
 875
 876         const ir_edge_t *edge;
 877         ir_node *new_alloc, *size, *addr, *ins[2];
 878         unsigned stack_alignment;
 879
 880         assert(get_Alloc_where(alloc) == stack_alloc);
 881
 882         block = get_nodes_block(alloc);
 883         irg = get_irn_irg(block);
 884         alloc_mem = NULL;
 885         alloc_res = NULL;
 886         type = get_Alloc_type(alloc);
 887
 888         foreach_out_edge(alloc, edge) {
 889                 ir_node *irn = get_edge_src_irn(edge);
 890
 891                 assert(is_Proj(irn));
 892                 switch (get_Proj_proj(irn)) {
 893                 case pn_Alloc_M:
 894                         alloc_mem = irn;
 895                         break;
 896                 case pn_Alloc_res:
 897                         alloc_res = irn;
 898                         break;
 899                 default:
 900                         break;
 901                 }
 902         }
 903
 904         /* Beware: currently Alloc nodes without a result might happen,
 905            only escape analysis kills them and this phase runs only for object
 906            oriented source. We kill the Alloc here. */
 907         if (alloc_res == NULL && alloc_mem) {
 908                 exchange(alloc_mem, get_Alloc_mem(alloc));
 909                 return curr_sp;
 910         }
 911
 912         dbg  = get_irn_dbg_info(alloc);
 913         size = get_Alloc_size(alloc);
 914
 915         /* we might need to multiply the size with the element size */
 916         if (type != firm_unknown_type && get_type_size_bytes(type) != 1) {
 917                 ir_mode *mode = get_irn_mode(size);
 918                 tarval *tv    = new_tarval_from_long(get_type_size_bytes(type),
 919                                                      mode);
 920                 ir_node *cnst = new_rd_Const(dbg, irg, tv);
 921                 size          = new_rd_Mul(dbg, irg, block, size, cnst, mode);
 922         }
 923
 924         /* The stack pointer will be modified in an unknown manner.
 925            We cannot omit it. */
 926         env->call->flags.bits.try_omit_fp = 0;
 927
 928         stack_alignment = 1 << env->arch_env->stack_alignment;
 929         size            = adjust_alloc_size(stack_alignment, size, irg, block, dbg);
 930         new_alloc       = be_new_AddSP(env->arch_env->sp, irg, block, curr_sp, size);
 931         set_irn_dbg_info(new_alloc, dbg);
 932
 933         if (alloc_mem != NULL) {
 934                 ir_node *addsp_mem;
 935                 ir_node *sync;
 936
 937                 addsp_mem = new_r_Proj(irg, block, new_alloc, mode_M, pn_be_AddSP_M);
 938
 939                 /* We need to sync the output mem of the AddSP with the input mem
 940                    edge into the alloc node. */
 941                 ins[0] = get_Alloc_mem(alloc);
 942                 ins[1] = addsp_mem;
 943                 sync = new_r_Sync(irg, block, 2, ins);
 944
 945                 exchange(alloc_mem, sync);
 946         }
 947
 948         exchange(alloc, new_alloc);
 949
 950         /* fix projnum of alloca res */
 951         set_Proj_proj(alloc_res, pn_be_AddSP_res);
 952
 953         addr    = alloc_res;
 954         curr_sp = new_r_Proj(irg, block, new_alloc,  get_irn_mode(curr_sp),
 955                              pn_be_AddSP_sp);
 956
 957         return curr_sp;
 958 }  /* adjust_alloc */
 959
 960 /**
 961  * Adjust a Free.
 962  * The Free is transformed into a back end free node and connected to the stack nodes.
 963  */
 964 static ir_node *adjust_free(be_abi_irg_t *env, ir_node *free, ir_node *curr_sp)
 965 {
 966         ir_node *block;
 967         ir_graph *irg;
 968         ir_node *subsp, *mem, *res, *size, *sync;
 969         ir_type *type;
 970         ir_node *in[2];
 971         ir_mode *sp_mode;
 972         unsigned stack_alignment;
 973         dbg_info *dbg;
 974
 975         assert(get_Free_where(free) == stack_alloc);
 976
 977         block = get_nodes_block(free);
 978         irg = get_irn_irg(block);
 979         type = get_Free_type(free);
 980         sp_mode = env->arch_env->sp->reg_class->mode;
 981         dbg = get_irn_dbg_info(free);
 982
 983         /* we might need to multiply the size with the element size */
 984         if (type != firm_unknown_type && get_type_size_bytes(type) != 1) {
 985                 tarval *tv = new_tarval_from_long(get_type_size_bytes(type), mode_Iu);
 986                 ir_node *cnst = new_rd_Const(dbg, irg, tv);
 987                 ir_node *mul = new_rd_Mul(dbg, irg, block, get_Free_size(free),
 988                                           cnst, mode_Iu);
 989                 size = mul;
 990         } else {
 991                 size = get_Free_size(free);
 992         }
 993
 994         stack_alignment = 1 << env->arch_env->stack_alignment;
 995         size            = adjust_alloc_size(stack_alignment, size, irg, block, dbg);
 996
 997         /* The stack pointer will be modified in an unknown manner.
 998            We cannot omit it. */
 999         env->call->flags.bits.try_omit_fp = 0;
1000         subsp = be_new_SubSP(env->arch_env->sp, irg, block, curr_sp, size);
1001         set_irn_dbg_info(subsp, dbg);
1002
1003         mem = new_r_Proj(irg, block, subsp, mode_M, pn_be_SubSP_M);
1004         res = new_r_Proj(irg, block, subsp, sp_mode, pn_be_SubSP_sp);
1005
1006         /* we need to sync the memory */
1007         in[0] = get_Free_mem(free);
1008         in[1] = mem;
1009         sync = new_r_Sync(irg, block, 2, in);
1010
1011         /* and make the AddSP dependent on the former memory */
1012         add_irn_dep(subsp, get_Free_mem(free));
1013
1014         /* kill the free */
1015         exchange(free, sync);
1016         curr_sp = res;
1017
1018         return curr_sp;
1019 }  /* adjust_free */
1020
1021 /* the following function is replaced by the usage of the heights module */
1022 #if 0
1023 /**
1024  * Walker for dependent_on().
1025  * This function searches a node tgt recursively from a given node
1026  * but is restricted to the given block.
1027  * @return 1 if tgt was reachable from curr, 0 if not.
1028  */
1029 static int check_dependence(ir_node *curr, ir_node *tgt, ir_node *bl)
1030 {
1031         int n, i;
1032
1033         if (get_nodes_block(curr) != bl)
1034                 return 0;
1035
1036         if (curr == tgt)
1037                 return 1;
1038
1039         /* Phi functions stop the recursion inside a basic block */
1040         if (! is_Phi(curr)) {
1041                 for (i = 0, n = get_irn_arity(curr); i < n; ++i) {
1042                         if (check_dependence(get_irn_n(curr, i), tgt, bl))
1043                                 return 1;
1044                 }
1045         }
1046
1047         return 0;
1048 }
1049 #endif /* if 0 */
1050
1051 /**
1052  * Check if a node is somehow data dependent on another one.
1053  * both nodes must be in the same basic block.
1054  * @param n1 The first node.
1055  * @param n2 The second node.
1056  * @return 1, if n1 is data dependent (transitively) on n2, 0 if not.
1057  */
1058 static int dependent_on(ir_node *n1, ir_node *n2)
1059 {
1060         assert(get_nodes_block(n1) == get_nodes_block(n2));
1061
1062         return heights_reachable_in_block(ir_heights, n1, n2);
1063 }
1064
1065 static int cmp_call_dependency(const void *c1, const void *c2)
1066 {
1067         ir_node *n1 = *(ir_node **) c1;
1068         ir_node *n2 = *(ir_node **) c2;
1069
1070         /*
1071                 Classical qsort() comparison function behavior:
1072                 0  if both elements are equal
1073                 1  if second is "smaller" that first
1074                 -1 if first is "smaller" that second
1075         */
1076         if (dependent_on(n1, n2))
1077                 return -1;
1078
1079         if (dependent_on(n2, n1))
1080                 return 1;
1081
1082         return 0;
1083 }
1084
1085 /**
1086  * Walker: links all Call/Alloc/Free nodes to the Block they are contained.
1087  * Clears the irg_is_leaf flag if a Call is detected.
1088  */
1089 static void link_ops_in_block_walker(ir_node *irn, void *data)
1090 {
1091         ir_opcode code = get_irn_opcode(irn);
1092
1093         if (code == iro_Call ||
1094            (code == iro_Alloc && get_Alloc_where(irn) == stack_alloc) ||
1095            (code == iro_Free && get_Free_where(irn) == stack_alloc)) {
1096                 be_abi_irg_t *env = data;
1097                 ir_node *bl       = get_nodes_block(irn);
1098                 void *save        = get_irn_link(bl);
1099
1100                 if (code == iro_Call)
1101                         env->call->flags.bits.irg_is_leaf = 0;
1102
1103                 set_irn_link(irn, save);
1104                 set_irn_link(bl, irn);
1105         }
1106 }
1107
1108 /**
1109  * Block-walker:
1110  * Process all Call/Alloc/Free nodes inside a basic block.
1111  * Note that the link field of the block must contain a linked list of all
1112  * Call nodes inside the Block. We first order this list according to data dependency
1113  * and that connect the calls together.
1114  */
1115 static void process_ops_in_block(ir_node *bl, void *data)
1116 {
1117         be_abi_irg_t *env = data;
1118         ir_node *curr_sp  = env->init_sp;
1119         ir_node *irn;
1120         int n;
1121
1122         for (irn = get_irn_link(bl), n = 0; irn; irn = get_irn_link(irn), ++n)
1123                 obstack_ptr_grow(&env->obst, irn);
1124
1125         /* If there were call nodes in the block. */
1126         if (n > 0) {
1127                 ir_node *keep;
1128                 ir_node **nodes;
1129                 int i;
1130
1131                 nodes = obstack_finish(&env->obst);
1132
1133                 /* order the call nodes according to data dependency */
1134                 qsort(nodes, n, sizeof(nodes[0]), cmp_call_dependency);
1135
1136                 for (i = n - 1; i >= 0; --i) {
1137                         ir_node *irn = nodes[i];
1138
1139                         DBG((env->dbg, LEVEL_3, "\tprocessing call %+F\n", irn));
1140                         switch (get_irn_opcode(irn)) {
1141                         case iro_Call:
1142                                 if (! be_omit_fp) {
1143                                         /* The stack pointer will be modified due to a call. */
1144                                         env->call->flags.bits.try_omit_fp = 0;
1145                                 }
1146                                 curr_sp = adjust_call(env, irn, curr_sp);
1147                                 break;
1148                         case iro_Alloc:
1149                                 if (get_Alloc_where(irn) == stack_alloc)
1150                                         curr_sp = adjust_alloc(env, irn, curr_sp);
1151                                 break;
1152                         case iro_Free:
1153                                 if (get_Free_where(irn) == stack_alloc)
1154                                         curr_sp = adjust_free(env, irn, curr_sp);
1155                                 break;
1156                         default:
1157                                 panic("invalid call");
1158                                 break;
1159                         }
1160                 }
1161
1162                 obstack_free(&env->obst, nodes);
1163
1164                 /* Keep the last stack state in the block by tying it to Keep node,
1165                  * the proj from calls is already kept */
1166                 if (curr_sp != env->init_sp &&
1167                     !(is_Proj(curr_sp) && be_is_Call(get_Proj_pred(curr_sp)))) {
1168                         nodes[0] = curr_sp;
1169                         keep     = be_new_Keep(env->arch_env->sp->reg_class,
1170                                                get_irn_irg(bl), bl, 1, nodes);
1171                         pmap_insert(env->keep_map, bl, keep);
1172                 }
1173         }
1174
1175         set_irn_link(bl, curr_sp);
1176 }  /* process_calls_in_block */
1177
1178 /**
1179  * Adjust all call nodes in the graph to the ABI conventions.
1180  */
1181 static void process_calls(be_abi_irg_t *env)
1182 {
1183         ir_graph *irg = env->birg->irg;
1184
1185         env->call->flags.bits.irg_is_leaf = 1;
1186         irg_walk_graph(irg, firm_clear_link, link_ops_in_block_walker, env);
1187
1188         ir_heights = heights_new(env->birg->irg);
1189         irg_block_walk_graph(irg, NULL, process_ops_in_block, env);
1190         heights_free(ir_heights);
1191 }
1192
1193 /**
1194  * Computes the stack argument layout type.
1195  * Changes a possibly allocated value param type by moving
1196  * entities to the stack layout type.
1197  *
1198  * @param env          the ABI environment
1199  * @param call         the current call ABI
1200  * @param method_type  the method type
1201  * @param param_map    an array mapping method arguments to the stack layout type
1202  *
1203  * @return the stack argument layout type
1204  */
1205 static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call, ir_type *method_type, ir_entity ***param_map)
1206 {
1207         int dir  = env->call->flags.bits.left_to_right ? 1 : -1;
1208         int inc  = env->birg->main_env->arch_env->stack_dir * dir;
1209         int n    = get_method_n_params(method_type);
1210         int curr = inc > 0 ? 0 : n - 1;
1211         int ofs  = 0;
1212
1213         char buf[128];
1214         ir_type *res;
1215         int i;
1216         ir_type *val_param_tp = get_method_value_param_type(method_type);
1217         ident *id = get_entity_ident(get_irg_entity(env->birg->irg));
1218         ir_entity **map;
1219
1220         *param_map = map = obstack_alloc(&env->obst, n * sizeof(ir_entity *));
1221         res = new_type_struct(id_mangle_u(id, new_id_from_chars("arg_type", 8)));
1222         for (i = 0; i < n; ++i, curr += inc) {
1223                 ir_type *param_type    = get_method_param_type(method_type, curr);
1224                 be_abi_call_arg_t *arg = get_call_arg(call, 0, curr);
1225
1226                 map[i] = NULL;
1227                 if (arg->on_stack) {
1228                         if (val_param_tp) {
1229                                 /* the entity was already created, move it to the param type */
1230                                 arg->stack_ent = get_method_value_param_ent(method_type, i);
1231                                 remove_struct_member(val_param_tp, arg->stack_ent);
1232                                 set_entity_owner(arg->stack_ent, res);
1233                                 add_struct_member(res, arg->stack_ent);
1234                                 /* must be automatic to set a fixed layout */
1235                                 set_entity_allocation(arg->stack_ent, allocation_automatic);
1236                         }
1237                         else {
1238                                 snprintf(buf, sizeof(buf), "param_%d", i);
1239                                 arg->stack_ent = new_entity(res, new_id_from_str(buf), param_type);
1240                         }
1241                         ofs += arg->space_before;
1242                         ofs = round_up2(ofs, arg->alignment);
1243                         set_entity_offset(arg->stack_ent, ofs);
1244                         ofs += arg->space_after;
1245                         ofs += get_type_size_bytes(param_type);
1246                         map[i] = arg->stack_ent;
1247                 }
1248         }
1249         set_type_size_bytes(res, ofs);
1250         set_type_state(res, layout_fixed);
1251         return res;
1252 }
1253
1254 typedef struct {
1255         const arch_register_t *reg;
1256         ir_node *irn;
1257 } reg_node_map_t;
1258
1259 static int cmp_regs(const void *a, const void *b)
1260 {
1261         const reg_node_map_t *p = a;
1262         const reg_node_map_t *q = b;
1263
1264         if (p->reg->reg_class == q->reg->reg_class)
1265                 return p->reg->index - q->reg->index;
1266         else
1267                 return p->reg->reg_class - q->reg->reg_class;
1268 }
1269
1270 static reg_node_map_t *reg_map_to_arr(struct obstack *obst, pmap *reg_map)
1271 {
1272         pmap_entry *ent;
1273         int n = pmap_count(reg_map);
1274         int i = 0;
1275         reg_node_map_t *res = obstack_alloc(obst, n * sizeof(res[0]));
1276
1277         foreach_pmap(reg_map, ent) {
1278                 res[i].reg = ent->key;
1279                 res[i].irn = ent->value;
1280                 i++;
1281         }
1282
1283         qsort(res, n, sizeof(res[0]), cmp_regs);
1284         return res;
1285 }
1286
1287 /**
1288  * Creates a barrier.
1289  */
1290 static ir_node *create_barrier(be_abi_irg_t *env, ir_node *bl, ir_node **mem, pmap *regs, int in_req)
1291 {
1292         ir_graph *irg = env->birg->irg;
1293         int n_regs    = pmap_count(regs);
1294         int n;
1295         ir_node *irn;
1296         ir_node **in;
1297         reg_node_map_t *rm;
1298
1299         rm = reg_map_to_arr(&env->obst, regs);
1300
1301         for (n = 0; n < n_regs; ++n)
1302                 obstack_ptr_grow(&env->obst, rm[n].irn);
1303
1304         if (mem) {
1305                 obstack_ptr_grow(&env->obst, *mem);
1306                 n++;
1307         }
1308
1309         in = (ir_node **) obstack_finish(&env->obst);
1310         irn = be_new_Barrier(irg, bl, n, in);
1311         obstack_free(&env->obst, in);
1312
1313         for (n = 0; n < n_regs; ++n) {
1314                 ir_node                   *pred     = rm[n].irn;
1315                 const arch_register_t     *reg      = rm[n].reg;
1316                 arch_register_type_t       add_type = 0;
1317                 ir_node                   *proj;
1318
1319                 /* stupid workaround for now... as not all nodes report register
1320                  * requirements. */
1321                 if (!is_Phi(pred)) {
1322                         const arch_register_req_t *ireq = arch_get_register_req_out(pred);
1323                         if (ireq->type & arch_register_req_type_ignore)
1324                                 add_type |= arch_register_req_type_ignore;
1325                         if (ireq->type & arch_register_req_type_produces_sp)
1326                                 add_type |= arch_register_req_type_produces_sp;
1327                 }
1328
1329                 proj = new_r_Proj(irg, bl, irn, get_irn_mode(pred), n);
1330                 be_node_set_reg_class_in(irn, n, reg->reg_class);
1331                 if (in_req)
1332                         be_set_constr_single_reg_in(irn, n, reg, 0);
1333                 be_set_constr_single_reg_out(irn, n, reg, add_type);
1334                 arch_set_irn_register(proj, reg);
1335
1336                 pmap_insert(regs, (void *) reg, proj);
1337         }
1338
1339         if (mem) {
1340                 *mem = new_r_Proj(irg, bl, irn, mode_M, n);
1341         }
1342
1343         obstack_free(&env->obst, rm);
1344         return irn;
1345 }
1346
1347 /**
1348  * Creates a be_Return for a Return node.
1349  *
1350  * @param @env    the abi environment
1351  * @param irn     the Return node or NULL if there was none
1352  * @param bl      the block where the be_Retun should be placed
1353  * @param mem     the current memory
1354  * @param n_res   number of return results
1355  */
1356 static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl,
1357                 ir_node *mem, int n_res)
1358 {
1359         be_abi_call_t    *call     = env->call;
1360         const arch_env_t *arch_env = env->birg->main_env->arch_env;
1361         dbg_info *dbgi;
1362         pmap *reg_map  = pmap_create();
1363         ir_node *keep  = pmap_get(env->keep_map, bl);
1364         int in_max;
1365         ir_node *ret;
1366         int i, n;
1367         unsigned pop;
1368         ir_node **in;
1369         ir_node *stack;
1370         const arch_register_t **regs;
1371         pmap_entry *ent ;
1372
1373         /*
1374                 get the valid stack node in this block.
1375                 If we had a call in that block there is a Keep constructed by process_calls()
1376                 which points to the last stack modification in that block. we'll use
1377                 it then. Else we use the stack from the start block and let
1378                 the ssa construction fix the usage.
1379         */
1380         stack = be_abi_reg_map_get(env->regs, arch_env->sp);
1381         if (keep) {
1382                 stack = get_irn_n(keep, 0);
1383                 kill_node(keep);
1384                 remove_End_keepalive(get_irg_end(env->birg->irg), keep);
1385         }
1386
1387         /* Insert results for Return into the register map. */
1388         for (i = 0; i < n_res; ++i) {
1389                 ir_node *res           = get_Return_res(irn, i);
1390                 be_abi_call_arg_t *arg = get_call_arg(call, 1, i);
1391                 assert(arg->in_reg && "return value must be passed in register");
1392                 pmap_insert(reg_map, (void *) arg->reg, res);
1393         }
1394
1395         /* Add uses of the callee save registers. */
1396         foreach_pmap(env->regs, ent) {
1397                 const arch_register_t *reg = ent->key;
1398                 if (arch_register_type_is(reg, callee_save) || arch_register_type_is(reg, ignore))
1399                         pmap_insert(reg_map, ent->key, ent->value);
1400         }
1401
1402         be_abi_reg_map_set(reg_map, arch_env->sp, stack);
1403
1404         /* Make the Epilogue node and call the arch's epilogue maker. */
1405         create_barrier(env, bl, &mem, reg_map, 1);
1406         call->cb->epilogue(env->cb, bl, &mem, reg_map);
1407
1408         /*
1409                 Maximum size of the in array for Return nodes is
1410                 return args + callee save/ignore registers + memory + stack pointer
1411         */
1412         in_max = pmap_count(reg_map) + n_res + 2;
1413
1414         in   = obstack_alloc(&env->obst, in_max * sizeof(in[0]));
1415         regs = obstack_alloc(&env->obst, in_max * sizeof(regs[0]));
1416
1417         in[0]   = mem;
1418         in[1]   = be_abi_reg_map_get(reg_map, arch_env->sp);
1419         regs[0] = NULL;
1420         regs[1] = arch_env->sp;
1421         n       = 2;
1422
1423         /* clear SP entry, since it has already been grown. */
1424         pmap_insert(reg_map, (void *) arch_env->sp, NULL);
1425         for (i = 0; i < n_res; ++i) {
1426                 be_abi_call_arg_t *arg = get_call_arg(call, 1, i);
1427
1428                 in[n]     = be_abi_reg_map_get(reg_map, arg->reg);
1429                 regs[n++] = arg->reg;
1430
1431                 /* Clear the map entry to mark the register as processed. */
1432                 be_abi_reg_map_set(reg_map, arg->reg, NULL);
1433         }
1434
1435         /* grow the rest of the stuff. */
1436         foreach_pmap(reg_map, ent) {
1437                 if (ent->value) {
1438                         in[n]     = ent->value;
1439                         regs[n++] = ent->key;
1440                 }
1441         }
1442
1443         /* The in array for the new back end return is now ready. */
1444         if (irn != NULL) {
1445                 dbgi = get_irn_dbg_info(irn);
1446         } else {
1447                 dbgi = NULL;
1448         }
1449         /* we have to pop the shadow parameter in in case of struct returns */
1450         pop = call->pop;
1451         ret = be_new_Return(dbgi, env->birg->irg, bl, n_res, pop, n, in);
1452
1453         /* Set the register classes of the return's parameter accordingly. */
1454         for (i = 0; i < n; ++i) {
1455                 if (regs[i] == NULL)
1456                         continue;
1457
1458                 be_node_set_reg_class_in(ret, i, regs[i]->reg_class);
1459         }
1460
1461         /* Free the space of the Epilog's in array and the register <-> proj map. */
1462         obstack_free(&env->obst, in);
1463         pmap_destroy(reg_map);
1464
1465         return ret;
1466 }
1467
1468 typedef struct lower_frame_sels_env_t {
1469         be_abi_irg_t *env;
1470         ir_entity    *value_param_list;  /**< the list of all value param entities */
1471         ir_entity    *value_param_tail;  /**< the tail of the list of all value param entities */
1472 } lower_frame_sels_env_t;
1473
1474 /**
1475  * Walker: Replaces Sels of frame type and
1476  * value param type entities by FrameAddress.
1477  * Links all used entities.
1478  */
1479 static void lower_frame_sels_walker(ir_node *irn, void *data) {
1480         lower_frame_sels_env_t *ctx = data;
1481
1482         if (is_Sel(irn)) {
1483                 ir_graph *irg        = current_ir_graph;
1484                 ir_node  *frame      = get_irg_frame(irg);
1485                 ir_node  *param_base = get_irg_value_param_base(irg);
1486                 ir_node  *ptr        = get_Sel_ptr(irn);
1487
1488                 if (ptr == frame || ptr == param_base) {
1489                         be_abi_irg_t *env = ctx->env;
1490                         ir_entity    *ent = get_Sel_entity(irn);
1491                         ir_node      *bl  = get_nodes_block(irn);
1492                         ir_node      *nw;
1493
1494                         nw = be_new_FrameAddr(env->arch_env->sp->reg_class, irg, bl, frame, ent);
1495                         exchange(irn, nw);
1496
1497                         /* check, if it's a param sel and if have not seen this entity before */
1498                         if (ptr == param_base &&
1499                             ent != ctx->value_param_tail &&
1500                             get_entity_link(ent) == NULL) {
1501                                 set_entity_link(ent, ctx->value_param_list);
1502                                 ctx->value_param_list = ent;
1503                                 if (ctx->value_param_tail == NULL) ctx->value_param_tail = ent;
1504                         }
1505                 }
1506         }
1507 }
1508
1509 /**
1510  * Check if a value parameter is transmitted as a register.
1511  * This might happen if the address of an parameter is taken which is
1512  * transmitted in registers.
1513  *
1514  * Note that on some architectures this case must be handled specially
1515  * because the place of the backing store is determined by their ABI.
1516  *
1517  * In the default case we move the entity to the frame type and create
1518  * a backing store into the first block.
1519  */
1520 static void fix_address_of_parameter_access(be_abi_irg_t *env, ir_entity *value_param_list) {
1521         be_abi_call_t *call = env->call;
1522         ir_graph *irg       = env->birg->irg;
1523         ir_entity *ent, *next_ent, *new_list;
1524         ir_type *frame_tp;
1525         DEBUG_ONLY(firm_dbg_module_t *dbg = env->dbg;)
1526
1527         new_list = NULL;
1528         for (ent = value_param_list; ent; ent = next_ent) {
1529                 int i = get_struct_member_index(get_entity_owner(ent), ent);
1530                 be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
1531
1532                 next_ent = get_entity_link(ent);
1533                 if (arg->in_reg) {
1534                         DBG((dbg, LEVEL_2, "\targ #%d need backing store\n", i));
1535                         set_entity_link(ent, new_list);
1536                         new_list = ent;
1537                 }
1538         }
1539         if (new_list) {
1540                 /* ok, change the graph */
1541                 ir_node *start_bl = get_irg_start_block(irg);
1542                 ir_node *first_bl = NULL;
1543                 ir_node *frame, *imem, *nmem, *store, *mem, *args, *args_bl;
1544                 const ir_edge_t *edge;
1545                 optimization_state_t state;
1546                 unsigned offset;
1547
1548                 foreach_block_succ(start_bl, edge) {
1549                         ir_node *succ = get_edge_src_irn(edge);
1550                         if (start_bl != succ) {
1551                                 first_bl = succ;
1552                                 break;
1553                         }
1554                 }
1555                 assert(first_bl);
1556                 /* we had already removed critical edges, so the following
1557                    assertion should be always true. */
1558                 assert(get_Block_n_cfgpreds(first_bl) == 1);
1559
1560                 /* now create backing stores */
1561                 frame = get_irg_frame(irg);
1562                 imem = get_irg_initial_mem(irg);
1563
1564                 save_optimization_state(&state);
1565                 set_optimize(0);
1566                 nmem = new_r_Proj(irg, first_bl, get_irg_start(irg), mode_M, pn_Start_M);
1567                 restore_optimization_state(&state);
1568
1569                 /* reroute all edges to the new memory source */
1570                 edges_reroute(imem, nmem, irg);
1571
1572                 store   = NULL;
1573                 mem     = imem;
1574                 args    = get_irg_args(irg);
1575                 args_bl = get_nodes_block(args);
1576                 for (ent = new_list; ent; ent = get_entity_link(ent)) {
1577                         int     i     = get_struct_member_index(get_entity_owner(ent), ent);
1578                         ir_type *tp   = get_entity_type(ent);
1579                         ir_mode *mode = get_type_mode(tp);
1580                         ir_node *addr;
1581
1582                         /* address for the backing store */
1583                         addr = be_new_FrameAddr(env->arch_env->sp->reg_class, irg, first_bl, frame, ent);
1584
1585                         if (store)
1586                                 mem = new_r_Proj(irg, first_bl, store, mode_M, pn_Store_M);
1587
1588                         /* the backing store itself */
1589                         store = new_r_Store(irg, first_bl, mem, addr,
1590                                             new_r_Proj(irg, args_bl, args, mode, i));
1591                 }
1592                 /* the new memory Proj gets the last Proj from store */
1593                 set_Proj_pred(nmem, store);
1594                 set_Proj_proj(nmem, pn_Store_M);
1595
1596                 /* move all entities to the frame type */
1597                 frame_tp = get_irg_frame_type(irg);
1598                 offset   = get_type_size_bytes(frame_tp);
1599
1600                 /* we will add new entities: set the layout to undefined */
1601                 assert(get_type_state(frame_tp) == layout_fixed);
1602                 set_type_state(frame_tp, layout_undefined);
1603                 for (ent = new_list; ent; ent = get_entity_link(ent)) {
1604                         ir_type  *tp   = get_entity_type(ent);
1605                         unsigned align = get_type_alignment_bytes(tp);
1606
1607                         offset += align - 1;
1608                         offset &= ~(align - 1);
1609                         set_entity_owner(ent, frame_tp);
1610                         add_class_member(frame_tp, ent);
1611                         /* must be automatic to set a fixed layout */
1612                         set_entity_allocation(ent, allocation_automatic);
1613                         set_entity_offset(ent, offset);
1614                         offset += get_type_size_bytes(tp);
1615                 }
1616                 set_type_size_bytes(frame_tp, offset);
1617                 /* fix the layout again */
1618                 set_type_state(frame_tp, layout_fixed);
1619         }
1620 }
1621
1622 #if 1
1623 /**
1624  * The start block has no jump, instead it has an initial exec Proj.
1625  * The backend wants to handle all blocks the same way, so we replace
1626  * the out cfg edge with a real jump.
1627  */
1628 static void fix_start_block(ir_node *block, void *env) {
1629         int      *done = env;
1630         int      i;
1631         ir_node  *start_block;
1632         ir_graph *irg;
1633
1634         /* we processed the start block, return */
1635         if (*done)
1636                 return;
1637
1638         irg         = get_irn_irg(block);
1639         start_block = get_irg_start_block(irg);
1640
1641         for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) {
1642                 ir_node *pred       = get_Block_cfgpred(block, i);
1643                 ir_node *pred_block = get_nodes_block(pred);
1644
1645                 /* ok, we are in the block, having start as cfg predecessor */
1646                 if (pred_block == start_block) {
1647                         ir_node *jump = new_r_Jmp(irg, pred_block);
1648                         set_Block_cfgpred(block, i, jump);
1649                         *done = 1;
1650                 }
1651         }
1652 }
1653 #endif
1654
1655 /**
1656  * Modify the irg itself and the frame type.
1657  */
1658 static void modify_irg(be_abi_irg_t *env)
1659 {
1660         be_abi_call_t *call       = env->call;
1661         const arch_env_t *arch_env= env->birg->main_env->arch_env;
1662         const arch_register_t *sp = arch_env_sp(arch_env);
1663         ir_graph *irg             = env->birg->irg;
1664         ir_node *start_bl;
1665         ir_node *end;
1666         ir_node *old_mem;
1667         ir_node *new_mem_proj;
1668         ir_node *mem;
1669         ir_type *method_type      = get_entity_type(get_irg_entity(irg));
1670
1671         int n_params;
1672         int i, n;
1673         unsigned j;
1674
1675         reg_node_map_t *rm;
1676         const arch_register_t *fp_reg;
1677         ir_node *frame_pointer;
1678         ir_node *reg_params_bl;
1679         ir_node **args;
1680         ir_node *arg_tuple;
1681         ir_node *value_param_base;
1682         const ir_edge_t *edge;
1683         ir_type *arg_type, *bet_type, *tp;
1684         lower_frame_sels_env_t ctx;
1685         ir_entity **param_map;
1686
1687         bitset_t *used_proj_nr;
1688         DEBUG_ONLY(firm_dbg_module_t *dbg = env->dbg;)
1689
1690         DBG((dbg, LEVEL_1, "introducing abi on %+F\n", irg));
1691
1692         /* Must fetch memory here, otherwise the start Barrier gets the wrong
1693          * memory, which leads to loops in the DAG. */
1694         old_mem = get_irg_initial_mem(irg);
1695
1696         irp_reserve_resources(irp, IR_RESOURCE_ENTITY_LINK);
1697         /* set the links of all frame entities to NULL, we use it
1698            to detect if an entity is already linked in the value_param_list */
1699         tp = get_method_value_param_type(method_type);
1700         if (tp != NULL) {
1701                 for (i = get_struct_n_members(tp) - 1; i >= 0; --i)
1702                         set_entity_link(get_struct_member(tp, i), NULL);
1703         }
1704
1705         /* Convert the Sel nodes in the irg to frame load/store/addr nodes. */
1706         ctx.env              = env;
1707         ctx.value_param_list = NULL;
1708         ctx.value_param_tail = NULL;
1709         irg_walk_graph(irg, lower_frame_sels_walker, NULL, &ctx);
1710
1711         /* value_param_base anchor is not needed anymore now */
1712         value_param_base = get_irg_value_param_base(irg);
1713         kill_node(value_param_base);
1714         set_irg_value_param_base(irg, new_r_Bad(irg));
1715
1716         env->regs  = pmap_create();
1717
1718         used_proj_nr = bitset_alloca(1024);
1719         n_params     = get_method_n_params(method_type);
1720         args         = obstack_alloc(&env->obst, n_params * sizeof(args[0]));
1721         memset(args, 0, n_params * sizeof(args[0]));
1722
1723         /* Check if a value parameter is transmitted as a register.
1724          * This might happen if the address of an parameter is taken which is
1725          * transmitted in registers.
1726          *
1727          * Note that on some architectures this case must be handled specially
1728          * because the place of the backing store is determined by their ABI.
1729          *
1730          * In the default case we move the entity to the frame type and create
1731          * a backing store into the first block.
1732          */
1733         fix_address_of_parameter_access(env, ctx.value_param_list);
1734         irp_free_resources(irp, IR_RESOURCE_ENTITY_LINK);
1735
1736         /* Fill the argument vector */
1737         arg_tuple = get_irg_args(irg);
1738         foreach_out_edge(arg_tuple, edge) {
1739                 ir_node *irn = get_edge_src_irn(edge);
1740                 if (! is_Anchor(irn)) {
1741                         int nr       = get_Proj_proj(irn);
1742                         args[nr]     = irn;
1743                         DBG((dbg, LEVEL_2, "\treading arg: %d -> %+F\n", nr, irn));
1744                 }
1745         }
1746
1747         arg_type = compute_arg_type(env, call, method_type, &param_map);
1748         bet_type = call->cb->get_between_type(env->cb);
1749         stack_frame_init(&env->frame, arg_type, bet_type, get_irg_frame_type(irg), arch_env->stack_dir, param_map);
1750
1751         /* Count the register params and add them to the number of Projs for the RegParams node */
1752         for (i = 0; i < n_params; ++i) {
1753                 be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
1754                 if (arg->in_reg && args[i]) {
1755                         assert(arg->reg != sp && "cannot use stack pointer as parameter register");
1756                         assert(i == get_Proj_proj(args[i]));
1757
1758                         /* For now, associate the register with the old Proj from Start representing that argument. */
1759                         pmap_insert(env->regs, (void *) arg->reg, args[i]);
1760                         bitset_set(used_proj_nr, i);
1761                         DBG((dbg, LEVEL_2, "\targ #%d -> reg %s\n", i, arg->reg->name));
1762                 }
1763         }
1764
1765         /* Collect all callee-save registers */
1766         for (i = 0, n = arch_env_get_n_reg_class(arch_env); i < n; ++i) {
1767                 const arch_register_class_t *cls = arch_env_get_reg_class(arch_env, i);
1768                 for (j = 0; j < cls->n_regs; ++j) {
1769                         const arch_register_t *reg = &cls->regs[j];
1770                         if (arch_register_type_is(reg, callee_save) ||
1771                                         arch_register_type_is(reg, state)) {
1772                                 pmap_insert(env->regs, (void *) reg, NULL);
1773                         }
1774                 }
1775         }
1776
1777         pmap_insert(env->regs, (void *) sp, NULL);
1778         pmap_insert(env->regs, (void *) arch_env->bp, NULL);
1779         reg_params_bl   = get_irg_start_block(irg);
1780         env->reg_params = be_new_RegParams(irg, reg_params_bl, pmap_count(env->regs));
1781         add_irn_dep(env->reg_params, get_irg_start(irg));
1782
1783         /*
1784          * make proj nodes for the callee save registers.
1785          * memorize them, since Return nodes get those as inputs.
1786          *
1787          * Note, that if a register corresponds to an argument, the regs map contains
1788          * the old Proj from start for that argument.
1789          */
1790
1791         rm = reg_map_to_arr(&env->obst, env->regs);
1792         for (i = 0, n = pmap_count(env->regs); i < n; ++i) {
1793                 arch_register_t          *reg      = (void *) rm[i].reg;
1794                 ir_mode                  *mode     = reg->reg_class->mode;
1795                 long                      nr       = i;
1796                 arch_register_req_type_t  add_type = 0;
1797                 ir_node                  *proj;
1798
1799                 if (reg == sp)
1800                         add_type |= arch_register_req_type_produces_sp | arch_register_req_type_ignore;
1801
1802                 assert(nr >= 0);
1803                 bitset_set(used_proj_nr, nr);
1804                 proj = new_r_Proj(irg, reg_params_bl, env->reg_params, mode, nr);
1805                 pmap_insert(env->regs, (void *) reg, proj);
1806                 be_set_constr_single_reg_out(env->reg_params, nr, reg, add_type);
1807                 arch_set_irn_register(proj, reg);
1808
1809                 DBG((dbg, LEVEL_2, "\tregister save proj #%d -> reg %s\n", nr, reg->name));
1810         }
1811         obstack_free(&env->obst, rm);
1812
1813         /* create a new initial memory proj */
1814         assert(is_Proj(old_mem));
1815         new_mem_proj = new_r_Proj(irg, get_nodes_block(old_mem),
1816                                   new_r_Unknown(irg, mode_T), mode_M,
1817                                   get_Proj_proj(old_mem));
1818         mem = new_mem_proj;
1819
1820         /* Generate the Prologue */
1821         fp_reg = call->cb->prologue(env->cb, &mem, env->regs, &env->frame.initial_bias);
1822
1823         /* do the stack allocation BEFORE the barrier, or spill code
1824            might be added before it */
1825         env->init_sp = be_abi_reg_map_get(env->regs, sp);
1826         start_bl     = get_irg_start_block(irg);
1827         env->init_sp = be_new_IncSP(sp, irg, start_bl, env->init_sp, BE_STACK_FRAME_SIZE_EXPAND, 0);
1828         be_abi_reg_map_set(env->regs, sp, env->init_sp);
1829
1830         create_barrier(env, start_bl, &mem, env->regs, 0);
1831
1832         env->init_sp = be_abi_reg_map_get(env->regs, sp);
1833         arch_set_irn_register(env->init_sp, sp);
1834
1835         frame_pointer = be_abi_reg_map_get(env->regs, fp_reg);
1836         set_irg_frame(irg, frame_pointer);
1837         pset_insert_ptr(env->ignore_regs, fp_reg);
1838
1839         /* rewire old mem users to new mem */
1840         set_Proj_pred(new_mem_proj, get_Proj_pred(old_mem));
1841         exchange(old_mem, mem);
1842
1843         set_irg_initial_mem(irg, mem);
1844
1845         /* Now, introduce stack param nodes for all parameters passed on the stack */
1846         for (i = 0; i < n_params; ++i) {
1847                 ir_node *arg_proj = args[i];
1848                 ir_node *repl     = NULL;
1849
1850                 if (arg_proj != NULL) {
1851                         be_abi_call_arg_t *arg;
1852                         ir_type *param_type;
1853                         int     nr = get_Proj_proj(arg_proj);
1854                         ir_mode *mode;
1855
1856                         nr         = MIN(nr, n_params);
1857                         arg        = get_call_arg(call, 0, nr);
1858                         param_type = get_method_param_type(method_type, nr);
1859
1860                         if (arg->in_reg) {
1861                                 repl = pmap_get(env->regs, (void *) arg->reg);
1862                         } else if (arg->on_stack) {
1863                                 ir_node *addr = be_new_FrameAddr(sp->reg_class, irg, reg_params_bl, frame_pointer, arg->stack_ent);
1864
1865                                 /* For atomic parameters which are actually used, we create a Load node. */
1866                                 if (is_atomic_type(param_type) && get_irn_n_edges(args[i]) > 0) {
1867                                         ir_mode *mode      = get_type_mode(param_type);
1868                                         ir_mode *load_mode = arg->load_mode;
1869
1870                                         ir_node *load = new_r_Load(irg, reg_params_bl, new_NoMem(), addr, load_mode);
1871                                         set_irn_pinned(load, op_pin_state_floats);
1872                                         repl = new_r_Proj(irg, reg_params_bl, load, load_mode, pn_Load_res);
1873
1874                                         if (mode != load_mode) {
1875                                                 repl = new_r_Conv(irg, reg_params_bl, repl, mode);
1876                                         }
1877                                 } else {
1878                                         /* The stack parameter is not primitive (it is a struct or array),
1879                                          * we thus will create a node representing the parameter's address
1880                                          * on the stack. */
1881                                         repl = addr;
1882                                 }
1883                         }
1884
1885                         assert(repl != NULL);
1886
1887                         /* Beware: the mode of the register parameters is always the mode of the register class
1888                            which may be wrong. Add Conv's then. */
1889                         mode = get_irn_mode(args[i]);
1890                         if (mode != get_irn_mode(repl)) {
1891                                 repl = new_r_Conv(irg, get_irn_n(repl, -1), repl, mode);
1892                         }
1893                         exchange(args[i], repl);
1894                 }
1895         }
1896
1897         /* the arg proj is not needed anymore now and should be only used by the anchor */
1898         assert(get_irn_n_edges(arg_tuple) == 1);
1899         kill_node(arg_tuple);
1900         set_irg_args(irg, new_r_Bad(irg));
1901
1902         /* All Return nodes hang on the End node, so look for them there. */
1903         end = get_irg_end_block(irg);
1904         for (i = 0, n = get_Block_n_cfgpreds(end); i < n; ++i) {
1905                 ir_node *irn = get_Block_cfgpred(end, i);
1906
1907                 if (is_Return(irn)) {
1908                         ir_node *blk = get_nodes_block(irn);
1909                         ir_node *mem = get_Return_mem(irn);
1910                         ir_node *ret = create_be_return(env, irn, blk, mem, get_Return_n_ress(irn));
1911                         exchange(irn, ret);
1912                 }
1913         }
1914         /* if we have endless loops here, n might be <= 0. Do NOT create a be_Return then,
1915            the code is dead and will never be executed. */
1916
1917         obstack_free(&env->obst, args);
1918
1919         /* handle start block here (place a jump in the block) */
1920         i = 0;
1921         irg_block_walk_graph(irg, fix_start_block, NULL, &i);
1922 }
1923
1924 /** Fix the state inputs of calls that still hang on unknowns */
1925 static
1926 void fix_call_state_inputs(be_abi_irg_t *env)
1927 {
1928         const arch_env_t *arch_env = env->arch_env;
1929         int i, n, n_states;
1930         arch_register_t **stateregs = NEW_ARR_F(arch_register_t*, 0);
1931
1932         /* Collect caller save registers */
1933         n = arch_env_get_n_reg_class(arch_env);
1934         for (i = 0; i < n; ++i) {
1935                 unsigned j;
1936                 const arch_register_class_t *cls = arch_env_get_reg_class(arch_env, i);
1937                 for (j = 0; j < cls->n_regs; ++j) {
1938                         const arch_register_t *reg = arch_register_for_index(cls, j);
1939                         if (arch_register_type_is(reg, state)) {
1940                                 ARR_APP1(arch_register_t*, stateregs, (arch_register_t *)reg);
1941                         }
1942                 }
1943         }
1944
1945         n = ARR_LEN(env->calls);
1946         n_states = ARR_LEN(stateregs);
1947         for (i = 0; i < n; ++i) {
1948                 int s, arity;
1949                 ir_node *call = env->calls[i];
1950
1951                 arity = get_irn_arity(call);
1952
1953                 /* the state reg inputs are the last n inputs of the calls */
1954                 for (s = 0; s < n_states; ++s) {
1955                         int inp = arity - n_states + s;
1956                         const arch_register_t *reg = stateregs[s];
1957                         ir_node *regnode = be_abi_reg_map_get(env->regs, reg);
1958
1959                         set_irn_n(call, inp, regnode);
1960                 }
1961         }
1962
1963         DEL_ARR_F(stateregs);
1964 }
1965
1966 /**
1967  * Create a trampoline entity for the given method.
1968  */
1969 static ir_entity *create_trampoline(be_main_env_t *be, ir_entity *method)
1970 {
1971         ir_type   *type   = get_entity_type(method);
1972         ident     *old_id = get_entity_ld_ident(method);
1973         ident     *id     = id_mangle3("L", old_id, "$stub");
1974         ir_type   *parent = be->pic_trampolines_type;
1975         ir_entity *ent    = new_entity(parent, old_id, type);
1976         set_entity_ld_ident(ent, id);
1977         set_entity_visibility(ent, visibility_local);
1978         set_entity_variability(ent, variability_uninitialized);
1979
1980         return ent;
1981 }
1982
1983 /**
1984  * Returns the trampoline entity for the given method.
1985  */
1986 static ir_entity *get_trampoline(be_main_env_t *env, ir_entity *method)
1987 {
1988         ir_entity *result = pmap_get(env->ent_trampoline_map, method);
1989         if (result == NULL) {
1990                 result = create_trampoline(env, method);
1991                 pmap_insert(env->ent_trampoline_map, method, result);
1992         }
1993
1994         return result;
1995 }
1996
1997 static ir_entity *create_pic_symbol(be_main_env_t *be, ir_entity *entity)
1998 {
1999         ident     *old_id = get_entity_ld_ident(entity);
2000         ident     *id     = id_mangle3("L", old_id, "$non_lazy_ptr");
2001         ir_type   *e_type = get_entity_type(entity);
2002         ir_type   *type   = new_type_pointer(id, e_type, mode_P_data);
2003         ir_type   *parent = be->pic_symbols_type;
2004         ir_entity *ent    = new_entity(parent, old_id, type);
2005         set_entity_ld_ident(ent, id);
2006         set_entity_visibility(ent, visibility_local);
2007         set_entity_variability(ent, variability_uninitialized);
2008
2009         return ent;
2010 }
2011
2012 static ir_entity *get_pic_symbol(be_main_env_t *env, ir_entity *entity)
2013 {
2014         ir_entity *result = pmap_get(env->ent_pic_symbol_map, entity);
2015         if (result == NULL) {
2016                 result = create_pic_symbol(env, entity);
2017                 pmap_insert(env->ent_pic_symbol_map, entity, result);
2018         }
2019
2020         return result;
2021 }
2022
2023
2024
2025 /**
2026  * Returns non-zero if a given entity can be accessed using a relative address.
2027  */
2028 static int can_address_relative(ir_entity *entity)
2029 {
2030         return get_entity_variability(entity) == variability_initialized
2031                 || get_entity_visibility(entity) == visibility_local;
2032 }
2033
2034 /** patches SymConsts to work in position independent code */
2035 static void fix_pic_symconsts(ir_node *node, void *data)
2036 {
2037         ir_graph     *irg;
2038         ir_node      *pic_base;
2039         ir_node      *add;
2040         ir_node      *block;
2041         ir_node      *unknown;
2042         ir_mode      *mode;
2043         ir_node      *load;
2044         ir_node      *load_res;
2045         be_abi_irg_t *env = data;
2046         int           arity, i;
2047         be_main_env_t *be = env->birg->main_env;
2048
2049         arity = get_irn_arity(node);
2050         for (i = 0; i < arity; ++i) {
2051                 dbg_info  *dbgi;
2052                 ir_node   *pred = get_irn_n(node, i);
2053                 ir_entity *entity;
2054                 ir_entity *pic_symbol;
2055                 ir_node   *pic_symconst;
2056
2057                 if (!is_SymConst(pred))
2058                         continue;
2059
2060                 entity = get_SymConst_entity(pred);
2061                 block  = get_nodes_block(pred);
2062                 irg    = get_irn_irg(pred);
2063
2064                 /* calls can jump to relative addresses, so we can directly jump to
2065                    the (relatively) known call address or the trampoline */
2066                 if (i == 1 && is_Call(node)) {
2067                         ir_entity *trampoline;
2068                         ir_node   *trampoline_const;
2069
2070                         if (can_address_relative(entity))
2071                                 continue;
2072
2073                         dbgi             = get_irn_dbg_info(pred);
2074                         trampoline       = get_trampoline(be, entity);
2075                         trampoline_const = new_rd_SymConst_addr_ent(dbgi, irg, mode_P_code,
2076                                                                     trampoline, NULL);
2077                         set_irn_n(node, i, trampoline_const);
2078                         continue;
2079                 }
2080
2081                 /* everything else is accessed relative to EIP */
2082                 mode     = get_irn_mode(pred);
2083                 unknown  = new_r_Unknown(irg, mode);
2084                 pic_base = arch_code_generator_get_pic_base(env->birg->cg);
2085
2086                 /* all ok now for locally constructed stuff */
2087                 if (can_address_relative(entity)) {
2088                         ir_node *add = new_r_Add(irg, block, pic_base, pred, mode);
2089
2090                         /* make sure the walker doesn't visit this add again */
2091                         mark_irn_visited(add);
2092                         set_irn_n(node, i, add);
2093                         continue;
2094                 }
2095
2096                 /* get entry from pic symbol segment */
2097                 dbgi         = get_irn_dbg_info(pred);
2098                 pic_symbol   = get_pic_symbol(be, entity);
2099                 pic_symconst = new_rd_SymConst_addr_ent(dbgi, irg, mode_P_code,
2100                                                         pic_symbol, NULL);
2101                 add = new_r_Add(irg, block, pic_base, pic_symconst, mode);
2102                 mark_irn_visited(add);
2103
2104                 /* we need an extra indirection for global data outside our current
2105                    module. The loads are always safe and can therefore float
2106                    and need no memory input */
2107                 load     = new_r_Load(irg, block, new_NoMem(), add, mode);
2108                 load_res = new_r_Proj(irg, block, load, mode, pn_Load_res);
2109                 set_irn_pinned(load, op_pin_state_floats);
2110
2111                 set_irn_n(node, i, load_res);
2112         }
2113 }
2114
2115 be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
2116 {
2117         be_abi_irg_t *env  = XMALLOC(be_abi_irg_t);
2118         ir_node *old_frame = get_irg_frame(birg->irg);
2119         ir_graph *irg      = birg->irg;
2120
2121         pmap_entry *ent;
2122         ir_node *dummy;
2123         optimization_state_t state;
2124         unsigned *limited_bitset;
2125
2126         be_omit_fp      = birg->main_env->options->omit_fp;
2127         be_omit_leaf_fp = birg->main_env->options->omit_leaf_fp;
2128
2129         obstack_init(&env->obst);
2130
2131         env->arch_env    = birg->main_env->arch_env;
2132         env->method_type = get_entity_type(get_irg_entity(irg));
2133         env->call        = be_abi_call_new(env->arch_env->sp->reg_class);
2134         arch_env_get_call_abi(env->arch_env, env->method_type, env->call);
2135
2136         env->ignore_regs  = pset_new_ptr_default();
2137         env->keep_map     = pmap_create();
2138         env->dce_survivor = new_survive_dce();
2139         env->birg         = birg;
2140
2141         env->sp_req.type    = arch_register_req_type_limited;
2142         env->sp_req.cls     = arch_register_get_class(env->arch_env->sp);
2143         limited_bitset      = rbitset_obstack_alloc(&env->obst, env->sp_req.cls->n_regs);
2144         rbitset_set(limited_bitset, arch_register_get_index(env->arch_env->sp));
2145         env->sp_req.limited = limited_bitset;
2146         if (env->arch_env->sp->type & arch_register_type_ignore) {
2147                 env->sp_req.type |= arch_register_req_type_ignore;
2148         }
2149
2150         env->sp_cls_req.type  = arch_register_req_type_normal;
2151         env->sp_cls_req.cls   = arch_register_get_class(env->arch_env->sp);
2152
2153         /* Beware: later we replace this node by the real one, ensure it is not CSE'd
2154            to another Unknown or the stack pointer gets used */
2155         save_optimization_state(&state);
2156         set_optimize(0);
2157         env->init_sp = dummy  = new_r_Unknown(irg, env->arch_env->sp->reg_class->mode);
2158         restore_optimization_state(&state);
2159
2160         FIRM_DBG_REGISTER(env->dbg, "firm.be.abi");
2161
2162         env->calls = NEW_ARR_F(ir_node*, 0);
2163
2164         if (birg->main_env->options->pic) {
2165                 irg_walk_graph(irg, fix_pic_symconsts, NULL, env);
2166         }
2167
2168         /* Lower all call nodes in the IRG. */
2169         process_calls(env);
2170
2171         /*
2172                 Beware: init backend abi call object after processing calls,
2173                 otherwise some information might be not yet available.
2174         */
2175         env->cb = env->call->cb->init(env->call, birg->main_env->arch_env, irg);
2176
2177         /* Process the IRG */
2178         modify_irg(env);
2179
2180         /* fix call inputs for state registers */
2181         fix_call_state_inputs(env);
2182
2183         /* We don't need the keep map anymore. */
2184         pmap_destroy(env->keep_map);
2185         env->keep_map = NULL;
2186
2187         /* calls array is not needed anymore */
2188         DEL_ARR_F(env->calls);
2189         env->calls = NULL;
2190
2191         /* reroute the stack origin of the calls to the true stack origin. */
2192         exchange(dummy, env->init_sp);
2193         exchange(old_frame, get_irg_frame(irg));
2194
2195         /* Make some important node pointers survive the dead node elimination. */
2196         survive_dce_register_irn(env->dce_survivor, &env->init_sp);
2197         foreach_pmap(env->regs, ent) {
2198                 survive_dce_register_irn(env->dce_survivor, (ir_node **) &ent->value);
2199         }
2200
2201         env->call->cb->done(env->cb);
2202         env->cb = NULL;
2203         return env;
2204 }
2205
2206 void be_abi_free(be_abi_irg_t *env)
2207 {
2208         be_abi_call_free(env->call);
2209         free_survive_dce(env->dce_survivor);
2210         del_pset(env->ignore_regs);
2211         pmap_destroy(env->regs);
2212         obstack_free(&env->obst, NULL);
2213         free(env);
2214 }
2215
2216 void be_abi_put_ignore_regs(be_abi_irg_t *abi, const arch_register_class_t *cls, bitset_t *bs)
2217 {
2218         arch_register_t *reg;
2219
2220         for (reg = pset_first(abi->ignore_regs); reg; reg = pset_next(abi->ignore_regs))
2221                 if (reg->reg_class == cls)
2222                         bitset_set(bs, reg->index);
2223 }
2224
2225 void be_abi_set_non_ignore_regs(be_abi_irg_t *abi, const arch_register_class_t *cls, unsigned *raw_bitset)
2226 {
2227         unsigned         i;
2228         arch_register_t *reg;
2229
2230         for (i = 0; i < cls->n_regs; ++i) {
2231                 if (arch_register_type_is(&cls->regs[i], ignore))
2232                         continue;
2233
2234                 rbitset_set(raw_bitset, i);
2235         }
2236
2237         for (reg = pset_first(abi->ignore_regs); reg != NULL;
2238              reg = pset_next(abi->ignore_regs)) {
2239                 if (reg->reg_class != cls)
2240                         continue;
2241
2242                 rbitset_clear(raw_bitset, reg->index);
2243         }
2244 }
2245
2246 /* Returns the stack layout from a abi environment. */
2247 const be_stack_layout_t *be_abi_get_stack_layout(const be_abi_irg_t *abi) {
2248         return &abi->frame;
2249 }
2250
2251 /*
2252
2253   _____ _        ____  _             _
2254  |  ___(_)_  __ / ___|| |_ __ _  ___| | __
2255  | |_  | \ \/ / \___ \| __/ _` |/ __| |/ /
2256  |  _| | |>  <   ___) | || (_| | (__|   <
2257  |_|   |_/_/\_\ |____/ \__\__,_|\___|_|\_\
2258
2259 */
2260
2261 typedef ir_node **node_array;
2262
2263 typedef struct fix_stack_walker_env_t {
2264         node_array sp_nodes;
2265 } fix_stack_walker_env_t;
2266
2267 /**
2268  * Walker. Collect all stack modifying nodes.
2269  */
2270 static void collect_stack_nodes_walker(ir_node *node, void *data)
2271 {
2272         fix_stack_walker_env_t    *env = data;
2273         const arch_register_req_t *req;
2274
2275         if (get_irn_mode(node) == mode_T)
2276                 return;
2277
2278         req = arch_get_register_req_out(node);
2279         if (! (req->type & arch_register_req_type_produces_sp))
2280                 return;
2281
2282         ARR_APP1(ir_node*, env->sp_nodes, node);
2283 }
2284
2285 void be_abi_fix_stack_nodes(be_abi_irg_t *env)
2286 {
2287         be_ssa_construction_env_t senv;
2288         int i, len;
2289         ir_node **phis;
2290         be_irg_t *birg = env->birg;
2291         be_lv_t *lv = be_get_birg_liveness(birg);
2292         fix_stack_walker_env_t walker_env;
2293
2294         walker_env.sp_nodes = NEW_ARR_F(ir_node*, 0);
2295
2296         irg_walk_graph(birg->irg, collect_stack_nodes_walker, NULL, &walker_env);
2297
2298         /* nothing to be done if we didn't find any node, in fact we mustn't
2299          * continue, as for endless loops incsp might have had no users and is bad
2300          * now.
2301          */
2302         len = ARR_LEN(walker_env.sp_nodes);
2303         if (len == 0) {
2304                 DEL_ARR_F(walker_env.sp_nodes);
2305                 return;
2306         }
2307
2308         be_ssa_construction_init(&senv, birg);
2309         be_ssa_construction_add_copies(&senv, walker_env.sp_nodes,
2310                                    ARR_LEN(walker_env.sp_nodes));
2311         be_ssa_construction_fix_users_array(&senv, walker_env.sp_nodes,
2312                                             ARR_LEN(walker_env.sp_nodes));
2313
2314         if (lv != NULL) {
2315                 len = ARR_LEN(walker_env.sp_nodes);
2316                 for (i = 0; i < len; ++i) {
2317                         be_liveness_update(lv, walker_env.sp_nodes[i]);
2318                 }
2319                 be_ssa_construction_update_liveness_phis(&senv, lv);
2320         }
2321
2322         phis = be_ssa_construction_get_new_phis(&senv);
2323
2324         /* set register requirements for stack phis */
2325         len = ARR_LEN(phis);
2326         for (i = 0; i < len; ++i) {
2327                 ir_node *phi = phis[i];
2328                 be_set_phi_reg_req(phi, &env->sp_req, arch_register_req_type_produces_sp);
2329                 arch_set_irn_register(phi, env->arch_env->sp);
2330         }
2331         be_ssa_construction_destroy(&senv);
2332
2333         DEL_ARR_F(walker_env.sp_nodes);
2334 }
2335
2336 /**
2337  * Fix all stack accessing operations in the block bl.
2338  *
2339  * @param env        the abi environment
2340  * @param bl         the block to process
2341  * @param real_bias  the bias value
2342  *
2343  * @return the bias at the end of this block
2344  */
2345 static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int real_bias)
2346 {
2347         int               omit_fp  = env->call->flags.bits.try_omit_fp;
2348         ir_node          *irn;
2349         int               wanted_bias = real_bias;
2350
2351         sched_foreach(bl, irn) {
2352                 int ofs;
2353
2354                 /*
2355                    Check, if the node relates to an entity on the stack frame.
2356                    If so, set the true offset (including the bias) for that
2357                    node.
2358                  */
2359                 ir_entity *ent = arch_get_frame_entity(irn);
2360                 if (ent) {
2361                         int bias   = omit_fp ? real_bias : 0;
2362                         int offset = get_stack_entity_offset(&env->frame, ent, bias);
2363                         arch_set_frame_offset(irn, offset);
2364                         DBG((env->dbg, LEVEL_2, "%F has offset %d (including bias %d)\n",
2365                              ent, offset, bias));
2366                 }
2367
2368                 /*
2369                  * If the node modifies the stack pointer by a constant offset,
2370                  * record that in the bias.
2371                  */
2372                 ofs = arch_get_sp_bias(irn);
2373
2374                 if (be_is_IncSP(irn)) {
2375                         /* fill in real stack frame size */
2376                         if (ofs == BE_STACK_FRAME_SIZE_EXPAND) {
2377                                 ir_type *frame_type = get_irg_frame_type(env->birg->irg);
2378                                 ofs = (int) get_type_size_bytes(frame_type);
2379                                 be_set_IncSP_offset(irn, ofs);
2380                         } else if (ofs == BE_STACK_FRAME_SIZE_SHRINK) {
2381                                 ir_type *frame_type = get_irg_frame_type(env->birg->irg);
2382                                 ofs = - (int)get_type_size_bytes(frame_type);
2383                                 be_set_IncSP_offset(irn, ofs);
2384                         } else {
2385                                 if (be_get_IncSP_align(irn)) {
2386                                         /* patch IncSP to produce an aligned stack pointer */
2387                                         ir_type *between_type = env->frame.between_type;
2388                                         int      between_size = get_type_size_bytes(between_type);
2389                                         int      alignment    = 1 << env->arch_env->stack_alignment;
2390                                         int      delta        = (real_bias + ofs + between_size) & (alignment - 1);
2391                                         assert(ofs >= 0);
2392                                         if (delta > 0) {
2393                                                 be_set_IncSP_offset(irn, ofs + alignment - delta);
2394                                                 real_bias += alignment - delta;
2395                                         }
2396                                 } else {
2397                                         /* adjust so real_bias corresponds with wanted_bias */
2398                                         int delta = wanted_bias - real_bias;
2399                                         assert(delta <= 0);
2400                                         if (delta != 0) {
2401                                                 be_set_IncSP_offset(irn, ofs + delta);
2402                                                 real_bias += delta;
2403                                         }
2404                                 }
2405                         }
2406                 }
2407
2408                 real_bias   += ofs;
2409                 wanted_bias += ofs;
2410         }
2411
2412         assert(real_bias == wanted_bias);
2413         return real_bias;
2414 }
2415
2416 /**
2417  * A helper struct for the bias walker.
2418  */
2419 struct bias_walk {
2420         be_abi_irg_t *env;     /**< The ABI irg environment. */
2421         int           start_block_bias;  /**< The bias at the end of the start block. */
2422         int           between_size;
2423         ir_node      *start_block;  /**< The start block of the current graph. */
2424 };
2425
2426 /**
2427  * Block-Walker: fix all stack offsets for all blocks
2428  * except the start block
2429  */
2430 static void stack_bias_walker(ir_node *bl, void *data)
2431 {
2432         struct bias_walk *bw = data;
2433         if (bl != bw->start_block) {
2434                 process_stack_bias(bw->env, bl, bw->start_block_bias);
2435         }
2436 }
2437
2438 void be_abi_fix_stack_bias(be_abi_irg_t *env)
2439 {
2440         ir_graph          *irg   = env->birg->irg;
2441         struct bias_walk  bw;
2442
2443         stack_frame_compute_initial_offset(&env->frame);
2444         // stack_layout_dump(stdout, frame);
2445
2446         /* Determine the stack bias at the end of the start block. */
2447         bw.start_block_bias = process_stack_bias(env, get_irg_start_block(irg), env->frame.initial_bias);
2448         bw.between_size     = get_type_size_bytes(env->frame.between_type);
2449
2450         /* fix the bias is all other blocks */
2451         bw.env = env;
2452         bw.start_block = get_irg_start_block(irg);
2453         irg_block_walk_graph(irg, stack_bias_walker, NULL, &bw);
2454 }
2455
2456 ir_node *be_abi_get_callee_save_irn(be_abi_irg_t *abi, const arch_register_t *reg)
2457 {
2458         assert(arch_register_type_is(reg, callee_save));
2459         assert(pmap_contains(abi->regs, (void *) reg));
2460         return pmap_get(abi->regs, (void *) reg);
2461 }
2462
2463 ir_node *be_abi_get_ignore_irn(be_abi_irg_t *abi, const arch_register_t *reg)
2464 {
2465         assert(arch_register_type_is(reg, ignore));
2466         assert(pmap_contains(abi->regs, (void *) reg));
2467         return pmap_get(abi->regs, (void *) reg);
2468 }
2469
2470 /**
2471  * Returns non-zero if the ABI has omitted the frame pointer in
2472  * the current graph.
2473  */
2474 int be_abi_omit_fp(const be_abi_irg_t *abi) {
2475         return abi->call->flags.bits.try_omit_fp;
2476 }