irop.h 11.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-2011 University of Karlsruhe.  All right reserved.
Christian Würdig's avatar
Christian Würdig committed
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 *
 * This file is part of libFirm.
 *
 * This file may be distributed and/or modified under the terms of the
 * GNU General Public License version 2 as published by the Free Software
 * Foundation and appearing in the file LICENSE.GPL included in the
 * packaging of this file.
 *
 * Licensees holding valid libFirm Professional Edition licenses may use
 * this file in accordance with the libFirm Commercial License.
 * Agreement provided with the Software.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE.
 */

Michael Beck's avatar
Michael Beck committed
20
/**
Matthias Braun's avatar
Matthias Braun committed
21
22
 * @file
 * @brief   Representation of opcode of intermediate operation.
Michael Beck's avatar
Michael Beck committed
23
 * @author  Christian Schaefer, Goetz Lindenmaier, Michael Beck
yb9976's avatar
yb9976 committed
24
 * @brief
Matthias Braun's avatar
Matthias Braun committed
25
 *  Operators of firm nodes.
Götz Lindenmaier's avatar
Götz Lindenmaier committed
26
27
28
29
30
 *
 *  This module specifies the opcodes possible for ir nodes.  Their
 *  definition is close to the operations specified in UKA Tech-Report
 *  1999-14
 */
Matthias Braun's avatar
Matthias Braun committed
31
32
#ifndef FIRM_IR_IROP_H
#define FIRM_IR_IROP_H
Christian Schäfer's avatar
Christian Schäfer committed
33

Michael Beck's avatar
Michael Beck committed
34
#include <stdio.h>
35
#include "firm_types.h"
Michael Beck's avatar
Michael Beck committed
36
#include "ident.h"
37
#include "begin.h"
38
#include "opcodes.h"
Christian Schäfer's avatar
Christian Schäfer committed
39

40
/** The allowed arities. */
41
typedef enum {
Michael Beck's avatar
Michael Beck committed
42
	oparity_invalid = 0,
43
44
45
46
47
	oparity_unary,              /**< An unary operator -- considering 'numeric' arguments. */
	oparity_binary,             /**< A binary operator  -- considering 'numeric' arguments.*/
	oparity_trinary,            /**< A trinary operator  -- considering 'numeric' arguments.*/
	oparity_zero,               /**< A zero arity operator, e.g. a Const. */
	oparity_variable,           /**< The arity is not fixed by opcode, but statically
Michael Beck's avatar
Michael Beck committed
48
	                                 known.  E.g., number of arguments to call. */
49
50
	oparity_dynamic,            /**< The arity depends on state of Firm representation.
	                                 Can be changed by optimizations...
Michael Beck's avatar
Michael Beck committed
51
	                                 We must allocate a dynamic in array for the node! */
52
	oparity_any                 /**< Any other arity. */
53
54
55
56
57
} op_arity;


/** The irop flags */
typedef enum {
58
59
60
61
	irop_flag_none         = 0, /**< Nothing. */
	irop_flag_labeled      = 1U << 0, /**< If set, output edge labels on in-edges in vcg graph. */
	irop_flag_commutative  = 1U << 1, /**< This operation is commutative. */
	irop_flag_cfopcode     = 1U << 2, /**< This operation is a control flow operation. */
Matthias Braun's avatar
Matthias Braun committed
62
63
64
	irop_flag_fragile      = 1U << 3, /**< Set if the operation can change the
	                                       control flow because of an exception.
	                                   */
65
66
67
68
69
70
71
72
73
74
75
	irop_flag_forking      = 1U << 4, /**< Forking control flow at this operation. */
	irop_flag_highlevel    = 1U << 5, /**< This operation is a pure high-level one and can be
	                                      skipped in low-level optimizations. */
	irop_flag_constlike    = 1U << 6, /**< This operation has no arguments and is some
	                                       kind of a constant. */
	irop_flag_always_opt   = 1U << 7, /**< This operation must always be optimized .*/
	irop_flag_keep         = 1U << 8, /**< This operation can be kept in End's keep-alive list. */
	irop_flag_start_block  = 1U << 9, /**< This operation is always placed in the Start block. */
	irop_flag_uses_memory  = 1U << 10, /**< This operation has a memory input and may change the memory state. */
	irop_flag_dump_noblock = 1U << 11, /**< node should be dumped outside any blocks */
	irop_flag_dump_noinput = 1U << 12, /**< node is a placeholder for "no input" */
76
	irop_flag_cse_neutral  = 1U << 13, /**< This operation is CSE neutral to its users. */
77
78
79
	/** This operation jumps to an unknown destination. The CFG is a
	 * conservative aproximation in this case. You cannot change the destination
	 * of an unknown_jump */
80
	irop_flag_unknown_jump = 1U << 14,
81
82
} irop_flags;

Michael Beck's avatar
Michael Beck committed
83
/** Returns the ident for the opcode name */
Michael Beck's avatar
Michael Beck committed
84
FIRM_API ident *get_op_ident(const ir_op *op);
Michael Beck's avatar
Michael Beck committed
85

Michael Beck's avatar
Michael Beck committed
86
/** Returns the string for the opcode. */
Michael Beck's avatar
Michael Beck committed
87
FIRM_API const char *get_op_name(const ir_op *op);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
88

Michael Beck's avatar
Michael Beck committed
89
/** Returns the enum for the opcode */
Michael Beck's avatar
Michael Beck committed
90
FIRM_API unsigned get_op_code(const ir_op *op);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
91

92
/** Returns a human readable name of an op_pin_state. */
Michael Beck's avatar
Michael Beck committed
93
FIRM_API const char *get_op_pin_state_name(op_pin_state s);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
94

95
/** Gets pinned state of an opcode. */
Michael Beck's avatar
Michael Beck committed
96
FIRM_API op_pin_state get_op_pinned(const ir_op *op);
Michael Beck's avatar
Michael Beck committed
97
98

/** Sets pinned in the opcode.  Setting it to floating has no effect
Michael Beck's avatar
Michael Beck committed
99
    for Block, Phi and control flow nodes. */
Michael Beck's avatar
Michael Beck committed
100
FIRM_API void set_op_pinned(ir_op *op, op_pin_state pinned);
101

102
/** Returns the next free IR opcode number, allows to register user ops. */
Michael Beck's avatar
Michael Beck committed
103
FIRM_API unsigned get_next_ir_opcode(void);
Michael Beck's avatar
Michael Beck committed
104

105
/** Returns the next free n IR opcode number, allows to register a bunch of user ops. */
Michael Beck's avatar
Michael Beck committed
106
FIRM_API unsigned get_next_ir_opcodes(unsigned num);
107

108
/**
109
 * A generic function pointer type.
110
111
112
113
114
115
116
 */
typedef void (*op_func)(void);

/** The NULL-function. */
#define NULL_FUNC       ((generic_func)(NULL))

/**
117
 * Returns the generic function pointer from an IR operation.
118
 */
Michael Beck's avatar
Michael Beck committed
119
FIRM_API op_func get_generic_function_ptr(const ir_op *op);
120
121

/**
122
 * Store a generic function pointer into an IR operation.
123
 */
Michael Beck's avatar
Michael Beck committed
124
FIRM_API void set_generic_function_ptr(ir_op *op, op_func func);
125

126
127
128
/**
 * Return the irop flags of an IR opcode.
 */
Michael Beck's avatar
Michael Beck committed
129
FIRM_API irop_flags get_op_flags(const ir_op *op);
130

131
132
133
134
135
136
/**
 * The hash operation.
 * This operation calculates a hash value for a given IR node.
 */
typedef unsigned (*hash_func)(const ir_node *self);

Michael Beck's avatar
Michael Beck committed
137
138
139
140
141
/**
 * The compute value operation.
 * This operation evaluates an IR node into a tarval if possible,
 * returning tarval_bad otherwise.
 */
Matthias Braun's avatar
Matthias Braun committed
142
typedef ir_tarval *(*computed_value_func)(const ir_node *self);
Michael Beck's avatar
Michael Beck committed
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

/**
 * The equivalent node operation.
 * This operation returns an equivalent node for the input node.
 * It does not create new nodes.  It is therefore safe to free self
 * if the node returned is not self.
 * If a node returns a Tuple we can not just skip it.  If the size of the
 * in array fits, we transform n into a tuple (e.g., possible for Div).
 */
typedef ir_node *(*equivalent_node_func)(ir_node *self);

/**
 * The transform node operation.
 * This operation tries several [inplace] [optimizing] transformations
 * and returns an equivalent node.
 * The difference to equivalent_node() is that these
 * transformations _do_ generate new nodes, and thus the old node must
 * not be freed even if the equivalent node isn't the old one.
 */
typedef ir_node *(*transform_node_func)(ir_node *self);

/**
 * The node attribute compare operation.
 * Compares the nodes attributes of two nodes of identical opcode
 * and returns 0 if the attributes are identical, 1 if they differ.
 */
Michael Beck's avatar
Michael Beck committed
169
typedef int (*node_cmp_attr_func)(const ir_node *a, const ir_node *b);
Michael Beck's avatar
Michael Beck committed
170
171
172
173
174
175
176
177
178
179
180
181

/**
 * The reassociation operation.
 * Called from a walker.  Returns non-zero if
 * a reassociation rule was applied.
 * The pointer n is set to the newly created node, if some reassociation
 * was applied.
 */
typedef int (*reassociate_func)(ir_node **n);

/**
 * The copy attribute operation.
182
 * Copy the node attributes from an 'old' node to a 'new' one.
Michael Beck's avatar
Michael Beck committed
183
 */
184
typedef void (*copy_attr_func)(ir_graph *irg, const ir_node *old_node, ir_node *new_node);
Michael Beck's avatar
Michael Beck committed
185

Michael Beck's avatar
Michael Beck committed
186
187
188
189
190
/**
 * The get_type_attr operation. Used to traverse all types that can be
 * accessed from an ir_graph.
 * Return the type attribute of the node self.
 */
191
typedef ir_type *(*get_type_attr_func)(const ir_node *self);
Michael Beck's avatar
Michael Beck committed
192
193
194
195
196
197

/**
 * The get_entity_attr operation. Used to traverse all entities that can be
 * accessed from an ir_graph.
 * Return the entity attribute of the node self.
 */
198
typedef ir_entity *(*get_entity_attr_func)(const ir_node *self);
Michael Beck's avatar
Michael Beck committed
199
200
201
202
203
204
205
206

/**
 * The verify_node operation.
 * Return non-zero if the node verification is ok, else 0.
 * Depending on the node verification settings, may even assert.
 *
 * @see do_node_verification()
 */
207
typedef int (*verify_node_func)(const ir_node *node);
Michael Beck's avatar
Michael Beck committed
208
209
210
211
212
213
214
215

/**
 * The verify_node operation for Proj(X).
 * Return non-zero if the node verification is ok, else 0.
 * Depending on the node verification settings, may even assert.
 *
 * @see do_node_verification()
 */
216
typedef int (*verify_proj_node_func)(const ir_node *proj);
Michael Beck's avatar
Michael Beck committed
217

Michael Beck's avatar
Michael Beck committed
218
219
220
221
/**
 * Reasons to call the dump_node operation:
 */
typedef enum {
222
223
224
225
	dump_node_opcode_txt,   /**< Dump the opcode. */
	dump_node_mode_txt,     /**< Dump the mode. */
	dump_node_nodeattr_txt, /**< Dump node attributes to be shown in the label. */
	dump_node_info_txt      /**< Dump node attributes into info1. */
Michael Beck's avatar
Michael Beck committed
226
227
228
229
230
231
232
} dump_reason_t;

/**
 * The dump_node operation.
 * Writes several informations requested by reason to
 * an output file
 */
233
typedef void (*dump_node_func)(FILE *out, const ir_node *self, dump_reason_t reason);
Michael Beck's avatar
Michael Beck committed
234

Michael Beck's avatar
Michael Beck committed
235
236
237
238
/**
 * io_op Operations.
 */
typedef struct {
Michael Beck's avatar
Michael Beck committed
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
	hash_func             hash;                 /**< Calculate a hash value for an IR node. */
	computed_value_func   computed_value;       /**< Evaluates a node into a tarval if possible. */
	computed_value_func   computed_value_Proj;  /**< Evaluates a Proj node into a tarval if possible. */
	equivalent_node_func  equivalent_node;      /**< Optimizes the node by returning an equivalent one. */
	equivalent_node_func  equivalent_node_Proj; /**< Optimizes the Proj node by returning an equivalent one. */
	transform_node_func   transform_node;       /**< Optimizes the node by transforming it. */
	equivalent_node_func  transform_node_Proj;  /**< Optimizes the Proj node by transforming it. */
	node_cmp_attr_func    node_cmp_attr;        /**< Compares two node attributes. */
	reassociate_func      reassociate;          /**< Reassociate a tree. */
	copy_attr_func        copy_attr;            /**< Copy node attributes. */
	get_type_attr_func    get_type_attr;        /**< Return the type attribute of a node. */
	get_entity_attr_func  get_entity_attr;      /**< Return the entity attribute of a node. */
	verify_node_func      verify_node;          /**< Verify the node. */
	verify_proj_node_func verify_proj_node;     /**< Verify the Proj node. */
	dump_node_func        dump_node;            /**< Dump a node. */
	op_func               generic;              /**< A generic function pointer. */
	const arch_irn_ops_t *be_ops;               /**< callbacks used by the backend. */
Michael Beck's avatar
Michael Beck committed
256
257
258
} ir_op_ops;

/**
259
 * Creates a new IR operation.
Michael Beck's avatar
Michael Beck committed
260
261
262
263
 *
 * @param code      the opcode, one of type \c opcode
 * @param name      the printable name of this opcode
 * @param p         whether operations of this opcode are op_pin_state_pinned or floating
264
265
 * @param flags     a bitmask of irop_flags describing the behavior of the IR operation
 * @param opar      the parity of this IR operation
Michael Beck's avatar
Michael Beck committed
266
267
268
 * @param op_index  if the parity is oparity_unary, oparity_binary or oparity_trinary the index
 *                  of the left operand
 * @param ops       operations for this opcode, iff NULL default operations are used
269
 * @param attr_size attribute size for this IR operation
Michael Beck's avatar
Michael Beck committed
270
 *
271
 * @return The generated IR operation.
Michael Beck's avatar
Michael Beck committed
272
273
274
275
 *
 * This function can create all standard Firm opcode as well as new ones.
 * The behavior of new opcode depends on the operations \c ops and the \c flags.
 */
Michael Beck's avatar
Michael Beck committed
276
FIRM_API ir_op *new_ir_op(unsigned code, const char *name, op_pin_state p,
277
278
                          unsigned flags, op_arity opar, int op_index,
                          size_t attr_size, const ir_op_ops *ops);
Michael Beck's avatar
Michael Beck committed
279

280
281
282
283
284
/**
 * set memory input of operation using memory
 */
FIRM_API void ir_op_set_memory_index(ir_op *op, int memory_index);

Matthias Braun's avatar
Matthias Braun committed
285
286
287
288
/**
 * Set proj-number for X_regular and X_except projs of fragile nodes.
 * Note: should only be used immediately after new_ir_op
 */
289
290
FIRM_API void ir_op_set_fragile_indices(ir_op *op, int pn_x_regular,
                                        int pn_x_except);
Matthias Braun's avatar
Matthias Braun committed
291

Michael Beck's avatar
Michael Beck committed
292
/** Returns the ir_op_ops of an ir_op. */
Michael Beck's avatar
Michael Beck committed
293
FIRM_API const ir_op_ops *get_op_ops(const ir_op *op);
294
295

#include "end.h"
Michael Beck's avatar
Michael Beck committed
296

Matthias Braun's avatar
Matthias Braun committed
297
#endif