# %nodes = (
#
# <op-name> => {
-# op_flags => "N|L|C|X|I|F|Y|H|c|K", # optional
-# irn_flags => "R|N|I" # optional
# arity => "0|1|2|3 ... |variable|dynamic|any", # optional
# state => "floats|pinned|mem_pinned|exc_pinned", # optional
# args => [
#
# ); # close the %nodes initializer
-# op_flags: flags for the operation, OPTIONAL (default is "N")
-# the op_flags correspond to the firm irop_flags:
-# N irop_flag_none
-# L irop_flag_labeled
-# C irop_flag_commutative
-# X irop_flag_cfopcode
-# I irop_flag_ip_cfopcode
-# F irop_flag_fragile
-# Y irop_flag_forking
-# H irop_flag_highlevel
-# c irop_flag_constlike
-# K irop_flag_keep
-#
-# irn_flags: special node flags, OPTIONAL (default is 0)
-# following irn_flags are supported:
-# R rematerializeable
-# N not spillable
-# I ignore for register allocation
-#
# state: state of the operation, OPTIONAL (default is "floats")
#
# arity: arity of the operation, MUST NOT BE OMITTED
#
# comment: OPTIONAL comment for the node constructor
#
-# rd_constructor: for every operation there will be a
-# new_rd_<arch>_<op-name> function with the arguments from above
-# which creates the ir_node corresponding to the defined operation
-# you can either put the complete source code of this function here
-#
-# This key is OPTIONAL. If omitted, the following constructor will
-# be created:
-# if (!op_<arch>_<op-name>) assert(0);
-# for i = 1 to arity
-# set in[i] = op_i
-# done
-# res = new_ir_node(db, irg, block, op_<arch>_<op-name>, mode, arity, in)
-# return res
-#
-# NOTE: rd_constructor and args are only optional if and only if arity is 0,1,2 or 3
-
# register types:
# 0 - no special type
-# 1 - caller save (register must be saved by the caller of a function)
-# 2 - callee save (register must be saved by the called function)
-# 4 - ignore (do not assign this register)
+# 1 - ignore (do not assign this register)
+# 2 - emitter can choose an arbitrary register of this class
+# 4 - the register is a virtual one
+# 8 - register represents a state
# NOTE: Last entry of each class is the largest Firm-Mode a register can hold
%reg_classes = (
gp => [
- { name => "r0", type => 1 },
- { name => "r1", type => 1 },
- { name => "r2", type => 1 },
- { name => "r3", type => 1 },
- { name => "r4", type => 1 },
- { name => "r5", type => 1 },
- { name => "r6", type => 1 },
- { name => "r7", type => 2 },
- { name => "r8", type => 2 },
- { name => "r9", type => 2 },
- { name => "r10", type => 2 },
- { name => "r11", type => 2 },
- { name => "r12", type => 2 },
- { name => "r13", type => 2 },
- { name => "sp", realname => "r14", type => 4 }, # stackpointer
- { name => "bp", realname => "r15", type => 4 }, # basepointer
+ { name => "r0" },
+ { name => "r1" },
+ { name => "r2" },
+ { name => "r3" },
+ { name => "r4" },
+ { name => "r5" },
+ { name => "r6" },
+ { name => "r7" },
+ { name => "r8" },
+ { name => "r9" },
+ { name => "r10" },
+ { name => "r11" },
+ { name => "r12" },
+ { name => "r13" },
+ { name => "sp", realname => "r14", type => 1 }, # stackpointer
+ { name => "bp", realname => "r15", type => 1 }, # basepointer
{ mode => $mode_gp }
],
fp => [
- { name => "f0", type => 1 },
- { name => "f1", type => 1 },
- { name => "f2", type => 1 },
- { name => "f3", type => 1 },
- { name => "f4", type => 1 },
- { name => "f5", type => 1 },
- { name => "f6", type => 1 },
- { name => "f7", type => 1 },
- { name => "f8", type => 1 },
- { name => "f9", type => 1 },
- { name => "f10", type => 1 },
- { name => "f11", type => 1 },
- { name => "f12", type => 1 },
- { name => "f13", type => 1 },
- { name => "f14", type => 1 },
- { name => "f15", type => 1 },
+ { name => "f0" },
+ { name => "f1" },
+ { name => "f2" },
+ { name => "f3" },
+ { name => "f4" },
+ { name => "f5" },
+ { name => "f6" },
+ { name => "f7" },
+ { name => "f8" },
+ { name => "f9" },
+ { name => "f10" },
+ { name => "f11" },
+ { name => "f12" },
+ { name => "f13" },
+ { name => "f14" },
+ { name => "f15" },
{ mode => $mode_fp }
]
);
C => "${arch}_emit_immediate(node);"
);
+$default_attr_type = "TEMPLATE_attr_t";
+$default_copy_attr = "TEMPLATE_copy_attr";
+
%nodes = (
# Integer nodes
Add => {
- op_flags => "C",
- irn_flags => "R",
+ op_flags => [ "commutative" ],
+ irn_flags => [ "rematerializable" ],
reg_req => { in => [ "gp", "gp" ], out => [ "gp" ] },
emit => '. add %S1, %S2, %D1',
mode => $mode_gp,
},
Mul => {
- op_flags => "C",
- irn_flags => "R",
+ op_flags => [ "commutative" ],
+ irn_flags => [ "rematerializable" ],
reg_req => { in => [ "gp", "gp" ], out => [ "gp" ] },
emit =>'. mul %S1, %S2, %D1',
mode => $mode_gp,
},
And => {
- op_flags => "C",
- irn_flags => "R",
+ op_flags => [ "commutative" ],
+ irn_flags => [ "rematerializable" ],
reg_req => { in => [ "gp", "gp" ], out => [ "gp" ] },
emit => '. and %S1, %S2, %D1',
mode => $mode_gp,
},
Or => {
- op_flags => "C",
- irn_flags => "R",
+ op_flags => [ "commutative" ],
+ irn_flags => [ "rematerializable" ],
reg_req => { in => [ "gp", "gp" ], out => [ "gp" ] },
emit => '. or %S1, %S2, %D1',
mode => $mode_gp,
},
Xor => {
- op_flags => "C",
- irn_flags => "R",
+ op_flags => [ "commutative" ],
+ irn_flags => [ "rematerializable" ],
reg_req => { in => [ "gp", "gp" ], out => [ "gp" ] },
emit => '. xor %S1, %S2, %D1',
mode => $mode_gp,
},
Sub => {
- irn_flags => "R",
+ irn_flags => [ "rematerializable" ],
reg_req => { in => [ "gp", "gp" ], out => [ "gp" ] },
emit => '. sub %S1, %S2, %D1',
mode => $mode_gp,
},
Shl => {
- irn_flags => "R",
+ irn_flags => [ "rematerializable" ],
reg_req => { in => [ "gp", "gp" ], out => [ "gp" ] },
emit => '. shl %S1, %S2, %D1',
mode => $mode_gp,
},
Shr => {
- irn_flags => "R",
+ irn_flags => [ "rematerializable" ],
reg_req => { in => [ "gp", "gp" ], out => [ "in_r1" ] },
emit => '. shr %S2, %D1',
mode => $mode_gp,
},
Minus => {
- irn_flags => "R",
+ irn_flags => [ "rematerializable" ],
reg_req => { in => [ "gp" ], out => [ "gp" ] },
emit => '. neg %S1, %D1',
mode => $mode_gp,
},
Const => {
- op_flags => "c",
- irn_flags => "R",
- attr => "tarval *value",
+ op_flags => [ "constlike" ],
+ irn_flags => [ "rematerializable" ],
+ attr => "ir_tarval *value",
custominit => "set_TEMPLATE_value(res, value);",
reg_req => { out => [ "gp" ] },
emit => '. mov %C, %D1',
Jmp => {
state => "pinned",
- op_flags => "X",
- irn_flags => "J",
+ op_flags => [ "cfopcode" ],
+ irn_flags => [ "simple_jump" ],
reg_req => { out => [ "none" ] },
mode => "mode_X",
},
# Load / Store
Load => {
- op_flags => "L|F",
- irn_flags => "R",
+ op_flags => [ "labeled" ],
+ irn_flags => [ "rematerializable" ],
state => "exc_pinned",
reg_req => { in => [ "gp", "none" ], out => [ "gp" ] },
emit => '. mov (%S1), %D1',
},
Store => {
- op_flags => "L|F",
- irn_flags => "R",
+ op_flags => [ "labeled" ],
+ irn_flags => [ "rematerializable" ],
state => "exc_pinned",
reg_req => { in => [ "gp", "gp", "none" ] },
emit => '. movl %S2, (%S1)',
# Floating Point operations
fAdd => {
- op_flags => "C",
- irn_flags => "R",
+ op_flags => [ "commutative" ],
+ irn_flags => [ "rematerializable" ],
reg_req => { in => [ "fp", "fp" ], out => [ "fp" ] },
emit => '. fadd %S1, %S2, %D1',
mode => $mode_fp,
},
fMul => {
- op_flags => "C",
+ op_flags => [ "commutative" ],
reg_req => { in => [ "fp", "fp" ], out => [ "fp" ] },
emit =>'. fmul %S1, %S2, %D1',
mode => $mode_fp,
},
fSub => {
- irn_flags => "R",
+ irn_flags => [ "rematerializable" ],
reg_req => { in => [ "fp", "fp" ], out => [ "fp" ] },
emit => '. fsub %S1, %S2, %D1',
mode => $mode_fp,
},
fMinus => {
- irn_flags => "R",
+ irn_flags => [ "rematerializable" ],
reg_req => { in => [ "fp" ], out => [ "fp" ] },
emit => '. fneg %S1, %D1',
mode => $mode_fp,
},
fConst => {
- op_flags => "c",
- irn_flags => "R",
+ op_flags => [ "constlike" ],
+ irn_flags => [ "rematerializable" ],
reg_req => { out => [ "fp" ] },
emit => '. fmov %C, %D1',
cmp_attr =>
# Load / Store
fLoad => {
- op_flags => "L|F",
- irn_flags => "R",
+ op_flags => [ "labeled" ],
+ irn_flags => [ "rematerializable" ],
state => "exc_pinned",
reg_req => { in => [ "gp", "none" ], out => [ "fp" ] },
emit => '. fmov (%S1), %D1',
},
fStore => {
- op_flags => "L|F",
- irn_flags => "R",
+ op_flags => [ "labeled" ],
+ irn_flags => [ "rematerializable" ],
state => "exc_pinned",
reg_req => { in => [ "gp", "fp", "none" ] },
emit => '. fmov %S2, (%S1)',