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 # include <string.h>
  18
  19 # include "irop_t.h"
  20 # include "irnode_t.h"
  21 # include "firmstat.h"
  22
  23 # include "xmalloc.h"
  24
  25 ir_op *op_Block;           ir_op *get_op_Block     (void) { return op_Block;     }
  26
  27 ir_op *op_Start;           ir_op *get_op_Start     (void) { return op_Start;     }
  28 ir_op *op_End;             ir_op *get_op_End       (void) { return op_End;       }
  29 ir_op *op_Jmp;             ir_op *get_op_Jmp       (void) { return op_Jmp;       }
  30 ir_op *op_Cond;            ir_op *get_op_Cond      (void) { return op_Cond;      }
  31 ir_op *op_Return;          ir_op *get_op_Return    (void) { return op_Return;    }
  32 ir_op *op_Raise;           ir_op *get_op_Raise     (void) { return op_Raise;     }
  33
  34 ir_op *op_Sel;             ir_op *get_op_Sel       (void) { return op_Sel;       }
  35 ir_op *op_InstOf;          ir_op *get_op_InstOf    (void) { return op_InstOf;    }
  36
  37 ir_op *op_Const;           ir_op *get_op_Const     (void) { return op_Const;     }
  38 ir_op *op_SymConst;        ir_op *get_op_SymConst  (void) { return op_SymConst;  }
  39
  40 ir_op *op_Call;            ir_op *get_op_Call      (void) { return op_Call;      }
  41 ir_op *op_Add;             ir_op *get_op_Add       (void) { return op_Add;       }
  42 ir_op *op_Sub;             ir_op *get_op_Sub       (void) { return op_Sub;       }
  43 ir_op *op_Minus;           ir_op *get_op_Minus     (void) { return op_Minus;     }
  44 ir_op *op_Mul;             ir_op *get_op_Mul       (void) { return op_Mul;       }
  45 ir_op *op_Quot;            ir_op *get_op_Quot      (void) { return op_Quot;      }
  46 ir_op *op_DivMod;          ir_op *get_op_DivMod    (void) { return op_DivMod;    }
  47 ir_op *op_Div;             ir_op *get_op_Div       (void) { return op_Div;       }
  48 ir_op *op_Mod;             ir_op *get_op_Mod       (void) { return op_Mod;       }
  49 ir_op *op_Abs;             ir_op *get_op_Abs       (void) { return op_Abs;       }
  50 ir_op *op_And;             ir_op *get_op_And       (void) { return op_And;       }
  51 ir_op *op_Or;              ir_op *get_op_Or        (void) { return op_Or;        }
  52 ir_op *op_Eor;             ir_op *get_op_Eor       (void) { return op_Eor;       }
  53 ir_op *op_Not;             ir_op *get_op_Not       (void) { return op_Not;       }
  54 ir_op *op_Cmp;             ir_op *get_op_Cmp       (void) { return op_Cmp;       }
  55 ir_op *op_Shl;             ir_op *get_op_Shl       (void) { return op_Shl;       }
  56 ir_op *op_Shr;             ir_op *get_op_Shr       (void) { return op_Shr;       }
  57 ir_op *op_Shrs;            ir_op *get_op_Shrs      (void) { return op_Shrs;      }
  58 ir_op *op_Rot;             ir_op *get_op_Rot       (void) { return op_Rot;       }
  59 ir_op *op_Conv;            ir_op *get_op_Conv      (void) { return op_Conv;      }
  60 ir_op *op_Cast;            ir_op *get_op_Cast      (void) { return op_Cast;      }
  61
  62 ir_op *op_Phi;             ir_op *get_op_Phi       (void) { return op_Phi;       }
  63
  64 ir_op *op_Load;            ir_op *get_op_Load      (void) { return op_Load;      }
  65 ir_op *op_Store;           ir_op *get_op_Store     (void) { return op_Store;     }
  66 ir_op *op_Alloc;           ir_op *get_op_Alloc     (void) { return op_Alloc;     }
  67 ir_op *op_Free;            ir_op *get_op_Free      (void) { return op_Free;      }
  68 ir_op *op_Sync;            ir_op *get_op_Sync      (void) { return op_Sync;      }
  69
  70 ir_op *op_Tuple;           ir_op *get_op_Tuple     (void) { return op_Tuple;     }
  71 ir_op *op_Proj;            ir_op *get_op_Proj      (void) { return op_Proj;      }
  72 ir_op *op_Id;              ir_op *get_op_Id        (void) { return op_Id;        }
  73 ir_op *op_Bad;             ir_op *get_op_Bad       (void) { return op_Bad;       }
  74 ir_op *op_Confirm;         ir_op *get_op_Confirm   (void) { return op_Confirm;   }
  75
  76 ir_op *op_Unknown;         ir_op *get_op_Unknown   (void) { return op_Unknown;   }
  77 ir_op *op_Filter;          ir_op *get_op_Filter    (void) { return op_Filter;    }
  78 ir_op *op_Break;           ir_op *get_op_Break     (void) { return op_Break;     }
  79 ir_op *op_CallBegin;       ir_op *get_op_CallBegin (void) { return op_CallBegin; }
  80 ir_op *op_EndReg;          ir_op *get_op_EndReg    (void) { return op_EndReg;    }
  81 ir_op *op_EndExcept;       ir_op *get_op_EndExcept (void) { return op_EndExcept; }
  82
  83 ir_op *op_FuncCall;        ir_op *get_op_FuncCall  (void) { return op_FuncCall; }
  84
  85
  86 ir_op *
  87 new_ir_op(opcode code, const char *name, op_pinned p, unsigned flags, op_arity opar, int op_index, size_t attr_size)
  88 {
  89   ir_op *res;
  90
  91   res = (ir_op *) xmalloc (sizeof (ir_op));
  92   res->code      = code;
  93   res->name      = id_from_str(name, strlen(name));
  94   res->pinned    = p;
  95   res->attr_size = attr_size;
  96   res->flags     = flags;
  97   res->opar      = opar;
  98   res->op_index  = op_index;
  99
 100   firm_set_default_operations(res);
 101   stat_new_ir_op(res);
 102   return res;
 103 }
 104
 105 void free_ir_op(ir_op *code) {
 106   stat_free_ir_op(code);
 107   free(code);
 108 }
 109
 110 void
 111 init_op(void)
 112 {
 113 #define L       irop_flag_labeled
 114 #define C       irop_flag_commutative
 115 #define X       irop_flag_cfopcode
 116 #define I       irop_flag_ip_cfopcode
 117 #define F       irop_flag_fragile
 118
 119   op_Block     = new_ir_op(iro_Block,     "Block",     pinned, L,   oparity_variable, -1, sizeof(block_attr));
 120
 121   op_Start     = new_ir_op(iro_Start,     "Start",     pinned, X,   oparity_zero,     -1, sizeof(start_attr));
 122   op_End       = new_ir_op(iro_End,       "End",       pinned, X,   oparity_dynamic,  -1, 0);
 123   op_Jmp       = new_ir_op(iro_Jmp,       "Jmp",       pinned, X,   oparity_zero,     -1, 0);
 124   op_Cond      = new_ir_op(iro_Cond,      "Cond",      pinned, L|X, oparity_any,      -1, sizeof(cond_attr));
 125   op_Return    = new_ir_op(iro_Return,    "Return",    pinned, L|X, oparity_zero,     -1, 0);
 126   op_Raise     = new_ir_op(iro_Raise,     "Raise",     pinned, L|X, oparity_any,      -1, 0);
 127
 128   op_Const     = new_ir_op(iro_Const,     "Const",     floats, 0,   oparity_zero,     -1, sizeof(const_attr));
 129   op_SymConst  = new_ir_op(iro_SymConst,  "SymConst",  floats, 0,   oparity_zero,     -1, sizeof(symconst_attr));
 130
 131   op_Sel       = new_ir_op(iro_Sel,       "Sel",       floats, L,   oparity_any,      -1, sizeof(sel_attr));
 132   op_InstOf    = new_ir_op(iro_InstOf,    "InstOf",    floats, L,   oparity_any,      -1, sizeof(sel_attr));
 133
 134   op_Call      = new_ir_op(iro_Call,      "Call",      pinned, L|F, oparity_variable, -1, sizeof(call_attr));
 135   op_Add       = new_ir_op(iro_Add,       "Add",       floats, C,   oparity_binary,    0, 0);
 136   op_Minus     = new_ir_op(iro_Minus,     "Minus",     floats, 0,   oparity_unary,     0, 0);
 137   op_Sub       = new_ir_op(iro_Sub,       "Sub",       floats, L,   oparity_binary,    0, 0);
 138   op_Mul       = new_ir_op(iro_Mul,       "Mul",       floats, C,   oparity_binary,    0, 0);
 139   op_Quot      = new_ir_op(iro_Quot,      "Quot",      pinned, L|F, oparity_binary,    1, sizeof(struct irnode **));
 140   op_DivMod    = new_ir_op(iro_DivMod,    "DivMod",    pinned, L|F, oparity_binary,    1, sizeof(struct irnode **));
 141   op_Div       = new_ir_op(iro_Div,       "Div",       pinned, L|F, oparity_binary,    1, sizeof(struct irnode **));
 142   op_Mod       = new_ir_op(iro_Mod,       "Mod",       pinned, L|F, oparity_binary,    1, sizeof(struct irnode **));
 143   op_Abs       = new_ir_op(iro_Abs,       "Abs",       floats, 0,   oparity_unary,     0, 0);
 144   op_And       = new_ir_op(iro_And,       "And",       floats, C,   oparity_binary,    0, 0);
 145   op_Or        = new_ir_op(iro_Or,        "Or",        floats, C,   oparity_binary,    0, 0);
 146   op_Eor       = new_ir_op(iro_Eor,       "Eor",       floats, C,   oparity_binary,    0, 0);
 147   op_Not       = new_ir_op(iro_Not,       "Not",       floats, 0,   oparity_unary,     0, 0);
 148   op_Cmp       = new_ir_op(iro_Cmp,       "Cmp",       floats, L,   oparity_binary,    0, 0);
 149   op_Shl       = new_ir_op(iro_Shl,       "Shl",       floats, L,   oparity_binary,    0, 0);
 150   op_Shr       = new_ir_op(iro_Shr,       "Shr",       floats, L,   oparity_binary,    0, 0);
 151   op_Shrs      = new_ir_op(iro_Shrs,      "Shrs",      floats, L,   oparity_binary,    0, 0);
 152   op_Rot       = new_ir_op(iro_Rot,       "Rot",       floats, L,   oparity_binary,    0, 0);
 153   op_Conv      = new_ir_op(iro_Conv,      "Conv",      floats, 0,   oparity_unary,     0, 0);
 154   op_Cast      = new_ir_op(iro_Cast,      "Cast",      floats, 0,   oparity_unary,     0, sizeof(cast_attr));
 155
 156   op_Phi       = new_ir_op(iro_Phi,       "Phi",       pinned, L,   oparity_variable, -1, sizeof(int));
 157
 158   op_Load      = new_ir_op(iro_Load,      "Load",      pinned, L|F, oparity_any,      -1, sizeof(struct irnode **));
 159   op_Store     = new_ir_op(iro_Store,     "Store",     pinned, L|F, oparity_any,      -1, sizeof(struct irnode **));
 160   op_Alloc     = new_ir_op(iro_Alloc,     "Alloc",     pinned, L|F, oparity_any,      -1, sizeof(alloc_attr));
 161   op_Free      = new_ir_op(iro_Free,      "Free",      pinned, L,   oparity_any,      -1, sizeof(type *));
 162   op_Sync      = new_ir_op(iro_Sync,      "Sync",      pinned, 0,   oparity_any,      -1, 0);
 163
 164   op_Proj      = new_ir_op(iro_Proj,      "Proj",      floats, 0,   oparity_any,      -1, sizeof(long));
 165   op_Tuple     = new_ir_op(iro_Tuple,     "Tuple",     floats, L,   oparity_variable, -1, 0);
 166   op_Id        = new_ir_op(iro_Id,        "Id",        floats, 0,   oparity_any,      -1, 0);
 167   op_Bad       = new_ir_op(iro_Bad,       "Bad",       floats, X|F, oparity_zero,     -1, 0);
 168   op_Confirm   = new_ir_op(iro_Confirm,   "Confirm",   floats, L,   oparity_any,      -1, sizeof(confirm_attr));
 169
 170   op_Unknown   = new_ir_op(iro_Unknown,   "Unknown",   floats, X|F, oparity_zero,     -1, 0);
 171   op_Filter    = new_ir_op(iro_Filter,    "Filter",    pinned, L,   oparity_variable, -1, sizeof(filter_attr));
 172   op_Break     = new_ir_op(iro_Break,     "Break",     pinned, X,   oparity_zero,     -1, 0);
 173   op_CallBegin = new_ir_op(iro_CallBegin, "CallBegin", pinned, X|I, oparity_any,      -1, sizeof(callbegin_attr));
 174   op_EndReg    = new_ir_op(iro_EndReg,    "EndReg",    pinned, X|I, oparity_any,      -1, sizeof(end_attr));
 175   op_EndExcept = new_ir_op(iro_EndExcept, "EndExcept", pinned, X|I, oparity_any,      -1, sizeof(end_attr));
 176
 177   op_FuncCall  = new_ir_op(iro_FuncCall,  "FuncCall",  floats, L,   oparity_any,      -1, sizeof(call_attr));
 178
 179 #undef F
 180 #undef I
 181 #undef X
 182 #undef C
 183 #undef L
 184 }
 185
 186
 187 /* free memory used by irop module. */
 188 void finish_op(void) {
 189   free_ir_op (op_Block    ); op_Block     = NULL;
 190
 191   free_ir_op (op_Start    ); op_Start     = NULL;
 192   free_ir_op (op_End      ); op_End       = NULL;
 193   free_ir_op (op_Jmp      ); op_Jmp       = NULL;
 194   free_ir_op (op_Cond     ); op_Cond      = NULL;
 195   free_ir_op (op_Return   ); op_Return    = NULL;
 196   free_ir_op (op_Raise    ); op_Raise     = NULL;
 197
 198   free_ir_op (op_Const    ); op_Const     = NULL;
 199   free_ir_op (op_SymConst ); op_SymConst  = NULL;
 200
 201   free_ir_op (op_Sel      ); op_Sel       = NULL;
 202   free_ir_op (op_InstOf   ); op_InstOf    = NULL;
 203
 204   free_ir_op (op_Call     ); op_Call      = NULL;
 205   free_ir_op (op_Add      ); op_Add       = NULL;
 206   free_ir_op (op_Minus    ); op_Minus     = NULL;
 207   free_ir_op (op_Sub      ); op_Sub       = NULL;
 208   free_ir_op (op_Mul      ); op_Mul       = NULL;
 209   free_ir_op (op_Quot     ); op_Quot      = NULL;
 210   free_ir_op (op_DivMod   ); op_DivMod    = NULL;
 211   free_ir_op (op_Div      ); op_Div       = NULL;
 212   free_ir_op (op_Mod      ); op_Mod       = NULL;
 213   free_ir_op (op_Abs      ); op_Abs       = NULL;
 214   free_ir_op (op_And      ); op_And       = NULL;
 215   free_ir_op (op_Or       ); op_Or        = NULL;
 216   free_ir_op (op_Eor      ); op_Eor       = NULL;
 217   free_ir_op (op_Not      ); op_Not       = NULL;
 218   free_ir_op (op_Cmp      ); op_Cmp       = NULL;
 219   free_ir_op (op_Shl      ); op_Shl       = NULL;
 220   free_ir_op (op_Shr      ); op_Shr       = NULL;
 221   free_ir_op (op_Shrs     ); op_Shrs      = NULL;
 222   free_ir_op (op_Rot      ); op_Rot       = NULL;
 223   free_ir_op (op_Conv     ); op_Conv      = NULL;
 224   free_ir_op (op_Cast     ); op_Cast      = NULL;
 225
 226   free_ir_op (op_Phi      ); op_Phi       = NULL;
 227
 228   free_ir_op (op_Load     ); op_Load      = NULL;
 229   free_ir_op (op_Store    ); op_Store     = NULL;
 230   free_ir_op (op_Alloc    ); op_Alloc     = NULL;
 231   free_ir_op (op_Free     ); op_Free      = NULL;
 232   free_ir_op (op_Sync     ); op_Sync      = NULL;
 233
 234   free_ir_op (op_Proj     ); op_Proj      = NULL;
 235   free_ir_op (op_Tuple    ); op_Tuple     = NULL;
 236   free_ir_op (op_Id       ); op_Id        = NULL;
 237   free_ir_op (op_Bad      ); op_Bad       = NULL;
 238   free_ir_op (op_Confirm  ); op_Confirm   = NULL;
 239
 240   free_ir_op (op_Unknown  ); op_Unknown   = NULL;
 241   free_ir_op (op_Filter   ); op_Filter    = NULL;
 242   free_ir_op (op_Break    ); op_Break     = NULL;
 243   free_ir_op (op_CallBegin); op_CallBegin = NULL;
 244   free_ir_op (op_EndReg   ); op_EndReg    = NULL;
 245   free_ir_op (op_EndExcept); op_EndExcept = NULL;
 246
 247   free_ir_op (op_FuncCall ); op_FuncCall  = NULL;
 248 }
 249
 250 /* Returns the string for the opcode. */
 251 const char *get_op_name (const ir_op *op) {
 252   return get_id_str(op->name);
 253 }
 254
 255 opcode get_op_code (const ir_op *op){
 256   return op->code;
 257 }
 258
 259 ident *get_op_ident(ir_op *op){
 260   return op->name;
 261 }
 262
 263 op_pinned get_op_pinned (const ir_op *op){
 264   return op->pinned;
 265 }
 266
 267 /* Sets pinned in the opcode.  Setting it to floating has no effect
 268    for Phi, Block and control flow nodes. */
 269 void      set_op_pinned(ir_op *op, op_pinned pinned) {
 270   if (op == op_Block || op == op_Phi || is_cfopcode(op)) return;
 271   op->pinned = pinned;
 272 }