fix fucompp emitter when no register is needed

[libfirm] / ir / be / ia32 / ia32_new_nodes.c

diff --git a/ir/be/ia32/ia32_new_nodes.c b/ir/be/ia32/ia32_new_nodes.c
index 62b7684..d077b3a 100644 (file)
--- a/ir/be/ia32/ia32_new_nodes.c
+++ b/ir/be/ia32/ia32_new_nodes.c
@@ -243,6 +243,23 @@ static int ia32_dump_node(ir_node *n, FILE *F, dump_reason_t reason) {
                        }
                        fprintf(F, "\n");
 
+                       /* dump immop type */
+                       fprintf(F, "immediate = ");
+                       switch (get_ia32_immop_type(n)) {
+                               case ia32_ImmNone:
+                                       fprintf(F, "None");
+                                       break;
+                               case ia32_ImmConst:
+                                       fprintf(F, "Const");
+                                       break;
+                               case ia32_ImmSymConst:
+                                       fprintf(F, "SymConst");
+                                       break;
+                               default:
+                                       fprintf(F, "unknown (%d)", get_ia32_immop_type(n));
+                                       break;
+                       }
+                       fprintf(F, "\n");
 
                        /* dump supported am */
                        fprintf(F, "AM support = ");
@@ -312,6 +329,18 @@ static int ia32_dump_node(ir_node *n, FILE *F, dump_reason_t reason) {
                        /* commutative */
                        fprintf(F, "commutative = %d\n", is_ia32_commutative(n));
 
+                       /* emit cl */
+                       fprintf(F, "emit cl instead of ecx = %d\n", is_ia32_emit_cl(n));
+
+                       /* got lea */
+                       fprintf(F, "got loea = %d\n", is_ia32_got_lea(n));
+
+                       /* got reload */
+                       fprintf(F, "got reload = %d\n", is_ia32_got_reload(n));
+
+                       /* dump latency */
+                       fprintf(F, "latency = %d\n", get_ia32_latency(n));
+
                        /* dump flags */
                        fprintf(F, "flags =");
                        flags = get_ia32_flags(n);
@@ -328,6 +357,9 @@ static int ia32_dump_node(ir_node *n, FILE *F, dump_reason_t reason) {
                                if (flags & arch_irn_flags_ignore) {
                                        fprintf(F, " ignore");
                                }
+                               if (flags & arch_irn_flags_modify_sp) {
+                                       fprintf(F, " modify_sp");
+                               }
                        }
                        fprintf(F, " (%d)\n", flags);
 
@@ -341,6 +373,43 @@ static int ia32_dump_node(ir_node *n, FILE *F, dump_reason_t reason) {
                        }
                        fprintf(F, "\n");
 
+                       /* dump modes */
+                       fprintf(F, "ls_mode = ");
+                       if (get_ia32_ls_mode(n)) {
+                               ir_fprintf(F, "%+F", get_ia32_ls_mode(n));
+                       }
+                       else {
+                               fprintf(F, "n/a");
+                       }
+                       fprintf(F, "\n");
+
+                       fprintf(F, "res_mode = ");
+                       if (get_ia32_res_mode(n)) {
+                               ir_fprintf(F, "%+F", get_ia32_res_mode(n));
+                       }
+                       else {
+                               fprintf(F, "n/a");
+                       }
+                       fprintf(F, "\n");
+
+                       fprintf(F, "src_mode = ");
+                       if (get_ia32_src_mode(n)) {
+                               ir_fprintf(F, "%+F", get_ia32_src_mode(n));
+                       }
+                       else {
+                               fprintf(F, "n/a");
+                       }
+                       fprintf(F, "\n");
+
+                       fprintf(F, "tgt_mode = ");
+                       if (get_ia32_tgt_mode(n)) {
+                               ir_fprintf(F, "%+F", get_ia32_tgt_mode(n));
+                       }
+                       else {
+                               fprintf(F, "n/a");
+                       }
+                       fprintf(F, "\n");
+
 #ifndef NDEBUG
                        /* dump original ir node name */
                        fprintf(F, "orig node = ");
@@ -861,6 +930,23 @@ void set_ia32_frame_ent(ir_node *node, entity *ent) {
        set_ia32_use_frame(node);
 }
 
+
+/**
+ * Gets the instruction latency.
+ */
+unsigned get_ia32_latency(const ir_node *node) {
+       ia32_attr_t *attr = get_ia32_attr(node);
+       return attr->latency;
+}
+
+/**
+* Sets the instruction latency.
+*/
+void set_ia32_latency(ir_node *node, unsigned latency) {
+       ia32_attr_t *attr = get_ia32_attr(node);
+       attr->latency     = latency;
+}
+
 /**
  * Returns the argument register requirements of an ia32 node.
  */
@@ -1243,12 +1329,13 @@ const arch_register_t *get_ia32_out_reg(const ir_node *node, int pos) {
  * Initializes the nodes attributes.
  */
 void init_ia32_attributes(ir_node *node, arch_irn_flags_t flags, const ia32_register_req_t **in_reqs,
-                                                 const ia32_register_req_t **out_reqs, int n_res)
+                                                 const ia32_register_req_t **out_reqs, int n_res, unsigned latency)
 {
        ia32_attr_t *attr = get_ia32_attr(node);
        set_ia32_flags(node, flags);
        set_ia32_in_req_all(node, in_reqs);
        set_ia32_out_req_all(node, out_reqs);
+       set_ia32_latency(node, latency);
 
        attr->data.n_res = n_res;
        memset((void *)attr->slots, 0, n_res * sizeof(attr->slots[0]));