belive: Avoid duplicate map lookups when calculating the liveness of a node in a...

[libfirm] / ir / be / TEMPLATE / TEMPLATE_spec.pl

diff --git a/ir/be/TEMPLATE/TEMPLATE_spec.pl b/ir/be/TEMPLATE/TEMPLATE_spec.pl
index 6518546..adec64b 100644 (file)
--- a/ir/be/TEMPLATE/TEMPLATE_spec.pl
+++ b/ir/be/TEMPLATE/TEMPLATE_spec.pl
@@ -56,11 +56,10 @@ $mode_fp  = "mode_F";  # mode used by floatingpoint registers
 # comment: OPTIONAL comment for the node constructor
 #
 # register types:
-#   0 - no special type
-#   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
+#   none    - no special type
+#   ignore  - ignore (do not assign this register)
+#   virtual - the register is a virtual one
+#   state   - register represents a state
 # NOTE: Last entry of each class is the largest Firm-Mode a register can hold
 %reg_classes = (
        gp => [
@@ -78,8 +77,8 @@ $mode_fp  = "mode_F";  # mode used by floatingpoint registers
                { name => "r11" },
                { name => "r12" },
                { name => "r13" },
-               { name => "sp", realname => "r14", type => 1 },  # stackpointer
-               { name => "bp", realname => "r15", type => 1 },  # basepointer
+               { name => "sp", realname => "r14", type => "ignore" }, # stackpointer
+               { name => "bp", realname => "r15", type => "ignore" }, # basepointer
                { mode => $mode_gp }
        ],
        fp => [
@@ -103,22 +102,6 @@ $mode_fp  = "mode_F";  # mode used by floatingpoint registers
        ]
 );
 
-%emit_templates = (
-       S1 => "${arch}_emit_source_register(node, 0);",
-       S2 => "${arch}_emit_source_register(node, 1);",
-       S3 => "${arch}_emit_source_register(node, 2);",
-       S4 => "${arch}_emit_source_register(node, 3);",
-       S5 => "${arch}_emit_source_register(node, 4);",
-       S6 => "${arch}_emit_source_register(node, 5);",
-       D1 => "${arch}_emit_dest_register(node, 0);",
-       D2 => "${arch}_emit_dest_register(node, 1);",
-       D3 => "${arch}_emit_dest_register(node, 2);",
-       D4 => "${arch}_emit_dest_register(node, 3);",
-       D5 => "${arch}_emit_dest_register(node, 4);",
-       D6 => "${arch}_emit_dest_register(node, 5);",
-       C  => "${arch}_emit_immediate(node);"
-);
-
 $default_attr_type = "TEMPLATE_attr_t";
 $default_copy_attr = "TEMPLATE_copy_attr";
 
@@ -130,7 +113,7 @@ Add => {
        op_flags  => [ "commutative" ],
        irn_flags => [ "rematerializable" ],
        reg_req   => { in => [ "gp", "gp" ], out => [ "gp" ] },
-       emit      => '. add %S1, %S2, %D1',
+       emit      => 'add %S1, %S2, %D1',
        mode      => $mode_gp,
 },
 
@@ -138,7 +121,7 @@ Mul => {
        op_flags  => [ "commutative" ],
        irn_flags => [ "rematerializable" ],
        reg_req   => { in => [ "gp", "gp" ], out => [ "gp" ] },
-       emit      =>'. mul %S1, %S2, %D1',
+       emit      =>'mul %S1, %S2, %D1',
        mode      => $mode_gp,
 },
 
@@ -146,7 +129,7 @@ And => {
        op_flags  => [ "commutative" ],
        irn_flags => [ "rematerializable" ],
        reg_req   => { in => [ "gp", "gp" ], out => [ "gp" ] },
-       emit      => '. and %S1, %S2, %D1',
+       emit      => 'and %S1, %S2, %D1',
        mode      => $mode_gp,
 },
 
@@ -154,7 +137,7 @@ Or => {
        op_flags  => [ "commutative" ],
        irn_flags => [ "rematerializable" ],
        reg_req   => { in => [ "gp", "gp" ], out => [ "gp" ] },
-       emit      => '. or %S1, %S2, %D1',
+       emit      => 'or %S1, %S2, %D1',
        mode      => $mode_gp,
 },
 
@@ -162,35 +145,35 @@ Xor => {
        op_flags  => [ "commutative" ],
        irn_flags => [ "rematerializable" ],
        reg_req   => { in => [ "gp", "gp" ], out => [ "gp" ] },
-       emit      => '. xor %S1, %S2, %D1',
+       emit      => 'xor %S1, %S2, %D1',
        mode      => $mode_gp,
 },
 
 Sub => {
        irn_flags => [ "rematerializable" ],
        reg_req   => { in => [ "gp", "gp" ], out => [ "gp" ] },
-       emit      => '. sub %S1, %S2, %D1',
+       emit      => 'sub %S1, %S2, %D1',
        mode      => $mode_gp,
 },
 
 Shl => {
        irn_flags => [ "rematerializable" ],
        reg_req   => { in => [ "gp", "gp" ], out => [ "gp" ] },
-       emit      => '. shl %S1, %S2, %D1',
+       emit      => 'shl %S1, %S2, %D1',
        mode      => $mode_gp,
 },
 
 Shr => {
        irn_flags => [ "rematerializable" ],
        reg_req   => { in => [ "gp", "gp" ], out => [ "in_r1" ] },
-       emit      => '. shr %S2, %D1',
+       emit      => 'shr %S2, %D1',
        mode      => $mode_gp,
 },
 
 Minus => {
        irn_flags => [ "rematerializable" ],
        reg_req   => { in => [ "gp" ], out => [ "gp" ] },
-       emit      => '. neg %S1, %D1',
+       emit      => 'neg %S1, %D1',
        mode      => $mode_gp,
 },
 
@@ -198,7 +181,7 @@ Not => {
        arity   => 1,
        remat   => 1,
        reg_req => { in => [ "gp" ], out => [ "gp" ] },
-       emit    => '. not %S1, %D1',
+       emit    => 'not %S1, %D1',
        mode    => $mode_gp,
 },
 
@@ -208,7 +191,7 @@ Const => {
        attr       => "ir_tarval *value",
        custominit => "set_TEMPLATE_value(res, value);",
        reg_req    => { out => [ "gp" ] },
-       emit       => '. mov %C, %D1',
+       emit       => 'mov %I, %D1',
        cmp_attr   =>
 '
        /* TODO: compare Const attributes */
@@ -227,22 +210,37 @@ Jmp => {
        mode      => "mode_X",
 },
 
+Start => {
+       state     => "pinned",
+       reg_req   => { in => [], out => [ "sp:I|S", "none" ] },
+       outs      => [ "stack", "M" ],
+       ins       => [],
+},
+
+Return => {
+       state    => "pinned",
+       op_flags => [ "cfopcode" ],
+       ins      => [ "stack", "mem" ],
+       reg_req  => { in => [ "sp", "none", ], out => [] },
+       mode     => "mode_X",
+},
+
 # Load / Store
 
 Load => {
-       op_flags  => [ "labeled" ],
+       op_flags  => [ "uses_memory" ],
        irn_flags => [ "rematerializable" ],
        state     => "exc_pinned",
        reg_req   => { in => [ "gp", "none" ], out => [ "gp" ] },
-       emit      => '. mov (%S1), %D1',
+       emit      => 'mov (%S1), %D1',
 },
 
 Store => {
-       op_flags  => [ "labeled" ],
+       op_flags  => [ "uses_memory" ],
        irn_flags => [ "rematerializable" ],
        state     => "exc_pinned",
        reg_req   => { in => [ "gp", "gp", "none" ] },
-       emit      => '. movl %S2, (%S1)',
+       emit      => 'movl %S2, (%S1)',
 },
 
 # Floating Point operations
@@ -251,34 +249,34 @@ fAdd => {
        op_flags  => [ "commutative" ],
        irn_flags => [ "rematerializable" ],
        reg_req   => { in => [ "fp", "fp" ], out => [ "fp" ] },
-       emit      => '. fadd %S1, %S2, %D1',
+       emit      => 'fadd %S1, %S2, %D1',
        mode    => $mode_fp,
 },
 
 fMul => {
        op_flags  => [ "commutative" ],
        reg_req   => { in => [ "fp", "fp" ], out => [ "fp" ] },
-       emit      =>'. fmul %S1, %S2, %D1',
+       emit      =>'fmul %S1, %S2, %D1',
        mode      => $mode_fp,
 },
 
 fSub => {
        irn_flags => [ "rematerializable" ],
        reg_req   => { in => [ "fp", "fp" ], out => [ "fp" ] },
-       emit      => '. fsub %S1, %S2, %D1',
+       emit      => 'fsub %S1, %S2, %D1',
        mode      => $mode_fp,
 },
 
 fDiv => {
        reg_req   => { in => [ "fp", "fp" ], out => [ "fp" ] },
-       emit      => '. fdiv %S1, %S2, %D1',
+       emit      => 'fdiv %S1, %S2, %D1',
        mode      => $mode_fp,
 },
 
 fMinus => {
        irn_flags => [ "rematerializable" ],
        reg_req   => { in => [ "fp" ], out => [ "fp" ] },
-       emit      => '. fneg %S1, %D1',
+       emit      => 'fneg %S1, %D1',
        mode      => $mode_fp,
 },
 
@@ -286,7 +284,7 @@ fConst => {
        op_flags  => [ "constlike" ],
        irn_flags => [ "rematerializable" ],
        reg_req   => { out => [ "fp" ] },
-       emit      => '. fmov %C, %D1',
+       emit      => 'fmov %I, %D1',
        cmp_attr  =>
 '
        /* TODO: compare fConst attributes */
@@ -298,19 +296,19 @@ fConst => {
 # Load / Store
 
 fLoad => {
-       op_flags  => [ "labeled" ],
+       op_flags  => [ "uses_memory" ],
        irn_flags => [ "rematerializable" ],
        state     => "exc_pinned",
        reg_req   => { in => [ "gp", "none" ], out => [ "fp" ] },
-       emit      => '. fmov (%S1), %D1',
+       emit      => 'fmov (%S1), %D1',
 },
 
 fStore => {
-       op_flags  => [ "labeled" ],
+       op_flags  => [ "uses_memory" ],
        irn_flags => [ "rematerializable" ],
        state     => "exc_pinned",
        reg_req   => { in => [ "gp", "fp", "none" ] },
-       emit      => '. fmov %S2, (%S1)',
+       emit      => 'fmov %S2, (%S1)',
 },
 
 );