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

   1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
   2 ** All rights reserved.
   3 **
   4 ** Authors: Christian Schaefer
   5 **
   6 */
   7
   8 /* $Id$ */
   9
  10 #ifdef HAVE_CONFIG_H
  11 # include <config.h>
  12 #endif
  13
  14 # include "irop_t.h"
  15 # include "irnode_t.h"
  16 # include "misc.h"
  17
  18 ir_op *op_Block;
  19
  20 ir_op *op_Start;
  21 ir_op *op_End;
  22 ir_op *op_Jmp;
  23 ir_op *op_Cond;
  24 ir_op *op_Return;
  25 ir_op *op_Raise;
  26
  27 ir_op *op_Sel;
  28
  29 ir_op *op_Const;
  30 ir_op *op_SymConst;
  31
  32 ir_op *op_Call;
  33 ir_op *op_Add;
  34 ir_op *op_Sub;
  35 ir_op *op_Minus;
  36 ir_op *op_Mul;
  37 ir_op *op_Quot;
  38 ir_op *op_DivMod;
  39 ir_op *op_Div;
  40 ir_op *op_Mod;
  41 ir_op *op_Abs;
  42 ir_op *op_And;
  43 ir_op *op_Or;
  44 ir_op *op_Eor;
  45 ir_op *op_Not;
  46 ir_op *op_Cmp;
  47 ir_op *op_Shl;
  48 ir_op *op_Shr;
  49 ir_op *op_Shrs;
  50 ir_op *op_Rot;
  51 ir_op *op_Conv;
  52
  53 ir_op *op_Phi;
  54
  55 ir_op *op_Load;
  56 ir_op *op_Store;
  57 ir_op *op_Alloc;
  58 ir_op *op_Free;
  59 ir_op *op_Sync;
  60
  61 ir_op *op_Tuple;
  62 ir_op *op_Proj;
  63 ir_op *op_Id;
  64 ir_op *op_Bad;
  65
  66
  67 ir_op *
  68 new_ir_op (opcode code, char *name, op_pinned p, int labeled, size_t attr_size)
  69 {
  70   ir_op *res;
  71
  72   res = (ir_op *) xmalloc (sizeof (ir_op));
  73   res->code = code;
  74   res->name = id_from_str(name, strlen(name));
  75   res->pinned = p;
  76   res->attr_size = attr_size;
  77   res->labeled = labeled;   /* For vcg dumping.
  78                                Set labeled = 1 if the edges should be
  79                                enumarated in vcg output, otherwise set
  80                                labeled = 0. */
  81   return res;
  82 }
  83
  84
  85 void
  86 init_op(void)
  87 {
  88   op_Block = new_ir_op (iro_Block, "Block",  pinned, 1, sizeof (block_attr));
  89
  90   op_Start = new_ir_op (iro_Start, "Start",  pinned, 0, 0);
  91   op_End   = new_ir_op (iro_End,   "End",    pinned, 0, 0);
  92   op_Jmp   = new_ir_op (iro_Jmp,   "Jmp",    pinned, 0, 0);
  93   op_Cond  = new_ir_op (iro_Cond,  "Cond",   pinned, 1, sizeof(cond_attr));
  94   op_Return= new_ir_op (iro_Return,"Return", pinned, 1, 0);
  95   op_Raise = new_ir_op (iro_Raise, "Raise",  pinned, 1, 0);
  96
  97   op_Const = new_ir_op (iro_Const, "Const",  floats, 0, sizeof (struct tarval *));
  98   op_SymConst = new_ir_op (iro_SymConst, "SymConst",
  99                                              floats, 0, sizeof (symconst_attr));
 100
 101   op_Sel   = new_ir_op (iro_Sel,   "Sel",    floats, 1, sizeof (sel_attr));
 102
 103   op_Call  = new_ir_op (iro_Call,  "Call",   pinned, 1, sizeof (call_attr));
 104   op_Add   = new_ir_op (iro_Add,   "Add",    floats, 0, 0);
 105   op_Minus = new_ir_op (iro_Minus, "Minus",  floats, 0, 0);
 106   op_Sub   = new_ir_op (iro_Sub,   "Sub",    floats, 1, 0);
 107   op_Mul   = new_ir_op (iro_Mul,   "Mul",    floats, 0, 0);
 108   op_Quot  = new_ir_op (iro_Quot,  "Quot",   pinned, 1, sizeof(struct irnode **));
 109   op_DivMod= new_ir_op (iro_DivMod,"DivMod", pinned, 1, sizeof(struct irnode **));
 110   op_Div   = new_ir_op (iro_Div,   "Div",    pinned, 1, sizeof(struct irnode **));
 111   op_Mod   = new_ir_op (iro_Mod,   "Mod",    pinned, 1, sizeof(struct irnode **));
 112   op_Abs   = new_ir_op (iro_Abs,   "Abs",    floats, 0, 0);
 113   op_And   = new_ir_op (iro_And,   "And",    floats, 0, 0);
 114   op_Or    = new_ir_op (iro_Or,    "Or",     floats, 0, 0);
 115   op_Eor   = new_ir_op (iro_Eor,   "Eor",    floats, 0, 0);
 116   op_Not   = new_ir_op (iro_Not,   "Not",    floats, 0, 0);
 117   op_Cmp   = new_ir_op (iro_Cmp,   "Cmp",    floats, 1, 0);
 118   op_Shl   = new_ir_op (iro_Shl,   "Shl",    floats, 1, 0);
 119   op_Shr   = new_ir_op (iro_Shr,   "Shr",    floats, 1, 0);
 120   op_Shrs  = new_ir_op (iro_Shrs,  "Shrs",   floats, 1, 0);
 121   op_Rot   = new_ir_op (iro_Rot,   "Rot",    floats, 1, 0);
 122   op_Conv  = new_ir_op (iro_Conv,  "Conv",   floats, 0, 0);
 123
 124   op_Phi   = new_ir_op (iro_Phi,   "Phi",    pinned, 1, sizeof (int));
 125
 126   op_Load  = new_ir_op (iro_Load,  "Load",   pinned, 1, sizeof(struct irnode **));
 127   op_Store = new_ir_op (iro_Store, "Store",  pinned, 1, sizeof(struct irnode **));
 128   op_Alloc = new_ir_op (iro_Alloc, "Alloc",  pinned, 1, sizeof (alloc_attr));
 129   op_Free  = new_ir_op (iro_Free,  "Free",   pinned, 1, sizeof (type *));
 130   op_Sync  = new_ir_op (iro_Sync,  "Sync",   pinned, 0, 0);
 131
 132   op_Proj  = new_ir_op (iro_Proj,  "Proj",   floats, 0, sizeof (long));
 133   op_Tuple = new_ir_op (iro_Tuple, "Tuple",  floats, 1, 0);
 134   op_Id    = new_ir_op (iro_Id,    "Id",     floats, 0, 0);
 135   op_Bad   = new_ir_op (iro_Bad,   "Bad",    floats, 0, 0);
 136 }
 137
 138 /* Returns the string for the opcode. */
 139 const char  *get_op_name      (ir_op *op) {
 140   return id_to_str(op->name);
 141 }
 142
 143 opcode get_op_code (ir_op *op){
 144   return op->code;
 145 }
 146
 147 ident *get_op_ident(ir_op *op){
 148   return op->name;
 149 }
 150
 151 op_pinned get_op_pinned (ir_op *op){
 152   return op->pinned;
 153 }
 154
 155 /* Sets pinned in the opcode.  Setting it to floating has no effect
 156    for Phi, Block and control flow nodes. */
 157 void      set_op_pinned(ir_op *op, op_pinned pinned) {
 158   if (op == op_Block || op == op_Phi || is_cfopcode(op)) return;
 159   op->pinned = pinned;
 160 }
 161
 162
 163 /* returns the attribute size of the operator. */
 164 int get_op_attr_size (ir_op *op) {
 165   return op->attr_size;
 166 }
 167
 168 int is_cfopcode(ir_op *op) {
 169   return ((op == op_Start)
 170           || (op == op_Jmp)
 171           || (op == op_Cond)
 172           || (op == op_Return)
 173           || (op == op_Raise)
 174           || (op == op_Bad)
 175           || (op == op_End));
 176 }