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
  22 # include "xmalloc.h"
  23
  24 ir_op *op_Block;           ir_op *get_op_Block     () { return op_Block;     }
  25
  26 ir_op *op_Start;           ir_op *get_op_Start     () { return op_Start;     }
  27 ir_op *op_End;             ir_op *get_op_End       () { return op_End;       }
  28 ir_op *op_Jmp;             ir_op *get_op_Jmp       () { return op_Jmp;       }
  29 ir_op *op_Cond;            ir_op *get_op_Cond      () { return op_Cond;      }
  30 ir_op *op_Return;          ir_op *get_op_Return    () { return op_Return;    }
  31 ir_op *op_Raise;           ir_op *get_op_Raise     () { return op_Raise;     }
  32
  33 ir_op *op_Sel;             ir_op *get_op_Sel       () { return op_Sel;       }
  34 ir_op *op_InstOf;          ir_op *get_op_InstOf    () { return op_InstOf;    }
  35
  36 ir_op *op_Const;           ir_op *get_op_Const     () { return op_Const;     }
  37 ir_op *op_SymConst;        ir_op *get_op_SymConst  () { return op_SymConst;  }
  38
  39 ir_op *op_Call;            ir_op *get_op_Call      () { return op_Call;      }
  40 ir_op *op_Add;             ir_op *get_op_Add       () { return op_Add;       }
  41 ir_op *op_Sub;             ir_op *get_op_Sub       () { return op_Sub;       }
  42 ir_op *op_Minus;           ir_op *get_op_Minus     () { return op_Minus;     }
  43 ir_op *op_Mul;             ir_op *get_op_Mul       () { return op_Mul;       }
  44 ir_op *op_Quot;            ir_op *get_op_Quot      () { return op_Quot;      }
  45 ir_op *op_DivMod;          ir_op *get_op_DivMod    () { return op_DivMod;    }
  46 ir_op *op_Div;             ir_op *get_op_Div       () { return op_Div;       }
  47 ir_op *op_Mod;             ir_op *get_op_Mod       () { return op_Mod;       }
  48 ir_op *op_Abs;             ir_op *get_op_Abs       () { return op_Abs;       }
  49 ir_op *op_And;             ir_op *get_op_And       () { return op_And;       }
  50 ir_op *op_Or;              ir_op *get_op_Or        () { return op_Or;        }
  51 ir_op *op_Eor;             ir_op *get_op_Eor       () { return op_Eor;       }
  52 ir_op *op_Not;             ir_op *get_op_Not       () { return op_Not;       }
  53 ir_op *op_Cmp;             ir_op *get_op_Cmp       () { return op_Cmp;       }
  54 ir_op *op_Shl;             ir_op *get_op_Shl       () { return op_Shl;       }
  55 ir_op *op_Shr;             ir_op *get_op_Shr       () { return op_Shr;       }
  56 ir_op *op_Shrs;            ir_op *get_op_Shrs      () { return op_Shrs;      }
  57 ir_op *op_Rot;             ir_op *get_op_Rot       () { return op_Rot;       }
  58 ir_op *op_Conv;            ir_op *get_op_Conv      () { return op_Conv;      }
  59 ir_op *op_Cast;            ir_op *get_op_Cast      () { return op_Cast;      }
  60
  61 ir_op *op_Phi;             ir_op *get_op_Phi       () { return op_Phi;       }
  62
  63 ir_op *op_Load;            ir_op *get_op_Load      () { return op_Load;      }
  64 ir_op *op_Store;           ir_op *get_op_Store     () { return op_Store;     }
  65 ir_op *op_Alloc;           ir_op *get_op_Alloc     () { return op_Alloc;     }
  66 ir_op *op_Free;            ir_op *get_op_Free      () { return op_Free;      }
  67 ir_op *op_Sync;            ir_op *get_op_Sync      () { return op_Sync;      }
  68
  69 ir_op *op_Tuple;           ir_op *get_op_Tuple     () { return op_Tuple;     }
  70 ir_op *op_Proj;            ir_op *get_op_Proj      () { return op_Proj;      }
  71 ir_op *op_Id;              ir_op *get_op_Id        () { return op_Id;        }
  72 ir_op *op_Bad;             ir_op *get_op_Bad       () { return op_Bad;       }
  73 ir_op *op_Confirm;         ir_op *get_op_Confirm   () { return op_Confirm;   }
  74
  75 ir_op *op_Unknown;         ir_op *get_op_Unknown   () { return op_Unknown;   }
  76 ir_op *op_Filter;          ir_op *get_op_Filter    () { return op_Filter;    }
  77 ir_op *op_Break;           ir_op *get_op_Break     () { return op_Break;     }
  78 ir_op *op_CallBegin;       ir_op *get_op_CallBegin () { return op_CallBegin; }
  79 ir_op *op_EndReg;          ir_op *get_op_EndReg    () { return op_EndReg;    }
  80 ir_op *op_EndExcept;       ir_op *get_op_EndExcept () { return op_EndExcept; }
  81
  82
  83 ir_op *
  84 new_ir_op (opcode code, char *name, op_pinned p, int labeled, size_t attr_size)
  85 {
  86   ir_op *res;
  87
  88   res = (ir_op *) xmalloc (sizeof (ir_op));
  89   res->code = code;
  90   res->name = id_from_str(name, strlen(name));
  91   res->pinned = p;
  92   res->attr_size = attr_size;
  93   res->labeled = labeled;   /* For vcg dumping.
  94                                Set labeled = 1 if the edges should be
  95                                enumarated in vcg output, otherwise set
  96                                labeled = 0. */
  97   return res;
  98 }
  99
 100
 101 void
 102 init_op(void)
 103 {
 104   op_Block = new_ir_op (iro_Block, "Block",  pinned, 1, sizeof (block_attr));
 105
 106   op_Start = new_ir_op (iro_Start, "Start",  pinned, 0, sizeof (start_attr));
 107   op_End   = new_ir_op (iro_End,   "End",    pinned, 0, 0);
 108   op_Jmp   = new_ir_op (iro_Jmp,   "Jmp",    pinned, 0, 0);
 109   op_Cond  = new_ir_op (iro_Cond,  "Cond",   pinned, 1, sizeof(cond_attr));
 110   op_Return= new_ir_op (iro_Return,"Return", pinned, 1, 0);
 111   op_Raise = new_ir_op (iro_Raise, "Raise",  pinned, 1, 0);
 112
 113   op_Const = new_ir_op (iro_Const, "Const",  floats, 0, sizeof (const_attr));
 114   op_SymConst = new_ir_op (iro_SymConst, "SymConst",
 115                                              floats, 0, sizeof (symconst_attr));
 116
 117   op_Sel   = new_ir_op (iro_Sel,   "Sel",    floats, 1, sizeof (sel_attr));
 118   op_InstOf= new_ir_op (iro_InstOf,"InstOf", floats, 1, sizeof (sel_attr));
 119
 120   op_Call  = new_ir_op (iro_Call,  "Call",   pinned, 1, sizeof (call_attr));
 121   op_Add   = new_ir_op (iro_Add,   "Add",    floats, 0, 0);
 122   op_Minus = new_ir_op (iro_Minus, "Minus",  floats, 0, 0);
 123   op_Sub   = new_ir_op (iro_Sub,   "Sub",    floats, 1, 0);
 124   op_Mul   = new_ir_op (iro_Mul,   "Mul",    floats, 0, 0);
 125   op_Quot  = new_ir_op (iro_Quot,  "Quot",   pinned, 1, sizeof(struct irnode **));
 126   op_DivMod= new_ir_op (iro_DivMod,"DivMod", pinned, 1, sizeof(struct irnode **));
 127   op_Div   = new_ir_op (iro_Div,   "Div",    pinned, 1, sizeof(struct irnode **));
 128   op_Mod   = new_ir_op (iro_Mod,   "Mod",    pinned, 1, sizeof(struct irnode **));
 129   op_Abs   = new_ir_op (iro_Abs,   "Abs",    floats, 0, 0);
 130   op_And   = new_ir_op (iro_And,   "And",    floats, 0, 0);
 131   op_Or    = new_ir_op (iro_Or,    "Or",     floats, 0, 0);
 132   op_Eor   = new_ir_op (iro_Eor,   "Eor",    floats, 0, 0);
 133   op_Not   = new_ir_op (iro_Not,   "Not",    floats, 0, 0);
 134   op_Cmp   = new_ir_op (iro_Cmp,   "Cmp",    floats, 1, 0);
 135   op_Shl   = new_ir_op (iro_Shl,   "Shl",    floats, 1, 0);
 136   op_Shr   = new_ir_op (iro_Shr,   "Shr",    floats, 1, 0);
 137   op_Shrs  = new_ir_op (iro_Shrs,  "Shrs",   floats, 1, 0);
 138   op_Rot   = new_ir_op (iro_Rot,   "Rot",    floats, 1, 0);
 139   op_Conv  = new_ir_op (iro_Conv,  "Conv",   floats, 0, 0);
 140   op_Cast  = new_ir_op (iro_Cast,  "Cast",   floats, 0, sizeof (cast_attr));
 141
 142   op_Phi   = new_ir_op (iro_Phi,   "Phi",    pinned, 1, sizeof (int));
 143
 144   op_Load  = new_ir_op (iro_Load,  "Load",   pinned, 1, sizeof(struct irnode **));
 145   op_Store = new_ir_op (iro_Store, "Store",  pinned, 1, sizeof(struct irnode **));
 146   op_Alloc = new_ir_op (iro_Alloc, "Alloc",  pinned, 1, sizeof (alloc_attr));
 147   op_Free  = new_ir_op (iro_Free,  "Free",   pinned, 1, sizeof (type *));
 148   op_Sync  = new_ir_op (iro_Sync,  "Sync",   pinned, 0, 0);
 149
 150   op_Proj      = new_ir_op (iro_Proj,      "Proj",      floats, 0, sizeof (long));
 151   op_Tuple     = new_ir_op (iro_Tuple,     "Tuple",     floats, 1, 0);
 152   op_Id        = new_ir_op (iro_Id,        "Id",        floats, 0, 0);
 153   op_Bad       = new_ir_op (iro_Bad,       "Bad",       floats, 0, 0);
 154   op_Confirm   = new_ir_op (iro_Confirm,   "Confirm",   floats, 1, sizeof (confirm_attr));
 155
 156   op_Unknown   = new_ir_op (iro_Unknown,   "Unknown",   floats, 0, 0);
 157   op_Filter    = new_ir_op (iro_Filter,    "Filter",    pinned, 1, sizeof(filter_attr));
 158   op_Break     = new_ir_op (iro_Break,     "Break",     pinned, 0, 0);
 159   op_CallBegin = new_ir_op (iro_CallBegin, "CallBegin", pinned, 0, sizeof(callbegin_attr));
 160   op_EndReg    = new_ir_op (iro_EndReg,    "EndReg",    pinned, 0, sizeof(end_attr));
 161   op_EndExcept = new_ir_op (iro_EndExcept, "EndExcept", pinned, 0, sizeof(end_attr));
 162 }
 163
 164 /* Returns the string for the opcode. */
 165 const char  *get_op_name      (ir_op *op) {
 166   return get_id_str(op->name);
 167 }
 168
 169 opcode get_op_code (ir_op *op){
 170   return op->code;
 171 }
 172
 173 ident *get_op_ident(ir_op *op){
 174   return op->name;
 175 }
 176
 177 op_pinned get_op_pinned (ir_op *op){
 178   return op->pinned;
 179 }
 180
 181 /* Sets pinned in the opcode.  Setting it to floating has no effect
 182    for Phi, Block and control flow nodes. */
 183 void      set_op_pinned(ir_op *op, op_pinned pinned) {
 184   if (op == op_Block || op == op_Phi || is_cfopcode(op)) return;
 185   op->pinned = pinned;
 186 }
 187
 188
 189 /* returns the attribute size of the operator. */
 190 int get_op_attr_size (ir_op *op) {
 191   return op->attr_size;
 192 }
 193
 194 int is_cfopcode(ir_op *op) {
 195   return ((op == op_Start)
 196           || (op == op_Jmp)
 197           || (op == op_Cond)
 198           || (op == op_Return)
 199           || (op == op_Raise)
 200           || (op == op_Bad)
 201           || (op == op_End)
 202           || (op == op_Unknown)
 203           || (op == op_Break)
 204           || (op == op_CallBegin)
 205           || (op == op_EndReg)
 206           || (op == op_EndExcept));
 207 }
 208
 209 /* Returns true if the operation manipulates interprocedural control flow:
 210    CallBegin, EndReg, EndExcept */
 211 int is_ip_cfopcode(ir_op *op) {
 212   return ((op == op_CallBegin)
 213           || (op == op_EndReg)
 214           || (op == op_EndExcept));
 215
 216 }