bespillutil.c 36.4 KB
Newer Older
1
2
/*
 * This file is part of libFirm.
3
 * Copyright (C) 2012 University of Karlsruhe.
4
5
6
7
8
9
 */

/**
 * @file
 * @brief       implementation of the spill/reload placement abstraction layer
 * @author      Daniel Grund, Sebastian Hack, Matthias Braun
10
 * @date        29.09.2005
11
12
13
14
15
16
 */
#include <stdlib.h>
#include <stdbool.h>

#include "array.h"
#include "bearch.h"
Matthias Braun's avatar
Matthias Braun committed
17
18
19
20
21
#include "bechordal_t.h"
#include "beirg.h"
#include "belive.h"
#include "bemodule.h"
#include "benode.h"
22
23
24
25
26
#include "besched.h"
#include "bespill.h"
#include "bespillutil.h"
#include "bessaconstr.h"
#include "be_t.h"
Matthias Braun's avatar
Matthias Braun committed
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include "beutil.h"
#include "debug.h"
#include "execfreq.h"
#include "ident_t.h"
#include "irbackedge_t.h"
#include "ircons_t.h"
#include "iredges_t.h"
#include "irgmod.h"
#include "irgwalk.h"
#include "irnodehashmap.h"
#include "irnode_t.h"
#include "statev_t.h"
#include "type_t.h"
#include "util.h"
41

42
43
DEBUG_ONLY(static firm_dbg_module_t *dbg;)
DEBUG_ONLY(static firm_dbg_module_t *dbg_constr;)
44
45
46
47
48
49
50
51

#define REMAT_COST_INFINITE  1000

typedef struct reloader_t reloader_t;
struct reloader_t {
	reloader_t *next;
	ir_node    *reloader;
	int         remat_cost_delta; /** costs needed for rematerialization,
Matthias Braun's avatar
Matthias Braun committed
52
	                                  compared to placing a reload */
53
54
55
56
57
58
59
60
61
62
63
};

typedef struct spill_t spill_t;
struct spill_t {
	spill_t *next;
	ir_node *after;  /**< spill has to be placed after this node (or earlier) */
	ir_node *spill;
};

typedef struct spill_info_t spill_info_t;
struct spill_info_t {
64
65
	ir_node      *to_spill;  /**< the value that should get spilled */
	reloader_t   *reloaders; /**< list of places where the value should get
Matthias Braun's avatar
Matthias Braun committed
66
	                              reloaded */
67
	spill_t      *spills;    /**< list of latest places where spill must be
Matthias Braun's avatar
Matthias Braun committed
68
	                              placed */
69
70
71
72
73
74
	spill_info_t *next;
	spill_info_t *next_mem_phi;
	double        spill_costs; /**< costs needed for spilling the value */
	bool          spilled_phi; /**< true when the whole Phi has been spilled and
	                                will be replaced with a PhiM. false if only
	                                the value of the Phi gets spilled */
75
76
77
78
};

struct spill_env_t {
	ir_graph         *irg;
79
80
81
	ir_nodehashmap_t  spillmap;
	spill_info_t     *spills;
	spill_info_t     *mem_phis;
82
	struct obstack    obst;
83
	regalloc_if_t     regif;
84
85
86
87
88
89
90
91
92
	unsigned          spill_count;
	unsigned          reload_count;
	unsigned          remat_count;
	unsigned          spilled_phi_count;
};

/**
 * Returns spill info for a specific value (the value that is to be spilled)
 */
93
static spill_info_t *get_spillinfo(spill_env_t *env, ir_node *value)
94
{
95
96
97
98
99
100
101
102
103
104
	spill_info_t *info = ir_nodehashmap_get(spill_info_t, &env->spillmap,
	                                        value);
	if (info == NULL) {
		info = OALLOCZ(&env->obst, spill_info_t);
		info->to_spill    = value;
		info->spill_costs = -1;
		ir_nodehashmap_insert(&env->spillmap, value, info);

		info->next = env->spills;
		env->spills = info;
105
106
	}

107
	return info;
108
109
}

110
spill_env_t *be_new_spill_env(ir_graph *irg, const regalloc_if_t *regif)
111
{
112
113
	spill_env_t *env = XMALLOCZ(spill_env_t);
	env->irg         = irg;
114
	env->regif       = *regif;
115
	ir_nodehashmap_init(&env->spillmap);
116
117
118
119
120
121
	obstack_init(&env->obst);
	return env;
}

void be_delete_spill_env(spill_env_t *env)
{
122
	ir_nodehashmap_destroy(&env->spillmap);
123
124
125
126
127
128
	obstack_free(&env->obst, NULL);
	free(env);
}

void be_add_spill(spill_env_t *env, ir_node *to_spill, ir_node *after)
{
129
	assert(!arch_irn_is(skip_Proj_const(to_spill), dont_spill));
130
131
132
133
134
135
	DB((dbg, LEVEL_1, "Add spill of %+F after %+F\n", to_spill, after));

	/* Just for safety make sure that we do not insert the spill in front of a phi */
	assert(!is_Phi(sched_next(after)));

	/* spills that are dominated by others are not needed */
Matthias Braun's avatar
Matthias Braun committed
136
	spill_info_t *spill_info = get_spillinfo(env, to_spill);
137
138
	for (spill_t **anchor = &spill_info->spills; *anchor;) {
		spill_t *const s = *anchor;
139
		/* no need to add this spill if it is dominated by another */
Matthias Braun's avatar
Matthias Braun committed
140
		if (value_strictly_dominates(s->after, after)) {
141
142
143
144
			DB((dbg, LEVEL_1, "...dominated by %+F, not added\n", s->after));
			return;
		}
		/* remove spills that we dominate */
Matthias Braun's avatar
Matthias Braun committed
145
		if (value_strictly_dominates(after, s->after)) {
146
			DB((dbg, LEVEL_1, "...remove old spill at %+F\n", s->after));
147
			*anchor = s->next;
148
		} else {
149
			anchor = &s->next;
150
151
152
		}
	}

Matthias Braun's avatar
Matthias Braun committed
153
154
155
156
	spill_t *spill = OALLOC(&env->obst, spill_t);
	spill->after = after;
	spill->next  = spill_info->spills;
	spill->spill = NULL;
157
158
159
	spill_info->spills = spill;
}

Matthias Braun's avatar
Matthias Braun committed
160
void be_add_reload(spill_env_t *env, ir_node *to_spill, ir_node *before)
161
{
162
	assert(!arch_irn_is(skip_Proj_const(to_spill), dont_spill));
Matthias Braun's avatar
Matthias Braun committed
163
	assert(!be_is_Keep(before));
164

Matthias Braun's avatar
Matthias Braun committed
165
	spill_info_t *info = get_spillinfo(env, to_spill);
166
167

	/* put reload into list */
Matthias Braun's avatar
Matthias Braun committed
168
	reloader_t *rel       = OALLOC(&env->obst, reloader_t);
169
170
	rel->next             = info->reloaders;
	rel->reloader         = before;
Matthias Braun's avatar
Matthias Braun committed
171
	rel->remat_cost_delta = 0;
172

Matthias Braun's avatar
Matthias Braun committed
173
	info->reloaders = rel;
174

Matthias Braun's avatar
Matthias Braun committed
175
176
177
	DBG((dbg, LEVEL_1,
	     "creating spillinfo for %+F, will be reloaded before %+F\n",
	     to_spill, before));
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
}

ir_node *be_get_end_of_block_insertion_point(const ir_node *block)
{
	ir_node *last = sched_last(block);

	/* we might have keeps behind the jump... */
	while (be_is_Keep(last)) {
		last = sched_prev(last);
		assert(!sched_is_end(last));
	}

	assert(is_cfop(last));

	/* add the reload before the (cond-)jump */
	return last;
}

/**
 * Returns the point at which you can insert a node that should be executed
 * before block @p block when coming from pred @p pos.
 */
static ir_node *get_block_insertion_point(ir_node *block, int pos)
{
	/* simply add the reload to the beginning of the block if we only have 1
	 * predecessor. We don't need to check for phis as there can't be any in a
	 * block with only 1 pred. */
205
	if (get_Block_n_cfgpreds(block) == 1) {
206
207
208
209
210
		assert(!is_Phi(sched_first(block)));
		return sched_first(block);
	}

	/* We have to reload the value in pred-block */
Matthias Braun's avatar
Matthias Braun committed
211
	ir_node *predblock = get_Block_cfgpred_block(block, pos);
212
213
214
215
	return be_get_end_of_block_insertion_point(predblock);
}

void be_add_reload_on_edge(spill_env_t *env, ir_node *to_spill, ir_node *block,
Matthias Braun's avatar
Matthias Braun committed
216
                           int pos)
217
218
{
	ir_node *before = get_block_insertion_point(block, pos);
Matthias Braun's avatar
Matthias Braun committed
219
	be_add_reload(env, to_spill, before);
220
221
}

222
void be_spill_phi(spill_env_t *const env, ir_node *const phi)
223
{
224
	assert(is_Phi(phi));
225

226
	spill_info_t *info = get_spillinfo(env, phi);
227
228
229
	info->spilled_phi  = true;
	info->next_mem_phi = env->mem_phis;
	env->mem_phis      = info;
230
231

	/* create spills for the phi arguments */
232
	foreach_irn_in(phi, i, arg) {
233
		ir_node *const insert = be_move_after_schedule_first(arg);
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
		be_add_spill(env, arg, insert);
	}
}

static void determine_spill_costs(spill_env_t *env, spill_info_t *spillinfo);

/**
 * Creates a spill.
 *
 * @param senv      the spill environment
 * @param irn       the node that should be spilled
 * @param ctx_irn   an user of the spilled node
 * @return a be_Spill node
 */
static void spill_irn(spill_env_t *env, spill_info_t *spillinfo)
{
	/* determine_spill_costs must have been run before */
	assert(spillinfo->spill_costs >= 0);

253
	ir_node *const to_spill = spillinfo->to_spill;
254
	DBG((dbg, LEVEL_1, "spilling %+F ... \n", to_spill));
Matthias Braun's avatar
Matthias Braun committed
255
256
	for (spill_t *spill = spillinfo->spills; spill != NULL;
	     spill = spill->next) {
257
		ir_node *const after = be_move_after_schedule_first(spill->after);
258
		spill->spill = env->regif.new_spill(to_spill, after);
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
		DB((dbg, LEVEL_1, "\t%+F after %+F\n", spill->spill, after));
		env->spill_count++;
	}
	DBG((dbg, LEVEL_1, "\n"));
}

static void spill_node(spill_env_t *env, spill_info_t *spillinfo);

/**
 * If the first usage of a Phi result would be out of memory
 * there is no sense in allocating a register for it.
 * Thus we spill it and all its operands to the same spill slot.
 * Therefore the phi/dataB becomes a phi/Memory
 *
 * @param senv      the spill environment
 * @param phi       the Phi node that should be spilled
 * @param ctx_irn   an user of the spilled node
 */
static void spill_phi(spill_env_t *env, spill_info_t *spillinfo)
{
Matthias Braun's avatar
Matthias Braun committed
279
	ir_node *phi = spillinfo->to_spill;
280
281
282
	DBG((dbg, LEVEL_1, "spilling Phi %+F:\n", phi));

	/* build a new PhiM */
283
	ir_node *const block = get_nodes_block(phi);
284
	ir_node *const phim  = be_new_Phi0(block, arch_memory_req);
285
	sched_add_after(block, phim);
286
287

	/* override or replace spills list... */
Matthias Braun's avatar
Matthias Braun committed
288
	spill_t *spill = OALLOC(&env->obst, spill_t);
289
290
291
	spill->after = be_move_after_schedule_first(phi);
	spill->spill = phim;
	spill->next  = NULL;
292
293
294
295

	spillinfo->spills = spill;
	env->spilled_phi_count++;

296
297
	unsigned  const arity = get_Phi_n_preds(phi);
	ir_node **const ins   = ALLOCAN(ir_node*, arity);
298
	foreach_irn_in(phi, i, arg) {
299
300
301
302
303
		spill_info_t *arg_info = get_spillinfo(env, arg);

		determine_spill_costs(env, arg_info);
		spill_node(env, arg_info);

304
		ins[i] = arg_info->spills->spill;
305
	}
306
307
	be_complete_Phi(phim, arity, ins);
	DBG((dbg, LEVEL_1, "... done spilling Phi %+F, created PhiM %+F\n", phi, phim));
308
309
310
311
312
313
314
315
316
317
318
}

/**
 * Spill a node.
 *
 * @param senv      the spill environment
 * @param to_spill  the node that should be spilled
 */
static void spill_node(spill_env_t *env, spill_info_t *spillinfo)
{
	/* node is already spilled */
319
	if (spillinfo->spills != NULL && spillinfo->spills->spill != NULL)
320
321
		return;

322
	if (spillinfo->spilled_phi) {
323
324
325
326
327
328
329
330
		spill_phi(env, spillinfo);
	} else {
		spill_irn(env, spillinfo);
	}
}

/**
 * Tests whether value @p arg is available before node @p reloader
Matthias Braun's avatar
Matthias Braun committed
331
 * @returns true if value is available
332
 */
Matthias Braun's avatar
Matthias Braun committed
333
static bool is_value_available(spill_env_t *env, const ir_node *arg)
334
{
335
	if (is_Unknown(arg) || is_NoMem(arg))
Matthias Braun's avatar
Matthias Braun committed
336
		return true;
337
	if (arch_irn_is(skip_Proj_const(arg), spill))
Matthias Braun's avatar
Matthias Braun committed
338
		return true;
339
	if (arg == get_irg_frame(env->irg))
Matthias Braun's avatar
Matthias Braun committed
340
		return true;
341
	if (get_irn_mode(arg) == mode_T)
Matthias Braun's avatar
Matthias Braun committed
342
343
		return false;
	/* "Ignore registers" are always available */
344
	if (arch_irn_is_ignore(arg))
Matthias Braun's avatar
Matthias Braun committed
345
		return true;
346

Matthias Braun's avatar
Matthias Braun committed
347
	return false;
348
349
350
351
352
353
354
355
356
357
358
359
360
}

/**
 * Check if a node is rematerializable. This tests for the following conditions:
 *
 * - The node itself is rematerializable
 * - All arguments of the node are available or also rematerialisable
 * - The costs for the rematerialisation operation is less or equal a limit
 *
 * Returns the costs needed for rematerialisation or something
 * >= REMAT_COST_INFINITE if remat is not possible.
 */
static int check_remat_conditions_costs(spill_env_t *env,
Matthias Braun's avatar
Matthias Braun committed
361
362
363
                                        const ir_node *spilled,
                                        const ir_node *reloader,
                                        int parentcosts)
364
{
365
	const ir_node *insn = skip_Proj_const(spilled);
366

367
	assert(!arch_irn_is(insn, spill));
368
	if (!arch_irn_is(insn, rematerializable))
369
370
		return REMAT_COST_INFINITE;

371
	int costs = isa_if->get_op_estimated_cost(insn);
372
373
	int spillcosts = env->regif.reload_cost + env->regif.spill_cost;
	if (parentcosts + costs >= spillcosts)
374
		return REMAT_COST_INFINITE;
375

376
	/* never rematerialize a node which modifies the flags.
377
	 * (would be better to test whether the flags are actually live at point
378
379
	 * reloader...)
	 */
Matthias Braun's avatar
Matthias Braun committed
380
	if (arch_irn_is(insn, modify_flags))
381
382
		return REMAT_COST_INFINITE;

Matthias Braun's avatar
Matthias Braun committed
383
	int argremats = 0;
384
	foreach_irn_in(insn, i, arg) {
Matthias Braun's avatar
Matthias Braun committed
385
		if (is_value_available(env, arg))
386
387
388
			continue;

		/* we have to rematerialize the argument as well */
389
		++argremats;
390
		if (argremats > 1) {
391
			/* we only support rematerializing 1 argument at the moment,
392
			 * as multiple arguments could increase register pressure */
393
394
395
396
397
			return REMAT_COST_INFINITE;
		}

		costs += check_remat_conditions_costs(env, arg, reloader,
		                                      parentcosts + costs);
398
		if (parentcosts + costs >= spillcosts)
399
400
401
402
403
404
405
406
407
			return REMAT_COST_INFINITE;
	}

	return costs;
}

/**
 * Re-materialize a node.
 *
Michael Beck's avatar
Michael Beck committed
408
 * @param env       the spill environment
409
410
411
412
413
 * @param spilled   the node that was spilled
 * @param reloader  a irn that requires a reload
 */
static ir_node *do_remat(spill_env_t *env, ir_node *spilled, ir_node *reloader)
{
Matthias Braun's avatar
Matthias Braun committed
414
	ir_node **ins = ALLOCAN(ir_node*, get_irn_arity(spilled));
415
	foreach_irn_in(spilled, i, arg) {
Matthias Braun's avatar
Matthias Braun committed
416
		if (is_value_available(env, arg)) {
417
418
419
420
421
422
423
			ins[i] = arg;
		} else {
			ins[i] = do_remat(env, arg, reloader);
		}
	}

	/* create a copy of the node */
424
425
	ir_node *const bl  = get_nodes_block(reloader);
	ir_node *const res = new_similar_node(spilled, bl, ins);
426
427
	if (env->regif.mark_remat)
		env->regif.mark_remat(res);
428

Matthias Braun's avatar
Matthias Braun committed
429
430
	DBG((dbg, LEVEL_1, "Insert remat %+F of %+F before reloader %+F\n", res,
	     spilled, reloader));
431

Christoph Mallon's avatar
Christoph Mallon committed
432
	if (!is_Proj(res))
433
434
435
436
437
438
439
		sched_add_before(reloader, res);

	return res;
}

double be_get_spill_costs(spill_env_t *env, ir_node *to_spill, ir_node *before)
{
Matthias Braun's avatar
Matthias Braun committed
440
	(void)to_spill;
441
	ir_node *block = get_nodes_block(before);
442
	double   freq  = get_block_execfreq(block);
443
	return env->regif.spill_cost * freq;
444
445
}

Matthias Braun's avatar
Matthias Braun committed
446
447
unsigned be_get_reload_costs_no_weight(spill_env_t *env,
                                       const ir_node *to_spill,
448
449
                                       const ir_node *before)
{
450
	if (be_do_remats) {
451
452
		/* is the node rematerializable? */
		unsigned costs = check_remat_conditions_costs(env, to_spill, before, 0);
453
		if (costs < (unsigned) env->regif.reload_cost)
454
455
456
			return costs;
	}

457
	return env->regif.reload_cost;
458
459
460
461
}

double be_get_reload_costs(spill_env_t *env, ir_node *to_spill, ir_node *before)
{
462
463
	ir_node *block = get_nodes_block(before);
	double   freq  = get_block_execfreq(block);
464

465
	if (be_do_remats) {
466
467
		/* is the node rematerializable? */
		int costs = check_remat_conditions_costs(env, to_spill, before, 0);
468
		if (costs < (int)env->regif.reload_cost)
469
470
471
			return costs * freq;
	}

472
	return env->regif.reload_cost * freq;
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
}

double be_get_reload_costs_on_edge(spill_env_t *env, ir_node *to_spill,
                                   ir_node *block, int pos)
{
	ir_node *before = get_block_insertion_point(block, pos);
	return be_get_reload_costs(env, to_spill, before);
}

/**
 * analyzes how to best spill a node and determine costs for that
 */
static void determine_spill_costs(spill_env_t *env, spill_info_t *spillinfo)
{
	/* already calculated? */
488
	if (spillinfo->spill_costs >= 0)
489
490
		return;

491
492
	ir_node *const to_spill = spillinfo->to_spill;
	ir_node *const insn     = skip_Proj(to_spill);
493
	assert(!arch_irn_is(insn, dont_spill));
494
	assert(!arch_irn_is(insn, reload));
495

Matthias Braun's avatar
Matthias Braun committed
496
497
	ir_node *spill_block    = get_nodes_block(insn);
	double   spill_execfreq = get_block_execfreq(spill_block);
498

499
	if (spillinfo->spilled_phi) {
500
501
		/* TODO calculate correct costs...
		 * (though we can't remat this node anyway so no big problem) */
502
		spillinfo->spill_costs = env->regif.spill_cost * spill_execfreq;
503
504
505
		return;
	}

506
507
508
509
510
511
512
513
514
	/* calculate sum of execution frequencies of individual spills */
	assert(spillinfo->spills);
	double spills_execfreq = 0;
	for (spill_t *s = spillinfo->spills; s != NULL; s = s->next) {
		ir_node *spill_block = get_block(s->after);
		double   freq        = get_block_execfreq(spill_block);

		spills_execfreq += freq;
	}
515

516
	DB((dbg, LEVEL_1, "%+F: latespillcosts %f after def: %f\n", to_spill,
yb9976's avatar
yb9976 committed
517
518
	    spills_execfreq * env->regif.spill_cost,
	    spill_execfreq * env->regif.spill_cost));
519

520
521
522
	/* multi-/latespill is advantageous -> return*/
	if (spills_execfreq < spill_execfreq) {
		DB((dbg, LEVEL_1, "use latespills for %+F\n", to_spill));
523
		spillinfo->spill_costs = spills_execfreq * env->regif.spill_cost;
524
		return;
525
526
527
	}

	/* override spillinfos or create a new one */
Matthias Braun's avatar
Matthias Braun committed
528
	spill_t *spill = OALLOC(&env->obst, spill_t);
529
	spill->after   = be_move_after_schedule_first(insn);
Matthias Braun's avatar
Matthias Braun committed
530
531
	spill->next    = NULL;
	spill->spill   = NULL;
532
533

	spillinfo->spills      = spill;
534
	spillinfo->spill_costs = spill_execfreq * env->regif.spill_cost;
535
536
537
538
539
	DB((dbg, LEVEL_1, "spill %+F after definition\n", to_spill));
}

void be_insert_spills_reloads(spill_env_t *env)
{
540
	be_timer_push(T_RA_SPILL_APPLY);
541
542
543

	/* create all phi-ms first, this is needed so, that phis, hanging on
	   spilled phis work correctly */
544
545
	for (spill_info_t *info = env->mem_phis; info != NULL;
	     info = info->next_mem_phi) {
546
547
548
549
		spill_node(env, info);
	}

	/* process each spilled node */
550
	for (spill_info_t *si = env->spills; si != NULL; si = si->next) {
551
552
553
		ir_node  *to_spill        = si->to_spill;
		ir_node **copies          = NEW_ARR_F(ir_node*, 0);
		double    all_remat_costs = 0; /** costs when we would remat all nodes */
554
		bool      force_remat     = false;
555
556
557
558
559
560

		DBG((dbg, LEVEL_1, "\nhandling all reloaders of %+F:\n", to_spill));

		determine_spill_costs(env, si);

		/* determine possibility of rematerialisations */
561
		if (be_do_remats) {
yb9976's avatar
yb9976 committed
562
563
			/* calculate cost savings for each individual value when it would
			   be rematerialised instead of reloaded */
Matthias Braun's avatar
Matthias Braun committed
564
565
			for (reloader_t *rld = si->reloaders; rld != NULL;
			     rld = rld->next) {
566
				ir_node *reloader = rld->reloader;
567
				if (rld->remat_cost_delta >= REMAT_COST_INFINITE) {
568
569
570
571
572
573
					DBG((dbg, LEVEL_2, "\treload before %+F is forbidden\n",
					     reloader));
					all_remat_costs = REMAT_COST_INFINITE;
					continue;
				}

Matthias Braun's avatar
Matthias Braun committed
574
575
				int remat_cost = check_remat_conditions_costs(env, to_spill,
				                                              reloader, 0);
576
				if (remat_cost >= REMAT_COST_INFINITE) {
577
578
579
580
581
582
583
					DBG((dbg, LEVEL_2, "\tremat before %+F not possible\n",
					     reloader));
					rld->remat_cost_delta = REMAT_COST_INFINITE;
					all_remat_costs       = REMAT_COST_INFINITE;
					continue;
				}

584
				int remat_cost_delta  = remat_cost - env->regif.reload_cost;
585
				rld->remat_cost_delta = remat_cost_delta;
Matthias Braun's avatar
Matthias Braun committed
586
587
				ir_node *block        = get_block(reloader);
				double   freq         = get_block_execfreq(block);
588
589
590
591
592
				all_remat_costs      += remat_cost_delta * freq;
				DBG((dbg, LEVEL_2, "\tremat costs delta before %+F: "
				     "%d (rel %f)\n", reloader, remat_cost_delta,
				     remat_cost_delta * freq));
			}
593
			if (all_remat_costs < REMAT_COST_INFINITE) {
594
595
596
597
				/* we don't need the costs for the spill if we can remat
				   all reloaders */
				all_remat_costs -= si->spill_costs;
				DBG((dbg, LEVEL_2, "\tspill costs %d (rel %f)\n",
598
				     env->regif.spill_cost, si->spill_costs));
599
600
			}

601
			if (all_remat_costs < 0) {
Matthias Braun's avatar
Matthias Braun committed
602
				force_remat = true;
603
604
605
606
607
608
				DBG((dbg, LEVEL_1, "\nforcing remats of all reloaders (%f)\n",
				     all_remat_costs));
			}
		}

		/* go through all reloads for this spill */
Matthias Braun's avatar
Matthias Braun committed
609
		for (reloader_t *rld = si->reloaders; rld != NULL; rld = rld->next) {
610
			ir_node *copy; /* a reload is a "copy" of the original value */
611
			if (be_do_remats && (force_remat || rld->remat_cost_delta < 0)) {
612
				copy = do_remat(env, to_spill, rld->reloader);
Christoph Mallon's avatar
Christoph Mallon committed
613
				++env->remat_count;
614
615
616
617
618
619
620
			} else {
				/* make sure we have a spill */
				spill_node(env, si);

				/* create a reload, use the first spill for now SSA
				 * reconstruction for memory comes below */
				assert(si->spills != NULL);
621
				copy = env->regif.new_reload(si->to_spill, si->spills->spill,
yb9976's avatar
yb9976 committed
622
				                             rld->reloader);
623
624
625
626
627
628
629
630
631
632
633
634
				env->reload_count++;
			}

			DBG((dbg, LEVEL_1, " %+F of %+F before %+F\n",
			     copy, to_spill, rld->reloader));
			ARR_APP1(ir_node*, copies, copy);
		}

		/* if we had any reloads or remats, then we need to reconstruct the
		 * SSA form for the spilled value */
		if (ARR_LEN(copies) > 0) {
			be_ssa_construction_env_t senv;
635
			be_ssa_construction_init(&senv, env->irg);
636
637
638
639
640
641
642
643
			be_ssa_construction_add_copy(&senv, to_spill);
			be_ssa_construction_add_copies(&senv, copies, ARR_LEN(copies));
			be_ssa_construction_fix_users(&senv, to_spill);
			be_ssa_construction_destroy(&senv);
		}
		/* need to reconstruct SSA form if we had multiple spills */
		if (si->spills != NULL && si->spills->next != NULL) {
			be_ssa_construction_env_t senv;
644
			be_ssa_construction_init(&senv, env->irg);
Matthias Braun's avatar
Matthias Braun committed
645
646
647
			unsigned spill_count = 0;
			for (spill_t *spill = si->spills ; spill != NULL;
			     spill = spill->next) {
648
				/* maybe we rematerialized the value and need no spill */
649
				if (spill->spill == NULL)
650
651
					continue;
				be_ssa_construction_add_copy(&senv, spill->spill);
Matthias Braun's avatar
Matthias Braun committed
652
				++spill_count;
653
			}
654
			if (spill_count > 1) {
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
				/* all reloads are attached to the first spill, fix them now */
				be_ssa_construction_fix_users(&senv, si->spills->spill);
			}

			be_ssa_construction_destroy(&senv);
		}

		DEL_ARR_F(copies);
		si->reloaders = NULL;
	}

	stat_ev_dbl("spill_spills", env->spill_count);
	stat_ev_dbl("spill_reloads", env->reload_count);
	stat_ev_dbl("spill_remats", env->remat_count);
	stat_ev_dbl("spill_spilled_phis", env->spilled_phi_count);

	/* Matze: In theory be_ssa_construction should take care of the liveness...
	 * try to disable this again in the future */
673
	be_invalidate_live_sets(env->irg);
674

675
	be_remove_dead_nodes_from_schedule(env->irg);
676

677
	be_timer_pop(T_RA_SPILL_APPLY);
678
679
}

680
681
682
683
684
685
686
687
static void be_new_Copy_for_input(ir_node *const val, ir_node *const before, int const pos)
{
	ir_node *const block = get_nodes_block(before);
	ir_node *const copy  = be_new_Copy(block, val);
	sched_add_before(before, copy);
	set_irn_n(before, pos, copy);
}

688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
static be_irg_t      *birg;
static be_lv_t       *lv;
static unsigned long  precol_copies;
static unsigned long  multi_precol_copies;
static unsigned long  constrained_livethrough_copies;

static void prepare_constr_insn(ir_node *const node)
{
	/* Insert a copy for constraint inputs attached to a value which can't
	 * fulfill the constraint
	 * (typical example: stack pointer as input to copyb)
	 * TODO: This really just checks precolored registers at the moment and
	 *       ignores the general case of not matching in/out constraints */
	foreach_irn_in(node, i, op) {
		const arch_register_t *const reg = arch_get_irn_register(op);
		if (reg == NULL)
			continue;

		/* Precolored with an ignore register (which is not virtual). */
707
		if ((reg->is_virtual) ||
708
709
710
		    rbitset_is_set(birg->allocatable_regs, reg->global_index))
			continue;

711
		arch_register_req_t const *const req = arch_get_irn_register_req_in(node, i);
712
		if (req->limited == NULL)
713
714
715
716
			continue;
		if (rbitset_is_set(req->limited, reg->index))
			continue;

717
		be_new_Copy_for_input(op, node, i);
718
		++precol_copies;
719
		DBG((dbg_constr, LEVEL_3, "inserting ignore arg copy for %+F pos %d\n", node, i));
720
721
722
723
724
725
	}

	/* insert copies for nodes that occur constrained more than once. */
	for (int i = 0, arity = get_irn_arity(node); i < arity; ++i) {
		const arch_register_req_t *const req
			= arch_get_irn_register_req_in(node, i);
726
		if (req->limited == NULL)
727
728
729
			continue;

		ir_node *in = get_irn_n(node, i);
730
731
		const arch_register_req_t *const in_req = arch_get_irn_register_req(in);
		if (in_req->ignore)
732
			continue;
733
		arch_register_class_t const *const cls = req->cls;
734
735
736
737
738
		for (int i2 = i + 1; i2 < arity; ++i2) {
			const arch_register_req_t *const req2
				= arch_get_irn_register_req_in(node, i2);
			if (req2->cls != cls)
				continue;
739
			if (req2->limited == NULL)
740
741
742
743
744
745
746
747
748
749
750
				continue;

			ir_node *in2 = get_irn_n(node, i2);
			if (in2 != in)
				continue;

			/* if the constraint is the same, no copy is necessary
			 * TODO generalise to unequal but overlapping constraints */
			if (rbitsets_equal(req->limited, req2->limited, cls->n_regs))
				continue;

751
			be_new_Copy_for_input(in, node, i2);
752
			++multi_precol_copies;
753
			DBG((dbg_constr, LEVEL_3, "inserting multiple constr copy for %+F pos %d\n", node, i2));
754
755
756
757
758
759
760
		}
	}

	/* collect all registers occurring in out constraints. */
	unsigned *def_constr = NULL;
	be_foreach_value(node, value,
		const arch_register_req_t *const req = arch_get_irn_register_req(value);
761
		if (req->limited == NULL)
762
			continue;
763
764
		if (def_constr == NULL)
			def_constr = rbitset_alloca(isa_if->n_registers);
765
		arch_register_class_t const *const cls = req->cls;
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
		rbitset_foreach(req->limited, cls->n_regs, e) {
			const arch_register_t *reg = arch_register_for_index(cls, e);
			rbitset_set(def_constr, reg->global_index);
		}
	);

	/* Insert copies for all constrained arguments living through the node and
	 * being constrained to a register which also occurs in out constraints. */
	for (int i = 0, arity = get_irn_arity(node); i < arity; ++i) {
		/* Check, if
		 * 1) the operand is constrained.
		 * 2) lives through the node.
		 * 3) is constrained to a register occurring in out constraints. */
		const arch_register_req_t *const req
			= arch_get_irn_register_req_in(node, i);
781
782
783
784
785
786
		ir_node *const in = get_irn_n(node, i);
		if (req->kills_value) {
			/* we need a copy */
		} else {
			if (def_constr == NULL || req->limited == NULL)
				continue;
787
788
789
790
			const arch_register_req_t *const in_req
				= arch_get_irn_register_req(in);
			if (in_req->ignore)
				continue;
791

792
793
794
795
796
797
798
799
			bool                               common_limits = false;
			arch_register_class_t const *const cls           = req->cls;
			rbitset_foreach(req->limited, cls->n_regs, e) {
				const arch_register_t *reg = arch_register_for_index(cls, e);
				if (rbitset_is_set(def_constr, reg->global_index)) {
					common_limits = true;
					break;
				}
800
			}
801
802
			if (!common_limits)
				continue;
803
		}
804

805
806
807
808
809
810
		/* Only create the copy if the operand is no copy.
		 * this is necessary since the assure constraints phase inserts
		 * Copies and Keeps for operands which must be different from the
		 * results. Additional copies here would destroy this. */
		if (be_is_Copy(in))
			continue;
811
		if (!be_value_live_after(in, node))
812
813
			continue;

Matthias Braun's avatar
Matthias Braun committed
814
815
816
817
818
		/* TODO: This is suboptimal, we should rather have the node use the old
		 * value and all following users use the copy (because that gives us a
		 * register change for free), need to add some SSA-reconstruction code
		 * to achieve this. */

819
		be_new_Copy_for_input(in, node, i);
820
		++constrained_livethrough_copies;
821
		DBG((dbg_constr, LEVEL_3, "inserting constr copy for %+F pos %d\n", node, i));
822
823
824
825
826
827
828
829
830
831
832
833
		be_liveness_update(lv, in);
	}
}

static void add_missing_copies_in_block(ir_node *block, void *data)
{
	(void)data;
	sched_foreach(block, node) {
		prepare_constr_insn(node);
	}
}

834
835
836
837
838
839
840
841
842
843
844
static ir_node *find_copy(ir_node *irn, ir_node *op)
{
	for (ir_node *cur_node = irn;;) {
		cur_node = sched_prev(cur_node);
		if (!be_is_Copy(cur_node))
			return NULL;
		if (be_get_Copy_op(cur_node) == op && arch_irn_is(cur_node, dont_spill))
			return cur_node;
	}
}

845
846
847
848
849
850
851
852
853
854
855
856
857
858
/** Environment for constraints. */
typedef struct {
	ir_nodehashmap_t op_set;
	struct obstack   obst;
} constraint_env_t;

/** Associates an ir_node with its copy and CopyKeep. */
typedef struct {
	ir_nodeset_t copies; /**< all non-spillable copies of this irn */
} op_copy_assoc_t;

static void gen_assure_different_pattern(ir_node *irn, ir_node *other_different, constraint_env_t *env)
{
	arch_register_req_t const *const req = arch_get_irn_register_req(other_different);
859
	if (req->ignore) {
860
		DB((dbg_constr, LEVEL_1, "ignore constraint for %+F because other_irn is ignore\n", irn));
861
862
863
		return;
	}

864
865
	ir_nodehashmap_t *op_set = &env->op_set;
	ir_node          *block  = get_nodes_block(irn);
866

867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
	/* Make a not spillable copy of the different node   */
	/* this is needed because the different irn could be */
	/* in block far far away                             */
	/* The copy is optimized later if not needed         */

	/* check if already exists such a copy in the schedule immediately before */
	ir_node *cpy = find_copy(skip_Proj(irn), other_different);
	if (cpy == NULL) {
		cpy = be_new_Copy(block, other_different);
		arch_add_irn_flags(cpy, arch_irn_flag_dont_spill);
		DB((dbg_constr, LEVEL_1, "created non-spillable %+F for value %+F\n", cpy, other_different));
	} else {
		DB((dbg_constr, LEVEL_1, "using already existing %+F for value %+F\n", cpy, other_different));
	}

882
883
	/* Add the Keep resp. CopyKeep and reroute the users */
	/* of the other_different irn in case of CopyKeep.   */
884
	ir_node *const in[] = { irn };
885
	ir_node *const keep = be_new_CopyKeep(block, cpy, ARRAY_SIZE(in), in);
886

887
	DB((dbg_constr, LEVEL_1, "created %+F(%+F, %+F)\n\n", keep, irn, cpy));
888
889
890

	/* insert copy and keep into schedule */
	assert(sched_is_scheduled(irn) && "need schedule to assure constraints");
891
892
	if (!sched_is_scheduled(cpy))
		sched_add_before(skip_Proj(irn), cpy);
893
894
895
	sched_add_after(skip_Proj(irn), keep);

	/* insert the other different and its copies into the map */
Matthias Braun's avatar
Matthias Braun committed
896
897
898
	op_copy_assoc_t *entry
		= ir_nodehashmap_get(op_copy_assoc_t, op_set, other_different);
	if (entry == NULL) {
899
		entry = OALLOC(&env->obst, op_copy_assoc_t);
900
901
902
903
904
		ir_nodeset_init(&entry->copies);

		ir_nodehashmap_insert(op_set, other_different, entry);
	}

905
906
907
908
	/* insert copy */
	ir_nodeset_insert(&entry->copies, cpy);

	/* insert keep in case of CopyKeep */
909
	ir_nodeset_insert(&entry->copies, keep);
910
911
912
913
914
915
916
917
918
919
920
921
922
923
}

/**
 * Checks if node has a must_be_different constraint in output and adds a Keep
 * then to assure the constraint.
 *
 * @param irn          the node to check
 * @param skipped_irn  if irn is a Proj node, its predecessor, else irn
 * @param env          the constraint environment
 */
static void assure_different_constraints(ir_node *irn, ir_node *skipped_irn, constraint_env_t *env)
{
	const arch_register_req_t *req = arch_get_irn_register_req(irn);

924
925
	if (req->must_be_different != 0) {
		const unsigned other = req->must_be_different;
926

927
928
		if (req->should_be_same != 0) {
			const unsigned same = req->should_be_same;
929

930
			if (is_po2_or_zero(other) && is_po2_or_zero(same)) {
931
932
933
934
935
936
937
938
939
940
941
942
				int idx_other = ntz(other);
				int idx_same  = ntz(same);

				/*
				 * We can safely ignore a should_be_same x must_be_different y
				 * IFF both inputs are equal!
				 */
				if (get_irn_n(skipped_irn, idx_other) == get_irn_n(skipped_irn, idx_same)) {
					return;
				}
			}
		}
Matthias Braun's avatar
Matthias Braun committed
943
		for (unsigned i = 0; 1U << i <= other; ++i) {
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
			if (other & (1U << i)) {
				ir_node *different_from = get_irn_n(skipped_irn, i);
				gen_assure_different_pattern(irn, different_from, env);
			}
		}
	}
}

/**
 * Calls the functions to assure register constraints.
 *
 * @param block    The block to be checked
 * @param walk_env The walker environment
 */
static void assure_constraints_walker(ir_node *block, void *walk_env)
{
	constraint_env_t *env = (constraint_env_t*)walk_env;

	sched_foreach_reverse(block, irn) {
		be_foreach_value(irn, value,
964
			assure_different_constraints(value, irn, env);
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
		);
	}
}

/**
 * Melt all copykeeps pointing to the same node
 * (or Projs of the same node), copying the same operand.
 */
static void melt_copykeeps(constraint_env_t *cenv)
{
	struct obstack obst;
	obstack_init(&obst);

	/* for all */
	ir_nodehashmap_entry_t    map_entry;
	ir_nodehashmap_iterator_t map_iter;
	foreach_ir_nodehashmap(&cenv->op_set, map_entry, map_iter) {
		op_copy_assoc_t *entry = (op_copy_assoc_t*)map_entry.data;

		/* collect all copykeeps */
		unsigned num_ck = 0;
		foreach_ir_nodeset(&entry->copies, cp, iter) {
			if (be_is_CopyKeep(cp)) {
				obstack_grow(&obst, &cp, sizeof(cp));
				++num_ck;
			}
		}

		/* compare each copykeep with all other copykeeps */
		ir_node **ck_arr = (ir_node **)obstack_finish(&obst);
		for (unsigned idx = 0; idx < num_ck; ++idx) {
			if (ck_arr[idx] == NULL)
				continue;
			unsigned n_melt     = 1;
			ir_node *ref        = ck_arr[idx];
			ir_node *ref_mode_T = skip_Proj(get_irn_n(ref, 1));
			obstack_grow(&obst, &ref, sizeof(ref));

			DB((dbg_constr, LEVEL_1, "Trying to melt %+F:\n", ref));

			/* check for copykeeps pointing to the same mode_T node as the reference copykeep */
			for (unsigned j = 0; j < num_ck; ++j) {
				if (j == idx)
					continue;
				ir_node *cur_ck = ck_arr[j];
				if (cur_ck == NULL || skip_Proj(get_irn_n(cur_ck, 1)) != ref_mode_T)
					continue;

				obstack_grow(&obst, &cur_ck, sizeof(cur_ck));
				ir_nodeset_remove(&entry->copies, cur_ck);
				DB((dbg_constr, LEVEL_1, "\t%+F\n", cur_ck));
				ck_arr[j] = NULL;
				++n_melt;
				sched_remove(cur_ck);
			}
			ck_arr[idx] = NULL;

			/* check, if we found some candidates for melting */
			if (n_melt == 1) {
				DB((dbg_constr, LEVEL_1, "\tno candidate found\n"));
				continue;
			}

			ir_nodeset_remove(&entry->copies, ref);
			sched_remove(ref);

			ir_node **melt_arr = (ir_node **)obstack_finish(&obst);
			/* melt all found copykeeps */
			ir_node **new_ck_in = ALLOCAN(ir_node*,n_melt);
			for (unsigned j = 0; j < n_melt; ++j) {
				new_ck_in[j] = get_irn_n(melt_arr[j], 1);

				/* now, we can kill the melted keep, except the */
				/* ref one, we still need some information      */
				if (melt_arr[j] != ref)
					kill_node(melt_arr[j]);
			}

			ir_node *const new_ck = be_new_CopyKeep(get_nodes_block(ref), be_get_CopyKeep_op(ref), n_melt, new_ck_in);

			ir_nodeset_insert(&entry->copies, new_ck);

			/* find scheduling point */
1048
1049
			ir_node *const sched_pt = be_move_after_schedule_first(ref_mode_T);
			sched_add_after(sched_pt, new_ck);
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
			DB((dbg_constr, LEVEL_1, "created %+F, scheduled before %+F\n", new_ck, sched_pt));

			/* finally: kill the reference copykeep */
			kill_node(ref);
		}
		obstack_free(&obst, ck_arr);
	}
	obstack_free(&obst, NULL);
}

1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
/**
 * Tests whether a node has a real user and is not just kept by the End or
 * Anchor node
 */
static bool has_real_user(const ir_node *node)
{
	foreach_out_edge(node, edge) {
		ir_node *user = get_edge_src_irn(edge);
		if (!is_End(user) && !is_Anchor(user))
			return true;
	}
	return false;
}

static void add_missing_keep_walker(ir_node *node, void *data)
{
1076
1077
1078
	if (!sched_is_scheduled(node))
		return;

1079
	(void)data;
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
	if (get_irn_mode(node) == mode_T) {
		unsigned const n_outs = arch_get_irn_n_outs(node);
		assert(n_outs != 0);

		ir_node **const existing_projs = ALLOCANZ(ir_node*, n_outs);
		foreach_out_edge(node, edge) {
			ir_node *const succ = get_edge_src_irn(edge);
			/* The node could be kept */
			if (is_Proj(succ)) {
				unsigned const pn = get_Proj_num(succ);
				assert(pn < n_outs);
				existing_projs[pn] = succ;
1092
1093
1094
			}
		}

1095
1096
1097
1098
1099
		/* are keeps missing? */
		unsigned n_to_keep = 0;
		for (unsigned i = 0; i < n_outs; ++i) {
			arch_register_req_t   const *const req = arch_get_irn_register_req_out(node, i);
			arch_register_class_t const *const cls = req->cls;
1100
			if (!cls->manual_ra) {
1101
1102
				ir_node *value = existing_projs[i];
				if (!value) {
1103
					value = be_new_Proj(node, i);
1104
1105
1106
1107
1108
				} else if (has_real_user(value)) {
					continue;
				}
				existing_projs[n_to_keep++] = value;
			}
1109
		}
1110
1111
1112
1113
1114
1115
1116
1117
		if (n_to_keep != 0) {
			ir_node *const block = get_nodes_block(node);
			ir_node *const keep  = be_new_Keep(block, n_to_keep, existing_projs);
			sched_add_after(node, keep);
		}
	} else if (!is_Proj(node)) {
		arch_register_req_t   const *const req = arch_get_irn_register_req(node);
		arch_register_class_t const *const cls = req->cls;
1118
		if (!cls->manual_ra) {
1119
1120
1121
1122
			if (!has_real_user(node)) {
				ir_node *const keep = be_new_Keep_one(node);
				sched_add_after(node, keep);
			}
1123
1124
1125
1126
		}
	}
}

1127
1128
1129
void be_spill_prepare_for_constraints(ir_graph *irg)
{
	FIRM_DBG_REGISTER(dbg_constr, "firm.be.lower.constr");
1130
	be_timer_push(T_RA_CONSTR);
1131

1132
1133
	irg_walk_graph(irg, add_missing_keep_walker, NULL, NULL);

1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
	constraint_env_t cenv;
	ir_nodehashmap_init(&cenv.op_set);
	obstack_init(&cenv.obst);

	irg_block_walk_graph(irg, NULL, assure_constraints_walker, &cenv);

	/* melt copykeeps, pointing to projs of */
	/* the same mode_T node and keeping the */
	/* same operand                         */
	melt_copykeeps(&cenv);

	/* for all */
	ir_nodehashmap_iterator_t map_iter;
	ir_nodehashmap_entry_t    map_entry;
	foreach_ir_nodehashmap(&cenv.op_set, map_entry, map_iter) {
Matthias Braun's avatar
Matthias Braun committed
1149
1150
1151
		op_copy_assoc_t *entry    = (op_copy_assoc_t*)map_entry.data;
		size_t           n_copies = ir_nodeset_size(&entry->copies);
		ir_node        **nodes    = ALLOCAN(ir_node*, n_copies);
1152
1153
1154
1155
1156

		/* put the node in an array */
		DBG((dbg_constr, LEVEL_1, "introduce copies for %+F ", map_entry.node));

		/* collect all copies */
Matthias Braun's avatar
Matthias Braun committed
1157
		size_t n = 0;
1158
1159
1160
1161
1162
1163
1164
1165
		foreach_ir_nodeset(&entry->copies, cp, iter) {
			nodes[n++] = cp;
			DB((dbg_constr, LEVEL_1, ", %+F ", cp));
		}

		DB((dbg_constr, LEVEL_1, "\n"));

		/* introduce the copies for the operand and its copies */
Matthias Braun's avatar
Matthias Braun committed
1166
		be_ssa_construction_env_t senv;
1167
1168
1169
1170
1171
1172
1173
1174
1175
		be_ssa_construction_init(&senv, irg);
		be_ssa_construction_add_copy(&senv, map_entry.node);
		be_ssa_construction_add_copies(&senv, nodes, n);
		be_ssa_construction_fix_users(&senv, map_entry.node);
		be_ssa_construction_destroy(&senv);

		/* Could be that not all CopyKeeps are really needed, */
		/* so we transform unnecessary ones into Keeps.       */
		foreach_ir_nodeset(&entry->copies, cp, iter) {
1176
			if (be_is_CopyKeep(cp) && get_irn_n_edges(cp) == 0) {
Matthias Braun's avatar
Matthias Braun committed
1177
1178
				int      arity = get_irn_arity(cp);
				ir_node *block = get_nodes_block(cp);
1179
				ir_node *keep  = be_new_Keep(block, arity, get_irn_in(cp));
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
				sched_replace(cp, keep);

				/* Set all ins (including the block) of the CopyKeep BAD to keep the verifier happy. */
				kill_node(cp);
			}
		}

		ir_nodeset_destroy(&entry->copies);
	}

	ir_nodehashmap_destroy(&cenv.op_set);
	obstack_free(&cenv.obst, NULL);
	be_invalidate_live_sets(irg);

1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
	/* part2: add missing copies */
	precol_copies                  = 0;
	multi_precol_copies            = 0;
	constrained_livethrough_copies = 0;
	be_assure_live_sets(irg);
	birg = be_birg_from_irg(irg);
	lv   = be_get_irg_liveness(irg);
	irg_block_walk_graph(irg, add_missing_copies_in_block, NULL, NULL);

	stat_ev_ull("ra_precol_copies", precol_copies);
	stat_ev_ull("ra_multi_precol_copies", multi_precol_copies);
	stat_ev_ull("ra_constrained_livethrough_copies",
	            constrained_livethrough_copies);
1207
1208
	be_timer_pop(T_RA_CONSTR);
	be_dump(DUMP_RA, irg, "spillprepare");
1209
1210
}

Matthias Braun's avatar
Matthias Braun committed
1211
BE_REGISTER_MODULE_CONSTRUCTOR(be_init_spill)
1212
1213
1214
1215
void be_init_spill(void)
{
	FIRM_DBG_REGISTER(dbg, "firm.be.spill");
}