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