beabi.c 77 KB
Newer Older
Christian Würdig's avatar
Christian Würdig committed
1
/*
Michael Beck's avatar
Michael Beck committed
2
 * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
Christian Würdig's avatar
Christian Würdig committed
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 *
 * This file is part of libFirm.
 *
 * This file may be distributed and/or modified under the terms of the
 * GNU General Public License version 2 as published by the Free Software
 * Foundation and appearing in the file LICENSE.GPL included in the
 * packaging of this file.
 *
 * Licensees holding valid libFirm Professional Edition licenses may use
 * this file in accordance with the libFirm Commercial License.
 * Agreement provided with the Software.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE.
Christian Würdig's avatar
Christian Würdig committed
18
19
20
21
22
 */

/**
 * @file
 * @brief       Backend ABI implementation.
23
 * @author      Sebastian Hack, Michael Beck
Christian Würdig's avatar
Christian Würdig committed
24
 * @version     $Id$
Sebastian Hack's avatar
Sebastian Hack committed
25
 */
Matthias Braun's avatar
Matthias Braun committed
26
#include "config.h"
27

Sebastian Hack's avatar
Sebastian Hack committed
28
#include "obst.h"
29
#include "offset.h"
Sebastian Hack's avatar
Sebastian Hack committed
30

31
#include "irgopt.h"
Sebastian Hack's avatar
Sebastian Hack committed
32
33
34
35
36
37
38

#include "irgraph_t.h"
#include "irnode_t.h"
#include "ircons_t.h"
#include "iredges_t.h"
#include "irgmod.h"
#include "irgwalk.h"
Sebastian Hack's avatar
Sebastian Hack committed
39
#include "irprintf_t.h"
40
#include "irgopt.h"
41
#include "irbitset.h"
42
#include "iropt_t.h"
43
44
45
#include "height.h"
#include "pdeq.h"
#include "irtools.h"
Matthias Braun's avatar
Matthias Braun committed
46
#include "raw_bitset.h"
47
#include "error.h"
48
#include "pset_new.h"
Sebastian Hack's avatar
Sebastian Hack committed
49
50
51

#include "be.h"
#include "beabi.h"
52
#include "bearch.h"
53
#include "benode.h"
Sebastian Hack's avatar
Sebastian Hack committed
54
#include "belive_t.h"
55
56
#include "besched.h"
#include "beirg.h"
57
#include "bessaconstr.h"
58
59
60
#include "bemodule.h"

DEBUG_ONLY(static firm_dbg_module_t *dbg;)
Sebastian Hack's avatar
Sebastian Hack committed
61
62

typedef struct _be_abi_call_arg_t {
63
64
65
	unsigned is_res   : 1;  /**< 1: the call argument is a return value. 0: it's a call parameter. */
	unsigned in_reg   : 1;  /**< 1: this argument is transmitted in registers. */
	unsigned on_stack : 1;	/**< 1: this argument is transmitted on the stack. */
Sebastian Hack's avatar
Sebastian Hack committed
66

67
	int                    pos;
Sebastian Hack's avatar
Sebastian Hack committed
68
	const arch_register_t *reg;
69
70
71
72
73
	ir_entity             *stack_ent;
	ir_mode               *load_mode;
	unsigned               alignment;    /**< stack alignment */
	unsigned               space_before; /**< allocate space before */
	unsigned               space_after;  /**< allocate space after */
Sebastian Hack's avatar
Sebastian Hack committed
74
75
76
} be_abi_call_arg_t;

struct _be_abi_call_t {
Michael Beck's avatar
Michael Beck committed
77
78
	be_abi_call_flags_t          flags;  /**< Flags describing the ABI behavior on calls */
	int                          pop;    /**< number of bytes the stack frame is shrinked by the callee on return. */
79
80
81
	const be_abi_callbacks_t    *cb;
	ir_type                     *between_type;
	set                         *params;
Michael Beck's avatar
Michael Beck committed
82
	const arch_register_class_t *cls_addr; /**< register class of the call address */
Sebastian Hack's avatar
Sebastian Hack committed
83
84
};

Michael Beck's avatar
Michael Beck committed
85
86
87
/**
 * The ABI information for the current birg.
 */
Sebastian Hack's avatar
Sebastian Hack committed
88
struct _be_abi_irg_t {
89
	be_irg_t             *birg;         /**< The back end IRG. */
90
	ir_graph             *irg;
91
	const arch_env_t     *arch_env;
Sebastian Hack's avatar
Sebastian Hack committed
92
93
	survive_dce_t        *dce_survivor;

Sebastian Hack's avatar
Sebastian Hack committed
94
	be_abi_call_t        *call;         /**< The ABI call information. */
95
	ir_type              *method_type;  /**< The type of the method of the IRG. */
Sebastian Hack's avatar
Sebastian Hack committed
96

Sebastian Hack's avatar
Sebastian Hack committed
97
	ir_node              *init_sp;      /**< The node representing the stack pointer
98
	                                         at the start of the function. */
Sebastian Hack's avatar
Sebastian Hack committed
99

100
	ir_node              *start;        /**< The be_Start params node. */
Sebastian Hack's avatar
Sebastian Hack committed
101
	pmap                 *regs;         /**< A map of all callee-save and ignore regs to
102
	                                         their Projs to the RegParams node. */
Sebastian Hack's avatar
Sebastian Hack committed
103

104
	int                  start_block_bias; /**< The stack bias at the end of the start block. */
Sebastian Hack's avatar
Sebastian Hack committed
105

106
107
	void                 *cb;           /**< ABI Callback self pointer. */

Sebastian Hack's avatar
Sebastian Hack committed
108
109
110
	pmap                 *keep_map;     /**< mapping blocks to keep nodes. */
	pset                 *ignore_regs;  /**< Additional registers which shall be ignored. */

111
	ir_node              **calls;       /**< flexible array containing all be_Call nodes */
112

113
	arch_register_req_t  *sp_req;
114
115

	be_stack_layout_t    frame;         /**< The stack frame model. */
Sebastian Hack's avatar
Sebastian Hack committed
116
};
Sebastian Hack's avatar
Sebastian Hack committed
117

118
static heights_t *ir_heights;
119

120
/** Flag: if set, try to omit the frame pointer in all routines. */
121
static int be_omit_fp = 1;
122

123
124
125
/** Flag: if set, try to omit the frame pointer in leaf routines only. */
static int be_omit_leaf_fp = 1;

Sebastian Hack's avatar
Sebastian Hack committed
126
127
128
129
130
131
/*
     _    ____ ___    ____      _ _ _                _
    / \  | __ )_ _|  / ___|__ _| | | |__   __ _  ___| | _____
   / _ \ |  _ \| |  | |   / _` | | | '_ \ / _` |/ __| |/ / __|
  / ___ \| |_) | |  | |__| (_| | | | |_) | (_| | (__|   <\__ \
 /_/   \_\____/___|  \____\__,_|_|_|_.__/ \__,_|\___|_|\_\___/
132

Sebastian Hack's avatar
Sebastian Hack committed
133
134
135
  These callbacks are used by the backend to set the parameters
  for a specific call type.
*/
Sebastian Hack's avatar
Sebastian Hack committed
136

Michael Beck's avatar
Michael Beck committed
137
138
139
/**
 * Set compare function: compares two ABI call object arguments.
 */
Sebastian Hack's avatar
Sebastian Hack committed
140
141
142
static int cmp_call_arg(const void *a, const void *b, size_t n)
{
	const be_abi_call_arg_t *p = a, *q = b;
143
	(void) n;
Sebastian Hack's avatar
Sebastian Hack committed
144
145
146
	return !(p->is_res == q->is_res && p->pos == q->pos);
}

Michael Beck's avatar
Michael Beck committed
147
/**
Michael Beck's avatar
Michael Beck committed
148
 * Get  an ABI call object argument.
Michael Beck's avatar
Michael Beck committed
149
150
151
152
153
 *
 * @param call      the abi call
 * @param is_res    true for call results, false for call arguments
 * @param pos       position of the argument
 */
Michael Beck's avatar
Michael Beck committed
154
static be_abi_call_arg_t *get_call_arg(be_abi_call_t *call, int is_res, int pos)
Sebastian Hack's avatar
Sebastian Hack committed
155
156
157
158
{
	be_abi_call_arg_t arg;
	unsigned hash;

159
	memset(&arg, 0, sizeof(arg));
Sebastian Hack's avatar
Sebastian Hack committed
160
161
162
	arg.is_res = is_res;
	arg.pos    = pos;

Michael Beck's avatar
Michael Beck committed
163
	hash = is_res * 128 + pos;
Sebastian Hack's avatar
Sebastian Hack committed
164

Michael Beck's avatar
Michael Beck committed
165
	return set_find(call->params, &arg, sizeof(arg), hash);
Sebastian Hack's avatar
Sebastian Hack committed
166
167
}

Michael Beck's avatar
Michael Beck committed
168
/**
Michael Beck's avatar
Michael Beck committed
169
 * Set an ABI call object argument.
Michael Beck's avatar
Michael Beck committed
170
 *
Michael Beck's avatar
Michael Beck committed
171
 * @param call      the abi call
Michael Beck's avatar
Michael Beck committed
172
173
174
 * @param is_res    true for call results, false for call arguments
 * @param pos       position of the argument
 */
Michael Beck's avatar
Michael Beck committed
175
static be_abi_call_arg_t *create_call_arg(be_abi_call_t *call, int is_res, int pos)
Sebastian Hack's avatar
Sebastian Hack committed
176
{
Michael Beck's avatar
Michael Beck committed
177
178
179
180
181
182
183
184
185
186
	be_abi_call_arg_t arg;
	unsigned hash;

	memset(&arg, 0, sizeof(arg));
	arg.is_res = is_res;
	arg.pos    = pos;

	hash = is_res * 128 + pos;

	return set_insert(call->params, &arg, sizeof(arg), hash);
Sebastian Hack's avatar
Sebastian Hack committed
187
188
}

Michael Beck's avatar
Michael Beck committed
189
/* Set the flags for a call. */
190
void be_abi_call_set_flags(be_abi_call_t *call, be_abi_call_flags_t flags, const be_abi_callbacks_t *cb)
Sebastian Hack's avatar
Sebastian Hack committed
191
{
192
193
	call->flags = flags;
	call->cb    = cb;
Sebastian Hack's avatar
Sebastian Hack committed
194
195
}

Michael Beck's avatar
Michael Beck committed
196
/* Sets the number of bytes the stackframe is shrinked by the callee on return */
197
198
199
200
201
void be_abi_call_set_pop(be_abi_call_t *call, int pop)
{
	assert(pop >= 0);
	call->pop = pop;
}
202
203
204
205
206
207
208
209

/* Set register class for call address */
void be_abi_call_set_call_address_reg_class(be_abi_call_t *call, const arch_register_class_t *cls)
{
	call->cls_addr = cls;
}


210
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)
Sebastian Hack's avatar
Sebastian Hack committed
211
{
Michael Beck's avatar
Michael Beck committed
212
	be_abi_call_arg_t *arg = create_call_arg(call, 0, arg_pos);
213
	arg->on_stack     = 1;
214
	arg->load_mode    = load_mode;
215
216
217
	arg->alignment    = alignment;
	arg->space_before = space_before;
	arg->space_after  = space_after;
218
	assert(alignment > 0 && "Alignment must be greater than 0");
Sebastian Hack's avatar
Sebastian Hack committed
219
220
221
222
}

void be_abi_call_param_reg(be_abi_call_t *call, int arg_pos, const arch_register_t *reg)
{
Michael Beck's avatar
Michael Beck committed
223
	be_abi_call_arg_t *arg = create_call_arg(call, 0, arg_pos);
224
	arg->in_reg = 1;
Sebastian Hack's avatar
Sebastian Hack committed
225
226
227
228
229
	arg->reg = reg;
}

void be_abi_call_res_reg(be_abi_call_t *call, int arg_pos, const arch_register_t *reg)
{
Michael Beck's avatar
Michael Beck committed
230
	be_abi_call_arg_t *arg = create_call_arg(call, 1, arg_pos);
231
	arg->in_reg = 1;
Sebastian Hack's avatar
Sebastian Hack committed
232
233
234
	arg->reg = reg;
}

Michael Beck's avatar
Michael Beck committed
235
/* Get the flags of a ABI call object. */
236
237
238
239
240
be_abi_call_flags_t be_abi_call_get_flags(const be_abi_call_t *call)
{
	return call->flags;
}

Michael Beck's avatar
Michael Beck committed
241
242
243
/**
 * Constructor for a new ABI call object.
 *
Michael Beck's avatar
Michael Beck committed
244
245
 * @param cls_addr  register class of the call address
 *
Michael Beck's avatar
Michael Beck committed
246
247
 * @return the new ABI call object
 */
248
static be_abi_call_t *be_abi_call_new(const arch_register_class_t *cls_addr)
Sebastian Hack's avatar
Sebastian Hack committed
249
{
250
	be_abi_call_t *call = XMALLOCZ(be_abi_call_t);
251

Sebastian Hack's avatar
Sebastian Hack committed
252
253
254
	call->flags.val  = 0;
	call->params     = new_set(cmp_call_arg, 16);
	call->cb         = NULL;
255
	call->cls_addr   = cls_addr;
256

257
	call->flags.bits.try_omit_fp = be_omit_fp | be_omit_leaf_fp;
258

Sebastian Hack's avatar
Sebastian Hack committed
259
260
261
	return call;
}

Michael Beck's avatar
Michael Beck committed
262
263
264
265
/**
 * Destructor for an ABI call object.
 */
static void be_abi_call_free(be_abi_call_t *call)
Sebastian Hack's avatar
Sebastian Hack committed
266
267
268
269
270
{
	del_set(call->params);
	free(call);
}

Sebastian Hack's avatar
Sebastian Hack committed
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
/*
  _____                           _   _                 _ _ _
 |  ___| __ __ _ _ __ ___   ___  | | | | __ _ _ __   __| | (_)_ __   __ _
 | |_ | '__/ _` | '_ ` _ \ / _ \ | |_| |/ _` | '_ \ / _` | | | '_ \ / _` |
 |  _|| | | (_| | | | | | |  __/ |  _  | (_| | | | | (_| | | | | | | (_| |
 |_|  |_|  \__,_|_| |_| |_|\___| |_| |_|\__,_|_| |_|\__,_|_|_|_| |_|\__, |
                                                                    |___/

  Handling of the stack frame. It is composed of three types:
  1) The type of the arguments which are pushed on the stack.
  2) The "between type" which consists of stuff the call of the
     function pushes on the stack (like the return address and
	 the old base pointer for ia32).
  3) The Firm frame type which consists of all local variables
     and the spills.
*/

288
289
static int get_stack_entity_offset(be_stack_layout_t *frame, ir_entity *ent,
                                   int bias)
290
{
291
	ir_type *t = get_entity_owner(ent);
292
	int ofs    = get_entity_offset(ent);
293

294
	int index;
295
296

	/* Find the type the entity is contained in. */
297
298
	for (index = 0; index < N_FRAME_TYPES; ++index) {
		if (frame->order[index] == t)
299
			break;
300
301
		/* Add the size of all the types below the one of the entity to the entity's offset */
		ofs += get_type_size_bytes(frame->order[index]);
302
303
304
305
306
307
308
309
310
311
312
	}

	/* correct the offset by the initial position of the frame pointer */
	ofs -= frame->initial_offset;

	/* correct the offset with the current bias. */
	ofs += bias;

	return ofs;
}

Michael Beck's avatar
Michael Beck committed
313
314
315
/**
 * Retrieve the entity with given offset from a frame type.
 */
316
static ir_entity *search_ent_with_offset(ir_type *t, int offset)
Sebastian Hack's avatar
Sebastian Hack committed
317
318
319
{
	int i, n;

320
	for (i = 0, n = get_compound_n_members(t); i < n; ++i) {
321
		ir_entity *ent = get_compound_member(t, i);
322
		if (get_entity_offset(ent) == offset)
Sebastian Hack's avatar
Sebastian Hack committed
323
324
325
326
327
328
			return ent;
	}

	return NULL;
}

329
static int stack_frame_compute_initial_offset(be_stack_layout_t *frame)
330
{
331
332
	ir_type  *base = frame->stack_dir < 0 ? frame->between_type : frame->frame_type;
	ir_entity *ent = search_ent_with_offset(base, 0);
333

334
335
336
337
338
339
	if (ent == NULL) {
		frame->initial_offset
			= frame->stack_dir < 0 ? get_type_size_bytes(frame->frame_type) : get_type_size_bytes(frame->between_type);
	} else {
		frame->initial_offset = get_stack_entity_offset(frame, ent, 0);
	}
340

341
342
343
	return frame->initial_offset;
}

344
345
346
347
348
349
350
/**
 * Initializes the frame layout from parts
 *
 * @param frame     the stack layout that will be initialized
 * @param args      the stack argument layout type
 * @param between   the between layout type
 * @param locals    the method frame type
351
 * @param stack_dir the stack direction: < 0 decreasing, > 0 increasing addresses
352
 * @param param_map an array mapping method argument positions to the stack argument type
353
354
355
356
 *
 * @return the initialized stack layout
 */
static be_stack_layout_t *stack_frame_init(be_stack_layout_t *frame, ir_type *args,
357
                                           ir_type *between, ir_type *locals, int stack_dir,
358
                                           ir_entity *param_map[])
359
360
361
362
363
{
	frame->arg_type       = args;
	frame->between_type   = between;
	frame->frame_type     = locals;
	frame->initial_offset = 0;
Matthias Braun's avatar
Matthias Braun committed
364
	frame->initial_bias   = 0;
365
366
	frame->stack_dir      = stack_dir;
	frame->order[1]       = between;
367
	frame->param_map      = param_map;
368

369
	if (stack_dir > 0) {
370
371
372
373
		frame->order[0] = args;
		frame->order[2] = locals;
	}
	else {
374
375
		/* typical decreasing stack: locals have the
		 * lowest addresses, arguments the highest */
376
377
378
379
380
381
		frame->order[0] = locals;
		frame->order[2] = args;
	}
	return frame;
}

Michael Beck's avatar
Michael Beck committed
382
383
384
385
/**
 * Returns non-zero if the call argument at given position
 * is transfered on the stack.
 */
386
static inline int is_on_stack(be_abi_call_t *call, int pos)
Sebastian Hack's avatar
Sebastian Hack committed
387
388
389
390
391
{
	be_abi_call_arg_t *arg = get_call_arg(call, 0, pos);
	return arg && !arg->in_reg;
}

392
393
394
395
396
397
398
399
400
401
402
/*
   ____      _ _
  / ___|__ _| | |___
 | |   / _` | | / __|
 | |__| (_| | | \__ \
  \____\__,_|_|_|___/

  Adjustment of the calls inside a graph.

*/

Sebastian Hack's avatar
Sebastian Hack committed
403
/**
404
405
 * Transform a call node into a be_Call node.
 *
Sebastian Hack's avatar
Sebastian Hack committed
406
 * @param env The ABI environment for the current irg.
407
408
409
 * @param irn The call node.
 * @param curr_sp The stack pointer node to use.
 * @return The stack pointer after the call.
Sebastian Hack's avatar
Sebastian Hack committed
410
 */
Matthias Braun's avatar
Matthias Braun committed
411
static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
Sebastian Hack's avatar
Sebastian Hack committed
412
{
413
	ir_graph *irg              = env->birg->irg;
414
	const arch_env_t *arch_env = env->birg->main_env->arch_env;
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
419
420
	ir_node *curr_mem          = get_Call_mem(irn);
	ir_node *bl                = get_nodes_block(irn);
	int stack_size             = 0;
421
422
	int stack_dir              = arch_env->stack_dir;
	const arch_register_t *sp  = arch_env->sp;
423
424
	be_abi_call_t *call        = be_abi_call_new(sp->reg_class);
	ir_mode *mach_mode         = sp->reg_class->mode;
425
	struct obstack *obst       = be_get_birg_obst(irg);
426
	int no_alloc               = call->flags.bits.frame_is_setup_on_call;
427
	int n_res                  = get_method_n_ress(call_tp);
428
	int do_seq                 = call->flags.bits.store_args_sequential && !no_alloc;
429
430
431
432
433

	ir_node *res_proj  = NULL;
	int n_reg_params   = 0;
	int n_stack_params = 0;
	int n_ins;
Sebastian Hack's avatar
Sebastian Hack committed
434

435
436
	pset_new_t              destroyed_regs, states;
	pset_new_iterator_t     iter;
437
438
439
440
441
442
443
444
	ir_node                *low_call;
	ir_node               **in;
	ir_node               **res_projs;
	int                     n_reg_results = 0;
	const arch_register_t  *reg;
	const ir_edge_t        *edge;
	int                    *reg_param_idxs;
	int                    *stack_param_idx;
445
	int                     i, n, destroy_all_regs;
446
	dbg_info               *dbgi;
Sebastian Hack's avatar
Sebastian Hack committed
447

448
449
450
	pset_new_init(&destroyed_regs);
	pset_new_init(&states);

Sebastian Hack's avatar
Sebastian Hack committed
451
	/* Let the isa fill out the abi description for that call node. */
452
	arch_env_get_call_abi(arch_env, call_tp, call);
Sebastian Hack's avatar
Sebastian Hack committed
453
454

	/* Insert code to put the stack arguments on the stack. */
455
	assert(get_Call_n_params(irn) == n_params);
456
457
	assert(obstack_object_size(obst) == 0);
	stack_param_idx = ALLOCAN(int, n_params);
458
	for (i = 0; i < n_params; ++i) {
Sebastian Hack's avatar
Sebastian Hack committed
459
		be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
460
		assert(arg);
Michael Beck's avatar
Michael Beck committed
461
		if (arg->on_stack) {
462
			int arg_size = get_type_size_bytes(get_method_param_type(call_tp, i));
Michael Beck's avatar
Michael Beck committed
463
464
465
466

			stack_size += round_up2(arg->space_before, arg->alignment);
			stack_size += round_up2(arg_size, arg->alignment);
			stack_size += round_up2(arg->space_after, arg->alignment);
467
468

			stack_param_idx[n_stack_params++] = i;
Sebastian Hack's avatar
Sebastian Hack committed
469
470
471
472
		}
	}

	/* Collect all arguments which are passed in registers. */
473
	reg_param_idxs = ALLOCAN(int, n_params);
474
	for (i = 0; i < n_params; ++i) {
Sebastian Hack's avatar
Sebastian Hack committed
475
		be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
476
		if (arg && arg->in_reg) {
477
			reg_param_idxs[n_reg_params++] = i;
Sebastian Hack's avatar
Sebastian Hack committed
478
479
480
		}
	}

481
482
483
484
485
486
487
488
489
490
	/*
	 * If the stack is decreasing and we do not want to store sequentially,
	 * or someone else allocated the call frame
	 * we allocate as much space on the stack all parameters need, by
	 * moving the stack pointer along the stack's direction.
	 *
	 * Note: we also have to do this for stack_size == 0, because we may have
	 * to adjust stack alignment for the call.
	 */
	if (stack_dir < 0 && !do_seq && !no_alloc) {
491
		curr_sp = be_new_IncSP(sp, bl, curr_sp, stack_size, 1);
492
493
	}

Christoph Mallon's avatar
Christoph Mallon committed
494
	dbgi = get_irn_dbg_info(irn);
Sebastian Hack's avatar
Sebastian Hack committed
495
	/* If there are some parameters which shall be passed on the stack. */
496
	if (n_stack_params > 0) {
497
498
499
		int       curr_ofs = 0;
		ir_node **in       = ALLOCAN(ir_node*, n_stack_params+1);
		unsigned  n_in     = 0;
Sebastian Hack's avatar
Sebastian Hack committed
500

501
502
		/*
		 * Reverse list of stack parameters if call arguments are from left to right.
503
		 * We must them reverse again if they are pushed (not stored) and the stack
504
505
506
		 * direction is downwards.
		 */
		if (call->flags.bits.left_to_right ^ (do_seq && stack_dir < 0)) {
507
508
509
510
511
			for (i = 0; i < n_stack_params >> 1; ++i) {
				int other  = n_stack_params - i - 1;
				int tmp    = stack_param_idx[i];
				stack_param_idx[i]     = stack_param_idx[other];
				stack_param_idx[other] = tmp;
Sebastian Hack's avatar
Sebastian Hack committed
512
513
514
			}
		}

515
		curr_mem = get_Call_mem(irn);
516
		if (! do_seq) {
517
			in[n_in++] = curr_mem;
518
519
		}

520
521
		for (i = 0; i < n_stack_params; ++i) {
			int p                  = stack_param_idx[i];
522
523
524
525
			be_abi_call_arg_t *arg = get_call_arg(call, 0, p);
			ir_node *param         = get_Call_param(irn, p);
			ir_node *addr          = curr_sp;
			ir_node *mem           = NULL;
526
			ir_type *param_type    = get_method_param_type(call_tp, p);
527
528
			int param_size         = get_type_size_bytes(param_type) + arg->space_after;

529
530
531
532
533
534
535
			/*
			 * If we wanted to build the arguments sequentially,
			 * the stack pointer for the next must be incremented,
			 * and the memory value propagated.
			 */
			if (do_seq) {
				curr_ofs = 0;
536
537
				addr = curr_sp = be_new_IncSP(sp, bl, curr_sp,
				                              param_size + arg->space_before, 0);
Sebastian Hack's avatar
Sebastian Hack committed
538
				add_irn_dep(curr_sp, curr_mem);
539
			} else {
540
541
542
543
				curr_ofs += arg->space_before;
				curr_ofs =  round_up2(curr_ofs, arg->alignment);

				/* Make the expression to compute the argument's offset. */
544
				if (curr_ofs > 0) {
545
					ir_mode *constmode = mach_mode;
546
					if (mode_is_reference(mach_mode)) {
547
548
						constmode = mode_Is;
					}
549
					addr = new_r_Const_long(irg, constmode, curr_ofs);
550
					addr = new_r_Add(bl, curr_sp, addr, mach_mode);
551
				}
Sebastian Hack's avatar
Sebastian Hack committed
552
553
554
			}

			/* Insert a store for primitive arguments. */
555
			if (is_atomic_type(param_type)) {
556
				ir_node *store;
557
				ir_node *mem_input = do_seq ? curr_mem : new_NoMem();
558
				store = new_rd_Store(dbgi, bl, mem_input, addr, param, 0);
559
				mem   = new_r_Proj(store, mode_M, pn_Store_M);
560
561
			} else {
				/* Make a mem copy for compound arguments. */
562
563
				ir_node *copy;

Sebastian Hack's avatar
Sebastian Hack committed
564
				assert(mode_is_reference(get_irn_mode(param)));
565
				copy = new_rd_CopyB(dbgi, bl, curr_mem, addr, param, param_type);
566
				mem = new_r_Proj(copy, mode_M, pn_CopyB_M_regular);
Sebastian Hack's avatar
Sebastian Hack committed
567
568
569
570
			}

			curr_ofs += param_size;

571
			if (do_seq)
Sebastian Hack's avatar
Sebastian Hack committed
572
				curr_mem = mem;
573
			else
574
				in[n_in++] = mem;
Sebastian Hack's avatar
Sebastian Hack committed
575
576
577
		}

		/* We need the sync only, if we didn't build the stores sequentially. */
578
579
		if (! do_seq) {
			if (n_stack_params >= 1) {
580
				curr_mem = new_r_Sync(bl, n_in, in);
581
582
583
584
			} else {
				curr_mem = get_Call_mem(irn);
			}
		}
Sebastian Hack's avatar
Sebastian Hack committed
585
586
	}

587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
	/* check for the return_twice property */
	destroy_all_regs = 0;
	if (is_SymConst_addr_ent(call_ptr)) {
		ir_entity *ent = get_SymConst_entity(call_ptr);

		if (get_entity_additional_properties(ent) & mtp_property_returns_twice)
			destroy_all_regs = 1;
	} else {
		ir_type *call_tp = get_Call_type(irn);

		if (get_method_additional_properties(call_tp) & mtp_property_returns_twice)
			destroy_all_regs = 1;
	}

	/* Put caller save into the destroyed set and state registers in the states set */
602
	for (i = 0, n = arch_env_get_n_reg_class(arch_env); i < n; ++i) {
603
		unsigned j;
604
		const arch_register_class_t *cls = arch_env_get_reg_class(arch_env, i);
605
		for (j = 0; j < cls->n_regs; ++j) {
Sebastian Hack's avatar
Sebastian Hack committed
606
			const arch_register_t *reg = arch_register_for_index(cls, j);
607
608
609
610

			if (destroy_all_regs || arch_register_type_is(reg, caller_save)) {
				if (! arch_register_type_is(reg, ignore))
					pset_new_insert(&destroyed_regs, (void *) reg);
611
			}
612
			if (arch_register_type_is(reg, state)) {
613
614
				pset_new_insert(&destroyed_regs, (void*) reg);
				pset_new_insert(&states, (void*) reg);
615
			}
Sebastian Hack's avatar
Sebastian Hack committed
616
617
		}
	}
Sebastian Hack's avatar
Sebastian Hack committed
618

619
	if (destroy_all_regs) {
Christoph Mallon's avatar
Christoph Mallon committed
620
		/* even if destroyed all is specified, neither SP nor FP are destroyed (else bad things will happen) */
621
622
623
		pset_new_remove(&destroyed_regs, arch_env->sp);
		pset_new_remove(&destroyed_regs, arch_env->bp);
	}
Michael Beck's avatar
Michael Beck committed
624

Christoph Mallon's avatar
Christoph Mallon committed
625
	/* search the largest result proj number */
626
	res_projs = ALLOCANZ(ir_node*, n_res);
Matthias Braun's avatar
Matthias Braun committed
627

Sebastian Hack's avatar
Sebastian Hack committed
628
629
	foreach_out_edge(irn, edge) {
		const ir_edge_t *res_edge;
Matthias Braun's avatar
Matthias Braun committed
630
		ir_node         *irn = get_edge_src_irn(edge);
Sebastian Hack's avatar
Sebastian Hack committed
631

632
		if (!is_Proj(irn) || get_Proj_proj(irn) != pn_Call_T_result)
Matthias Braun's avatar
Matthias Braun committed
633
634
635
636
637
638
639
640
641
642
			continue;

		foreach_out_edge(irn, res_edge) {
			int proj;
			ir_node *res = get_edge_src_irn(res_edge);

			assert(is_Proj(res));

			proj = get_Proj_proj(res);
			assert(proj < n_res);
Matthias Braun's avatar
Matthias Braun committed
643
			assert(res_projs[proj] == NULL);
Matthias Braun's avatar
Matthias Braun committed
644
			res_projs[proj] = res;
Sebastian Hack's avatar
Sebastian Hack committed
645
		}
Matthias Braun's avatar
Matthias Braun committed
646
647
		res_proj = irn;
		break;
Sebastian Hack's avatar
Sebastian Hack committed
648
	}
649

Matthias Braun's avatar
Matthias Braun committed
650
	/** TODO: this is not correct for cases where return values are passed
Christoph Mallon's avatar
Christoph Mallon committed
651
	 * on the stack, but no known ABI does this currently...
Matthias Braun's avatar
Matthias Braun committed
652
653
	 */
	n_reg_results = n_res;
Sebastian Hack's avatar
Sebastian Hack committed
654

655
656
657
658
	assert(obstack_object_size(obst) == 0);
	n_ins = 0;
	in    = ALLOCAN(ir_node*, n_reg_params + pset_new_size(&states));

659
	/* make the back end call node and set its register requirements. */
660
	for (i = 0; i < n_reg_params; ++i) {
661
		in[n_ins++] = get_Call_param(irn, reg_param_idxs[i]);
662
	}
663
664
665

	/* add state registers ins */
	foreach_pset_new(&states, reg, iter) {
666
667
668
669
670
		const arch_register_class_t *cls = arch_register_get_class(reg);
#if 0
		ir_node *regnode = be_abi_reg_map_get(env->regs, reg);
		ir_fprintf(stderr, "Adding %+F\n", regnode);
#endif
671
		ir_node *regnode = new_r_Unknown(irg, arch_register_class_mode(cls));
672
		in[n_ins++]      = regnode;
673
	}
674
	assert(n_ins == (int) (n_reg_params + pset_new_size(&states)));
675

676
	/* ins collected, build the call */
677
678
	if (env->call->flags.bits.call_has_imm && is_SymConst(call_ptr)) {
		/* direct call */
679
		low_call = be_new_Call(dbgi, irg, bl, curr_mem, curr_sp, curr_sp,
680
		                       n_reg_results + pn_be_Call_first_res + pset_new_size(&destroyed_regs),
Matthias Braun's avatar
Matthias Braun committed
681
		                       n_ins, in, get_Call_type(irn));
Sebastian Hack's avatar
Sebastian Hack committed
682
		be_Call_set_entity(low_call, get_SymConst_entity(call_ptr));
683
	} else {
684
		/* indirect call */
685
		low_call = be_new_Call(dbgi, irg, bl, curr_mem, curr_sp, call_ptr,
686
		                       n_reg_results + pn_be_Call_first_res + pset_new_size(&destroyed_regs),
687
		                       n_ins, in, get_Call_type(irn));
Sebastian Hack's avatar
Sebastian Hack committed
688
	}
689
	be_Call_set_pop(low_call, call->pop);
690
691

	/* put the call into the list of all calls for later processing */
692
	ARR_APP1(ir_node *, env->calls, low_call);
693

Matthias Braun's avatar
Matthias Braun committed
694
	/* create new stack pointer */
695
	curr_sp = new_r_Proj(low_call, get_irn_mode(curr_sp), pn_be_Call_sp);
696
697
	be_set_constr_single_reg_out(low_call, pn_be_Call_sp, sp,
			arch_register_req_type_ignore | arch_register_req_type_produces_sp);
698
	arch_set_irn_register(curr_sp, sp);
Matthias Braun's avatar
Matthias Braun committed
699

700
	/* now handle results */
701
	for (i = 0; i < n_res; ++i) {
Matthias Braun's avatar
Matthias Braun committed
702
703
704
705
		int pn;
		ir_node           *proj = res_projs[i];
		be_abi_call_arg_t *arg  = get_call_arg(call, 1, i);

Matthias Braun's avatar
Matthias Braun committed
706
707
708
		/* returns values on stack not supported yet */
		assert(arg->in_reg);

Matthias Braun's avatar
Matthias Braun committed
709
710
711
712
713
714
715
		/*
			shift the proj number to the right, since we will drop the
			unspeakable Proj_T from the Call. Therefore, all real argument
			Proj numbers must be increased by pn_be_Call_first_res
		*/
		pn = i + pn_be_Call_first_res;

716
		if (proj == NULL) {
717
			ir_type *res_type = get_method_res_type(call_tp, i);
Matthias Braun's avatar
Matthias Braun committed
718
			ir_mode *mode     = get_type_mode(res_type);
719
			proj              = new_r_Proj(low_call, mode, pn);
Matthias Braun's avatar
Matthias Braun committed
720
721
722
723
724
725
726
			res_projs[i]      = proj;
		} else {
			set_Proj_pred(proj, low_call);
			set_Proj_proj(proj, pn);
		}

		if (arg->in_reg) {
727
			pset_new_remove(&destroyed_regs, arg->reg);
Matthias Braun's avatar
Matthias Braun committed
728
729
730
		}
	}

731
	/*
732
733
		Set the register class of the call address to
		the backend provided class (default: stack pointer class)
734
	*/
735
	be_node_set_reg_class_in(low_call, be_pos_Call_ptr, call->cls_addr);
736

737
	DBG((dbg, LEVEL_3, "\tcreated backend call %+F\n", low_call));
738

Sebastian Hack's avatar
Sebastian Hack committed
739
	/* Set the register classes and constraints of the Call parameters. */
740
741
	for (i = 0; i < n_reg_params; ++i) {
		int index = reg_param_idxs[i];
Sebastian Hack's avatar
Sebastian Hack committed
742
743
		be_abi_call_arg_t *arg = get_call_arg(call, 0, index);
		assert(arg->reg != NULL);
744

745
746
		be_set_constr_single_reg_in(low_call, be_pos_Call_first_arg + i,
		                            arg->reg, 0);
Sebastian Hack's avatar
Sebastian Hack committed
747
748
749
	}

	/* Set the register constraints of the results. */
Matthias Braun's avatar
Matthias Braun committed
750
751
752
753
	for (i = 0; i < n_res; ++i) {
		ir_node                 *proj = res_projs[i];
		const be_abi_call_arg_t *arg  = get_call_arg(call, 1, i);
		int                      pn   = get_Proj_proj(proj);
754

Sebastian Hack's avatar
Sebastian Hack committed
755
		assert(arg->in_reg);
756
		be_set_constr_single_reg_out(low_call, pn, arg->reg, 0);
757
		arch_set_irn_register(proj, arg->reg);
Sebastian Hack's avatar
Sebastian Hack committed
758
	}
759
760
	exchange(irn, low_call);

Matthias Braun's avatar
Matthias Braun committed
761
	/* kill the ProjT node */
762
	if (res_proj != NULL) {
763
		kill_node(res_proj);
764
765
	}

Sebastian Hack's avatar
Sebastian Hack committed
766
767
	/* Make additional projs for the caller save registers
	   and the Keep node which keeps them alive. */
768
	{
Sebastian Hack's avatar
Sebastian Hack committed
769
		const arch_register_t *reg;
770
		ir_node               **in, *keep;
771
772
		int                   i;
		int                   n = 0;
773
774
		int                   curr_res_proj = pn_be_Call_first_res + n_reg_results;
		pset_new_iterator_t   iter;
775
		int                   n_ins;
Sebastian Hack's avatar
Sebastian Hack committed
776

777
778
		n_ins = (int)pset_new_size(&destroyed_regs) + n_reg_results + 1;
		in    = ALLOCAN(ir_node *, n_ins);
779

780
781
		/* also keep the stack pointer */
		set_irn_link(curr_sp, (void*) sp);
782
		in[n++] = curr_sp;
783

784
		foreach_pset_new(&destroyed_regs, reg, iter) {
785
			ir_node *proj = new_r_Proj(low_call, reg->reg_class->mode, curr_res_proj);
Sebastian Hack's avatar
Sebastian Hack committed
786

Sebastian Hack's avatar
Sebastian Hack committed
787
			/* memorize the register in the link field. we need afterwards to set the register class of the keep correctly. */
788
			be_set_constr_single_reg_out(low_call, curr_res_proj, reg, 0);
789
			arch_set_irn_register(proj, reg);
790

Matthias Braun's avatar
Matthias Braun committed
791
			set_irn_link(proj, (void*) reg);
792
			in[n++] = proj;
793
			++curr_res_proj;
Sebastian Hack's avatar
Sebastian Hack committed
794
795
		}

796
		for (i = 0; i < n_reg_results; ++i) {
Matthias Braun's avatar
Matthias Braun committed
797
			ir_node *proj = res_projs[i];
798
			const arch_register_t *reg = arch_get_irn_register(proj);
Matthias Braun's avatar
Matthias Braun committed
799
			set_irn_link(proj, (void*) reg);
800
			in[n++] = proj;
Matthias Braun's avatar
Matthias Braun committed
801
		}
802
		assert(n <= n_ins);
Matthias Braun's avatar
Matthias Braun committed
803

804
		/* create the Keep for the caller save registers */
805
		keep = be_new_Keep(bl, n, in);
806
		for (i = 0; i < n; ++i) {
Sebastian Hack's avatar
Sebastian Hack committed
807
			const arch_register_t *reg = get_irn_link(in[i]);
808
			be_node_set_reg_class_in(keep, i, reg->reg_class);
Sebastian Hack's avatar
Sebastian Hack committed
809
		}
Sebastian Hack's avatar
Sebastian Hack committed
810
811
812
	}

	/* Clean up the stack. */
813
814
815
	assert(stack_size >= call->pop);
	stack_size -= call->pop;

816
	if (stack_size > 0) {
817
818
819
820
		ir_node *mem_proj = NULL;

		foreach_out_edge(low_call, edge) {
			ir_node *irn = get_edge_src_irn(edge);
821
			if (is_Proj(irn) && get_Proj_proj(irn) == pn_Call_M) {
822
823
824
825
				mem_proj = irn;
				break;
			}
		}
Sebastian Hack's avatar
Sebastian Hack committed
826

827
		if (! mem_proj) {
828
			mem_proj = new_r_Proj(low_call, mode_M, pn_be_Call_M_regular);
Sebastian Hack's avatar
Sebastian Hack committed
829
830
			keep_alive(mem_proj);
		}
831
832
833
	}
	/* Clean up the stack frame or revert alignment fixes if we allocated it */
	if (! no_alloc) {
834
		curr_sp = be_new_IncSP(sp, bl, curr_sp, -stack_size, 0);
Sebastian Hack's avatar
Sebastian Hack committed
835
836
837
	}

	be_abi_call_free(call);
838
839
840

	pset_new_destroy(&states);
	pset_new_destroy(&destroyed_regs);
841
842
843
844

	return curr_sp;
}

845
846
847
848
849
/**
 * Adjust the size of a node representing a stack alloc or free for the minimum stack alignment.
 *
 * @param alignment  the minimum stack alignment
 * @param size       the node containing the non-aligned size
850
 * @param block      the block where new nodes are allocated on
851
852
853
854
 * @param dbg        debug info for new nodes
 *
 * @return a node representing the aligned size
 */
855
static ir_node *adjust_alloc_size(unsigned stack_alignment, ir_node *size,
856
                                  ir_node *block, dbg_info *dbg)
857
{
858
	if (stack_alignment > 1) {
859
860
861
862
		ir_mode  *mode;
		tarval   *tv;
		ir_node  *mask;
		ir_graph *irg;
Michael Beck's avatar
Michael Beck committed
863

864
		assert(is_po2(stack_alignment));
865

Michael Beck's avatar
Michael Beck committed
866
867
		mode = get_irn_mode(size);
		tv   = new_tarval_from_long(stack_alignment-1, mode);
868
		irg  = get_Block_irg(block);
869
		mask = new_r_Const(irg, tv);
870
		size = new_rd_Add(dbg, block, size, mask, mode);
871
872

		tv   = new_tarval_from_long(-(long)stack_alignment, mode);
873
		mask = new_r_Const(irg, tv);
874
		size = new_rd_And(dbg, block, size, mask, mode);
875
876
877
	}
	return size;
}
878
879
880
881
/**
 * Adjust an alloca.
 * The alloca is transformed into a back end alloca node and connected to the stack nodes.
 */
Matthias Braun's avatar
Matthias Braun committed
882
static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp)
883
{
884
885
886
887
888
	ir_node *block;
	ir_graph *irg;
	ir_node *alloc_mem;
	ir_node *alloc_res;
	ir_type *type;
889
	dbg_info *dbg;
890

891
	const ir_edge_t *edge;
892