nsz Git - libfirm/blob - ir/be/arm/arm_optimize.c

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   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.
  10  *
  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.
  14  *
  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
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief       Implements several optimizations for ARM.
  23  * @author      Michael Beck
  24  * @version     $Id: $
  25  */
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #include "irgmod.h"
  31 #include "ircons.h"
  32 #include "error.h"
  33
  34 #include "benode_t.h"
  35 #include "bepeephole.h"
  36 #include "besched.h"
  37
  38 #include "arm_optimize.h"
  39 #include "gen_arm_regalloc_if.h"
  40 #include "gen_arm_new_nodes.h"
  41
  42 static const arch_env_t *arch_env;
  43 static arm_code_gen_t  *cg;
  44
  45 /** Execute ARM ROL. */
  46 static unsigned arm_rol(unsigned v, unsigned rol) {
  47         return (v << rol) | (v >> (32 - rol));
  48 }
  49
  50 /*
  51  * construct 8bit values and rot amounts for a value.
  52  */
  53 void arm_gen_vals_from_word(unsigned int value, arm_vals *result)
  54 {
  55         int initial = 0;
  56
  57         memset(result, 0, sizeof(*result));
  58
  59         /* special case: we prefer shift amount 0 */
  60         if (value < 0x100) {
  61                 result->values[0] = value;
  62                 result->ops       = 1;
  63                 return;
  64         }
  65
  66         while (value != 0) {
  67                 if (value & 0xFF) {
  68                         unsigned v = arm_rol(value, 8) & 0xFFFFFF;
  69                         int shf = 0;
  70                         for (;;) {
  71                                 if ((v & 3) != 0)
  72                                         break;
  73                                 shf += 2;
  74                                 v >>= 2;
  75                         }
  76                         v  &= 0xFF;
  77                         shf = (initial + shf - 8) & 0x1F;
  78                         result->values[result->ops] = v;
  79                         result->shifts[result->ops] = shf;
  80                         ++result->ops;
  81
  82                         value ^= arm_rol(v, shf) >> initial;
  83                 }
  84                 else {
  85                         value >>= 8;
  86                         initial += 8;
  87                 }
  88         }
  89 }
  90
  91 /**
  92  * Encodes an immediate with shifter operand
  93  */
  94 unsigned int arm_encode_imm_w_shift(unsigned int shift, unsigned int immediate) {
  95         return immediate | ((shift>>1)<<8);
  96 }
  97
  98 /**
  99  * Decode an immediate with shifter operand
 100  */
 101 unsigned int arm_decode_imm_w_shift(long imm_value) {
 102         unsigned l = (unsigned)imm_value;
 103         unsigned rol = (l & ~0xFF) >> 7;
 104
 105         return arm_rol(l & 0xFF, rol);
 106 }
 107
 108 /**
 109  * Returns non.zero if the given offset can be directly encoded into an ARM instruction.
 110  */
 111 static int allowed_arm_immediate(int offset, arm_vals *result) {
 112         arm_gen_vals_from_word(offset, result);
 113         return result->ops <= 1;
 114 }
 115
 116 /**
 117  * Fix an IncSP node if the offset gets too big
 118  */
 119 static void peephole_be_IncSP(ir_node *node) {
 120         ir_graph *irg;
 121         ir_node  *block;
 122         int      offset, cnt, align, sign = 1;
 123         arm_vals v;
 124
 125         /* first optimize incsp->incsp combinations */
 126         node = be_peephole_IncSP_IncSP(node);
 127
 128         offset = be_get_IncSP_offset(node);
 129         /* can be transformed into Add OR Sub */
 130         if (offset < 0) {
 131                 sign = -1;
 132                 offset = -offset;
 133         }
 134         if (allowed_arm_immediate(offset, &v))
 135                 return;
 136
 137         be_set_IncSP_offset(node, (int)arm_rol(v.values[0], v.shifts[0]) * sign);
 138
 139         irg   = current_ir_graph;
 140         block = get_nodes_block(node);
 141         align = be_get_IncSP_align(node);
 142         for (cnt = 1; cnt < v.ops; ++cnt) {
 143                 int value = (int)arm_rol(v.values[cnt], v.shifts[cnt]);
 144                 ir_node *next = be_new_IncSP(&arm_gp_regs[REG_SP], irg, block, node, value * sign, align);
 145                 sched_add_after(node, next);
 146                 node = next;
 147         }
 148 }
 149
 150 /**
 151  * creates the address by Adds
 152  */
 153 static ir_node *gen_ptr_add(ir_node *node, ir_node *frame, arm_vals *v)
 154 {
 155         ir_graph *irg   = current_ir_graph;
 156         dbg_info *dbg   = get_irn_dbg_info(node);
 157         ir_node  *block = get_nodes_block(node);
 158         int     cnt;
 159         ir_node *ptr;
 160
 161         ptr = new_rd_arm_Add_i(dbg, irg, block, frame, mode_Iu, arm_encode_imm_w_shift(v->shifts[0], v->values[0]));
 162         arch_set_irn_register(arch_env, ptr, &arm_gp_regs[REG_R12]);
 163         sched_add_before(node, ptr);
 164
 165         for (cnt = 1; cnt < v->ops; ++cnt) {
 166                 long value = arm_encode_imm_w_shift(v->shifts[cnt], v->values[cnt]);
 167                 ir_node *next = new_rd_arm_Add_i(dbg, irg, block, ptr, mode_Iu, value);
 168                 arch_set_irn_register(arch_env, next, &arm_gp_regs[REG_R12]);
 169                 sched_add_before(node, next);
 170                 ptr = next;
 171         }
 172         return ptr;
 173 }
 174
 175 /**
 176 * creates the address by Subs
 177 */
 178 static ir_node *gen_ptr_sub(ir_node *node, ir_node *frame, arm_vals *v)
 179 {
 180         ir_graph *irg   = current_ir_graph;
 181         dbg_info *dbg   = get_irn_dbg_info(node);
 182         ir_node  *block = get_nodes_block(node);
 183         int     cnt;
 184         ir_node *ptr;
 185
 186         ptr = new_rd_arm_Sub_i(dbg, irg, block, frame, mode_Iu, arm_encode_imm_w_shift(v->shifts[0], v->values[0]));
 187         arch_set_irn_register(arch_env, ptr, &arm_gp_regs[REG_R12]);
 188         sched_add_before(node, ptr);
 189
 190         for (cnt = 1; cnt < v->ops; ++cnt) {
 191                 long value = arm_encode_imm_w_shift(v->shifts[cnt], v->values[cnt]);
 192                 ir_node *next = new_rd_arm_Sub_i(dbg, irg, block, ptr, mode_Iu, value);
 193                 arch_set_irn_register(arch_env, next, &arm_gp_regs[REG_R12]);
 194                 sched_add_before(node, next);
 195                 ptr = next;
 196         }
 197         return ptr;
 198 }
 199
 200 /**
 201  * Fix an be_Spill node if the offset gets too big
 202  */
 203 static void peephole_be_Spill(ir_node *node) {
 204         ir_entity *ent   = be_get_frame_entity(node);
 205         int       use_add = 1, offset = get_entity_offset(ent);
 206         ir_node   *block, *ptr, *frame, *value, *store;
 207         ir_mode   *mode;
 208         dbg_info  *dbg;
 209         ir_graph  *irg;
 210         arm_vals  v;
 211
 212         if (allowed_arm_immediate(offset, &v))
 213                 return;
 214         if (offset < 0) {
 215                 use_add = 0;
 216                 offset = -offset;
 217         }
 218
 219         frame = be_get_Spill_frame(node);
 220         if (use_add) {
 221                 ptr = gen_ptr_add(node, frame, &v);
 222         } else {
 223                 ptr = gen_ptr_sub(node, frame, &v);
 224         }
 225
 226         value = be_get_Spill_val(node);
 227         mode  = get_irn_mode(value);
 228         irg   = current_ir_graph;
 229         dbg   = get_irn_dbg_info(node);
 230         block = get_nodes_block(node);
 231
 232         if (mode_is_float(mode)) {
 233                 if (USE_FPA(cg->isa)) {
 234                         /* transform into fpaStf */
 235                         store = new_rd_arm_fpaStf(dbg, irg, block, ptr, value, get_irg_no_mem(irg), mode);
 236                         sched_add_before(node, store);
 237                 } else {
 238                         panic("peephole_be_Spill: spill not supported for this mode");
 239                 }
 240         } else if (mode_is_dataM(mode)) {
 241                  /* transform into Store */;
 242                  store = new_rd_arm_Store(dbg, irg, block, ptr, value, get_irg_no_mem(irg));
 243                  sched_add_before(node, store);
 244         } else {
 245                 panic("peephole_be_Spill: spill not supported for this mode");
 246         }
 247
 248         be_peephole_exchange(node, store);
 249 }
 250
 251 /**
 252  * Fix an be_Reload node if the offset gets too big
 253  */
 254 static void peephole_be_Reload(ir_node *node) {
 255         ir_entity *ent   = be_get_frame_entity(node);
 256         int       use_add = 1, offset = get_entity_offset(ent);
 257         ir_node   *block, *ptr, *frame, *load, *mem, *proj;
 258         ir_mode   *mode;
 259         dbg_info  *dbg;
 260         ir_graph  *irg;
 261         arm_vals  v;
 262         const arch_register_t *reg;
 263
 264         if (allowed_arm_immediate(offset, &v))
 265                 return;
 266         if (offset < 0) {
 267                 use_add = 0;
 268                 offset = -offset;
 269         }
 270
 271         frame = be_get_Reload_frame(node);
 272         if (use_add) {
 273                 ptr = gen_ptr_add(node, frame, &v);
 274         } else {
 275                 ptr = gen_ptr_sub(node, frame, &v);
 276         }
 277
 278         reg   = arch_get_irn_register(arch_env, node);
 279         mem   = be_get_Reload_mem(node);
 280         mode  = get_irn_mode(node);
 281         irg   = current_ir_graph;
 282         dbg   = get_irn_dbg_info(node);
 283         block = get_nodes_block(node);
 284
 285         if (mode_is_float(mode)) {
 286                 if (USE_FPA(cg->isa)) {
 287                         /* transform into fpaLdf */
 288                         load = new_rd_arm_fpaLdf(dbg, irg, block, ptr, mem, mode);
 289                         sched_add_before(node, load);
 290                         proj = new_rd_Proj(dbg, irg, block, load, mode, pn_arm_fpaLdf_res);
 291                         arch_set_irn_register(arch_env, proj, reg);
 292                 } else {
 293                         panic("peephole_be_Spill: spill not supported for this mode");
 294                 }
 295         } else if (mode_is_dataM(mode)) {
 296                 /* transform into Store */;
 297                 load = new_rd_arm_Load(dbg, irg, block, ptr, mem);
 298                 sched_add_before(node, load);
 299                 proj = new_rd_Proj(dbg, irg, block, load, mode_Iu, pn_arm_Load_res);
 300                 arch_set_irn_register(arch_env, proj, reg);
 301         } else {
 302                 panic("peephole_be_Spill: spill not supported for this mode");
 303         }
 304
 305         be_peephole_exchange(node, proj);
 306 }
 307
 308 /**
 309  * Register a peephole optimization function.
 310  */
 311 static void register_peephole_optimisation(ir_op *op, peephole_opt_func func) {
 312         assert(op->ops.generic == NULL);
 313         op->ops.generic = (op_func)func;
 314 }
 315
 316 /* Perform peephole-optimizations. */
 317 void arm_peephole_optimization(arm_code_gen_t *new_cg)
 318 {
 319         cg       = new_cg;
 320         arch_env = cg->arch_env;
 321
 322         /* register peephole optimizations */
 323         clear_irp_opcodes_generic_func();
 324         register_peephole_optimisation(op_be_IncSP, peephole_be_IncSP);
 325         register_peephole_optimisation(op_be_Spill, peephole_be_Spill);
 326         register_peephole_optimisation(op_be_Reload, peephole_be_Reload);
 327
 328         be_peephole_opt(cg->birg);
 329 }