X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fia32%2Fia32_new_nodes.c;h=59caaf074f31b3f36dc9788624cbc17ab67c30a2;hb=88fc027c8f6bbf5f4eaf848463c7afa7d59cd24a;hp=a0f2769aa177dbb0d7d20d10f44ae3679e152bfa;hpb=691de77e1607bb2e860338389466a0f9b7b90b16;p=libfirm diff --git a/ir/be/ia32/ia32_new_nodes.c b/ir/be/ia32/ia32_new_nodes.c index a0f2769aa..59caaf074 100644 --- a/ir/be/ia32/ia32_new_nodes.c +++ b/ir/be/ia32/ia32_new_nodes.c @@ -42,6 +42,8 @@ # define obstack_chunk_free free #endif +extern int obstack_printf(struct obstack *obst, char *fmt, ...); + /*********************************************************************************** * _ _ _ __ * | | (_) | | / _| @@ -53,22 +55,6 @@ * |_| ***********************************************************************************/ -/** - * Prints a tarval to file F. - * @param F output file - * @param tv tarval - * @param brackets 1 == print square brackets around tarval - */ -static void fprintf_tv(FILE *F, tarval *tv, int brackets) { - char buf[1024]; - tarval_snprintf(buf, sizeof(buf), tv); - - if (brackets) - fprintf(F, "[%s]", buf); - else - fprintf(F, "%s", buf); -} - /** * Returns the name of a SymConst. * @param symc the SymConst @@ -150,11 +136,11 @@ static void dump_reg_req(FILE *F, ir_node *n, const ia32_register_req_t **reqs, } if (reqs[i]->req.type & arch_register_req_type_should_be_same) { - ir_fprintf(F, " same as %+F", get_irn_n(n, reqs[i]->pos)); + ir_fprintf(F, " same as %+F", get_irn_n(n, reqs[i]->same_pos)); } if (reqs[i]->req.type & arch_register_req_type_should_be_different) { - ir_fprintf(F, " different from %+F", get_irn_n(n, reqs[i]->pos)); + ir_fprintf(F, " different from %+F", get_irn_n(n, reqs[i]->different_pos)); } fprintf(F, "\n"); @@ -177,8 +163,7 @@ static void dump_reg_req(FILE *F, ir_node *n, const ia32_register_req_t **reqs, static int dump_node_ia32(ir_node *n, FILE *F, dump_reason_t reason) { ir_mode *mode = NULL; int bad = 0; - int i; - ia32_attr_t *attr; + int i, n_res, am_flav, flags; const ia32_register_req_t **reqs; const arch_register_t **slots; @@ -190,26 +175,15 @@ static int dump_node_ia32(ir_node *n, FILE *F, dump_reason_t reason) { case dump_node_mode_txt: mode = get_irn_mode(n); - if (mode == mode_BB || mode == mode_ANY || mode == mode_BAD || mode == mode_T) { - mode = NULL; - } - else if (is_ia32_Load(n)) { - mode = get_irn_mode(get_irn_n(n, 0)); - } - else if (is_ia32_Store(n)) { - mode = get_irn_mode(get_irn_n(n, 2)); + if (is_ia32_Ld(n) || is_ia32_St(n)) { + mode = get_ia32_ls_mode(n); } - if (mode) { - fprintf(F, "[%s]", get_mode_name(mode)); - } + fprintf(F, "[%s]", mode ? get_mode_name(mode) : "?NOMODE?"); break; case dump_node_nodeattr_txt: - if (is_ia32_Call(n)) { - fprintf(F, "&%s ", get_ia32_sc(n)); - } - else if (get_ia32_cnst(n)) { + if (get_ia32_cnst(n)) { char *pref = ""; if (get_ia32_sc(n)) { @@ -219,14 +193,19 @@ static int dump_node_ia32(ir_node *n, FILE *F, dump_reason_t reason) { fprintf(F, "[%s%s]", pref, get_ia32_cnst(n)); } - if (is_ia32_AddrModeS(n) || is_ia32_AddrModeD(n)) { - fprintf(F, "[AM] "); + if (! is_ia32_Lea(n)) { + if (is_ia32_AddrModeS(n)) { + fprintf(F, "[AM S] "); + } + else if (is_ia32_AddrModeD(n)) { + fprintf(F, "[AM D] "); + } } break; case dump_node_info_txt: - attr = get_ia32_attr(n); + n_res = get_ia32_n_res(n); fprintf(F, "=== IA32 attr begin ===\n"); /* dump IN requirements */ @@ -236,28 +215,23 @@ static int dump_node_ia32(ir_node *n, FILE *F, dump_reason_t reason) { } /* dump OUT requirements */ - if (attr->n_res > 0) { + if (n_res > 0) { reqs = get_ia32_out_req_all(n); dump_reg_req(F, n, reqs, 1); } /* dump assigned registers */ slots = get_ia32_slots(n); - if (slots && attr->n_res > 0) { - for (i = 0; i < attr->n_res; i++) { - if (slots[i]) { - fprintf(F, "reg #%d = %s\n", i, slots[i]->name); - } - else { - fprintf(F, "reg #%d = n/a\n", i); - } + if (slots && n_res > 0) { + for (i = 0; i < n_res; i++) { + fprintf(F, "reg #%d = %s\n", i, slots[i] ? slots[i]->name : "n/a"); } + fprintf(F, "\n"); } - fprintf(F, "\n"); /* dump op type */ fprintf(F, "op = "); - switch (attr->tp) { + switch (get_ia32_op_type(n)) { case ia32_Normal: fprintf(F, "Normal"); break; @@ -273,13 +247,16 @@ static int dump_node_ia32(ir_node *n, FILE *F, dump_reason_t reason) { case ia32_AddrModeS: fprintf(F, "AM Source (Load)"); break; + default: + fprintf(F, "unknown (%d)", get_ia32_op_type(n)); + break; } fprintf(F, "\n"); /* dump supported am */ fprintf(F, "AM support = "); - switch (attr->am_support) { + switch (get_ia32_am_support(n)) { case ia32_am_None: fprintf(F, "none"); break; @@ -292,12 +269,37 @@ static int dump_node_ia32(ir_node *n, FILE *F, dump_reason_t reason) { case ia32_am_Full: fprintf(F, "full"); break; + default: + fprintf(F, "unknown (%d)", get_ia32_am_support(n)); + break; } fprintf(F, "\n"); + /* dump am flavour */ + fprintf(F, "AM flavour ="); + am_flav = get_ia32_am_flavour(n); + if (am_flav == ia32_am_N) { + fprintf(F, " none"); + } + else { + if (am_flav & ia32_O) { + fprintf(F, " O"); + } + if (am_flav & ia32_B) { + fprintf(F, " B"); + } + if (am_flav & ia32_I) { + fprintf(F, " I"); + } + if (am_flav & ia32_S) { + fprintf(F, " S"); + } + } + fprintf(F, " (%d)\n", am_flav); + /* dump AM offset */ fprintf(F, "AM offset = "); - if (attr->am_offs) { + if (get_ia32_am_offs(n)) { fprintf(F, "%s", get_ia32_am_offs(n)); } else { @@ -309,23 +311,57 @@ static int dump_node_ia32(ir_node *n, FILE *F, dump_reason_t reason) { fprintf(F, "AM scale = %d\n", get_ia32_am_scale(n)); /* dump pn code */ - fprintf(F, "pn_code = %d\n", get_ia32_pncode(n)); + fprintf(F, "pn_code = %ld\n", get_ia32_pncode(n)); /* dump n_res */ fprintf(F, "n_res = %d\n", get_ia32_n_res(n)); + /* dump use_frame */ + fprintf(F, "use_frame = %d\n", is_ia32_use_frame(n)); + + /* commutative */ + fprintf(F, "commutative = %d\n", is_ia32_commutative(n)); + /* dump flags */ fprintf(F, "flags ="); - if (attr->flags & arch_irn_flags_dont_spill) { - fprintf(F, " unspillable"); + flags = get_ia32_flags(n); + if (flags == arch_irn_flags_none) { + fprintf(F, " none"); + } + else { + if (flags & arch_irn_flags_dont_spill) { + fprintf(F, " unspillable"); + } + if (flags & arch_irn_flags_rematerializable) { + fprintf(F, " remat"); + } + if (flags & arch_irn_flags_ignore) { + fprintf(F, " ignore"); + } + } + fprintf(F, " (%d)\n", flags); + + /* dump frame entity */ + fprintf(F, "frame entity = "); + if (get_ia32_frame_ent(n)) { + ir_fprintf(F, "%+F", get_ia32_frame_ent(n)); + } + else { + fprintf(F, "n/a"); } - if (attr->flags & arch_irn_flags_rematerializable) { - fprintf(F, " remat"); + fprintf(F, "\n"); + +#ifndef NDEBUG + /* dump original ir node name */ + fprintf(F, "orig node = "); + if (get_ia32_orig_node(n)) { + fprintf(F, "%s", get_ia32_orig_node(n)); } - if (attr->flags & arch_irn_flags_ignore) { - fprintf(F, " ignore"); + else { + fprintf(F, "n/a"); } fprintf(F, "\n"); +#endif /* NDEBUG */ fprintf(F, "=== IA32 attr end ===\n"); /* end of: case dump_node_info_txt */ @@ -348,19 +384,23 @@ static int dump_node_ia32(ir_node *n, FILE *F, dump_reason_t reason) { * |___/ ***************************************************************************************************/ - static char *copy_str(char *dst, const char *src) { - dst = xcalloc(1, strlen(src) + 1); - strncpy(dst, src, strlen(src) + 1); + static char *copy_str(const char *src) { + size_t l = strlen(src) + 1; + char *dst = xmalloc(l); + strncpy(dst, src, l); + dst[l - 1] = '\0'; return dst; } static char *set_cnst_from_tv(char *cnst, tarval *tv) { + int l = 64; if (cnst) { free(cnst); } - cnst = xcalloc(1, 64); - assert(tarval_snprintf(cnst, 63, tv)); + cnst = xmalloc(l); + assert(tarval_snprintf(cnst, l, tv)); + cnst[l - 1] = 0; return cnst; } @@ -378,7 +418,7 @@ ia32_attr_t *get_ia32_attr(const ir_node *node) { */ ia32_op_type_t get_ia32_op_type(const ir_node *node) { ia32_attr_t *attr = get_ia32_attr(node); - return attr->tp; + return attr->data.tp; } /** @@ -386,7 +426,7 @@ ia32_op_type_t get_ia32_op_type(const ir_node *node) { */ void set_ia32_op_type(ir_node *node, ia32_op_type_t tp) { ia32_attr_t *attr = get_ia32_attr(node); - attr->tp = tp; + attr->data.tp = tp; } /** @@ -394,7 +434,7 @@ void set_ia32_op_type(ir_node *node, ia32_op_type_t tp) { */ ia32_am_type_t get_ia32_am_support(const ir_node *node) { ia32_attr_t *attr = get_ia32_attr(node); - return attr->am_support; + return attr->data.am_support; } /** @@ -402,15 +442,15 @@ ia32_am_type_t get_ia32_am_support(const ir_node *node) { */ void set_ia32_am_support(ir_node *node, ia32_am_type_t am_tp) { ia32_attr_t *attr = get_ia32_attr(node); - attr->am_support = am_tp; + attr->data.am_support = am_tp; } /** * Gets the addrmode flavour of an ia32 node */ -ia32_am_flavour_t get_ia32_am_support(const ir_node *node) { +ia32_am_flavour_t get_ia32_am_flavour(const ir_node *node) { ia32_attr_t *attr = get_ia32_attr(node); - return attr->am_flavour; + return attr->data.am_flavour; } /** @@ -418,7 +458,7 @@ ia32_am_flavour_t get_ia32_am_support(const ir_node *node) { */ void set_ia32_am_flavour(ir_node *node, ia32_am_flavour_t am_flavour) { ia32_attr_t *attr = get_ia32_attr(node); - attr->am_support = am_flavour; + attr->data.am_flavour = am_flavour; } /** @@ -429,13 +469,17 @@ char *get_ia32_am_offs(const ir_node *node) { char *res = NULL; int size; - size = obstack_object_size(attr->am_offs); - if (size > 0) { - res = xcalloc(1, size + 1); - memcpy(res, obstack_base(attr->am_offs), size); - } + if (! attr->am_offs) { + return NULL; + } - res[size] = '\0'; + size = obstack_object_size(attr->am_offs); + if (size > 0) { + res = xmalloc(size + 2); + res[0] = attr->data.offs_sign ? '-' : '+'; + memcpy(&res[1], obstack_base(attr->am_offs), size); + res[size + 1] = '\0'; + } return res; } @@ -445,15 +489,30 @@ char *get_ia32_am_offs(const ir_node *node) { static void extend_ia32_am_offs(ir_node *node, char *offset, char op) { ia32_attr_t *attr = get_ia32_attr(node); - if (!attr->am_offs) { + if (! offset) + return; + + /* offset could already have an explicit sign */ + /* -> supersede op if necessary */ + if (offset[0] == '-' || offset[0] == '+') { + if (offset[0] == '-') { + op = (op == '-') ? '+' : '-'; + } + + /* skip explicit sign */ + offset++; + } + + if (! attr->am_offs) { /* obstack is not initialized */ attr->am_offs = xcalloc(1, sizeof(*(attr->am_offs))); obstack_init(attr->am_offs); + + attr->data.offs_sign = (op == '-') ? 1 : 0; } else { - /* obstack is initialized -> there is already one offset */ - /* present -> connect the offsets with an add */ - obstack_printf(attr->am_offs, " %c ", op); + /* If obstack is initialized, connect the new offset with op */ + obstack_printf(attr->am_offs, "%c", op); } obstack_printf(attr->am_offs, "%s", offset); @@ -478,15 +537,15 @@ void sub_ia32_am_offs(ir_node *node, char *offset) { */ int get_ia32_am_scale(const ir_node *node) { ia32_attr_t *attr = get_ia32_attr(node); - return attr->am_scale; + return attr->data.am_scale; } /** * Sets the index register scale for addrmode. */ void set_ia32_am_scale(ir_node *node, int scale) { - ia32_attr_t *attr = get_ia32_attr(node); - attr->am_scale = scale; + ia32_attr_t *attr = get_ia32_attr(node); + attr->data.am_scale = scale; } /** @@ -509,30 +568,126 @@ void set_ia32_Immop_tarval(ir_node *node, tarval *tv) { /** * Return the sc attribute. */ -char *get_ia32_sc(const ir_node *node) { - ia32_attr_t *attr = get_ia32_attr(node); - return attr->sc; +const char *get_ia32_sc(const ir_node *node) { + ia32_attr_t *attr = get_ia32_attr(node); + return attr->sc; } /** * Sets the sc attribute. */ -void set_ia32_sc(ir_node *node, char *sc) { - ia32_attr_t *attr = get_ia32_attr(node); - attr->sc = copy_str(attr->sc, sc); +void set_ia32_sc(ir_node *node, const char *sc) { + ia32_attr_t *attr = get_ia32_attr(node); + attr->sc = copy_str(sc); - if (attr->cnst) { - free(attr->cnst); - } - attr->cnst = attr->sc; + if (attr->cnst) { + free(attr->cnst); + } + attr->cnst = attr->sc; } /** * Gets the string representation of the internal const (tv or symconst) */ -char *get_ia32_cnst(ir_node *node) { - ia32_attr_t *attr = get_ia32_attr(node); - return attr->cnst; +char *get_ia32_cnst(const ir_node *node) { + ia32_attr_t *attr = get_ia32_attr(node); + return attr->cnst; +} + +/** + * Sets the uses_frame flag. + */ +void set_ia32_use_frame(ir_node *node) { + ia32_attr_t *attr = get_ia32_attr(node); + attr->data.use_frame = 1; +} + +/** + * Clears the uses_frame flag. + */ +void clear_ia32_use_frame(ir_node *node) { + ia32_attr_t *attr = get_ia32_attr(node); + attr->data.use_frame = 0; +} + +/** + * Gets the uses_frame flag. + */ +int is_ia32_use_frame(const ir_node *node) { + ia32_attr_t *attr = get_ia32_attr(node); + return attr->data.use_frame; +} + +/** + * Sets node to commutative. + */ +void set_ia32_commutative(ir_node *node) { + ia32_attr_t *attr = get_ia32_attr(node); + attr->data.is_commutative = 1; +} + +/** + * Sets node to non-commutative. + */ +void clear_ia32_commutative(ir_node *node) { + ia32_attr_t *attr = get_ia32_attr(node); + attr->data.is_commutative = 0; +} + +/** + * Checks if node is commutative. + */ +int is_ia32_commutative(const ir_node *node) { + ia32_attr_t *attr = get_ia32_attr(node); + return attr->data.is_commutative; +} + +/** + * Gets the mode of the stored/loaded value (only set for Store/Load) + */ +ir_mode *get_ia32_ls_mode(const ir_node *node) { + ia32_attr_t *attr = get_ia32_attr(node); + return attr->ls_mode; +} + +/** + * Sets the mode of the stored/loaded value (only set for Store/Load) + */ +void set_ia32_ls_mode(ir_node *node, ir_mode *mode) { + ia32_attr_t *attr = get_ia32_attr(node); + attr->ls_mode = mode; +} + +/** + * Gets the mode of the result. + */ +ir_mode *get_ia32_res_mode(const ir_node *node) { + ia32_attr_t *attr = get_ia32_attr(node); + return attr->res_mode; +} + +/** + * Sets the mode of the result. + */ +void set_ia32_res_mode(ir_node *node, ir_mode *mode) { + ia32_attr_t *attr = get_ia32_attr(node); + attr->res_mode = mode; +} + +/** + * Gets the frame entity assigned to this node; + */ +entity *get_ia32_frame_ent(const ir_node *node) { + ia32_attr_t *attr = get_ia32_attr(node); + return attr->frame_ent; +} + +/** + * Sets the frame entity for this node; + */ +void set_ia32_frame_ent(ir_node *node, entity *ent) { + ia32_attr_t *attr = get_ia32_attr(node); + attr->frame_ent = ent; } /** @@ -543,6 +698,14 @@ const ia32_register_req_t **get_ia32_in_req_all(const ir_node *node) { return attr->in_req; } +/** + * Sets the argument register requirements of an ia32 node. + */ +void set_ia32_in_req_all(ir_node *node, const ia32_register_req_t **reqs) { + ia32_attr_t *attr = get_ia32_attr(node); + attr->in_req = reqs; +} + /** * Returns the result register requirements of an ia32 node. */ @@ -551,6 +714,14 @@ const ia32_register_req_t **get_ia32_out_req_all(const ir_node *node) { return attr->out_req; } +/** + * Sets the result register requirements of an ia32 node. + */ +void set_ia32_out_req_all(ir_node *node, const ia32_register_req_t **reqs) { + ia32_attr_t *attr = get_ia32_attr(node); + attr->out_req = reqs; +} + /** * Returns the argument register requirement at position pos of an ia32 node. */ @@ -588,15 +759,15 @@ void set_ia32_req_in(ir_node *node, const ia32_register_req_t *req, int pos) { */ arch_irn_flags_t get_ia32_flags(const ir_node *node) { ia32_attr_t *attr = get_ia32_attr(node); - return attr->flags; + return attr->data.flags; } /** * Sets the register flag of an ia32 node. */ -void set_ia32_flags(const ir_node *node, arch_irn_flags_t flags) { +void set_ia32_flags(ir_node *node, arch_irn_flags_t flags) { ia32_attr_t *attr = get_ia32_attr(node); - attr->flags = flags; + attr->data.flags = flags; } /** @@ -607,51 +778,12 @@ const arch_register_t **get_ia32_slots(const ir_node *node) { return attr->slots; } -/** - * Returns the name of the OUT register at position pos. - */ -const char *get_ia32_out_reg_name(const ir_node *node, int pos) { - ia32_attr_t *attr = get_ia32_attr(node); - - assert(is_ia32_irn(node) && "Not an ia32 node."); - assert(pos < attr->n_res && "Invalid OUT position."); - assert(attr->slots[pos] && "No register assigned"); - - return arch_register_get_name(attr->slots[pos]); -} - -/** - * Returns the index of the OUT register at position pos within its register class. - */ -int get_ia32_out_regnr(const ir_node *node, int pos) { - ia32_attr_t *attr = get_ia32_attr(node); - - assert(is_ia32_irn(node) && "Not an ia32 node."); - assert(pos < attr->n_res && "Invalid OUT position."); - assert(attr->slots[pos] && "No register assigned"); - - return arch_register_get_index(attr->slots[pos]); -} - -/** - * Returns the OUT register at position pos. - */ -const arch_register_t *get_ia32_out_reg(const ir_node *node, int pos) { - ia32_attr_t *attr = get_ia32_attr(node); - - assert(is_ia32_irn(node) && "Not an ia32 node."); - assert(pos < attr->n_res && "Invalid OUT position."); - assert(attr->slots[pos] && "No register assigned"); - - return attr->slots[pos]; -} - /** * Sets the number of results. */ void set_ia32_n_res(ir_node *node, int n_res) { ia32_attr_t *attr = get_ia32_attr(node); - attr->n_res = n_res; + attr->data.n_res = n_res; } /** @@ -659,7 +791,7 @@ void set_ia32_n_res(ir_node *node, int n_res) { */ int get_ia32_n_res(const ir_node *node) { ia32_attr_t *attr = get_ia32_attr(node); - return attr->n_res; + return attr->data.n_res; } /** @@ -667,15 +799,15 @@ int get_ia32_n_res(const ir_node *node) { */ ia32_op_flavour_t get_ia32_flavour(const ir_node *node) { ia32_attr_t *attr = get_ia32_attr(node); - return attr->op_flav; + return attr->data.op_flav; } /** * Sets the flavour of an ia32 node to flavour_Div/Mod/DivMod/Mul/Mulh. */ void set_ia32_flavour(ir_node *node, ia32_op_flavour_t op_flav) { - ia32_attr_t *attr = get_ia32_attr(node); - attr->op_flav = op_flav; + ia32_attr_t *attr = get_ia32_attr(node); + attr->data.op_flav = op_flav; } /** @@ -694,6 +826,25 @@ void set_ia32_pncode(ir_node *node, long code) { attr->pn_code = code; } +#ifndef NDEBUG + +/** + * Returns the name of the original ir node. + */ +const char *get_ia32_orig_node(const ir_node *node) { + ia32_attr_t *attr = get_ia32_attr(node); + return attr->orig_node; +} + +/** + * Sets the name of the original ir node. + */ +void set_ia32_orig_node(ir_node *node, const char *name) { + ia32_attr_t *attr = get_ia32_attr(node); + attr->orig_node = name; +} + +#endif /* NDEBUG */ /****************************************************************************************************** * _ _ _ _ __ _ _ @@ -709,12 +860,12 @@ void set_ia32_pncode(ir_node *node, long code) { /** * Gets the type of an ia32_Const. */ -unsigned get_ia32_Const_type(ir_node *node) { +unsigned get_ia32_Const_type(const ir_node *node) { ia32_attr_t *attr = get_ia32_attr(node); - assert((is_ia32_Const(node) || is_ia32_fConst(node)) && "Need ia32_Const to get type"); + assert(is_ia32_Cnst(node) && "Need ia32_Const to get type"); - return attr->tp; + return attr->data.tp; } /** @@ -723,10 +874,10 @@ unsigned get_ia32_Const_type(ir_node *node) { void set_ia32_Const_type(ir_node *node, int type) { ia32_attr_t *attr = get_ia32_attr(node); - assert((is_ia32_Const(node) || is_ia32_fConst(node)) && "Need ia32_Const to set type"); + assert(is_ia32_Cnst(node) && "Need ia32_Const to set type"); assert((type == ia32_Const || type == ia32_SymConst) && "Unsupported ia32_Const type"); - attr->tp = type; + attr->data.tp = type; } /** @@ -736,16 +887,38 @@ void set_ia32_Immop_attr(ir_node *node, ir_node *cnst) { ia32_attr_t *na = get_ia32_attr(node); ia32_attr_t *ca = get_ia32_attr(cnst); - assert((is_ia32_Const(cnst) || is_ia32_fConst(cnst)) && "Need ia32_Const to set Immop attr"); + assert(is_ia32_Cnst(cnst) && "Need ia32_Const to set Immop attr"); - na->tp = ca->tp; na->tv = ca->tv; if (ca->sc) { - na->sc = copy_str(na->sc, ca->sc); + na->sc = copy_str(ca->sc); + na->cnst = na->sc; } else { - na->sc = NULL; + na->cnst = set_cnst_from_tv(na->cnst, na->tv); + na->sc = NULL; + } +} + +/** + * Copy the attributes from Immop to an Immop + */ +void copy_ia32_Immop_attr(ir_node *node, ir_node *src) +{ + ia32_attr_t *na = get_ia32_attr(node); + ia32_attr_t *ca = get_ia32_attr(src); + + assert(get_ia32_cnst(src) != NULL); + na->tv = ca->tv; + + if (ca->sc) { + na->sc = copy_str(ca->sc); + na->cnst = na->sc; + } + else { + na->cnst = set_cnst_from_tv(na->cnst, na->tv); + na->sc = NULL; } } @@ -755,19 +928,19 @@ void set_ia32_Immop_attr(ir_node *node, ir_node *cnst) { void set_ia32_Const_attr(ir_node *ia32_cnst, ir_node *cnst) { ia32_attr_t *attr = get_ia32_attr(ia32_cnst); - assert((is_ia32_Const(ia32_cnst) || is_ia32_fConst(ia32_cnst)) && "Need ia32_Const to set Const attr"); + assert(is_ia32_Cnst(ia32_cnst) && "Need ia32_Const to set Const attr"); switch (get_irn_opcode(cnst)) { case iro_Const: - attr->tp = ia32_Const; - attr->tv = get_Const_tarval(cnst); - attr->cnst = set_cnst_from_tv(attr->cnst, attr->tv); + attr->data.tp = ia32_Const; + attr->tv = get_Const_tarval(cnst); + attr->cnst = set_cnst_from_tv(attr->cnst, attr->tv); break; case iro_SymConst: - attr->tp = ia32_SymConst; - attr->tv = NULL; - attr->sc = copy_str(attr->sc, get_sc_name(cnst)); - attr->cnst = attr->sc; + attr->data.tp = ia32_SymConst; + attr->tv = NULL; + attr->sc = copy_str(get_sc_name(cnst)); + attr->cnst = attr->sc; break; case iro_Unknown: assert(0 && "Unknown Const NYI"); @@ -785,10 +958,10 @@ void set_ia32_AddrMode(ir_node *node, char direction) { switch (direction) { case 'D': - attr->tp = ia32_AddrModeD; + attr->data.tp = ia32_AddrModeD; break; case 'S': - attr->tp = ia32_AddrModeS; + attr->data.tp = ia32_AddrModeS; break; default: assert(0 && "wrong AM type"); @@ -798,20 +971,106 @@ void set_ia32_AddrMode(ir_node *node, char direction) { /** * Returns whether or not the node is an AddrModeS node. */ -int is_ia32_AddrModeS(ir_node *node) { +int is_ia32_AddrModeS(const ir_node *node) { ia32_attr_t *attr = get_ia32_attr(node); - return (attr->tp == ia32_AddrModeS); + return (attr->data.tp == ia32_AddrModeS); } /** * Returns whether or not the node is an AddrModeD node. */ -int is_ia32_AddrModeD(ir_node *node) { +int is_ia32_AddrModeD(const ir_node *node) { ia32_attr_t *attr = get_ia32_attr(node); - return (attr->tp == ia32_AddrModeD); + return (attr->data.tp == ia32_AddrModeD); } +/** + * Checks if node is a Load or fLoad. + */ +int is_ia32_Ld(const ir_node *node) { + return is_ia32_Load(node) || is_ia32_fLoad(node); +} +/** + * Checks if node is a Store or fStore. + */ +int is_ia32_St(const ir_node *node) { + return is_ia32_Store(node) || is_ia32_fStore(node); +} + +/** + * Checks if node is a Const or fConst. + */ +int is_ia32_Cnst(const ir_node *node) { + return is_ia32_Const(node) || is_ia32_fConst(node); +} + +/** + * Returns the name of the OUT register at position pos. + */ +const char *get_ia32_out_reg_name(const ir_node *node, int pos) { + ia32_attr_t *attr = get_ia32_attr(node); + + assert(is_ia32_irn(node) && "Not an ia32 node."); + assert(pos < attr->data.n_res && "Invalid OUT position."); + assert(attr->slots[pos] && "No register assigned"); + + return arch_register_get_name(attr->slots[pos]); +} + +/** + * Returns the index of the OUT register at position pos within its register class. + */ +int get_ia32_out_regnr(const ir_node *node, int pos) { + ia32_attr_t *attr = get_ia32_attr(node); + + assert(is_ia32_irn(node) && "Not an ia32 node."); + assert(pos < attr->data.n_res && "Invalid OUT position."); + assert(attr->slots[pos] && "No register assigned"); + + return arch_register_get_index(attr->slots[pos]); +} + +/** + * Returns the OUT register at position pos. + */ +const arch_register_t *get_ia32_out_reg(const ir_node *node, int pos) { + ia32_attr_t *attr = get_ia32_attr(node); + + assert(is_ia32_irn(node) && "Not an ia32 node."); + assert(pos < attr->data.n_res && "Invalid OUT position."); + assert(attr->slots[pos] && "No register assigned"); + + return attr->slots[pos]; +} + +/** + * Allocates num register slots for node. + */ +void alloc_ia32_reg_slots(ir_node *node, int num) { + ia32_attr_t *attr = get_ia32_attr(node); + + if (num) { + attr->slots = xcalloc(num, sizeof(attr->slots[0])); + } + else { + attr->slots = NULL; + } + + attr->data.n_res = num; +} + +/** + * Initializes the nodes attributes. + */ +void init_ia32_attributes(ir_node *node, arch_irn_flags_t flags, const ia32_register_req_t **in_reqs, + const ia32_register_req_t **out_reqs, int n_res) +{ + set_ia32_flags(node, flags); + set_ia32_in_req_all(node, in_reqs); + set_ia32_out_req_all(node, out_reqs); + alloc_ia32_reg_slots(node, n_res); +} /*************************************************************************************** * _ _ _ @@ -823,5 +1082,17 @@ int is_ia32_AddrModeD(ir_node *node) { * ***************************************************************************************/ +/* default compare operation to compare immediate ops */ +int ia32_compare_immop_attr(ia32_attr_t *a, ia32_attr_t *b) { + if (a->data.tp == b->data.tp) { + if (! (a->cnst && b->cnst)) + return 1; + + return strcmp(a->cnst, b->cnst); + } + + return 1; +} + /* Include the generated constructor functions */ #include "gen_ia32_new_nodes.c.inl"