benode_t.h 18 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.
 */

Sebastian Hack's avatar
Sebastian Hack committed
20
/**
Christian Würdig's avatar
Christian Würdig committed
21
22
23
24
25
 * @file
 * @brief       Backend node support for generic backend nodes.
 * @author      Sebastian Hack
 * @date        17.05.2005
 * @version     $Id$
Sebastian Hack's avatar
Sebastian Hack committed
26
 *
Christian Würdig's avatar
Christian Würdig committed
27
28
 * Backend node support for generic backend nodes.
 * This file provides Perm, Copy, Spill and Reload nodes.
Sebastian Hack's avatar
Sebastian Hack committed
29
 */
Christian Würdig's avatar
Christian Würdig committed
30
31
#ifndef FIRM_BE_BENODE_T_H
#define FIRM_BE_BENODE_T_H
32

33
34
#include <limits.h>

35
#include "firm_types.h"
36
#include "irnode_t.h"
Christian Würdig's avatar
Christian Würdig committed
37
#include "bearch.h"
Sebastian Hack's avatar
Sebastian Hack committed
38

39
40
#define BE_OUT_POS(p) (-((p) + 1))

41
42
43
44
45
46
/**
 * The benode op's.  Must be available to register emitter function.
 */
extern ir_op *op_be_Spill;
extern ir_op *op_be_Reload;
extern ir_op *op_be_Perm;
Matthias Braun's avatar
Matthias Braun committed
47
extern ir_op *op_be_MemPerm;
48
49
extern ir_op *op_be_Copy;
extern ir_op *op_be_Keep;
Michael Beck's avatar
Michael Beck committed
50
extern ir_op *op_be_CopyKeep;
51
52
53
extern ir_op *op_be_Call;
extern ir_op *op_be_Return;
extern ir_op *op_be_IncSP;
Sebastian Hack's avatar
Sebastian Hack committed
54
extern ir_op *op_be_AddSP;
Michael Beck's avatar
Michael Beck committed
55
extern ir_op *op_be_SubSP;
56
57
extern ir_op *op_be_RegParams;
extern ir_op *op_be_FrameAddr;
58
extern ir_op *op_be_Barrier;
Michael Beck's avatar
Michael Beck committed
59
extern ir_op *op_be_Unwind;
60

Sebastian Hack's avatar
Sebastian Hack committed
61
/** Not used yet. */
62
63
64
65
66
67
typedef enum {
	be_frame_flag_spill = 1,
	be_frame_flag_local = 2,
	be_frame_flag_arg   = 4
} be_frame_flag_t;

Sebastian Hack's avatar
Sebastian Hack committed
68
69
70
71
/**
 * A "symbolic constant" for the size of the stack frame to use with IncSP nodes.
 * It gets back-patched to the real size as soon it is known.
 */
72
73
#define BE_STACK_FRAME_SIZE_EXPAND INT_MAX
#define BE_STACK_FRAME_SIZE_SHRINK INT_MIN
Sebastian Hack's avatar
Sebastian Hack committed
74

75
76
77
78
79
/**
 * Determines if irn is a be_node.
 */
int is_be_node(const ir_node *irn);

80
81
82
/**
 * Create all BE specific opcodes.
 */
Sebastian Hack's avatar
Sebastian Hack committed
83
void be_node_init(void);
84

85
86
87
/**
 * Position numbers for the be_Spill inputs.
 */
88
enum {
89
90
	be_pos_Spill_frame = 0,
	be_pos_Spill_val   = 1
91
};
92
93
94
95

/**
 * Make a new Spill node.
 */
96
97
ir_node *be_new_Spill(const arch_register_class_t *cls, const arch_register_class_t *cls_frame,
	ir_graph *irg, ir_node *bl, ir_node *frame, ir_node *to_spill);
98

99
100
101
/**
 * Position numbers for the be_Reload inputs.
 */
102
enum {
103
104
	be_pos_Reload_frame = 0,
	be_pos_Reload_mem   = 1
105
};
106
107
108
109

/**
 * Make a new Reload node.
 */
110
111
ir_node *be_new_Reload(const arch_register_class_t *cls, const arch_register_class_t *cls_frame,
	ir_graph *irg, ir_node *bl, ir_node *frame, ir_node *mem, ir_mode *mode);
112

113
114
115
/**
 * Position numbers for the be_Copy inputs.
 */
116
enum {
117
	be_pos_Copy_op = 0
118
};
119
120
121
122

/**
 * Make a new Copy node.
 */
Sebastian Hack's avatar
Sebastian Hack committed
123
ir_node *be_new_Copy(const arch_register_class_t *cls, ir_graph *irg, ir_node *block, ir_node *in);
124
/** Returns the Copy Argument. */
125
ir_node *be_get_Copy_op(const ir_node *cpy);
126
127
/** Sets the Copy Argument. */
void be_set_Copy_op(ir_node *cpy, ir_node *op);
128

129
130
131
/**
 * Make a new Perm node.
 */
Sebastian Hack's avatar
Sebastian Hack committed
132
ir_node *be_new_Perm(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, int arity, ir_node *in[]);
133
134
135
136
137
138
139
140
141
142
143
144
145
146

/**
 * Reduce a Perm.
 * Basically, we provide a map to remap the Perm's arguments. If an entry in the
 * map is -1, the argument gets deleted.
 * This function takes care, that the register data and the input array reflects
 * the changes described by the map.
 * This is needed by the Perm optimization/movement in belower.c, see push_through_perm().
 * @param perm     The perm node.
 * @param new_size The new number of arguments (must be smaller or equal to the current one).
 * @param map      A map assigning each operand a new index (or -1 to indicate deletion).
 */
void be_Perm_reduce(ir_node *perm, int new_size, int *map);

147
148
149
/**
 * Create a new MemPerm node.
 */
Matthias Braun's avatar
Matthias Braun committed
150
ir_node *be_new_MemPerm(const arch_env_t *arch_env, ir_graph *irg, ir_node *bl, int n, ir_node *in[]);
Sebastian Hack's avatar
Sebastian Hack committed
151
ir_node *be_new_Keep(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, int arity, ir_node *in[]);
Sebastian Hack's avatar
Sebastian Hack committed
152

153
154
void be_Keep_add_node(ir_node *keep, const arch_register_class_t *cls, ir_node *node);

155
156
157
158
159
160
161
/**
 * Position numbers for the be_FrameAddr inputs
 */
enum {
	be_pos_FrameAddr_ptr = 0
};

Michael Beck's avatar
Michael Beck committed
162
/** Create a new FrameAddr node. */
163
ir_node *be_new_FrameAddr(const arch_register_class_t *cls_frame, ir_graph *irg, ir_node *bl, ir_node *frame, ir_entity *ent);
164

Michael Beck's avatar
Michael Beck committed
165
/** Return the frame input of a FrameAddr node. */
Matthias Braun's avatar
Matthias Braun committed
166
167
168
ir_node *be_get_FrameAddr_frame(const ir_node *node);

ir_entity *be_get_FrameAddr_entity(const ir_node *node);
Michael Beck's avatar
Michael Beck committed
169

170
171
172
/**
 * Position numbers for the be_AddSP inputs
 */
Sebastian Hack's avatar
Sebastian Hack committed
173
174
175
176
177
178
enum {
	be_pos_AddSP_old_sp = 0,
	be_pos_AddSP_size   = 1,
	be_pos_AddSP_last   = 2
};

Sebastian Hack's avatar
Sebastian Hack committed
179
enum {
180
181
182
183
	pn_be_AddSP_sp   = 0,
	pn_be_AddSP_res  = 1,
	pn_be_AddSP_M    = 2,
	pn_be_AddSP_last = 3
Sebastian Hack's avatar
Sebastian Hack committed
184
185
};

Sebastian Hack's avatar
Sebastian Hack committed
186
187
188
189
190
191
192
193
194
195
196
197
198
/**
 * Make a new AddSP node.
 * An AddSP node expresses an increase of the stack pointer in the direction the stack
 * grows. In contrast to IncSP, the amount of bytes the stack pointer is grown, is not
 * given by a constant but an ordinary Firm node.
 * @param sp     The stack pointer register.
 * @param irg    The graph.
 * @param bl     The block.
 * @param old_sp The node representing the old stack pointer value.
 * @param sz     The node expressing the size by which the stack pointer shall be grown.
 * @return       A new AddSP node.
 */
ir_node *be_new_AddSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, ir_node *sz);
Sebastian Hack's avatar
Sebastian Hack committed
199

Michael Beck's avatar
Michael Beck committed
200
201
202
203
204
205
206
207
208
209
/**
 * Position numbers for the be_SubSP inputs
 */
enum {
	be_pos_SubSP_old_sp = 0,
	be_pos_SubSP_size   = 1,
	be_pos_SubSP_last   = 2
};

enum {
210
	pn_be_SubSP_sp   = 0,
Michael Beck's avatar
Michael Beck committed
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
	pn_be_SubSP_M    = 1,
	pn_be_SubSP_last = 2
};

/**
 * Make a new SubSP node.
 * A SubSP node expresses a decrease of the stack pointer in the direction the stack
 * grows. In contrast to IncSP, the amount of bytes the stack pointer is grown, is not
 * given by a constant but an ordinary Firm node.
 * @param sp     The stack pointer register.
 * @param irg    The graph.
 * @param bl     The block.
 * @param old_sp The node representing the old stack pointer value.
 * @param sz     The node expressing the size by which the stack pointer shall be grown.
 * @return       A new DecSP node.
 */
ir_node *be_new_SubSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, ir_node *sz);

Sebastian Hack's avatar
Sebastian Hack committed
229
230
/**
 * Make a stack pointer increase/decrease node.
Sebastian Hack's avatar
Sebastian Hack committed
231
 * @param sp     The stack pointer register.
Sebastian Hack's avatar
Sebastian Hack committed
232
233
234
 * @param irg    The graph to insert the node to.
 * @param bl     The block to insert the node into.
 * @param old_sp The node defining the former stack pointer.
235
 * @param amount The mount of bytes the stack shall be expanded/shrinked (see set_IncSP_offset)
Sebastian Hack's avatar
Sebastian Hack committed
236
237
238
239
240
 * @param dir    The direction in which the stack pointer shall be modified:
 *               Along the stack's growing direction or against.
 * @return       A new stack pointer increment/decrement node.
 * @note         This node sets a register constraint to the @p sp register on its output.
 */
241
242
ir_node *be_new_IncSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl,
                      ir_node *old_sp, int offset, int align);
Sebastian Hack's avatar
Sebastian Hack committed
243

Michael Beck's avatar
BugFix:    
Michael Beck committed
244
245
/** Returns the previous node that computes the stack pointer. */
ir_node *be_get_IncSP_pred(ir_node *incsp);
Sebastian Hack's avatar
Sebastian Hack committed
246

247
/** Sets the previous node that computes the stack pointer. */
248
void     be_set_IncSP_pred(ir_node *incsp, ir_node *pred);
249

250
251
252
253
254
255
256
/**
 * Sets a new offset to a IncSP node.
 * A positive offset means expanding the stack, a negative offset shrinking
 * an offset is == BE_STACK_FRAME_SIZE will be replaced by the real size of the
 * stackframe in the fix_stack_offsets phase.
 */
void     be_set_IncSP_offset(ir_node *irn, int offset);
Michael Beck's avatar
BugFix:    
Michael Beck committed
257
258

/** Gets the offset from a IncSP node. */
259
int be_get_IncSP_offset(const ir_node *irn);
260
int be_get_IncSP_align(const ir_node *irn);
Sebastian Hack's avatar
Sebastian Hack committed
261

262
/** Gets the call entity or NULL if this is no static call. */
263
ir_entity  *be_Call_get_entity(const ir_node *call);
264
/** Sets the call entity. */
265
void     be_Call_set_entity(ir_node *call, ir_entity *ent);
266
267
268
269
/** Gets the call type. */
ir_type *be_Call_get_type(ir_node *call);
/** Sets the call type. */
void     be_Call_set_type(ir_node *call, ir_type *call_tp);
270

Matthias Braun's avatar
Matthias Braun committed
271
272
273
274
void     be_Call_set_pop(ir_node *call, unsigned pop);

unsigned be_Call_get_pop(const ir_node *call);

275
276
277
/**
 * Position numbers for the be_Call inputs.
 */
278
enum {
279
280
281
282
	be_pos_Call_mem       = 0,  /**< memory input of a be_Call node */
	be_pos_Call_sp        = 1,  /**< stack pointer input of a be_Call node */
	be_pos_Call_ptr       = 2,  /**< call pointer input of a be_Call node */
	be_pos_Call_first_arg = 3   /**< first argument input of a be_Call node */
283
284
};

285
286
287
288
289
/**
 * Projection numbers for result of be_Call node: use for Proj nodes!
 */
typedef enum {
	pn_be_Call_M_regular = pn_Call_M_regular,  /**< The memory result of a be_Call. */
Matthias Braun's avatar
Matthias Braun committed
290
291
	pn_be_Call_sp        = pn_Call_max,
	pn_be_Call_first_res                      /**< The first result proj number of a be_Call. */
292
293
294
} pn_be_Call;

/**
Michael Beck's avatar
Michael Beck committed
295
296
297
298
299
300
301
302
303
304
305
306
 * Construct a new be_Call.
 *
 * @param dbg      debug info
 * @param irg      the graph where the call is placed
 * @param bl       the block where the call is placed
 * @param mem      the memory input of the call
 * @param sp       the stack pointer input of the call
 * @param ptr      the address of the called function, if immediate call set to sp
 * @param n_outs   the number of outcoming values from this call
 * @param n        the number of (register) inputs of this call
 * @param in       the (register) inputs of this call
 * @param call_tp  the call type of this call
307
308
309
310
311
 */
ir_node *be_new_Call(dbg_info *dbg, ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *sp, ir_node *ptr,
                     int n_outs, int n, ir_node *in[], ir_type *call_tp);

/**
312
313
314
315
316
317
318
319
320
321
 * Position numbers for the be_Return inputs.
 */
enum {
	be_pos_Return_mem  = 0,     /**< memory input of a be_Return node */
	be_pos_Return_sp   = 1,     /**< stack pointer input of a be_Return node */
	be_pos_Return_val  = 2,     /**< first "real" return value if any */
};

/**
 * Construct a new be_Return.
Michael Beck's avatar
Michael Beck committed
322
323
 *
 * @param dbg    debug info
324
325
326
327
 * @param irg    the graph where the new node will be placed
 * @param bl     the block where the new node will be placed
 * @param n_res  number of "real" results
 * @param n      number of inputs
328
 * @param pop    pop number of bytes on return
329
330
 * @param in     input array
 */
331
ir_node *be_new_Return(dbg_info *dbg, ir_graph *irg, ir_node *bl, int n_res, unsigned pop, int n, ir_node *in[]);
332
333

/** Returns the number of real returns values */
334
335
int be_Return_get_n_rets(const ir_node *ret);

Michael Beck's avatar
Michael Beck committed
336
337
338
339
340
/**
 * Return the number of bytes that should be popped from stack when executing the Return.
 *
 * @param ret  the be_Return node
 */
341
unsigned be_Return_get_pop(const ir_node *ret);
342

343
344
345
346
347
348
349
350
351
352
353
354
355
356
/**
 * Return non-zero, if number of popped bytes must be always emitted.
 *
 * @param ret  the be_Return node
 */
int be_Return_get_emit_pop(const ir_node *ret);

/**
 * Set the emit_pop flag.
 *
 * @param ret  the be_Return node
 */
void be_Return_set_emit_pop(ir_node *ret, int emit_pop);

357
358
359
/** appends a node to the return node, returns the position of the node */
int be_Return_append_node(ir_node *ret, ir_node *node);

Sebastian Hack's avatar
Sebastian Hack committed
360
ir_node *be_new_RegParams(ir_graph *irg, ir_node *bl, int n_out);
Sebastian Hack's avatar
Sebastian Hack committed
361

362
ir_node *be_new_Barrier(ir_graph *irg, ir_node *bl, int n, ir_node *in[]);
Sebastian Hack's avatar
Sebastian Hack committed
363

364
365
366
367
368
/**
 * Appends a node to a barrier, returns the result proj of the node
 */
ir_node *be_Barrier_append_node(ir_node *barrier, ir_node *node);

Sebastian Hack's avatar
Sebastian Hack committed
369
/**
370
 * Make a spill node.
Sebastian Hack's avatar
Sebastian Hack committed
371
372
373
374
375
 *
 * @param irn       The node to be spilled.
 * @param spill_ctx The context in which the spill is introduced (This is mostly == irn up to the case of Phis).
 * @return          The new spill node.
 */
376
ir_node *be_spill(ir_node *block, ir_node *irn);
Sebastian Hack's avatar
Sebastian Hack committed
377
378
379
380
381
382
383
384
385
386

/**
 * Make a reload and insert it into the schedule.
 *
 * @param cls      The register class of the reloaded value.
 * @param insert   The node in the schedule in front of which the reload is inserted.
 * @param mode     The mode of the original (spilled) value.
 * @param spill    The spill node corresponding to this reload.
 * @return         A freshly made reload.
 */
387
ir_node *be_reload(const arch_register_class_t *cls, ir_node *insert, ir_mode *mode, ir_node *spill);
Sebastian Hack's avatar
Sebastian Hack committed
388

Sebastian Hack's avatar
Sebastian Hack committed
389
390
391
enum {
	be_pos_CopyKeep_op = 0
};
Sebastian Hack's avatar
Sebastian Hack committed
392
393
ir_node *be_new_CopyKeep(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, ir_node *src, int n, ir_node *in_keep[], ir_mode *mode);
ir_node *be_new_CopyKeep_single(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, ir_node *src, ir_node *keep, ir_mode *mode);
394
395
ir_node *be_get_CopyKeep_op(const ir_node *cpy);
void be_set_CopyKeep_op(ir_node *cpy, ir_node *op);
Sebastian Hack's avatar
Sebastian Hack committed
396

Michael Beck's avatar
Michael Beck committed
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
/**
 * Position numbers for the be_Unwind inputs.
 */
enum {
	be_pos_Unwind_mem  = 0,     /**< memory input of a be_Unwind node */
	be_pos_Unwind_sp   = 1,     /**< stack pointer input of a be_Unwind node */
};

/**
 * Construct a new be_Unwind.
 *
 * @param dbg    debug info
 * @param irg    the graph where the new node will be placed
 * @param bl     the block where the new node will be placed
 * @param mem    the memory input
 * @param sp     the stack pointer input
 */
ir_node *be_new_Unwind(dbg_info *dbg, ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *sp);

ir_node *be_get_Unwind_mem(const ir_node *irn);
ir_node *be_get_Unwind_sp(const ir_node *irn);

Sebastian Hack's avatar
Sebastian Hack committed
419
420
421
422
423
/**
 * Get the backend opcode of a backend node.
 * @param irn The node.
 * @return The backend opcode.
 */
424
#define be_get_irn_opcode(irn)	get_irn_opcode(irn)
Sebastian Hack's avatar
Sebastian Hack committed
425

426
/**
Michael Beck's avatar
Michael Beck committed
427
 * Returns the frame entity of a be node.
428
 * Try to avoid this function and better call arch_get_frame_entity!
429
 *
Michael Beck's avatar
Michael Beck committed
430
 * @return the frame entity used by the be node
431
 */
432
433
434
435
436
437
ir_entity *be_get_frame_entity(const ir_node *irn);

/**
 * Returns the frame offset of this node.
 */
int be_get_frame_offset(const ir_node *irn);
438
439

ir_node* be_get_Reload_mem(const ir_node *irn);
440
ir_node *be_get_Reload_frame(const ir_node *irn);
441
ir_node* be_get_Spill_val(const ir_node *irn);
442
ir_node *be_get_Spill_frame(const ir_node *irn);
443

444
445
void be_set_MemPerm_in_entity(const ir_node *irn, int n, ir_entity* ent);
ir_entity *be_get_MemPerm_in_entity(const ir_node *irn, int n);
Matthias Braun's avatar
Matthias Braun committed
446

447
448
void be_set_MemPerm_out_entity(const ir_node *irn, int n, ir_entity* ent);
ir_entity *be_get_MemPerm_out_entity(const ir_node *irn, int n);
449

450
451
int be_get_MemPerm_entity_arity(const ir_node *irn);

Sebastian Hack's avatar
Sebastian Hack committed
452
453
454
/**
 * Impose a register constraint on a backend node.
 * @param irn The node.
455
 * @param pos The position of the argument.
Sebastian Hack's avatar
Sebastian Hack committed
456
457
 * @param reg The register which is admissible for that node, argument/result and position.
 */
458
459
460
461
void be_set_constr_single_reg_in(ir_node *irn, int pos,
		const arch_register_t *reg, arch_register_req_type_t additional_flags);
void be_set_constr_single_reg_out(ir_node *irn, int pos,
		const arch_register_t *reg, arch_register_req_type_t additional_flags);
462

463
/**
464
465
466
467
468
469
 * Impose register constraints on a backend node.
 * The register subsets given by the limited function in @p req are copied to the backend node.
 * This requires that the constraint type of the @p req is arch_register_req_type_limited.
 * @param irn The backend node.
 * @param pos The position (@see be_set_constr_single_reg()).
 * @param req The register requirements which shall be transferred.
470
 */
471
void be_set_constr_limited(ir_node *irn, int pos, const arch_register_req_t *req);
472

Sebastian Hack's avatar
Sebastian Hack committed
473
474
475
/**
 * Set the register class of a node.
 * @param irn The node itself.
476
 * @param pos The position (0..n) for arguments
Sebastian Hack's avatar
Sebastian Hack committed
477
478
 * @param flags The register class to set for that node and position.
 */
479
480
void be_node_set_reg_class_in(ir_node *irn, int pos, const arch_register_class_t *cls);
void be_node_set_reg_class_out(ir_node *irn, int pos, const arch_register_class_t *cls);
Sebastian Hack's avatar
Sebastian Hack committed
481

Christian Würdig's avatar
Christian Würdig committed
482
483
484
485
486
487
488
489
/**
 * Set the register requirement type of a node.
 * @param irn The node itself.
 * @param pos The position (0..n) for arguments, (-1..-m) for results.
 * @param flags The register requirement type to set for that node and position.
 */
void be_node_set_req_type(ir_node *irn, int pos, arch_register_req_type_t type);

490
/**
491
 * Initialize the Phi handler.
492
 */
493
void be_phi_handler_new(void);
Sebastian Hack's avatar
Sebastian Hack committed
494

Sebastian Hack's avatar
Sebastian Hack committed
495
/**
496
 * Destroy the Phi handler.
Sebastian Hack's avatar
Sebastian Hack committed
497
 */
Matthias Braun's avatar
Matthias Braun committed
498
void be_phi_handler_free(void);
Sebastian Hack's avatar
Sebastian Hack committed
499
500

/**
501
 * Reset the register data in the Phi handler.
Sebastian Hack's avatar
Sebastian Hack committed
502
503
 * This should be called on each new graph and deletes the register information of the current graph.
 */
Matthias Braun's avatar
Matthias Braun committed
504
void be_phi_handler_reset(void);
Sebastian Hack's avatar
Sebastian Hack committed
505

506
507
508
/**
 * Set the register requirements for a phi node.
 */
509
510
void be_set_phi_reg_req(ir_node *phi, const arch_register_req_t *req,
		arch_register_req_type_t additional_types);
511

Sebastian Hack's avatar
Sebastian Hack committed
512
/**
Michael Beck's avatar
Michael Beck committed
513
 * irn handler for common be nodes and Phi's.
Sebastian Hack's avatar
Sebastian Hack committed
514
 */
515
const void *be_node_get_irn_ops(const ir_node *irn);
Sebastian Hack's avatar
Sebastian Hack committed
516

517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
static inline int be_is_Spill    (const ir_node *irn) { return get_irn_opcode(irn) == beo_Spill    ; }
static inline int be_is_Reload   (const ir_node *irn) { return get_irn_opcode(irn) == beo_Reload   ; }
static inline int be_is_Copy     (const ir_node *irn) { return get_irn_opcode(irn) == beo_Copy     ; }
static inline int be_is_CopyKeep (const ir_node *irn) { return get_irn_opcode(irn) == beo_CopyKeep ; }
static inline int be_is_Perm     (const ir_node *irn) { return get_irn_opcode(irn) == beo_Perm     ; }
static inline int be_is_MemPerm  (const ir_node *irn) { return get_irn_opcode(irn) == beo_MemPerm  ; }
static inline int be_is_Keep     (const ir_node *irn) { return get_irn_opcode(irn) == beo_Keep     ; }
static inline int be_is_Call     (const ir_node *irn) { return get_irn_opcode(irn) == beo_Call     ; }
static inline int be_is_Return   (const ir_node *irn) { return get_irn_opcode(irn) == beo_Return   ; }
static inline int be_is_IncSP    (const ir_node *irn) { return get_irn_opcode(irn) == beo_IncSP    ; }
static inline int be_is_AddSP    (const ir_node *irn) { return get_irn_opcode(irn) == beo_AddSP    ; }
static inline int be_is_SubSP    (const ir_node *irn) { return get_irn_opcode(irn) == beo_SubSP    ; }
static inline int be_is_RegParams(const ir_node *irn) { return get_irn_opcode(irn) == beo_RegParams; }
static inline int be_is_FrameAddr(const ir_node *irn) { return get_irn_opcode(irn) == beo_FrameAddr; }
static inline int be_is_Barrier  (const ir_node *irn) { return get_irn_opcode(irn) == beo_Barrier  ; }
static inline int be_is_Unwind   (const ir_node *irn) { return get_irn_opcode(irn) == beo_Unwind   ; }
533

Christian Würdig's avatar
Christian Würdig committed
534
#endif /* FIRM_BE_BENODE_T_H */