2 * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved.
4 * This file is part of libFirm.
6 * This file may be distributed and/or modified under the terms of the
7 * GNU General Public License version 2 as published by the Free Software
8 * Foundation and appearing in the file LICENSE.GPL included in the
9 * packaging of this file.
11 * Licensees holding valid libFirm Professional Edition licenses may use
12 * this file in accordance with the libFirm Commercial License.
13 * Agreement provided with the Software.
15 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
16 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * @brief This file implements the ia32 node emitter.
23 * @author Christian Wuerdig, Matthias Braun
25 * Summary table for x86 floatingpoint compares:
26 * (remember effect of unordered on x86: ZF=1, PF=1, CF=1)
34 * pnc_Leg => NP (ordered)
56 #include "iredges_t.h"
60 #include "raw_bitset.h"
69 #include "beemitter.h"
73 #include "ia32_emitter.h"
74 #include "ia32_common_transform.h"
75 #include "gen_ia32_emitter.h"
76 #include "gen_ia32_regalloc_if.h"
77 #include "ia32_nodes_attr.h"
78 #include "ia32_new_nodes.h"
79 #include "ia32_architecture.h"
80 #include "bearch_ia32_t.h"
82 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
84 static const ia32_isa_t *isa;
85 static char pic_base_label[128];
86 static ir_label_t exc_label_id;
87 static int mark_spill_reload = 0;
90 static bool sp_relative;
91 static int frame_type_size;
92 static int callframe_offset;
94 /** Return the next block in Block schedule */
95 static ir_node *get_prev_block_sched(const ir_node *block)
97 return (ir_node*)get_irn_link(block);
100 /** Checks if the current block is a fall-through target. */
101 static int is_fallthrough(const ir_node *cfgpred)
105 if (!is_Proj(cfgpred))
107 pred = get_Proj_pred(cfgpred);
108 if (is_ia32_SwitchJmp(pred))
115 * returns non-zero if the given block needs a label
116 * because of being a jump-target (and not a fall-through)
118 static int block_needs_label(const ir_node *block)
121 int n_cfgpreds = get_Block_n_cfgpreds(block);
123 if (get_Block_entity(block) != NULL)
126 if (n_cfgpreds == 0) {
128 } else if (n_cfgpreds == 1) {
129 ir_node *cfgpred = get_Block_cfgpred(block, 0);
130 ir_node *cfgpred_block = get_nodes_block(cfgpred);
132 if (get_prev_block_sched(block) == cfgpred_block
133 && is_fallthrough(cfgpred)) {
142 * Add a number to a prefix. This number will not be used a second time.
144 static char *get_unique_label(char *buf, size_t buflen, const char *prefix)
146 static unsigned long id = 0;
147 snprintf(buf, buflen, "%s%s%lu", be_gas_get_private_prefix(), prefix, ++id);
152 * Emit the name of the 8bit low register
154 static void emit_8bit_register(const arch_register_t *reg)
156 assert(reg->index == REG_GP_EAX || reg->index == REG_GP_EBX
157 || reg->index == REG_GP_ECX || reg->index == REG_GP_EDX);
160 be_emit_char(reg->name[1]); /* get the basic name of the register */
165 * Emit the name of the 8bit high register
167 static void emit_8bit_register_high(const arch_register_t *reg)
169 assert(reg->index == REG_GP_EAX || reg->index == REG_GP_EBX
170 || reg->index == REG_GP_ECX || reg->index == REG_GP_EDX);
173 be_emit_char(reg->name[1]); /* get the basic name of the register */
177 static void emit_16bit_register(const arch_register_t *reg)
180 be_emit_string(reg->name + 1); /* skip the 'e' prefix of the 32bit names */
184 * emit a register, possible shortened by a mode
186 * @param reg the register
187 * @param mode the mode of the register or NULL for full register
189 static void emit_register(const arch_register_t *reg, const ir_mode *mode)
192 int size = get_mode_size_bits(mode);
194 case 8: emit_8bit_register(reg); return;
195 case 16: emit_16bit_register(reg); return;
197 assert(mode_is_float(mode) || size == 32);
201 be_emit_string(reg->name);
204 static void ia32_emit_entity(ir_entity *entity, int no_pic_adjust)
206 be_gas_emit_entity(entity);
208 if (get_entity_owner(entity) == get_tls_type()) {
209 if (!entity_has_definition(entity)) {
210 be_emit_cstring("@INDNTPOFF");
212 be_emit_cstring("@NTPOFF");
216 if (do_pic && !no_pic_adjust) {
218 be_emit_string(pic_base_label);
222 static void emit_ia32_Immediate_no_prefix(const ir_node *node)
224 const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(node);
226 if (attr->symconst != NULL) {
229 ia32_emit_entity(attr->symconst, attr->no_pic_adjust);
231 if (attr->symconst == NULL || attr->offset != 0) {
232 if (attr->symconst != NULL) {
233 be_emit_irprintf("%+d", attr->offset);
235 be_emit_irprintf("0x%X", attr->offset);
240 static void emit_ia32_Immediate(const ir_node *node)
243 emit_ia32_Immediate_no_prefix(node);
246 static void ia32_emit_mode_suffix_mode(const ir_mode *mode)
248 assert(mode_is_int(mode) || mode_is_reference(mode));
249 switch (get_mode_size_bits(mode)) {
250 case 8: be_emit_char('b'); return;
251 case 16: be_emit_char('w'); return;
252 case 32: be_emit_char('l'); return;
253 /* gas docu says q is the suffix but gcc, objdump and icc use ll
255 case 64: be_emit_cstring("ll"); return;
257 panic("Can't output mode_suffix for %+F", mode);
260 static void ia32_emit_x87_mode_suffix(ir_node const *const node)
264 /* we only need to emit the mode on address mode */
265 if (get_ia32_op_type(node) == ia32_Normal)
268 mode = get_ia32_ls_mode(node);
269 assert(mode != NULL);
271 if (mode_is_float(mode)) {
272 switch (get_mode_size_bits(mode)) {
273 case 32: be_emit_char('s'); return;
274 case 64: be_emit_char('l'); return;
275 /* long doubles have different sizes due to alignment on different
279 case 128: be_emit_char('t'); return;
282 assert(mode_is_int(mode) || mode_is_reference(mode));
283 switch (get_mode_size_bits(mode)) {
284 case 16: be_emit_char('s'); return;
285 case 32: be_emit_char('l'); return;
286 /* gas docu says q is the suffix but gcc, objdump and icc use ll
288 case 64: be_emit_cstring("ll"); return;
291 panic("Can't output mode_suffix for %+F", mode);
294 static char get_xmm_mode_suffix(ir_mode *mode)
296 assert(mode_is_float(mode));
297 switch (get_mode_size_bits(mode)) {
300 default: panic("Invalid XMM mode");
304 static void ia32_emit_xmm_mode_suffix(ir_node const *const node)
306 ir_mode *mode = get_ia32_ls_mode(node);
307 assert(mode != NULL);
308 be_emit_char(get_xmm_mode_suffix(mode));
312 * Returns the target block for a control flow node.
314 static ir_node *get_cfop_target_block(const ir_node *irn)
316 assert(get_irn_mode(irn) == mode_X);
317 return (ir_node*)get_irn_link(irn);
321 * Emits the target label for a control flow node.
323 static void ia32_emit_cfop_target(const ir_node *node)
325 ir_node *block = get_cfop_target_block(node);
326 be_gas_emit_block_name(block);
330 * Emit the suffix for a compare instruction.
332 static void ia32_emit_condition_code(ia32_condition_code_t cc)
335 case ia32_cc_overflow: be_emit_cstring("o"); return;
336 case ia32_cc_not_overflow: be_emit_cstring("no"); return;
337 case ia32_cc_float_below:
338 case ia32_cc_float_unordered_below:
339 case ia32_cc_below: be_emit_cstring("b"); return;
340 case ia32_cc_float_above_equal:
341 case ia32_cc_float_unordered_above_equal:
342 case ia32_cc_above_equal: be_emit_cstring("ae"); return;
343 case ia32_cc_float_equal:
344 case ia32_cc_equal: be_emit_cstring("e"); return;
345 case ia32_cc_float_not_equal:
346 case ia32_cc_not_equal: be_emit_cstring("ne"); return;
347 case ia32_cc_float_below_equal:
348 case ia32_cc_float_unordered_below_equal:
349 case ia32_cc_below_equal: be_emit_cstring("be"); return;
350 case ia32_cc_float_above:
351 case ia32_cc_float_unordered_above:
352 case ia32_cc_above: be_emit_cstring("a"); return;
353 case ia32_cc_sign: be_emit_cstring("s"); return;
354 case ia32_cc_not_sign: be_emit_cstring("ns"); return;
355 case ia32_cc_parity: be_emit_cstring("p"); return;
356 case ia32_cc_not_parity: be_emit_cstring("np"); return;
357 case ia32_cc_less: be_emit_cstring("l"); return;
358 case ia32_cc_greater_equal: be_emit_cstring("ge"); return;
359 case ia32_cc_less_equal: be_emit_cstring("le"); return;
360 case ia32_cc_greater: be_emit_cstring("g"); return;
361 case ia32_cc_float_parity_cases:
362 case ia32_cc_additional_float_cases:
365 panic("Invalid ia32 condition code");
368 typedef enum ia32_emit_mod_t {
370 EMIT_RESPECT_LS = 1U << 0,
371 EMIT_ALTERNATE_AM = 1U << 1,
373 EMIT_HIGH_REG = 1U << 3,
374 EMIT_LOW_REG = 1U << 4,
375 EMIT_16BIT_REG = 1U << 5
377 ENUM_BITSET(ia32_emit_mod_t)
380 * Emits address mode.
382 static void ia32_emit_am(ir_node const *const node)
384 ir_entity *ent = get_ia32_am_sc(node);
385 int offs = get_ia32_am_offs_int(node);
386 ir_node *base = get_irn_n(node, n_ia32_base);
387 int has_base = !is_ia32_NoReg_GP(base);
388 ir_node *idx = get_irn_n(node, n_ia32_index);
389 int has_index = !is_ia32_NoReg_GP(idx);
391 /* just to be sure... */
392 assert(!is_ia32_use_frame(node) || get_ia32_frame_ent(node) != NULL);
394 if (get_ia32_am_tls_segment(node))
395 be_emit_cstring("%gs:");
399 const ia32_attr_t *attr = get_ia32_attr_const(node);
400 if (is_ia32_am_sc_sign(node))
402 ia32_emit_entity(ent, attr->data.am_sc_no_pic_adjust);
405 /* also handle special case if nothing is set */
406 if (offs != 0 || (ent == NULL && !has_base && !has_index)) {
408 be_emit_irprintf("%+d", offs);
410 be_emit_irprintf("%d", offs);
414 if (has_base || has_index) {
419 const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_base);
420 emit_register(reg, NULL);
423 /* emit index + scale */
425 const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_index);
428 emit_register(reg, NULL);
430 scale = get_ia32_am_scale(node);
432 be_emit_irprintf(",%d", 1 << scale);
439 static ia32_condition_code_t determine_final_cc(ir_node const *node, int flags_pos, ia32_condition_code_t cc);
441 void ia32_emitf(ir_node const *const node, char const *fmt, ...)
448 const char *start = fmt;
449 ia32_emit_mod_t mod = EMIT_NONE;
451 while (*fmt != '%' && *fmt != '\n' && *fmt != '\0')
454 be_emit_string_len(start, fmt - start);
459 be_emit_write_line();
473 case '*': mod |= EMIT_ALTERNATE_AM; break;
474 case '#': mod |= EMIT_RESPECT_LS; break;
475 case 'l': mod |= EMIT_LONG; break;
476 case '>': mod |= EMIT_HIGH_REG; break;
477 case '<': mod |= EMIT_LOW_REG; break;
478 case '^': mod |= EMIT_16BIT_REG; break;
487 arch_register_t const *reg;
497 if (get_ia32_op_type(node) == ia32_AddrModeS) {
500 assert(get_ia32_op_type(node) == ia32_Normal);
501 ia32_x87_attr_t const *const attr = get_ia32_x87_attr_const(node);
502 char const *const fmt = attr->res_in_reg ? "%%st, %%%s" : "%%%s, %%st";
503 be_emit_irprintf(fmt, attr->reg->name);
509 if (mod & EMIT_ALTERNATE_AM)
515 reg = va_arg(ap, const arch_register_t*);
516 if (get_ia32_op_type(node) == ia32_AddrModeS) {
523 if (get_ia32_op_type(node) == ia32_AddrModeS) {
527 assert(get_ia32_op_type(node) == ia32_Normal);
531 default: goto unknown;
537 imm = get_irn_n(node, n_ia32_binary_right);
538 if (is_ia32_Immediate(imm)) {
539 emit_ia32_Immediate(imm);
540 be_emit_cstring(", ");
541 if (get_ia32_op_type(node) == ia32_AddrModeS) {
544 assert(get_ia32_op_type(node) == ia32_Normal);
545 reg = arch_get_irn_register_in(node, n_ia32_binary_left);
546 emit_register(reg, get_ia32_ls_mode(node));
549 if (get_ia32_op_type(node) == ia32_AddrModeS) {
552 assert(get_ia32_op_type(node) == ia32_Normal);
553 reg = arch_get_irn_register_in(node, n_ia32_binary_right);
554 emit_register(reg, get_ia32_ls_mode(node));
556 be_emit_cstring(", ");
557 reg = arch_get_irn_register_in(node, n_ia32_binary_left);
558 emit_register(reg, get_ia32_ls_mode(node));
563 if (*fmt < '0' || '9' < *fmt)
565 reg = arch_get_irn_register_out(node, *fmt++ - '0');
570 ia32_emit_x87_mode_suffix(node);
571 } else if (*fmt == 'P') {
572 ia32_x87_attr_t const *const attr = get_ia32_x87_attr_const(node);
575 } else if (*fmt == 'R') {
576 /* NOTE: Work around a gas quirk for non-commutative operations if the
577 * destination register is not %st0. In this case r/non-r is swapped.
578 * %st0 = %st0 - %st1 -> fsub %st1, %st0 (as expected)
579 * %st0 = %st1 - %st0 -> fsubr %st1, %st0 (as expected)
580 * %st1 = %st0 - %st1 -> fsub %st0, %st1 (expected: fsubr)
581 * %st1 = %st1 - %st0 -> fsubr %st0, %st1 (expected: fsub)
582 * In fact this corresponds to the encoding of the instruction:
583 * - The r suffix selects whether %st0 is on the left (no r) or on the
584 * right (r) side of the executed operation.
585 * - The placement of %st0 selects whether the result is written to
586 * %st0 (right) or the other register (left).
587 * This means that it is sufficient to test whether the operands are
588 * permuted. In particular it is not necessary to consider wether the
589 * result is to be placed into the explicit register operand. */
590 if (get_ia32_x87_attr_const(node)->attr.data.ins_permuted)
592 } else if (*fmt == 'X') {
593 ia32_emit_xmm_mode_suffix(node);
594 } else if (*fmt == '0') {
596 be_emit_string(get_ia32_x87_attr_const(node)->reg->name);
606 if (!(mod & EMIT_ALTERNATE_AM))
608 emit_ia32_Immediate_no_prefix(imm);
612 ia32_emit_cfop_target(node);
616 ir_mode *mode = get_ia32_ls_mode(node);
619 if (mod & EMIT_RESPECT_LS) {
620 if (get_mode_size_bits(mode) == 32)
622 be_emit_char(mode_is_signed(mode) ? 's' : 'z');
624 ia32_emit_mode_suffix_mode(mode);
629 ia32_condition_code_t cc;
632 cc = (ia32_condition_code_t)va_arg(ap, int);
633 } else if ('0' <= *fmt && *fmt <= '9') {
634 cc = get_ia32_condcode(node);
635 cc = determine_final_cc(node, *fmt - '0', cc);
640 ia32_emit_condition_code(cc);
645 reg = va_arg(ap, const arch_register_t*);
647 if (mod & EMIT_ALTERNATE_AM)
649 if (mod & EMIT_HIGH_REG) {
650 emit_8bit_register_high(reg);
651 } else if (mod & EMIT_LOW_REG) {
652 emit_8bit_register(reg);
653 } else if (mod & EMIT_16BIT_REG) {
654 emit_16bit_register(reg);
656 emit_register(reg, mod & EMIT_RESPECT_LS ? get_ia32_ls_mode(node) : NULL);
664 if (*fmt < '0' || '9' < *fmt)
668 imm = get_irn_n(node, pos);
669 if (is_ia32_Immediate(imm)) {
672 reg = arch_get_irn_register_in(node, pos);
678 const char *str = va_arg(ap, const char*);
684 if (mod & EMIT_LONG) {
685 unsigned long num = va_arg(ap, unsigned long);
686 be_emit_irprintf("%lu", num);
688 unsigned num = va_arg(ap, unsigned);
689 be_emit_irprintf("%u", num);
694 if (mod & EMIT_LONG) {
695 long num = va_arg(ap, long);
696 be_emit_irprintf("%ld", num);
698 int num = va_arg(ap, int);
699 be_emit_irprintf("%d", num);
705 panic("unknown format conversion");
709 be_emit_finish_line_gas(node);
713 static void emit_ia32_IMul(const ir_node *node)
715 ir_node *left = get_irn_n(node, n_ia32_IMul_left);
716 const arch_register_t *out_reg = arch_get_irn_register_out(node, pn_ia32_IMul_res);
718 /* do we need the 3-address form? */
719 if (is_ia32_NoReg_GP(left) ||
720 arch_get_irn_register_in(node, n_ia32_IMul_left) != out_reg) {
721 ia32_emitf(node, "imul%M %#S4, %#AS3, %#D0");
723 ia32_emitf(node, "imul%M %#AS4, %#S3");
728 * walks up a tree of copies/perms/spills/reloads to find the original value
729 * that is moved around
731 static ir_node *find_original_value(ir_node *node)
733 if (irn_visited(node))
736 mark_irn_visited(node);
737 if (be_is_Copy(node)) {
738 return find_original_value(be_get_Copy_op(node));
739 } else if (be_is_CopyKeep(node)) {
740 return find_original_value(be_get_CopyKeep_op(node));
741 } else if (is_Proj(node)) {
742 ir_node *pred = get_Proj_pred(node);
743 if (be_is_Perm(pred)) {
744 return find_original_value(get_irn_n(pred, get_Proj_proj(node)));
745 } else if (be_is_MemPerm(pred)) {
746 return find_original_value(get_irn_n(pred, get_Proj_proj(node) + 1));
747 } else if (is_ia32_Load(pred)) {
748 return find_original_value(get_irn_n(pred, n_ia32_Load_mem));
749 } else if (is_ia32_Store(pred)) {
750 return find_original_value(get_irn_n(pred, n_ia32_Store_val));
754 } else if (is_Phi(node)) {
756 arity = get_irn_arity(node);
757 for (i = 0; i < arity; ++i) {
758 ir_node *in = get_irn_n(node, i);
759 ir_node *res = find_original_value(in);
770 static ia32_condition_code_t determine_final_cc(const ir_node *node,
771 int flags_pos, ia32_condition_code_t cc)
773 ir_node *flags = get_irn_n(node, flags_pos);
774 const ia32_attr_t *flags_attr;
775 flags = skip_Proj(flags);
777 if (is_ia32_Sahf(flags)) {
778 ir_node *cmp = get_irn_n(flags, n_ia32_Sahf_val);
779 if (!(is_ia32_FucomFnstsw(cmp) || is_ia32_FucomppFnstsw(cmp) || is_ia32_FtstFnstsw(cmp))) {
780 inc_irg_visited(current_ir_graph);
781 cmp = find_original_value(cmp);
783 assert(is_ia32_FucomFnstsw(cmp) || is_ia32_FucomppFnstsw(cmp) || is_ia32_FtstFnstsw(cmp));
786 flags_attr = get_ia32_attr_const(cmp);
788 flags_attr = get_ia32_attr_const(flags);
791 if (flags_attr->data.ins_permuted)
792 cc = ia32_invert_condition_code(cc);
797 * Emits an exception label for a given node.
799 static void ia32_emit_exc_label(const ir_node *node)
801 be_emit_string(be_gas_insn_label_prefix());
802 be_emit_irprintf("%lu", get_ia32_exc_label_id(node));
806 * Returns the Proj with projection number proj and NOT mode_M
808 static ir_node *get_proj(const ir_node *node, long proj)
812 assert(get_irn_mode(node) == mode_T && "expected mode_T node");
814 foreach_out_edge(node, edge) {
815 src = get_edge_src_irn(edge);
817 assert(is_Proj(src) && "Proj expected");
818 if (get_irn_mode(src) == mode_M)
821 if (get_Proj_proj(src) == proj)
827 static int can_be_fallthrough(const ir_node *node)
829 ir_node *target_block = get_cfop_target_block(node);
830 ir_node *block = get_nodes_block(node);
831 return get_prev_block_sched(target_block) == block;
835 * Emits the jump sequence for a conditional jump (cmp + jmp_true + jmp_false)
837 static void emit_ia32_Jcc(const ir_node *node)
839 int need_parity_label = 0;
840 ia32_condition_code_t cc = get_ia32_condcode(node);
841 const ir_node *proj_true;
842 const ir_node *proj_false;
844 cc = determine_final_cc(node, 0, cc);
847 proj_true = get_proj(node, pn_ia32_Jcc_true);
848 assert(proj_true && "Jcc without true Proj");
850 proj_false = get_proj(node, pn_ia32_Jcc_false);
851 assert(proj_false && "Jcc without false Proj");
853 if (can_be_fallthrough(proj_true)) {
854 /* exchange both proj's so the second one can be omitted */
855 const ir_node *t = proj_true;
857 proj_true = proj_false;
859 cc = ia32_negate_condition_code(cc);
862 if (cc & ia32_cc_float_parity_cases) {
863 /* Some floating point comparisons require a test of the parity flag,
864 * which indicates that the result is unordered */
865 if (cc & ia32_cc_negated) {
866 ia32_emitf(proj_true, "jp %L");
868 /* we need a local label if the false proj is a fallthrough
869 * as the falseblock might have no label emitted then */
870 if (can_be_fallthrough(proj_false)) {
871 need_parity_label = 1;
872 ia32_emitf(proj_false, "jp 1f");
874 ia32_emitf(proj_false, "jp %L");
878 ia32_emitf(proj_true, "j%PX %L", (int)cc);
879 if (need_parity_label) {
880 be_emit_cstring("1:\n");
881 be_emit_write_line();
884 /* the second Proj might be a fallthrough */
885 if (can_be_fallthrough(proj_false)) {
886 if (be_options.verbose_asm)
887 ia32_emitf(proj_false, "/* fallthrough to %L */");
889 ia32_emitf(proj_false, "jmp %L");
894 * Emits an ia32 Setcc. This is mostly easy but some floating point compares
897 static void emit_ia32_Setcc(const ir_node *node)
899 const arch_register_t *dreg = arch_get_irn_register_out(node, pn_ia32_Setcc_res);
901 ia32_condition_code_t cc = get_ia32_condcode(node);
902 cc = determine_final_cc(node, n_ia32_Setcc_eflags, cc);
903 if (cc & ia32_cc_float_parity_cases) {
904 if (cc & ia32_cc_negated) {
905 ia32_emitf(node, "set%PX %<R", (int)cc, dreg);
906 ia32_emitf(node, "setp %>R", dreg);
907 ia32_emitf(node, "orb %>R, %<R", dreg, dreg);
909 ia32_emitf(node, "set%PX %<R", (int)cc, dreg);
910 ia32_emitf(node, "setnp %>R", dreg);
911 ia32_emitf(node, "andb %>R, %<R", dreg, dreg);
914 ia32_emitf(node, "set%PX %#R", (int)cc, dreg);
918 static void emit_ia32_CMovcc(const ir_node *node)
920 const ia32_attr_t *attr = get_ia32_attr_const(node);
921 const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_res);
922 ia32_condition_code_t cc = get_ia32_condcode(node);
923 const arch_register_t *in_true;
924 const arch_register_t *in_false;
926 cc = determine_final_cc(node, n_ia32_CMovcc_eflags, cc);
927 /* although you can't set ins_permuted in the constructor it might still
928 * be set by memory operand folding
929 * Permuting inputs of a cmov means the condition is negated!
931 if (attr->data.ins_permuted)
932 cc = ia32_negate_condition_code(cc);
934 in_true = arch_get_irn_register(get_irn_n(node, n_ia32_CMovcc_val_true));
935 in_false = arch_get_irn_register(get_irn_n(node, n_ia32_CMovcc_val_false));
937 /* should be same constraint fullfilled? */
938 if (out == in_false) {
939 /* yes -> nothing to do */
940 } else if (out == in_true) {
941 const arch_register_t *tmp;
943 assert(get_ia32_op_type(node) == ia32_Normal);
945 cc = ia32_negate_condition_code(cc);
952 ia32_emitf(node, "movl %R, %R", in_false, out);
955 if (cc & ia32_cc_float_parity_cases) {
956 panic("CMov with floatingpoint compare/parity not supported yet");
959 ia32_emitf(node, "cmov%PX %#AR, %#R", (int)cc, in_true, out);
963 * Emits code for a SwitchJmp
965 static void emit_ia32_SwitchJmp(const ir_node *node)
967 ir_entity *jump_table = get_ia32_am_sc(node);
968 const ir_switch_table *table = get_ia32_switch_table(node);
970 ia32_emitf(node, "jmp %*AM");
971 be_emit_jump_table(node, table, jump_table, get_cfop_target_block);
975 * Emits code for a unconditional jump.
977 static void emit_ia32_Jmp(const ir_node *node)
979 /* we have a block schedule */
980 if (can_be_fallthrough(node)) {
981 if (be_options.verbose_asm)
982 ia32_emitf(node, "/* fallthrough to %L */");
984 ia32_emitf(node, "jmp %L");
989 * Emit an inline assembler operand.
991 * @param node the ia32_ASM node
992 * @param s points to the operand (a %c)
994 * @return pointer to the first char in s NOT in the current operand
996 static const char* emit_asm_operand(const ir_node *node, const char *s)
998 const ia32_attr_t *ia32_attr = get_ia32_attr_const(node);
999 const ia32_asm_attr_t *attr = CONST_CAST_IA32_ATTR(ia32_asm_attr_t,
1001 const arch_register_t *reg;
1002 const ia32_asm_reg_t *asm_regs = attr->register_map;
1003 const ia32_asm_reg_t *asm_reg;
1012 /* parse modifiers */
1015 ir_fprintf(stderr, "Warning: asm text (%+F) ends with %%\n", node);
1040 "Warning: asm text (%+F) contains unknown modifier '%c' for asm op\n",
1047 if (sscanf(s, "%d%n", &num, &p) != 1) {
1048 ir_fprintf(stderr, "Warning: Couldn't parse assembler operand (%+F)\n",
1055 if (num < 0 || ARR_LEN(asm_regs) <= (size_t)num) {
1057 "Error: Custom assembler references invalid input/output (%+F)\n",
1061 asm_reg = & asm_regs[num];
1062 assert(asm_reg->valid);
1065 if (asm_reg->use_input == 0) {
1066 reg = arch_get_irn_register_out(node, asm_reg->inout_pos);
1068 ir_node *pred = get_irn_n(node, asm_reg->inout_pos);
1070 /* might be an immediate value */
1071 if (is_ia32_Immediate(pred)) {
1072 emit_ia32_Immediate(pred);
1075 reg = arch_get_irn_register_in(node, asm_reg->inout_pos);
1079 "Warning: no register assigned for %d asm op (%+F)\n",
1084 if (asm_reg->memory) {
1089 if (modifier != 0) {
1092 emit_8bit_register(reg);
1095 emit_8bit_register_high(reg);
1098 emit_16bit_register(reg);
1101 panic("Invalid asm op modifier");
1104 emit_register(reg, asm_reg->memory ? mode_Iu : asm_reg->mode);
1107 if (asm_reg->memory) {
1115 * Emits code for an ASM pseudo op.
1117 static void emit_ia32_Asm(const ir_node *node)
1119 const void *gen_attr = get_irn_generic_attr_const(node);
1120 const ia32_asm_attr_t *attr
1121 = CONST_CAST_IA32_ATTR(ia32_asm_attr_t, gen_attr);
1122 ident *asm_text = attr->asm_text;
1123 const char *s = get_id_str(asm_text);
1125 be_emit_cstring("#APP\n");
1126 be_emit_write_line();
1133 s = emit_asm_operand(node, s);
1139 be_emit_cstring("\n#NO_APP\n");
1140 be_emit_write_line();
1145 * Emit movsb/w instructions to make mov count divideable by 4
1147 static void emit_CopyB_prolog(unsigned size)
1150 ia32_emitf(NULL, "movsb");
1152 ia32_emitf(NULL, "movsw");
1156 * Emit rep movsd instruction for memcopy.
1158 static void emit_ia32_CopyB(const ir_node *node)
1160 unsigned size = get_ia32_copyb_size(node);
1162 emit_CopyB_prolog(size);
1163 ia32_emitf(node, "rep movsd");
1167 * Emits unrolled memcopy.
1169 static void emit_ia32_CopyB_i(const ir_node *node)
1171 unsigned size = get_ia32_copyb_size(node);
1173 emit_CopyB_prolog(size);
1177 ia32_emitf(NULL, "movsd");
1183 * Emit code for conversions (I, FP), (FP, I) and (FP, FP).
1185 static void emit_ia32_Conv_with_FP(const ir_node *node, const char* conv_f,
1188 ir_mode *ls_mode = get_ia32_ls_mode(node);
1189 int ls_bits = get_mode_size_bits(ls_mode);
1190 const char *conv = ls_bits == 32 ? conv_f : conv_d;
1192 ia32_emitf(node, "cvt%s %AS3, %D0", conv);
1195 static void emit_ia32_Conv_I2FP(const ir_node *node)
1197 emit_ia32_Conv_with_FP(node, "si2ss", "si2sd");
1200 static void emit_ia32_Conv_FP2I(const ir_node *node)
1202 emit_ia32_Conv_with_FP(node, "ss2si", "sd2si");
1205 static void emit_ia32_Conv_FP2FP(const ir_node *node)
1207 emit_ia32_Conv_with_FP(node, "sd2ss", "ss2sd");
1211 * Emits code to increase stack pointer.
1213 static void emit_be_IncSP(const ir_node *node)
1215 int offs = be_get_IncSP_offset(node);
1221 ia32_emitf(node, "subl $%u, %D0", offs);
1223 ia32_emitf(node, "addl $%u, %D0", -offs);
1228 * Emits code for Copy/CopyKeep.
1230 static void Copy_emitter(const ir_node *node, const ir_node *op)
1232 const arch_register_t *in = arch_get_irn_register(op);
1233 const arch_register_t *out = arch_get_irn_register(node);
1238 /* copies of fp nodes aren't real... */
1239 if (in->reg_class == &ia32_reg_classes[CLASS_ia32_fp])
1242 ia32_emitf(node, "movl %R, %R", in, out);
1245 static void emit_be_Copy(const ir_node *node)
1247 Copy_emitter(node, be_get_Copy_op(node));
1250 static void emit_be_CopyKeep(const ir_node *node)
1252 Copy_emitter(node, be_get_CopyKeep_op(node));
1256 * Emits code for exchange.
1258 static void emit_be_Perm(const ir_node *node)
1260 const arch_register_t *in0, *in1;
1262 in0 = arch_get_irn_register(get_irn_n(node, 0));
1263 in1 = arch_get_irn_register(get_irn_n(node, 1));
1265 arch_register_class_t const *const cls0 = in0->reg_class;
1266 assert(cls0 == in1->reg_class && "Register class mismatch at Perm");
1268 if (cls0 == &ia32_reg_classes[CLASS_ia32_gp]) {
1269 ia32_emitf(node, "xchg %R, %R", in1, in0);
1270 } else if (cls0 == &ia32_reg_classes[CLASS_ia32_xmm]) {
1271 ia32_emitf(NULL, "xorpd %R, %R", in1, in0);
1272 ia32_emitf(NULL, "xorpd %R, %R", in0, in1);
1273 ia32_emitf(node, "xorpd %R, %R", in1, in0);
1274 } else if (cls0 == &ia32_reg_classes[CLASS_ia32_fp]) {
1277 panic("unexpected register class in be_Perm (%+F)", node);
1281 /* helper function for emit_ia32_Minus64Bit */
1282 static void emit_mov(const ir_node* node, const arch_register_t *src, const arch_register_t *dst)
1284 ia32_emitf(node, "movl %R, %R", src, dst);
1287 /* helper function for emit_ia32_Minus64Bit */
1288 static void emit_neg(const ir_node* node, const arch_register_t *reg)
1290 ia32_emitf(node, "negl %R", reg);
1293 /* helper function for emit_ia32_Minus64Bit */
1294 static void emit_sbb0(const ir_node* node, const arch_register_t *reg)
1296 ia32_emitf(node, "sbbl $0, %R", reg);
1299 /* helper function for emit_ia32_Minus64Bit */
1300 static void emit_sbb(const ir_node* node, const arch_register_t *src, const arch_register_t *dst)
1302 ia32_emitf(node, "sbbl %R, %R", src, dst);
1305 /* helper function for emit_ia32_Minus64Bit */
1306 static void emit_xchg(const ir_node* node, const arch_register_t *src, const arch_register_t *dst)
1308 ia32_emitf(node, "xchgl %R, %R", src, dst);
1311 /* helper function for emit_ia32_Minus64Bit */
1312 static void emit_zero(const ir_node* node, const arch_register_t *reg)
1314 ia32_emitf(node, "xorl %R, %R", reg, reg);
1317 static void emit_ia32_Minus64Bit(const ir_node *node)
1319 const arch_register_t *in_lo = arch_get_irn_register_in(node, 0);
1320 const arch_register_t *in_hi = arch_get_irn_register_in(node, 1);
1321 const arch_register_t *out_lo = arch_get_irn_register_out(node, 0);
1322 const arch_register_t *out_hi = arch_get_irn_register_out(node, 1);
1324 if (out_lo == in_lo) {
1325 if (out_hi != in_hi) {
1326 /* a -> a, b -> d */
1329 /* a -> a, b -> b */
1332 } else if (out_lo == in_hi) {
1333 if (out_hi == in_lo) {
1334 /* a -> b, b -> a */
1335 emit_xchg(node, in_lo, in_hi);
1338 /* a -> b, b -> d */
1339 emit_mov(node, in_hi, out_hi);
1340 emit_mov(node, in_lo, out_lo);
1344 if (out_hi == in_lo) {
1345 /* a -> c, b -> a */
1346 emit_mov(node, in_lo, out_lo);
1348 } else if (out_hi == in_hi) {
1349 /* a -> c, b -> b */
1350 emit_mov(node, in_lo, out_lo);
1353 /* a -> c, b -> d */
1354 emit_mov(node, in_lo, out_lo);
1360 emit_neg( node, out_hi);
1361 emit_neg( node, out_lo);
1362 emit_sbb0(node, out_hi);
1366 emit_zero(node, out_hi);
1367 emit_neg( node, out_lo);
1368 emit_sbb( node, in_hi, out_hi);
1371 static void emit_ia32_GetEIP(const ir_node *node)
1373 ia32_emitf(node, "call %s", pic_base_label);
1374 be_emit_irprintf("%s:\n", pic_base_label);
1375 be_emit_write_line();
1376 ia32_emitf(node, "popl %D0");
1379 static void emit_ia32_ClimbFrame(const ir_node *node)
1381 const ia32_climbframe_attr_t *attr = get_ia32_climbframe_attr_const(node);
1383 ia32_emitf(node, "movl %S0, %D0");
1384 ia32_emitf(node, "movl $%u, %S1", attr->count);
1385 be_gas_emit_block_name(node);
1386 be_emit_cstring(":\n");
1387 be_emit_write_line();
1388 ia32_emitf(node, "movl (%D0), %D0");
1389 ia32_emitf(node, "dec %S1");
1390 be_emit_cstring("\tjnz ");
1391 be_gas_emit_block_name(node);
1392 be_emit_finish_line_gas(node);
1395 static void emit_be_Return(const ir_node *node)
1397 unsigned pop = be_Return_get_pop(node);
1399 if (pop > 0 || be_Return_get_emit_pop(node)) {
1400 ia32_emitf(node, "ret $%u", pop);
1402 ia32_emitf(node, "ret");
1406 static void emit_Nothing(const ir_node *node)
1413 * Enters the emitter functions for handled nodes into the generic
1414 * pointer of an opcode.
1416 static void ia32_register_emitters(void)
1418 #define IA32_EMIT(a) op_ia32_##a->ops.generic = (op_func)emit_ia32_##a
1419 #define EMIT(a) op_##a->ops.generic = (op_func)emit_##a
1420 #define IGN(a) op_##a->ops.generic = (op_func)emit_Nothing
1421 #define BE_EMIT(a) op_be_##a->ops.generic = (op_func)emit_be_##a
1422 #define BE_IGN(a) op_be_##a->ops.generic = (op_func)emit_Nothing
1424 /* first clear the generic function pointer for all ops */
1425 ir_clear_opcodes_generic_func();
1427 /* register all emitter functions defined in spec */
1428 ia32_register_spec_emitters();
1430 /* other ia32 emitter functions */
1433 IA32_EMIT(Conv_FP2FP);
1434 IA32_EMIT(Conv_FP2I);
1435 IA32_EMIT(Conv_I2FP);
1442 IA32_EMIT(Minus64Bit);
1443 IA32_EMIT(SwitchJmp);
1444 IA32_EMIT(ClimbFrame);
1447 /* benode emitter */
1466 typedef void (*emit_func_ptr) (const ir_node *);
1469 * Assign and emit an exception label if the current instruction can fail.
1471 static void ia32_assign_exc_label(ir_node *node)
1473 /* assign a new ID to the instruction */
1474 set_ia32_exc_label_id(node, ++exc_label_id);
1476 ia32_emit_exc_label(node);
1478 be_emit_pad_comment();
1479 be_emit_cstring("/* exception to Block ");
1480 ia32_emit_cfop_target(node);
1481 be_emit_cstring(" */\n");
1482 be_emit_write_line();
1486 * Emits code for a node.
1488 static void ia32_emit_node(ir_node *node)
1490 ir_op *op = get_irn_op(node);
1492 DBG((dbg, LEVEL_1, "emitting code for %+F\n", node));
1494 if (is_ia32_irn(node)) {
1495 if (get_ia32_exc_label(node)) {
1496 /* emit the exception label of this instruction */
1497 ia32_assign_exc_label(node);
1499 if (mark_spill_reload) {
1500 if (is_ia32_is_spill(node)) {
1501 ia32_emitf(NULL, "xchg %ebx, %ebx /* spill mark */");
1503 if (is_ia32_is_reload(node)) {
1504 ia32_emitf(NULL, "xchg %edx, %edx /* reload mark */");
1506 if (is_ia32_is_remat(node)) {
1507 ia32_emitf(NULL, "xchg %ecx, %ecx /* remat mark */");
1511 if (op->ops.generic) {
1512 emit_func_ptr func = (emit_func_ptr) op->ops.generic;
1514 be_dwarf_location(get_irn_dbg_info(node));
1519 ir_fprintf(stderr, "Error: No emit handler for node %+F (%+G, graph %+F)\n", node, node, current_ir_graph);
1524 int sp_change = arch_get_sp_bias(node);
1525 if (sp_change != 0) {
1526 assert(sp_change != SP_BIAS_RESET);
1527 callframe_offset += sp_change;
1528 be_dwarf_callframe_offset(callframe_offset);
1534 * Emits gas alignment directives
1536 static void ia32_emit_alignment(unsigned align, unsigned skip)
1538 ia32_emitf(NULL, ".p2align %u,,%u", align, skip);
1542 * Emits gas alignment directives for Labels depended on cpu architecture.
1544 static void ia32_emit_align_label(void)
1546 unsigned align = ia32_cg_config.label_alignment;
1547 unsigned maximum_skip = ia32_cg_config.label_alignment_max_skip;
1548 ia32_emit_alignment(align, maximum_skip);
1552 * Test whether a block should be aligned.
1553 * For cpus in the P4/Athlon class it is useful to align jump labels to
1554 * 16 bytes. However we should only do that if the alignment nops before the
1555 * label aren't executed more often than we have jumps to the label.
1557 static int should_align_block(const ir_node *block)
1559 static const double DELTA = .0001;
1560 ir_node *prev = get_prev_block_sched(block);
1561 double prev_freq = 0; /**< execfreq of the fallthrough block */
1562 double jmp_freq = 0; /**< execfreq of all non-fallthrough blocks */
1566 if (ia32_cg_config.label_alignment_factor <= 0)
1569 block_freq = get_block_execfreq(block);
1570 if (block_freq < DELTA)
1573 n_cfgpreds = get_Block_n_cfgpreds(block);
1574 for (i = 0; i < n_cfgpreds; ++i) {
1575 const ir_node *pred = get_Block_cfgpred_block(block, i);
1576 double pred_freq = get_block_execfreq(pred);
1579 prev_freq += pred_freq;
1581 jmp_freq += pred_freq;
1585 if (prev_freq < DELTA && !(jmp_freq < DELTA))
1588 jmp_freq /= prev_freq;
1590 return jmp_freq > ia32_cg_config.label_alignment_factor;
1594 * Emit the block header for a block.
1596 * @param block the block
1597 * @param prev_block the previous block
1599 static void ia32_emit_block_header(ir_node *block)
1601 ir_graph *irg = current_ir_graph;
1602 int need_label = block_needs_label(block);
1604 if (block == get_irg_end_block(irg))
1607 if (ia32_cg_config.label_alignment > 0) {
1608 /* align the current block if:
1609 * a) if should be aligned due to its execution frequency
1610 * b) there is no fall-through here
1612 if (should_align_block(block)) {
1613 ia32_emit_align_label();
1615 /* if the predecessor block has no fall-through,
1616 we can always align the label. */
1618 int has_fallthrough = 0;
1620 for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) {
1621 ir_node *cfg_pred = get_Block_cfgpred(block, i);
1622 if (can_be_fallthrough(cfg_pred)) {
1623 has_fallthrough = 1;
1628 if (!has_fallthrough)
1629 ia32_emit_align_label();
1633 be_gas_begin_block(block, need_label);
1637 * Walks over the nodes in a block connected by scheduling edges
1638 * and emits code for each node.
1640 static void ia32_gen_block(ir_node *block)
1642 ia32_emit_block_header(block);
1645 ir_graph *irg = get_irn_irg(block);
1646 callframe_offset = 4; /* 4 bytes for the return address */
1647 /* ESP guessing, TODO perform a real ESP simulation */
1648 if (block != get_irg_start_block(irg)) {
1649 callframe_offset += frame_type_size;
1651 be_dwarf_callframe_offset(callframe_offset);
1654 /* emit the contents of the block */
1655 be_dwarf_location(get_irn_dbg_info(block));
1656 sched_foreach(block, node) {
1657 ia32_emit_node(node);
1661 typedef struct exc_entry {
1662 ir_node *exc_instr; /** The instruction that can issue an exception. */
1663 ir_node *block; /** The block to call then. */
1668 * Sets labels for control flow nodes (jump target).
1669 * Links control predecessors to there destination blocks.
1671 static void ia32_gen_labels(ir_node *block, void *data)
1673 exc_entry **exc_list = (exc_entry**)data;
1677 for (n = get_Block_n_cfgpreds(block) - 1; n >= 0; --n) {
1678 pred = get_Block_cfgpred(block, n);
1679 set_irn_link(pred, block);
1681 pred = skip_Proj(pred);
1682 if (is_ia32_irn(pred) && get_ia32_exc_label(pred)) {
1687 ARR_APP1(exc_entry, *exc_list, e);
1688 set_irn_link(pred, block);
1694 * Compare two exception_entries.
1696 static int cmp_exc_entry(const void *a, const void *b)
1698 const exc_entry *ea = (const exc_entry*)a;
1699 const exc_entry *eb = (const exc_entry*)b;
1701 if (get_ia32_exc_label_id(ea->exc_instr) < get_ia32_exc_label_id(eb->exc_instr))
1706 static parameter_dbg_info_t *construct_parameter_infos(ir_graph *irg)
1708 ir_entity *entity = get_irg_entity(irg);
1709 ir_type *type = get_entity_type(entity);
1710 size_t n_params = get_method_n_params(type);
1711 be_stack_layout_t *layout = be_get_irg_stack_layout(irg);
1712 ir_type *arg_type = layout->arg_type;
1713 size_t n_members = get_compound_n_members(arg_type);
1714 parameter_dbg_info_t *infos = XMALLOCNZ(parameter_dbg_info_t, n_params);
1717 for (i = 0; i < n_members; ++i) {
1718 ir_entity *member = get_compound_member(arg_type, i);
1720 if (!is_parameter_entity(member))
1722 param = get_entity_parameter_number(member);
1723 if (param == IR_VA_START_PARAMETER_NUMBER)
1725 assert(infos[param].entity == NULL && infos[param].reg == NULL);
1726 infos[param].reg = NULL;
1727 infos[param].entity = member;
1734 * Main driver. Emits the code for one routine.
1736 void ia32_gen_routine(ir_graph *irg)
1738 ir_entity *entity = get_irg_entity(irg);
1739 exc_entry *exc_list = NEW_ARR_F(exc_entry, 0);
1740 const arch_env_t *arch_env = be_get_irg_arch_env(irg);
1741 ia32_irg_data_t *irg_data = ia32_get_irg_data(irg);
1742 ir_node **blk_sched = irg_data->blk_sched;
1743 be_stack_layout_t *layout = be_get_irg_stack_layout(irg);
1744 parameter_dbg_info_t *infos;
1747 isa = (ia32_isa_t*) arch_env;
1748 do_pic = be_options.pic;
1750 be_gas_elf_type_char = '@';
1752 ia32_register_emitters();
1754 get_unique_label(pic_base_label, sizeof(pic_base_label), "PIC_BASE");
1756 infos = construct_parameter_infos(irg);
1757 be_gas_emit_function_prolog(entity, ia32_cg_config.function_alignment,
1761 sp_relative = layout->sp_relative;
1762 if (layout->sp_relative) {
1763 ir_type *frame_type = get_irg_frame_type(irg);
1764 frame_type_size = get_type_size_bytes(frame_type);
1765 be_dwarf_callframe_register(&ia32_registers[REG_ESP]);
1767 /* well not entirely correct here, we should emit this after the
1768 * "movl esp, ebp" */
1769 be_dwarf_callframe_register(&ia32_registers[REG_EBP]);
1770 /* TODO: do not hardcode the following */
1771 be_dwarf_callframe_offset(8);
1772 be_dwarf_callframe_spilloffset(&ia32_registers[REG_EBP], -8);
1775 /* we use links to point to target blocks */
1776 ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
1777 irg_block_walk_graph(irg, ia32_gen_labels, NULL, &exc_list);
1779 /* initialize next block links */
1780 n = ARR_LEN(blk_sched);
1781 for (i = 0; i < n; ++i) {
1782 ir_node *block = blk_sched[i];
1783 ir_node *prev = i > 0 ? blk_sched[i-1] : NULL;
1785 set_irn_link(block, prev);
1788 for (i = 0; i < n; ++i) {
1789 ir_node *block = blk_sched[i];
1791 ia32_gen_block(block);
1794 be_gas_emit_function_epilog(entity);
1796 ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
1798 /* Sort the exception table using the exception label id's.
1799 Those are ascending with ascending addresses. */
1800 qsort(exc_list, ARR_LEN(exc_list), sizeof(exc_list[0]), cmp_exc_entry);
1804 for (e = 0; e < ARR_LEN(exc_list); ++e) {
1805 be_emit_cstring("\t.long ");
1806 ia32_emit_exc_label(exc_list[e].exc_instr);
1808 be_emit_cstring("\t.long ");
1809 be_gas_emit_block_name(exc_list[e].block);
1813 DEL_ARR_F(exc_list);
1816 static const lc_opt_table_entry_t ia32_emitter_options[] = {
1817 LC_OPT_ENT_BOOL("mark_spill_reload", "mark spills and reloads with ud opcodes", &mark_spill_reload),
1821 /* ==== Experimental binary emitter ==== */
1823 static unsigned char reg_gp_map[N_ia32_gp_REGS];
1824 //static unsigned char reg_mmx_map[N_ia32_mmx_REGS];
1825 //static unsigned char reg_sse_map[N_ia32_xmm_REGS];
1827 static void build_reg_map(void)
1829 reg_gp_map[REG_GP_EAX] = 0x0;
1830 reg_gp_map[REG_GP_ECX] = 0x1;
1831 reg_gp_map[REG_GP_EDX] = 0x2;
1832 reg_gp_map[REG_GP_EBX] = 0x3;
1833 reg_gp_map[REG_GP_ESP] = 0x4;
1834 reg_gp_map[REG_GP_EBP] = 0x5;
1835 reg_gp_map[REG_GP_ESI] = 0x6;
1836 reg_gp_map[REG_GP_EDI] = 0x7;
1839 /** Returns the encoding for a pnc field. */
1840 static unsigned char pnc2cc(ia32_condition_code_t cc)
1845 /** Sign extension bit values for binops */
1847 UNSIGNED_IMM = 0, /**< unsigned immediate */
1848 SIGNEXT_IMM = 2, /**< sign extended immediate */
1851 /** The mod encoding of the ModR/M */
1853 MOD_IND = 0x00, /**< [reg1] */
1854 MOD_IND_BYTE_OFS = 0x40, /**< [reg1 + byte ofs] */
1855 MOD_IND_WORD_OFS = 0x80, /**< [reg1 + word ofs] */
1856 MOD_REG = 0xC0 /**< reg1 */
1859 /** create R/M encoding for ModR/M */
1860 #define ENC_RM(x) (x)
1861 /** create REG encoding for ModR/M */
1862 #define ENC_REG(x) ((x) << 3)
1864 /** create encoding for a SIB byte */
1865 #define ENC_SIB(scale, index, base) ((scale) << 6 | (index) << 3 | (base))
1867 /* Node: The following routines are supposed to append bytes, words, dwords
1868 to the output stream.
1869 Currently the implementation is stupid in that it still creates output
1870 for an "assembler" in the form of .byte, .long
1871 We will change this when enough infrastructure is there to create complete
1872 machine code in memory/object files */
1874 static void bemit8(const unsigned char byte)
1876 be_emit_irprintf("\t.byte 0x%x\n", byte);
1877 be_emit_write_line();
1880 static void bemit16(const unsigned short u16)
1882 be_emit_irprintf("\t.word 0x%x\n", u16);
1883 be_emit_write_line();
1886 static void bemit32(const unsigned u32)
1888 be_emit_irprintf("\t.long 0x%x\n", u32);
1889 be_emit_write_line();
1893 * Emit address of an entity. If @p is_relative is true then a relative
1894 * offset from behind the address to the entity is created.
1896 static void bemit_entity(ir_entity *entity, bool entity_sign, int offset,
1899 if (entity == NULL) {
1904 /* the final version should remember the position in the bytestream
1905 and patch it with the correct address at linktime... */
1906 be_emit_cstring("\t.long ");
1909 be_gas_emit_entity(entity);
1911 if (get_entity_owner(entity) == get_tls_type()) {
1912 if (!entity_has_definition(entity)) {
1913 be_emit_cstring("@INDNTPOFF");
1915 be_emit_cstring("@NTPOFF");
1920 be_emit_cstring("-.");
1925 be_emit_irprintf("%+d", offset);
1928 be_emit_write_line();
1931 static void bemit_jmp_destination(const ir_node *dest_block)
1933 be_emit_cstring("\t.long ");
1934 be_gas_emit_block_name(dest_block);
1935 be_emit_cstring(" - . - 4\n");
1936 be_emit_write_line();
1939 /* end emit routines, all emitters following here should only use the functions
1942 typedef enum reg_modifier {
1947 /** Create a ModR/M byte for src1,src2 registers */
1948 static void bemit_modrr(const arch_register_t *src1,
1949 const arch_register_t *src2)
1951 unsigned char modrm = MOD_REG;
1952 modrm |= ENC_RM(reg_gp_map[src1->index]);
1953 modrm |= ENC_REG(reg_gp_map[src2->index]);
1957 /** Create a ModR/M8 byte for src1,src2 registers */
1958 static void bemit_modrr8(reg_modifier_t high_part1, const arch_register_t *src1,
1959 reg_modifier_t high_part2, const arch_register_t *src2)
1961 unsigned char modrm = MOD_REG;
1962 modrm |= ENC_RM(reg_gp_map[src1->index] + (high_part1 == REG_HIGH ? 4 : 0));
1963 modrm |= ENC_REG(reg_gp_map[src2->index] + (high_part2 == REG_HIGH ? 4 : 0));
1967 /** Create a ModR/M byte for one register and extension */
1968 static void bemit_modru(const arch_register_t *reg, unsigned ext)
1970 unsigned char modrm = MOD_REG;
1972 modrm |= ENC_RM(reg_gp_map[reg->index]);
1973 modrm |= ENC_REG(ext);
1977 /** Create a ModR/M8 byte for one register */
1978 static void bemit_modrm8(reg_modifier_t high_part, const arch_register_t *reg)
1980 unsigned char modrm = MOD_REG;
1981 assert(reg_gp_map[reg->index] < 4);
1982 modrm |= ENC_RM(reg_gp_map[reg->index] + (high_part == REG_HIGH ? 4 : 0));
1988 * Calculate the size of an signed immediate in bytes.
1990 * @param offset an offset
1992 static unsigned get_signed_imm_size(int offset)
1994 if (-128 <= offset && offset < 128) {
1996 } else if (-32768 <= offset && offset < 32768) {
2004 * Emit an address mode.
2006 * @param reg content of the reg field: either a register index or an opcode extension
2007 * @param node the node
2009 static void bemit_mod_am(unsigned reg, const ir_node *node)
2011 ir_entity *ent = get_ia32_am_sc(node);
2012 int offs = get_ia32_am_offs_int(node);
2013 ir_node *base = get_irn_n(node, n_ia32_base);
2014 int has_base = !is_ia32_NoReg_GP(base);
2015 ir_node *idx = get_irn_n(node, n_ia32_index);
2016 int has_index = !is_ia32_NoReg_GP(idx);
2019 unsigned emitoffs = 0;
2020 bool emitsib = false;
2023 /* set the mod part depending on displacement */
2025 modrm |= MOD_IND_WORD_OFS;
2027 } else if (offs == 0) {
2030 } else if (-128 <= offs && offs < 128) {
2031 modrm |= MOD_IND_BYTE_OFS;
2034 modrm |= MOD_IND_WORD_OFS;
2039 const arch_register_t *base_reg = arch_get_irn_register(base);
2040 base_enc = reg_gp_map[base_reg->index];
2042 /* Use the EBP encoding + MOD_IND if NO base register. There is
2043 * always a 32bit offset present in this case. */
2049 /* Determine if we need a SIB byte. */
2051 const arch_register_t *reg_index = arch_get_irn_register(idx);
2052 int scale = get_ia32_am_scale(node);
2054 /* R/M set to ESP means SIB in 32bit mode. */
2055 modrm |= ENC_RM(0x04);
2056 sib = ENC_SIB(scale, reg_gp_map[reg_index->index], base_enc);
2058 } else if (base_enc == 0x04) {
2059 /* for the above reason we are forced to emit a SIB when base is ESP.
2060 * Only the base is used, index must be ESP too, which means no index.
2062 modrm |= ENC_RM(0x04);
2063 sib = ENC_SIB(0, 0x04, 0x04);
2066 modrm |= ENC_RM(base_enc);
2069 /* We are forced to emit an 8bit offset as EBP base without offset is a
2070 * special case for SIB without base register. */
2071 if (base_enc == 0x05 && emitoffs == 0) {
2072 modrm |= MOD_IND_BYTE_OFS;
2076 modrm |= ENC_REG(reg);
2082 /* emit displacement */
2083 if (emitoffs == 8) {
2084 bemit8((unsigned) offs);
2085 } else if (emitoffs == 32) {
2086 bemit_entity(ent, is_ia32_am_sc_sign(node), offs, false);
2091 * Emit a binop with a immediate operand.
2093 * @param node the node to emit
2094 * @param opcode_eax the opcode for the op eax, imm variant
2095 * @param opcode the opcode for the reg, imm variant
2096 * @param ruval the opcode extension for opcode
2098 static void bemit_binop_with_imm(
2099 const ir_node *node,
2100 unsigned char opcode_ax,
2101 unsigned char opcode, unsigned char ruval)
2103 /* Use in-reg, because some instructions (cmp, test) have no out-reg. */
2104 const ir_node *op = get_irn_n(node, n_ia32_binary_right);
2105 const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(op);
2108 /* Some instructions (test) have no short form with 32bit value + 8bit
2110 if (attr->symconst != NULL || opcode & SIGNEXT_IMM) {
2113 /* check for sign extension */
2114 size = get_signed_imm_size(attr->offset);
2119 bemit8(opcode | SIGNEXT_IMM);
2120 /* cmp has this special mode */
2121 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2122 bemit_mod_am(ruval, node);
2124 const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2125 bemit_modru(reg, ruval);
2127 bemit8((unsigned char)attr->offset);
2131 /* check for eax variant: this variant is shorter for 32bit immediates only */
2132 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2134 bemit_mod_am(ruval, node);
2136 const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2137 if (reg->index == REG_GP_EAX) {
2141 bemit_modru(reg, ruval);
2144 bemit_entity(attr->symconst, attr->sc_sign, attr->offset, false);
2147 panic("invalid imm size?!?");
2153 static void bemit_binop_2(const ir_node *node, unsigned code)
2155 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_binary_left);
2157 if (get_ia32_op_type(node) == ia32_Normal) {
2158 const arch_register_t *op2 = arch_get_irn_register_in(node, n_ia32_binary_right);
2159 bemit_modrr(op2, out);
2161 bemit_mod_am(reg_gp_map[out->index], node);
2168 static void bemit_binop(const ir_node *node, const unsigned char opcodes[4])
2170 ir_node *right = get_irn_n(node, n_ia32_binary_right);
2171 if (is_ia32_Immediate(right)) {
2172 bemit_binop_with_imm(node, opcodes[1], opcodes[2], opcodes[3]);
2174 bemit_binop_2(node, opcodes[0]);
2181 static void bemit_unop(const ir_node *node, unsigned char code, unsigned char ext, int input)
2184 if (get_ia32_op_type(node) == ia32_Normal) {
2185 const arch_register_t *in = arch_get_irn_register_in(node, input);
2186 bemit_modru(in, ext);
2188 bemit_mod_am(ext, node);
2192 static void bemit_unop_reg(const ir_node *node, unsigned char code, int input)
2194 const arch_register_t *out = arch_get_irn_register_out(node, 0);
2195 bemit_unop(node, code, reg_gp_map[out->index], input);
2198 static void bemit_unop_mem(const ir_node *node, unsigned char code, unsigned char ext)
2200 unsigned size = get_mode_size_bits(get_ia32_ls_mode(node));
2203 bemit8(size == 8 ? code : code + 1);
2204 bemit_mod_am(ext, node);
2207 static void bemit_0f_unop_reg(ir_node const *const node, unsigned char const code, int const input)
2210 bemit_unop_reg(node, code, input);
2213 static void bemit_immediate(const ir_node *node, bool relative)
2215 const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(node);
2216 bemit_entity(attr->symconst, attr->sc_sign, attr->offset, relative);
2219 static void bemit_copy(const ir_node *copy)
2221 const arch_register_t *in = arch_get_irn_register_in(copy, 0);
2222 const arch_register_t *out = arch_get_irn_register_out(copy, 0);
2226 /* copies of fp nodes aren't real... */
2227 if (in->reg_class == &ia32_reg_classes[CLASS_ia32_fp])
2230 assert(in->reg_class == &ia32_reg_classes[CLASS_ia32_gp]);
2232 bemit_modrr(in, out);
2235 static void bemit_perm(const ir_node *node)
2237 const arch_register_t *in0 = arch_get_irn_register(get_irn_n(node, 0));
2238 const arch_register_t *in1 = arch_get_irn_register(get_irn_n(node, 1));
2239 const arch_register_class_t *cls0 = in0->reg_class;
2241 assert(cls0 == in1->reg_class && "Register class mismatch at Perm");
2243 if (cls0 == &ia32_reg_classes[CLASS_ia32_gp]) {
2244 if (in0->index == REG_GP_EAX) {
2245 bemit8(0x90 + reg_gp_map[in1->index]);
2246 } else if (in1->index == REG_GP_EAX) {
2247 bemit8(0x90 + reg_gp_map[in0->index]);
2250 bemit_modrr(in0, in1);
2252 } else if (cls0 == &ia32_reg_classes[CLASS_ia32_xmm]) {
2253 panic("unimplemented"); // TODO implement
2254 //ia32_emitf(NULL, "xorpd %R, %R", in1, in0);
2255 //ia32_emitf(NULL, "xorpd %R, %R", in0, in1);
2256 //ia32_emitf(node, "xorpd %R, %R", in1, in0);
2257 } else if (cls0 == &ia32_reg_classes[CLASS_ia32_fp]) {
2260 panic("unexpected register class in be_Perm (%+F)", node);
2264 static void bemit_xor0(const ir_node *node)
2266 const arch_register_t *out = arch_get_irn_register_out(node, 0);
2268 bemit_modrr(out, out);
2271 static void bemit_mov_const(const ir_node *node)
2273 const arch_register_t *out = arch_get_irn_register_out(node, 0);
2274 bemit8(0xB8 + reg_gp_map[out->index]);
2275 bemit_immediate(node, false);
2279 * Creates a function for a Binop with 3 possible encodings.
2281 #define BINOP(op, op0, op1, op2, op2_ext) \
2282 static void bemit_ ## op(const ir_node *node) { \
2283 static const unsigned char op ## _codes[] = {op0, op1, op2, op2_ext}; \
2284 bemit_binop(node, op ## _codes); \
2287 /* insn def eax,imm imm */
2288 BINOP(add, 0x03, 0x05, 0x81, 0)
2289 BINOP(or, 0x0B, 0x0D, 0x81, 1)
2290 BINOP(adc, 0x13, 0x15, 0x81, 2)
2291 BINOP(sbb, 0x1B, 0x1D, 0x81, 3)
2292 BINOP(and, 0x23, 0x25, 0x81, 4)
2293 BINOP(sub, 0x2B, 0x2D, 0x81, 5)
2294 BINOP(xor, 0x33, 0x35, 0x81, 6)
2295 BINOP(test, 0x85, 0xA9, 0xF7, 0)
2297 #define BINOPMEM(op, ext) \
2298 static void bemit_##op(const ir_node *node) \
2301 unsigned size = get_mode_size_bits(get_ia32_ls_mode(node)); \
2304 val = get_irn_n(node, n_ia32_unary_op); \
2305 if (is_ia32_Immediate(val)) { \
2306 const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(val); \
2307 int offset = attr->offset; \
2308 if (attr->symconst == NULL && get_signed_imm_size(offset) == 1) { \
2310 bemit_mod_am(ext, node); \
2314 bemit_mod_am(ext, node); \
2318 bemit_entity(attr->symconst, attr->sc_sign, offset, false); \
2322 bemit8(ext << 3 | 1); \
2323 bemit_mod_am(reg_gp_map[arch_get_irn_register(val)->index], node); \
2327 static void bemit_##op##8bit(const ir_node *node) \
2329 ir_node *val = get_irn_n(node, n_ia32_unary_op); \
2330 if (is_ia32_Immediate(val)) { \
2332 bemit_mod_am(ext, node); \
2333 bemit8(get_ia32_immediate_attr_const(val)->offset); \
2336 bemit_mod_am(reg_gp_map[arch_get_irn_register(val)->index], node); \
2348 * Creates a function for an Unop with code /ext encoding.
2350 #define UNOP(op, code, ext, input) \
2351 static void bemit_ ## op(const ir_node *node) { \
2352 bemit_unop(node, code, ext, input); \
2355 UNOP(not, 0xF7, 2, n_ia32_Not_val)
2356 UNOP(neg, 0xF7, 3, n_ia32_Neg_val)
2357 UNOP(mul, 0xF7, 4, n_ia32_Mul_right)
2358 UNOP(imul1op, 0xF7, 5, n_ia32_IMul1OP_right)
2359 UNOP(div, 0xF7, 6, n_ia32_Div_divisor)
2360 UNOP(idiv, 0xF7, 7, n_ia32_IDiv_divisor)
2362 /* TODO: am support for IJmp */
2363 UNOP(ijmp, 0xFF, 4, n_ia32_IJmp_target)
2365 #define SHIFT(op, ext) \
2366 static void bemit_##op(const ir_node *node) \
2368 const arch_register_t *out = arch_get_irn_register_out(node, 0); \
2369 ir_node *count = get_irn_n(node, 1); \
2370 if (is_ia32_Immediate(count)) { \
2371 int offset = get_ia32_immediate_attr_const(count)->offset; \
2372 if (offset == 1) { \
2374 bemit_modru(out, ext); \
2377 bemit_modru(out, ext); \
2382 bemit_modru(out, ext); \
2386 static void bemit_##op##mem(const ir_node *node) \
2389 unsigned size = get_mode_size_bits(get_ia32_ls_mode(node)); \
2392 count = get_irn_n(node, 1); \
2393 if (is_ia32_Immediate(count)) { \
2394 int offset = get_ia32_immediate_attr_const(count)->offset; \
2395 if (offset == 1) { \
2396 bemit8(size == 8 ? 0xD0 : 0xD1); \
2397 bemit_mod_am(ext, node); \
2399 bemit8(size == 8 ? 0xC0 : 0xC1); \
2400 bemit_mod_am(ext, node); \
2404 bemit8(size == 8 ? 0xD2 : 0xD3); \
2405 bemit_mod_am(ext, node); \
2415 static void bemit_shld(const ir_node *node)
2417 const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_ShlD_val_low);
2418 const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_ShlD_res);
2419 ir_node *count = get_irn_n(node, n_ia32_ShlD_count);
2421 if (is_ia32_Immediate(count)) {
2423 bemit_modrr(out, in);
2424 bemit8(get_ia32_immediate_attr_const(count)->offset);
2427 bemit_modrr(out, in);
2431 static void bemit_shrd(const ir_node *node)
2433 const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_ShrD_val_low);
2434 const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_ShrD_res);
2435 ir_node *count = get_irn_n(node, n_ia32_ShrD_count);
2437 if (is_ia32_Immediate(count)) {
2439 bemit_modrr(out, in);
2440 bemit8(get_ia32_immediate_attr_const(count)->offset);
2443 bemit_modrr(out, in);
2447 static void bemit_sbb0(ir_node const *const node)
2449 arch_register_t const *const out = arch_get_irn_register_out(node, pn_ia32_Sbb0_res);
2450 unsigned char const reg = reg_gp_map[out->index];
2452 bemit8(MOD_REG | ENC_REG(reg) | ENC_RM(reg));
2456 * binary emitter for setcc.
2458 static void bemit_setcc(const ir_node *node)
2460 const arch_register_t *dreg = arch_get_irn_register_out(node, pn_ia32_Setcc_res);
2462 ia32_condition_code_t cc = get_ia32_condcode(node);
2463 cc = determine_final_cc(node, n_ia32_Setcc_eflags, cc);
2464 if (cc & ia32_cc_float_parity_cases) {
2465 if (cc & ia32_cc_negated) {
2468 bemit8(0x90 | pnc2cc(cc));
2469 bemit_modrm8(REG_LOW, dreg);
2474 bemit_modrm8(REG_HIGH, dreg);
2476 /* orb %>dreg, %<dreg */
2478 bemit_modrr8(REG_LOW, dreg, REG_HIGH, dreg);
2482 bemit8(0x90 | pnc2cc(cc));
2483 bemit_modrm8(REG_LOW, dreg);
2488 bemit_modrm8(REG_HIGH, dreg);
2490 /* andb %>dreg, %<dreg */
2492 bemit_modrr8(REG_LOW, dreg, REG_HIGH, dreg);
2497 bemit8(0x90 | pnc2cc(cc));
2498 bemit_modrm8(REG_LOW, dreg);
2502 static void bemit_bsf(ir_node const *const node)
2504 bemit_0f_unop_reg(node, 0xBC, n_ia32_Bsf_operand);
2507 static void bemit_bsr(ir_node const *const node)
2509 bemit_0f_unop_reg(node, 0xBD, n_ia32_Bsr_operand);
2512 static void bemit_bswap(ir_node const *const node)
2515 bemit_modru(arch_get_irn_register_out(node, pn_ia32_Bswap_res), 1);
2518 static void bemit_bt(ir_node const *const node)
2521 arch_register_t const *const lreg = arch_get_irn_register_in(node, n_ia32_Bt_left);
2522 ir_node const *const right = get_irn_n(node, n_ia32_Bt_right);
2523 if (is_ia32_Immediate(right)) {
2524 ia32_immediate_attr_t const *const attr = get_ia32_immediate_attr_const(right);
2525 int const offset = attr->offset;
2526 assert(!attr->symconst);
2527 assert(get_signed_imm_size(offset) == 1);
2529 bemit_modru(lreg, 4);
2533 bemit_modrr(lreg, arch_get_irn_register(right));
2537 static void bemit_cmovcc(const ir_node *node)
2539 const ia32_attr_t *attr = get_ia32_attr_const(node);
2540 int ins_permuted = attr->data.ins_permuted;
2541 const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_res);
2542 ia32_condition_code_t cc = get_ia32_condcode(node);
2543 const arch_register_t *in_true;
2544 const arch_register_t *in_false;
2546 cc = determine_final_cc(node, n_ia32_CMovcc_eflags, cc);
2548 in_true = arch_get_irn_register(get_irn_n(node, n_ia32_CMovcc_val_true));
2549 in_false = arch_get_irn_register(get_irn_n(node, n_ia32_CMovcc_val_false));
2551 /* should be same constraint fullfilled? */
2552 if (out == in_false) {
2553 /* yes -> nothing to do */
2554 } else if (out == in_true) {
2555 assert(get_ia32_op_type(node) == ia32_Normal);
2556 ins_permuted = !ins_permuted;
2560 bemit8(0x8B); // mov %in_false, %out
2561 bemit_modrr(in_false, out);
2565 cc = ia32_negate_condition_code(cc);
2567 if (cc & ia32_cc_float_parity_cases)
2568 panic("cmov can't handle parity float cases");
2571 bemit8(0x40 | pnc2cc(cc));
2572 if (get_ia32_op_type(node) == ia32_Normal) {
2573 bemit_modrr(in_true, out);
2575 bemit_mod_am(reg_gp_map[out->index], node);
2579 static void bemit_cmp(const ir_node *node)
2581 unsigned ls_size = get_mode_size_bits(get_ia32_ls_mode(node));
2587 right = get_irn_n(node, n_ia32_binary_right);
2588 if (is_ia32_Immediate(right)) {
2589 /* Use in-reg, because some instructions (cmp, test) have no out-reg. */
2590 const ir_node *op = get_irn_n(node, n_ia32_binary_right);
2591 const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(op);
2594 if (attr->symconst != NULL) {
2597 /* check for sign extension */
2598 size = get_signed_imm_size(attr->offset);
2603 bemit8(0x81 | SIGNEXT_IMM);
2604 /* cmp has this special mode */
2605 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2606 bemit_mod_am(7, node);
2608 const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2609 bemit_modru(reg, 7);
2611 bemit8((unsigned char)attr->offset);
2615 /* check for eax variant: this variant is shorter for 32bit immediates only */
2616 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2618 bemit_mod_am(7, node);
2620 const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2621 if (reg->index == REG_GP_EAX) {
2625 bemit_modru(reg, 7);
2628 if (ls_size == 16) {
2629 bemit16(attr->offset);
2631 bemit_entity(attr->symconst, attr->sc_sign, attr->offset, false);
2635 panic("invalid imm size?!?");
2637 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_binary_left);
2639 if (get_ia32_op_type(node) == ia32_Normal) {
2640 const arch_register_t *op2 = arch_get_irn_register_in(node, n_ia32_binary_right);
2641 bemit_modrr(op2, out);
2643 bemit_mod_am(reg_gp_map[out->index], node);
2648 static void bemit_cmp8bit(const ir_node *node)
2650 ir_node *right = get_irn_n(node, n_ia32_binary_right);
2651 if (is_ia32_Immediate(right)) {
2652 if (get_ia32_op_type(node) == ia32_Normal) {
2653 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Cmp_left);
2654 if (out->index == REG_GP_EAX) {
2658 bemit_modru(out, 7);
2662 bemit_mod_am(7, node);
2664 bemit8(get_ia32_immediate_attr_const(right)->offset);
2666 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Cmp_left);
2668 if (get_ia32_op_type(node) == ia32_Normal) {
2669 const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_Cmp_right);
2670 bemit_modrr(out, in);
2672 bemit_mod_am(reg_gp_map[out->index], node);
2677 static void bemit_test8bit(const ir_node *node)
2679 ir_node *right = get_irn_n(node, n_ia32_Test8Bit_right);
2680 if (is_ia32_Immediate(right)) {
2681 if (get_ia32_op_type(node) == ia32_Normal) {
2682 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Test8Bit_left);
2683 if (out->index == REG_GP_EAX) {
2687 bemit_modru(out, 0);
2691 bemit_mod_am(0, node);
2693 bemit8(get_ia32_immediate_attr_const(right)->offset);
2695 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Test8Bit_left);
2697 if (get_ia32_op_type(node) == ia32_Normal) {
2698 const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_Test8Bit_right);
2699 bemit_modrr(out, in);
2701 bemit_mod_am(reg_gp_map[out->index], node);
2706 static void bemit_imul(const ir_node *node)
2708 ir_node *right = get_irn_n(node, n_ia32_IMul_right);
2709 /* Do we need the immediate form? */
2710 if (is_ia32_Immediate(right)) {
2711 int imm = get_ia32_immediate_attr_const(right)->offset;
2712 if (get_signed_imm_size(imm) == 1) {
2713 bemit_unop_reg(node, 0x6B, n_ia32_IMul_left);
2716 bemit_unop_reg(node, 0x69, n_ia32_IMul_left);
2720 bemit_0f_unop_reg(node, 0xAF, n_ia32_IMul_right);
2724 static void bemit_dec(const ir_node *node)
2726 const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_Dec_res);
2727 bemit8(0x48 + reg_gp_map[out->index]);
2730 static void bemit_inc(const ir_node *node)
2732 const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_Inc_res);
2733 bemit8(0x40 + reg_gp_map[out->index]);
2736 #define UNOPMEM(op, code, ext) \
2737 static void bemit_##op(const ir_node *node) \
2739 bemit_unop_mem(node, code, ext); \
2742 UNOPMEM(notmem, 0xF6, 2)
2743 UNOPMEM(negmem, 0xF6, 3)
2744 UNOPMEM(incmem, 0xFE, 0)
2745 UNOPMEM(decmem, 0xFE, 1)
2747 static void bemit_ldtls(const ir_node *node)
2749 const arch_register_t *out = arch_get_irn_register_out(node, 0);
2751 bemit8(0x65); // gs:
2752 if (out->index == REG_GP_EAX) {
2753 bemit8(0xA1); // movl 0, %eax
2755 bemit8(0x8B); // movl 0, %reg
2756 bemit8(MOD_IND | ENC_REG(reg_gp_map[out->index]) | ENC_RM(0x05));
2764 static void bemit_lea(const ir_node *node)
2766 const arch_register_t *out = arch_get_irn_register_out(node, 0);
2768 bemit_mod_am(reg_gp_map[out->index], node);
2771 /* helper function for bemit_minus64bit */
2772 static void bemit_helper_mov(const arch_register_t *src, const arch_register_t *dst)
2774 bemit8(0x8B); // movl %src, %dst
2775 bemit_modrr(src, dst);
2778 /* helper function for bemit_minus64bit */
2779 static void bemit_helper_neg(const arch_register_t *reg)
2781 bemit8(0xF7); // negl %reg
2782 bemit_modru(reg, 3);
2785 /* helper function for bemit_minus64bit */
2786 static void bemit_helper_sbb0(const arch_register_t *reg)
2788 bemit8(0x83); // sbbl $0, %reg
2789 bemit_modru(reg, 3);
2793 /* helper function for bemit_minus64bit */
2794 static void bemit_helper_sbb(const arch_register_t *src, const arch_register_t *dst)
2796 bemit8(0x1B); // sbbl %src, %dst
2797 bemit_modrr(src, dst);
2800 /* helper function for bemit_minus64bit */
2801 static void bemit_helper_xchg(const arch_register_t *src, const arch_register_t *dst)
2803 if (src->index == REG_GP_EAX) {
2804 bemit8(0x90 + reg_gp_map[dst->index]); // xchgl %eax, %dst
2805 } else if (dst->index == REG_GP_EAX) {
2806 bemit8(0x90 + reg_gp_map[src->index]); // xchgl %src, %eax
2808 bemit8(0x87); // xchgl %src, %dst
2809 bemit_modrr(src, dst);
2813 /* helper function for bemit_minus64bit */
2814 static void bemit_helper_zero(const arch_register_t *reg)
2816 bemit8(0x33); // xorl %reg, %reg
2817 bemit_modrr(reg, reg);
2820 static void bemit_minus64bit(const ir_node *node)
2822 const arch_register_t *in_lo = arch_get_irn_register_in(node, 0);
2823 const arch_register_t *in_hi = arch_get_irn_register_in(node, 1);
2824 const arch_register_t *out_lo = arch_get_irn_register_out(node, 0);
2825 const arch_register_t *out_hi = arch_get_irn_register_out(node, 1);
2827 if (out_lo == in_lo) {
2828 if (out_hi != in_hi) {
2829 /* a -> a, b -> d */
2832 /* a -> a, b -> b */
2835 } else if (out_lo == in_hi) {
2836 if (out_hi == in_lo) {
2837 /* a -> b, b -> a */
2838 bemit_helper_xchg(in_lo, in_hi);
2841 /* a -> b, b -> d */
2842 bemit_helper_mov(in_hi, out_hi);
2843 bemit_helper_mov(in_lo, out_lo);
2847 if (out_hi == in_lo) {
2848 /* a -> c, b -> a */
2849 bemit_helper_mov(in_lo, out_lo);
2851 } else if (out_hi == in_hi) {
2852 /* a -> c, b -> b */
2853 bemit_helper_mov(in_lo, out_lo);
2856 /* a -> c, b -> d */
2857 bemit_helper_mov(in_lo, out_lo);
2863 bemit_helper_neg( out_hi);
2864 bemit_helper_neg( out_lo);
2865 bemit_helper_sbb0(out_hi);
2869 bemit_helper_zero(out_hi);
2870 bemit_helper_neg( out_lo);
2871 bemit_helper_sbb( in_hi, out_hi);
2875 * Emit a single opcode.
2877 #define EMIT_SINGLEOP(op, code) \
2878 static void bemit_ ## op(const ir_node *node) { \
2883 //EMIT_SINGLEOP(daa, 0x27)
2884 //EMIT_SINGLEOP(das, 0x2F)
2885 //EMIT_SINGLEOP(aaa, 0x37)
2886 //EMIT_SINGLEOP(aas, 0x3F)
2887 //EMIT_SINGLEOP(nop, 0x90)
2888 EMIT_SINGLEOP(cwtl, 0x98)
2889 EMIT_SINGLEOP(cltd, 0x99)
2890 //EMIT_SINGLEOP(fwait, 0x9B)
2891 EMIT_SINGLEOP(sahf, 0x9E)
2892 //EMIT_SINGLEOP(popf, 0x9D)
2893 EMIT_SINGLEOP(leave, 0xC9)
2894 EMIT_SINGLEOP(int3, 0xCC)
2895 //EMIT_SINGLEOP(iret, 0xCF)
2896 //EMIT_SINGLEOP(xlat, 0xD7)
2897 //EMIT_SINGLEOP(lock, 0xF0)
2898 EMIT_SINGLEOP(rep, 0xF3)
2899 //EMIT_SINGLEOP(halt, 0xF4)
2900 EMIT_SINGLEOP(cmc, 0xF5)
2901 EMIT_SINGLEOP(stc, 0xF9)
2902 //EMIT_SINGLEOP(cli, 0xFA)
2903 //EMIT_SINGLEOP(sti, 0xFB)
2904 //EMIT_SINGLEOP(std, 0xFD)
2907 * Emits a MOV out, [MEM].
2909 static void bemit_load(const ir_node *node)
2911 const arch_register_t *out = arch_get_irn_register_out(node, 0);
2913 if (out->index == REG_GP_EAX) {
2914 ir_node *base = get_irn_n(node, n_ia32_base);
2915 int has_base = !is_ia32_NoReg_GP(base);
2916 ir_node *idx = get_irn_n(node, n_ia32_index);
2917 int has_index = !is_ia32_NoReg_GP(idx);
2918 if (!has_base && !has_index) {
2919 ir_entity *ent = get_ia32_am_sc(node);
2920 int offs = get_ia32_am_offs_int(node);
2921 /* load from constant address to EAX can be encoded
2924 bemit_entity(ent, 0, offs, false);
2929 bemit_mod_am(reg_gp_map[out->index], node);
2933 * Emits a MOV [mem], in.
2935 static void bemit_store(const ir_node *node)
2937 const ir_node *value = get_irn_n(node, n_ia32_Store_val);
2938 unsigned size = get_mode_size_bits(get_ia32_ls_mode(node));
2940 if (is_ia32_Immediate(value)) {
2943 bemit_mod_am(0, node);
2944 bemit8(get_ia32_immediate_attr_const(value)->offset);
2945 } else if (size == 16) {
2948 bemit_mod_am(0, node);
2949 bemit16(get_ia32_immediate_attr_const(value)->offset);
2952 bemit_mod_am(0, node);
2953 bemit_immediate(value, false);
2956 const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_Store_val);
2958 if (in->index == REG_GP_EAX) {
2959 ir_node *base = get_irn_n(node, n_ia32_base);
2960 int has_base = !is_ia32_NoReg_GP(base);
2961 ir_node *idx = get_irn_n(node, n_ia32_index);
2962 int has_index = !is_ia32_NoReg_GP(idx);
2963 if (!has_base && !has_index) {
2964 ir_entity *ent = get_ia32_am_sc(node);
2965 int offs = get_ia32_am_offs_int(node);
2966 /* store to constant address from EAX can be encoded as
2967 * 0xA2/0xA3 [offset]*/
2975 bemit_entity(ent, 0, offs, false);
2987 bemit_mod_am(reg_gp_map[in->index], node);
2991 static void bemit_conv_i2i(const ir_node *node)
2996 ir_mode *const smaller_mode = get_ia32_ls_mode(node);
2997 unsigned opcode = 0xB6;
2998 if (mode_is_signed(smaller_mode)) opcode |= 0x08;
2999 if (get_mode_size_bits(smaller_mode) == 16) opcode |= 0x01;
3000 bemit_0f_unop_reg(node, opcode, n_ia32_Conv_I2I_val);
3003 static void bemit_popcnt(ir_node const *const node)
3006 bemit_0f_unop_reg(node, 0xB8, n_ia32_Popcnt_operand);
3012 static void bemit_push(const ir_node *node)
3014 const ir_node *value = get_irn_n(node, n_ia32_Push_val);
3016 if (is_ia32_Immediate(value)) {
3017 const ia32_immediate_attr_t *attr
3018 = get_ia32_immediate_attr_const(value);
3019 unsigned size = get_signed_imm_size(attr->offset);
3025 bemit8((unsigned char)attr->offset);
3030 bemit_immediate(value, false);
3033 } else if (is_ia32_NoReg_GP(value)) {
3035 bemit_mod_am(6, node);
3037 const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_Push_val);
3038 bemit8(0x50 + reg_gp_map[reg->index]);
3045 static void bemit_pop(const ir_node *node)
3047 const arch_register_t *reg = arch_get_irn_register_out(node, pn_ia32_Pop_res);
3048 bemit8(0x58 + reg_gp_map[reg->index]);
3051 static void bemit_popmem(const ir_node *node)
3054 bemit_mod_am(0, node);
3057 static void bemit_call(const ir_node *node)
3059 ir_node *proc = get_irn_n(node, n_ia32_Call_addr);
3061 if (is_ia32_Immediate(proc)) {
3063 bemit_immediate(proc, true);
3065 bemit_unop(node, 0xFF, 2, n_ia32_Call_addr);
3069 static void bemit_jmp(const ir_node *dest_block)
3072 bemit_jmp_destination(dest_block);
3075 static void bemit_jump(const ir_node *node)
3077 if (can_be_fallthrough(node))
3080 bemit_jmp(get_cfop_target_block(node));
3083 static void bemit_jcc(ia32_condition_code_t pnc, const ir_node *dest_block)
3085 unsigned char cc = pnc2cc(pnc);
3088 bemit_jmp_destination(dest_block);
3091 static void bemit_jp(bool odd, const ir_node *dest_block)
3095 bemit_jmp_destination(dest_block);
3098 static void bemit_ia32_jcc(const ir_node *node)
3100 ia32_condition_code_t cc = get_ia32_condcode(node);
3101 const ir_node *proj_true;
3102 const ir_node *proj_false;
3103 const ir_node *dest_true;
3104 const ir_node *dest_false;
3106 cc = determine_final_cc(node, 0, cc);
3108 /* get both Projs */
3109 proj_true = get_proj(node, pn_ia32_Jcc_true);
3110 assert(proj_true && "Jcc without true Proj");
3112 proj_false = get_proj(node, pn_ia32_Jcc_false);
3113 assert(proj_false && "Jcc without false Proj");
3115 if (can_be_fallthrough(proj_true)) {
3116 /* exchange both proj's so the second one can be omitted */
3117 const ir_node *t = proj_true;
3119 proj_true = proj_false;
3121 cc = ia32_negate_condition_code(cc);
3124 dest_true = get_cfop_target_block(proj_true);
3125 dest_false = get_cfop_target_block(proj_false);
3127 if (cc & ia32_cc_float_parity_cases) {
3128 /* Some floating point comparisons require a test of the parity flag,
3129 * which indicates that the result is unordered */
3130 if (cc & ia32_cc_negated) {
3131 bemit_jp(false, dest_true);
3133 /* we need a local label if the false proj is a fallthrough
3134 * as the falseblock might have no label emitted then */
3135 if (can_be_fallthrough(proj_false)) {
3137 bemit8(0x06); // jp + 6
3139 bemit_jp(false, dest_false);
3143 bemit_jcc(cc, dest_true);
3145 /* the second Proj might be a fallthrough */
3146 if (can_be_fallthrough(proj_false)) {
3147 /* it's a fallthrough */
3149 bemit_jmp(dest_false);
3153 static void bemit_switchjmp(const ir_node *node)
3155 ir_entity *jump_table = get_ia32_am_sc(node);
3156 const ir_switch_table *table = get_ia32_switch_table(node);
3158 bemit8(0xFF); // jmp *tbl.label(,%in,4)
3159 bemit_mod_am(0x05, node);
3161 be_emit_jump_table(node, table, jump_table, get_cfop_target_block);
3167 static void bemit_return(const ir_node *node)
3169 unsigned pop = be_Return_get_pop(node);
3170 if (pop > 0 || be_Return_get_emit_pop(node)) {
3172 assert(pop <= 0xffff);
3179 static void bemit_subsp(const ir_node *node)
3181 const arch_register_t *out;
3184 /* mov %esp, %out */
3186 out = arch_get_irn_register_out(node, 1);
3187 bemit8(MOD_REG | ENC_REG(reg_gp_map[out->index]) | ENC_RM(0x04));
3190 static void bemit_incsp(const ir_node *node)
3193 const arch_register_t *reg;
3197 offs = be_get_IncSP_offset(node);
3208 size = get_signed_imm_size(offs);
3209 bemit8(size == 1 ? 0x83 : 0x81);
3211 reg = arch_get_irn_register_out(node, 0);
3212 bemit_modru(reg, ext);
3221 static void bemit_copybi(const ir_node *node)
3223 unsigned size = get_ia32_copyb_size(node);
3225 bemit8(0xA4); // movsb
3228 bemit8(0xA5); // movsw
3232 bemit8(0xA5); // movsl
3236 static void bemit_fbinop(ir_node const *const node, unsigned const op_fwd, unsigned const op_rev)
3238 ia32_x87_attr_t const *const attr = get_ia32_x87_attr_const(node);
3239 unsigned const op = attr->attr.data.ins_permuted ? op_rev : op_fwd;
3240 if (get_ia32_op_type(node) == ia32_Normal) {
3241 assert(!attr->pop || attr->res_in_reg);
3243 unsigned char op0 = 0xD8;
3244 if (attr->res_in_reg) op0 |= 0x04;
3245 if (attr->pop) op0 |= 0x02;
3248 bemit8(MOD_REG | ENC_REG(op) | ENC_RM(attr->reg->index));
3253 unsigned const size = get_mode_size_bits(get_ia32_ls_mode(node));
3254 bemit8(size == 32 ? 0xD8 : 0xDC);
3255 bemit_mod_am(op, node);
3259 static void bemit_fop_reg(ir_node const *const node, unsigned char const op0, unsigned char const op1)
3262 bemit8(op1 + get_ia32_x87_attr_const(node)->reg->index);
3265 static void bemit_fabs(const ir_node *node)
3273 static void bemit_fadd(const ir_node *node)
3275 bemit_fbinop(node, 0, 0);
3278 static void bemit_fchs(const ir_node *node)
3286 static void bemit_fdiv(const ir_node *node)
3288 bemit_fbinop(node, 6, 7);
3291 static void bemit_ffreep(ir_node const *const node)
3293 bemit_fop_reg(node, 0xDF, 0xC0);
3296 static void bemit_fild(const ir_node *node)
3298 switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3300 bemit8(0xDF); // filds
3301 bemit_mod_am(0, node);
3305 bemit8(0xDB); // fildl
3306 bemit_mod_am(0, node);
3310 bemit8(0xDF); // fildll
3311 bemit_mod_am(5, node);
3315 panic("invalid mode size");
3319 static void bemit_fist(const ir_node *node)
3322 unsigned const size = get_mode_size_bits(get_ia32_ls_mode(node));
3324 case 16: bemit8(0xDF); op = 2; break; // fist[p]s
3325 case 32: bemit8(0xDB); op = 2; break; // fist[p]l
3326 case 64: bemit8(0xDF); op = 6; break; // fistpll
3327 default: panic("invalid mode size");
3329 if (get_ia32_x87_attr_const(node)->pop)
3331 // There is only a pop variant for 64 bit integer store.
3332 assert(size < 64 || get_ia32_x87_attr_const(node)->pop);
3333 bemit_mod_am(op, node);
3336 static void bemit_fisttp(ir_node const *const node)
3338 switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3339 case 16: bemit8(0xDF); break; // fisttps
3340 case 32: bemit8(0xDB); break; // fisttpl
3341 case 64: bemit8(0xDD); break; // fisttpll
3342 default: panic("Invalid mode size");
3344 bemit_mod_am(1, node);
3347 static void bemit_fld(const ir_node *node)
3349 switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3351 bemit8(0xD9); // flds
3352 bemit_mod_am(0, node);
3356 bemit8(0xDD); // fldl
3357 bemit_mod_am(0, node);
3362 bemit8(0xDB); // fldt
3363 bemit_mod_am(5, node);
3367 panic("invalid mode size");
3371 static void bemit_fld1(const ir_node *node)
3375 bemit8(0xE8); // fld1
3378 static void bemit_fldcw(const ir_node *node)
3380 bemit8(0xD9); // fldcw
3381 bemit_mod_am(5, node);
3384 static void bemit_fldz(const ir_node *node)
3388 bemit8(0xEE); // fldz
3391 static void bemit_fmul(const ir_node *node)
3393 bemit_fbinop(node, 1, 1);
3396 static void bemit_fpop(const ir_node *node)
3398 bemit_fop_reg(node, 0xDD, 0xD8);
3401 static void bemit_fpush(const ir_node *node)
3403 bemit_fop_reg(node, 0xD9, 0xC0);
3406 static void bemit_fpushcopy(const ir_node *node)
3408 bemit_fop_reg(node, 0xD9, 0xC0);
3411 static void bemit_fst(const ir_node *node)
3414 unsigned const size = get_mode_size_bits(get_ia32_ls_mode(node));
3416 case 32: bemit8(0xD9); op = 2; break; // fst[p]s
3417 case 64: bemit8(0xDD); op = 2; break; // fst[p]l
3419 case 96: bemit8(0xDB); op = 6; break; // fstpt
3420 default: panic("invalid mode size");
3422 if (get_ia32_x87_attr_const(node)->pop)
3424 // There is only a pop variant for long double store.
3425 assert(size < 80 || get_ia32_x87_attr_const(node)->pop);
3426 bemit_mod_am(op, node);
3429 static void bemit_fsub(const ir_node *node)
3431 bemit_fbinop(node, 4, 5);
3434 static void bemit_fnstcw(const ir_node *node)
3436 bemit8(0xD9); // fnstcw
3437 bemit_mod_am(7, node);
3440 static void bemit_fnstsw(void)
3442 bemit8(0xDF); // fnstsw %ax
3446 static void bemit_ftstfnstsw(const ir_node *node)
3450 bemit8(0xD9); // ftst
3455 static void bemit_fucomi(const ir_node *node)
3457 const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3458 bemit8(attr->pop ? 0xDF : 0xDB); // fucom[p]i
3459 bemit8(0xE8 + attr->reg->index);
3462 static void bemit_fucomfnstsw(const ir_node *node)
3464 const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3465 bemit8(0xDD); // fucom[p]
3466 bemit8((attr->pop ? 0xE8 : 0xE0) + attr->reg->index);
3470 static void bemit_fucomppfnstsw(const ir_node *node)
3474 bemit8(0xDA); // fucompp
3479 static void bemit_fxch(const ir_node *node)
3481 bemit_fop_reg(node, 0xD9, 0xC8);
3485 * The type of a emitter function.
3487 typedef void (*emit_func) (const ir_node *);
3490 * Set a node emitter. Make it a bit more type safe.
3492 static void register_emitter(ir_op *op, emit_func func)
3494 op->ops.generic = (op_func) func;
3497 static void ia32_register_binary_emitters(void)
3499 /* first clear the generic function pointer for all ops */
3500 ir_clear_opcodes_generic_func();
3502 /* benode emitter */
3503 register_emitter(op_be_Copy, bemit_copy);
3504 register_emitter(op_be_CopyKeep, bemit_copy);
3505 register_emitter(op_be_IncSP, bemit_incsp);
3506 register_emitter(op_be_Perm, bemit_perm);
3507 register_emitter(op_be_Return, bemit_return);
3508 register_emitter(op_ia32_Adc, bemit_adc);
3509 register_emitter(op_ia32_Add, bemit_add);
3510 register_emitter(op_ia32_AddMem, bemit_addmem);
3511 register_emitter(op_ia32_AddMem8Bit, bemit_addmem8bit);
3512 register_emitter(op_ia32_And, bemit_and);
3513 register_emitter(op_ia32_AndMem, bemit_andmem);
3514 register_emitter(op_ia32_AndMem8Bit, bemit_andmem8bit);
3515 register_emitter(op_ia32_Asm, emit_ia32_Asm); // TODO implement binary emitter
3516 register_emitter(op_ia32_Breakpoint, bemit_int3);
3517 register_emitter(op_ia32_Bsf, bemit_bsf);
3518 register_emitter(op_ia32_Bsr, bemit_bsr);
3519 register_emitter(op_ia32_Bswap, bemit_bswap);
3520 register_emitter(op_ia32_Bt, bemit_bt);
3521 register_emitter(op_ia32_CMovcc, bemit_cmovcc);
3522 register_emitter(op_ia32_Call, bemit_call);
3523 register_emitter(op_ia32_Cltd, bemit_cltd);
3524 register_emitter(op_ia32_Cmc, bemit_cmc);
3525 register_emitter(op_ia32_Cmp, bemit_cmp);
3526 register_emitter(op_ia32_Cmp8Bit, bemit_cmp8bit);
3527 register_emitter(op_ia32_Const, bemit_mov_const);
3528 register_emitter(op_ia32_Conv_I2I, bemit_conv_i2i);
3529 register_emitter(op_ia32_Conv_I2I8Bit, bemit_conv_i2i);
3530 register_emitter(op_ia32_CopyB_i, bemit_copybi);
3531 register_emitter(op_ia32_Cwtl, bemit_cwtl);
3532 register_emitter(op_ia32_Dec, bemit_dec);
3533 register_emitter(op_ia32_DecMem, bemit_decmem);
3534 register_emitter(op_ia32_Div, bemit_div);
3535 register_emitter(op_ia32_FldCW, bemit_fldcw);
3536 register_emitter(op_ia32_FnstCW, bemit_fnstcw);
3537 register_emitter(op_ia32_FtstFnstsw, bemit_ftstfnstsw);
3538 register_emitter(op_ia32_FucomFnstsw, bemit_fucomfnstsw);
3539 register_emitter(op_ia32_Fucomi, bemit_fucomi);
3540 register_emitter(op_ia32_FucomppFnstsw, bemit_fucomppfnstsw);
3541 register_emitter(op_ia32_IDiv, bemit_idiv);
3542 register_emitter(op_ia32_IJmp, bemit_ijmp);
3543 register_emitter(op_ia32_IMul, bemit_imul);
3544 register_emitter(op_ia32_IMul1OP, bemit_imul1op);
3545 register_emitter(op_ia32_Inc, bemit_inc);
3546 register_emitter(op_ia32_IncMem, bemit_incmem);
3547 register_emitter(op_ia32_Jcc, bemit_ia32_jcc);
3548 register_emitter(op_ia32_Jmp, bemit_jump);
3549 register_emitter(op_ia32_LdTls, bemit_ldtls);
3550 register_emitter(op_ia32_Lea, bemit_lea);
3551 register_emitter(op_ia32_Leave, bemit_leave);
3552 register_emitter(op_ia32_Load, bemit_load);
3553 register_emitter(op_ia32_Minus64Bit, bemit_minus64bit);
3554 register_emitter(op_ia32_Mul, bemit_mul);
3555 register_emitter(op_ia32_Neg, bemit_neg);
3556 register_emitter(op_ia32_NegMem, bemit_negmem);
3557 register_emitter(op_ia32_Not, bemit_not);
3558 register_emitter(op_ia32_NotMem, bemit_notmem);
3559 register_emitter(op_ia32_Or, bemit_or);
3560 register_emitter(op_ia32_OrMem, bemit_ormem);
3561 register_emitter(op_ia32_OrMem8Bit, bemit_ormem8bit);
3562 register_emitter(op_ia32_Pop, bemit_pop);
3563 register_emitter(op_ia32_PopEbp, bemit_pop);
3564 register_emitter(op_ia32_PopMem, bemit_popmem);
3565 register_emitter(op_ia32_Popcnt, bemit_popcnt);
3566 register_emitter(op_ia32_Push, bemit_push);
3567 register_emitter(op_ia32_RepPrefix, bemit_rep);
3568 register_emitter(op_ia32_Rol, bemit_rol);
3569 register_emitter(op_ia32_RolMem, bemit_rolmem);
3570 register_emitter(op_ia32_Ror, bemit_ror);
3571 register_emitter(op_ia32_RorMem, bemit_rormem);
3572 register_emitter(op_ia32_Sahf, bemit_sahf);
3573 register_emitter(op_ia32_Sar, bemit_sar);
3574 register_emitter(op_ia32_SarMem, bemit_sarmem);
3575 register_emitter(op_ia32_Sbb, bemit_sbb);
3576 register_emitter(op_ia32_Sbb0, bemit_sbb0);
3577 register_emitter(op_ia32_Setcc, bemit_setcc);
3578 register_emitter(op_ia32_Shl, bemit_shl);
3579 register_emitter(op_ia32_ShlD, bemit_shld);
3580 register_emitter(op_ia32_ShlMem, bemit_shlmem);
3581 register_emitter(op_ia32_Shr, bemit_shr);
3582 register_emitter(op_ia32_ShrD, bemit_shrd);
3583 register_emitter(op_ia32_ShrMem, bemit_shrmem);
3584 register_emitter(op_ia32_Stc, bemit_stc);
3585 register_emitter(op_ia32_Store, bemit_store);
3586 register_emitter(op_ia32_Store8Bit, bemit_store);
3587 register_emitter(op_ia32_Sub, bemit_sub);
3588 register_emitter(op_ia32_SubMem, bemit_submem);
3589 register_emitter(op_ia32_SubMem8Bit, bemit_submem8bit);
3590 register_emitter(op_ia32_SubSP, bemit_subsp);
3591 register_emitter(op_ia32_SwitchJmp, bemit_switchjmp);
3592 register_emitter(op_ia32_Test, bemit_test);
3593 register_emitter(op_ia32_Test8Bit, bemit_test8bit);
3594 register_emitter(op_ia32_Xor, bemit_xor);
3595 register_emitter(op_ia32_Xor0, bemit_xor0);
3596 register_emitter(op_ia32_XorMem, bemit_xormem);
3597 register_emitter(op_ia32_XorMem8Bit, bemit_xormem8bit);
3598 register_emitter(op_ia32_fabs, bemit_fabs);
3599 register_emitter(op_ia32_fadd, bemit_fadd);
3600 register_emitter(op_ia32_fchs, bemit_fchs);
3601 register_emitter(op_ia32_fdiv, bemit_fdiv);
3602 register_emitter(op_ia32_ffreep, bemit_ffreep);
3603 register_emitter(op_ia32_fild, bemit_fild);
3604 register_emitter(op_ia32_fist, bemit_fist);
3605 register_emitter(op_ia32_fisttp, bemit_fisttp);
3606 register_emitter(op_ia32_fld, bemit_fld);
3607 register_emitter(op_ia32_fld1, bemit_fld1);
3608 register_emitter(op_ia32_fldz, bemit_fldz);
3609 register_emitter(op_ia32_fmul, bemit_fmul);
3610 register_emitter(op_ia32_fpop, bemit_fpop);
3611 register_emitter(op_ia32_fpush, bemit_fpush);
3612 register_emitter(op_ia32_fpushCopy, bemit_fpushcopy);
3613 register_emitter(op_ia32_fst, bemit_fst);
3614 register_emitter(op_ia32_fsub, bemit_fsub);
3615 register_emitter(op_ia32_fxch, bemit_fxch);
3617 /* ignore the following nodes */
3618 register_emitter(op_ia32_ProduceVal, emit_Nothing);
3619 register_emitter(op_ia32_Unknown, emit_Nothing);
3620 register_emitter(op_be_Keep, emit_Nothing);
3621 register_emitter(op_be_Start, emit_Nothing);
3622 register_emitter(op_Phi, emit_Nothing);
3623 register_emitter(op_Start, emit_Nothing);
3626 static void gen_binary_block(ir_node *block)
3628 ia32_emit_block_header(block);
3630 /* emit the contents of the block */
3631 sched_foreach(block, node) {
3632 ia32_emit_node(node);
3636 void ia32_gen_binary_routine(ir_graph *irg)
3638 ir_entity *entity = get_irg_entity(irg);
3639 const arch_env_t *arch_env = be_get_irg_arch_env(irg);
3640 ia32_irg_data_t *irg_data = ia32_get_irg_data(irg);
3641 ir_node **blk_sched = irg_data->blk_sched;
3643 parameter_dbg_info_t *infos;
3645 isa = (ia32_isa_t*) arch_env;
3647 ia32_register_binary_emitters();
3649 infos = construct_parameter_infos(irg);
3650 be_gas_emit_function_prolog(entity, ia32_cg_config.function_alignment,
3654 /* we use links to point to target blocks */
3655 ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
3656 irg_block_walk_graph(irg, ia32_gen_labels, NULL, NULL);
3658 /* initialize next block links */
3659 n = ARR_LEN(blk_sched);
3660 for (i = 0; i < n; ++i) {
3661 ir_node *block = blk_sched[i];
3662 ir_node *prev = i > 0 ? blk_sched[i-1] : NULL;
3664 set_irn_link(block, prev);
3667 for (i = 0; i < n; ++i) {
3668 ir_node *block = blk_sched[i];
3669 gen_binary_block(block);
3672 be_gas_emit_function_epilog(entity);
3674 ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
3678 void ia32_init_emitter(void)
3680 lc_opt_entry_t *be_grp;
3681 lc_opt_entry_t *ia32_grp;
3683 be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");
3684 ia32_grp = lc_opt_get_grp(be_grp, "ia32");
3686 lc_opt_add_table(ia32_grp, ia32_emitter_options);
3690 FIRM_DBG_REGISTER(dbg, "firm.be.ia32.emitter");