projects / libfirm / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Improved AMD detection.
[libfirm] / ir / be / ia32 / ia32_emitter.c
diff --git a/ir/be/ia32/ia32_emitter.c b/ir/be/ia32/ia32_emitter.c
index 61b7809..4ac0a82 100644 (file)
--- a/ir/be/ia32/ia32_emitter.c
+++ b/ir/be/ia32/ia32_emitter.c
@@ -75,7 +75,6 @@
 #include "gen_ia32_regalloc_if.h"
 #include "ia32_nodes_attr.h"
 #include "ia32_new_nodes.h"
-#include "ia32_map_regs.h"
 #include "ia32_architecture.h"
 #include "bearch_ia32_t.h"
 
@@ -92,7 +91,7 @@ static int               do_pic;
 /** Return the next block in Block schedule */
 static ir_node *get_prev_block_sched(const ir_node *block)
 {
-       return get_irn_link(block);
+       return (ir_node*)get_irn_link(block);
 }
 
 /** Checks if the current block is a fall-through target. */
@@ -154,7 +153,7 @@ static const arch_register_t *get_in_reg(const ir_node *irn, int pos)
 
        assert(reg && "no in register found");
 
-       if (reg == &ia32_gp_regs[REG_GP_NOREG])
+       if (reg == &ia32_registers[REG_GP_NOREG])
                panic("trying to emit noreg for %+F input %d", irn, pos);
 
        return reg;
@@ -205,16 +204,17 @@ static char *get_unique_label(char *buf, size_t buflen, const char *prefix)
        return buf;
 }
 
-
 /**
  * Emit the name of the 8bit low register
  */
 static void emit_8bit_register(const arch_register_t *reg)
 {
        const char *reg_name = arch_register_get_name(reg);
+       assert(reg->index == REG_GP_EAX || reg->index == REG_GP_EBX
+                       || reg->index == REG_GP_ECX || reg->index == REG_GP_EDX);
 
        be_emit_char('%');
-       be_emit_char(reg_name[1]);
+       be_emit_char(reg_name[1]); /* get the basic name of the register */
        be_emit_char('l');
 }
 
@@ -224,18 +224,20 @@ static void emit_8bit_register(const arch_register_t *reg)
 static void emit_8bit_register_high(const arch_register_t *reg)
 {
        const char *reg_name = arch_register_get_name(reg);
+       assert(reg->index == REG_GP_EAX || reg->index == REG_GP_EBX
+                       || reg->index == REG_GP_ECX || reg->index == REG_GP_EDX);
 
        be_emit_char('%');
-       be_emit_char(reg_name[1]);
+       be_emit_char(reg_name[1]); /* get the basic name of the register */
        be_emit_char('h');
 }
 
 static void emit_16bit_register(const arch_register_t *reg)
 {
-       const char *reg_name = ia32_get_mapped_reg_name(isa->regs_16bit, reg);
+       const char *reg_name = arch_register_get_name(reg);
 
        be_emit_char('%');
-       be_emit_string(reg_name);
+       be_emit_string(reg_name+1); /* skip the 'e' prefix of the 32bit names */
 }
 
 /**
@@ -483,7 +485,7 @@ void ia32_emit_source_register_or_immediate(const ir_node *node, int pos)
 static ir_node *get_cfop_target_block(const ir_node *irn)
 {
        assert(get_irn_mode(irn) == mode_X);
-       return get_irn_link(irn);
+       return (ir_node*)get_irn_link(irn);
 }
 
 /**
@@ -545,12 +547,14 @@ static void ia32_emit_cmp_suffix(int pnc)
 }
 
 typedef enum ia32_emit_mod_t {
+       EMIT_NONE         = 0,
        EMIT_RESPECT_LS   = 1U << 0,
        EMIT_ALTERNATE_AM = 1U << 1,
        EMIT_LONG         = 1U << 2,
        EMIT_HIGH_REG     = 1U << 3,
        EMIT_LOW_REG      = 1U << 4
 } ia32_emit_mod_t;
+ENUM_BITSET(ia32_emit_mod_t)
 
 /**
  * Emits address mode.
@@ -641,7 +645,7 @@ static void ia32_emitf(const ir_node *node, const char *fmt, ...)
 
        for (;;) {
                const char      *start = fmt;
-               ia32_emit_mod_t  mod   = 0;
+               ia32_emit_mod_t  mod   = EMIT_NONE;
 
                while (*fmt != '%' && *fmt != '\n' && *fmt != '\0')
                        ++fmt;
@@ -975,7 +979,7 @@ static int determine_final_pnc(const ir_node *node, int flags_pos, int pnc)
        return pnc;
 }
 
-static pn_Cmp ia32_get_negated_pnc(pn_Cmp pnc)
+static int ia32_get_negated_pnc(int pnc)
 {
        ir_mode *mode = pnc & ia32_pn_Cmp_float ? mode_F : mode_Iu;
        return get_negated_pnc(pnc, mode);
@@ -983,7 +987,7 @@ static pn_Cmp ia32_get_negated_pnc(pn_Cmp pnc)
 
 void ia32_emit_cmp_suffix_node(const ir_node *node, int flags_pos)
 {
-       pn_Cmp pnc = get_ia32_condcode(node);
+       int pnc = get_ia32_condcode(node);
        pnc = determine_final_pnc(node, flags_pos, pnc);
 
        ia32_emit_cmp_suffix(pnc);
@@ -1036,7 +1040,7 @@ static void emit_ia32_Jcc(const ir_node *node)
        int            need_parity_label = 0;
        const ir_node *proj_true;
        const ir_node *proj_false;
-       pn_Cmp         pnc = get_ia32_condcode(node);
+       int            pnc = get_ia32_condcode(node);
 
        pnc = determine_final_pnc(node, 0, pnc);
 
@@ -1116,8 +1120,8 @@ static void emit_ia32_Setcc(const ir_node *node)
 {
        const arch_register_t *dreg = get_out_reg(node, pn_ia32_Setcc_res);
 
-       pn_Cmp pnc = get_ia32_condcode(node);
-       pnc        = determine_final_pnc(node, n_ia32_Setcc_eflags, pnc);
+       int pnc = get_ia32_condcode(node);
+       pnc     = determine_final_pnc(node, n_ia32_Setcc_eflags, pnc);
        if (pnc & ia32_pn_Cmp_float) {
                switch (pnc & 0x0f) {
                case pn_Cmp_Uo:
@@ -1153,9 +1157,9 @@ static void emit_ia32_Setcc(const ir_node *node)
 
 static void emit_ia32_CMovcc(const ir_node *node)
 {
-       const ia32_attr_t     *attr         = get_ia32_attr_const(node);
-       const arch_register_t *out          = arch_irn_get_register(node, pn_ia32_res);
-       pn_Cmp                 pnc          = get_ia32_condcode(node);
+       const ia32_attr_t     *attr = get_ia32_attr_const(node);
+       const arch_register_t *out  = arch_irn_get_register(node, pn_ia32_res);
+       int                    pnc  = get_ia32_condcode(node);
        const arch_register_t *in_true;
        const arch_register_t *in_false;
 
@@ -1364,7 +1368,6 @@ static const char* emit_asm_operand(const ir_node *node, const char *s)
        const arch_register_t *reg;
        const ia32_asm_reg_t  *asm_regs = attr->register_map;
        const ia32_asm_reg_t  *asm_reg;
-       const char            *reg_name;
        char                   c;
        char                   modifier = 0;
        int                    num      = -1;
@@ -1452,21 +1455,19 @@ static const char* emit_asm_operand(const ir_node *node, const char *s)
 
        /* emit it */
        if (modifier != 0) {
-               be_emit_char('%');
                switch (modifier) {
                case 'b':
-                       reg_name = ia32_get_mapped_reg_name(isa->regs_8bit, reg);
+                       emit_8bit_register(reg);
                        break;
                case 'h':
-                       reg_name = ia32_get_mapped_reg_name(isa->regs_8bit_high, reg);
+                       emit_8bit_register_high(reg);
                        break;
                case 'w':
-                       reg_name = ia32_get_mapped_reg_name(isa->regs_16bit, reg);
+                       emit_16bit_register(reg);
                        break;
                default:
                        panic("Invalid asm op modifier");
                }
-               be_emit_string(reg_name);
        } else {
                emit_register(reg, asm_reg->mode);
        }
@@ -2111,7 +2112,7 @@ typedef struct exc_entry {
  */
 static void ia32_gen_labels(ir_node *block, void *data)
 {
-       exc_entry **exc_list = data;
+       exc_entry **exc_list = (exc_entry**)data;
        ir_node *pred;
        int     n;
 
@@ -2136,8 +2137,8 @@ static void ia32_gen_labels(ir_node *block, void *data)
  */
 static int cmp_exc_entry(const void *a, const void *b)
 {
-       const exc_entry *ea = a;
-       const exc_entry *eb = b;
+       const exc_entry *ea = (const exc_entry*)a;
+       const exc_entry *eb = (const exc_entry*)b;
 
        if (get_ia32_exc_label_id(ea->exc_instr) < get_ia32_exc_label_id(eb->exc_instr))
                return -1;
@@ -2227,14 +2228,14 @@ static unsigned char pnc_map_unsigned[8];
 
 static void build_reg_map(void)
 {
-       reg_gp_map[REG_EAX] = 0x0;
-       reg_gp_map[REG_ECX] = 0x1;
-       reg_gp_map[REG_EDX] = 0x2;
-       reg_gp_map[REG_EBX] = 0x3;
-       reg_gp_map[REG_ESP] = 0x4;
-       reg_gp_map[REG_EBP] = 0x5;
-       reg_gp_map[REG_ESI] = 0x6;
-       reg_gp_map[REG_EDI] = 0x7;
+       reg_gp_map[REG_GP_EAX] = 0x0;
+       reg_gp_map[REG_GP_ECX] = 0x1;
+       reg_gp_map[REG_GP_EDX] = 0x2;
+       reg_gp_map[REG_GP_EBX] = 0x3;
+       reg_gp_map[REG_GP_ESP] = 0x4;
+       reg_gp_map[REG_GP_EBP] = 0x5;
+       reg_gp_map[REG_GP_ESI] = 0x6;
+       reg_gp_map[REG_GP_EDI] = 0x7;
 
        pnc_map_signed[pn_Cmp_Eq]    = 0x04;
        pnc_map_signed[pn_Cmp_Lt]    = 0x0C;
@@ -2558,7 +2559,7 @@ static void bemit_binop_with_imm(
                        bemit_mod_am(ruval, node);
                } else {
                        const arch_register_t *reg = get_in_reg(node, n_ia32_binary_left);
-                       if (reg->index == REG_EAX) {
+                       if (reg->index == REG_GP_EAX) {
                                bemit8(opcode_ax);
                        } else {
                                bemit8(opcode);
@@ -2663,9 +2664,9 @@ static void bemit_perm(const ir_node *node)
        assert(cls0 == arch_register_get_class(in1) && "Register class mismatch at Perm");
 
        if (cls0 == &ia32_reg_classes[CLASS_ia32_gp]) {
-               if (in0->index == REG_EAX) {
+               if (in0->index == REG_GP_EAX) {
                        bemit8(0x90 + reg_gp_map[in1->index]);
-               } else if (in1->index == REG_EAX) {
+               } else if (in1->index == REG_GP_EAX) {
                        bemit8(0x90 + reg_gp_map[in0->index]);
                } else {
                        bemit8(0x87);
@@ -2875,8 +2876,8 @@ static void bemit_setcc(const ir_node *node)
 {
        const arch_register_t *dreg = get_out_reg(node, pn_ia32_Setcc_res);
 
-       pn_Cmp pnc = get_ia32_condcode(node);
-       pnc        = determine_final_pnc(node, n_ia32_Setcc_eflags, pnc);
+       int pnc = get_ia32_condcode(node);
+       pnc     = determine_final_pnc(node, n_ia32_Setcc_eflags, pnc);
        if (pnc & ia32_pn_Cmp_float) {
                switch (pnc & 0x0f) {
                case pn_Cmp_Uo:
@@ -2944,7 +2945,7 @@ static void bemit_cmovcc(const ir_node *node)
        const ia32_attr_t     *attr         = get_ia32_attr_const(node);
        int                    ins_permuted = attr->data.ins_permuted;
        const arch_register_t *out          = arch_irn_get_register(node, pn_ia32_res);
-       pn_Cmp                 pnc          = get_ia32_condcode(node);
+       int                    pnc          = get_ia32_condcode(node);
        const arch_register_t *in_true;
        const arch_register_t *in_false;
 
@@ -3022,7 +3023,7 @@ static void bemit_cmp(const ir_node *node)
                                        bemit_mod_am(7, node);
                                } else {
                                        const arch_register_t *reg = get_in_reg(node, n_ia32_binary_left);
-                                       if (reg->index == REG_EAX) {
+                                       if (reg->index == REG_GP_EAX) {
                                                bemit8(0x3D);
                                        } else {
                                                bemit8(0x81);
@@ -3055,7 +3056,7 @@ static void bemit_cmp8bit(const ir_node *node)
        if (is_ia32_Immediate(right)) {
                if (get_ia32_op_type(node) == ia32_Normal) {
                        const arch_register_t *out = get_in_reg(node, n_ia32_Cmp_left);
-                       if (out->index == REG_EAX) {
+                       if (out->index == REG_GP_EAX) {
                                bemit8(0x3C);
                        } else {
                                bemit8(0x80);
@@ -3084,7 +3085,7 @@ static void bemit_test8bit(const ir_node *node)
        if (is_ia32_Immediate(right)) {
                if (get_ia32_op_type(node) == ia32_Normal) {
                        const arch_register_t *out = get_in_reg(node, n_ia32_Test8Bit_left);
-                       if (out->index == REG_EAX) {
+                       if (out->index == REG_GP_EAX) {
                                bemit8(0xA8);
                        } else {
                                bemit8(0xF6);
@@ -3154,7 +3155,7 @@ static void bemit_ldtls(const ir_node *node)
        const arch_register_t *out = get_out_reg(node, 0);
 
        bemit8(0x65); // gs:
-       if (out->index == REG_EAX) {
+       if (out->index == REG_GP_EAX) {
                bemit8(0xA1); // movl 0, %eax
        } else {
                bemit8(0x8B); // movl 0, %reg
@@ -3205,9 +3206,9 @@ static void bemit_helper_sbb(const arch_register_t *src, const arch_register_t *
 /* helper function for bemit_minus64bit */
 static void bemit_helper_xchg(const arch_register_t *src, const arch_register_t *dst)
 {
-       if (src->index == REG_EAX) {
+       if (src->index == REG_GP_EAX) {
                bemit8(0x90 + reg_gp_map[dst->index]); // xchgl %eax, %dst
-       } else if (dst->index == REG_EAX) {
+       } else if (dst->index == REG_GP_EAX) {
                bemit8(0x90 + reg_gp_map[src->index]); // xchgl %src, %eax
        } else {
                bemit8(0x87); // xchgl %src, %dst
@@ -3315,7 +3316,7 @@ static void bemit_load(const ir_node *node)
 {
        const arch_register_t *out = get_out_reg(node, 0);
 
-       if (out->index == REG_EAX) {
+       if (out->index == REG_GP_EAX) {
                ir_node   *base      = get_irn_n(node, n_ia32_base);
                int        has_base  = !is_ia32_NoReg_GP(base);
                ir_node   *index     = get_irn_n(node, n_ia32_index);
@@ -3360,7 +3361,7 @@ static void bemit_store(const ir_node *node)
        } else {
                const arch_register_t *in = get_in_reg(node, n_ia32_Store_val);
 
-               if (in->index == REG_EAX) {
+               if (in->index == REG_GP_EAX) {
                        ir_node   *base      = get_irn_n(node, n_ia32_base);
                        int        has_base  = !is_ia32_NoReg_GP(base);
                        ir_node   *index     = get_irn_n(node, n_ia32_index);
libfirm