bearch.h 29.6 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
50
} arch_register_class_flags_t;

51
typedef enum arch_register_type_t {
Michael Beck's avatar
Michael Beck committed
52
	arch_register_type_none         = 0,
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
	/** 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
71
} arch_register_type_t;
72

Sebastian Hack's avatar
Sebastian Hack committed
73
74
75
/**
 * Different types of register allocation requirements.
 */
76
typedef enum arch_register_req_type_t {
77
	/** No register requirement. */
78
	arch_register_req_type_none              = 0,
79
80
81
82
83
84
85
86
	/** 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,
87
	/** The registernumber should be aligned (in case of multiregister values)*/
88
	arch_register_req_type_aligned           = 1U << 4,
89
	/** ignore while allocating registers */
90
	arch_register_req_type_ignore            = 1U << 5,
91
92
93
	/** 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) */
94
	arch_register_req_type_produces_sp       = 1U << 6,
Sebastian Hack's avatar
Sebastian Hack committed
95
} arch_register_req_type_t;
96

Matthias Braun's avatar
Matthias Braun committed
97
98
extern const arch_register_req_t *arch_no_register_req;

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

107
108
109
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
110
/**
111
 * Node classification. Used for statistics and for detecting reload nodes.
Sebastian Hack's avatar
Sebastian Hack committed
112
 */
113
typedef enum arch_irn_class_t {
114
115
116
117
118
	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
119
120
} arch_irn_class_t;

121
void arch_set_frame_offset(ir_node *irn, int bias);
122

123
ir_entity *arch_get_frame_entity(const ir_node *irn);
124
int        arch_get_sp_bias(ir_node *irn);
Sebastian Hack's avatar
Sebastian Hack committed
125

126
int             arch_get_op_estimated_cost(const ir_node *irn);
127
128
129
130
131
132
133
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);
134

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

Sebastian Hack's avatar
Sebastian Hack committed
148
149
150
151
152
153
/**
 * Put all registers which shall not be ignored by the register
 * allocator in a bit set.
 * @param cls The register class to consider.
 * @param bs  The bit set to put the registers to.
 */
154
155
extern void arch_put_non_ignore_regs(const arch_register_class_t *cls,
                                     bitset_t *bs);
Sebastian Hack's avatar
Sebastian Hack committed
156

Sebastian Hack's avatar
Sebastian Hack committed
157
158
159
160
161
162
163
/**
 * 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.
 */
164
165
int arch_reg_is_allocatable(const ir_node *irn, int pos,
                            const arch_register_t *reg);
Sebastian Hack's avatar
Sebastian Hack committed
166

167
168
#define arch_reg_out_is_allocatable(irn, reg) arch_reg_is_allocatable(irn, -1, reg)

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

179
180
#define arch_get_irn_reg_class_out(irn) arch_get_irn_reg_class(irn, -1)

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

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

197
198
199
200
201
/**
 * Classify a node.
 * @param irn The node.
 * @return A classification of the node.
 */
202
arch_irn_class_t arch_irn_classify(const ir_node *irn);
203

Sebastian Hack's avatar
Sebastian Hack committed
204
205
206
207
208
/**
 * Get the flags of a node.
 * @param irn The node.
 * @return The flags.
 */
209
arch_irn_flags_t arch_irn_get_flags(const ir_node *irn);
Sebastian Hack's avatar
Sebastian Hack committed
210

211
212
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
213

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

216
217
218
219
220
221
222
223
/**
 * 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
224
/**
Sebastian Hack's avatar
Sebastian Hack committed
225
 * Initialize the architecture environment struct.
226
227
 * @param isa           The isa which shall be put into the environment.
 * @param file_handle   The file handle
Sebastian Hack's avatar
Sebastian Hack committed
228
229
 * @return The environment.
 */
230
extern arch_env_t *arch_env_init(const arch_isa_if_t *isa,
231
                                 FILE *file_handle, be_main_env_t *main_env);
Sebastian Hack's avatar
Sebastian Hack committed
232

233
234
235
236
237
/**
 * Register an instruction set architecture
 */
void be_register_isa_if(const char *name, const arch_isa_if_t *isa);

238
239
240
241
/**
 * A register.
 */
struct arch_register_t {
242
243
244
245
246
247
	const char                  *name;       /**< The name of the register. */
	const arch_register_class_t *reg_class;  /**< The class of the register */
	unsigned                     index;      /**< The index of the register in
	                                              the class. */
	arch_register_type_t         type;       /**< The type of the register. */
	/** register constraint allowing just this register */
248
	const arch_register_req_t   *single_req;
249
250
};

251
252
static inline const arch_register_class_t *_arch_register_get_class(
		const arch_register_t *reg)
253
254
255
256
{
	return reg->reg_class;
}

257
static inline unsigned _arch_register_get_index(const arch_register_t *reg)
258
259
260
261
{
	return reg->index;
}

262
static inline const char *_arch_register_get_name(const arch_register_t *reg)
263
264
265
266
{
	return reg->name;
}

267
268
269
#define arch_register_get_class(reg)        _arch_register_get_class(reg)
#define arch_register_get_index(reg)        _arch_register_get_index(reg)
#define arch_register_get_name(reg)         _arch_register_get_name(reg)
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284

/**
 * 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 {
285
286
287
288
289
290
291
292
	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;
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
};

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

310
311
static inline const arch_register_t *_arch_register_for_index(
		const arch_register_class_t *cls, unsigned idx)
312
313
314
315
316
317
318
319
320
321
{
	assert(idx < cls->n_regs);
	return &cls->regs[idx];
}

#define arch_register_for_index(cls, idx)   _arch_register_for_index(cls, idx)

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

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);
365
		if (!rbitsets_equal(req1->limited, req2->limited, n_regs))
366
367
368
369
370
371
372
373
374
375
376
377
378
			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 */

379
380
	/** nodes for this inverse operation. shall be in schedule order.
	 * last element is the target value */
381
382
383
384
385
386
	ir_node  **nodes;
};

struct arch_irn_ops_t {

	/**
387
	 * Get the register requirements for a given operand.
388
	 * @param irn The node.
389
390
391
392
	 * @param pos The operand's position
	 * @return    The register requirements for the selected operand.
	 *            The pointer returned is never NULL.
	 */
393
394
	const arch_register_req_t *(*get_irn_reg_req_in)(const ir_node *irn,
	                                                 int pos);
395

396
397
398
399
400
401
402
403
404
405
	/**
	 * 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.
406
407
	 * @return The entity on the stack frame or NULL, if the node does not have
	 *         a stack frame entity.
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
	 */
	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
436
437
	 * @param i         Index of the argument we want the inverse operation to
	 *                  yield
438
	 * @param inverse   struct to be filled with the resulting inverse op
439
440
	 * @param obstack   The obstack to use for allocation of the returned nodes
	 *                  array
441
442
	 * @return          The inverse operation or NULL if operation invertible
	 */
443
444
445
	arch_inverse_t *(*get_inverse)(const ir_node *irn, int i,
	                               arch_inverse_t *inverse,
	                               struct obstack *obstack);
446
447
448
449
450
451
452
453
454
455

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

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

/**
 * The code generator interface.
 */
struct arch_code_generator_if_t {
	/**
	 * Initialize the code generator.
483
	 * @param irg  A graph
484
485
	 * @return     A newly created code generator.
	 */
486
	void *(*init)(ir_graph *irg);
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506

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

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

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

	/**
	 * Backend may provide an own spiller.
	 * This spiller needs to spill all register classes.
	 */
507
	void (*spill)(void *self, ir_graph *irg);
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
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

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

	/**
	 * Called after register allocation.
	 */
	void (*after_ra)(void *self);

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

	/**
	 * 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 (*done)(void *self);
};

/**
 * helper macro: call function func from the code generator
 * if it's implemented.
 */
#define _arch_cg_call(cg, func) \
do { \
	if((cg)->impl->func) \
		(cg)->impl->func(cg); \
} while(0)

#define _arch_cg_call_env(cg, env, func) \
do { \
	if((cg)->impl->func) \
		(cg)->impl->func(cg, env); \
} while(0)

#define arch_code_generator_before_abi(cg)      _arch_cg_call(cg, before_abi)
#define arch_code_generator_prepare_graph(cg)   _arch_cg_call(cg, prepare_graph)
#define arch_code_generator_before_ra(cg)       _arch_cg_call(cg, before_ra)
#define arch_code_generator_after_ra(cg)        _arch_cg_call(cg, after_ra)
#define arch_code_generator_finish(cg)          _arch_cg_call(cg, finish)
#define arch_code_generator_done(cg)            _arch_cg_call(cg, done)
555
#define arch_code_generator_spill(cg, irg)      _arch_cg_call_env(cg, irg, spill)
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
587
588
589
590
591
592
#define arch_code_generator_has_spiller(cg)     ((cg)->impl->spill != NULL)
#define arch_code_generator_get_pic_base(cg)    \
	((cg)->impl->get_pic_base != NULL ? (cg)->impl->get_pic_base(cg) : NULL)

/**
 * Code generator base class.
 */
struct arch_code_generator_t {
	const arch_code_generator_if_t *impl;
};

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

	/**
	 * Get the the number of register classes in the isa.
	 * @return The number of register classes.
	 */
593
	unsigned (*get_n_reg_class)(void);
594
595
596
597
598
599

	/**
	 * Get the i-th register class.
	 * @param i The number of the register class.
	 * @return The register class.
	 */
600
	const arch_register_class_t *(*get_reg_class)(unsigned i);
601
602

	/**
603
604
	 * Get the register class which shall be used to store a value of a given
	 * mode.
605
606
607
608
	 * @param self The this pointer.
	 * @param mode The mode in question.
	 * @return A register class which can hold values of the given mode.
	 */
609
	const arch_register_class_t *(*get_reg_class_for_mode)(const ir_mode *mode);
610
611
612
613
614
615
616

	/**
	 * 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.
	 */
617
618
	void (*get_call_abi)(const void *self, ir_type *call_type,
	                     be_abi_call_t *abi);
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634

	/**
	 * Get the code generator interface.
	 * @param self The this pointer.
	 * @return     Some code generator interface.
	 */
	const arch_code_generator_if_t *(*get_code_generator_if)(void *self);

	/**
	 * Get the list scheduler to use. There is already a selector given, the
	 * backend is free to modify and/or ignore it.
	 *
	 * @param self     The isa object.
	 * @param selector The selector given by options.
	 * @return         The list scheduler selector.
	 */
635
636
	const list_sched_selector_t *(*get_list_sched_selector)(const void *self,
			list_sched_selector_t *selector);
637
638
639
640
641
642
643
644
645
646
647
648
649
650

	/**
	 * Get the ILP scheduler to use.
	 * @param self  The isa object.
	 * @return      The ILP scheduler selector
	 */
	const ilp_sched_selector_t *(*get_ilp_sched_selector)(const void *self);

	/**
	 * 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.
	 */
651
	int (*get_reg_class_alignment)(const arch_register_class_t *cls);
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673

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

	/**
	 * Returns an 2-dim array of execution units, @p irn can be executed on.
	 * The first dimension is the type, the second the allowed units of this
	 * type.
	 * Each dimension is a NULL terminated list.
	 * @param self  The isa object.
	 * @param irn   The node.
	 * @return An array of allowed execution units.
	 *         exec_unit = {
	 *                       { unit1_of_tp1, ..., unitX1_of_tp1, NULL },
	 *                       ...,
	 *                       { unit1_of_tpY, ..., unitXn_of_tpY, NULL },
	 *                       NULL
	 *                     };
	 */
674
675
	const be_execution_unit_t ***(*get_allowed_execution_units)(
			const ir_node *irn);
676
677
678
679
680
681
682
683
684
685
686
687

	/**
	 * Return the abstract machine for this isa.
	 * @param self  The isa object.
	 */
	const be_machine_t *(*get_machine)(const void *self);

	/**
	 * 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.
688
689
690
691
	 * @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.
692
693
694
695
696
697
	 */
	ir_graph **(*get_backend_irg_list)(const void *self, ir_graph ***irgs);

	/**
	 * mark node as rematerialized
	 */
698
	void (*mark_remat)(ir_node *node);
699
700
701
702
703
704

	/**
	 * 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)
	 */
705
	asm_constraint_flags_t (*parse_asm_constraint)(const char **c);
706
707
708
709
710

	/**
	 * returns true if the string is a valid clobbered (register) in this
	 * backend
	 */
711
	int (*is_valid_clobber)(const char *clobber);
712
713
714
715
716
};

#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)
717
718
719
#define arch_env_get_n_reg_class(env)                  ((env)->impl->get_n_reg_class())
#define arch_env_get_reg_class(env,i)                  ((env)->impl->get_reg_class(i))
#define arch_env_get_reg_class_for_mode(env,mode)      ((env)->impl->get_reg_class_for_mode((mode)))
720
721
722
723
#define arch_env_get_call_abi(env,tp,abi)              ((env)->impl->get_call_abi((env), (tp), (abi)))
#define arch_env_get_code_generator_if(env)            ((env)->impl->get_code_generator_if((env)))
#define arch_env_get_list_sched_selector(env,selector) ((env)->impl->get_list_sched_selector((env), (selector)))
#define arch_env_get_ilp_sched_selector(env)           ((env)->impl->get_ilp_sched_selector(env))
724
#define arch_env_get_reg_class_alignment(env,cls)      ((env)->impl->get_reg_class_alignment((cls)))
725
#define arch_env_get_params(env)                       ((env)->impl->get_params())
726
#define arch_env_get_allowed_execution_units(env,irn)  ((env)->impl->get_allowed_execution_units((irn)))
727
728
#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)))
729
730
#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))
731
#define arch_env_mark_remat(env,node) \
732
	do { if ((env)->impl->mark_remat != NULL) (env)->impl->mark_remat((node)); } while(0)
733
734
735
736
737
738

/**
 * ISA base class.
 */
struct arch_env_t {
	const arch_isa_if_t   *impl;
739
740
741
742
743
744
745
746
747
748
	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 */
749
750
751
	bool                   custom_abi : 1;   /**< backend does all abi handling
	                                              and does not need the generic stuff
	                                              from beabi.h/.c */
752
753
754
755
756
};

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

760
761
762
	return ARR_LEN(info->out_infos);
}

763
static inline const arch_irn_ops_t *get_irn_ops_simple(const ir_node *node)
764
{
765
766
767
768
769
770
771
772
773
	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)
{
774
775
	int             pos = 0;
	backend_info_t *info;
776

777
778
779
780
781
	/* 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);

782
783
784
785
	if (is_Proj(irn)) {
		pos = get_Proj_proj(irn);
		irn = get_Proj_pred(irn);
	}
786

787
788
789
790
791
	info = be_get_info(irn);
	if (info->out_infos == NULL)
		return arch_no_register_req;

	return info->out_infos[pos].req;
792
793
794
795
796
797
798
799
}

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);
}

800
801
static inline bool arch_irn_consider_in_reg_alloc(
		const arch_register_class_t *cls, const ir_node *node)
802
{
803
804
805
806
	const arch_register_req_t *req = arch_get_register_req_out(node);
	return
		req->cls == cls &&
		!(req->type & arch_register_req_type_ignore);
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
}

/**
 * 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)
{
	const arch_irn_ops_t *ops = get_irn_ops_simple(node);
	return ops->get_irn_reg_req_in(node, pos);
}

/**
 * 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)
{
825
826
827
828
829
830
831
832
833
834
835
836
	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;
837
838
}

839
840
841
842
843
844
/**
 * 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.
 */
845
#define be_foreach_definition_(node, cls, value, code)                     \
846
847
848
849
850
851
852
853
854
855
856
857
858
859
	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;                                                      \
860
		if (req_->cls == cls) {                                            \
861
862
863
864
865
			code                                                           \
		}                                                                  \
	}                                                                      \
	} while (0)

866
867
868
869
870
871
872
#define be_foreach_definition(node, cls, value, code)                      \
	be_foreach_definition_(node, cls, value,                               \
		if (req_->type & arch_register_req_type_ignore)                    \
			continue;                                                      \
		code                                                               \
	)

873
#endif