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, mode, 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, mode, 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
 914         /* we might need to multiply the size with the element size */
 915         if (type != firm_unknown_type && get_type_size_bytes(type) != 1) {
 916                 tarval *tv    = new_tarval_from_long(get_type_size_bytes(type),
 917                                                      mode_Iu);
 918                 ir_node *cnst = new_rd_Const(dbg, irg, mode_Iu, tv);
 919                 ir_node *mul  = new_rd_Mul(dbg, irg, block, get_Alloc_size(alloc),
 920                                            cnst, mode_Iu);
 921                 size = mul;
 922         } else {
 923                 size = get_Alloc_size(alloc);
 924         }
 925
 926         /* The stack pointer will be modified in an unknown manner.
 927            We cannot omit it. */
 928         env->call->flags.bits.try_omit_fp = 0;
 929
 930         stack_alignment = 1 << env->arch_env->stack_alignment;
 931         size            = adjust_alloc_size(stack_alignment, size, irg, block, dbg);
 932         new_alloc       = be_new_AddSP(env->arch_env->sp, irg, block, curr_sp, size);
 933         set_irn_dbg_info(new_alloc, dbg);
 934
 935         if(alloc_mem != NULL) {
 936                 ir_node *addsp_mem;
 937                 ir_node *sync;
 938
 939                 addsp_mem = new_r_Proj(irg, block, new_alloc, mode_M, pn_be_AddSP_M);
 940
 941                 /* We need to sync the output mem of the AddSP with the input mem
 942                    edge into the alloc node. */
 943                 ins[0] = get_Alloc_mem(alloc);
 944                 ins[1] = addsp_mem;
 945                 sync = new_r_Sync(irg, block, 2, ins);
 946
 947                 exchange(alloc_mem, sync);
 948         }
 949
 950         exchange(alloc, new_alloc);
 951
 952         /* fix projnum of alloca res */
 953         set_Proj_proj(alloc_res, pn_be_AddSP_res);
 954
 955         addr    = alloc_res;
 956         curr_sp = new_r_Proj(irg, block, new_alloc,  get_irn_mode(curr_sp),
 957                              pn_be_AddSP_sp);
 958
 959         return curr_sp;
 960 }  /* adjust_alloc */
 961
 962 /**
 963  * Adjust a Free.
 964  * The Free is transformed into a back end free node and connected to the stack nodes.
 965  */
 966 static ir_node *adjust_free(be_abi_irg_t *env, ir_node *free, ir_node *curr_sp)
 967 {
 968         ir_node *block;
 969         ir_graph *irg;
 970         ir_node *subsp, *mem, *res, *size, *sync;
 971         ir_type *type;
 972         ir_node *in[2];
 973         ir_mode *sp_mode;
 974         unsigned stack_alignment;
 975         dbg_info *dbg;
 976
 977         assert(get_Free_where(free) == stack_alloc);
 978
 979         block = get_nodes_block(free);
 980         irg = get_irn_irg(block);
 981         type = get_Free_type(free);
 982         sp_mode = env->arch_env->sp->reg_class->mode;
 983         dbg = get_irn_dbg_info(free);
 984
 985         /* we might need to multiply the size with the element size */
 986         if (type != firm_unknown_type && get_type_size_bytes(type) != 1) {
 987                 tarval *tv = new_tarval_from_long(get_type_size_bytes(type), mode_Iu);
 988                 ir_node *cnst = new_rd_Const(dbg, irg, mode_Iu, tv);
 989                 ir_node *mul = new_rd_Mul(dbg, irg, block, get_Free_size(free),
 990                                           cnst, mode_Iu);
 991                 size = mul;
 992         } else {
 993                 size = get_Free_size(free);
 994         }
 995
 996         stack_alignment = 1 << env->arch_env->stack_alignment;
 997         size            = adjust_alloc_size(stack_alignment, size, irg, block, dbg);
 998
 999         /* The stack pointer will be modified in an unknown manner.
1000            We cannot omit it. */
1001         env->call->flags.bits.try_omit_fp = 0;
1002         subsp = be_new_SubSP(env->arch_env->sp, irg, block, curr_sp, size);
1003         set_irn_dbg_info(subsp, dbg);
1004
1005         mem = new_r_Proj(irg, block, subsp, mode_M, pn_be_SubSP_M);
1006         res = new_r_Proj(irg, block, subsp, sp_mode, pn_be_SubSP_sp);
1007
1008         /* we need to sync the memory */
1009         in[0] = get_Free_mem(free);
1010         in[1] = mem;
1011         sync = new_r_Sync(irg, block, 2, in);
1012
1013         /* and make the AddSP dependent on the former memory */
1014         add_irn_dep(subsp, get_Free_mem(free));
1015
1016         /* kill the free */
1017         exchange(free, sync);
1018         curr_sp = res;
1019
1020         return curr_sp;
1021 }  /* adjust_free */
1022
1023 /* the following function is replaced by the usage of the heights module */
1024 #if 0
1025 /**
1026  * Walker for dependent_on().
1027  * This function searches a node tgt recursively from a given node
1028  * but is restricted to the given block.
1029  * @return 1 if tgt was reachable from curr, 0 if not.
1030  */
1031 static int check_dependence(ir_node *curr, ir_node *tgt, ir_node *bl)
1032 {
1033         int n, i;
1034
1035         if (get_nodes_block(curr) != bl)
1036                 return 0;
1037
1038         if (curr == tgt)
1039                 return 1;
1040
1041         /* Phi functions stop the recursion inside a basic block */
1042         if (! is_Phi(curr)) {
1043                 for(i = 0, n = get_irn_arity(curr); i < n; ++i) {
1044                         if (check_dependence(get_irn_n(curr, i), tgt, bl))
1045                                 return 1;
1046                 }
1047         }
1048
1049         return 0;
1050 }
1051 #endif /* if 0 */
1052
1053 /**
1054  * Check if a node is somehow data dependent on another one.
1055  * both nodes must be in the same basic block.
1056  * @param n1 The first node.
1057  * @param n2 The second node.
1058  * @return 1, if n1 is data dependent (transitively) on n2, 0 if not.
1059  */
1060 static int dependent_on(ir_node *n1, ir_node *n2)
1061 {
1062         assert(get_nodes_block(n1) == get_nodes_block(n2));
1063
1064         return heights_reachable_in_block(ir_heights, n1, n2);
1065 }
1066
1067 static int cmp_call_dependency(const void *c1, const void *c2)
1068 {
1069         ir_node *n1 = *(ir_node **) c1;
1070         ir_node *n2 = *(ir_node **) c2;
1071
1072         /*
1073                 Classical qsort() comparison function behavior:
1074                 0  if both elements are equal
1075                 1  if second is "smaller" that first
1076                 -1 if first is "smaller" that second
1077         */
1078         if (dependent_on(n1, n2))
1079                 return -1;
1080
1081         if (dependent_on(n2, n1))
1082                 return 1;
1083
1084         return 0;
1085 }
1086
1087 /**
1088  * Walker: links all Call/Alloc/Free nodes to the Block they are contained.
1089  * Clears the irg_is_leaf flag if a Call is detected.
1090  */
1091 static void link_ops_in_block_walker(ir_node *irn, void *data)
1092 {
1093         ir_opcode code = get_irn_opcode(irn);
1094
1095         if (code == iro_Call ||
1096            (code == iro_Alloc && get_Alloc_where(irn) == stack_alloc) ||
1097            (code == iro_Free && get_Free_where(irn) == stack_alloc)) {
1098                 be_abi_irg_t *env = data;
1099                 ir_node *bl       = get_nodes_block(irn);
1100                 void *save        = get_irn_link(bl);
1101
1102                 if (code == iro_Call)
1103                         env->call->flags.bits.irg_is_leaf = 0;
1104
1105                 set_irn_link(irn, save);
1106                 set_irn_link(bl, irn);
1107         }
1108 }
1109
1110 /**
1111  * Block-walker:
1112  * Process all Call/Alloc/Free nodes inside a basic block.
1113  * Note that the link field of the block must contain a linked list of all
1114  * Call nodes inside the Block. We first order this list according to data dependency
1115  * and that connect the calls together.
1116  */
1117 static void process_ops_in_block(ir_node *bl, void *data)
1118 {
1119         be_abi_irg_t *env = data;
1120         ir_node *curr_sp  = env->init_sp;
1121         ir_node *irn;
1122         int n;
1123
1124         for (irn = get_irn_link(bl), n = 0; irn; irn = get_irn_link(irn), ++n)
1125                 obstack_ptr_grow(&env->obst, irn);
1126
1127         /* If there were call nodes in the block. */
1128         if (n > 0) {
1129                 ir_node *keep;
1130                 ir_node **nodes;
1131                 int i;
1132
1133                 nodes = obstack_finish(&env->obst);
1134
1135                 /* order the call nodes according to data dependency */
1136                 qsort(nodes, n, sizeof(nodes[0]), cmp_call_dependency);
1137
1138                 for (i = n - 1; i >= 0; --i) {
1139                         ir_node *irn = nodes[i];
1140
1141                         DBG((env->dbg, LEVEL_3, "\tprocessing call %+F\n", irn));
1142                         switch (get_irn_opcode(irn)) {
1143                         case iro_Call:
1144                                 if (! be_omit_fp) {
1145                                         /* The stack pointer will be modified due to a call. */
1146                                         env->call->flags.bits.try_omit_fp = 0;
1147                                 }
1148                                 curr_sp = adjust_call(env, irn, curr_sp);
1149                                 break;
1150                         case iro_Alloc:
1151                                 if (get_Alloc_where(irn) == stack_alloc)
1152                                         curr_sp = adjust_alloc(env, irn, curr_sp);
1153                                 break;
1154                         case iro_Free:
1155                                 if (get_Free_where(irn) == stack_alloc)
1156                                         curr_sp = adjust_free(env, irn, curr_sp);
1157                                 break;
1158                         default:
1159                                 panic("invalid call");
1160                                 break;
1161                         }
1162                 }
1163
1164                 obstack_free(&env->obst, nodes);
1165
1166                 /* Keep the last stack state in the block by tying it to Keep node,
1167                  * the proj from calls is already kept */
1168                 if (curr_sp != env->init_sp &&
1169                     !(is_Proj(curr_sp) && be_is_Call(get_Proj_pred(curr_sp)))) {
1170                         nodes[0] = curr_sp;
1171                         keep     = be_new_Keep(env->arch_env->sp->reg_class,
1172                                                get_irn_irg(bl), bl, 1, nodes);
1173                         pmap_insert(env->keep_map, bl, keep);
1174                 }
1175         }
1176
1177         set_irn_link(bl, curr_sp);
1178 }  /* process_calls_in_block */
1179
1180 /**
1181  * Adjust all call nodes in the graph to the ABI conventions.
1182  */
1183 static void process_calls(be_abi_irg_t *env)
1184 {
1185         ir_graph *irg = env->birg->irg;
1186
1187         env->call->flags.bits.irg_is_leaf = 1;
1188         irg_walk_graph(irg, firm_clear_link, link_ops_in_block_walker, env);
1189
1190         ir_heights = heights_new(env->birg->irg);
1191         irg_block_walk_graph(irg, NULL, process_ops_in_block, env);
1192         heights_free(ir_heights);
1193 }
1194
1195 /**
1196  * Computes the stack argument layout type.
1197  * Changes a possibly allocated value param type by moving
1198  * entities to the stack layout type.
1199  *
1200  * @param env          the ABI environment
1201  * @param call         the current call ABI
1202  * @param method_type  the method type
1203  * @param param_map    an array mapping method arguments to the stack layout type
1204  *
1205  * @return the stack argument layout type
1206  */
1207 static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call, ir_type *method_type, ir_entity ***param_map)
1208 {
1209         int dir  = env->call->flags.bits.left_to_right ? 1 : -1;
1210         int inc  = env->birg->main_env->arch_env->stack_dir * dir;
1211         int n    = get_method_n_params(method_type);
1212         int curr = inc > 0 ? 0 : n - 1;
1213         int ofs  = 0;
1214
1215         char buf[128];
1216         ir_type *res;
1217         int i;
1218         ir_type *val_param_tp = get_method_value_param_type(method_type);
1219         ident *id = get_entity_ident(get_irg_entity(env->birg->irg));
1220         ir_entity **map;
1221
1222         *param_map = map = obstack_alloc(&env->obst, n * sizeof(ir_entity *));
1223         res = new_type_struct(id_mangle_u(id, new_id_from_chars("arg_type", 8)));
1224         for (i = 0; i < n; ++i, curr += inc) {
1225                 ir_type *param_type    = get_method_param_type(method_type, curr);
1226                 be_abi_call_arg_t *arg = get_call_arg(call, 0, curr);
1227
1228                 map[i] = NULL;
1229                 if (arg->on_stack) {
1230                         if (val_param_tp) {
1231                                 /* the entity was already created, move it to the param type */
1232                                 arg->stack_ent = get_method_value_param_ent(method_type, i);
1233                                 remove_struct_member(val_param_tp, arg->stack_ent);
1234                                 set_entity_owner(arg->stack_ent, res);
1235                                 add_struct_member(res, arg->stack_ent);
1236                                 /* must be automatic to set a fixed layout */
1237                                 set_entity_allocation(arg->stack_ent, allocation_automatic);
1238                         }
1239                         else {
1240                                 snprintf(buf, sizeof(buf), "param_%d", i);
1241                                 arg->stack_ent = new_entity(res, new_id_from_str(buf), param_type);
1242                         }
1243                         ofs += arg->space_before;
1244                         ofs = round_up2(ofs, arg->alignment);
1245                         set_entity_offset(arg->stack_ent, ofs);
1246                         ofs += arg->space_after;
1247                         ofs += get_type_size_bytes(param_type);
1248                         map[i] = arg->stack_ent;
1249                 }
1250         }
1251         set_type_size_bytes(res, ofs);
1252         set_type_state(res, layout_fixed);
1253         return res;
1254 }
1255
1256 typedef struct {
1257         const arch_register_t *reg;
1258         ir_node *irn;
1259 } reg_node_map_t;
1260
1261 static int cmp_regs(const void *a, const void *b)
1262 {
1263         const reg_node_map_t *p = a;
1264         const reg_node_map_t *q = b;
1265
1266         if(p->reg->reg_class == q->reg->reg_class)
1267                 return p->reg->index - q->reg->index;
1268         else
1269                 return p->reg->reg_class - q->reg->reg_class;
1270 }
1271
1272 static reg_node_map_t *reg_map_to_arr(struct obstack *obst, pmap *reg_map)
1273 {
1274         pmap_entry *ent;
1275         int n = pmap_count(reg_map);
1276         int i = 0;
1277         reg_node_map_t *res = obstack_alloc(obst, n * sizeof(res[0]));
1278
1279         foreach_pmap(reg_map, ent) {
1280                 res[i].reg = ent->key;
1281                 res[i].irn = ent->value;
1282                 i++;
1283         }
1284
1285         qsort(res, n, sizeof(res[0]), cmp_regs);
1286         return res;
1287 }
1288
1289 /**
1290  * Creates a barrier.
1291  */
1292 static ir_node *create_barrier(be_abi_irg_t *env, ir_node *bl, ir_node **mem, pmap *regs, int in_req)
1293 {
1294         ir_graph *irg = env->birg->irg;
1295         int n_regs    = pmap_count(regs);
1296         int n;
1297         ir_node *irn;
1298         ir_node **in;
1299         reg_node_map_t *rm;
1300
1301         rm = reg_map_to_arr(&env->obst, regs);
1302
1303         for (n = 0; n < n_regs; ++n)
1304                 obstack_ptr_grow(&env->obst, rm[n].irn);
1305
1306         if (mem) {
1307                 obstack_ptr_grow(&env->obst, *mem);
1308                 n++;
1309         }
1310
1311         in = (ir_node **) obstack_finish(&env->obst);
1312         irn = be_new_Barrier(irg, bl, n, in);
1313         obstack_free(&env->obst, in);
1314
1315         for(n = 0; n < n_regs; ++n) {
1316                 ir_node                   *pred     = rm[n].irn;
1317                 const arch_register_t     *reg      = rm[n].reg;
1318                 arch_register_type_t       add_type = 0;
1319                 ir_node                   *proj;
1320
1321                 /* stupid workaround for now... as not all nodes report register
1322                  * requirements. */
1323                 if (!is_Phi(pred)) {
1324                         const arch_register_req_t *ireq = arch_get_register_req_out(pred);
1325                         if (ireq->type & arch_register_req_type_ignore)
1326                                 add_type |= arch_register_req_type_ignore;
1327                         if (ireq->type & arch_register_req_type_produces_sp)
1328                                 add_type |= arch_register_req_type_produces_sp;
1329                 }
1330
1331                 proj = new_r_Proj(irg, bl, irn, get_irn_mode(pred), n);
1332                 be_node_set_reg_class_in(irn, n, reg->reg_class);
1333                 if (in_req)
1334                         be_set_constr_single_reg_in(irn, n, reg, 0);
1335                 be_set_constr_single_reg_out(irn, n, reg, add_type);
1336                 arch_set_irn_register(proj, reg);
1337
1338                 pmap_insert(regs, (void *) reg, proj);
1339         }
1340
1341         if (mem) {
1342                 *mem = new_r_Proj(irg, bl, irn, mode_M, n);
1343         }
1344
1345         obstack_free(&env->obst, rm);
1346         return irn;
1347 }
1348
1349 /**
1350  * Creates a be_Return for a Return node.
1351  *
1352  * @param @env    the abi environment
1353  * @param irn     the Return node or NULL if there was none
1354  * @param bl      the block where the be_Retun should be placed
1355  * @param mem     the current memory
1356  * @param n_res   number of return results
1357  */
1358 static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl,
1359                 ir_node *mem, int n_res)
1360 {
1361         be_abi_call_t    *call     = env->call;
1362         const arch_env_t *arch_env = env->birg->main_env->arch_env;
1363         dbg_info *dbgi;
1364         pmap *reg_map  = pmap_create();
1365         ir_node *keep  = pmap_get(env->keep_map, bl);
1366         int in_max;
1367         ir_node *ret;
1368         int i, n;
1369         unsigned pop;
1370         ir_node **in;
1371         ir_node *stack;
1372         const arch_register_t **regs;
1373         pmap_entry *ent ;
1374
1375         /*
1376                 get the valid stack node in this block.
1377                 If we had a call in that block there is a Keep constructed by process_calls()
1378                 which points to the last stack modification in that block. we'll use
1379                 it then. Else we use the stack from the start block and let
1380                 the ssa construction fix the usage.
1381         */
1382         stack = be_abi_reg_map_get(env->regs, arch_env->sp);
1383         if (keep) {
1384                 stack = get_irn_n(keep, 0);
1385                 kill_node(keep);
1386                 remove_End_keepalive(get_irg_end(env->birg->irg), keep);
1387         }
1388
1389         /* Insert results for Return into the register map. */
1390         for (i = 0; i < n_res; ++i) {
1391                 ir_node *res           = get_Return_res(irn, i);
1392                 be_abi_call_arg_t *arg = get_call_arg(call, 1, i);
1393                 assert(arg->in_reg && "return value must be passed in register");
1394                 pmap_insert(reg_map, (void *) arg->reg, res);
1395         }
1396
1397         /* Add uses of the callee save registers. */
1398         foreach_pmap(env->regs, ent) {
1399                 const arch_register_t *reg = ent->key;
1400                 if(arch_register_type_is(reg, callee_save) || arch_register_type_is(reg, ignore))
1401                         pmap_insert(reg_map, ent->key, ent->value);
1402         }
1403
1404         be_abi_reg_map_set(reg_map, arch_env->sp, stack);
1405
1406         /* Make the Epilogue node and call the arch's epilogue maker. */
1407         create_barrier(env, bl, &mem, reg_map, 1);
1408         call->cb->epilogue(env->cb, bl, &mem, reg_map);
1409
1410         /*
1411                 Maximum size of the in array for Return nodes is
1412                 return args + callee save/ignore registers + memory + stack pointer
1413         */
1414         in_max = pmap_count(reg_map) + n_res + 2;
1415
1416         in   = obstack_alloc(&env->obst, in_max * sizeof(in[0]));
1417         regs = obstack_alloc(&env->obst, in_max * sizeof(regs[0]));
1418
1419         in[0]   = mem;
1420         in[1]   = be_abi_reg_map_get(reg_map, arch_env->sp);
1421         regs[0] = NULL;
1422         regs[1] = arch_env->sp;
1423         n       = 2;
1424
1425         /* clear SP entry, since it has already been grown. */
1426         pmap_insert(reg_map, (void *) arch_env->sp, NULL);
1427         for (i = 0; i < n_res; ++i) {
1428                 be_abi_call_arg_t *arg = get_call_arg(call, 1, i);
1429
1430                 in[n]     = be_abi_reg_map_get(reg_map, arg->reg);
1431                 regs[n++] = arg->reg;
1432
1433                 /* Clear the map entry to mark the register as processed. */
1434                 be_abi_reg_map_set(reg_map, arg->reg, NULL);
1435         }
1436
1437         /* grow the rest of the stuff. */
1438         foreach_pmap(reg_map, ent) {
1439                 if (ent->value) {
1440                         in[n]     = ent->value;
1441                         regs[n++] = ent->key;
1442                 }
1443         }
1444
1445         /* The in array for the new back end return is now ready. */
1446         if (irn != NULL) {
1447                 dbgi = get_irn_dbg_info(irn);
1448         } else {
1449                 dbgi = NULL;
1450         }
1451         /* we have to pop the shadow parameter in in case of struct returns */
1452         pop = call->pop;
1453         ret = be_new_Return(dbgi, env->birg->irg, bl, n_res, pop, n, in);
1454
1455         /* Set the register classes of the return's parameter accordingly. */
1456         for (i = 0; i < n; ++i) {
1457                 if (regs[i] == NULL)
1458                         continue;
1459
1460                 be_node_set_reg_class_in(ret, i, regs[i]->reg_class);
1461         }
1462
1463         /* Free the space of the Epilog's in array and the register <-> proj map. */
1464         obstack_free(&env->obst, in);
1465         pmap_destroy(reg_map);
1466
1467         return ret;
1468 }
1469
1470 typedef struct lower_frame_sels_env_t {
1471         be_abi_irg_t *env;
1472         ir_entity    *value_param_list;  /**< the list of all value param entities */
1473         ir_entity    *value_param_tail;  /**< the tail of the list of all value param entities */
1474 } lower_frame_sels_env_t;
1475
1476 /**
1477  * Walker: Replaces Sels of frame type and
1478  * value param type entities by FrameAddress.
1479  * Links all used entities.
1480  */
1481 static void lower_frame_sels_walker(ir_node *irn, void *data) {
1482         lower_frame_sels_env_t *ctx = data;
1483
1484         if (is_Sel(irn)) {
1485                 ir_graph *irg        = current_ir_graph;
1486                 ir_node  *frame      = get_irg_frame(irg);
1487                 ir_node  *param_base = get_irg_value_param_base(irg);
1488                 ir_node  *ptr        = get_Sel_ptr(irn);
1489
1490                 if (ptr == frame || ptr == param_base) {
1491                         be_abi_irg_t *env = ctx->env;
1492                         ir_entity    *ent = get_Sel_entity(irn);
1493                         ir_node      *bl  = get_nodes_block(irn);
1494                         ir_node      *nw;
1495
1496                         nw = be_new_FrameAddr(env->arch_env->sp->reg_class, irg, bl, frame, ent);
1497                         exchange(irn, nw);
1498
1499                         /* check, if it's a param sel and if have not seen this entity before */
1500                         if (ptr == param_base &&
1501                             ent != ctx->value_param_tail &&
1502                             get_entity_link(ent) == NULL) {
1503                                 set_entity_link(ent, ctx->value_param_list);
1504                                 ctx->value_param_list = ent;
1505                                 if (ctx->value_param_tail == NULL) ctx->value_param_tail = ent;
1506                         }
1507                 }
1508         }
1509 }
1510
1511 /**
1512  * Check if a value parameter is transmitted as a register.
1513  * This might happen if the address of an parameter is taken which is
1514  * transmitted in registers.
1515  *
1516  * Note that on some architectures this case must be handled specially
1517  * because the place of the backing store is determined by their ABI.
1518  *
1519  * In the default case we move the entity to the frame type and create
1520  * a backing store into the first block.
1521  */
1522 static void fix_address_of_parameter_access(be_abi_irg_t *env, ir_entity *value_param_list) {
1523         be_abi_call_t *call = env->call;
1524         ir_graph *irg       = env->birg->irg;
1525         ir_entity *ent, *next_ent, *new_list;
1526         ir_type *frame_tp;
1527         DEBUG_ONLY(firm_dbg_module_t *dbg = env->dbg;)
1528
1529         new_list = NULL;
1530         for (ent = value_param_list; ent; ent = next_ent) {
1531                 int i = get_struct_member_index(get_entity_owner(ent), ent);
1532                 be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
1533
1534                 next_ent = get_entity_link(ent);
1535                 if (arg->in_reg) {
1536                         DBG((dbg, LEVEL_2, "\targ #%d need backing store\n", i));
1537                         set_entity_link(ent, new_list);
1538                         new_list = ent;
1539                 }
1540         }
1541         if (new_list) {
1542                 /* ok, change the graph */
1543                 ir_node *start_bl = get_irg_start_block(irg);
1544                 ir_node *first_bl = NULL;
1545                 ir_node *frame, *imem, *nmem, *store, *mem, *args, *args_bl;
1546                 const ir_edge_t *edge;
1547                 optimization_state_t state;
1548                 unsigned offset;
1549
1550                 foreach_block_succ(start_bl, edge) {
1551                         ir_node *succ = get_edge_src_irn(edge);
1552                         if (start_bl != succ) {
1553                                 first_bl = succ;
1554                                 break;
1555                         }
1556                 }
1557                 assert(first_bl);
1558                 /* we had already removed critical edges, so the following
1559                    assertion should be always true. */
1560                 assert(get_Block_n_cfgpreds(first_bl) == 1);
1561
1562                 /* now create backing stores */
1563                 frame = get_irg_frame(irg);
1564                 imem = get_irg_initial_mem(irg);
1565
1566                 save_optimization_state(&state);
1567                 set_optimize(0);
1568                 nmem = new_r_Proj(irg, first_bl, get_irg_start(irg), mode_M, pn_Start_M);
1569                 restore_optimization_state(&state);
1570
1571                 /* reroute all edges to the new memory source */
1572                 edges_reroute(imem, nmem, irg);
1573
1574                 store   = NULL;
1575                 mem     = imem;
1576                 args    = get_irg_args(irg);
1577                 args_bl = get_nodes_block(args);
1578                 for (ent = new_list; ent; ent = get_entity_link(ent)) {
1579                         int     i     = get_struct_member_index(get_entity_owner(ent), ent);
1580                         ir_type *tp   = get_entity_type(ent);
1581                         ir_mode *mode = get_type_mode(tp);
1582                         ir_node *addr;
1583
1584                         /* address for the backing store */
1585                         addr = be_new_FrameAddr(env->arch_env->sp->reg_class, irg, first_bl, frame, ent);
1586
1587                         if (store)
1588                                 mem = new_r_Proj(irg, first_bl, store, mode_M, pn_Store_M);
1589
1590                         /* the backing store itself */
1591                         store = new_r_Store(irg, first_bl, mem, addr,
1592                                             new_r_Proj(irg, args_bl, args, mode, i));
1593                 }
1594                 /* the new memory Proj gets the last Proj from store */
1595                 set_Proj_pred(nmem, store);
1596                 set_Proj_proj(nmem, pn_Store_M);
1597
1598                 /* move all entities to the frame type */
1599                 frame_tp = get_irg_frame_type(irg);
1600                 offset   = get_type_size_bytes(frame_tp);
1601
1602                 /* we will add new entities: set the layout to undefined */
1603                 assert(get_type_state(frame_tp) == layout_fixed);
1604                 set_type_state(frame_tp, layout_undefined);
1605                 for (ent = new_list; ent; ent = get_entity_link(ent)) {
1606                         ir_type  *tp   = get_entity_type(ent);
1607                         unsigned align = get_type_alignment_bytes(tp);
1608
1609                         offset += align - 1;
1610                         offset &= ~(align - 1);
1611                         set_entity_owner(ent, frame_tp);
1612                         add_class_member(frame_tp, ent);
1613                         /* must be automatic to set a fixed layout */
1614                         set_entity_allocation(ent, allocation_automatic);
1615                         set_entity_offset(ent, offset);
1616                         offset += get_type_size_bytes(tp);
1617                 }
1618                 set_type_size_bytes(frame_tp, offset);
1619                 /* fix the layout again */
1620                 set_type_state(frame_tp, layout_fixed);
1621         }
1622 }
1623
1624 #if 1
1625 /**
1626  * The start block has no jump, instead it has an initial exec Proj.
1627  * The backend wants to handle all blocks the same way, so we replace
1628  * the out cfg edge with a real jump.
1629  */
1630 static void fix_start_block(ir_node *block, void *env) {
1631         int      *done = env;
1632         int      i;
1633         ir_node  *start_block;
1634         ir_graph *irg;
1635
1636         /* we processed the start block, return */
1637         if (*done)
1638                 return;
1639
1640         irg         = get_irn_irg(block);
1641         start_block = get_irg_start_block(irg);
1642
1643         for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) {
1644                 ir_node *pred       = get_Block_cfgpred(block, i);
1645                 ir_node *pred_block = get_nodes_block(pred);
1646
1647                 /* ok, we are in the block, having start as cfg predecessor */
1648                 if (pred_block == start_block) {
1649                         ir_node *jump = new_r_Jmp(irg, pred_block);
1650                         set_Block_cfgpred(block, i, jump);
1651                         *done = 1;
1652                 }
1653         }
1654 }
1655 #endif
1656
1657 /**
1658  * Modify the irg itself and the frame type.
1659  */
1660 static void modify_irg(be_abi_irg_t *env)
1661 {
1662         be_abi_call_t *call       = env->call;
1663         const arch_env_t *arch_env= env->birg->main_env->arch_env;
1664         const arch_register_t *sp = arch_env_sp(arch_env);
1665         ir_graph *irg             = env->birg->irg;
1666         ir_node *start_bl;
1667         ir_node *end;
1668         ir_node *old_mem;
1669         ir_node *new_mem_proj;
1670         ir_node *mem;
1671         ir_type *method_type      = get_entity_type(get_irg_entity(irg));
1672
1673         int n_params;
1674         int i, n;
1675         unsigned j;
1676
1677         reg_node_map_t *rm;
1678         const arch_register_t *fp_reg;
1679         ir_node *frame_pointer;
1680         ir_node *reg_params_bl;
1681         ir_node **args;
1682         ir_node *arg_tuple;
1683         ir_node *value_param_base;
1684         const ir_edge_t *edge;
1685         ir_type *arg_type, *bet_type, *tp;
1686         lower_frame_sels_env_t ctx;
1687         ir_entity **param_map;
1688
1689         bitset_t *used_proj_nr;
1690         DEBUG_ONLY(firm_dbg_module_t *dbg = env->dbg;)
1691
1692         DBG((dbg, LEVEL_1, "introducing abi on %+F\n", irg));
1693
1694         /* Must fetch memory here, otherwise the start Barrier gets the wrong
1695          * memory, which leads to loops in the DAG. */
1696         old_mem = get_irg_initial_mem(irg);
1697
1698         irp_reserve_resources(irp, IR_RESOURCE_ENTITY_LINK);
1699         /* set the links of all frame entities to NULL, we use it
1700            to detect if an entity is already linked in the value_param_list */
1701         tp = get_method_value_param_type(method_type);
1702         if (tp != NULL) {
1703                 for (i = get_struct_n_members(tp) - 1; i >= 0; --i)
1704                         set_entity_link(get_struct_member(tp, i), NULL);
1705         }
1706
1707         /* Convert the Sel nodes in the irg to frame load/store/addr nodes. */
1708         ctx.env              = env;
1709         ctx.value_param_list = NULL;
1710         ctx.value_param_tail = NULL;
1711         irg_walk_graph(irg, lower_frame_sels_walker, NULL, &ctx);
1712
1713         /* value_param_base anchor is not needed anymore now */
1714         value_param_base = get_irg_value_param_base(irg);
1715         kill_node(value_param_base);
1716         set_irg_value_param_base(irg, new_r_Bad(irg));
1717
1718         env->regs  = pmap_create();
1719
1720         used_proj_nr = bitset_alloca(1024);
1721         n_params     = get_method_n_params(method_type);
1722         args         = obstack_alloc(&env->obst, n_params * sizeof(args[0]));
1723         memset(args, 0, n_params * sizeof(args[0]));
1724
1725         /* Check if a value parameter is transmitted as a register.
1726          * This might happen if the address of an parameter is taken which is
1727          * transmitted in registers.
1728          *
1729          * Note that on some architectures this case must be handled specially
1730          * because the place of the backing store is determined by their ABI.
1731          *
1732          * In the default case we move the entity to the frame type and create
1733          * a backing store into the first block.
1734          */
1735         fix_address_of_parameter_access(env, ctx.value_param_list);
1736         irp_free_resources(irp, IR_RESOURCE_ENTITY_LINK);
1737
1738         /* Fill the argument vector */
1739         arg_tuple = get_irg_args(irg);
1740         foreach_out_edge(arg_tuple, edge) {
1741                 ir_node *irn = get_edge_src_irn(edge);
1742                 if (! is_Anchor(irn)) {
1743                         int nr       = get_Proj_proj(irn);
1744                         args[nr]     = irn;
1745                         DBG((dbg, LEVEL_2, "\treading arg: %d -> %+F\n", nr, irn));
1746                 }
1747         }
1748
1749         arg_type = compute_arg_type(env, call, method_type, &param_map);
1750         bet_type = call->cb->get_between_type(env->cb);
1751         stack_frame_init(&env->frame, arg_type, bet_type, get_irg_frame_type(irg), arch_env->stack_dir, param_map);
1752
1753         /* Count the register params and add them to the number of Projs for the RegParams node */
1754         for (i = 0; i < n_params; ++i) {
1755                 be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
1756                 if (arg->in_reg && args[i]) {
1757                         assert(arg->reg != sp && "cannot use stack pointer as parameter register");
1758                         assert(i == get_Proj_proj(args[i]));
1759
1760                         /* For now, associate the register with the old Proj from Start representing that argument. */
1761                         pmap_insert(env->regs, (void *) arg->reg, args[i]);
1762                         bitset_set(used_proj_nr, i);
1763                         DBG((dbg, LEVEL_2, "\targ #%d -> reg %s\n", i, arg->reg->name));
1764                 }
1765         }
1766
1767         /* Collect all callee-save registers */
1768         for (i = 0, n = arch_env_get_n_reg_class(arch_env); i < n; ++i) {
1769                 const arch_register_class_t *cls = arch_env_get_reg_class(arch_env, i);
1770                 for (j = 0; j < cls->n_regs; ++j) {
1771                         const arch_register_t *reg = &cls->regs[j];
1772                         if (arch_register_type_is(reg, callee_save) ||
1773                                         arch_register_type_is(reg, state)) {
1774                                 pmap_insert(env->regs, (void *) reg, NULL);
1775                         }
1776                 }
1777         }
1778
1779         pmap_insert(env->regs, (void *) sp, NULL);
1780         pmap_insert(env->regs, (void *) arch_env->bp, NULL);
1781         reg_params_bl   = get_irg_start_block(irg);
1782         env->reg_params = be_new_RegParams(irg, reg_params_bl, pmap_count(env->regs));
1783         add_irn_dep(env->reg_params, get_irg_start(irg));
1784
1785         /*
1786          * make proj nodes for the callee save registers.
1787          * memorize them, since Return nodes get those as inputs.
1788          *
1789          * Note, that if a register corresponds to an argument, the regs map contains
1790          * the old Proj from start for that argument.
1791          */
1792
1793         rm = reg_map_to_arr(&env->obst, env->regs);
1794         for (i = 0, n = pmap_count(env->regs); i < n; ++i) {
1795                 arch_register_t          *reg      = (void *) rm[i].reg;
1796                 ir_mode                  *mode     = reg->reg_class->mode;
1797                 long                      nr       = i;
1798                 arch_register_req_type_t  add_type = 0;
1799                 ir_node                  *proj;
1800
1801                 if (reg == sp)
1802                         add_type |= arch_register_req_type_produces_sp | arch_register_req_type_ignore;
1803
1804                 assert(nr >= 0);
1805                 bitset_set(used_proj_nr, nr);
1806                 proj = new_r_Proj(irg, reg_params_bl, env->reg_params, mode, nr);
1807                 pmap_insert(env->regs, (void *) reg, proj);
1808                 be_set_constr_single_reg_out(env->reg_params, nr, reg, add_type);
1809                 arch_set_irn_register(proj, reg);
1810
1811                 DBG((dbg, LEVEL_2, "\tregister save proj #%d -> reg %s\n", nr, reg->name));
1812         }
1813         obstack_free(&env->obst, rm);
1814
1815         /* create a new initial memory proj */
1816         assert(is_Proj(old_mem));
1817         new_mem_proj = new_r_Proj(irg, get_nodes_block(old_mem),
1818                                   new_r_Unknown(irg, mode_T), mode_M,
1819                                   get_Proj_proj(old_mem));
1820         mem = new_mem_proj;
1821
1822         /* Generate the Prologue */
1823         fp_reg = call->cb->prologue(env->cb, &mem, env->regs, &env->frame.initial_bias);
1824
1825         /* do the stack allocation BEFORE the barrier, or spill code
1826            might be added before it */
1827         env->init_sp = be_abi_reg_map_get(env->regs, sp);
1828         start_bl     = get_irg_start_block(irg);
1829         env->init_sp = be_new_IncSP(sp, irg, start_bl, env->init_sp, BE_STACK_FRAME_SIZE_EXPAND, 0);
1830         be_abi_reg_map_set(env->regs, sp, env->init_sp);
1831
1832         create_barrier(env, start_bl, &mem, env->regs, 0);
1833
1834         env->init_sp = be_abi_reg_map_get(env->regs, sp);
1835         arch_set_irn_register(env->init_sp, sp);
1836
1837         frame_pointer = be_abi_reg_map_get(env->regs, fp_reg);
1838         set_irg_frame(irg, frame_pointer);
1839         pset_insert_ptr(env->ignore_regs, fp_reg);
1840
1841         /* rewire old mem users to new mem */
1842         set_Proj_pred(new_mem_proj, get_Proj_pred(old_mem));
1843         exchange(old_mem, mem);
1844
1845         set_irg_initial_mem(irg, mem);
1846
1847         /* Now, introduce stack param nodes for all parameters passed on the stack */
1848         for (i = 0; i < n_params; ++i) {
1849                 ir_node *arg_proj = args[i];
1850                 ir_node *repl     = NULL;
1851
1852                 if (arg_proj != NULL) {
1853                         be_abi_call_arg_t *arg;
1854                         ir_type *param_type;
1855                         int     nr = get_Proj_proj(arg_proj);
1856                         ir_mode *mode;
1857
1858                         nr         = MIN(nr, n_params);
1859                         arg        = get_call_arg(call, 0, nr);
1860                         param_type = get_method_param_type(method_type, nr);
1861
1862                         if (arg->in_reg) {
1863                                 repl = pmap_get(env->regs, (void *) arg->reg);
1864                         } else if (arg->on_stack) {
1865                                 ir_node *addr = be_new_FrameAddr(sp->reg_class, irg, reg_params_bl, frame_pointer, arg->stack_ent);
1866
1867                                 /* For atomic parameters which are actually used, we create a Load node. */
1868                                 if(is_atomic_type(param_type) && get_irn_n_edges(args[i]) > 0) {
1869                                         ir_mode *mode      = get_type_mode(param_type);
1870                                         ir_mode *load_mode = arg->load_mode;
1871
1872                                         ir_node *load = new_r_Load(irg, reg_params_bl, new_NoMem(), addr, load_mode);
1873                                         set_irn_pinned(load, op_pin_state_floats);
1874                                         repl = new_r_Proj(irg, reg_params_bl, load, load_mode, pn_Load_res);
1875
1876                                         if (mode != load_mode) {
1877                                                 repl = new_r_Conv(irg, reg_params_bl, repl, mode);
1878                                         }
1879                                 } else {
1880                                         /* The stack parameter is not primitive (it is a struct or array),
1881                                          * we thus will create a node representing the parameter's address
1882                                          * on the stack. */
1883                                         repl = addr;
1884                                 }
1885                         }
1886
1887                         assert(repl != NULL);
1888
1889                         /* Beware: the mode of the register parameters is always the mode of the register class
1890                            which may be wrong. Add Conv's then. */
1891                         mode = get_irn_mode(args[i]);
1892                         if (mode != get_irn_mode(repl)) {
1893                                 repl = new_r_Conv(irg, get_irn_n(repl, -1), repl, mode);
1894                         }
1895                         exchange(args[i], repl);
1896                 }
1897         }
1898
1899         /* the arg proj is not needed anymore now and should be only used by the anchor */
1900         assert(get_irn_n_edges(arg_tuple) == 1);
1901         kill_node(arg_tuple);
1902         set_irg_args(irg, new_r_Bad(irg));
1903
1904         /* All Return nodes hang on the End node, so look for them there. */
1905         end = get_irg_end_block(irg);
1906         for (i = 0, n = get_Block_n_cfgpreds(end); i < n; ++i) {
1907                 ir_node *irn = get_Block_cfgpred(end, i);
1908
1909                 if (is_Return(irn)) {
1910                         ir_node *blk = get_nodes_block(irn);
1911                         ir_node *mem = get_Return_mem(irn);
1912                         ir_node *ret = create_be_return(env, irn, blk, mem, get_Return_n_ress(irn));
1913                         exchange(irn, ret);
1914                 }
1915         }
1916         /* if we have endless loops here, n might be <= 0. Do NOT create a be_Return then,
1917            the code is dead and will never be executed. */
1918
1919         obstack_free(&env->obst, args);
1920
1921         /* handle start block here (place a jump in the block) */
1922         i = 0;
1923         irg_block_walk_graph(irg, fix_start_block, NULL, &i);
1924 }
1925
1926 /** Fix the state inputs of calls that still hang on unknowns */
1927 static
1928 void fix_call_state_inputs(be_abi_irg_t *env)
1929 {
1930         const arch_env_t *arch_env = env->arch_env;
1931         int i, n, n_states;
1932         arch_register_t **stateregs = NEW_ARR_F(arch_register_t*, 0);
1933
1934         /* Collect caller save registers */
1935         n = arch_env_get_n_reg_class(arch_env);
1936         for (i = 0; i < n; ++i) {
1937                 unsigned j;
1938                 const arch_register_class_t *cls = arch_env_get_reg_class(arch_env, i);
1939                 for (j = 0; j < cls->n_regs; ++j) {
1940                         const arch_register_t *reg = arch_register_for_index(cls, j);
1941                         if (arch_register_type_is(reg, state)) {
1942                                 ARR_APP1(arch_register_t*, stateregs, (arch_register_t *)reg);
1943                         }
1944                 }
1945         }
1946
1947         n = ARR_LEN(env->calls);
1948         n_states = ARR_LEN(stateregs);
1949         for (i = 0; i < n; ++i) {
1950                 int s, arity;
1951                 ir_node *call = env->calls[i];
1952
1953                 arity = get_irn_arity(call);
1954
1955                 /* the state reg inputs are the last n inputs of the calls */
1956                 for (s = 0; s < n_states; ++s) {
1957                         int inp = arity - n_states + s;
1958                         const arch_register_t *reg = stateregs[s];
1959                         ir_node *regnode = be_abi_reg_map_get(env->regs, reg);
1960
1961                         set_irn_n(call, inp, regnode);
1962                 }
1963         }
1964
1965         DEL_ARR_F(stateregs);
1966 }
1967
1968 /**
1969  * Create a trampoline entity for the given method.
1970  */
1971 static ir_entity *create_trampoline(be_main_env_t *be, ir_entity *method)
1972 {
1973         ir_type   *type   = get_entity_type(method);
1974         ident     *old_id = get_entity_ld_ident(method);
1975         ident     *id     = id_mangle3("L", old_id, "$stub");
1976         ir_type   *parent = be->pic_trampolines_type;
1977         ir_entity *ent    = new_entity(parent, old_id, type);
1978         set_entity_ld_ident(ent, id);
1979         set_entity_visibility(ent, visibility_local);
1980         set_entity_variability(ent, variability_uninitialized);
1981
1982         return ent;
1983 }
1984
1985 /**
1986  * Returns the trampoline entity for the given method.
1987  */
1988 static ir_entity *get_trampoline(be_main_env_t *env, ir_entity *method)
1989 {
1990         ir_entity *result = pmap_get(env->ent_trampoline_map, method);
1991         if (result == NULL) {
1992                 result = create_trampoline(env, method);
1993                 pmap_insert(env->ent_trampoline_map, method, result);
1994         }
1995
1996         return result;
1997 }
1998
1999 static ir_entity *create_pic_symbol(be_main_env_t *be, ir_entity *entity)
2000 {
2001         ident     *old_id = get_entity_ld_ident(entity);
2002         ident     *id     = id_mangle3("L", old_id, "$non_lazy_ptr");
2003         ir_type   *e_type = get_entity_type(entity);
2004         ir_type   *type   = new_type_pointer(id, e_type, mode_P_data);
2005         ir_type   *parent = be->pic_symbols_type;
2006         ir_entity *ent    = new_entity(parent, old_id, type);
2007         set_entity_ld_ident(ent, id);
2008         set_entity_visibility(ent, visibility_local);
2009         set_entity_variability(ent, variability_uninitialized);
2010
2011         return ent;
2012 }
2013
2014 static ir_entity *get_pic_symbol(be_main_env_t *env, ir_entity *entity)
2015 {
2016         ir_entity *result = pmap_get(env->ent_pic_symbol_map, entity);
2017         if (result == NULL) {
2018                 result = create_pic_symbol(env, entity);
2019                 pmap_insert(env->ent_pic_symbol_map, entity, result);
2020         }
2021
2022         return result;
2023 }
2024
2025
2026
2027 /**
2028  * Returns non-zero if a given entity can be accessed using a relative address.
2029  */
2030 static int can_address_relative(ir_entity *entity)
2031 {
2032         return get_entity_variability(entity) == variability_initialized
2033                 || get_entity_visibility(entity) == visibility_local;
2034 }
2035
2036 /** patches SymConsts to work in position independent code */
2037 static void fix_pic_symconsts(ir_node *node, void *data)
2038 {
2039         ir_graph     *irg;
2040         ir_node      *pic_base;
2041         ir_node      *add;
2042         ir_node      *block;
2043         ir_node      *unknown;
2044         ir_mode      *mode;
2045         ir_node      *load;
2046         ir_node      *load_res;
2047         be_abi_irg_t *env = data;
2048         int           arity, i;
2049         be_main_env_t *be = env->birg->main_env;
2050
2051         arity = get_irn_arity(node);
2052         for (i = 0; i < arity; ++i) {
2053                 dbg_info  *dbgi;
2054                 ir_node   *pred = get_irn_n(node, i);
2055                 ir_entity *entity;
2056                 ir_entity *pic_symbol;
2057                 ir_node   *pic_symconst;
2058
2059                 if (!is_SymConst(pred))
2060                         continue;
2061
2062                 entity = get_SymConst_entity(pred);
2063                 block  = get_nodes_block(pred);
2064                 irg    = get_irn_irg(pred);
2065
2066                 /* calls can jump to relative addresses, so we can directly jump to
2067                    the (relatively) known call address or the trampoline */
2068                 if (i == 1 && is_Call(node)) {
2069                         ir_entity *trampoline;
2070                         ir_node   *trampoline_const;
2071
2072                         if (can_address_relative(entity))
2073                                 continue;
2074
2075                         dbgi             = get_irn_dbg_info(pred);
2076                         trampoline       = get_trampoline(be, entity);
2077                         trampoline_const = new_rd_SymConst_addr_ent(dbgi, irg, mode_P_code,
2078                                                                     trampoline, NULL);
2079                         set_irn_n(node, i, trampoline_const);
2080                         continue;
2081                 }
2082
2083                 /* everything else is accessed relative to EIP */
2084                 mode     = get_irn_mode(pred);
2085                 unknown  = new_r_Unknown(irg, mode);
2086                 pic_base = arch_code_generator_get_pic_base(env->birg->cg);
2087
2088                 /* all ok now for locally constructed stuff */
2089                 if (can_address_relative(entity)) {
2090                         ir_node *add = new_r_Add(irg, block, pic_base, pred, mode);
2091
2092                         /* make sure the walker doesn't visit this add again */
2093                         mark_irn_visited(add);
2094                         set_irn_n(node, i, add);
2095                         continue;
2096                 }
2097
2098                 /* get entry from pic symbol segment */
2099                 dbgi         = get_irn_dbg_info(pred);
2100                 pic_symbol   = get_pic_symbol(be, entity);
2101                 pic_symconst = new_rd_SymConst_addr_ent(dbgi, irg, mode_P_code,
2102                                                         pic_symbol, NULL);
2103                 add = new_r_Add(irg, block, pic_base, pic_symconst, mode);
2104                 mark_irn_visited(add);
2105
2106                 /* we need an extra indirection for global data outside our current
2107                    module. The loads are always safe and can therefore float
2108                    and need no memory input */
2109                 load     = new_r_Load(irg, block, new_NoMem(), add, mode);
2110                 load_res = new_r_Proj(irg, block, load, mode, pn_Load_res);
2111                 set_irn_pinned(load, op_pin_state_floats);
2112
2113                 set_irn_n(node, i, load_res);
2114         }
2115 }
2116
2117 be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
2118 {
2119         be_abi_irg_t *env  = XMALLOC(be_abi_irg_t);
2120         ir_node *old_frame = get_irg_frame(birg->irg);
2121         ir_graph *irg      = birg->irg;
2122
2123         pmap_entry *ent;
2124         ir_node *dummy;
2125         optimization_state_t state;
2126         unsigned *limited_bitset;
2127
2128         be_omit_fp      = birg->main_env->options->omit_fp;
2129         be_omit_leaf_fp = birg->main_env->options->omit_leaf_fp;
2130
2131         obstack_init(&env->obst);
2132
2133         env->arch_env    = birg->main_env->arch_env;
2134         env->method_type = get_entity_type(get_irg_entity(irg));
2135         env->call        = be_abi_call_new(env->arch_env->sp->reg_class);
2136         arch_env_get_call_abi(env->arch_env, env->method_type, env->call);
2137
2138         env->ignore_regs  = pset_new_ptr_default();
2139         env->keep_map     = pmap_create();
2140         env->dce_survivor = new_survive_dce();
2141         env->birg         = birg;
2142
2143         env->sp_req.type    = arch_register_req_type_limited;
2144         env->sp_req.cls     = arch_register_get_class(env->arch_env->sp);
2145         limited_bitset      = rbitset_obstack_alloc(&env->obst, env->sp_req.cls->n_regs);
2146         rbitset_set(limited_bitset, arch_register_get_index(env->arch_env->sp));
2147         env->sp_req.limited = limited_bitset;
2148         if (env->arch_env->sp->type & arch_register_type_ignore) {
2149                 env->sp_req.type |= arch_register_req_type_ignore;
2150         }
2151
2152         env->sp_cls_req.type  = arch_register_req_type_normal;
2153         env->sp_cls_req.cls   = arch_register_get_class(env->arch_env->sp);
2154
2155         /* Beware: later we replace this node by the real one, ensure it is not CSE'd
2156            to another Unknown or the stack pointer gets used */
2157         save_optimization_state(&state);
2158         set_optimize(0);
2159         env->init_sp = dummy  = new_r_Unknown(irg, env->arch_env->sp->reg_class->mode);
2160         restore_optimization_state(&state);
2161
2162         FIRM_DBG_REGISTER(env->dbg, "firm.be.abi");
2163
2164         env->calls = NEW_ARR_F(ir_node*, 0);
2165
2166         if (birg->main_env->options->pic) {
2167                 irg_walk_graph(irg, fix_pic_symconsts, NULL, env);
2168         }
2169
2170         /* Lower all call nodes in the IRG. */
2171         process_calls(env);
2172
2173         /*
2174                 Beware: init backend abi call object after processing calls,
2175                 otherwise some information might be not yet available.
2176         */
2177         env->cb = env->call->cb->init(env->call, birg->main_env->arch_env, irg);
2178
2179         /* Process the IRG */
2180         modify_irg(env);
2181
2182         /* fix call inputs for state registers */
2183         fix_call_state_inputs(env);
2184
2185         /* We don't need the keep map anymore. */
2186         pmap_destroy(env->keep_map);
2187         env->keep_map = NULL;
2188
2189         /* calls array is not needed anymore */
2190         DEL_ARR_F(env->calls);
2191         env->calls = NULL;
2192
2193         /* reroute the stack origin of the calls to the true stack origin. */
2194         exchange(dummy, env->init_sp);
2195         exchange(old_frame, get_irg_frame(irg));
2196
2197         /* Make some important node pointers survive the dead node elimination. */
2198         survive_dce_register_irn(env->dce_survivor, &env->init_sp);
2199         foreach_pmap(env->regs, ent) {
2200                 survive_dce_register_irn(env->dce_survivor, (ir_node **) &ent->value);
2201         }
2202
2203         env->call->cb->done(env->cb);
2204         env->cb = NULL;
2205         return env;
2206 }
2207
2208 void be_abi_free(be_abi_irg_t *env)
2209 {
2210         be_abi_call_free(env->call);
2211         free_survive_dce(env->dce_survivor);
2212         del_pset(env->ignore_regs);
2213         pmap_destroy(env->regs);
2214         obstack_free(&env->obst, NULL);
2215         free(env);
2216 }
2217
2218 void be_abi_put_ignore_regs(be_abi_irg_t *abi, const arch_register_class_t *cls, bitset_t *bs)
2219 {
2220         arch_register_t *reg;
2221
2222         for(reg = pset_first(abi->ignore_regs); reg; reg = pset_next(abi->ignore_regs))
2223                 if(reg->reg_class == cls)
2224                         bitset_set(bs, reg->index);
2225 }
2226
2227 void be_abi_set_non_ignore_regs(be_abi_irg_t *abi, const arch_register_class_t *cls, unsigned *raw_bitset)
2228 {
2229         unsigned         i;
2230         arch_register_t *reg;
2231
2232         for (i = 0; i < cls->n_regs; ++i) {
2233                 if (arch_register_type_is(&cls->regs[i], ignore))
2234                         continue;
2235
2236                 rbitset_set(raw_bitset, i);
2237         }
2238
2239         for (reg = pset_first(abi->ignore_regs); reg != NULL;
2240              reg = pset_next(abi->ignore_regs)) {
2241                 if (reg->reg_class != cls)
2242                         continue;
2243
2244                 rbitset_clear(raw_bitset, reg->index);
2245         }
2246 }
2247
2248 /* Returns the stack layout from a abi environment. */
2249 const be_stack_layout_t *be_abi_get_stack_layout(const be_abi_irg_t *abi) {
2250         return &abi->frame;
2251 }
2252
2253 /*
2254
2255   _____ _        ____  _             _
2256  |  ___(_)_  __ / ___|| |_ __ _  ___| | __
2257  | |_  | \ \/ / \___ \| __/ _` |/ __| |/ /
2258  |  _| | |>  <   ___) | || (_| | (__|   <
2259  |_|   |_/_/\_\ |____/ \__\__,_|\___|_|\_\
2260
2261 */
2262
2263 typedef ir_node **node_array;
2264
2265 typedef struct fix_stack_walker_env_t {
2266         node_array sp_nodes;
2267 } fix_stack_walker_env_t;
2268
2269 /**
2270  * Walker. Collect all stack modifying nodes.
2271  */
2272 static void collect_stack_nodes_walker(ir_node *node, void *data)
2273 {
2274         fix_stack_walker_env_t    *env = data;
2275         const arch_register_req_t *req;
2276
2277         if (get_irn_mode(node) == mode_T)
2278                 return;
2279
2280         req = arch_get_register_req_out(node);
2281         if (! (req->type & arch_register_req_type_produces_sp))
2282                 return;
2283
2284         ARR_APP1(ir_node*, env->sp_nodes, node);
2285 }
2286
2287 void be_abi_fix_stack_nodes(be_abi_irg_t *env)
2288 {
2289         be_ssa_construction_env_t senv;
2290         int i, len;
2291         ir_node **phis;
2292         be_irg_t *birg = env->birg;
2293         be_lv_t *lv = be_get_birg_liveness(birg);
2294         fix_stack_walker_env_t walker_env;
2295
2296         walker_env.sp_nodes = NEW_ARR_F(ir_node*, 0);
2297
2298         irg_walk_graph(birg->irg, collect_stack_nodes_walker, NULL, &walker_env);
2299
2300         /* nothing to be done if we didn't find any node, in fact we mustn't
2301          * continue, as for endless loops incsp might have had no users and is bad
2302          * now.
2303          */
2304         len = ARR_LEN(walker_env.sp_nodes);
2305         if (len == 0) {
2306                 DEL_ARR_F(walker_env.sp_nodes);
2307                 return;
2308         }
2309
2310         be_ssa_construction_init(&senv, birg);
2311         be_ssa_construction_add_copies(&senv, walker_env.sp_nodes,
2312                                    ARR_LEN(walker_env.sp_nodes));
2313         be_ssa_construction_fix_users_array(&senv, walker_env.sp_nodes,
2314                                             ARR_LEN(walker_env.sp_nodes));
2315
2316         if(lv != NULL) {
2317                 len = ARR_LEN(walker_env.sp_nodes);
2318                 for(i = 0; i < len; ++i) {
2319                         be_liveness_update(lv, walker_env.sp_nodes[i]);
2320                 }
2321                 be_ssa_construction_update_liveness_phis(&senv, lv);
2322         }
2323
2324         phis = be_ssa_construction_get_new_phis(&senv);
2325
2326         /* set register requirements for stack phis */
2327         len = ARR_LEN(phis);
2328         for(i = 0; i < len; ++i) {
2329                 ir_node *phi = phis[i];
2330                 be_set_phi_reg_req(phi, &env->sp_req, arch_register_req_type_produces_sp);
2331                 arch_set_irn_register(phi, env->arch_env->sp);
2332         }
2333         be_ssa_construction_destroy(&senv);
2334
2335         DEL_ARR_F(walker_env.sp_nodes);
2336 }
2337
2338 /**
2339  * Fix all stack accessing operations in the block bl.
2340  *
2341  * @param env        the abi environment
2342  * @param bl         the block to process
2343  * @param real_bias  the bias value
2344  *
2345  * @return the bias at the end of this block
2346  */
2347 static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int real_bias)
2348 {
2349         int               omit_fp  = env->call->flags.bits.try_omit_fp;
2350         ir_node          *irn;
2351         int               wanted_bias = real_bias;
2352
2353         sched_foreach(bl, irn) {
2354                 int ofs;
2355
2356                 /*
2357                    Check, if the node relates to an entity on the stack frame.
2358                    If so, set the true offset (including the bias) for that
2359                    node.
2360                  */
2361                 ir_entity *ent = arch_get_frame_entity(irn);
2362                 if (ent) {
2363                         int bias   = omit_fp ? real_bias : 0;
2364                         int offset = get_stack_entity_offset(&env->frame, ent, bias);
2365                         arch_set_frame_offset(irn, offset);
2366                         DBG((env->dbg, LEVEL_2, "%F has offset %d (including bias %d)\n",
2367                              ent, offset, bias));
2368                 }
2369
2370                 /*
2371                  * If the node modifies the stack pointer by a constant offset,
2372                  * record that in the bias.
2373                  */
2374                 ofs = arch_get_sp_bias(irn);
2375
2376                 if (be_is_IncSP(irn)) {
2377                         /* fill in real stack frame size */
2378                         if (ofs == BE_STACK_FRAME_SIZE_EXPAND) {
2379                                 ir_type *frame_type = get_irg_frame_type(env->birg->irg);
2380                                 ofs = (int) get_type_size_bytes(frame_type);
2381                                 be_set_IncSP_offset(irn, ofs);
2382                         } else if (ofs == BE_STACK_FRAME_SIZE_SHRINK) {
2383                                 ir_type *frame_type = get_irg_frame_type(env->birg->irg);
2384                                 ofs = - (int)get_type_size_bytes(frame_type);
2385                                 be_set_IncSP_offset(irn, ofs);
2386                         } else {
2387                                 if (be_get_IncSP_align(irn)) {
2388                                         /* patch IncSP to produce an aligned stack pointer */
2389                                         ir_type *between_type = env->frame.between_type;
2390                                         int      between_size = get_type_size_bytes(between_type);
2391                                         int      alignment    = 1 << env->arch_env->stack_alignment;
2392                                         int      delta        = (real_bias + ofs + between_size) & (alignment - 1);
2393                                         assert(ofs >= 0);
2394                                         if (delta > 0) {
2395                                                 be_set_IncSP_offset(irn, ofs + alignment - delta);
2396                                                 real_bias += alignment - delta;
2397                                         }
2398                                 } else {
2399                                         /* adjust so real_bias corresponds with wanted_bias */
2400                                         int delta = wanted_bias - real_bias;
2401                                         assert(delta <= 0);
2402                                         if (delta != 0) {
2403                                                 be_set_IncSP_offset(irn, ofs + delta);
2404                                                 real_bias += delta;
2405                                         }
2406                                 }
2407                         }
2408                 }
2409
2410                 real_bias   += ofs;
2411                 wanted_bias += ofs;
2412         }
2413
2414         assert(real_bias == wanted_bias);
2415         return real_bias;
2416 }
2417
2418 /**
2419  * A helper struct for the bias walker.
2420  */
2421 struct bias_walk {
2422         be_abi_irg_t *env;     /**< The ABI irg environment. */
2423         int           start_block_bias;  /**< The bias at the end of the start block. */
2424         int           between_size;
2425         ir_node      *start_block;  /**< The start block of the current graph. */
2426 };
2427
2428 /**
2429  * Block-Walker: fix all stack offsets for all blocks
2430  * except the start block
2431  */
2432 static void stack_bias_walker(ir_node *bl, void *data)
2433 {
2434         struct bias_walk *bw = data;
2435         if (bl != bw->start_block) {
2436                 process_stack_bias(bw->env, bl, bw->start_block_bias);
2437         }
2438 }
2439
2440 void be_abi_fix_stack_bias(be_abi_irg_t *env)
2441 {
2442         ir_graph          *irg   = env->birg->irg;
2443         struct bias_walk  bw;
2444
2445         stack_frame_compute_initial_offset(&env->frame);
2446         // stack_layout_dump(stdout, frame);
2447
2448         /* Determine the stack bias at the end of the start block. */
2449         bw.start_block_bias = process_stack_bias(env, get_irg_start_block(irg), env->frame.initial_bias);
2450         bw.between_size     = get_type_size_bytes(env->frame.between_type);
2451
2452         /* fix the bias is all other blocks */
2453         bw.env = env;
2454         bw.start_block = get_irg_start_block(irg);
2455         irg_block_walk_graph(irg, stack_bias_walker, NULL, &bw);
2456 }
2457
2458 ir_node *be_abi_get_callee_save_irn(be_abi_irg_t *abi, const arch_register_t *reg)
2459 {
2460         assert(arch_register_type_is(reg, callee_save));
2461         assert(pmap_contains(abi->regs, (void *) reg));
2462         return pmap_get(abi->regs, (void *) reg);
2463 }
2464
2465 ir_node *be_abi_get_ignore_irn(be_abi_irg_t *abi, const arch_register_t *reg)
2466 {
2467         assert(arch_register_type_is(reg, ignore));
2468         assert(pmap_contains(abi->regs, (void *) reg));
2469         return pmap_get(abi->regs, (void *) reg);
2470 }
2471
2472 /**
2473  * Returns non-zero if the ABI has omitted the frame pointer in
2474  * the current graph.
2475  */
2476 int be_abi_omit_fp(const be_abi_irg_t *abi) {
2477         return abi->call->flags.bits.try_omit_fp;
2478 }