bearch.h 25.9 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
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
27
/**
 * @file
 * @brief       Processor architecture specification.
 * @author      Sebastian Hack
 * @version     $Id$
 */
#ifndef FIRM_BE_BEARCH_H
#define FIRM_BE_BEARCH_H
28

29
30
#include <stdbool.h>

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

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

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

52
typedef enum arch_register_type_t {
Michael Beck's avatar
Michael Beck committed
53
	arch_register_type_none         = 0,
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
	/** The register must be saved by the caller upon a function call. It thus
	 * can be overwritten in the called function. */
	arch_register_type_caller_save  = 1U << 0,
	/** The register must be saved by the caller upon a function call. It thus
	 * can be overwritten in the called function. */
	arch_register_type_callee_save  = 1U << 1,
	/** Do not consider this register when allocating. */
	arch_register_type_ignore       = 1U << 2,
	/** The emitter can choose an arbitrary register. The register fulfills any
	 * register constraints as long as the register class matches */
	arch_register_type_joker        = 1U << 3,
	/** 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 */
	arch_register_type_virtual      = 1U << 4,
	/** The register represents a state that should be handled by bestate
	 * code */
	arch_register_type_state        = 1U << 5,
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);

Sebastian Hack's avatar
Sebastian Hack committed
113
/**
114
 * Node classification. Used for statistics and for detecting reload nodes.
Sebastian Hack's avatar
Sebastian Hack committed
115
 */
116
typedef enum arch_irn_class_t {
117
	arch_irn_class_none   = 0,
118
119
120
121
122
	arch_irn_class_spill  = 1 << 0,
	arch_irn_class_reload = 1 << 1,
	arch_irn_class_remat  = 1 << 2,
	arch_irn_class_copy   = 1 << 3,
	arch_irn_class_perm   = 1 << 4
Sebastian Hack's avatar
Sebastian Hack committed
123
} arch_irn_class_t;
124
ENUM_BITSET(arch_irn_class_t)
Sebastian Hack's avatar
Sebastian Hack committed
125

126
void arch_set_frame_offset(ir_node *irn, int bias);
127

128
ir_entity *arch_get_frame_entity(const ir_node *irn);
129
int        arch_get_sp_bias(ir_node *irn);
Sebastian Hack's avatar
Sebastian Hack committed
130

131
int             arch_get_op_estimated_cost(const ir_node *irn);
132
133
134
135
136
137
138
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);
139

Sebastian Hack's avatar
Sebastian Hack committed
140
141
/**
 * Get the register requirements for a node.
142
143
144
145
 * @note Deprecated API! Preferably use
 *       arch_get_in_register_req and
 *       arch_get_out_register_req.
 *
Sebastian Hack's avatar
Sebastian Hack committed
146
147
 * @param irn The node.
 * @param pos The position of the operand you're interested in.
Christoph Mallon's avatar
Christoph Mallon committed
148
 * @return    A pointer to the register requirements.  If NULL is returned, the
Sebastian Hack's avatar
Sebastian Hack committed
149
150
 *            operand was no register operand.
 */
151
const arch_register_req_t *arch_get_register_req(const ir_node *irn, int pos);
152

Sebastian Hack's avatar
Sebastian Hack committed
153
154
155
156
157
158
159
/**
 * Check, if a register is assignable to an operand of a node.
 * @param irn The node.
 * @param pos The position of the operand.
 * @param reg The register.
 * @return    1, if the register might be allocated to the operand 0 if not.
 */
160
161
int arch_reg_is_allocatable(const ir_node *irn, int pos,
                            const arch_register_t *reg);
Sebastian Hack's avatar
Sebastian Hack committed
162

163
164
#define arch_reg_out_is_allocatable(irn, reg) arch_reg_is_allocatable(irn, -1, reg)

Sebastian Hack's avatar
Sebastian Hack committed
165
166
167
/**
 * Get the register class of an operand of a node.
 * @param irn The node.
Michael Beck's avatar
Michael Beck committed
168
 * @param pos The position of the operand, -1 for the output.
Sebastian Hack's avatar
Sebastian Hack committed
169
170
171
 * @return    The register class of the operand or NULL, if
 *            operand is a non-register operand.
 */
172
173
const arch_register_class_t *arch_get_irn_reg_class(const ir_node *irn,
                                                    int pos);
Sebastian Hack's avatar
Sebastian Hack committed
174

175
176
#define arch_get_irn_reg_class_out(irn) arch_get_irn_reg_class(irn, -1)

Sebastian Hack's avatar
Sebastian Hack committed
177
178
179
180
181
/**
 * Get the register allocated at a certain output operand of a node.
 * @param irn The node.
 * @return    The register allocated for this operand
 */
182
const arch_register_t *arch_get_irn_register(const ir_node *irn);
183
const arch_register_t *arch_irn_get_register(const ir_node *irn, int pos);
Sebastian Hack's avatar
Sebastian Hack committed
184
185
186
187
188
189

/**
 * Set the register for a certain output operand.
 * @param irn The node.
 * @param reg The register.
 */
190
void arch_set_irn_register(ir_node *irn, const arch_register_t *reg);
191
void arch_irn_set_register(ir_node *irn, int pos, const arch_register_t *reg);
Sebastian Hack's avatar
Sebastian Hack committed
192

193
194
195
196
197
/**
 * Classify a node.
 * @param irn The node.
 * @return A classification of the node.
 */
198
arch_irn_class_t arch_irn_classify(const ir_node *irn);
199

Sebastian Hack's avatar
Sebastian Hack committed
200
201
202
203
204
/**
 * Get the flags of a node.
 * @param irn The node.
 * @return The flags.
 */
205
arch_irn_flags_t arch_irn_get_flags(const ir_node *irn);
Sebastian Hack's avatar
Sebastian Hack committed
206

207
208
void arch_irn_set_flags(ir_node *node, arch_irn_flags_t flags);
void arch_irn_add_flags(ir_node *node, arch_irn_flags_t flags);
Sebastian Hack's avatar
Sebastian Hack committed
209

210
#define arch_irn_is(irn, flag) ((arch_irn_get_flags(irn) & arch_irn_flags_ ## flag) != 0)
Sebastian Hack's avatar
Sebastian Hack committed
211

212
213
214
215
216
217
218
219
/**
 * Get the operations of an irn.
 * @param self The handler from which the method is invoked.
 * @param irn Some node.
 * @return Operations for that irn.
 */
typedef const void *(arch_get_irn_ops_t)(const ir_node *irn);

Sebastian Hack's avatar
Sebastian Hack committed
220
/**
Sebastian Hack's avatar
Sebastian Hack committed
221
 * Initialize the architecture environment struct.
222
223
 * @param isa           The isa which shall be put into the environment.
 * @param file_handle   The file handle
Sebastian Hack's avatar
Sebastian Hack committed
224
225
 * @return The environment.
 */
226
extern arch_env_t *arch_env_init(const arch_isa_if_t *isa,
227
                                 FILE *file_handle, be_main_env_t *main_env);
Sebastian Hack's avatar
Sebastian Hack committed
228

229
230
231
232
233
/**
 * Register an instruction set architecture
 */
void be_register_isa_if(const char *name, const arch_isa_if_t *isa);

234
235
236
237
/**
 * A register.
 */
struct arch_register_t {
Michael Beck's avatar
Michael Beck committed
238
239
240
241
242
243
244
	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. */
245
	/** register constraint allowing just this register */
246
	const arch_register_req_t   *single_req;
247
248
};

249
static inline const arch_register_class_t *arch_register_get_class(
250
		const arch_register_t *reg)
251
252
253
254
{
	return reg->reg_class;
}

255
static inline unsigned arch_register_get_index(const arch_register_t *reg)
256
257
258
259
{
	return reg->index;
}

260
static inline const char *arch_register_get_name(const arch_register_t *reg)
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
{
	return reg->name;
}

/**
 * Convenience macro to check for register type.
 * @param req   A pointer to register.
 * @param kind  The kind of type to check for (see arch_register_type_t).
 * @return      1, If register is of given kind, 0 if not.
 */
#define arch_register_type_is(reg, kind) \
  (((reg)->type & arch_register_type_ ## kind) != 0)

/**
 * A class of registers.
 * Like general purpose or floating point.
 */
struct arch_register_class_t {
279
280
281
282
283
284
285
286
	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;
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
};

/** 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)

304
static inline const arch_register_t *arch_register_for_index(
305
		const arch_register_class_t *cls, unsigned idx)
306
307
308
309
310
311
312
313
{
	assert(idx < cls->n_regs);
	return &cls->regs[idx];
}

/**
 * Convenience macro to check for set constraints.
 * @param req   A pointer to register requirements.
314
315
 * @param kind  The kind of constraint to check for
 *              (see arch_register_req_type_t).
316
317
318
319
320
321
322
323
324
 * @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 {
325
326
327
	arch_register_req_type_t     type; /**< The type of the constraint. */
	const arch_register_class_t *cls;  /**< The register class this constraint
	                                        belongs to. */
328
329
330
331
332
333
	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) */
334
335
	unsigned char width;                /**< specifies how many sequential
	                                         registers are required */
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
};

static inline int reg_reqs_equal(const arch_register_req_t *req1,
                                 const arch_register_req_t *req2)
{
	if (req1 == req2)
		return 1;

	if (req1->type != req2->type
			|| req1->cls != req2->cls
			|| req1->other_same != req2->other_same
			|| req1->other_different != req2->other_different)
		return 0;

	if (req1->limited != NULL) {
		size_t n_regs;

		if (req2->limited == NULL)
			return 0;

		n_regs = arch_register_class_n_regs(req1->cls);
357
		if (!rbitsets_equal(req1->limited, req2->limited, n_regs))
358
359
360
361
362
363
364
365
366
367
368
369
370
			return 0;
	}

	return 1;
}

/**
 * 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 */

371
372
	/** nodes for this inverse operation. shall be in schedule order.
	 * last element is the target value */
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
	ir_node  **nodes;
};

struct arch_irn_ops_t {

	/**
	 * Classify the node.
	 * @param irn The node.
	 * @return A classification.
	 */
	arch_irn_class_t (*classify)(const ir_node *irn);

	/**
	 * Get the entity on the stack frame this node depends on.
	 * @param irn  The node in question.
388
389
	 * @return The entity on the stack frame or NULL, if the node does not have
	 *         a stack frame entity.
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
	 */
	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
418
419
	 * @param i         Index of the argument we want the inverse operation to
	 *                  yield
420
	 * @param inverse   struct to be filled with the resulting inverse op
421
422
	 * @param obstack   The obstack to use for allocation of the returned nodes
	 *                  array
423
424
	 * @return          The inverse operation or NULL if operation invertible
	 */
425
426
427
	arch_inverse_t *(*get_inverse)(const ir_node *irn, int i,
	                               arch_inverse_t *inverse,
	                               struct obstack *obstack);
428
429
430
431
432
433
434
435
436
437

	/**
	 * 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);

	/**
438
439
	 * Asks the backend whether operand @p i of @p irn can be loaded form memory
	 * internally
440
441
	 *
	 * @param irn  The node.
442
443
	 * @param i    Index of the argument we would like to know whether @p irn
	 *             can load it form memory internally
444
445
446
447
448
449
450
451
452
453
454
	 * @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.
	 */
455
456
	void (*perform_memory_operand)(ir_node *irn, ir_node *spill,
	                               unsigned int i);
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
};

/**
 * Architecture interface.
 */
struct arch_isa_if_t {
	/**
	 * Initialize the isa interface.
	 * @param file_handle  the file handle to write the output to
	 * @return a new isa instance
	 */
	arch_env_t *(*init)(FILE *file_handle);

	/**
	 * Free the isa instance.
	 */
	void (*done)(void *self);

	/**
	 * Called directly after initialization. Backend should handle all
	 * intrinsics here.
	 */
	void (*handle_intrinsics)(void);

	/**
482
483
	 * Get the register class which shall be used to store a value of a given
	 * mode.
484
485
486
487
	 * @param self The this pointer.
	 * @param mode The mode in question.
	 * @return A register class which can hold values of the given mode.
	 */
488
	const arch_register_class_t *(*get_reg_class_for_mode)(const ir_mode *mode);
489
490
491
492
493
494
495

	/**
	 * Get the ABI restrictions for procedure calls.
	 * @param self        The this pointer.
	 * @param call_type   The call type of the method (procedure) in question.
	 * @param p           The array of parameter locations to be filled.
	 */
496
497
	void (*get_call_abi)(const void *self, ir_type *call_type,
	                     be_abi_call_t *abi);
498
499
500
501
502
503
504

	/**
	 * Get the necessary alignment for storing a register of given class.
	 * @param self  The isa object.
	 * @param cls   The register class.
	 * @return      The alignment in bytes.
	 */
505
	int (*get_reg_class_alignment)(const arch_register_class_t *cls);
506
507
508
509
510
511
512
513
514
515
516
517

	/**
	 * A "static" function, returns the frontend settings
	 * needed for this backend.
	 */
	const backend_params *(*get_params)(void);

	/**
	 * Return an ordered list of irgs where code should be generated for.
	 * If NULL is returned, all irg will be taken into account and they will be
	 * generated in an arbitrary order.
	 * @param self   The isa object.
518
519
520
521
	 * @param irgs   A flexible array ARR_F of length 0 where the backend can
	 *               append the desired irgs.
	 * @return A flexible array ARR_F containing all desired irgs in the
	 *         desired order.
522
523
524
525
526
527
	 */
	ir_graph **(*get_backend_irg_list)(const void *self, ir_graph ***irgs);

	/**
	 * mark node as rematerialized
	 */
528
	void (*mark_remat)(ir_node *node);
529
530
531
532
533
534

	/**
	 * 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)
	 */
535
	asm_constraint_flags_t (*parse_asm_constraint)(const char **c);
536
537
538
539
540

	/**
	 * returns true if the string is a valid clobbered (register) in this
	 * backend
	 */
541
	int (*is_valid_clobber)(const char *clobber);
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586

	/**
	 * Initialize the code generator.
	 * @param irg  A graph
	 * @return     A newly created code generator.
	 */
	void (*init_graph)(ir_graph *irg);

	/**
	 * return node used as base in pic code addresses
	 */
	ir_node* (*get_pic_base)(ir_graph *irg);

	/**
	 * 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 after register allocation.
	 */
	void (*after_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.
	 * The code generator must also be de-allocated here.
	 */
	void (*emit)(ir_graph *irg);
587
588
589
590
591
};

#define arch_env_done(env)                             ((env)->impl->done(env))
#define arch_env_handle_intrinsics(env)                \
	do { if((env)->impl->handle_intrinsics != NULL) (env)->impl->handle_intrinsics(); } while(0)
592
#define arch_env_get_reg_class_for_mode(env,mode)      ((env)->impl->get_reg_class_for_mode((mode)))
593
#define arch_env_get_call_abi(env,tp,abi)              ((env)->impl->get_call_abi((env), (tp), (abi)))
594
#define arch_env_get_reg_class_alignment(env,cls)      ((env)->impl->get_reg_class_alignment((cls)))
595
#define arch_env_get_params(env)                       ((env)->impl->get_params())
596
#define arch_env_get_allowed_execution_units(env,irn)  ((env)->impl->get_allowed_execution_units((irn)))
597
598
#define arch_env_get_machine(env)                      ((env)->impl->get_machine(env))
#define arch_env_get_backend_irg_list(env,irgs)        ((env)->impl->get_backend_irg_list((env), (irgs)))
599
600
#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))
601
#define arch_env_mark_remat(env,node) \
602
	do { if ((env)->impl->mark_remat != NULL) (env)->impl->mark_remat((node)); } while(0)
603
604
605
606
607
608

/**
 * ISA base class.
 */
struct arch_env_t {
	const arch_isa_if_t   *impl;
609
610
	unsigned               n_registers;      /**< number of registers */
	const arch_register_t *registers;        /**< register array */
611
612
	unsigned               n_register_classes; /**< number of register classes*/
	const arch_register_class_t *register_classes; /**< register classes */
613
614
615
616
617
618
619
620
621
622
	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_dir;        /**< -1 for decreasing, 1 for
	                                              increasing. */
	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 */
623
	bool                   custom_abi : 1;   /**< backend does all abi handling
624
625
	                                              and does not need the generic
	                                              stuff from beabi.h/.c */
626
627
628
629
630
};

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

634
635
636
	return ARR_LEN(info->out_infos);
}

637
static inline const arch_irn_ops_t *get_irn_ops_simple(const ir_node *node)
638
{
639
640
641
642
643
644
645
646
647
	const ir_op          *ops    = get_irn_op(node);
	const arch_irn_ops_t *be_ops = get_op_ops(ops)->be_ops;
	assert(!is_Proj(node));
	return be_ops;
}

static inline const arch_register_req_t *arch_get_register_req_out(
		const ir_node *irn)
{
648
649
	int             pos = 0;
	backend_info_t *info;
650

651
652
653
654
655
	/* you have to query the Proj nodes for the constraints (or use
	 * arch_get_out_register_req. Querying a mode_T node and expecting
	 * arch_no_register_req is a bug in your code! */
	assert(get_irn_mode(irn) != mode_T);

656
657
658
659
	if (is_Proj(irn)) {
		pos = get_Proj_proj(irn);
		irn = get_Proj_pred(irn);
	}
660

661
662
663
664
665
	info = be_get_info(irn);
	if (info->out_infos == NULL)
		return arch_no_register_req;

	return info->out_infos[pos].req;
666
667
668
669
670
671
672
673
}

static inline bool arch_irn_is_ignore(const ir_node *irn)
{
	const arch_register_req_t *req = arch_get_register_req_out(irn);
	return !!(req->type & arch_register_req_type_ignore);
}

674
675
static inline bool arch_irn_consider_in_reg_alloc(
		const arch_register_class_t *cls, const ir_node *node)
676
{
677
678
679
680
	const arch_register_req_t *req = arch_get_register_req_out(node);
	return
		req->cls == cls &&
		!(req->type & arch_register_req_type_ignore);
681
682
683
684
685
686
687
688
}

/**
 * Get register constraints for an operand at position @p
 */
static inline const arch_register_req_t *arch_get_in_register_req(
		const ir_node *node, int pos)
{
689
690
691
692
	const backend_info_t *info = be_get_info(node);
	if (info->in_reqs == NULL)
		return arch_no_register_req;
	return info->in_reqs[pos];
693
694
695
696
697
698
699
700
}

/**
 * Get register constraint for a produced result (the @p pos result)
 */
static inline const arch_register_req_t *arch_get_out_register_req(
		const ir_node *node, int pos)
{
701
702
703
704
705
706
707
708
709
710
711
712
	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;
}

static inline void arch_set_out_register_req(ir_node *node, int pos,
		const arch_register_req_t *req)
{
	backend_info_t *info = be_get_info(node);
	assert(pos < (int) arch_irn_get_n_outs(node));
	info->out_infos[pos].req = req;
713
714
}

715
716
717
718
719
720
721
722
723
724
725
726
727
728
static inline void arch_set_in_register_reqs(ir_node *node,
                                            const arch_register_req_t **in_reqs)
{
	backend_info_t *info = be_get_info(node);
	info->in_reqs = in_reqs;
}

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

729
730
731
732
733
734
/**
 * 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.
 */
735
#define be_foreach_definition_(node, cls, value, code)                     \
736
737
738
739
740
741
742
743
744
745
746
747
748
749
	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_);                               \
			req_  = arch_get_register_req_out(value);                      \
			if (req_->cls != cls)                                          \
				continue;                                                  \
			code                                                           \
		}                                                                  \
	} else {                                                               \
		const arch_register_req_t *req_ = arch_get_register_req_out(node); \
		value = node;                                                      \
750
		if (req_->cls == cls) {                                            \
751
752
753
754
755
			code                                                           \
		}                                                                  \
	}                                                                      \
	} while (0)

756
757
758
759
760
761
762
#define be_foreach_definition(node, cls, value, code)                      \
	be_foreach_definition_(node, cls, value,                               \
		if (req_->type & arch_register_req_type_ignore)                    \
			continue;                                                      \
		code                                                               \
	)

763
#endif