nsz Git - libfirm/blob - ir/be/arm/arm_spec.pl

   1 # Creation: 2006/02/13
   2 # Arm Architecure Specification
   3 # Author: Matthias Braun, Michael Beck, Oliver Richter, Tobias Gneist
   4 # $Id$
   5
   6 $arch = "arm";
   7
   8 #
   9 # Modes
  10 #
  11 $mode_gp    = "mode_Iu";
  12 $mode_flags = "mode_Bu";
  13 $mode_fp    = "mode_E";
  14
  15 # register types:
  16 $normal      =  0; # no special type
  17 $caller_save =  1; # caller save (register must be saved by the caller of a function)
  18 $callee_save =  2; # callee save (register must be saved by the called function)
  19 $ignore      =  4; # ignore (do not assign this register)
  20 $arbitrary   =  8; # emitter can choose an arbitrary register of this class
  21 $virtual     = 16; # the register is a virtual one
  22 $state       = 32; # register represents a state
  23 # NOTE: Last entry of each class is the largest Firm-Mode a register can hold
  24 %reg_classes = (
  25         gp => [
  26                 { name => "r0",  type => $caller_save },
  27                 { name => "r1",  type => $caller_save },
  28                 { name => "r2",  type => $caller_save },
  29                 { name => "r3",  type => $caller_save },
  30                 { name => "r4",  type => $callee_save },
  31                 { name => "r5",  type => $callee_save },
  32                 { name => "r6",  type => $callee_save },
  33                 { name => "r7",  type => $callee_save },
  34                 { name => "r8",  type => $callee_save },
  35                 { name => "r9",  type => $callee_save },
  36                 { name => "r10", type => $callee_save },
  37                 { name => "r11", type => $callee_save },
  38                 { name => "r12", type => $ignore }, # reserved for linker/immediate fixups
  39                 { name => "sp",  type => $ignore }, # this is our stack pointer
  40                 { name => "lr",  type => $callee_save | $caller_save }, # this is our return address
  41                 { name => "pc",  type => $ignore }, # this is our program counter
  42                 { mode => $mode_gp }
  43         ],
  44         fpa => [
  45                 { name => "f0", type => $caller_save },
  46                 { name => "f1", type => $caller_save },
  47                 { name => "f2", type => $caller_save },
  48                 { name => "f3", type => $caller_save },
  49                 { name => "f4", type => $caller_save },
  50                 { name => "f5", type => $caller_save },
  51                 { name => "f6", type => $caller_save },
  52                 { name => "f7", type => $caller_save },
  53                 { mode => $mode_fp }
  54         ],
  55         flags => [
  56                 { name => "fl", type => 0 },
  57                 { mode => $mode_flags, flags => "manual_ra" }
  58         ],
  59 );
  60
  61 %emit_templates = (
  62         FM  => "${arch}_emit_float_load_store_mode(node);",
  63         AM  => "${arch}_emit_float_arithmetic_mode(node);",
  64         LM  => "${arch}_emit_load_mode(node);",
  65         SM  => "${arch}_emit_store_mode(node);",
  66         SO  => "${arch}_emit_shifter_operand(node);",
  67         S0  => "${arch}_emit_source_register(node, 0);",
  68         SC  => "${arch}_emit_symconst(node);",
  69         S1  => "${arch}_emit_source_register(node, 1);",
  70         S2  => "${arch}_emit_source_register(node, 2);",
  71         S3  => "${arch}_emit_source_register(node, 3);",
  72         S4  => "${arch}_emit_source_register(node, 4);",
  73         D0  => "${arch}_emit_dest_register(node, 0);",
  74         D1  => "${arch}_emit_dest_register(node, 1);",
  75         D2  => "${arch}_emit_dest_register(node, 2);",
  76         O   => "${arch}_emit_offset(node);",
  77 );
  78
  79 $default_attr_type = "arm_attr_t";
  80 $default_copy_attr = "arm_copy_attr";
  81
  82 %init_attr = (
  83         arm_attr_t           => "\tinit_arm_attributes(res, flags, in_reqs, exec_units, n_res);",
  84         arm_SymConst_attr_t  =>
  85                 "\tinit_arm_attributes(res, flags, in_reqs, exec_units, n_res);\n".
  86                 "\tinit_arm_SymConst_attributes(res, entity, symconst_offset);",
  87         arm_CondJmp_attr_t   => "\tinit_arm_attributes(res, flags, in_reqs, exec_units, n_res);",
  88         arm_SwitchJmp_attr_t => "\tinit_arm_attributes(res, flags, in_reqs, exec_units, n_res);",
  89         arm_fConst_attr_t    => "\tinit_arm_attributes(res, flags, in_reqs, exec_units, n_res);",
  90         arm_load_store_attr_t =>
  91                 "\tinit_arm_attributes(res, flags, in_reqs, exec_units, n_res);\n".
  92                 "\tinit_arm_load_store_attributes(res, ls_mode, entity, entity_sign, offset, is_frame_entity);",
  93         arm_shifter_operand_t =>
  94                 "\tinit_arm_attributes(res, flags, in_reqs, exec_units, n_res);\n",
  95         arm_cmp_attr_t =>
  96                 "\tinit_arm_attributes(res, flags, in_reqs, exec_units, n_res);\n",
  97         arm_farith_attr_t =>
  98                 "\tinit_arm_attributes(res, flags, in_reqs, exec_units, n_res);\n".
  99                 "\tinit_arm_farith_attributes(res, op_mode);",
 100         arm_CopyB_attr_t =>
 101                 "\tinit_arm_attributes(res, flags, in_reqs, exec_units, n_res);\n".
 102                 "\tinit_arm_CopyB_attributes(res, size);",
 103 );
 104
 105 %compare_attr = (
 106         arm_attr_t            => "cmp_attr_arm",
 107         arm_SymConst_attr_t   => "cmp_attr_arm_SymConst",
 108         arm_CondJmp_attr_t    => "cmp_attr_arm_CondJmp",
 109         arm_SwitchJmp_attr_t  => "cmp_attr_arm_SwitchJmp",
 110         arm_fConst_attr_t     => "cmp_attr_arm_fConst",
 111         arm_load_store_attr_t => "cmp_attr_arm_load_store",
 112         arm_shifter_operand_t => "cmp_attr_arm_shifter_operand",
 113         arm_CopyB_attr_t      => "cmp_attr_arm_CopyB",
 114         arm_cmp_attr_t        => "cmp_attr_arm_cmp",
 115         arm_farith_attr_t     => "cmp_attr_arm_farith",
 116 );
 117
 118 my %unop_shifter_operand_constructors = (
 119         imm => {
 120                 attr       => "unsigned char immediate_value, unsigned char immediate_rot",
 121                 custominit => "init_arm_shifter_operand(res, immediate_value, ARM_SHF_IMM, immediate_rot);",
 122                 reg_req    => { in => [], out => [ "gp" ] },
 123         },
 124         reg => {
 125                 custominit => "init_arm_shifter_operand(res, 0, ARM_SHF_REG, 0);",
 126                 reg_req    => { in => [ "gp" ], out => [ "gp" ] },
 127         },
 128         reg_shift_reg => {
 129                 attr       => "arm_shift_modifier_t shift_modifier",
 130                 custominit => "init_arm_shifter_operand(res, 0, shift_modifier, 0);",
 131                 reg_req    => { in => [ "gp", "gp" ], out => [ "gp" ] },
 132         },
 133         reg_shift_imm => {
 134                 attr       => "arm_shift_modifier_t shift_modifier, unsigned shift_immediate",
 135                 custominit => "init_arm_shifter_operand(res, 0, shift_modifier, shift_immediate);",
 136                 reg_req    => { in => [ "gp" ], out => [ "gp" ] },
 137         },
 138 );
 139
 140 my %binop_shifter_operand_constructors = (
 141         imm => {
 142                 attr       => "unsigned char immediate_value, unsigned char immediate_rot",
 143                 custominit => "init_arm_shifter_operand(res, immediate_value, ARM_SHF_IMM, immediate_rot);",
 144                 reg_req    => { in => [ "gp" ], out => [ "gp" ] },
 145                 ins        => [ "left" ],
 146         },
 147         reg => {
 148                 custominit => "init_arm_shifter_operand(res, 0, ARM_SHF_REG, 0);",
 149                 reg_req    => { in => [ "gp", "gp" ], out => [ "gp" ] },
 150                 ins        => [ "left", "right" ],
 151         },
 152         reg_shift_reg => {
 153                 attr       => "arm_shift_modifier_t shift_modifier",
 154                 custominit => "init_arm_shifter_operand(res, 0, shift_modifier, 0);",
 155                 reg_req    => { in => [ "gp", "gp", "gp" ], out => [ "gp" ] },
 156                 ins        => [ "left", "right", "shift" ],
 157         },
 158         reg_shift_imm => {
 159                 attr       => "arm_shift_modifier_t shift_modifier, unsigned shift_immediate",
 160                 custominit => "init_arm_shifter_operand(res, 0, shift_modifier, shift_immediate);",
 161                 reg_req    => { in => [ "gp", "gp" ], out => [ "gp" ] },
 162                 ins        => [ "left", "right" ],
 163         },
 164 );
 165
 166 my %cmp_shifter_operand_constructors = (
 167         imm => {
 168                 attr       => "unsigned char immediate_value, unsigned char immediate_rot, bool ins_permuted, bool is_unsigned",
 169                 custominit =>
 170                         "init_arm_shifter_operand(res, immediate_value, ARM_SHF_IMM, immediate_rot);\n".
 171                         "\tinit_arm_cmp_attr(res, ins_permuted, is_unsigned);",
 172                 reg_req    => { in => [ "gp" ], out => [ "flags" ] },
 173                 ins        => [ "left" ],
 174         },
 175         reg => {
 176                 attr       => "bool ins_permuted, bool is_unsigned",
 177                 custominit =>
 178                         "init_arm_shifter_operand(res, 0, ARM_SHF_REG, 0);\n".
 179                         "\tinit_arm_cmp_attr(res, ins_permuted, is_unsigned);",
 180                 reg_req    => { in => [ "gp", "gp" ], out => [ "flags" ] },
 181                 ins        => [ "left", "right" ],
 182         },
 183         reg_shift_reg => {
 184                 attr       => "arm_shift_modifier_t shift_modifier, bool ins_permuted, bool is_unsigned",
 185                 custominit =>
 186                         "init_arm_shifter_operand(res, 0, shift_modifier, 0);\n".
 187                         "\tinit_arm_cmp_attr(res, ins_permuted, is_unsigned);",
 188                 reg_req    => { in => [ "gp", "gp", "gp" ], out => [ "flags" ] },
 189                 ins        => [ "left", "right", "shift" ],
 190         },
 191         reg_shift_imm => {
 192                 attr       => "arm_shift_modifier_t shift_modifier, unsigned shift_immediate, bool ins_permuted, bool is_unsigned",
 193                 custominit =>
 194                         "init_arm_shifter_operand(res, 0, shift_modifier, shift_immediate);\n".
 195                         "\tinit_arm_cmp_attr(res, ins_permuted, is_unsigned);",
 196                 reg_req    => { in => [ "gp", "gp" ], out => [ "flags" ] },
 197                 ins        => [ "left", "right" ],
 198         },
 199 );
 200
 201
 202 %nodes = (
 203
 204 Add => {
 205         irn_flags => [ "rematerializable" ],
 206         emit      => '. add %D0, %S0, %SO',
 207         mode      => $mode_gp,
 208         attr_type => "arm_shifter_operand_t",
 209         constructors => \%binop_shifter_operand_constructors,
 210 },
 211
 212 Mul => {
 213         irn_flags => [ "rematerializable" ],
 214         reg_req   => { in => [ "gp", "gp" ], out => [ "!in_r1" ] },
 215         emit      =>'. mul %D0, %S0, %S1',
 216         mode      => $mode_gp,
 217 },
 218
 219 Smull => {
 220         irn_flags => [ "rematerializable" ],
 221         reg_req   => { in => [ "gp", "gp" ], out => [ "gp", "gp" ] },
 222         emit      =>'. smull %D0, %D1, %S0, %S1',
 223         outs      => [ "low", "high" ],
 224 },
 225
 226 Umull => {
 227         irn_flags => [ "rematerializable" ],
 228         reg_req   => { in => [ "gp", "gp" ], out => [ "gp", "gp" ] },
 229         emit      =>'. umull %D0, %D1, %S0, %S1',
 230         outs      => [ "low", "high" ],
 231         mode      => $mode_gp,
 232 },
 233
 234 Mla => {
 235         irn_flags => [ "rematerializable" ],
 236         reg_req   => { in => [ "gp", "gp", "gp" ], out => [ "!in_r1" ] },
 237         emit      =>'. mla %D0, %S0, %S1, %S2',
 238         mode      => $mode_gp,
 239 },
 240
 241 And => {
 242         irn_flags => [ "rematerializable" ],
 243         emit      => '. and %D0, %S0, %SO',
 244         mode      => $mode_gp,
 245         attr_type => "arm_shifter_operand_t",
 246         constructors => \%binop_shifter_operand_constructors,
 247 },
 248
 249 Or => {
 250         irn_flags => [ "rematerializable" ],
 251         emit      => '. orr %D0, %S0, %SO',
 252         mode      => $mode_gp,
 253         attr_type => "arm_shifter_operand_t",
 254         constructors => \%binop_shifter_operand_constructors,
 255 },
 256
 257 Eor => {
 258         irn_flags => [ "rematerializable" ],
 259         emit      => '. eor %D0, %S0, %SO',
 260         mode      => $mode_gp,
 261         attr_type => "arm_shifter_operand_t",
 262         constructors => \%binop_shifter_operand_constructors,
 263 },
 264
 265 Bic => {
 266         irn_flags => [ "rematerializable" ],
 267         emit      => '. bic %D0, %S0, %SO',
 268         mode      => $mode_gp,
 269         attr_type => "arm_shifter_operand_t",
 270         constructors => \%binop_shifter_operand_constructors,
 271 },
 272
 273 Sub => {
 274         irn_flags => [ "rematerializable" ],
 275         emit      => '. sub %D0, %S0, %SO',
 276         mode      => $mode_gp,
 277         attr_type => "arm_shifter_operand_t",
 278         constructors => \%binop_shifter_operand_constructors,
 279 },
 280
 281 Rsb => {
 282         irn_flags => [ "rematerializable" ],
 283         emit      => '. rsb %D0, %S0, %SO',
 284         mode      => $mode_gp,
 285         attr_type => "arm_shifter_operand_t",
 286         constructors => \%binop_shifter_operand_constructors,
 287 },
 288
 289 Mov => {
 290         irn_flags => [ "rematerializable" ],
 291         arity     => "variable",
 292         emit      => '. mov %D0, %SO',
 293         mode      => $mode_gp,
 294         attr_type => "arm_shifter_operand_t",
 295         constructors => \%unop_shifter_operand_constructors,
 296 },
 297
 298 Mvn => {
 299         irn_flags => [ "rematerializable" ],
 300         attr_type => "arm_shifter_operand_t",
 301         arity     => "variable",
 302         emit      => '. mvn %D0, %SO',
 303         mode      => $mode_gp,
 304         constructors => \%unop_shifter_operand_constructors,
 305 },
 306
 307 Clz => {
 308         irn_flags => [ "rematerializable" ],
 309         reg_req   => { in => [ "gp" ], out => [ "gp" ] },
 310         emit      =>'. clz %D0, %S0',
 311         mode      => $mode_gp,
 312 },
 313
 314 # mov lr, pc\n mov pc, XXX -- This combination is used for calls to function
 315 # pointers
 316 LinkMovPC => {
 317         state        => "exc_pinned",
 318         arity        => "variable",
 319         out_arity    => "variable",
 320         attr_type    => "arm_shifter_operand_t",
 321         attr         => "arm_shift_modifier_t shift_modifier, unsigned char immediate_value, unsigned char immediate_rot",
 322         custominit   => "init_arm_shifter_operand(res, immediate_value, shift_modifier, immediate_rot);\n".
 323                         "\tarch_irn_add_flags(res, arch_irn_flags_modify_flags);",
 324         emit         => ". mov lr, pc\n".
 325                         ". mov pc, %SO",
 326 },
 327
 328 # mov lr, pc\n ldr pc, XXX -- This combination is used for calls to function
 329 # pointers
 330 LinkLdrPC => {
 331         state        => "exc_pinned",
 332         arity        => "variable",
 333         out_arity    => "variable",
 334         attr_type    => "arm_load_store_attr_t",
 335         attr         => "ir_mode *ls_mode, ir_entity *entity, int entity_sign, long offset, bool is_frame_entity",
 336         custominit   => "arch_irn_add_flags(res, arch_irn_flags_modify_flags);",
 337         emit         => ". mov lr, pc\n".
 338                         ". ldr pc, %SO",
 339 },
 340
 341 Bl => {
 342         state      => "exc_pinned",
 343         arity      => "variable",
 344         out_arity  => "variable",
 345         attr_type  => "arm_SymConst_attr_t",
 346         attr       => "ir_entity *entity, int symconst_offset",
 347         custominit => "arch_irn_add_flags(res, arch_irn_flags_modify_flags);",
 348         emit       => '. bl %SC',
 349 },
 350
 351 # this node produces ALWAYS an empty (tempary) gp reg and cannot be CSE'd
 352 EmptyReg => {
 353         op_flags  => [ "constlike" ],
 354         irn_flags => [ "rematerializable" ],
 355         reg_req   => { out => [ "gp" ] },
 356         emit      => '. /* %D0 now available for calculations */',
 357         cmp_attr  => 'return 1;',
 358         mode      => $mode_gp,
 359 },
 360
 361 CopyB => {
 362         op_flags  => [ "fragile" ],
 363         state     => "pinned",
 364         attr      => "unsigned size",
 365         attr_type => "arm_CopyB_attr_t",
 366         reg_req   => { in => [ "!sp", "!sp", "gp", "gp", "gp", "none" ], out => [ "none" ] },
 367         outs      => [ "M" ],
 368 },
 369
 370 FrameAddr => {
 371         op_flags  => [ "constlike" ],
 372         irn_flags => [ "rematerializable" ],
 373         attr      => "ir_entity *entity, int symconst_offset",
 374         reg_req   => { in => [ "gp" ], out => [ "gp" ] },
 375         ins       => [ "base" ],
 376         attr_type => "arm_SymConst_attr_t",
 377         mode      => $mode_gp,
 378 },
 379
 380 SymConst => {
 381         op_flags  => [ "constlike" ],
 382         irn_flags => [ "rematerializable" ],
 383         attr      => "ir_entity *entity, int symconst_offset",
 384         reg_req   => { out => [ "gp" ] },
 385         attr_type => "arm_SymConst_attr_t",
 386         mode      => $mode_gp,
 387 },
 388
 389 Cmp => {
 390         irn_flags    => [ "rematerializable", "modify_flags" ],
 391         emit         => '. cmp %S0, %SO',
 392         mode         => $mode_flags,
 393         attr_type    => "arm_cmp_attr_t",
 394         constructors => \%cmp_shifter_operand_constructors,
 395 },
 396
 397 Tst => {
 398         irn_flags    => [ "rematerializable", "modify_flags" ],
 399         emit         => '. tst %S0, %SO',
 400         mode         => $mode_flags,
 401         attr_type    => "arm_cmp_attr_t",
 402         constructors => \%cmp_shifter_operand_constructors,
 403 },
 404
 405 B => {
 406         op_flags  => [ "labeled", "cfopcode", "forking" ],
 407         state     => "pinned",
 408         mode      => "mode_T",
 409         reg_req   => { in => [ "flags" ], out => [ "none", "none" ] },
 410         attr      => "pn_Cmp pnc",
 411         attr_type => "arm_CondJmp_attr_t",
 412         init_attr => "\tset_arm_CondJmp_pnc(res, pnc);",
 413 },
 414
 415 Jmp => {
 416         state     => "pinned",
 417         op_flags  => [ "cfopcode" ],
 418         irn_flags => [ "simple_jump" ],
 419         reg_req   => { out => [ "none" ] },
 420         mode      => "mode_X",
 421 },
 422
 423 SwitchJmp => {
 424         op_flags  => [ "labeled", "cfopcode", "forking" ],
 425         state     => "pinned",
 426         mode      => "mode_T",
 427         attr      => "int n_projs, long def_proj_num",
 428         init_attr => "\tset_arm_SwitchJmp_n_projs(res, n_projs);\n".
 429                      "\tset_arm_SwitchJmp_default_proj_num(res, def_proj_num);",
 430         reg_req   => { in => [ "gp" ], out => [ "none" ] },
 431         attr_type => "arm_SwitchJmp_attr_t",
 432 },
 433
 434 Ldr => {
 435         op_flags  => [ "labeled", "fragile" ],
 436         state     => "exc_pinned",
 437         ins       => [ "ptr", "mem" ],
 438         outs      => [ "res", "M" ],
 439         reg_req   => { in => [ "gp", "none" ], out => [ "gp", "none" ] },
 440         emit      => '. ldr%LM %D0, [%S0, #%O]',
 441         attr_type => "arm_load_store_attr_t",
 442         attr      => "ir_mode *ls_mode, ir_entity *entity, int entity_sign, long offset, bool is_frame_entity",
 443 },
 444
 445 Str => {
 446         op_flags  => [ "labeled", "fragile" ],
 447         state     => "exc_pinned",
 448         ins       => [ "ptr", "val", "mem" ],
 449         outs      => [ "M" ],
 450         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "none" ] },
 451         emit      => '. str%SM %S1, [%S0, #%O]',
 452         mode      => "mode_M",
 453         attr_type => "arm_load_store_attr_t",
 454         attr      => "ir_mode *ls_mode, ir_entity *entity, int entity_sign, long offset, bool is_frame_entity",
 455 },
 456
 457 StoreStackM4Inc => {
 458         op_flags  => [ "labeled", "fragile" ],
 459         irn_flags => [ "rematerializable" ],
 460         state     => "exc_pinned",
 461         reg_req   => { in => [ "sp", "gp", "gp", "gp", "gp", "none" ], out => [ "sp:I|S", "none" ] },
 462         emit      => '. stmfd %S0!, {%S1, %S2, %S3, %S4}',
 463         outs      => [ "ptr", "M" ],
 464 },
 465
 466 LoadStackM3Epilogue => {
 467         op_flags  => [ "labeled", "fragile" ],
 468         irn_flags => [ "rematerializable" ],
 469         state     => "exc_pinned",
 470         reg_req   => { in => [ "sp", "none" ], out => [ "r11:I", "sp:I|S", "pc:I", "none" ] },
 471         emit      => '. ldmfd %S0, {%D0, %D1, %D2}',
 472         outs      => [ "res0", "res1", "res2", "M" ],
 473 },
 474
 475
 476
 477 Adf => {
 478         irn_flags => [ "rematerializable" ],
 479         reg_req   => { in => [ "fpa", "fpa" ], out => [ "fpa" ] },
 480         emit      => '. adf%AM %D0, %S0, %S1',
 481         attr_type => "arm_farith_attr_t",
 482         attr      => "ir_mode *op_mode",
 483         mode      => $mode_fp,
 484 },
 485
 486 Muf => {
 487         irn_flags => [ "rematerializable" ],
 488         reg_req   => { in => [ "fpa", "fpa" ], out => [ "fpa" ] },
 489         emit      =>'. muf%AM %D0, %S0, %S1',
 490         attr_type => "arm_farith_attr_t",
 491         attr      => "ir_mode *op_mode",
 492         mode      => $mode_fp,
 493 },
 494
 495 Suf => {
 496         irn_flags => [ "rematerializable" ],
 497         reg_req   => { in => [ "fpa", "fpa" ], out => [ "fpa" ] },
 498         emit      => '. suf%AM %D0, %S0, %S1',
 499         attr_type => "arm_farith_attr_t",
 500         attr      => "ir_mode *op_mode",
 501         mode      => $mode_fp,
 502 },
 503
 504 Dvf => {
 505         reg_req   => { in => [ "fpa", "fpa" ], out => [ "fpa", "none" ] },
 506         emit      =>'. dvf%AM %D0, %S0, %S1',
 507         outs      => [ "res", "M" ],
 508         attr_type => "arm_farith_attr_t",
 509         attr      => "ir_mode *op_mode",
 510         mode      => $mode_fp,
 511 },
 512
 513 Mvf => {
 514         irn_flags => [ "rematerializable" ],
 515         reg_req   => { in => [ "fpa" ], out => [ "fpa" ] },
 516         emit      => '. mvf%AM %S0, %D0',
 517         attr_type => "arm_farith_attr_t",
 518         attr      => "ir_mode *op_mode",
 519         mode      => $mode_fp,
 520 },
 521
 522 FltX => {
 523         irn_flags => [ "rematerializable" ],
 524         reg_req   => { in => [ "gp" ], out => [ "fpa" ] },
 525         emit      => '. flt%AM %D0, %S0',
 526         attr_type => "arm_farith_attr_t",
 527         attr      => "ir_mode *op_mode",
 528         mode      => $mode_fp,
 529 },
 530
 531 Cmfe => {
 532         irn_flags => [ "rematerializable", "modify_flags" ],
 533         mode      => $mode_flags,
 534         attr_type => "arm_cmp_attr_t",
 535         attr      => "bool ins_permuted",
 536         init_attr => "init_arm_cmp_attr(res, ins_permuted, false);",
 537         reg_req   => { in => [ "fpa", "fpa" ], out => [ "flags" ] },
 538         emit      => '. cmfe %S0, %S1',
 539 },
 540
 541 Ldf => {
 542         op_flags  => [ "labeled", "fragile" ],
 543         state     => "exc_pinned",
 544         ins       => [ "ptr", "mem" ],
 545         outs      => [ "res", "M" ],
 546         reg_req   => { in => [ "gp", "none" ], out => [ "fpa", "none" ] },
 547         emit      => '. ldf%FM %D0, [%S0, #%O]',
 548         attr_type => "arm_load_store_attr_t",
 549         attr      => "ir_mode *ls_mode, ir_entity *entity, int entity_sign, long offset, bool is_frame_entity",
 550 },
 551
 552 Stf => {
 553         op_flags  => [ "labeled", "fragile" ],
 554         state     => "exc_pinned",
 555         ins       => [ "ptr", "val", "mem" ],
 556         outs      => [ "M" ],
 557         mode      => "mode_M",
 558         reg_req   => { in => [ "gp", "fpa", "none" ], out => [ "none" ] },
 559         emit      => '. stf%FM %S1, [%S0, #%O]',
 560         attr_type => "arm_load_store_attr_t",
 561         attr      => "ir_mode *ls_mode, ir_entity *entity, int entity_sign, long offset, bool is_frame_entity",
 562 },
 563
 564 #
 565 # floating point constants
 566 #
 567 fConst => {
 568         op_flags  => [ "constlike" ],
 569         irn_flags => [ "rematerializable" ],
 570         attr      => "tarval *tv",
 571         init_attr => "attr->tv = tv;",
 572         mode      => "get_tarval_mode(tv)",
 573         reg_req   => { out => [ "fpa" ] },
 574         attr_type => "arm_fConst_attr_t",
 575 }
 576
 577 ); # end of %nodes