bearch.h 22.3 KB
Newer Older
Christian Würdig's avatar
Christian Würdig committed
1
/*
2
 * Copyright (C) 1995-2011 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
18
19
 *
 * 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
20
21
22
23
24
25
26
/**
 * @file
 * @brief       Processor architecture specification.
 * @author      Sebastian Hack
 */
#ifndef FIRM_BE_BEARCH_H
#define FIRM_BE_BEARCH_H
27

28
29
#include <stdbool.h>

30
#include "firm_types.h"
Sebastian Hack's avatar
Sebastian Hack committed
31
#include "bitset.h"
Matthias Braun's avatar
Matthias Braun committed
32
#include "obst.h"
33
#include "raw_bitset.h"
34
#include "irop_t.h"
35

36
37
38
39
#include "be_types.h"
#include "beinfo.h"
#include "be.h"
#include "beirg.h"
40
#include "error.h"
41

42
43
44
45
46
47
48
/**
 * this constant is returned by the get_sp_bias functions if the stack
 * is reset (usually because the frame pointer is copied to the stack
 * pointer
 */
#define SP_BIAS_RESET      INT_MIN

Matthias Braun's avatar
Matthias Braun committed
49
50
typedef enum arch_register_class_flags_t {
	arch_register_class_flag_none      = 0,
Matthias Braun's avatar
Matthias Braun committed
51
	/** don't do automatic register allocation for this class */
52
	arch_register_class_flag_manual_ra = 1U << 0,
Matthias Braun's avatar
Matthias Braun committed
53
	/** the register models an abstract state (example: fpu rounding mode) */
54
	arch_register_class_flag_state     = 1U << 1
Matthias Braun's avatar
Matthias Braun committed
55
} arch_register_class_flags_t;
56
ENUM_BITSET(arch_register_class_flags_t)
Matthias Braun's avatar
Matthias Braun committed
57

58
typedef enum arch_register_type_t {
Michael Beck's avatar
Michael Beck committed
59
	arch_register_type_none         = 0,
60
	/** Do not consider this register when allocating. */
61
	arch_register_type_ignore       = 1U << 0,
62
63
	/** The emitter can choose an arbitrary register. The register fulfills any
	 * register constraints as long as the register class matches */
64
	arch_register_type_joker        = 1U << 1,
65
66
67
	/** This is just a virtual register. Virtual registers fulfill any register
	 * constraints as long as the register class matches. It is a allowed to
	 * have multiple definitions for the same virtual register at a point */
68
	arch_register_type_virtual      = 1U << 2,
69
70
	/** The register represents a state that should be handled by bestate
	 * code */
71
	arch_register_type_state        = 1U << 3,
Sebastian Hack's avatar
Sebastian Hack committed
72
} arch_register_type_t;
73
ENUM_BITSET(arch_register_type_t)
74

Sebastian Hack's avatar
Sebastian Hack committed
75
76
77
/**
 * Different types of register allocation requirements.
 */
78
typedef enum arch_register_req_type_t {
79
	/** No register requirement. */
80
	arch_register_req_type_none              = 0,
81
82
83
84
85
86
87
88
	/** All registers in the class are allowed. */
	arch_register_req_type_normal            = 1U << 0,
	/** Only a real subset of the class is allowed. */
	arch_register_req_type_limited           = 1U << 1,
	/** The register should be equal to another one at the node. */
	arch_register_req_type_should_be_same    = 1U << 2,
	/** The register must be unequal from some other at the node. */
	arch_register_req_type_must_be_different = 1U << 3,
89
	/** The registernumber should be aligned (in case of multiregister values)*/
90
	arch_register_req_type_aligned           = 1U << 4,
91
	/** ignore while allocating registers */
92
	arch_register_req_type_ignore            = 1U << 5,
93
94
95
	/** the output produces a new value for the stack pointer
	 * (this is not really a constraint but a marker to guide the stackpointer
	 * rewiring logic) */
96
	arch_register_req_type_produces_sp       = 1U << 6,
Sebastian Hack's avatar
Sebastian Hack committed
97
} arch_register_req_type_t;
98
ENUM_BITSET(arch_register_req_type_t)
99

Matthias Braun's avatar
Matthias Braun committed
100
101
extern const arch_register_req_t *arch_no_register_req;

Sebastian Hack's avatar
Sebastian Hack committed
102
/**
103
104
 * Print information about a register requirement in human readable form
 * @param F   output stream/file
Sebastian Hack's avatar
Sebastian Hack committed
105
106
 * @param req The requirements structure to format.
 */
107
108
void arch_dump_register_req(FILE *F, const arch_register_req_t *req,
                            const ir_node *node);
Sebastian Hack's avatar
Sebastian Hack committed
109

110
111
112
void arch_dump_register_reqs(FILE *F, const ir_node *node);
void arch_dump_reqs_and_registers(FILE *F, const ir_node *node);

113
void arch_set_frame_offset(ir_node *irn, int bias);
114

115
ir_entity *arch_get_frame_entity(const ir_node *irn);
116
int        arch_get_sp_bias(ir_node *irn);
Sebastian Hack's avatar
Sebastian Hack committed
117

118
int             arch_get_op_estimated_cost(const ir_node *irn);
119
120
121
122
123
124
125
arch_inverse_t *arch_get_inverse(const ir_node *irn, int i,
                                 arch_inverse_t *inverse,
                                 struct obstack *obstack);
int             arch_possible_memory_operand(const ir_node *irn,
                                             unsigned int i);
void            arch_perform_memory_operand(ir_node *irn, ir_node *spill,
                                            unsigned int i);
126

Sebastian Hack's avatar
Sebastian Hack committed
127
/**
128
 * Get the register allocated for a value.
Sebastian Hack's avatar
Sebastian Hack committed
129
 */
130
const arch_register_t *arch_get_irn_register(const ir_node *irn);
131

Sebastian Hack's avatar
Sebastian Hack committed
132
/**
133
 * Assign register to a value
Sebastian Hack's avatar
Sebastian Hack committed
134
 */
135
void arch_set_irn_register(ir_node *irn, const arch_register_t *reg);
136

Sebastian Hack's avatar
Sebastian Hack committed
137
/**
138
 * Set the register for a certain output operand.
Sebastian Hack's avatar
Sebastian Hack committed
139
 */
140
void arch_set_irn_register_out(ir_node *irn, int pos, const arch_register_t *r);
Sebastian Hack's avatar
Sebastian Hack committed
141

142
143
const arch_register_t *arch_get_irn_register_out(const ir_node *irn, int pos);
const arch_register_t *arch_get_irn_register_in(const ir_node *irn, int pos);
144

Sebastian Hack's avatar
Sebastian Hack committed
145
/**
146
 * Get register constraints for an operand at position @p
Sebastian Hack's avatar
Sebastian Hack committed
147
 */
148
149
150
151
152
153
154
155
static inline const arch_register_req_t *arch_get_irn_register_req_in(
		const ir_node *node, int pos)
{
	const backend_info_t *info = be_get_info(node);
	if (info->in_reqs == NULL)
		return arch_no_register_req;
	return info->in_reqs[pos];
}
Sebastian Hack's avatar
Sebastian Hack committed
156
157

/**
158
 * Get register constraint for a produced result (the @p pos result)
Sebastian Hack's avatar
Sebastian Hack committed
159
 */
160
161
162
163
164
165
166
167
static inline const arch_register_req_t *arch_get_irn_register_req_out(
		const ir_node *node, int pos)
{
	const backend_info_t *info = be_get_info(node);
	if (info->out_infos == NULL)
		return arch_no_register_req;
	return info->out_infos[pos].req;
}
Sebastian Hack's avatar
Sebastian Hack committed
168

169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
static inline void arch_set_irn_register_req_out(ir_node *node, int pos,
		const arch_register_req_t *req)
{
	backend_info_t *info = be_get_info(node);
	assert(pos < (int)ARR_LEN(info->out_infos));
	info->out_infos[pos].req = req;
}

static inline void arch_set_irn_register_reqs_in(ir_node *node,
		const arch_register_req_t **reqs)
{
	backend_info_t *info = be_get_info(node);
	info->in_reqs = reqs;
}

static inline const arch_register_req_t **arch_get_irn_register_reqs_in(
		const ir_node *node)
{
	backend_info_t *info = be_get_info(node);
	return info->in_reqs;
}

const arch_register_req_t *arch_get_irn_register_req(const ir_node *node);
192

Sebastian Hack's avatar
Sebastian Hack committed
193
194
195
196
197
/**
 * Get the flags of a node.
 * @param irn The node.
 * @return The flags.
 */
198
arch_irn_flags_t arch_get_irn_flags(const ir_node *irn);
Sebastian Hack's avatar
Sebastian Hack committed
199

200
201
void arch_set_irn_flags(ir_node *node, arch_irn_flags_t flags);
void arch_add_irn_flags(ir_node *node, arch_irn_flags_t flags);
Sebastian Hack's avatar
Sebastian Hack committed
202

203
204
205
206
207
208
209
210
211
212
213
#define arch_irn_is(irn, flag) ((arch_get_irn_flags(irn) & arch_irn_flags_ ## flag) != 0)

static inline unsigned arch_get_irn_n_outs(const ir_node *node)
{
	backend_info_t *info = be_get_info(node);
	if (info->out_infos == NULL)
		return 0;

	return (unsigned)ARR_LEN(info->out_infos);
}

Sebastian Hack's avatar
Sebastian Hack committed
214
/**
215
 * Start codegeneration
Sebastian Hack's avatar
Sebastian Hack committed
216
 */
217
218
arch_env_t *arch_env_begin_codegeneration(const arch_isa_if_t *isa,
                                          be_main_env_t *main_env);
Sebastian Hack's avatar
Sebastian Hack committed
219

220
221
222
223
224
/**
 * Register an instruction set architecture
 */
void be_register_isa_if(const char *name, const arch_isa_if_t *isa);

225
226
227
228
/**
 * A register.
 */
struct arch_register_t {
Michael Beck's avatar
Michael Beck committed
229
230
231
232
233
234
235
	const char                  *name;         /**< The name of the register. */
	const arch_register_class_t *reg_class;    /**< The class of the register */
	unsigned short               index;        /**< The index of the register in
	                                                the class. */
	unsigned short               global_index; /** The global index this register
											       in the architecture. */
	arch_register_type_t         type;         /**< The type of the register. */
236
	/** register constraint allowing just this register */
237
	const arch_register_req_t   *single_req;
238
239
};

240
static inline const arch_register_class_t *arch_register_get_class(
241
		const arch_register_t *reg)
242
243
244
245
{
	return reg->reg_class;
}

246
static inline unsigned arch_register_get_index(const arch_register_t *reg)
247
248
249
250
{
	return reg->index;
}

251
static inline const char *arch_register_get_name(const arch_register_t *reg)
252
253
254
255
256
257
258
259
260
{
	return reg->name;
}

/**
 * A class of registers.
 * Like general purpose or floating point.
 */
struct arch_register_class_t {
261
262
263
264
265
266
267
268
	unsigned                     index;   /**< index of this register class */
	const char                  *name;    /**< The name of the register class.*/
	unsigned                     n_regs;  /**< Number of registers in this
	                                           class. */
	ir_mode                     *mode;    /**< The mode of the register class.*/
	const arch_register_t       *regs;    /**< The array of registers. */
	arch_register_class_flags_t  flags;   /**< register class flags. */
	const arch_register_req_t   *class_req;
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
};

/** return the number of registers in this register class */
#define arch_register_class_n_regs(cls) ((cls)->n_regs)

/** return the largest mode of this register class */
#define arch_register_class_mode(cls) ((cls)->mode)

/** return the name of this register class */
#define arch_register_class_name(cls) ((cls)->name)

/** return the index of this register class */
#define arch_register_class_index(cls)  ((cls)->index)

/** return the register class flags */
#define arch_register_class_flags(cls) ((cls)->flags)

286
static inline const arch_register_t *arch_register_for_index(
287
		const arch_register_class_t *cls, unsigned idx)
288
289
290
291
292
293
294
295
{
	assert(idx < cls->n_regs);
	return &cls->regs[idx];
}

/**
 * Convenience macro to check for set constraints.
 * @param req   A pointer to register requirements.
296
297
 * @param kind  The kind of constraint to check for
 *              (see arch_register_req_type_t).
298
299
300
301
302
303
304
305
306
 * @return      1, If the kind of constraint is present, 0 if not.
 */
#define arch_register_req_is(req, kind) \
	(((req)->type & (arch_register_req_type_ ## kind)) != 0)

/**
 * Expresses requirements to register allocation for an operand.
 */
struct arch_register_req_t {
307
308
309
	arch_register_req_type_t     type; /**< The type of the constraint. */
	const arch_register_class_t *cls;  /**< The register class this constraint
	                                        belongs to. */
310
311
312
313
314
315
	const unsigned *limited;            /**< allowed register bitset */
	unsigned other_same;                /**< Bitmask of ins which should use the
	                                         same register (should_be_same). */
	unsigned other_different;           /**< Bitmask of ins which shall use a
	                                         different register
	                                         (must_be_different) */
316
317
	unsigned char width;                /**< specifies how many sequential
	                                         registers are required */
318
319
};

320
321
static inline bool reg_reqs_equal(const arch_register_req_t *req1,
                                  const arch_register_req_t *req2)
322
323
{
	if (req1 == req2)
324
		return true;
325

Christoph Mallon's avatar
Christoph Mallon committed
326
327
328
329
330
	if (req1->type              != req2->type            ||
	    req1->cls               != req2->cls             ||
	    req1->other_same        != req2->other_same      ||
	    req1->other_different   != req2->other_different ||
	    (req1->limited != NULL) != (req2->limited != NULL))
331
		return false;
332
333

	if (req1->limited != NULL) {
Christoph Mallon's avatar
Christoph Mallon committed
334
		size_t const n_regs = arch_register_class_n_regs(req1->cls);
335
		if (!rbitsets_equal(req1->limited, req2->limited, n_regs))
336
			return false;
337
338
	}

339
	return true;
340
341
342
343
344
345
346
347
348
}

/**
 * An inverse operation returned by the backend
 */
struct arch_inverse_t {
	int      n;       /**< count of nodes returned in nodes array */
	int      costs;   /**< costs of this remat */

349
350
	/** nodes for this inverse operation. shall be in schedule order.
	 * last element is the target value */
351
352
353
354
355
356
357
358
	ir_node  **nodes;
};

struct arch_irn_ops_t {

	/**
	 * Get the entity on the stack frame this node depends on.
	 * @param irn  The node in question.
359
360
	 * @return The entity on the stack frame or NULL, if the node does not have
	 *         a stack frame entity.
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
	 */
	ir_entity *(*get_frame_entity)(const ir_node *irn);

	/**
	 * Set the offset of a node carrying an entity on the stack frame.
	 * @param irn  The node.
	 * @param offset The offset of the node's stack frame entity.
	 */
	void (*set_frame_offset)(ir_node *irn, int offset);

	/**
	 * Returns the delta of the stackpointer for nodes that increment or
	 * decrement the stackpointer with a constant value. (push, pop
	 * nodes on most architectures).
	 * A positive value stands for an expanding stack area, a negative value for
	 * a shrinking one.
	 *
	 * @param irn       The node
	 * @return          0 if the stackpointer is not modified with a constant
	 *                  value, otherwise the increment/decrement value
	 */
	int (*get_sp_bias)(const ir_node *irn);

	/**
	 * Returns an inverse operation which yields the i-th argument
	 * of the given node as result.
	 *
	 * @param irn       The original operation
389
390
	 * @param i         Index of the argument we want the inverse operation to
	 *                  yield
391
	 * @param inverse   struct to be filled with the resulting inverse op
392
393
	 * @param obstack   The obstack to use for allocation of the returned nodes
	 *                  array
394
395
	 * @return          The inverse operation or NULL if operation invertible
	 */
396
397
398
	arch_inverse_t *(*get_inverse)(const ir_node *irn, int i,
	                               arch_inverse_t *inverse,
	                               struct obstack *obstack);
399
400
401
402
403
404
405
406
407
408

	/**
	 * Get the estimated cycle count for @p irn.
	 *
	 * @param irn  The node.
	 * @return     The estimated cycle count for this operation
	 */
	int (*get_op_estimated_cost)(const ir_node *irn);

	/**
409
410
	 * Asks the backend whether operand @p i of @p irn can be loaded form memory
	 * internally
411
412
	 *
	 * @param irn  The node.
413
414
	 * @param i    Index of the argument we would like to know whether @p irn
	 *             can load it form memory internally
415
416
417
418
419
420
421
422
423
424
425
	 * @return     nonzero if argument can be loaded or zero otherwise
	 */
	int (*possible_memory_operand)(const ir_node *irn, unsigned int i);

	/**
	 * Ask the backend to assimilate @p reload of operand @p i into @p irn.
	 *
	 * @param irn    The node.
	 * @param spill  The spill.
	 * @param i      The position of the reload.
	 */
426
427
	void (*perform_memory_operand)(ir_node *irn, ir_node *spill,
	                               unsigned int i);
428
429
430
431
432
433
434
};

/**
 * Architecture interface.
 */
struct arch_isa_if_t {
	/**
435
436
437
438
439
440
441
	 * Initializes the isa interface. This is necessary before calling any
	 * other functions from this interface.
	 */
	void (*init)(void);

	/**
	 * Returns the frontend settings needed for this backend.
442
	 */
443
	const backend_params *(*get_params)(void);
444

445
446
447
448
449
450
	/**
	 * lowers current program for target. See the documentation for
	 * be_lower_for_target() for details.
	 */
	void (*lower_for_target)(void);

451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
	/**
	 * parse an assembler constraint part and set flags according to its nature
	 * advances the *c pointer to point to the last parsed character (so if you
	 * parse a single character don't advance c)
	 */
	asm_constraint_flags_t (*parse_asm_constraint)(const char **c);

	/**
	 * returns true if the string is a valid clobbered (register) in this
	 * backend
	 */
	int (*is_valid_clobber)(const char *clobber);

	/**
	 * Start codegeneration
	 * @return a new isa instance
	 */
	arch_env_t *(*begin_codegeneration)(const be_main_env_t *env);

470
471
472
	/**
	 * Free the isa instance.
	 */
473
	void (*end_codegeneration)(void *self);
474
475

	/**
476
477
	 * Initialize the code generator for a graph
	 * @param irg  A graph
478
	 */
479
	void (*init_graph)(ir_graph *irg);
480
481
482
483
484
485

	/**
	 * Get the ABI restrictions for procedure calls.
	 * @param call_type   The call type of the method (procedure) in question.
	 * @param p           The array of parameter locations to be filled.
	 */
486
	void (*get_call_abi)(ir_type *call_type, be_abi_call_t *abi);
487
488

	/**
489
	 * mark node as rematerialized
490
	 */
491
	void (*mark_remat)(ir_node *node);
492
493

	/**
494
	 * return node used as base in pic code addresses
495
	 */
496
	ir_node* (*get_pic_base)(ir_graph *irg);
497
498

	/**
499
500
501
502
503
504
	 * Create a spill instruction. We assume that spill instructions
	 * do not need any additional registers and do not affect cpu-flags in any
	 * way.
	 * Construct a sequence of instructions after @p after (the resulting nodes
	 * are already scheduled).
	 * Returns a mode_M value which is used as input for a reload instruction.
505
	 */
506
	ir_node *(*new_spill)(ir_node *value, ir_node *after);
507
508

	/**
509
510
511
512
513
514
	 * Create a reload instruction. We assume that reload instructions do not
	 * need any additional registers and do not affect cpu-flags in any way.
	 * Constructs a sequence of instruction before @p before (the resulting
	 * nodes are already scheduled). A rewiring of users is not performed in
	 * this function.
	 * Returns a value representing the restored value.
515
	 */
516
517
	ir_node *(*new_reload)(ir_node *value, ir_node *spilled_value,
	                       ir_node *before);
518
519

	/**
520
521
	 * Checks if the given register is callee/caller saved.
	 * @deprecated, only necessary if backend still uses beabi functions
522
	 */
523
	int (*register_saved_by)(const arch_register_t *reg, int callee);
524
525

	/**
526
527
	 * Called directly after initialization. Backend should handle all
	 * intrinsics here.
528
	 */
529
	void (*handle_intrinsics)(void);
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556

	/**
	 * Called before abi introduce.
	 */
	void (*before_abi)(ir_graph *irg);

	/**
	 * Called, when the graph is being normalized.
	 */
	void (*prepare_graph)(ir_graph *irg);

	/**
	 * Called before register allocation.
	 */
	void (*before_ra)(ir_graph *irg);

	/**
	 * Called directly before done is called. This should be the last place
	 * where the irg is modified.
	 */
	void (*finish)(ir_graph *irg);

	/**
	 * Called after everything happened. This call should emit the final
	 * assembly code but avoid changing the irg.
	 */
	void (*emit)(ir_graph *irg);
557
558
};

559
#define arch_env_end_codegeneration(env)               ((env)->impl->end_codegeneration(env))
560
561
#define arch_env_handle_intrinsics(env)                \
	do { if((env)->impl->handle_intrinsics != NULL) (env)->impl->handle_intrinsics(); } while(0)
562
#define arch_env_get_call_abi(env,tp,abi)              ((env)->impl->get_call_abi((tp), (abi)))
563
#define arch_env_get_params(env)                       ((env)->impl->get_params())
564
565
#define arch_env_parse_asm_constraint(env,c)           ((env)->impl->parse_asm_constraint((c))
#define arch_env_is_valid_clobber(env,clobber)         ((env)->impl->is_valid_clobber((clobber))
566
#define arch_env_mark_remat(env,node) \
567
	do { if ((env)->impl->mark_remat != NULL) (env)->impl->mark_remat((node)); } while(0)
568

569
570
571
#define arch_env_new_spill(env,value,after)            ((env)->impl->new_spill(value, after))
#define arch_env_new_reload(env,value,spilled,before)  ((env)->impl->new_reload(value, spilled, before))

572
573
574
575
576
/**
 * ISA base class.
 */
struct arch_env_t {
	const arch_isa_if_t   *impl;
577
578
	unsigned               n_registers;      /**< number of registers */
	const arch_register_t *registers;        /**< register array */
579
580
	unsigned               n_register_classes; /**< number of register classes*/
	const arch_register_class_t *register_classes; /**< register classes */
581
582
583
584
585
586
587
588
	const arch_register_t *sp;               /**< The stack pointer register. */
	const arch_register_t *bp;               /**< The base pointer register. */
	const arch_register_class_t *link_class; /**< The static link pointer
	                                              register class. */
	int                    stack_alignment;  /**< power of 2 stack alignment */
	const be_main_env_t   *main_env;         /**< the be main environment */
	int                    spill_cost;       /**< cost for a be_Spill node */
	int                    reload_cost;      /**< cost for a be_Reload node */
589
	bool                   custom_abi : 1;   /**< backend does all abi handling
590
591
	                                              and does not need the generic
	                                              stuff from beabi.h/.c */
592
593
594
595
};

static inline bool arch_irn_is_ignore(const ir_node *irn)
{
596
597
	const arch_register_req_t *req = arch_get_irn_register_req(irn);
	return req->type & arch_register_req_type_ignore;
598
599
}

600
601
static inline bool arch_irn_consider_in_reg_alloc(
		const arch_register_class_t *cls, const ir_node *node)
602
{
603
	const arch_register_req_t *req = arch_get_irn_register_req(node);
604
605
606
	return
		req->cls == cls &&
		!(req->type & arch_register_req_type_ignore);
607
608
}

609
610
611
612
613
614
/**
 * Iterate over all values defined by an instruction.
 * Only looks at values in a certain register class where the requirements
 * are not marked as ignore.
 * Executes @p code for each definition.
 */
615
#define be_foreach_definition_(node, cls, value, code)                     \
616
617
618
619
620
621
	do {                                                                   \
	if (get_irn_mode(node) == mode_T) {                                    \
		const ir_edge_t *edge_;                                            \
		foreach_out_edge(node, edge_) {                                    \
			const arch_register_req_t *req_;                               \
			value = get_edge_src_irn(edge_);                               \
622
			req_  = arch_get_irn_register_req(value);                      \
623
624
625
626
627
			if (req_->cls != cls)                                          \
				continue;                                                  \
			code                                                           \
		}                                                                  \
	} else {                                                               \
628
		const arch_register_req_t *req_ = arch_get_irn_register_req(node); \
629
		value = node;                                                      \
630
		if (req_->cls == cls) {                                            \
631
632
633
634
635
			code                                                           \
		}                                                                  \
	}                                                                      \
	} while (0)

636
637
638
639
640
641
642
#define be_foreach_definition(node, cls, value, code)                      \
	be_foreach_definition_(node, cls, value,                               \
		if (req_->type & arch_register_req_type_ignore)                    \
			continue;                                                      \
		code                                                               \
	)

643
644
645
646
647
648
649
650
651
652
static inline const arch_register_class_t *arch_get_irn_reg_class(
		const ir_node *node)
{
	const arch_register_req_t *req = arch_get_irn_register_req(node);
	return req->cls;
}

bool arch_reg_is_allocatable(const arch_register_req_t *req,
                             const arch_register_t *reg);

653
#endif