nsz Git - libfirm/blob - ir/be/TEMPLATE/TEMPLATE_spec.pl

   1 # Creation: 2006/02/13
   2 # $Id$
   3 # This is a template specification for the Firm-Backend
   4
   5 # the cpu architecture (ia32, ia64, mips, sparc, ppc, ...)
   6
   7 $arch = "TEMPLATE";
   8
   9 # The node description is done as a perl hash initializer with the
  10 # following structure:
  11 #
  12 # %nodes = (
  13 #
  14 # <op-name> => {
  15 #   "op_flags" => "N|L|C|X|I|F|Y|H|c|K",
  16 #   "arity"    => "0|1|2|3|variable|dynamic|all",
  17 #   "state"    => "floats|pinned",
  18 #   "args"     => [
  19 #                   { "type" => "type 1", "name" => "name 1" },
  20 #                   { "type" => "type 2", "name" => "name 2" },
  21 #                   ...
  22 #                 ],
  23 #   "comment"  => "any comment for constructor",
  24 #   "rd_constructor" => "c source code which constructs an ir_node"
  25 # },
  26 #
  27 # ... # (all nodes you need to describe)
  28 #
  29 # ); # close the %nodes initializer
  30
  31 # the op_flags correspond to the firm irop_flags:
  32 #   N   irop_flag_none
  33 #   L   irop_flag_labeled
  34 #   C   irop_flag_commutative
  35 #   X   irop_flag_cfopcode
  36 #   I   irop_flag_ip_cfopcode
  37 #   F   irop_flag_fragile
  38 #   Y   irop_flag_forking
  39 #   H   irop_flag_highlevel
  40 #   c   irop_flag_constlike
  41 #   K   irop_flag_keep
  42 #
  43 # op_flags: flags for the operation, OPTIONAL (default is "N")
  44 #
  45 # state: state of the operation, OPTIONAL (default is "pinned")
  46 #
  47 # arity: arity of the operation, MUST NOT BE OMITTED
  48 #
  49 # args:  the OPTIONAL arguments of the node constructor (debug, irg and block
  50 #        are always the first 3 arguments and are always autmatically
  51 #        created)
  52 #        If this key is missing the following arguments will be created:
  53 #        for i = 1 .. arity: ir_node *op_i
  54 #        ir_mode *mode
  55 #
  56 # comment: OPTIONAL comment for the node constructor
  57 #
  58 # rd_constructor: for every operation there will be a
  59 #      new_rd_<arch>_<op-name> function with the arguments from above
  60 #      which creates the ir_node corresponding to the defined operation
  61 #      you can either put the complete source code of this function here
  62 #
  63 #      This key is OPTIONAL. If omitted, the following constructor will
  64 #      be created:
  65 #      if (!op_<arch>_<op-name>) assert(0);
  66 #      for i = 1 to arity
  67 #         set in[i] = op_i
  68 #      done
  69 #      res = new_ir_node(db, irg, block, op_<arch>_<op-name>, mode, arity, in)
  70 #      return res
  71 #
  72 # NOTE: rd_constructor and args are only optional if and only if arity is 0,1,2 or 3
  73
  74 # register types:
  75 #   0 - no special type
  76 #   1 - write invariant (writes to this register doesn't change it's content)
  77 #   2 - caller save (register must be saved by the caller of a function)
  78 #   3 - callee save (register must be saved by the called function)
  79 #   4 - ignore (do not assign this register)
  80 # NOTE: Make sure to list the registers returning the call-result before all other
  81 #       caller save registers and in the correct order, otherwise it will break
  82 #       the magic!
  83
  84 %reg_classes = (
  85   "general_purpose" => [
  86                          { "name" => "r0", "type" => 2 },
  87                          { "name" => "r1", "type" => 2 },
  88                          { "name" => "r2", "type" => 3 },
  89                          { "name" => "r3", "type" => 2 },
  90                          { "name" => "r4", "type" => 3 },
  91                          { "name" => "r5", "type" => 3 },
  92                          { "name" => "r6", "type" => 4 },  # this is our stackpointer
  93                          { "name" => "r7", "type" => 3 },
  94                          { "name" => "r8", "type" => 3 },
  95                          { "name" => "r9", "type" => 3 },
  96                          { "name" => "r10", "type" => 3 },
  97                          { "name" => "r11", "type" => 3 },
  98                          { "name" => "r12", "type" => 3 },
  99                          { "name" => "r13", "type" => 3 },
 100                          { "name" => "r14", "type" => 3 },
 101                          { "name" => "r15", "type" => 3 }
 102                        ],
 103   "floating_point"  => [
 104                          { "name" => "f0", "type" => 2 },
 105                          { "name" => "f1", "type" => 2 },
 106                          { "name" => "f2", "type" => 2 },
 107                          { "name" => "f3", "type" => 2 },
 108                          { "name" => "f4", "type" => 2 },
 109                          { "name" => "f5", "type" => 2 },
 110                          { "name" => "f6", "type" => 2 },
 111                          { "name" => "f7", "type" => 2 },
 112                          { "name" => "f8", "type" => 2 },
 113                          { "name" => "f9", "type" => 2 },
 114                          { "name" => "f10", "type" => 2 },
 115                          { "name" => "f11", "type" => 2 },
 116                          { "name" => "f12", "type" => 2 },
 117                          { "name" => "f13", "type" => 2 },
 118                          { "name" => "f14", "type" => 2 },
 119                          { "name" => "f15", "type" => 2 }
 120                        ]
 121 ); # %reg_classes
 122
 123 #--------------------------------------------------#
 124 #                        _                         #
 125 #                       (_)                        #
 126 #  _ __   _____      __  _ _ __    ___  _ __  ___  #
 127 # | '_ \ / _ \ \ /\ / / | | '__|  / _ \| '_ \/ __| #
 128 # | | | |  __/\ V  V /  | | |    | (_) | |_) \__ \ #
 129 # |_| |_|\___| \_/\_/   |_|_|     \___/| .__/|___/ #
 130 #                                      | |         #
 131 #                                      |_|         #
 132 #--------------------------------------------------#
 133
 134 %nodes = (
 135
 136 #-----------------------------------------------------------------#
 137 #  _       _                                         _            #
 138 # (_)     | |                                       | |           #
 139 #  _ _ __ | |_ ___  __ _  ___ _ __   _ __   ___   __| | ___  ___  #
 140 # | | '_ \| __/ _ \/ _` |/ _ \ '__| | '_ \ / _ \ / _` |/ _ \/ __| #
 141 # | | | | | ||  __/ (_| |  __/ |    | | | | (_) | (_| |  __/\__ \ #
 142 # |_|_| |_|\__\___|\__, |\___|_|    |_| |_|\___/ \__,_|\___||___/ #
 143 #                   __/ |                                         #
 144 #                  |___/                                          #
 145 #-----------------------------------------------------------------#
 146
 147 # commutative operations
 148
 149 "Add" => {
 150   "op_flags"    => "C",
 151   "arity"       => 2,
 152   "remat"       => 1,
 153   "comment"     => "construct Add: Add(a, b) = Add(b, a) = a + b",
 154   "reg_req"     => { "in" => [ "general_purpose", "general_purpose" ], "out" => [ "general_purpose" ] },
 155   "emit"        => '. add %S1, %S2, %D1\t\t\t/* Add(%S1, %S2) -> %D1, (%A1, %A2) */'
 156 },
 157
 158 "Add_i" => {
 159   "arity"       => 1,
 160   "remat"       => 1,
 161   "comment"     => "construct Add: Add(a, const) = Add(const, a) = a + const",
 162   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 163   "emit"        => '. add %S1, %C, %D1\t\t\t/* Add(%C, %S1) -> %D1, (%A1, const) */'
 164 },
 165
 166 "Mul" => {
 167   "op_flags"    => "C",
 168   "arity"       => 2,
 169   "comment"     => "construct Mul: Mul(a, b) = Mul(b, a) = a * b",
 170   "reg_req"     => { "in" => [ "general_purpose", "general_purpose" ], "out" => [ "general_purpose" ] },
 171   "emit"        =>'. mul %S1, %S2, %D1\t\t\t/* Mul(%S1, %S2) -> %D1, (%A1, %A2) */'
 172 },
 173
 174 "Mul_i" => {
 175   "state"       => "pinned",
 176   "arity"       => 1,
 177   "comment"     => "construct Mul: Mul(a, const) = Mul(const, a) = a * const",
 178   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 179   "emit"        => '. mul %S1, %C, %D1\t\t\t/* signed Mul(%C, %S1) -> %D1, (%A1, const) */'
 180 },
 181
 182 "And" => {
 183   "op_flags"    => "C",
 184   "arity"       => 2,
 185   "remat"       => 1,
 186   "comment"     => "construct And: And(a, b) = And(b, a) = a AND b",
 187   "reg_req"     => { "in" => [ "general_purpose", "general_purpose" ], "out" => [ "general_purpose" ] },
 188   "emit"        => '. and %S1, %S2, %D1\t\t\t/* And(%S1, %S2) -> %D1, (%A1, %A2) */'
 189 },
 190
 191 "And_i" => {
 192   "arity"       => 1,
 193   "remat"       => 1,
 194   "comment"     => "construct And: And(a, const) = And(const, a) = a AND const",
 195   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 196   "emit"        => '. and %S1, %C, %D1\t\t\t/* And(%C, %S1) -> %D1, (%A1, const) */'
 197 },
 198
 199 "Or" => {
 200   "op_flags"    => "C",
 201   "arity"       => 2,
 202   "remat"       => 1,
 203   "comment"     => "construct Or: Or(a, b) = Or(b, a) = a OR b",
 204   "reg_req"     => { "in" => [ "general_purpose", "general_purpose" ], "out" => [ "general_purpose" ] },
 205   "emit"        => '. or %S1, %S2, %D1\t\t\t/* Or(%S1, %S2) -> %D1, (%A1, %A2) */'
 206 },
 207
 208 "Or_i" => {
 209   "arity"       => 1,
 210   "remat"       => 1,
 211   "comment"     => "construct Or: Or(a, const) = Or(const, a) = a OR const",
 212   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 213   "emit"        => '. or %S1, %C, %D1\t\t\t/* Or(%C, %S1) -> %D1, (%A1, const) */'
 214 },
 215
 216 "Eor" => {
 217   "op_flags"    => "C",
 218   "arity"       => 2,
 219   "remat"       => 1,
 220   "comment"     => "construct Eor: Eor(a, b) = Eor(b, a) = a EOR b",
 221   "reg_req"     => { "in" => [ "general_purpose", "general_purpose" ], "out" => [ "general_purpose" ] },
 222   "emit"        => '. xor %S1, %S2, %D1\t\t\t/* Xor(%S1, %S2) -> %D1, (%A1, %A2) */'
 223 },
 224
 225 "Eor_i" => {
 226   "arity"       => 1,
 227   "remat"       => 1,
 228   "comment"     => "construct Eor: Eor(a, const) = Eor(const, a) = a EOR const",
 229   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 230   "emit"        => '. xor %S1, %C, %D1\t\t\t/* Xor(%C, %S1) -> %D1, (%A1, const) */'
 231 },
 232
 233 # not commutative operations
 234
 235 "Sub" => {
 236   "arity"       => 2,
 237   "remat"       => 1,
 238   "comment"     => "construct Sub: Sub(a, b) = a - b",
 239   "reg_req"     => { "in" => [ "general_purpose", "general_purpose" ], "out" => [ "general_purpose" ] },
 240   "emit"        => '. sub %S1, %S2, %D1\t\t\t/* Sub(%S1, %S2) -> %D1, (%A1, %A2) */'
 241 },
 242
 243 "Sub_i" => {
 244   "arity"       => 1,
 245   "remat"       => 1,
 246   "comment"     => "construct Sub: Sub(a, const) = a - const",
 247   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 248   "emit"        => '. subl %S1, %C, %D1\t\t\t/* Sub(%S1, %C) -> %D1, (%A1, const) */'
 249 },
 250
 251 "Shl" => {
 252   "arity"       => 2,
 253   "remat"       => 1,
 254   "comment"     => "construct Shl: Shl(a, b) = a << b",
 255   "reg_req"     => { "in" => [ "general_purpose", "general_purpose" ], "out" => [ "general_purpose" ] },
 256   "emit"        => '. shl %S1, %S2, %D1\t\t\t/* Shl(%S1, %S2) -> %D1, (%A1, %A2) */'
 257 },
 258
 259 "Shl_i" => {
 260   "arity"       => 1,
 261   "remat"       => 1,
 262   "comment"     => "construct Shl: Shl(a, const) = a << const",
 263   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 264   "emit"        => '. shl %S1, %C, %D1\t\t\t/* Shl(%S1, %C) -> %D1, (%A1, const) */'
 265 },
 266
 267 "Shr" => {
 268   "arity"       => 2,
 269   "remat"       => 1,
 270   "comment"     => "construct Shr: Shr(a, b) = a >> b",
 271   "reg_req"     => { "in" => [ "general_purpose", "general_purpose" ], "out" => [ "in_r1" ] },
 272   "emit"        => '. shr %S2, %D1\t\t\t/* Shr(%S1, %S2) -> %D1, (%A1, %A2) */'
 273 },
 274
 275 "Shr_i" => {
 276   "arity"       => 1,
 277   "remat"       => 1,
 278   "comment"     => "construct Shr: Shr(a, const) = a >> const",
 279   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 280   "emit"        => '. shr %S1, %C, %D1\t\t\t/* Shr(%S1, %C) -> %D1, (%A1, const) */'
 281 },
 282
 283 "RotR" => {
 284   "arity"       => 2,
 285   "remat"       => 1,
 286   "comment"     => "construct RotR: RotR(a, b) = a ROTR b",
 287   "reg_req"     => { "in" => [ "general_purpose", "general_purpose" ], "out" => [ "general_purpose" ] },
 288   "emit"        => '. ror %S1, %S2, %D1\t\t\t/* RotR(%S1, %S2) -> %D1, (%A1, %A2) */'
 289 },
 290
 291 "RotL" => {
 292   "arity"       => 2,
 293   "remat"       => 1,
 294   "comment"     => "construct RotL: RotL(a, b) = a ROTL b",
 295   "reg_req"     => { "in" => [ "general_purpose", "general_purpose" ], "out" => [ "general_purpose" ] },
 296   "emit"        => '. rol %S1, %S2, %D1\t\t\t/* RotL(%S1, %S2) -> %D1, (%A1, %A2) */'
 297 },
 298
 299 "RotL_i" => {
 300   "arity"       => 1,
 301   "remat"       => 1,
 302   "comment"     => "construct RotL: RotL(a, const) = a ROTL const",
 303   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 304   "emit"        => '. rol %S1, %C, %D1\t\t\t/* RotL(%S1, %C) -> %D1, (%A1, const) */'
 305 },
 306
 307 "Minus" => {
 308   "arity"       => 1,
 309   "remat"       => 1,
 310   "comment"     => "construct Minus: Minus(a) = -a",
 311   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 312   "emit"        => '. neg %S1, %D1\t\t\t/* Neg(%S1) -> %D1, (%A1) */'
 313 },
 314
 315 "Inc" => {
 316   "arity"       => 1,
 317   "remat"       => 1,
 318   "comment"     => "construct Increment: Inc(a) = a++",
 319   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 320   "emit"        => '. inc %S1, %D1\t\t\t/* Inc(%S1) -> %D1, (%A1) */'
 321 },
 322
 323 "Dec" => {
 324   "arity"       => 1,
 325   "remat"       => 1,
 326   "comment"     => "construct Decrement: Dec(a) = a--",
 327   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 328   "emit"        => '. dec %S1, %D1\t\t\t/* Dec(%S1) -> %D1, (%A1) */'
 329 },
 330
 331 "Not" => {
 332   "arity"       => 1,
 333   "remat"       => 1,
 334   "comment"     => "construct Not: Not(a) = !a",
 335   "reg_req"     => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] },
 336   "emit"        => '. not %S1, %D1\t\t\t/* Not(%S1) -> %D1, (%A1) */'
 337 },
 338
 339 # other operations
 340
 341 "Const" => {
 342   "op_flags" => "c",
 343   "arity"    => "0",
 344   "remat"    => 1,
 345   "comment"  => "represents an integer constant",
 346   "reg_req"  => { "out" => [ "general_purpose" ] },
 347   "emit"     => '. mov %C, %D1\t\t\t/* Mov Const into register */',
 348   "cmp_attr" =>
 349 '
 350   if (attr_a->tp == attr_b->tp) {
 351     if (attr_a->tp == asmop_SymConst) {
 352       if (attr_a->old_ir == NULL || attr_b->old_ir == NULL)
 353         return 1;
 354       else
 355         return strcmp(get_sc_name(attr_a->old_ir), get_sc_name(attr_b->old_ir));
 356     }
 357     else {
 358       if (attr_a->old_ir == NULL || attr_b->old_ir == NULL)
 359         return 1;
 360
 361       if (tarval_cmp(attr_a->tv, attr_b->tv) == pn_Cmp_Eq)
 362         return 0;
 363       else
 364         return 1;
 365     }
 366   }
 367   else
 368     return 1;
 369 '
 370 },
 371
 372 # Load / Store
 373
 374 "Load" => {
 375   "op_flags" => "L|F",
 376   "state"    => "exc_pinned",
 377   "arity"    => 2,
 378   "remat"    => 1,
 379   "comment"  => "construct Load: Load(ptr, mem) = LD ptr -> reg",
 380   "reg_req"  => { "in" => [ "general_purpose", "none" ], "out" => [ "general_purpose" ] },
 381   "emit"     => '. mov %O(%S1), %D1\t\t\t/* Load((%S1)) -> %D1, (%A1) */'
 382 },
 383
 384 "Store" => {
 385   "op_flags" => "L|F",
 386   "state"    => "exc_pinned",
 387   "arity"    => 3,
 388   "remat"    => 1,
 389   "comment"  => "construct Store: Store(ptr, val, mem) = ST ptr,val",
 390   "reg_req"  => { "in" => [ "general_purpose", "general_purpose", "none" ] },
 391   "emit"     => '. movl %S2, %O(%S1)\t\t\t/* Store(%S2) -> (%S1), (%A1, %A2) */'
 392 },
 393
 394 #--------------------------------------------------------#
 395 #    __ _             _                     _            #
 396 #   / _| |           | |                   | |           #
 397 #  | |_| | ___   __ _| |_   _ __   ___   __| | ___  ___  #
 398 #  |  _| |/ _ \ / _` | __| | '_ \ / _ \ / _` |/ _ \/ __| #
 399 #  | | | | (_) | (_| | |_  | | | | (_) | (_| |  __/\__ \ #
 400 #  |_| |_|\___/ \__,_|\__| |_| |_|\___/ \__,_|\___||___/ #
 401 #--------------------------------------------------------#
 402
 403 # commutative operations
 404
 405 "fAdd" => {
 406   "op_flags"    => "C",
 407   "arity"       => 2,
 408   "remat"       => 1,
 409   "comment"     => "construct FP Add: Add(a, b) = Add(b, a) = a + b",
 410   "reg_req"     => { "in" => [ "floating_point", "floating_point" ], "out" => [ "floating_point" ] },
 411   "emit"        => '. fadd %S1, %S2, %D1\t\t\t/* FP Add(%S1, %S2) -> %D1 */'
 412 },
 413
 414 "fMul" => {
 415   "op_flags"    => "C",
 416   "arity"       => 2,
 417   "comment"     => "construct FP Mul: Mul(a, b) = Mul(b, a) = a * b",
 418   "reg_req"     => { "in" => [ "floating_point", "floating_point" ], "out" => [ "floating_point" ] },
 419   "emit"        =>'. fmul %S1, %S2, %D1\t\t\t/* FP Mul(%S1, %S2) -> %D1 */'
 420 },
 421
 422 "fMax" => {
 423   "op_flags"    => "C",
 424   "arity"       => 2,
 425   "remat"       => 1,
 426   "comment"     => "construct FP Max: Max(a, b) = Max(b, a) = a > b ? a : b",
 427   "reg_req"     => { "in" => [ "floating_point", "floating_point" ], "out" => [ "floating_point" ] },
 428   "emit"        =>'. fmax %S1, %S2, %D1\t\t\t/* FP Max(%S1, %S2) -> %D1 */'
 429 },
 430
 431 "fMin" => {
 432   "op_flags"    => "C",
 433   "arity"       => 2,
 434   "remat"       => 1,
 435   "comment"     => "construct FP Min: Min(a, b) = Min(b, a) = a < b ? a : b",
 436   "reg_req"     => { "in" => [ "floating_point", "floating_point" ], "out" => [ "floating_point" ] },
 437   "emit"        =>'. fmin %S1, %S2, %D1\t\t\t/* FP Min(%S1, %S2) -> %D1 */'
 438 },
 439
 440 # not commutative operations
 441
 442 "fSub" => {
 443   "arity"       => 2,
 444   "remat"       => 1,
 445   "comment"     => "construct FP Sub: Sub(a, b) = a - b",
 446   "reg_req"     => { "in" => [ "floating_point", "floating_point" ], "out" => [ "floating_point" ] },
 447   "emit"        => '. fsub %S1, %S2, %D1\t\t\t/* FP Sub(%S1, %S2) -> %D1 */'
 448 },
 449
 450 "fDiv" => {
 451   "arity"       => 2,
 452   "remat"       => 1,
 453   "check_inout" => 1,
 454   "comment"     => "construct FP Div: Div(a, b) = a / b",
 455   "reg_req"     => { "in" => [ "floating_point", "floating_point" ], "out" => [ "floating_point" ] },
 456   "emit"        => '. fdiv %S1, %S2, %D1\t\t\t/* FP Div(%S1, %S2) -> %D1 */'
 457 },
 458
 459 "fMinus" => {
 460   "arity"       => 1,
 461   "remat"       => 1,
 462   "check_inout" => 1,
 463   "comment"     => "construct FP Minus: Minus(a) = -a",
 464   "reg_req"     => { "in" => [ "floating_point" ], "out" => [ "floating_point" ] },
 465   "emit"        => '. fneg %S1, %D1\t\t\t/* FP Minus(%S1) -> %D1 */'
 466 },
 467
 468 # other operations
 469
 470 "fConst" => {
 471   "op_flags" => "c",
 472   "arity"    => "0",
 473   "remat"    => 1,
 474   "comment"  => "represents a FP constant",
 475   "reg_req"  => { "out" => [ "floating_point" ] },
 476   "emit"     => '. fmov %C, %D1\t\t\t/* Mov fConst into register */',
 477   "cmp_attr" =>
 478 '
 479   if (attr_a->tp == attr_b->tp) {
 480     if (attr_a->tp == asmop_SymConst) {
 481       if (attr_a->old_ir == NULL || attr_b->old_ir == NULL)
 482         return 1;
 483       else
 484         return strcmp(get_sc_name(attr_a->old_ir), get_sc_name(attr_b->old_ir));
 485     }
 486     else {
 487       if (attr_a->old_ir == NULL || attr_b->old_ir == NULL)
 488         return 1;
 489
 490       if (tarval_cmp(attr_a->tv, attr_b->tv) == pn_Cmp_Eq)
 491         return 0;
 492       else
 493         return 1;
 494     }
 495   }
 496   else
 497     return 1;
 498 '
 499 },
 500
 501 # Load / Store
 502
 503 "fLoad" => {
 504   "op_flags" => "L|F",
 505   "state"    => "exc_pinned",
 506   "arity"    => 2,
 507   "remat"    => 1,
 508   "comment"  => "construct FP Load: Load(ptr, mem) = LD ptr",
 509   "reg_req"  => { "in" => [ "general_purpose", "none" ], "out" => [ "floating_point" ] },
 510   "emit"     => '. fmov %O(%S1), %D1\t\t\t/* Load((%S1)) -> %D1 */'
 511 },
 512
 513 "fStore" => {
 514   "op_flags" => "L|F",
 515   "state"    => "exc_pinned",
 516   "arity"    => 3,
 517   "remat"    => 1,
 518   "comment"  => "construct Store: Store(ptr, val, mem) = ST ptr,val",
 519   "reg_req"  => { "in" => [ "general_purpose", "floating_point", "none" ] },
 520   "emit"     => '. fmov %S2, %O(%S1)\t\t\t/* Store(%S2) -> (%S1), (%A1, %A2) */'
 521 },
 522
 523 # Call
 524
 525 "Call" => {
 526   "op_flags" => "L|F",
 527   "state"    => "mem_pinned",
 528   "arity"    => "variable",
 529   "comment"  => "construct Call: Call(...)",
 530   "args"     => [
 531                   { "type" => "int",        "name" => "n" },
 532                   { "type" => "ir_node **", "name" => "in" }
 533                 ],
 534   "rd_constructor" =>
 535 "  if (!op_ia32_Call) assert(0);
 536   return new_ir_node(db, irg, block, op_ia32_Call, mode_T, n, in);
 537 "
 538 },
 539
 540 # M/Alloc
 541
 542 "Alloca" => {
 543   "op_flags" => "L|F",
 544   "state"    => "pinned",
 545   "arity"    => "2",
 546   "comment"  => "construct Alloca: allocate memory on Stack",
 547   "reg_req"  => { "in" => [ "general_purpose" ], "out" => [ "general_purpose" ] }
 548 },
 549
 550 "Alloca_i" => {
 551   "op_flags" => "L|F",
 552   "state"    => "pinned",
 553   "arity"    => "1",
 554   "comment"  => "construct Alloca: allocate memory on Stack",
 555   "reg_req"  => { "out" => [ "general_purpose" ] }
 556 }
 557
 558 ); # end of %nodes