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