nsz Git - libfirm/blob - ir/be/sparc/sparc_new_nodes.c

   1 /*
   2  * This file is part of libFirm.
   3  * Copyright (C) 2012 University of Karlsruhe.
   4  */
   5
   6 /**
   7  * @file
   8  * @brief   This file implements the creation of the achitecture specific firm
   9  *          opcodes and the coresponding node constructors for the sparc
  10  *          assembler irg.
  11  * @author  Hannes Rapp, Matthias Braun
  12  */
  13 #include "config.h"
  14
  15 #include <stdlib.h>
  16
  17 #include "irprog_t.h"
  18 #include "irgraph_t.h"
  19 #include "irnode_t.h"
  20 #include "irmode_t.h"
  21 #include "ircons_t.h"
  22 #include "iropt_t.h"
  23 #include "irop.h"
  24 #include "irprintf.h"
  25 #include "xmalloc.h"
  26
  27 #include "bearch.h"
  28 #include "bearch_sparc_t.h"
  29
  30 #include "sparc_nodes_attr.h"
  31 #include "sparc_new_nodes.h"
  32 #include "gen_sparc_regalloc_if.h"
  33
  34 bool sparc_has_load_store_attr(const ir_node *node)
  35 {
  36         return is_sparc_Ld(node) || is_sparc_St(node) || is_sparc_Ldf(node)
  37             || is_sparc_Stf(node);
  38 }
  39
  40 static bool has_jmp_cond_attr(const ir_node *node)
  41 {
  42         return is_sparc_Bicc(node) || is_sparc_fbfcc(node);
  43 }
  44
  45 static bool has_switch_jmp_attr(const ir_node *node)
  46 {
  47         return is_sparc_SwitchJmp(node);
  48 }
  49
  50 static bool has_fp_attr(const ir_node *node)
  51 {
  52         return is_sparc_fadd(node) || is_sparc_fsub(node)
  53             || is_sparc_fmul(node) || is_sparc_fdiv(node)
  54             || is_sparc_fftoi(node) || is_sparc_fitof(node)
  55             || is_sparc_fneg(node) || is_sparc_fcmp(node);
  56 }
  57
  58 static bool has_fp_conv_attr(const ir_node *node)
  59 {
  60         return is_sparc_fftof(node);
  61 }
  62
  63 /**
  64  * Dumper interface for dumping sparc nodes in vcg.
  65  * @param F        the output file
  66  * @param n        the node to dump
  67  * @param reason   indicates which kind of information should be dumped
  68  */
  69 static void sparc_dump_node(FILE *F, const ir_node *n, dump_reason_t reason)
  70 {
  71         const sparc_attr_t *sparc_attr;
  72
  73         switch (reason) {
  74         case dump_node_opcode_txt:
  75                 fprintf(F, "%s", get_irn_opname(n));
  76                 break;
  77
  78         case dump_node_mode_txt:
  79                 break;
  80
  81         case dump_node_info_txt:
  82                 arch_dump_reqs_and_registers(F, n);
  83                 sparc_attr = get_sparc_attr_const(n);
  84                 if (sparc_attr->immediate_value_entity) {
  85                         ir_fprintf(F, "entity: %+F (offset %d)\n",
  86                                    sparc_attr->immediate_value_entity,
  87                                    sparc_attr->immediate_value);
  88                 } else {
  89                         ir_fprintf(F, "immediate value: %d\n", sparc_attr->immediate_value);
  90                 }
  91                 if (sparc_has_load_store_attr(n)) {
  92                         const sparc_load_store_attr_t *attr = get_sparc_load_store_attr_const(n);
  93                         ir_fprintf(F, "load store mode: %+F\n", attr->load_store_mode);
  94                         fprintf(F, "is frame entity: %s\n",
  95                                 attr->is_frame_entity ? "true" : "false");
  96                 }
  97                 if (has_jmp_cond_attr(n)) {
  98                         const sparc_jmp_cond_attr_t *attr
  99                                 = get_sparc_jmp_cond_attr_const(n);
 100                         fprintf(F, "relation: %d (%s)\n", (int)attr->relation,
 101                                 get_relation_string(attr->relation));
 102                         fprintf(F, "unsigned: %s\n", attr->is_unsigned ? "true" : "false");
 103                 }
 104                 if (has_fp_attr(n)) {
 105                         const sparc_fp_attr_t *attr = get_sparc_fp_attr_const(n);
 106                         ir_fprintf(F, "fp_mode: %+F\n", attr->fp_mode);
 107                 }
 108                 if (has_fp_conv_attr(n)) {
 109                         const sparc_fp_conv_attr_t *attr = get_sparc_fp_conv_attr_const(n);
 110                         ir_fprintf(F, "conv from: %+F\n", attr->src_mode);
 111                         ir_fprintf(F, "conv to: %+F\n", attr->dest_mode);
 112                 }
 113                 break;
 114
 115         case dump_node_nodeattr_txt:
 116                 break;
 117         }
 118 }
 119
 120 static void sparc_set_attr_imm(ir_node *res, ir_entity *entity,
 121                                int32_t immediate_value)
 122 {
 123         sparc_attr_t *attr           = (sparc_attr_t*)get_irn_generic_attr(res);
 124         attr->immediate_value_entity = entity;
 125         attr->immediate_value        = immediate_value;
 126         arch_add_irn_flags(res, (arch_irn_flags_t)sparc_arch_irn_flag_immediate_form);
 127 }
 128
 129 static void init_sparc_jmp_cond_attr(ir_node *node, ir_relation relation,
 130                                      bool is_unsigned)
 131 {
 132         sparc_jmp_cond_attr_t *attr = get_sparc_jmp_cond_attr(node);
 133         attr->relation    = relation;
 134         attr->is_unsigned = is_unsigned;
 135 }
 136
 137 sparc_attr_t *get_sparc_attr(ir_node *node)
 138 {
 139         assert(is_sparc_irn(node));
 140         return (sparc_attr_t*) get_irn_generic_attr(node);
 141 }
 142
 143 const sparc_attr_t *get_sparc_attr_const(const ir_node *node)
 144 {
 145         assert(is_sparc_irn(node));
 146         return (const sparc_attr_t*) get_irn_generic_attr_const(node);
 147 }
 148
 149 sparc_load_store_attr_t *get_sparc_load_store_attr(ir_node *node)
 150 {
 151         assert(sparc_has_load_store_attr(node));
 152         return (sparc_load_store_attr_t*) get_irn_generic_attr_const(node);
 153 }
 154
 155 const sparc_load_store_attr_t *get_sparc_load_store_attr_const(const ir_node *node)
 156 {
 157         assert(sparc_has_load_store_attr(node));
 158         return (const sparc_load_store_attr_t*) get_irn_generic_attr_const(node);
 159 }
 160
 161 sparc_jmp_cond_attr_t *get_sparc_jmp_cond_attr(ir_node *node)
 162 {
 163         assert(has_jmp_cond_attr(node));
 164         return (sparc_jmp_cond_attr_t*) get_irn_generic_attr_const(node);
 165 }
 166
 167 const sparc_jmp_cond_attr_t *get_sparc_jmp_cond_attr_const(const ir_node *node)
 168 {
 169         assert(has_jmp_cond_attr(node));
 170         return (const sparc_jmp_cond_attr_t*) get_irn_generic_attr_const(node);
 171 }
 172
 173 sparc_switch_jmp_attr_t *get_sparc_switch_jmp_attr(ir_node *node)
 174 {
 175         assert(has_switch_jmp_attr(node));
 176         return (sparc_switch_jmp_attr_t*) get_irn_generic_attr_const(node);
 177 }
 178
 179 const sparc_switch_jmp_attr_t *get_sparc_switch_jmp_attr_const(const ir_node *node)
 180 {
 181         assert(has_switch_jmp_attr(node));
 182         return (const sparc_switch_jmp_attr_t*) get_irn_generic_attr_const(node);
 183 }
 184
 185 sparc_fp_attr_t *get_sparc_fp_attr(ir_node *node)
 186 {
 187         assert(has_fp_attr(node));
 188         return (sparc_fp_attr_t*) get_irn_generic_attr(node);
 189 }
 190
 191 const sparc_fp_attr_t *get_sparc_fp_attr_const(const ir_node *node)
 192 {
 193         assert(has_fp_attr(node));
 194         return (const sparc_fp_attr_t*) get_irn_generic_attr_const(node);
 195 }
 196
 197 sparc_fp_conv_attr_t *get_sparc_fp_conv_attr(ir_node *node)
 198 {
 199         assert(has_fp_conv_attr(node));
 200         return (sparc_fp_conv_attr_t*) get_irn_generic_attr(node);
 201 }
 202
 203 const sparc_fp_conv_attr_t *get_sparc_fp_conv_attr_const(const ir_node *node)
 204 {
 205         assert(has_fp_conv_attr(node));
 206         return (const sparc_fp_conv_attr_t*) get_irn_generic_attr_const(node);
 207 }
 208
 209 /**
 210  * Initializes the nodes attributes.
 211  */
 212 static void init_sparc_attributes(ir_node *node, arch_irn_flags_t flags,
 213                                   const arch_register_req_t **in_reqs,
 214                                   int n_res)
 215 {
 216         ir_graph        *irg  = get_irn_irg(node);
 217         struct obstack  *obst = get_irg_obstack(irg);
 218         backend_info_t  *info;
 219
 220         arch_set_irn_flags(node, flags);
 221         arch_set_irn_register_reqs_in(node, in_reqs);
 222
 223         info            = be_get_info(node);
 224         info->out_infos = NEW_ARR_DZ(reg_out_info_t, obst, n_res);
 225 }
 226
 227 static void init_sparc_load_store_attributes(ir_node *res, ir_mode *ls_mode,
 228                                                                                         ir_entity *entity, int32_t offset,
 229                                                                                         bool is_frame_entity,
 230                                                                                         bool is_reg_reg)
 231 {
 232         sparc_load_store_attr_t *attr     = get_sparc_load_store_attr(res);
 233         attr->base.immediate_value_entity = entity;
 234         attr->base.immediate_value        = offset;
 235         attr->load_store_mode             = ls_mode;
 236         attr->is_frame_entity             = is_frame_entity;
 237         attr->is_reg_reg                  = is_reg_reg;
 238 }
 239
 240 static void init_sparc_fp_attributes(ir_node *res, ir_mode *fp_mode)
 241 {
 242         sparc_fp_attr_t *attr = get_sparc_fp_attr(res);
 243         attr->fp_mode = fp_mode;
 244 }
 245
 246 static void init_sparc_fp_conv_attributes(ir_node *res, ir_mode *src_mode,
 247                                           ir_mode *dest_mode)
 248 {
 249         sparc_fp_conv_attr_t *attr = get_sparc_fp_conv_attr(res);
 250         attr->src_mode = src_mode;
 251         attr->dest_mode = dest_mode;
 252 }
 253
 254 static void init_sparc_switch_jmp_attributes(ir_node *node,
 255                                              const ir_switch_table *table,
 256                                              ir_entity *table_entity)
 257 {
 258         sparc_switch_jmp_attr_t *attr = get_sparc_switch_jmp_attr(node);
 259         attr->table        = table;
 260         attr->table_entity = table_entity;
 261
 262         be_foreach_out(node, o) {
 263                 arch_set_irn_register_req_out(node, o, arch_no_register_req);
 264         }
 265 }
 266
 267 /**
 268  * copies sparc attributes of  node
 269  */
 270 static void sparc_copy_attr(ir_graph *irg, const ir_node *old_node,
 271                             ir_node *new_node)
 272 {
 273         struct obstack     *obst    = get_irg_obstack(irg);
 274         const sparc_attr_t *attr_old = get_sparc_attr_const(old_node);
 275         sparc_attr_t       *attr_new = get_sparc_attr(new_node);
 276         backend_info_t     *old_info = be_get_info(old_node);
 277         backend_info_t     *new_info = be_get_info(new_node);
 278
 279         /* copy the attributes */
 280         memcpy(attr_new, attr_old, get_op_attr_size(get_irn_op(old_node)));
 281         /* copy out flags */
 282         new_info->flags = old_info->flags;
 283         new_info->out_infos =
 284                 DUP_ARR_D(reg_out_info_t, obst, old_info->out_infos);
 285         new_info->in_reqs = old_info->in_reqs;
 286 }
 287
 288 /**
 289  * compare some node's attributes
 290  */
 291 static int cmp_attr_sparc(const ir_node *a, const ir_node *b)
 292 {
 293         const sparc_attr_t *attr_a = get_sparc_attr_const(a);
 294         const sparc_attr_t *attr_b = get_sparc_attr_const(b);
 295
 296         return attr_a->immediate_value != attr_b->immediate_value
 297                 || attr_a->immediate_value_entity != attr_b->immediate_value_entity;
 298 }
 299
 300 static int cmp_attr_sparc_load_store(const ir_node *a, const ir_node *b)
 301 {
 302         const sparc_load_store_attr_t *attr_a = get_sparc_load_store_attr_const(a);
 303         const sparc_load_store_attr_t *attr_b = get_sparc_load_store_attr_const(b);
 304
 305         if (cmp_attr_sparc(a, b))
 306                 return 1;
 307
 308         return attr_a->is_frame_entity != attr_b->is_frame_entity
 309                         || attr_a->load_store_mode != attr_b->load_store_mode;
 310 }
 311
 312 static int cmp_attr_sparc_jmp_cond(const ir_node *a, const ir_node *b)
 313 {
 314         const sparc_jmp_cond_attr_t *attr_a = get_sparc_jmp_cond_attr_const(a);
 315         const sparc_jmp_cond_attr_t *attr_b = get_sparc_jmp_cond_attr_const(b);
 316
 317         if (cmp_attr_sparc(a, b))
 318                 return 1;
 319
 320         return attr_a->relation != attr_b->relation
 321             || attr_a->is_unsigned != attr_b->is_unsigned;
 322 }
 323
 324 static int cmp_attr_sparc_fp(const ir_node *a, const ir_node *b)
 325 {
 326         const sparc_fp_attr_t *attr_a = get_sparc_fp_attr_const(a);
 327         const sparc_fp_attr_t *attr_b = get_sparc_fp_attr_const(b);
 328
 329         if (cmp_attr_sparc(a, b))
 330                 return 1;
 331
 332         return attr_a->fp_mode != attr_b->fp_mode;
 333 }
 334
 335 static int cmp_attr_sparc_fp_conv(const ir_node *a, const ir_node *b)
 336 {
 337         const sparc_fp_conv_attr_t *attr_a = get_sparc_fp_conv_attr_const(a);
 338         const sparc_fp_conv_attr_t *attr_b = get_sparc_fp_conv_attr_const(b);
 339
 340         if (cmp_attr_sparc(a, b))
 341                 return 1;
 342
 343         return attr_a->src_mode != attr_b->src_mode
 344             || attr_a->dest_mode != attr_b->dest_mode;
 345 }
 346
 347 /* Include the generated constructor functions */
 348 #include "gen_sparc_new_nodes.c.inl"