bearch.h 27.5 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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
	/** No register requirement. */
 	arch_register_req_type_none              = 0,
	/** 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,
	/** ignore while allocating registers */
	arch_register_req_type_ignore            = 1U << 4,
	/** 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) */
	arch_register_req_type_produces_sp       = 1U << 5,
Sebastian Hack's avatar
Sebastian Hack committed
93
} arch_register_req_type_t;
94

Matthias Braun's avatar
Matthias Braun committed
95
96
extern const arch_register_req_t *arch_no_register_req;

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

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

119
void arch_set_frame_offset(ir_node *irn, int bias);
120

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

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

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

Sebastian Hack's avatar
Sebastian Hack committed
146
147
148
149
150
151
/**
 * 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.
 */
152
153
extern void arch_put_non_ignore_regs(const arch_register_class_t *cls,
                                     bitset_t *bs);
Sebastian Hack's avatar
Sebastian Hack committed
154

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

165
166
#define arch_reg_out_is_allocatable(irn, reg) arch_reg_is_allocatable(irn, -1, reg)

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

177
178
#define arch_get_irn_reg_class_out(irn) arch_get_irn_reg_class(irn, -1)

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

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

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

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

209
210
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
211

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

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

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

236
237
238
239
/**
 * A register.
 */
struct arch_register_t {
240
241
242
243
244
245
	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 */
246
	const arch_register_req_t   *single_req;
247
248
};

249
250
static inline const arch_register_class_t *_arch_register_get_class(
		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
{
	return reg->name;
}

265
266
267
#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)
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282

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

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

308
309
static inline const arch_register_t *_arch_register_for_index(
		const arch_register_class_t *cls, unsigned idx)
310
311
312
313
314
315
316
317
318
319
{
	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.
320
321
 * @param kind  The kind of constraint to check for
 *              (see arch_register_req_type_t).
322
323
324
325
326
327
328
329
330
 * @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 {
331
332
333
	arch_register_req_type_t     type; /**< The type of the constraint. */
	const arch_register_class_t *cls;  /**< The register class this constraint
	                                        belongs to. */
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
	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) */
};

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);
361
		if (!rbitsets_equal(req1->limited, req2->limited, n_regs))
362
363
364
365
366
367
368
369
370
371
372
373
374
			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 */

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

struct arch_irn_ops_t {

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

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

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

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

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

	/**
	 * 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.
	 */
503
	void (*spill)(void *self, ir_graph *irg);
504
505
506
507
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

	/**
	 * 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)
551
#define arch_code_generator_spill(cg, irg)      _arch_cg_call_env(cg, irg, spill)
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
587
588
#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.
	 */
589
	unsigned (*get_n_reg_class)(void);
590
591
592
593
594
595

	/**
	 * Get the i-th register class.
	 * @param i The number of the register class.
	 * @return The register class.
	 */
596
	const arch_register_class_t *(*get_reg_class)(unsigned i);
597
598

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

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

	/**
	 * 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.
	 */
631
632
	const list_sched_selector_t *(*get_list_sched_selector)(const void *self,
			list_sched_selector_t *selector);
633
634
635
636
637
638
639
640
641
642
643
644
645
646

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

	/**
	 * 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
	 *                     };
	 */
670
671
	const be_execution_unit_t ***(*get_allowed_execution_units)(
			const ir_node *irn);
672
673
674
675
676
677
678
679
680
681
682
683

	/**
	 * 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.
684
685
686
687
	 * @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.
688
689
690
691
692
693
	 */
	ir_graph **(*get_backend_irg_list)(const void *self, ir_graph ***irgs);

	/**
	 * mark node as rematerialized
	 */
694
	void (*mark_remat)(ir_node *node);
695
696
697
698
699
700

	/**
	 * 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)
	 */
701
	asm_constraint_flags_t (*parse_asm_constraint)(const char **c);
702
703
704
705
706

	/**
	 * returns true if the string is a valid clobbered (register) in this
	 * backend
	 */
707
	int (*is_valid_clobber)(const char *clobber);
708
709
710
711
712
};

#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)
713
714
715
#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)))
716
717
718
719
#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))
720
#define arch_env_get_reg_class_alignment(env,cls)      ((env)->impl->get_reg_class_alignment((cls)))
721
#define arch_env_get_params(env)                       ((env)->impl->get_params())
722
#define arch_env_get_allowed_execution_units(env,irn)  ((env)->impl->get_allowed_execution_units((irn)))
723
724
#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)))
725
726
#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))
727
#define arch_env_mark_remat(env,node) \
728
	do { if ((env)->impl->mark_remat != NULL) (env)->impl->mark_remat((node)); } while(0)
729
730
731
732
733
734

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

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

756
757
758
	return ARR_LEN(info->out_infos);
}

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

773
774
775
776
777
	/* 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);

778
779
780
781
	if (is_Proj(irn)) {
		pos = get_Proj_proj(irn);
		irn = get_Proj_pred(irn);
	}
782

783
784
785
786
787
	info = be_get_info(irn);
	if (info->out_infos == NULL)
		return arch_no_register_req;

	return info->out_infos[pos].req;
788
789
790
791
792
793
794
795
}

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

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

/**
 * 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)
{
821
822
823
824
825
826
827
828
829
830
831
832
	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;
833
834
}

835
#endif