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

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/ir/irop.c
   4  * Purpose:     Representation of opcode of intermediate operation.
   5  * Author:      Christian Schaefer
   6  * Modified by: Goetz Lindenmaier
   7  * Created:
   8  * CVS-ID:      $Id$
   9  * Copyright:   (c) 1998-2003 Universität Karlsruhe
  10  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include "config.h"
  15 #endif
  16
  17 #ifdef HAVE_STRING_H
  18 # include <string.h>
  19 #endif
  20
  21 # include "irop_t.h"
  22 # include "irnode_t.h"
  23 # include "irhooks.h"
  24
  25 # include "iropt_t.h"             /* for firm_set_default_operations */
  26 # include "irvrfy_t.h"
  27
  28 # include "xmalloc.h"
  29
  30 /** the available next opcode */
  31 static unsigned next_iro = iro_MaxOpcode;
  32
  33 ir_op *op_Block;       ir_op *get_op_Block     (void) { return op_Block;     }
  34
  35 ir_op *op_Start;       ir_op *get_op_Start     (void) { return op_Start;     }
  36 ir_op *op_End;         ir_op *get_op_End       (void) { return op_End;       }
  37 ir_op *op_Jmp;         ir_op *get_op_Jmp       (void) { return op_Jmp;       }
  38 ir_op *op_IJmp;        ir_op *get_op_IJmp      (void) { return op_IJmp;      }
  39 ir_op *op_Cond;        ir_op *get_op_Cond      (void) { return op_Cond;      }
  40 ir_op *op_Return;      ir_op *get_op_Return    (void) { return op_Return;    }
  41 ir_op *op_Raise;       ir_op *get_op_Raise     (void) { return op_Raise;     }
  42
  43 ir_op *op_Sel;         ir_op *get_op_Sel       (void) { return op_Sel;       }
  44 ir_op *op_InstOf;      ir_op *get_op_InstOf    (void) { return op_InstOf;    }
  45
  46 ir_op *op_Const;       ir_op *get_op_Const     (void) { return op_Const;     }
  47 ir_op *op_SymConst;    ir_op *get_op_SymConst  (void) { return op_SymConst;  }
  48
  49 ir_op *op_Call;        ir_op *get_op_Call      (void) { return op_Call;      }
  50 ir_op *op_Add;         ir_op *get_op_Add       (void) { return op_Add;       }
  51 ir_op *op_Sub;         ir_op *get_op_Sub       (void) { return op_Sub;       }
  52 ir_op *op_Minus;       ir_op *get_op_Minus     (void) { return op_Minus;     }
  53 ir_op *op_Mul;         ir_op *get_op_Mul       (void) { return op_Mul;       }
  54 ir_op *op_Quot;        ir_op *get_op_Quot      (void) { return op_Quot;      }
  55 ir_op *op_DivMod;      ir_op *get_op_DivMod    (void) { return op_DivMod;    }
  56 ir_op *op_Div;         ir_op *get_op_Div       (void) { return op_Div;       }
  57 ir_op *op_Mod;         ir_op *get_op_Mod       (void) { return op_Mod;       }
  58 ir_op *op_Abs;         ir_op *get_op_Abs       (void) { return op_Abs;       }
  59 ir_op *op_And;         ir_op *get_op_And       (void) { return op_And;       }
  60 ir_op *op_Or;          ir_op *get_op_Or        (void) { return op_Or;        }
  61 ir_op *op_Eor;         ir_op *get_op_Eor       (void) { return op_Eor;       }
  62 ir_op *op_Not;         ir_op *get_op_Not       (void) { return op_Not;       }
  63 ir_op *op_Cmp;         ir_op *get_op_Cmp       (void) { return op_Cmp;       }
  64 ir_op *op_Shl;         ir_op *get_op_Shl       (void) { return op_Shl;       }
  65 ir_op *op_Shr;         ir_op *get_op_Shr       (void) { return op_Shr;       }
  66 ir_op *op_Shrs;        ir_op *get_op_Shrs      (void) { return op_Shrs;      }
  67 ir_op *op_Rot;         ir_op *get_op_Rot       (void) { return op_Rot;       }
  68 ir_op *op_Conv;        ir_op *get_op_Conv      (void) { return op_Conv;      }
  69 ir_op *op_Cast;        ir_op *get_op_Cast      (void) { return op_Cast;      }
  70
  71 ir_op *op_Phi;         ir_op *get_op_Phi       (void) { return op_Phi;       }
  72
  73 ir_op *op_Load;        ir_op *get_op_Load      (void) { return op_Load;      }
  74 ir_op *op_Store;       ir_op *get_op_Store     (void) { return op_Store;     }
  75 ir_op *op_Alloc;       ir_op *get_op_Alloc     (void) { return op_Alloc;     }
  76 ir_op *op_Free;        ir_op *get_op_Free      (void) { return op_Free;      }
  77 ir_op *op_Sync;        ir_op *get_op_Sync      (void) { return op_Sync;      }
  78
  79 ir_op *op_Tuple;       ir_op *get_op_Tuple     (void) { return op_Tuple;     }
  80 ir_op *op_Proj;        ir_op *get_op_Proj      (void) { return op_Proj;      }
  81 ir_op *op_Id;          ir_op *get_op_Id        (void) { return op_Id;        }
  82 ir_op *op_Bad;         ir_op *get_op_Bad       (void) { return op_Bad;       }
  83 ir_op *op_Confirm;     ir_op *get_op_Confirm   (void) { return op_Confirm;   }
  84
  85 ir_op *op_Unknown;     ir_op *get_op_Unknown   (void) { return op_Unknown;   }
  86 ir_op *op_Filter;      ir_op *get_op_Filter    (void) { return op_Filter;    }
  87 ir_op *op_Break;       ir_op *get_op_Break     (void) { return op_Break;     }
  88 ir_op *op_CallBegin;   ir_op *get_op_CallBegin (void) { return op_CallBegin; }
  89 ir_op *op_EndReg;      ir_op *get_op_EndReg    (void) { return op_EndReg;    }
  90 ir_op *op_EndExcept;   ir_op *get_op_EndExcept (void) { return op_EndExcept; }
  91
  92 ir_op *op_NoMem;       ir_op *get_op_NoMem     (void) { return op_NoMem; }
  93 ir_op *op_Mux;         ir_op *get_op_Mux       (void) { return op_Mux; }
  94
  95
  96 /*
  97  * Copies all attributes stored in the old node to the new node.
  98  * Assumes both have the same opcode and sufficient size.
  99  */
 100 void default_copy_attr(const ir_node *old_node, ir_node *new_node) {
 101   unsigned size = firm_add_node_size;
 102
 103   assert(get_irn_op(old_node) == get_irn_op(new_node));
 104   memcpy(&new_node->attr, &old_node->attr, get_op_attr_size(get_irn_op(old_node)));
 105
 106   if (size > 0) {
 107     /* copy additional node data */
 108     memcpy(get_irn_data(new_node, void, size), get_irn_data(old_node, void, size), size);
 109   }
 110 }
 111
 112 /**
 113  * Copies all attributes stored in the old node to the new node.
 114  * Assumes both have the same opcode and sufficient size.
 115  */
 116 static void
 117 call_copy_attr(const ir_node *old_node, ir_node *new_node) {
 118   default_copy_attr(old_node, new_node);
 119
 120   remove_Call_callee_arr(new_node);
 121 }
 122
 123 static void
 124 block_copy_attr(const ir_node *old_node, ir_node *new_node)
 125 {
 126   default_copy_attr(old_node, new_node);
 127   INIT_LIST_HEAD(&new_node->attr.block.succ_head);
 128 }
 129
 130 /**
 131  * Sets the copy_attr operation for an ir_op
 132  */
 133 static ir_op *firm_set_default_copy_attr(ir_op *op) {
 134   if (op->code == iro_Call)
 135     op->copy_attr = call_copy_attr;
 136   else if (op->code == iro_Block)
 137     op->copy_attr = block_copy_attr;
 138   else
 139     op->copy_attr = default_copy_attr;
 140
 141   return op;
 142 }
 143
 144 ir_op *
 145 new_ir_op(opcode code, const char *name, op_pin_state p, unsigned flags, op_arity opar, int op_index, size_t attr_size)
 146 {
 147   ir_op *res;
 148
 149   res = (ir_op *)xmalloc(sizeof(*res));
 150   memset(res, 0, sizeof(*res));
 151
 152   res->code      = code;
 153   res->name      = new_id_from_chars(name, strlen(name));
 154   res->op_pin_state_pinned = p;
 155   res->attr_size = attr_size;
 156   res->flags     = flags;
 157   res->opar      = opar;
 158   res->op_index  = op_index;
 159
 160   firm_set_default_operations(res);
 161   firm_set_default_copy_attr(res);
 162   firm_set_default_verifyer(res);
 163
 164   hook_new_ir_op(res);
 165   return res;
 166 }
 167
 168 void free_ir_op(ir_op *code) {
 169   hook_free_ir_op(code);
 170   free(code);
 171 }
 172
 173 void
 174 init_op(void)
 175 {
 176 #define N   irop_flag_none
 177 #define L   irop_flag_labeled
 178 #define C   irop_flag_commutative
 179 #define X   irop_flag_cfopcode
 180 #define I   irop_flag_ip_cfopcode
 181 #define F   irop_flag_fragile
 182 #define Y   irop_flag_forking
 183 #define H   irop_flag_highlevel
 184 #define c   irop_flag_constlike
 185
 186   op_Block     = new_ir_op(iro_Block,     "Block",     op_pin_state_pinned, L,       oparity_variable, -1, sizeof(block_attr));
 187
 188   op_Start     = new_ir_op(iro_Start,     "Start",     op_pin_state_pinned, X,       oparity_zero,     -1, sizeof(start_attr));
 189   op_End       = new_ir_op(iro_End,       "End",       op_pin_state_pinned, X,       oparity_dynamic,  -1, 0);
 190   op_Jmp       = new_ir_op(iro_Jmp,       "Jmp",       op_pin_state_pinned, X,       oparity_zero,     -1, 0);
 191   op_IJmp      = new_ir_op(iro_IJmp,      "IJmp",      op_pin_state_pinned, X,       oparity_unary,    -1, 0);
 192   op_Cond      = new_ir_op(iro_Cond,      "Cond",      op_pin_state_pinned, L|X|Y,   oparity_any,      -1, sizeof(cond_attr));
 193   op_Return    = new_ir_op(iro_Return,    "Return",    op_pin_state_pinned, L|X,     oparity_zero,     -1, 0);
 194   op_Raise     = new_ir_op(iro_Raise,     "Raise",     op_pin_state_pinned, L|X,     oparity_any,      -1, 0);
 195
 196   op_Const     = new_ir_op(iro_Const,     "Const",     op_pin_state_floats, c,       oparity_zero,     -1, sizeof(const_attr));
 197   op_SymConst  = new_ir_op(iro_SymConst,  "SymConst",  op_pin_state_floats, c,       oparity_zero,     -1, sizeof(symconst_attr));
 198
 199   op_Sel       = new_ir_op(iro_Sel,       "Sel",       op_pin_state_floats, L,       oparity_any,      -1, sizeof(sel_attr));
 200   op_InstOf    = new_ir_op(iro_InstOf,    "InstOf",    op_pin_state_floats, L,       oparity_any,      -1, sizeof(sel_attr));
 201
 202   op_Call      = new_ir_op(iro_Call,      "Call",      op_pin_state_mem_pinned, L|F, oparity_variable, -1, sizeof(call_attr));
 203   op_Add       = new_ir_op(iro_Add,       "Add",       op_pin_state_floats, C,       oparity_binary,    0, 0);
 204   op_Minus     = new_ir_op(iro_Minus,     "Minus",     op_pin_state_floats, N,       oparity_unary,     0, 0);
 205   op_Sub       = new_ir_op(iro_Sub,       "Sub",       op_pin_state_floats, L,       oparity_binary,    0, 0);
 206   op_Mul       = new_ir_op(iro_Mul,       "Mul",       op_pin_state_floats, C,       oparity_binary,    0, 0);
 207   op_Quot      = new_ir_op(iro_Quot,      "Quot",      op_pin_state_exc_pinned, L|F, oparity_binary,    1, sizeof(except_attr));
 208   op_DivMod    = new_ir_op(iro_DivMod,    "DivMod",    op_pin_state_exc_pinned, L|F, oparity_binary,    1, sizeof(except_attr));
 209   op_Div       = new_ir_op(iro_Div,       "Div",       op_pin_state_exc_pinned, L|F, oparity_binary,    1, sizeof(except_attr));
 210   op_Mod       = new_ir_op(iro_Mod,       "Mod",       op_pin_state_exc_pinned, L|F, oparity_binary,    1, sizeof(except_attr));
 211   op_Abs       = new_ir_op(iro_Abs,       "Abs",       op_pin_state_floats, N,       oparity_unary,     0, 0);
 212   op_And       = new_ir_op(iro_And,       "And",       op_pin_state_floats, C,       oparity_binary,    0, 0);
 213   op_Or        = new_ir_op(iro_Or,        "Or",        op_pin_state_floats, C,       oparity_binary,    0, 0);
 214   op_Eor       = new_ir_op(iro_Eor,       "Eor",       op_pin_state_floats, C,       oparity_binary,    0, 0);
 215   op_Not       = new_ir_op(iro_Not,       "Not",       op_pin_state_floats, N,       oparity_unary,     0, 0);
 216   op_Cmp       = new_ir_op(iro_Cmp,       "Cmp",       op_pin_state_floats, L,       oparity_binary,    0, 0);
 217   op_Shl       = new_ir_op(iro_Shl,       "Shl",       op_pin_state_floats, L,       oparity_binary,    0, 0);
 218   op_Shr       = new_ir_op(iro_Shr,       "Shr",       op_pin_state_floats, L,       oparity_binary,    0, 0);
 219   op_Shrs      = new_ir_op(iro_Shrs,      "Shrs",      op_pin_state_floats, L,       oparity_binary,    0, 0);
 220   op_Rot       = new_ir_op(iro_Rot,       "Rot",       op_pin_state_floats, L,       oparity_binary,    0, 0);
 221   op_Conv      = new_ir_op(iro_Conv,      "Conv",      op_pin_state_floats, N,       oparity_unary,     0, 0);
 222   op_Cast      = new_ir_op(iro_Cast,      "Cast",      op_pin_state_floats, N|H,     oparity_unary,     0, sizeof(cast_attr));
 223
 224   op_Phi       = new_ir_op(iro_Phi,       "Phi",       op_pin_state_pinned, L,       oparity_variable, -1, sizeof(int));
 225
 226   op_Load      = new_ir_op(iro_Load,      "Load",      op_pin_state_exc_pinned, L|F, oparity_any,      -1, sizeof(load_attr));
 227   op_Store     = new_ir_op(iro_Store,     "Store",     op_pin_state_exc_pinned, L|F, oparity_any,      -1, sizeof(store_attr));
 228   op_Alloc     = new_ir_op(iro_Alloc,     "Alloc",     op_pin_state_pinned, L|F,     oparity_any,      -1, sizeof(alloc_attr));
 229   op_Free      = new_ir_op(iro_Free,      "Free",      op_pin_state_pinned, L,       oparity_any,      -1, sizeof(free_attr));
 230   op_Sync      = new_ir_op(iro_Sync,      "Sync",      op_pin_state_pinned, N,       oparity_any,      -1, 0);
 231
 232   op_Proj      = new_ir_op(iro_Proj,      "Proj",      op_pin_state_floats, N,       oparity_any,      -1, sizeof(long));
 233   op_Tuple     = new_ir_op(iro_Tuple,     "Tuple",     op_pin_state_floats, L,       oparity_variable, -1, 0);
 234   op_Id        = new_ir_op(iro_Id,        "Id",        op_pin_state_floats, N,       oparity_any,      -1, 0);
 235   op_Bad       = new_ir_op(iro_Bad,       "Bad",       op_pin_state_pinned, X|F,     oparity_zero,     -1, 0);
 236   op_Confirm   = new_ir_op(iro_Confirm,   "Confirm",   op_pin_state_floats, L|H,     oparity_any,      -1, sizeof(confirm_attr));
 237
 238   op_Unknown   = new_ir_op(iro_Unknown,   "Unknown",   op_pin_state_pinned, X|F,     oparity_zero,     -1, 0);
 239   op_Filter    = new_ir_op(iro_Filter,    "Filter",    op_pin_state_pinned, L,       oparity_variable, -1, sizeof(filter_attr));
 240   op_Break     = new_ir_op(iro_Break,     "Break",     op_pin_state_pinned, X,       oparity_zero,     -1, 0);
 241   op_CallBegin = new_ir_op(iro_CallBegin, "CallBegin", op_pin_state_pinned, X|I,     oparity_any,      -1, sizeof(callbegin_attr));
 242   op_EndReg    = new_ir_op(iro_EndReg,    "EndReg",    op_pin_state_pinned, X|I,     oparity_any,      -1, sizeof(end_attr));
 243   op_EndExcept = new_ir_op(iro_EndExcept, "EndExcept", op_pin_state_pinned, X|I,     oparity_any,      -1, sizeof(end_attr));
 244
 245   op_NoMem     = new_ir_op(iro_NoMem,     "NoMem",     op_pin_state_pinned, N,       oparity_zero,     -1, 0);
 246   op_Mux       = new_ir_op(iro_Mux,       "Mux",       op_pin_state_floats, N,       oparity_trinary,  -1, 0);
 247
 248 #undef H
 249 #undef Y
 250 #undef F
 251 #undef I
 252 #undef X
 253 #undef C
 254 #undef L
 255 }
 256
 257
 258 /* free memory used by irop module. */
 259 void finish_op(void) {
 260   free_ir_op (op_Block    ); op_Block     = NULL;
 261
 262   free_ir_op (op_Start    ); op_Start     = NULL;
 263   free_ir_op (op_End      ); op_End       = NULL;
 264   free_ir_op (op_Jmp      ); op_Jmp       = NULL;
 265   free_ir_op (op_Cond     ); op_Cond      = NULL;
 266   free_ir_op (op_Return   ); op_Return    = NULL;
 267   free_ir_op (op_Raise    ); op_Raise     = NULL;
 268
 269   free_ir_op (op_Const    ); op_Const     = NULL;
 270   free_ir_op (op_SymConst ); op_SymConst  = NULL;
 271
 272   free_ir_op (op_Sel      ); op_Sel       = NULL;
 273   free_ir_op (op_InstOf   ); op_InstOf    = NULL;
 274
 275   free_ir_op (op_Call     ); op_Call      = NULL;
 276   free_ir_op (op_Add      ); op_Add       = NULL;
 277   free_ir_op (op_Minus    ); op_Minus     = NULL;
 278   free_ir_op (op_Sub      ); op_Sub       = NULL;
 279   free_ir_op (op_Mul      ); op_Mul       = NULL;
 280   free_ir_op (op_Quot     ); op_Quot      = NULL;
 281   free_ir_op (op_DivMod   ); op_DivMod    = NULL;
 282   free_ir_op (op_Div      ); op_Div       = NULL;
 283   free_ir_op (op_Mod      ); op_Mod       = NULL;
 284   free_ir_op (op_Abs      ); op_Abs       = NULL;
 285   free_ir_op (op_And      ); op_And       = NULL;
 286   free_ir_op (op_Or       ); op_Or        = NULL;
 287   free_ir_op (op_Eor      ); op_Eor       = NULL;
 288   free_ir_op (op_Not      ); op_Not       = NULL;
 289   free_ir_op (op_Cmp      ); op_Cmp       = NULL;
 290   free_ir_op (op_Shl      ); op_Shl       = NULL;
 291   free_ir_op (op_Shr      ); op_Shr       = NULL;
 292   free_ir_op (op_Shrs     ); op_Shrs      = NULL;
 293   free_ir_op (op_Rot      ); op_Rot       = NULL;
 294   free_ir_op (op_Conv     ); op_Conv      = NULL;
 295   free_ir_op (op_Cast     ); op_Cast      = NULL;
 296
 297   free_ir_op (op_Phi      ); op_Phi       = NULL;
 298
 299   free_ir_op (op_Load     ); op_Load      = NULL;
 300   free_ir_op (op_Store    ); op_Store     = NULL;
 301   free_ir_op (op_Alloc    ); op_Alloc     = NULL;
 302   free_ir_op (op_Free     ); op_Free      = NULL;
 303   free_ir_op (op_Sync     ); op_Sync      = NULL;
 304
 305   free_ir_op (op_Proj     ); op_Proj      = NULL;
 306   free_ir_op (op_Tuple    ); op_Tuple     = NULL;
 307   free_ir_op (op_Id       ); op_Id        = NULL;
 308   free_ir_op (op_Bad      ); op_Bad       = NULL;
 309   free_ir_op (op_Confirm  ); op_Confirm   = NULL;
 310
 311   free_ir_op (op_Unknown  ); op_Unknown   = NULL;
 312   free_ir_op (op_Filter   ); op_Filter    = NULL;
 313   free_ir_op (op_Break    ); op_Break     = NULL;
 314   free_ir_op (op_CallBegin); op_CallBegin = NULL;
 315   free_ir_op (op_EndReg   ); op_EndReg    = NULL;
 316   free_ir_op (op_EndExcept); op_EndExcept = NULL;
 317
 318   free_ir_op (op_NoMem    ); op_NoMem     = NULL;
 319   free_ir_op (op_Mux      ); op_Mux       = NULL;
 320 }
 321
 322 /* Returns the string for the opcode. */
 323 const char *get_op_name (const ir_op *op) {
 324   return get_id_str(op->name);
 325 }
 326
 327 opcode (get_op_code)(const ir_op *op){
 328   return _get_op_code(op);
 329 }
 330
 331 ident *(get_op_ident)(const ir_op *op){
 332   return _get_op_ident(op);
 333 }
 334
 335 const char *get_op_pin_state_name(op_pin_state s) {
 336   switch(s) {
 337 #define XXX(s) case s: return #s
 338   XXX(op_pin_state_floats);
 339   XXX(op_pin_state_pinned);
 340   XXX(op_pin_state_exc_pinned);
 341   XXX(op_pin_state_mem_pinned);
 342 #undef XXX
 343   }
 344         return "<none>";
 345 }
 346
 347 op_pin_state (get_op_pinned)(const ir_op *op) {
 348   return _get_op_pinned(op);
 349 }
 350
 351 /* Sets op_pin_state_pinned in the opcode.  Setting it to floating has no effect
 352    for Phi, Block and control flow nodes. */
 353 void      set_op_pinned(ir_op *op, op_pin_state op_pin_state_pinned) {
 354   if (op == op_Block || op == op_Phi || is_cfopcode(op)) return;
 355   op->op_pin_state_pinned = op_pin_state_pinned;
 356 }
 357
 358 /* retrieve the next free opcode */
 359 unsigned get_next_ir_opcode(void) {
 360   return next_iro++;
 361 }
 362
 363 /* Returns the generic function pointer from an ir operation. */
 364 op_func (get_generic_function_ptr)(const ir_op *op) {
 365   return _get_generic_function_ptr(op);
 366 }
 367
 368 /* Store a generic function pointer into an ir operation. */
 369 void (set_generic_function_ptr)(ir_op *op, op_func func) {
 370   _set_generic_function_ptr(op, func);
 371 }