irop.c 23.3 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.
 */

Matthias Braun's avatar
Matthias Braun committed
20
21
22
23
24
/**
 * @file
 * @brief   Representation of opcode of intermediate operation.
 * @author  Christian Schaefer, Goetz Lindenmaier, Michael Beck
 * @version $Id$
Götz Lindenmaier's avatar
Götz Lindenmaier committed
25
 */
Matthias Braun's avatar
Matthias Braun committed
26
#include "config.h"
Boris Boesler's avatar
added    
Boris Boesler committed
27

28
#include <string.h>
29

Michael Beck's avatar
Michael Beck committed
30
31
32
#include "irop_t.h"
#include "irnode_t.h"
#include "irhooks.h"
33
#include "irbackedge_t.h"
34

Michael Beck's avatar
Michael Beck committed
35
36
37
#include "iropt_t.h"             /* for firm_set_default_operations */
#include "irvrfy_t.h"
#include "reassoc_t.h"
Florian Liekweg's avatar
Florian Liekweg committed
38

Michael Beck's avatar
Michael Beck committed
39
#include "xmalloc.h"
Christian Schäfer's avatar
Christian Schäfer committed
40

Michael Beck's avatar
Michael Beck committed
41
42
43
/** the available next opcode */
static unsigned next_iro = iro_MaxOpcode;

Michael Beck's avatar
Michael Beck committed
44
ir_op *op_Block;       ir_op *get_op_Block     (void) { return op_Block;     }
45

Florian Liekweg's avatar
Florian Liekweg committed
46
47
48
ir_op *op_Start;       ir_op *get_op_Start     (void) { return op_Start;     }
ir_op *op_End;         ir_op *get_op_End       (void) { return op_End;       }
ir_op *op_Jmp;         ir_op *get_op_Jmp       (void) { return op_Jmp;       }
49
ir_op *op_IJmp;        ir_op *get_op_IJmp      (void) { return op_IJmp;      }
Florian Liekweg's avatar
Florian Liekweg committed
50
51
52
53
54
55
56
57
58
59
ir_op *op_Cond;        ir_op *get_op_Cond      (void) { return op_Cond;      }
ir_op *op_Return;      ir_op *get_op_Return    (void) { return op_Return;    }

ir_op *op_Sel;         ir_op *get_op_Sel       (void) { return op_Sel;       }
ir_op *op_InstOf;      ir_op *get_op_InstOf    (void) { return op_InstOf;    }

ir_op *op_Const;       ir_op *get_op_Const     (void) { return op_Const;     }
ir_op *op_SymConst;    ir_op *get_op_SymConst  (void) { return op_SymConst;  }

ir_op *op_Call;        ir_op *get_op_Call      (void) { return op_Call;      }
60
ir_op *op_Builtin;     ir_op *get_op_Builtin   (void) { return op_Builtin;   }
Florian Liekweg's avatar
Florian Liekweg committed
61
62
63
64
ir_op *op_Add;         ir_op *get_op_Add       (void) { return op_Add;       }
ir_op *op_Sub;         ir_op *get_op_Sub       (void) { return op_Sub;       }
ir_op *op_Minus;       ir_op *get_op_Minus     (void) { return op_Minus;     }
ir_op *op_Mul;         ir_op *get_op_Mul       (void) { return op_Mul;       }
Michael Beck's avatar
Michael Beck committed
65
ir_op *op_Mulh;        ir_op *get_op_Mulh      (void) { return op_Mulh;      }
Florian Liekweg's avatar
Florian Liekweg committed
66
67
68
69
70
71
72
73
74
75
76
77
78
ir_op *op_Quot;        ir_op *get_op_Quot      (void) { return op_Quot;      }
ir_op *op_DivMod;      ir_op *get_op_DivMod    (void) { return op_DivMod;    }
ir_op *op_Div;         ir_op *get_op_Div       (void) { return op_Div;       }
ir_op *op_Mod;         ir_op *get_op_Mod       (void) { return op_Mod;       }
ir_op *op_Abs;         ir_op *get_op_Abs       (void) { return op_Abs;       }
ir_op *op_And;         ir_op *get_op_And       (void) { return op_And;       }
ir_op *op_Or;          ir_op *get_op_Or        (void) { return op_Or;        }
ir_op *op_Eor;         ir_op *get_op_Eor       (void) { return op_Eor;       }
ir_op *op_Not;         ir_op *get_op_Not       (void) { return op_Not;       }
ir_op *op_Cmp;         ir_op *get_op_Cmp       (void) { return op_Cmp;       }
ir_op *op_Shl;         ir_op *get_op_Shl       (void) { return op_Shl;       }
ir_op *op_Shr;         ir_op *get_op_Shr       (void) { return op_Shr;       }
ir_op *op_Shrs;        ir_op *get_op_Shrs      (void) { return op_Shrs;      }
79
ir_op *op_Rotl;        ir_op *get_op_Rotl      (void) { return op_Rotl;      }
Florian Liekweg's avatar
Florian Liekweg committed
80
ir_op *op_Conv;        ir_op *get_op_Conv      (void) { return op_Conv;      }
Michael Beck's avatar
Michael Beck committed
81
ir_op *op_Cast;        ir_op *get_op_Cast      (void) { return op_Cast;      }
Michael Beck's avatar
Michael Beck committed
82
83
ir_op *op_Carry;       ir_op *get_op_Carry     (void) { return op_Carry;     }
ir_op *op_Borrow;      ir_op *get_op_Borrow    (void) { return op_Borrow;    }
84

Florian Liekweg's avatar
Florian Liekweg committed
85
ir_op *op_Phi;         ir_op *get_op_Phi       (void) { return op_Phi;       }
86

Florian Liekweg's avatar
Florian Liekweg committed
87
88
89
90
91
ir_op *op_Load;        ir_op *get_op_Load      (void) { return op_Load;      }
ir_op *op_Store;       ir_op *get_op_Store     (void) { return op_Store;     }
ir_op *op_Alloc;       ir_op *get_op_Alloc     (void) { return op_Alloc;     }
ir_op *op_Free;        ir_op *get_op_Free      (void) { return op_Free;      }
ir_op *op_Sync;        ir_op *get_op_Sync      (void) { return op_Sync;      }
92

Florian Liekweg's avatar
Florian Liekweg committed
93
94
95
96
97
ir_op *op_Tuple;       ir_op *get_op_Tuple     (void) { return op_Tuple;     }
ir_op *op_Proj;        ir_op *get_op_Proj      (void) { return op_Proj;      }
ir_op *op_Id;          ir_op *get_op_Id        (void) { return op_Id;        }
ir_op *op_Bad;         ir_op *get_op_Bad       (void) { return op_Bad;       }
ir_op *op_Confirm;     ir_op *get_op_Confirm   (void) { return op_Confirm;   }
98

Florian Liekweg's avatar
Florian Liekweg committed
99
100
101
ir_op *op_Unknown;     ir_op *get_op_Unknown   (void) { return op_Unknown;   }
ir_op *op_Filter;      ir_op *get_op_Filter    (void) { return op_Filter;    }
ir_op *op_Break;       ir_op *get_op_Break     (void) { return op_Break;     }
Michael Beck's avatar
Michael Beck committed
102
ir_op *op_CallBegin;   ir_op *get_op_CallBegin (void) { return op_CallBegin; }
Florian Liekweg's avatar
Florian Liekweg committed
103
ir_op *op_EndReg;      ir_op *get_op_EndReg    (void) { return op_EndReg;    }
Michael Beck's avatar
Michael Beck committed
104
ir_op *op_EndExcept;   ir_op *get_op_EndExcept (void) { return op_EndExcept; }
105

106
107
ir_op *op_NoMem;       ir_op *get_op_NoMem     (void) { return op_NoMem;     }
ir_op *op_Mux;         ir_op *get_op_Mux       (void) { return op_Mux;       }
Michael Beck's avatar
Michael Beck committed
108
109
ir_op *op_Min;         ir_op *get_op_Min       (void) { return op_Max;       }
ir_op *op_Max;         ir_op *get_op_Max       (void) { return op_Max;       }
110
ir_op *op_CopyB;       ir_op *get_op_CopyB     (void) { return op_CopyB;     }
111
112

ir_op *op_Raise;       ir_op *get_op_Raise     (void) { return op_Raise;     }
Michael Beck's avatar
Michael Beck committed
113
ir_op *op_Bound;       ir_op *get_op_Bound     (void) { return op_Bound;     }
Michael Beck's avatar
Michael Beck committed
114

Michael Beck's avatar
Michael Beck committed
115
116
ir_op *op_Pin;         ir_op *get_op_Pin       (void) { return op_Pin;       }

Michael Beck's avatar
Michael Beck committed
117
ir_op *op_ASM;         ir_op *get_op_ASM       (void) { return op_ASM;       }
Michael Beck's avatar
Michael Beck committed
118
ir_op *op_Anchor;      ir_op *get_op_Anchor    (void) { return op_Anchor;    }
Michael Beck's avatar
Michael Beck committed
119

120
121
122
123
124
/*
 * Copies all attributes stored in the old node to the new node.
 * Assumes both have the same opcode and sufficient size.
 */
void default_copy_attr(const ir_node *old_node, ir_node *new_node) {
125
	unsigned size = firm_add_node_size;
126

127
128
	assert(get_irn_op(old_node) == get_irn_op(new_node));
	memcpy(&new_node->attr, &old_node->attr, get_op_attr_size(get_irn_op(old_node)));
129

130
131
132
133
	if (size > 0) {
		/* copy additional node data */
		memcpy(get_irn_data(new_node, void, size), get_irn_data(old_node, void, size), size);
	}
Michael Beck's avatar
Michael Beck committed
134
}  /* default_copy_attr */
135
136

/**
Michael Beck's avatar
Michael Beck committed
137
 * Copies all Call attributes stored in the old node to the new node.
138
139
140
 */
static void
call_copy_attr(const ir_node *old_node, ir_node *new_node) {
141
142
	default_copy_attr(old_node, new_node);
	remove_Call_callee_arr(new_node);
Michael Beck's avatar
Michael Beck committed
143
}  /* call_copy_attr */
144

Michael Beck's avatar
Michael Beck committed
145
146
147
/**
 * Copies all Block attributes stored in the old node to the new node.
 */
148
static void
Michael Beck's avatar
Michael Beck committed
149
block_copy_attr(const ir_node *old_node, ir_node *new_node) {
150
	ir_graph *irg = current_ir_graph;
151

152
	default_copy_attr(old_node, new_node);
153
	new_node->attr.block.phis        = NULL;
154
155
156
	new_node->attr.block.cg_backedge = NULL;
	new_node->attr.block.backedge = new_backedge_arr(irg->obst, get_irn_arity(new_node));
	INIT_LIST_HEAD(&new_node->attr.block.succ_head);
Michael Beck's avatar
Michael Beck committed
157
}  /* block_copy_attr */
158

159
160
161
162
163
/**
 * Copies all phi attributes stored in old node to the new node
 */
static void
phi_copy_attr(const ir_node *old_node, ir_node *new_node) {
164
	ir_graph *irg = current_ir_graph;
165

166
	default_copy_attr(old_node, new_node);
167
168
	new_node->attr.phi.next       = NULL;
	new_node->attr.phi.u.backedge = new_backedge_arr(irg->obst, get_irn_arity(new_node));
169
170
171
172
173
174
175
}

/**
 * Copies all filter attributes stored in old node to the new node
 */
static void
filter_copy_attr(const ir_node *old_node, ir_node *new_node) {
176
	ir_graph *irg = current_ir_graph;
177

178
179
	default_copy_attr(old_node, new_node);
	new_node->attr.filter.backedge = new_backedge_arr(irg->obst, get_irn_arity(new_node));
180
181
}

Michael Beck's avatar
Michael Beck committed
182
183
184
185
186
187
188
189
190
191
/**
 * Copies all ASM attributes stored in old node to the new node
 */
static void
ASM_copy_attr(const ir_node *old_node, ir_node *new_node) {
	ir_graph *irg = current_ir_graph;

	default_copy_attr(old_node, new_node);
	new_node->attr.assem.inputs  = DUP_ARR_D(ir_asm_constraint, irg->obst, old_node->attr.assem.inputs);
	new_node->attr.assem.outputs = DUP_ARR_D(ir_asm_constraint, irg->obst, old_node->attr.assem.outputs);
Michael Beck's avatar
Michael Beck committed
192
	new_node->attr.assem.clobber = DUP_ARR_D(ir_asm_constraint, irg->obst, old_node->attr.assem.clobber);
Michael Beck's avatar
Michael Beck committed
193
194
}

195
/**
Michael Beck's avatar
Michael Beck committed
196
197
198
199
200
201
202
 * Sets the default copy_attr operation for an ir_ops
 *
 * @param code   the opcode for the default operation
 * @param ops    the operations initialized
 *
 * @return
 *    The operations.
203
 */
204
static ir_op_ops *firm_set_default_copy_attr(ir_opcode code, ir_op_ops *ops) {
Matthias Braun's avatar
Matthias Braun committed
205
206
	switch(code) {
	case iro_Call:
207
		ops->copy_attr = call_copy_attr;
Matthias Braun's avatar
Matthias Braun committed
208
209
		break;
	case iro_Block:
210
		ops->copy_attr = block_copy_attr;
Matthias Braun's avatar
Matthias Braun committed
211
212
		break;
	case iro_Phi:
213
		ops->copy_attr = phi_copy_attr;
Matthias Braun's avatar
Matthias Braun committed
214
215
		break;
	case iro_Filter:
216
		ops->copy_attr = filter_copy_attr;
Matthias Braun's avatar
Matthias Braun committed
217
218
		break;
	case iro_ASM:
Michael Beck's avatar
Michael Beck committed
219
		ops->copy_attr = ASM_copy_attr;
Matthias Braun's avatar
Matthias Braun committed
220
221
		break;
	default:
222
223
224
225
226
		/* not allowed to be NULL */
		if (! ops->copy_attr)
			ops->copy_attr = default_copy_attr;
	}
	return ops;
Michael Beck's avatar
Michael Beck committed
227
}  /* firm_set_default_copy_attr */
228

Michael Beck's avatar
Michael Beck committed
229
/* Creates a new ir operation. */
Christian Schäfer's avatar
Christian Schäfer committed
230
ir_op *
Matthias Braun's avatar
Matthias Braun committed
231
new_ir_op(unsigned code, const char *name, op_pin_state p,
Michael Beck's avatar
Michael Beck committed
232
233
          unsigned flags, op_arity opar, int op_index, size_t attr_size,
          const ir_op_ops *ops)
Christian Schäfer's avatar
Christian Schäfer committed
234
{
235
	ir_op *res = XMALLOCZ(ir_op);
236
237
238

	res->code      = code;
	res->name      = new_id_from_chars(name, strlen(name));
239
	res->pin_state = p;
240
241
242
243
	res->attr_size = attr_size;
	res->flags     = flags;
	res->opar      = opar;
	res->op_index  = op_index;
Matthias Braun's avatar
Matthias Braun committed
244
	res->tag       = 0;
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259

	if (ops)
		memcpy(&res->ops, ops, sizeof(res->ops));
	else /* no given ops, set all operations to NULL */
		memset(&res->ops, 0, sizeof(res->ops));

	firm_set_default_operations(code, &res->ops);
	firm_set_default_copy_attr(code, &res->ops);
	firm_set_default_verifyer(code, &res->ops);
	firm_set_default_reassoc(code, &res->ops);

	add_irp_opcode(res);

	hook_new_ir_op(res);
	return res;
Michael Beck's avatar
Michael Beck committed
260
}  /* new_ir_op */
Christian Schäfer's avatar
Christian Schäfer committed
261

262
void free_ir_op(ir_op *code) {
263
	hook_free_ir_op(code);
264

265
266
	remove_irp_opcode(code);
	free(code);
Michael Beck's avatar
Michael Beck committed
267
}  /* free_ir_op */
Christian Schäfer's avatar
Christian Schäfer committed
268
269
270
271

void
init_op(void)
{
272
#define N   irop_flag_none
Florian Liekweg's avatar
Florian Liekweg committed
273
274
275
276
277
#define L   irop_flag_labeled
#define C   irop_flag_commutative
#define X   irop_flag_cfopcode
#define I   irop_flag_ip_cfopcode
#define F   irop_flag_fragile
Michael Beck's avatar
Michael Beck committed
278
#define Y   irop_flag_forking
279
#define H   irop_flag_highlevel
280
#define c   irop_flag_constlike
281
#define K   irop_flag_keep
282
#define S   irop_flag_start_block
283
#define M   irop_flag_uses_memory
284
285
#define NB  irop_flag_dump_noblock
#define NI  irop_flag_dump_noinput
Michael Beck's avatar
Michael Beck committed
286

287
288
289
290
291
292
	/* Caution: A great deal of Firm optimizations depend an right operations flags. */
	op_Block     = new_ir_op(iro_Block,     "Block",     op_pin_state_pinned, L,       oparity_variable, -1, sizeof(block_attr), NULL);

	op_Start     = new_ir_op(iro_Start,     "Start",     op_pin_state_pinned, X,       oparity_zero,     -1, 0, NULL);
	op_End       = new_ir_op(iro_End,       "End",       op_pin_state_pinned, X,       oparity_dynamic,  -1, 0, NULL);
	op_Jmp       = new_ir_op(iro_Jmp,       "Jmp",       op_pin_state_pinned, X,       oparity_zero,     -1, 0, NULL);
293
	op_IJmp      = new_ir_op(iro_IJmp,      "IJmp",      op_pin_state_pinned, X|Y|K,   oparity_unary,    -1, 0, NULL);
294
295
296
297
298
299
	op_Cond      = new_ir_op(iro_Cond,      "Cond",      op_pin_state_pinned, X|Y,     oparity_any,      -1, sizeof(cond_attr), NULL);
	op_Return    = new_ir_op(iro_Return,    "Return",    op_pin_state_pinned, X,       oparity_variable, -1, 0, NULL);

	op_Const     = new_ir_op(iro_Const,     "Const",     op_pin_state_floats, c|S,     oparity_zero,     -1, sizeof(const_attr), NULL);
	op_SymConst  = new_ir_op(iro_SymConst,  "SymConst",  op_pin_state_floats, c|S,     oparity_zero,     -1, sizeof(symconst_attr), NULL);

300
	op_Sel       = new_ir_op(iro_Sel,       "Sel",       op_pin_state_floats, N,       oparity_any,      -1, sizeof(sel_attr), NULL);
301

302
	op_Call      = new_ir_op(iro_Call,      "Call",      op_pin_state_mem_pinned, F|M, oparity_variable, -1, sizeof(call_attr), NULL);
303
304
	op_Add       = new_ir_op(iro_Add,       "Add",       op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
	op_Sub       = new_ir_op(iro_Sub,       "Sub",       op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
305
	op_Minus     = new_ir_op(iro_Minus,     "Minus",     op_pin_state_floats, N,       oparity_unary,     0, 0, NULL);
306
	op_Mul       = new_ir_op(iro_Mul,       "Mul",       op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
Michael Beck's avatar
Michael Beck committed
307
	op_Mulh      = new_ir_op(iro_Mulh,      "Mulh",      op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
308
309
310
311
	op_Quot      = new_ir_op(iro_Quot,      "Quot",      op_pin_state_exc_pinned, F|M, oparity_binary,    1, sizeof(divmod_attr), NULL);
	op_DivMod    = new_ir_op(iro_DivMod,    "DivMod",    op_pin_state_exc_pinned, F|M, oparity_binary,    1, sizeof(divmod_attr), NULL);
	op_Div       = new_ir_op(iro_Div,       "Div",       op_pin_state_exc_pinned, F|M, oparity_binary,    1, sizeof(divmod_attr), NULL);
	op_Mod       = new_ir_op(iro_Mod,       "Mod",       op_pin_state_exc_pinned, F|M, oparity_binary,    1, sizeof(divmod_attr), NULL);
312
313
314
315
316
317
318
319
320
	op_Abs       = new_ir_op(iro_Abs,       "Abs",       op_pin_state_floats, N,       oparity_unary,     0, 0, NULL);
	op_And       = new_ir_op(iro_And,       "And",       op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
	op_Or        = new_ir_op(iro_Or,        "Or",        op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
	op_Eor       = new_ir_op(iro_Eor,       "Eor",       op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
	op_Not       = new_ir_op(iro_Not,       "Not",       op_pin_state_floats, N,       oparity_unary,     0, 0, NULL);
	op_Cmp       = new_ir_op(iro_Cmp,       "Cmp",       op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
	op_Shl       = new_ir_op(iro_Shl,       "Shl",       op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
	op_Shr       = new_ir_op(iro_Shr,       "Shr",       op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
	op_Shrs      = new_ir_op(iro_Shrs,      "Shrs",      op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
321
	op_Rotl      = new_ir_op(iro_Rotl,      "Rotl",      op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
322
	op_Conv      = new_ir_op(iro_Conv,      "Conv",      op_pin_state_floats, N,       oparity_unary,     0, sizeof(conv_attr), NULL);
323
	op_Cast      = new_ir_op(iro_Cast,      "Cast",      op_pin_state_floats, H,       oparity_unary,     0, sizeof(cast_attr), NULL);
324
325
326
	op_Carry     = new_ir_op(iro_Carry,     "Carry",     op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
	op_Borrow    = new_ir_op(iro_Borrow,    "Borrow",    op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);

327
	op_Phi       = new_ir_op(iro_Phi,       "Phi",       op_pin_state_pinned, N,       oparity_variable, -1, sizeof(phi_attr), NULL);
328

329
330
331
332
	op_Load      = new_ir_op(iro_Load,      "Load",      op_pin_state_exc_pinned, F|M, oparity_any,      -1, sizeof(load_attr), NULL);
	op_Store     = new_ir_op(iro_Store,     "Store",     op_pin_state_exc_pinned, F|M, oparity_any,      -1, sizeof(store_attr), NULL);
	op_Alloc     = new_ir_op(iro_Alloc,     "Alloc",     op_pin_state_pinned, F|M,     oparity_any,      -1, sizeof(alloc_attr), NULL);
	op_Free      = new_ir_op(iro_Free,      "Free",      op_pin_state_pinned, N|M,     oparity_any,      -1, sizeof(free_attr), NULL);
Christoph Mallon's avatar
Christoph Mallon committed
333
	op_Sync      = new_ir_op(iro_Sync,      "Sync",      op_pin_state_floats, N,       oparity_dynamic,  -1, 0, NULL);
334
335
336
337

	op_Proj      = new_ir_op(iro_Proj,      "Proj",      op_pin_state_floats, N,       oparity_unary,    -1, sizeof(long), NULL);
	op_Tuple     = new_ir_op(iro_Tuple,     "Tuple",     op_pin_state_floats, L,       oparity_variable, -1, 0, NULL);
	op_Id        = new_ir_op(iro_Id,        "Id",        op_pin_state_floats, N,       oparity_any,      -1, 0, NULL);
338
	op_Bad       = new_ir_op(iro_Bad,       "Bad",       op_pin_state_pinned, X|F|S|NB,oparity_zero,     -1, 0, NULL);
339
340
	op_Confirm   = new_ir_op(iro_Confirm,   "Confirm",   op_pin_state_pinned, H,       oparity_any,      -1, sizeof(confirm_attr), NULL);

341
	op_Unknown   = new_ir_op(iro_Unknown,   "Unknown",   op_pin_state_pinned, X|F|S|c|NB,oparity_zero,   -1, 0, NULL);
342
343
344
345
346
347
	op_Filter    = new_ir_op(iro_Filter,    "Filter",    op_pin_state_pinned, N,       oparity_variable, -1, sizeof(filter_attr), NULL);
	op_Break     = new_ir_op(iro_Break,     "Break",     op_pin_state_pinned, X,       oparity_zero,     -1, 0, NULL);
	op_CallBegin = new_ir_op(iro_CallBegin, "CallBegin", op_pin_state_pinned, X|I,     oparity_any,      -1, sizeof(callbegin_attr), NULL);
	op_EndReg    = new_ir_op(iro_EndReg,    "EndReg",    op_pin_state_pinned, X|I,     oparity_dynamic,  -1, 0, NULL);
	op_EndExcept = new_ir_op(iro_EndExcept, "EndExcept", op_pin_state_pinned, X|I,     oparity_dynamic,  -1, 0, NULL);

348
	op_NoMem     = new_ir_op(iro_NoMem,     "NoMem",     op_pin_state_pinned, N|NB|NI, oparity_zero,     -1, 0, NULL);
349
	op_Mux       = new_ir_op(iro_Mux,       "Mux",       op_pin_state_floats, N,       oparity_trinary,  -1, 0, NULL);
Michael Beck's avatar
Michael Beck committed
350
351
	op_Min       = new_ir_op(iro_Min,       "Min",       op_pin_state_floats, N,       oparity_binary,   -1, 0, NULL);
	op_Max       = new_ir_op(iro_Max,       "Max",       op_pin_state_floats, N,       oparity_binary,   -1, 0, NULL);
352
	op_CopyB     = new_ir_op(iro_CopyB,     "CopyB",     op_pin_state_mem_pinned, F|H|M, oparity_trinary,-1, sizeof(copyb_attr), NULL);
353
354
355
356
357
358

	op_InstOf    = new_ir_op(iro_InstOf,    "InstOf",    op_pin_state_mem_pinned, H,   oparity_unary,    -1, sizeof(io_attr), NULL);
	op_Raise     = new_ir_op(iro_Raise,     "Raise",     op_pin_state_pinned,     H|X, oparity_any,      -1, 0, NULL);
	op_Bound     = new_ir_op(iro_Bound,     "Bound",     op_pin_state_exc_pinned, F|H, oparity_trinary,  -1, sizeof(bound_attr), NULL);

	op_Pin       = new_ir_op(iro_Pin,       "Pin",       op_pin_state_pinned, H,       oparity_unary,    -1, 0, NULL);
Michael Beck's avatar
Michael Beck committed
359

360
	op_ASM       = new_ir_op(iro_ASM,       "ASM",       op_pin_state_mem_pinned, K|M, oparity_variable, -1, sizeof(asm_attr), NULL);
361
	op_Builtin   = new_ir_op(iro_Builtin,   "Builtin",   op_pin_state_mem_pinned, M,   oparity_variable, -1, sizeof(builtin_attr), NULL);
Michael Beck's avatar
Michael Beck committed
362

363
	op_Anchor    = new_ir_op(iro_Anchor,    "Anchor",    op_pin_state_pinned, N|NB,    oparity_variable, -1, 0, NULL);
Michael Beck's avatar
Michael Beck committed
364

365
#undef S
366
#undef H
Michael Beck's avatar
Michael Beck committed
367
#undef Y
368
369
370
371
372
#undef F
#undef I
#undef X
#undef C
#undef L
373
#undef E
374
375
#undef NB
#undef NI
Michael Beck's avatar
Michael Beck committed
376
}  /* init_op */
Götz Lindenmaier's avatar
Götz Lindenmaier committed
377

378
379

/* free memory used by irop module. */
380
void finish_op(void) {
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
	free_ir_op (op_Block    ); op_Block     = NULL;

	free_ir_op (op_Start    ); op_Start     = NULL;
	free_ir_op (op_End      ); op_End       = NULL;
	free_ir_op (op_Jmp      ); op_Jmp       = NULL;
	free_ir_op (op_Cond     ); op_Cond      = NULL;
	free_ir_op (op_Return   ); op_Return    = NULL;

	free_ir_op (op_Const    ); op_Const     = NULL;
	free_ir_op (op_SymConst ); op_SymConst  = NULL;

	free_ir_op (op_Sel      ); op_Sel       = NULL;

	free_ir_op (op_Call     ); op_Call      = NULL;
	free_ir_op (op_Add      ); op_Add       = NULL;
	free_ir_op (op_Minus    ); op_Minus     = NULL;
	free_ir_op (op_Sub      ); op_Sub       = NULL;
	free_ir_op (op_Mul      ); op_Mul       = NULL;
Michael Beck's avatar
Michael Beck committed
399
	free_ir_op (op_Mulh     ); op_Mulh      = NULL;
400
401
402
403
404
405
406
407
408
409
410
411
412
	free_ir_op (op_Quot     ); op_Quot      = NULL;
	free_ir_op (op_DivMod   ); op_DivMod    = NULL;
	free_ir_op (op_Div      ); op_Div       = NULL;
	free_ir_op (op_Mod      ); op_Mod       = NULL;
	free_ir_op (op_Abs      ); op_Abs       = NULL;
	free_ir_op (op_And      ); op_And       = NULL;
	free_ir_op (op_Or       ); op_Or        = NULL;
	free_ir_op (op_Eor      ); op_Eor       = NULL;
	free_ir_op (op_Not      ); op_Not       = NULL;
	free_ir_op (op_Cmp      ); op_Cmp       = NULL;
	free_ir_op (op_Shl      ); op_Shl       = NULL;
	free_ir_op (op_Shr      ); op_Shr       = NULL;
	free_ir_op (op_Shrs     ); op_Shrs      = NULL;
413
	free_ir_op (op_Rotl     ); op_Rotl      = NULL;
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
	free_ir_op (op_Conv     ); op_Conv      = NULL;
	free_ir_op (op_Cast     ); op_Cast      = NULL;
	free_ir_op (op_Carry    ); op_Carry     = NULL;
	free_ir_op (op_Borrow   ); op_Borrow    = NULL;

	free_ir_op (op_Phi      ); op_Phi       = NULL;

	free_ir_op (op_Load     ); op_Load      = NULL;
	free_ir_op (op_Store    ); op_Store     = NULL;
	free_ir_op (op_Alloc    ); op_Alloc     = NULL;
	free_ir_op (op_Free     ); op_Free      = NULL;
	free_ir_op (op_Sync     ); op_Sync      = NULL;

	free_ir_op (op_Proj     ); op_Proj      = NULL;
	free_ir_op (op_Tuple    ); op_Tuple     = NULL;
	free_ir_op (op_Id       ); op_Id        = NULL;
	free_ir_op (op_Bad      ); op_Bad       = NULL;
	free_ir_op (op_Confirm  ); op_Confirm   = NULL;

	free_ir_op (op_Unknown  ); op_Unknown   = NULL;
	free_ir_op (op_Filter   ); op_Filter    = NULL;
	free_ir_op (op_Break    ); op_Break     = NULL;
	free_ir_op (op_CallBegin); op_CallBegin = NULL;
	free_ir_op (op_EndReg   ); op_EndReg    = NULL;
	free_ir_op (op_EndExcept); op_EndExcept = NULL;

	free_ir_op (op_NoMem    ); op_NoMem     = NULL;
Michael Beck's avatar
Michael Beck committed
441
442
	free_ir_op (op_Max      ); op_Max       = NULL;
	free_ir_op (op_Min      ); op_Min       = NULL;
443
444
445
446
447
448
449
450
	free_ir_op (op_Mux      ); op_Mux       = NULL;
	free_ir_op (op_CopyB    ); op_CopyB     = NULL;

	free_ir_op (op_InstOf   ); op_InstOf    = NULL;
	free_ir_op (op_Raise    ); op_Raise     = NULL;
	free_ir_op (op_Bound    ); op_Bound     = NULL;

	free_ir_op (op_Pin      ); op_Pin       = NULL;
Michael Beck's avatar
Michael Beck committed
451
452
	free_ir_op (op_ASM      ); op_ASM       = NULL;
	free_ir_op (op_Anchor   ); op_Anchor    = NULL;
453
454
}

Götz Lindenmaier's avatar
Götz Lindenmaier committed
455
/* Returns the string for the opcode. */
Michael Beck's avatar
Michael Beck committed
456
const char *get_op_name (const ir_op *op) {
457
	return get_id_str(op->name);
Michael Beck's avatar
Michael Beck committed
458
}  /* get_op_name */
Christian Schäfer's avatar
Christian Schäfer committed
459

Matthias Braun's avatar
Matthias Braun committed
460
unsigned (get_op_code)(const ir_op *op){
461
  return _get_op_code(op);
Michael Beck's avatar
Michael Beck committed
462
}  /* get_op_code */
Christian Schäfer's avatar
Christian Schäfer committed
463

464
ident *(get_op_ident)(const ir_op *op){
465
  return _get_op_ident(op);
Michael Beck's avatar
Michael Beck committed
466
}  /* get_op_ident */
Christian Schäfer's avatar
Christian Schäfer committed
467

Götz Lindenmaier's avatar
Götz Lindenmaier committed
468
const char *get_op_pin_state_name(op_pin_state s) {
469
	switch(s) {
Sebastian Hack's avatar
Sebastian Hack committed
470
#define XXX(s) case s: return #s
471
472
473
474
	XXX(op_pin_state_floats);
	XXX(op_pin_state_pinned);
	XXX(op_pin_state_exc_pinned);
	XXX(op_pin_state_mem_pinned);
Sebastian Hack's avatar
Sebastian Hack committed
475
#undef XXX
476
477
	}
	return "<none>";
Michael Beck's avatar
Michael Beck committed
478
}  /* get_op_pin_state_name */
Götz Lindenmaier's avatar
Götz Lindenmaier committed
479

480
op_pin_state (get_op_pinned)(const ir_op *op) {
481
	return _get_op_pinned(op);
Michael Beck's avatar
Michael Beck committed
482
}  /* get_op_pinned */
483

484
/* Sets op_pin_state_pinned in the opcode.  Setting it to floating has no effect
485
   for Phi, Block and control flow nodes. */
486
void set_op_pinned(ir_op *op, op_pin_state pinned) {
487
	if (op == op_Block || op == op_Phi || is_op_cfopcode(op)) return;
488
	op->pin_state = pinned;
Michael Beck's avatar
Michael Beck committed
489
}  /* set_op_pinned */
Michael Beck's avatar
Michael Beck committed
490

491
/* retrieve the next free opcode */
Michael Beck's avatar
Michael Beck committed
492
unsigned get_next_ir_opcode(void) {
493
	return next_iro++;
Michael Beck's avatar
Michael Beck committed
494
}  /* get_next_ir_opcode */
495

496
497
/* Returns the next free n IR opcode number, allows to register a bunch of user ops */
unsigned get_next_ir_opcodes(unsigned num) {
498
499
500
	unsigned base = next_iro;
	next_iro += num;
	return base;
Michael Beck's avatar
Michael Beck committed
501
}  /* get_next_ir_opcodes */
502

503
504
/* Returns the generic function pointer from an ir operation. */
op_func (get_generic_function_ptr)(const ir_op *op) {
505
	return _get_generic_function_ptr(op);
Michael Beck's avatar
Michael Beck committed
506
}  /* get_generic_function_ptr */
507
508
509

/* Store a generic function pointer into an ir operation. */
void (set_generic_function_ptr)(ir_op *op, op_func func) {
510
	_set_generic_function_ptr(op, func);
Michael Beck's avatar
Michael Beck committed
511
}  /* set_generic_function_ptr */
Michael Beck's avatar
Michael Beck committed
512
513
514

/* Returns the ir_op_ops of an ir_op. */
const ir_op_ops *(get_op_ops)(const ir_op *op) {
515
	return _get_op_ops(op);
Michael Beck's avatar
Michael Beck committed
516
}  /* get_op_ops */
517
518
519
520

irop_flags get_op_flags(const ir_op *op) {
	return op->flags;
}