nsz Git - libfirm/blob - ir/ir/irop.c

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief   Representation of opcode of intermediate operation.
  23  * @author  Christian Schaefer, Goetz Lindenmaier, Michael Beck
  24  * @version $Id$
  25  */
  26 #include "config.h"
  27
  28 #include <string.h>
  29
  30 #include "irop_t.h"
  31 #include "irnode_t.h"
  32 #include "irhooks.h"
  33 #include "irbackedge_t.h"
  34
  35 #include "iropt_t.h"             /* for firm_set_default_operations */
  36 #include "irvrfy_t.h"
  37 #include "reassoc_t.h"
  38
  39 #include "xmalloc.h"
  40
  41 void be_init_op(void);
  42
  43 /** the available next opcode */
  44 static unsigned next_iro = iro_MaxOpcode;
  45
  46 ir_op *op_Block;       ir_op *get_op_Block     (void) { return op_Block;     }
  47
  48 ir_op *op_Start;       ir_op *get_op_Start     (void) { return op_Start;     }
  49 ir_op *op_End;         ir_op *get_op_End       (void) { return op_End;       }
  50 ir_op *op_Jmp;         ir_op *get_op_Jmp       (void) { return op_Jmp;       }
  51 ir_op *op_IJmp;        ir_op *get_op_IJmp      (void) { return op_IJmp;      }
  52 ir_op *op_Cond;        ir_op *get_op_Cond      (void) { return op_Cond;      }
  53 ir_op *op_Return;      ir_op *get_op_Return    (void) { return op_Return;    }
  54
  55 ir_op *op_Sel;         ir_op *get_op_Sel       (void) { return op_Sel;       }
  56 ir_op *op_InstOf;      ir_op *get_op_InstOf    (void) { return op_InstOf;    }
  57
  58 ir_op *op_Const;       ir_op *get_op_Const     (void) { return op_Const;     }
  59 ir_op *op_SymConst;    ir_op *get_op_SymConst  (void) { return op_SymConst;  }
  60
  61 ir_op *op_Call;        ir_op *get_op_Call      (void) { return op_Call;      }
  62 ir_op *op_Builtin;     ir_op *get_op_Builtin   (void) { return op_Builtin;   }
  63 ir_op *op_Add;         ir_op *get_op_Add       (void) { return op_Add;       }
  64 ir_op *op_Sub;         ir_op *get_op_Sub       (void) { return op_Sub;       }
  65 ir_op *op_Minus;       ir_op *get_op_Minus     (void) { return op_Minus;     }
  66 ir_op *op_Mul;         ir_op *get_op_Mul       (void) { return op_Mul;       }
  67 ir_op *op_Mulh;        ir_op *get_op_Mulh      (void) { return op_Mulh;      }
  68 ir_op *op_Quot;        ir_op *get_op_Quot      (void) { return op_Quot;      }
  69 ir_op *op_DivMod;      ir_op *get_op_DivMod    (void) { return op_DivMod;    }
  70 ir_op *op_Div;         ir_op *get_op_Div       (void) { return op_Div;       }
  71 ir_op *op_Mod;         ir_op *get_op_Mod       (void) { return op_Mod;       }
  72 ir_op *op_Abs;         ir_op *get_op_Abs       (void) { return op_Abs;       }
  73 ir_op *op_And;         ir_op *get_op_And       (void) { return op_And;       }
  74 ir_op *op_Or;          ir_op *get_op_Or        (void) { return op_Or;        }
  75 ir_op *op_Eor;         ir_op *get_op_Eor       (void) { return op_Eor;       }
  76 ir_op *op_Not;         ir_op *get_op_Not       (void) { return op_Not;       }
  77 ir_op *op_Cmp;         ir_op *get_op_Cmp       (void) { return op_Cmp;       }
  78 ir_op *op_Shl;         ir_op *get_op_Shl       (void) { return op_Shl;       }
  79 ir_op *op_Shr;         ir_op *get_op_Shr       (void) { return op_Shr;       }
  80 ir_op *op_Shrs;        ir_op *get_op_Shrs      (void) { return op_Shrs;      }
  81 ir_op *op_Rotl;        ir_op *get_op_Rotl      (void) { return op_Rotl;      }
  82 ir_op *op_Conv;        ir_op *get_op_Conv      (void) { return op_Conv;      }
  83 ir_op *op_Cast;        ir_op *get_op_Cast      (void) { return op_Cast;      }
  84 ir_op *op_Carry;       ir_op *get_op_Carry     (void) { return op_Carry;     }
  85 ir_op *op_Borrow;      ir_op *get_op_Borrow    (void) { return op_Borrow;    }
  86
  87 ir_op *op_Phi;         ir_op *get_op_Phi       (void) { return op_Phi;       }
  88
  89 ir_op *op_Load;        ir_op *get_op_Load      (void) { return op_Load;      }
  90 ir_op *op_Store;       ir_op *get_op_Store     (void) { return op_Store;     }
  91 ir_op *op_Alloc;       ir_op *get_op_Alloc     (void) { return op_Alloc;     }
  92 ir_op *op_Free;        ir_op *get_op_Free      (void) { return op_Free;      }
  93 ir_op *op_Sync;        ir_op *get_op_Sync      (void) { return op_Sync;      }
  94
  95 ir_op *op_Tuple;       ir_op *get_op_Tuple     (void) { return op_Tuple;     }
  96 ir_op *op_Proj;        ir_op *get_op_Proj      (void) { return op_Proj;      }
  97 ir_op *op_Id;          ir_op *get_op_Id        (void) { return op_Id;        }
  98 ir_op *op_Bad;         ir_op *get_op_Bad       (void) { return op_Bad;       }
  99 ir_op *op_Confirm;     ir_op *get_op_Confirm   (void) { return op_Confirm;   }
 100
 101 ir_op *op_Unknown;     ir_op *get_op_Unknown   (void) { return op_Unknown;   }
 102 ir_op *op_Filter;      ir_op *get_op_Filter    (void) { return op_Filter;    }
 103 ir_op *op_Break;       ir_op *get_op_Break     (void) { return op_Break;     }
 104 ir_op *op_CallBegin;   ir_op *get_op_CallBegin (void) { return op_CallBegin; }
 105 ir_op *op_EndReg;      ir_op *get_op_EndReg    (void) { return op_EndReg;    }
 106 ir_op *op_EndExcept;   ir_op *get_op_EndExcept (void) { return op_EndExcept; }
 107
 108 ir_op *op_NoMem;       ir_op *get_op_NoMem     (void) { return op_NoMem;     }
 109 ir_op *op_Mux;         ir_op *get_op_Mux       (void) { return op_Mux;       }
 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;     }
 113 ir_op *op_Bound;       ir_op *get_op_Bound     (void) { return op_Bound;     }
 114
 115 ir_op *op_Pin;         ir_op *get_op_Pin       (void) { return op_Pin;       }
 116
 117 ir_op *op_ASM;         ir_op *get_op_ASM       (void) { return op_ASM;       }
 118 ir_op *op_Dummy;       ir_op *get_op_Dummy     (void) { return op_Dummy;     }
 119 ir_op *op_Anchor;      ir_op *get_op_Anchor    (void) { return op_Anchor;    }
 120
 121 /*
 122  * Copies all attributes stored in the old node to the new node.
 123  * Assumes both have the same opcode and sufficient size.
 124  */
 125 void default_copy_attr(const ir_node *old_node, ir_node *new_node) {
 126         unsigned size = firm_add_node_size;
 127
 128         assert(get_irn_op(old_node) == get_irn_op(new_node));
 129         memcpy(&new_node->attr, &old_node->attr, get_op_attr_size(get_irn_op(old_node)));
 130
 131         if (size > 0) {
 132                 /* copy additional node data */
 133                 memcpy(get_irn_data(new_node, void, size), get_irn_data(old_node, void, size), size);
 134         }
 135 }  /* default_copy_attr */
 136
 137 /**
 138  * Copies all Call attributes stored in the old node to the new node.
 139  */
 140 static void
 141 call_copy_attr(const ir_node *old_node, ir_node *new_node) {
 142         default_copy_attr(old_node, new_node);
 143         remove_Call_callee_arr(new_node);
 144 }  /* call_copy_attr */
 145
 146 /**
 147  * Copies all Block attributes stored in the old node to the new node.
 148  */
 149 static void
 150 block_copy_attr(const ir_node *old_node, ir_node *new_node) {
 151         ir_graph *irg = current_ir_graph;
 152
 153         default_copy_attr(old_node, new_node);
 154         new_node->attr.block.phis        = NULL;
 155         new_node->attr.block.cg_backedge = NULL;
 156         new_node->attr.block.backedge = new_backedge_arr(irg->obst, get_irn_arity(new_node));
 157         INIT_LIST_HEAD(&new_node->attr.block.succ_head);
 158 }  /* block_copy_attr */
 159
 160 /**
 161  * Copies all phi attributes stored in old node to the new node
 162  */
 163 static void
 164 phi_copy_attr(const ir_node *old_node, ir_node *new_node) {
 165         ir_graph *irg = current_ir_graph;
 166
 167         default_copy_attr(old_node, new_node);
 168         new_node->attr.phi.next       = NULL;
 169         new_node->attr.phi.u.backedge = new_backedge_arr(irg->obst, get_irn_arity(new_node));
 170 }
 171
 172 /**
 173  * Copies all filter attributes stored in old node to the new node
 174  */
 175 static void
 176 filter_copy_attr(const ir_node *old_node, ir_node *new_node) {
 177         ir_graph *irg = current_ir_graph;
 178
 179         default_copy_attr(old_node, new_node);
 180         new_node->attr.filter.backedge = new_backedge_arr(irg->obst, get_irn_arity(new_node));
 181 }
 182
 183 /**
 184  * Copies all ASM attributes stored in old node to the new node
 185  */
 186 static void
 187 ASM_copy_attr(const ir_node *old_node, ir_node *new_node) {
 188         ir_graph *irg = current_ir_graph;
 189
 190         default_copy_attr(old_node, new_node);
 191         new_node->attr.assem.inputs  = DUP_ARR_D(ir_asm_constraint, irg->obst, old_node->attr.assem.inputs);
 192         new_node->attr.assem.outputs = DUP_ARR_D(ir_asm_constraint, irg->obst, old_node->attr.assem.outputs);
 193         new_node->attr.assem.clobber = DUP_ARR_D(ir_asm_constraint, irg->obst, old_node->attr.assem.clobber);
 194 }
 195
 196 /**
 197  * Sets the default copy_attr operation for an ir_ops
 198  *
 199  * @param code   the opcode for the default operation
 200  * @param ops    the operations initialized
 201  *
 202  * @return
 203  *    The operations.
 204  */
 205 static ir_op_ops *firm_set_default_copy_attr(ir_opcode code, ir_op_ops *ops) {
 206         switch(code) {
 207         case iro_Call:
 208                 ops->copy_attr = call_copy_attr;
 209                 break;
 210         case iro_Block:
 211                 ops->copy_attr = block_copy_attr;
 212                 break;
 213         case iro_Phi:
 214                 ops->copy_attr = phi_copy_attr;
 215                 break;
 216         case iro_Filter:
 217                 ops->copy_attr = filter_copy_attr;
 218                 break;
 219         case iro_ASM:
 220                 ops->copy_attr = ASM_copy_attr;
 221                 break;
 222         default:
 223                 /* not allowed to be NULL */
 224                 if (! ops->copy_attr)
 225                         ops->copy_attr = default_copy_attr;
 226         }
 227         return ops;
 228 }  /* firm_set_default_copy_attr */
 229
 230 /* Creates a new ir operation. */
 231 ir_op *
 232 new_ir_op(unsigned code, const char *name, op_pin_state p,
 233           unsigned flags, op_arity opar, int op_index, size_t attr_size,
 234           const ir_op_ops *ops)
 235 {
 236         ir_op *res = XMALLOCZ(ir_op);
 237
 238         res->code      = code;
 239         res->name      = new_id_from_chars(name, strlen(name));
 240         res->pin_state = p;
 241         res->attr_size = attr_size;
 242         res->flags     = flags;
 243         res->opar      = opar;
 244         res->op_index  = op_index;
 245         res->tag       = 0;
 246
 247         if (ops)
 248                 memcpy(&res->ops, ops, sizeof(res->ops));
 249         else /* no given ops, set all operations to NULL */
 250                 memset(&res->ops, 0, sizeof(res->ops));
 251
 252         firm_set_default_operations(code, &res->ops);
 253         firm_set_default_copy_attr(code, &res->ops);
 254         firm_set_default_verifyer(code, &res->ops);
 255         firm_set_default_reassoc(code, &res->ops);
 256
 257         add_irp_opcode(res);
 258
 259         hook_new_ir_op(res);
 260         return res;
 261 }  /* new_ir_op */
 262
 263 void free_ir_op(ir_op *code) {
 264         hook_free_ir_op(code);
 265
 266         remove_irp_opcode(code);
 267         free(code);
 268 }  /* free_ir_op */
 269
 270 void
 271 init_op(void)
 272 {
 273 #define N   irop_flag_none
 274 #define L   irop_flag_labeled
 275 #define C   irop_flag_commutative
 276 #define X   irop_flag_cfopcode
 277 #define I   irop_flag_ip_cfopcode
 278 #define F   irop_flag_fragile
 279 #define Y   irop_flag_forking
 280 #define H   irop_flag_highlevel
 281 #define c   irop_flag_constlike
 282 #define K   irop_flag_keep
 283 #define S   irop_flag_start_block
 284 #define M   irop_flag_uses_memory
 285 #define NB  irop_flag_dump_noblock
 286 #define NI  irop_flag_dump_noinput
 287
 288         /* Caution: A great deal of Firm optimizations depend an right operations flags. */
 289         op_Block     = new_ir_op(iro_Block,     "Block",     op_pin_state_pinned, L,       oparity_variable, -1, sizeof(block_attr), NULL);
 290
 291         op_Start     = new_ir_op(iro_Start,     "Start",     op_pin_state_pinned, X,       oparity_zero,     -1, 0, NULL);
 292         op_End       = new_ir_op(iro_End,       "End",       op_pin_state_pinned, X,       oparity_dynamic,  -1, 0, NULL);
 293         op_Jmp       = new_ir_op(iro_Jmp,       "Jmp",       op_pin_state_pinned, X,       oparity_zero,     -1, 0, NULL);
 294         op_IJmp      = new_ir_op(iro_IJmp,      "IJmp",      op_pin_state_pinned, X|Y|K,   oparity_unary,    -1, 0, NULL);
 295         op_Cond      = new_ir_op(iro_Cond,      "Cond",      op_pin_state_pinned, X|Y,     oparity_any,      -1, sizeof(cond_attr), NULL);
 296         op_Return    = new_ir_op(iro_Return,    "Return",    op_pin_state_pinned, X,       oparity_variable, -1, 0, NULL);
 297
 298         op_Const     = new_ir_op(iro_Const,     "Const",     op_pin_state_floats, c|S,     oparity_zero,     -1, sizeof(const_attr), NULL);
 299         op_SymConst  = new_ir_op(iro_SymConst,  "SymConst",  op_pin_state_floats, c|S,     oparity_zero,     -1, sizeof(symconst_attr), NULL);
 300
 301         op_Sel       = new_ir_op(iro_Sel,       "Sel",       op_pin_state_floats, N,       oparity_any,      -1, sizeof(sel_attr), NULL);
 302
 303         op_Call      = new_ir_op(iro_Call,      "Call",      op_pin_state_mem_pinned, F|M, oparity_variable, -1, sizeof(call_attr), NULL);
 304         op_Add       = new_ir_op(iro_Add,       "Add",       op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
 305         op_Sub       = new_ir_op(iro_Sub,       "Sub",       op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
 306         op_Minus     = new_ir_op(iro_Minus,     "Minus",     op_pin_state_floats, N,       oparity_unary,     0, 0, NULL);
 307         op_Mul       = new_ir_op(iro_Mul,       "Mul",       op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
 308         op_Mulh      = new_ir_op(iro_Mulh,      "Mulh",      op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
 309         op_Quot      = new_ir_op(iro_Quot,      "Quot",      op_pin_state_exc_pinned, F|M, oparity_binary,    1, sizeof(divmod_attr), NULL);
 310         op_DivMod    = new_ir_op(iro_DivMod,    "DivMod",    op_pin_state_exc_pinned, F|M, oparity_binary,    1, sizeof(divmod_attr), NULL);
 311         op_Div       = new_ir_op(iro_Div,       "Div",       op_pin_state_exc_pinned, F|M, oparity_binary,    1, sizeof(divmod_attr), NULL);
 312         op_Mod       = new_ir_op(iro_Mod,       "Mod",       op_pin_state_exc_pinned, F|M, oparity_binary,    1, sizeof(divmod_attr), NULL);
 313         op_Abs       = new_ir_op(iro_Abs,       "Abs",       op_pin_state_floats, N,       oparity_unary,     0, 0, NULL);
 314         op_And       = new_ir_op(iro_And,       "And",       op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
 315         op_Or        = new_ir_op(iro_Or,        "Or",        op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
 316         op_Eor       = new_ir_op(iro_Eor,       "Eor",       op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
 317         op_Not       = new_ir_op(iro_Not,       "Not",       op_pin_state_floats, N,       oparity_unary,     0, 0, NULL);
 318         op_Cmp       = new_ir_op(iro_Cmp,       "Cmp",       op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
 319         op_Shl       = new_ir_op(iro_Shl,       "Shl",       op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
 320         op_Shr       = new_ir_op(iro_Shr,       "Shr",       op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
 321         op_Shrs      = new_ir_op(iro_Shrs,      "Shrs",      op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
 322         op_Rotl      = new_ir_op(iro_Rotl,      "Rotl",      op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
 323         op_Conv      = new_ir_op(iro_Conv,      "Conv",      op_pin_state_floats, N,       oparity_unary,     0, sizeof(conv_attr), NULL);
 324         op_Cast      = new_ir_op(iro_Cast,      "Cast",      op_pin_state_floats, H,       oparity_unary,     0, sizeof(cast_attr), NULL);
 325         op_Carry     = new_ir_op(iro_Carry,     "Carry",     op_pin_state_floats, C,       oparity_binary,    0, 0, NULL);
 326         op_Borrow    = new_ir_op(iro_Borrow,    "Borrow",    op_pin_state_floats, N,       oparity_binary,    0, 0, NULL);
 327
 328         op_Phi       = new_ir_op(iro_Phi,       "Phi",       op_pin_state_pinned, N,       oparity_variable, -1, sizeof(phi_attr), NULL);
 329
 330         op_Load      = new_ir_op(iro_Load,      "Load",      op_pin_state_exc_pinned, F|M, oparity_any,      -1, sizeof(load_attr), NULL);
 331         op_Store     = new_ir_op(iro_Store,     "Store",     op_pin_state_exc_pinned, F|M, oparity_any,      -1, sizeof(store_attr), NULL);
 332         op_Alloc     = new_ir_op(iro_Alloc,     "Alloc",     op_pin_state_pinned, F|M,     oparity_any,      -1, sizeof(alloc_attr), NULL);
 333         op_Free      = new_ir_op(iro_Free,      "Free",      op_pin_state_pinned, N|M,     oparity_any,      -1, sizeof(free_attr), NULL);
 334         op_Sync      = new_ir_op(iro_Sync,      "Sync",      op_pin_state_floats, N,       oparity_dynamic,  -1, 0, NULL);
 335
 336         op_Proj      = new_ir_op(iro_Proj,      "Proj",      op_pin_state_floats, N,       oparity_unary,    -1, sizeof(long), NULL);
 337         op_Tuple     = new_ir_op(iro_Tuple,     "Tuple",     op_pin_state_floats, L,       oparity_variable, -1, 0, NULL);
 338         op_Id        = new_ir_op(iro_Id,        "Id",        op_pin_state_floats, N,       oparity_any,      -1, 0, NULL);
 339         op_Bad       = new_ir_op(iro_Bad,       "Bad",       op_pin_state_pinned, X|F|S|NB,oparity_zero,     -1, 0, NULL);
 340         op_Confirm   = new_ir_op(iro_Confirm,   "Confirm",   op_pin_state_pinned, H,       oparity_any,      -1, sizeof(confirm_attr), NULL);
 341
 342         op_Unknown   = new_ir_op(iro_Unknown,   "Unknown",   op_pin_state_pinned, X|F|S|c|NB,oparity_zero,   -1, 0, NULL);
 343         op_Filter    = new_ir_op(iro_Filter,    "Filter",    op_pin_state_pinned, N,       oparity_variable, -1, sizeof(filter_attr), NULL);
 344         op_Break     = new_ir_op(iro_Break,     "Break",     op_pin_state_pinned, X,       oparity_zero,     -1, 0, NULL);
 345         op_CallBegin = new_ir_op(iro_CallBegin, "CallBegin", op_pin_state_pinned, X|I,     oparity_any,      -1, sizeof(callbegin_attr), NULL);
 346         op_EndReg    = new_ir_op(iro_EndReg,    "EndReg",    op_pin_state_pinned, X|I,     oparity_dynamic,  -1, 0, NULL);
 347         op_EndExcept = new_ir_op(iro_EndExcept, "EndExcept", op_pin_state_pinned, X|I,     oparity_dynamic,  -1, 0, NULL);
 348
 349         op_NoMem     = new_ir_op(iro_NoMem,     "NoMem",     op_pin_state_pinned, N|NB|NI, oparity_zero,     -1, 0, NULL);
 350         op_Mux       = new_ir_op(iro_Mux,       "Mux",       op_pin_state_floats, N,       oparity_trinary,  -1, 0, NULL);
 351         op_CopyB     = new_ir_op(iro_CopyB,     "CopyB",     op_pin_state_mem_pinned, F|H|M, oparity_trinary,-1, sizeof(copyb_attr), NULL);
 352
 353         op_InstOf    = new_ir_op(iro_InstOf,    "InstOf",    op_pin_state_mem_pinned, H,   oparity_unary,    -1, sizeof(io_attr), NULL);
 354         op_Raise     = new_ir_op(iro_Raise,     "Raise",     op_pin_state_pinned,     H|X, oparity_any,      -1, 0, NULL);
 355         op_Bound     = new_ir_op(iro_Bound,     "Bound",     op_pin_state_exc_pinned, F|H, oparity_trinary,  -1, sizeof(bound_attr), NULL);
 356
 357         op_Pin       = new_ir_op(iro_Pin,       "Pin",       op_pin_state_pinned, H,       oparity_unary,    -1, 0, NULL);
 358
 359         op_ASM       = new_ir_op(iro_ASM,       "ASM",       op_pin_state_mem_pinned, K|M, oparity_variable, -1, sizeof(asm_attr), NULL);
 360         op_Builtin   = new_ir_op(iro_Builtin,   "Builtin",   op_pin_state_mem_pinned, M,   oparity_variable, -1, sizeof(builtin_attr), NULL);
 361
 362         op_Dummy     = new_ir_op(iro_Dummy,     "Dummy",     op_pin_state_pinned, X|F|S|c|NB,oparity_zero,   -1, 0, NULL);
 363
 364         op_Anchor    = new_ir_op(iro_Anchor,    "Anchor",    op_pin_state_pinned, N|NB,    oparity_variable, -1, 0, NULL);
 365
 366 #undef S
 367 #undef H
 368 #undef Y
 369 #undef F
 370 #undef I
 371 #undef X
 372 #undef C
 373 #undef L
 374 #undef E
 375 #undef NB
 376 #undef NI
 377
 378         /* initialize backend opcodes */
 379         be_init_op();
 380 }  /* init_op */
 381
 382
 383 /* free memory used by irop module. */
 384 void finish_op(void) {
 385         free_ir_op (op_Block    ); op_Block     = NULL;
 386
 387         free_ir_op (op_Start    ); op_Start     = NULL;
 388         free_ir_op (op_End      ); op_End       = NULL;
 389         free_ir_op (op_Jmp      ); op_Jmp       = NULL;
 390         free_ir_op (op_Cond     ); op_Cond      = NULL;
 391         free_ir_op (op_Return   ); op_Return    = NULL;
 392
 393         free_ir_op (op_Const    ); op_Const     = NULL;
 394         free_ir_op (op_SymConst ); op_SymConst  = NULL;
 395
 396         free_ir_op (op_Sel      ); op_Sel       = NULL;
 397
 398         free_ir_op (op_Call     ); op_Call      = NULL;
 399         free_ir_op (op_Add      ); op_Add       = NULL;
 400         free_ir_op (op_Minus    ); op_Minus     = NULL;
 401         free_ir_op (op_Sub      ); op_Sub       = NULL;
 402         free_ir_op (op_Mul      ); op_Mul       = NULL;
 403         free_ir_op (op_Mulh     ); op_Mulh      = NULL;
 404         free_ir_op (op_Quot     ); op_Quot      = NULL;
 405         free_ir_op (op_DivMod   ); op_DivMod    = NULL;
 406         free_ir_op (op_Div      ); op_Div       = NULL;
 407         free_ir_op (op_Mod      ); op_Mod       = NULL;
 408         free_ir_op (op_Abs      ); op_Abs       = NULL;
 409         free_ir_op (op_And      ); op_And       = NULL;
 410         free_ir_op (op_Or       ); op_Or        = NULL;
 411         free_ir_op (op_Eor      ); op_Eor       = NULL;
 412         free_ir_op (op_Not      ); op_Not       = NULL;
 413         free_ir_op (op_Cmp      ); op_Cmp       = NULL;
 414         free_ir_op (op_Shl      ); op_Shl       = NULL;
 415         free_ir_op (op_Shr      ); op_Shr       = NULL;
 416         free_ir_op (op_Shrs     ); op_Shrs      = NULL;
 417         free_ir_op (op_Rotl     ); op_Rotl      = NULL;
 418         free_ir_op (op_Conv     ); op_Conv      = NULL;
 419         free_ir_op (op_Cast     ); op_Cast      = NULL;
 420         free_ir_op (op_Carry    ); op_Carry     = NULL;
 421         free_ir_op (op_Borrow   ); op_Borrow    = NULL;
 422
 423         free_ir_op (op_Phi      ); op_Phi       = NULL;
 424
 425         free_ir_op (op_Load     ); op_Load      = NULL;
 426         free_ir_op (op_Store    ); op_Store     = NULL;
 427         free_ir_op (op_Alloc    ); op_Alloc     = NULL;
 428         free_ir_op (op_Free     ); op_Free      = NULL;
 429         free_ir_op (op_Sync     ); op_Sync      = NULL;
 430
 431         free_ir_op (op_Proj     ); op_Proj      = NULL;
 432         free_ir_op (op_Tuple    ); op_Tuple     = NULL;
 433         free_ir_op (op_Id       ); op_Id        = NULL;
 434         free_ir_op (op_Bad      ); op_Bad       = NULL;
 435         free_ir_op (op_Confirm  ); op_Confirm   = NULL;
 436
 437         free_ir_op (op_Unknown  ); op_Unknown   = NULL;
 438         free_ir_op (op_Filter   ); op_Filter    = NULL;
 439         free_ir_op (op_Break    ); op_Break     = NULL;
 440         free_ir_op (op_CallBegin); op_CallBegin = NULL;
 441         free_ir_op (op_EndReg   ); op_EndReg    = NULL;
 442         free_ir_op (op_EndExcept); op_EndExcept = NULL;
 443
 444         free_ir_op (op_NoMem    ); op_NoMem     = NULL;
 445         free_ir_op (op_Mux      ); op_Mux       = NULL;
 446         free_ir_op (op_CopyB    ); op_CopyB     = NULL;
 447
 448         free_ir_op (op_InstOf   ); op_InstOf    = NULL;
 449         free_ir_op (op_Raise    ); op_Raise     = NULL;
 450         free_ir_op (op_Bound    ); op_Bound     = NULL;
 451
 452         free_ir_op (op_Pin      ); op_Pin       = NULL;
 453         free_ir_op (op_ASM      ); op_ASM       = NULL;
 454         free_ir_op (op_Dummy    ); op_Dummy     = NULL;
 455         free_ir_op (op_Anchor   ); op_Anchor    = NULL;
 456 }
 457
 458 /* Returns the string for the opcode. */
 459 const char *get_op_name (const ir_op *op) {
 460         return get_id_str(op->name);
 461 }  /* get_op_name */
 462
 463 unsigned (get_op_code)(const ir_op *op){
 464   return _get_op_code(op);
 465 }  /* get_op_code */
 466
 467 ident *(get_op_ident)(const ir_op *op){
 468   return _get_op_ident(op);
 469 }  /* get_op_ident */
 470
 471 const char *get_op_pin_state_name(op_pin_state s) {
 472         switch(s) {
 473 #define XXX(s) case s: return #s
 474         XXX(op_pin_state_floats);
 475         XXX(op_pin_state_pinned);
 476         XXX(op_pin_state_exc_pinned);
 477         XXX(op_pin_state_mem_pinned);
 478 #undef XXX
 479         }
 480         return "<none>";
 481 }  /* get_op_pin_state_name */
 482
 483 op_pin_state (get_op_pinned)(const ir_op *op) {
 484         return _get_op_pinned(op);
 485 }  /* get_op_pinned */
 486
 487 /* Sets op_pin_state_pinned in the opcode.  Setting it to floating has no effect
 488    for Phi, Block and control flow nodes. */
 489 void set_op_pinned(ir_op *op, op_pin_state pinned) {
 490         if (op == op_Block || op == op_Phi || is_op_cfopcode(op)) return;
 491         op->pin_state = pinned;
 492 }  /* set_op_pinned */
 493
 494 /* retrieve the next free opcode */
 495 unsigned get_next_ir_opcode(void) {
 496         return next_iro++;
 497 }  /* get_next_ir_opcode */
 498
 499 /* Returns the next free n IR opcode number, allows to register a bunch of user ops */
 500 unsigned get_next_ir_opcodes(unsigned num) {
 501         unsigned base = next_iro;
 502         next_iro += num;
 503         return base;
 504 }  /* get_next_ir_opcodes */
 505
 506 /* Returns the generic function pointer from an ir operation. */
 507 op_func (get_generic_function_ptr)(const ir_op *op) {
 508         return _get_generic_function_ptr(op);
 509 }  /* get_generic_function_ptr */
 510
 511 /* Store a generic function pointer into an ir operation. */
 512 void (set_generic_function_ptr)(ir_op *op, op_func func) {
 513         _set_generic_function_ptr(op, func);
 514 }  /* set_generic_function_ptr */
 515
 516 /* Returns the ir_op_ops of an ir_op. */
 517 const ir_op_ops *(get_op_ops)(const ir_op *op) {
 518         return _get_op_ops(op);
 519 }  /* get_op_ops */
 520
 521 irop_flags get_op_flags(const ir_op *op) {
 522         return op->flags;
 523 }