nsz Git - libfirm/blob - ir/be/grgen/simd/C_Patterns/Firm.gm

   1 /*
   2  * Project:     GRS
   3  * File name:   Firm.gm
   4  * Purpose:     A specification of Firm for use with GrGen
   5  * Author:      Rubino Geiss
   6  * Mowified by:
   7  * Created:     10.9.2003
   8  * Copyright:   (c) 2004 Universitaet Karlsruhe
   9  * Licence:     GPL
  10  */
  11
  12 model Firm;
  13
  14 node class FIRM_node extends Node {
  15         generation: int;
  16 }
  17
  18 edge class FIRM_edge extends Edge {
  19         generation: int;
  20         pos: int;
  21 }
  22
  23 /**********************************************
  24  * Modes                                      *
  25  **********************************************/
  26
  27 enum ENUM_sort {
  28         auxiliary, control_flow, memory, internal_boolean,
  29         int_number, float_number, reference, character
  30 }
  31 enum ENUM_arithmetic_kind {
  32         uninitialized, none, twos_complement, ones_complement,
  33         int_BCD, ieee754, float_BCD, max, unknown
  34 }
  35 enum ENUM_modecode {
  36         irm_BB, irm_X,   irm_F,   irm_D,  irm_E,  irm_Bs,
  37         irm_Bu, irm_Hs,  irm_Hu,  irm_Is, irm_Iu, irm_Ls,
  38         irm_Lu, irm_C,   irm_P,   irm_b,  irm_M,  irm_T,
  39         irm_U,  irm_ANY, irm_BAD, irm_max
  40 }
  41
  42 node class Mode extends FIRM_node {
  43         name            : string;
  44         size            : int;
  45         sort            : ENUM_sort;
  46 /*      code            : ENUM_modecode; */
  47         sign            : boolean;
  48         arithmetic      : ENUM_arithmetic_kind;
  49         shift           : int;
  50 }
  51
  52
  53 node class Mode_BB   extends Mode;
  54 node class Mode_X    extends Mode;
  55 node class Mode_F    extends Mode;
  56 node class Mode_D    extends Mode;
  57 node class Mode_E    extends Mode;
  58 node class Mode_Bs   extends Mode;
  59 node class Mode_Bu   extends Mode;
  60 node class Mode_Hs   extends Mode;
  61 node class Mode_Hu   extends Mode;
  62 node class Mode_Is   extends Mode;
  63 node class Mode_Iu   extends Mode;
  64 node class Mode_Ls   extends Mode;
  65 node class Mode_Lu   extends Mode;
  66 node class Mode_C    extends Mode;
  67 node class Mode_P    extends Mode;
  68 node class Mode_b    extends Mode;
  69 node class Mode_M    extends Mode;
  70 node class Mode_T    extends Mode;
  71 node class Mode_U    extends Mode;
  72 node class Mode_ANY  extends Mode;
  73 node class Mode_BAD  extends Mode;
  74 node class Mode_max  extends Mode;
  75 node class Mode_DLu  extends Mode;
  76 node class Mode_LLu  extends Mode;
  77
  78
  79
  80 /**********************************************
  81  * Types                                      *
  82  **********************************************/
  83
  84 enum ENUM_state       { layout_undefined, layout_fixed }
  85
  86 /************* Type Nodes         *************/
  87
  88 node class Type extends FIRM_node {
  89         id    : int;
  90         name  : string;
  91         state : ENUM_state;
  92         size  : int;
  93         align : int;
  94 }
  95
  96 node class Compound extends Type;
  97 node class Class extends Compound;
  98 node class Struct extends Compound;
  99 node class Union extends Compound;
 100 node class Method extends Type {
 101         n_params : int;         // number of calling paramters
 102         n_ress   : int;         // number of results
 103         variadic : boolean;     // true: additional variadic parameters allowed
 104 }
 105 node class Array extends Type {
 106         n_dimensions : int;
 107 }
 108 node class Enum extends Type;
 109 node class Pointer extends Type;
 110 node class Primitive extends Type;
 111
 112 /************* Type Edges         *************/
 113
 114 // Class (Sub) -> Class (Super)
 115 edge class is_subtype_of extends FIRM_edge
 116         connect Class [*] -> Class [*];         // Subclass -> Superclass
 117 edge class member extends FIRM_edge
 118                 // Entities may or may not be an Compound member: [0:1]
 119         connect Compound [*] -> Entity [0:1];
 120 edge class parameter extends FIRM_edge
 121         connect Method [*] -> Type [*] {
 122         position : int;
 123 }
 124 edge class result extends FIRM_edge
 125         connect Method [*] -> Type [*] {
 126         position : int;
 127 }
 128 edge class element_type extends FIRM_edge
 129         connect Array [1] -> Type [*];
 130 edge class element_ent extends FIRM_edge
 131         connect Array [1] -> Entity [*];
 132
 133
 134 /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 135    TODO XXX const_code_irg is not walked by wif.do_block
 136    TODO: Implement upper / lower in firm2grs.c
 137    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 138  */
 139 edge class lower extends FIRM_edge              // TODO: multidim arrays???
 140         connect Array [*] -> IR_node [*] {
 141         position : int;
 142 }
 143 edge class upper extends FIRM_edge
 144         connect Array [*] -> IR_node [*] {
 145         position : int;
 146 }
 147
 148 edge class named_value extends FIRM_edge        // Enum -> Tarval
 149         connect Enum [*] -> Tarval [*] {        // TODO: empty Enums [+]???
 150         name : string;
 151 }
 152 edge class has_type extends FIRM_edge
 153         connect Call     [1]   -> Type [*],
 154                 SymConst [0:1] -> Type [*],
 155                 Pointer  [1]   -> Type [*];
 156
 157
 158 /**********************************************
 159  * Tarval                                     *
 160  **********************************************/
 161
 162 node class Tarval extends FIRM_node {
 163         value : string;         //  is this aprobate
 164 }
 165
 166 edge class has_mode extends FIRM_edge
 167         connect Tarval    [1] -> Mode [*],
 168                 Pointer   [1] -> Mode [*],
 169                 Primitive [1] -> Mode [*],
 170                 Method    [1] -> Mode [*],
 171                 IR_node   [1] -> Mode [*],
 172                 Struct    [0:1]->Mode [*],
 173                 Enum      [1] -> Mode [*];
 174 edge class has_entity extends FIRM_edge
 175         connect SymConst[0:1] -> Entity [*];
 176
 177
 178 /**********************************************
 179  * Entities                                   *
 180  **********************************************/
 181
 182 enum ENUM_allocation   { automatic, parameter, dynamic, static }
 183 enum ENUM_visibility   { local, global, extern }
 184 enum ENUM_variability  { uninitialized, initialized, partly_constant, constant }
 185 enum ENUM_peculiarity  { description, inherited, existent }
 186
 187 /************* Entity Nodes       *************/
 188
 189 node class Entity extends FIRM_node {
 190         name        : string;           // the (source) name of the entity
 191         ld_name     : string;           // the linker name of the entity
 192         offset      : int;
 193         allocation  : ENUM_allocation;
 194         visibility  : ENUM_visibility;
 195         variability : ENUM_variability;
 196         peculiarity : ENUM_peculiarity;
 197         volatility  : boolean;
 198 }
 199
 200 /************* Entity Edges       *************/
 201
 202 edge class overwrites extends FIRM_edge
 203         connect Entity -> Entity;               // TODO arity ???
 204
 205 edge class init_node extends FIRM_edge;
 206 //      connect Entity -> Node (of Init);       // TODO arity ???
 207
 208 edge class init_entity extends FIRM_edge;
 209 //      connect Entity -> Entity (of Init);     // TODO arity ???
 210
 211 edge class graph extends FIRM_edge
 212         connect Entity [0:1] -> Method_IRG [*];
 213
 214 edge class type extends FIRM_edge
 215         connect Entity [1] -> Type [*];
 216
 217
 218 /**********************************************
 219  * Method IRG                                 *
 220  **********************************************/
 221
 222 /*
 223  * Firm IRG the IR graph of a method.
 224  * Pointing to Start and End nodes as well as its Entity
 225  */
 226 node class Method_IRG extends FIRM_node {
 227         main_method : boolean;  // set, if this method is the main entry point
 228 }
 229
 230 edge class meth_start extends FIRM_edge
 231         connect Method_IRG -> Start;
 232
 233 edge class meth_end extends FIRM_edge
 234         connect Method_IRG -> End;
 235
 236 edge class frame_type extends FIRM_edge
 237         connect Method_IRG -> Type;
 238
 239 edge class belong_to extends FIRM_edge
 240         connect Block -> Method_IRG;
 241
 242 node class IR_node extends FIRM_node {
 243         index : int; //quickfix for using vprojs
 244 }
 245
 246
 247 node class Ordinary;
 248 node class Special;
 249 node class Arithmetic extends Ordinary;
 250 node class Controlflow;
 251 node class Memory;
 252
 253 node class Unary;
 254 node class Binary;
 255 node class Trinary;
 256 node class Nary;
 257
 258 node class Commutative;
 259 node class Associative;
 260
 261
 262 /**********************************************
 263  * IR Nodes                                   *
 264  **********************************************/
 265
 266 node class Complex extends IR_node;
 267 node class Block extends IR_node, Special;
 268 node class Start extends IR_node, Special;
 269 node class End extends IR_node, Special;
 270
 271 node class Jmp extends IR_node, Controlflow;
 272 node class Cond extends IR_node, Controlflow, Ordinary;
 273 node class Return extends IR_node, Controlflow;
 274 node class Raise extends IR_node, Controlflow;
 275
 276 node class Const extends IR_node, Ordinary {
 277         value : string;                 // tarval coded as string
 278 }
 279 node class IntConst extends Const {
 280   // ATTENTION:
 281         // value inherited from Const is set to "<INTCONST>" and may not be used
 282         intval : int;                   // tarval coded as string
 283 }
 284
 285 node class SymConst extends IR_node, Ordinary {
 286         kind    : int;
 287         ptrinfo : string;
 288 }
 289
 290 node class Sel extends IR_node, VectorBase;
 291 node class InstOf extends IR_node;
 292 node class Call extends IR_node;
 293 node class Add extends IR_node, Arithmetic, Binary, Commutative;
 294 node class Sub extends IR_node, Arithmetic, Binary;
 295 node class Minus extends IR_node, Arithmetic, Unary;
 296 node class Mul extends IR_node, Arithmetic, Binary, Commutative;
 297 node class Mulh extends IR_node, Arithmetic, Binary, Commutative;
 298 node class Quot extends IR_node, Arithmetic, Binary;
 299 node class DivMod extends IR_node, Arithmetic, Binary;
 300 node class Div extends IR_node, Arithmetic, Binary;
 301 node class Mod extends IR_node, Arithmetic, Binary;
 302 node class Abs extends IR_node, Arithmetic, Unary;
 303 node class And extends IR_node, Arithmetic, Binary, Commutative;
 304 node class Or extends IR_node, Arithmetic, Binary, Commutative;
 305 node class Eor extends IR_node, Arithmetic, Binary, Commutative;
 306 node class Not extends IR_node, Arithmetic, Unary;
 307 node class Cmp extends IR_node, Ordinary;
 308 node class Shl extends IR_node, Arithmetic, Binary;
 309 node class Shr extends IR_node, Arithmetic, Binary;
 310 node class Shrs extends IR_node, Arithmetic, Binary;
 311 node class Rot extends IR_node, Arithmetic, Binary;
 312 node class Conv extends IR_node, Ordinary;
 313 node class Cast extends IR_node; // TODO classify
 314 node class Phi extends IR_node, Ordinary;
 315 node class Mux extends IR_node, Trinary; // TODO classify
 316
 317 node class MemNode extends IR_node, Memory {
 318         volatility  : boolean;
 319 }
 320
 321 node class Load extends MemNode;
 322 node class Store extends MemNode;
 323
 324 enum ENUM_alloc_where { stack_alloc, heap_alloc }
 325
 326 node class Alloc extends IR_node, Memory {
 327         where : ENUM_alloc_where;
 328 }
 329 node class Free extends IR_node, Memory;
 330 node class Sync extends IR_node, Memory {
 331         arity : int;
 332 }
 333
 334 node class SyncArity2 extends Sync;// A sync with arity 2, that has a wrong arity attribute
 335 node class IgnoreCF;    // it is not important to which block this node is connected
 336
 337 node class Proj extends IR_node, Ordinary, VectorBase {
 338         proj : int;
 339 }
 340
 341 // TODO classify the following IR_nodes
 342 node class Tuple extends IR_node;
 343 node class Id extends IR_node;
 344 node class Bad extends IR_node;
 345 node class NoMem extends IR_node;
 346 node class Confirm extends IR_node;
 347 node class Unknown extends IR_node;
 348 node class Filter extends IR_node;
 349 node class Break extends IR_node, Controlflow;
 350 node class CallBegin extends IR_node;
 351 node class EndReg extends IR_node;
 352 node class EndExcept extends IR_node, Controlflow;
 353
 354 /**********************************************
 355  * IR Intrinsic Nodes                         *
 356  **********************************************/
 357 node class Intrinsic extends IR_node, Ordinary
 358 {
 359         type : string;
 360 }
 361
 362 node class IntrinsicGP  extends Intrinsic;      // a intrinsic with gp registers
 363 node class IntrinsicGP3  extends Intrinsic;     // a intrinsic with 3 gp registers
 364 node class IntrinsicFP  extends Intrinsic;      // a intrinsic with fp registers
 365 node class IntrinsicMMX extends Intrinsic;      // a intrinsic with mmx registers
 366 node class IntrinsicSSE extends Intrinsic;      // a intrinsic with sse registers
 367
 368 node class Intrinsic_sse_sse_sse extends Intrinsic;     // a intrinsic
 369 node class Intrinsic_sse_sse extends Intrinsic;         // a intrinsic
 370 node class Intrinsic_sse_addr_sse extends Intrinsic;    // a intrinsic
 371 node class Intrinsic_addr_sse_store extends Intrinsic;  // a intrinsic
 372 node class Intrinsic_reg_sse_sse extends Intrinsic;     // a intrinsic
 373 node class Intrinsic_sse_reg_sse extends Intrinsic;     // a intrinsic
 374 node class Intrinsic_sse_addr_store extends Intrinsic;  // a intrinsic
 375 node class Intrinsic_addr_addr_store extends Intrinsic; // a intrinsic
 376 node class Intrinsic_addr_sse extends Intrinsic;        // a intrinsic
 377 node class Intrinsic_addr_addr_sse extends Intrinsic;   // a intrinsic
 378
 379 node class max extends IntrinsicGP;     // a max instruction
 380 node class min extends IntrinsicGP;     // a min instruction
 381
 382 node class CMOV extends IntrinsicGP;    // a conditional move instruction
 383
 384 node class CCopy extends IntrinsicGP;   // a conditional copy instruction
 385                                         // CCopy(val0:df, val1:df, cond:bool):df
 386
 387
 388 node class Match;
 389 node class IntrinsicMatch extends Match{
 390         name : string;
 391 }
 392
 393
 394 /************* IR Edges         *************/
 395
 396 edge class flow extends FIRM_edge
 397         connect IR_node [*] -> IR_node [*] {
 398         position : int;
 399 }
 400
 401 edge class df extends flow;             // IR_node -> IR_node, data flow
 402 edge class mem extends df;              // IR_node -> IR_node, memory
 403 edge class tuple extends df;            // Edges of Mode Tuple
 404 edge class cf extends flow              // control flow
 405         connect IR_node [1] -> Block [*],
 406                 // We cannot distinguish ProjI etc from ProjXi: therefor 0
 407                 // ProjX form Start has 2 successors
 408                 Block   [*] -> Proj  [0:2];
 409
 410
 411 /**********************************************
 412  * Extensions                                 *
 413  **********************************************/
 414
 415 node class Vector extends IR_node;
 416
 417 node class V2 extends Vector;
 418 node class V4 extends Vector;
 419
 420 node class pi;
 421
 422 node class V2pi_1 extends V2, pi;
 423 node class V2pi_2 extends V2, pi;
 424
 425 node class V4pi_1 extends V4, pi;
 426 node class V4pi_2 extends V4, pi;
 427 node class V4pi_3 extends V4, pi;
 428 node class V4pi_4 extends V4, pi;
 429
 430 node class V2Load extends V2;
 431 node class V2Store extends V2;
 432
 433 node class V2Sub extends V2;
 434
 435 edge class match {
 436         nr : int;
 437 }
 438
 439 node class StartBlock;
 440
 441
 442 /******************
 443  * SIMD Extension *
 444  ******************/
 445
 446 //select parts of a register (e.g. 32 bit of a 128 bit register)
 447 node class VProj extends IR_node, Ordinary
 448 {
 449         proj : int;
 450 }
 451
 452 // Add wich can have several operands
 453 node class MultipleAdd extends IR_node
 454 {
 455         arity: int;
 456 }
 457
 458 // A node which represents the base pointer of a vector
 459 node class VectorBase extends IR_node;
 460
 461 // A backend node we need to copy simd -> gp register on ia32
 462 node class IR_Keep extends IR_node;